package de.juplo.httpresources;
   
   import org.junit.jupiter.api.BeforeEach;
   import org.junit.jupiter.api.DisplayName;
   import org.junit.jupiter.api.Test;
   import org.junit.jupiter.api.extension.ExtendWith;
   import org.mockito.Mock;
   import org.mockito.junit.jupiter.MockitoExtension;
   import org.mockito.junit.jupiter.MockitoSettings;
  import org.mockito.quality.Strictness;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.cache.support.NoOpCache;
  import org.springframework.http.HttpHeaders;
  import org.springframework.test.context.junit.jupiter.SpringExtension;
  
  import java.net.URI;
  import java.time.Clock;
  import java.time.ZoneId;
  
  import static de.juplo.httpresources.TestUtil.*;
  import static org.assertj.core.api.Assertions.assertThat;
  import static org.mockito.ArgumentMatchers.any;
  import static org.mockito.ArgumentMatchers.eq;
  import static org.mockito.Mockito.*;
  
  
  @DisplayName(("HttpResource - Not Expired"))
  @ExtendWith({ SpringExtension.class, MockitoExtension.class })
  @MockitoSettings(strictness = Strictness.LENIENT)
  public class HttpResourceNotExpiredTest
  {
    private final static Logger LOG = LoggerFactory.getLogger(HttpResourceNotExpiredTest.class);
  
    @Mock
    HttpResourceFetcher fetcher;
  
    HttpResources resources;
    URI uri;
    HttpResource resource;
  
  
    /************** SETUP */
  
    @BeforeEach
    public void setUp()
    {
      Clock clock = Clock.fixed(NOW.toInstant(), ZoneId.of("GMT"));
      resources = new HttpResources(fetcher, clock);
      uri = URI.create("http://foo/bar");
      resource = new HttpResource(resources, fetcher, clock, uri);
      resource.data = DATA_NOT_EXPIRED;
  
      // Everything is possible, nothing is necessary: Only defines behavior!
  
      HttpHeaders headers = new HttpHeaders();
      headers.setContentType(MIME_TYPE_CONTENT_TYPE_HTML);
  
      when(fetcher.fetch(any(), any())).thenReturn(DATA_NOT_EXPIRED_DUMMY);
    }
  
  
    /*************** Calls, that trigger a fetch */
  
    @Test
    @DisplayName(("call to fetch() triggers fetch"))
    public void test_fetch_TriggersFetch()
    {
      LOG.info("<-- start of test-case");
  
      resource.fetch();
  
      // Do not verify implementation: Only verify necessary outcome!
      verify(fetcher).fetch(eq(uri), any());
    }
  
  
    /*************** Calls, that do not trigger a fetch */
  
    @Test
    @DisplayName(("call to fetched() does not trigger fetch"))
    public void test_fetched_DoesNotTriggerFetch() throws Exception
    {
      LOG.info("<-- start of test-case");
  
      resource.fetched();
  
      // Do not verify implementation: Only verify necessary outcome!
      verify(fetcher, never()).fetch(eq(uri), any());
    }
  
    @Test
    @DisplayName(("call to lastModified() does not trigger fetch"))
    public void test_lastModified_DoesNotTriggerFetch() throws Exception
    {
      LOG.info("<-- start of test-case");
  
      resource.lastModified();
  
     // Do not verify implementation: Only verify necessary outcome!
     verify(fetcher, never()).fetch(eq(uri), any());
   }
 
   @Test
   @DisplayName(("call to isModified() does not trigger fetch"))
   public void test_isModified_DoesNotTriggerFetch() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     resource.isModified();
 
     // Do not verify implementation: Only verify necessary outcome!
     verify(fetcher, never()).fetch(eq(uri), any());
   }
 
   @Test
   @DisplayName(("call to getInputStream() does not trigger fetch"))
   public void test_getInputStream_DoesNotTriggerFetch() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     resource.getInputStream();
 
     // Do not verify implementation: Only verify necessary outcome!
     verify(fetcher, never()).fetch(eq(uri), any());
   }
 
   @Test
   @DisplayName(("call to contentLength() does not trigger fetch"))
   public void test_contentLength_DoesNotTriggerFetch() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     resource.contentLength();
 
     // Do not verify implementation: Only verify necessary outcome!
     verify(fetcher, never()).fetch(eq(uri), any());
   }
 
   @Test
   @DisplayName(("call to expires() does not trigger fetch"))
   public void test_expires_DoesNotTriggerFetch() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     resource.expires();
 
     // Do not verify implementation: Only verify necessary outcome!
     verify(fetcher, never()).fetch(eq(uri), any());
   }
 
   @Test
   @DisplayName(("call to isExpired() does not trigger fetch"))
   public void test_isExpired_DoesNotTriggerFetch() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     resource.isExpired();
 
     // Do not verify implementation: Only verify necessary outcome!
     verify(fetcher, never()).fetch(eq(uri), any());
   }
 
   @Test
   @DisplayName(("call to eTag() does not trigger fetch"))
   public void test_eTag_DoesNotTriggerFetch() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     resource.eTag();
 
     // Do not verify implementation: Only verify necessary outcome!
     verify(fetcher, never()).fetch(eq(uri), any());
   }
 
   @Test
   @DisplayName(("call to contentType() does not trigger fetch"))
   public void test_contentType_DoesNotTriggerFetch() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     resource.contentType();
 
     // Do not verify implementation: Only verify necessary outcome!
     verify(fetcher, never()).fetch(eq(uri), any());
   }
 
 
   /*************** Results for calls, that does never trigger a fetch */
 
   @Test
   @DisplayName(("is fetched"))
   public void test_isNotFetched() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.fetched()).isTrue();
   }
 
   @Test
   @DisplayName(("exists"))
   public void test_exists_IsTrue()
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.exists()).isTrue();
   }
 
   @Test
   @DisplayName(("is readable"))
   public void test_isReadable_IsTrue()
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.isReadable()).isTrue();
   }
 
   @Test
   @DisplayName(("has expected value for last modification"))
   public void test_hasExpectedLastModification() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.lastModified()).isEqualTo(LONG_THEN   );
   }
 
   @Test
   @DisplayName(("is not modified"))
   public void test_isNotModified()
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.isModified()).isFalse();
   }
 
   @Test
   @DisplayName(("has expected content"))
   public void test_hasExpectedContent() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.getInputStream()).hasContent(STR_CONTENT);
   }
 
   @Test
   @DisplayName(("has expected content-length"))
   public void test_hasExpectedContentLength() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.contentLength()).isEqualTo(STR_CONTENT.getBytes().length);
   }
 
   @Test
   @DisplayName(("has expected expiration value"))
   public void test_hasInitialExpirationValue() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.expires()).isEqualTo(DATA_NOT_EXPIRED.expires);
   }
 
   @Test
   @DisplayName(("is not expired"))
   public void test_isNotExpired() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.isExpired()).isFalse();
   }
 
   @Test
   @DisplayName(("has expected eTag"))
   public void test_hasExpectedETag() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.eTag()).isEqualTo(STR_ETAG);
   }
 
   @Test
   @DisplayName(("has expected content-type"))
   public void test_hasExpectedContentType() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.contentType()).isEqualTo(MIME_TYPE_CONTENT_TYPE_HTML);
   }
 
 
   /*************** For results for calls, that does trigger a fetch, see
    *************** - HttpResourceNotExpiredFetchUnodifiedTest
    *************** - HttpResourceNotExpiredFetchModifiedTest
    *************** - HttpResourceNotExpiredFetchVanishedTest
    *************** - HttpResourceNotExpiredFetchServerErrorTest
    ***************/
 }