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.io.FileNotFoundException;
  import java.net.URI;
  import java.time.Clock;
  import java.time.ZoneId;
  
  import static de.juplo.httpresources.HttpData.SERVER_ERROR;
  import static de.juplo.httpresources.TestUtil.*;
  import static org.assertj.core.api.Assertions.assertThat;
  import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
  import static org.mockito.ArgumentMatchers.any;
  import static org.mockito.Mockito.when;
  
  
  @DisplayName(("HttpResource - Not Fetched - First Fetch: Server Error"))
  @ExtendWith({ SpringExtension.class, MockitoExtension.class })
  @MockitoSettings(strictness = Strictness.LENIENT)
  public class HttpResourceNotFetchedFirstFetchServerErrorTest
  {
    private final static Logger LOG = LoggerFactory.getLogger(HttpResourceNotFetchedFirstFetchServerErrorTest.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);
  
      // 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(SERVER_ERROR);
    }
  
  
    /*************** Results for calls, that trigger a fetch */
  
    @Test
    @DisplayName(("fetch() reports modifications"))
    public void test_fetch_ReportsModifications()
    {
      LOG.info("<-- start of test-case");
  
      assertThat(resource.fetch()).isTrue();
    }
  
    @Test
    @DisplayName(("exists() is false"))
    public void test_exists_IsFalse()
    {
      LOG.info("<-- start of test-case");
  
      assertThat(resource.exists()).isFalse();
    }
  
    @Test
    @DisplayName(("isReadable() is false"))
    public void test_isReadable_IsFalse()
    {
      LOG.info("<-- start of test-case");
  
      assertThat(resource.isReadable()).isFalse();
    }
  
    @Test
    @DisplayName(("lastModified() returns the expected time"))
    public void test_lastModified_ReturnsExpectedTime() throws Exception
    {
      LOG.info("<-- start of test-case");
  
      assertThatExceptionOfType(FileNotFoundException.class).isThrownBy(() -> resource.lastModified());
   }
 
   @Test
   @DisplayName(("isModified() if true"))
   public void test_isModified_IsTrue()
   {
     LOG.info("<-- start of test-case");
 
     assertThat(resource.isModified()).isTrue();
   }
 
   @Test
   @DisplayName(("getInputStream() throws FileNotFoundException"))
   public void test_getInputStream_ThrowsFileNotFoundException() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     assertThatExceptionOfType(FileNotFoundException.class).isThrownBy(() -> resource.getInputStream());
   }
 
   @Test
   @DisplayName(("contentLength() throws FileNotFoundException"))
   public void test_contentLength_ThrowsFileNotFoundException() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     assertThatExceptionOfType(FileNotFoundException.class).isThrownBy(() -> resource.contentLength());
   }
 
 
   /*************** Expected state after calls that trigger a fetch */
 
   @Test
   @DisplayName(("call to fetch() updates data"))
   public void test_fetch_UpdatesData()
   {
     LOG.info("<-- start of test-case");
 
     resource.fetch();
 
     assertThat(resource.data).isSameAs(SERVER_ERROR);
   }
 
   @Test
   @DisplayName(("call to exists() updates data"))
   public void test_exists_UpdatesData()
   {
     LOG.info("<-- start of test-case");
 
     resource.exists();
 
     assertThat(resource.data).isSameAs(SERVER_ERROR);
   }
 
   @Test
   @DisplayName(("call to isReadable() updates data"))
   public void test_isReadable_UpdatesData()
   {
     LOG.info("<-- start of test-case");
 
     resource.isReadable();
 
     assertThat(resource.data).isSameAs(SERVER_ERROR);
   }
 
   @Test
   @DisplayName(("call to lastModified() updates data"))
   public void test_lastModified_UpdatesData() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     try
     {
       resource.lastModified();
     }
     catch (FileNotFoundException e) {}
 
     assertThat(resource.data).isSameAs(SERVER_ERROR);
   }
 
   @Test
   @DisplayName(("call to isModified() updates data"))
   public void test_isModified_UpdatesData()
   {
     LOG.info("<-- start of test-case");
 
     resource.isModified();
 
     assertThat(resource.data).isSameAs(SERVER_ERROR);
   }
 
   @Test
   @DisplayName(("call to getInputStream() updates data"))
   public void test_getInputStream_UpdatesData() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     try
     {
       resource.getInputStream();
     }
     catch (FileNotFoundException e) {}
 
     assertThat(resource.data).isSameAs(SERVER_ERROR);
   }
 
   @Test
   @DisplayName(("call to contentLength() updates data"))
   public void test_contentLength_UpdatesData() throws Exception
   {
     LOG.info("<-- start of test-case");
 
     try
     {
       resource.contentLength();
     }
     catch (FileNotFoundException e) {}
 
     assertThat(resource.data).isSameAs(SERVER_ERROR);
   }
 }