/home/kai/Dokumente/yourshouter/http-resources/src/test/java/de/juplo/httpresources/HttpResourceProtocolResolverIT.java

+    package de.juplo.httpresources;
+
+    import org.junit.jupiter.api.BeforeEach;
+    import org.junit.jupiter.api.Test;
+    import org.mockserver.integration.ClientAndServer;
+    import org.slf4j.Logger;
+    import org.slf4j.LoggerFactory;
+    import org.springframework.beans.factory.annotation.Autowired;
+    import org.springframework.beans.factory.annotation.Value;
+    import org.springframework.boot.autoconfigure.SpringBootApplication;
+    import org.springframework.boot.test.context.SpringBootTest;
+    import org.springframework.cache.Cache;
+    import org.springframework.core.io.Resource;
+    import org.springframework.test.web.servlet.MockMvc;
+    import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+    import org.springframework.util.StreamUtils;
+    import org.springframework.web.context.WebApplicationContext;
+    import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
+    import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+    import java.net.URI;
+    import java.nio.charset.Charset;
+    import java.time.Duration;
+
+    import static de.juplo.httpresources.TestUtil.CONTENT;
+    import static de.juplo.httpresources.TestUtil.read;
+    import static org.junit.jupiter.api.Assertions.*;
+    import static org.mockserver.model.HttpRequest.request;
+    import static org.mockserver.verify.VerificationTimes.exactly;
+    import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+    import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
+    import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
+    import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+    /**
+     * Mostly identically with {@link HttpResourceResolverIT}.
+     * Differences:Test explicit lookup with full address through context and has
+     * no exclusion/inclusion.
+     */
+    @SpringBootTest({
+        "juplo.http-resources.protocol-resolver.enabled=true",
+        "juplo.http-resources.resolver.enabled=false",
+        "juplo.http-resources.resolver.exclusion-patterns=**.txt" // << Not used here!
+        })
+    public class HttpResourceProtocolResolverIT extends IntegrationTestBase
+    {
+      private final static Logger LOG =
+          LoggerFactory.getLogger(HttpResourceProtocolResolverIT.class);
+
+
+      @Autowired
+      HttpResources resources;
+      @Autowired
+      Cache cache;
+      @Autowired
+      WebApplicationContext context;
+
+      @Value("classpath:remote/remote.html")
+      Resource remote;
+      @Value("classpath:remote/modified.html")
+      Resource modified;
+
+      MockMvc mvc;
+
+
+      @BeforeEach
+      public void setUp()
+      {
+        cache.clear();
+        mvc = MockMvcBuilders
+                .webAppContextSetup(context)
+                .alwaysDo(print())
+                .build();
+      }
+
+
+      /**
+       * Olthough the {@HttpResourceResolver} is not enabled in this test-scenario,
+       * this works nearly, identically to the same test there, because all lookups
+       * for resources in the resource-chain for static http-resources are executed
+       * through the application-context, where the
+       * {@link HttpResourceProtocolResolver} is registerd.
+       * Only exclusion is not working, since this is only implemented in the
+       * {@HttpResourceResolver}.
+       */
+      @Test
+      public void testResourceHandling() throws Exception
+      {
+        LOG.info("<-- start of test-case");
+
+        mvc
+            .perform(get(URI.create("http://test/foo")))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType("application/octet-stream"))
+            .andExpect(content().string("FOO\n"));
+        mvc
+            .perform(get(URI.create("http://test/bar")))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType("application/octet-stream"))
+            .andExpect(content().string("BAR\n"));
+        mvc
+            .perform(get(URI.create("http://test/hello")))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType("application/octet-stream"))
+            .andExpect(content().bytes(CONTENT));
+        mvc
+            .perform(get(URI.create("http://test/remote.html")))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType("text/html"))
+            .andExpect(content().bytes(StreamUtils.copyToByteArray(remote.getInputStream())));
+        mvc
+            .perform(get(URI.create("http://test/foobar")))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType("application/octet-stream"))
+            .andExpect(content().string("FOOBAR\n"));
+        mvc
+            .perform(get(URI.create("http://test/hello")))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType("application/octet-stream"))
+            .andExpect(content().bytes(CONTENT));
+        mvc
+            .perform(get(URI.create("http://test/hello")))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType("application/octet-stream"))
+            .andExpect(content().bytes(CONTENT));
+        mvc
+            .perform(get(URI.create("http://test/hello")))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType("application/octet-stream"))
+            .andExpect(content().bytes(CONTENT));
+        mvc
+            .perform(get(URI.create("http://test/hallo.txt")))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType("text/plain"))
+            .andExpect(content().string("welt\n"));
+
+        server.verify(FETCH("/foo"), exactly(0));
+        server.verify(FETCH("/bar"), exactly(0));
+        server.verify(FETCH("/hello"), exactly(1));
+        server.verify(FETCH("/hallo.txt"), exactly(1));
+        server.verify(FETCH("/remote.html"), exactly(1));
+        server.verify(FETCH("/foobar"), exactly(2));
+      }
+
+      @Test
+      public void testFetchExistent() throws Exception
+      {
+        LOG.info("<-- Start of test-case");
+
+        getRemoteHtml();
+
+        server.verify(FETCH("/remote.html"), exactly(1));
+      }
+
+      @Test
+      public void testCachingOfExisting() throws Exception
+      {
+        LOG.info("<-- Start of test-case");
+
+        getRemoteHtml();
+        getRemoteHtml();
+        getRemoteHtml();
+        getRemoteHtml();
+        getRemoteHtml();
+        getRemoteHtml();
+        getRemoteHtml();
+        getRemoteHtml();
+
+        server.verify(FETCH("/remote.html"), exactly(1));
+      }
+
+      private void getRemoteHtml() throws Exception
+      {
+        Resource resource = context.getResource(address("/remote.html"));
+        assertNotNull(resource);
+        assertTrue(resource.exists());
+        String expected = StreamUtils.copyToString(remote.getInputStream(), Charset.forName("UTF-8"));
+        String content = StreamUtils.copyToString(resource.getInputStream(), Charset.forName("UTF-8"));
+        assertEquals(expected, content);
+      }
+
+      @Test
+      public void testFetchNonExistent() throws Exception
+      {
+        LOG.info("<-- Start of test-case");
+
+        getNonExistingHtml();
+
+        server.verify(FETCH("/peter.html"), exactly(2));
+      }
+
+      @Test
+      public void testCachingOfNonExistent() throws Exception
+      {
+        LOG.info("<-- Start of test-case");
+
+        getNonExistingHtml();
+        getNonExistingHtml();
+        getNonExistingHtml();
+        getNonExistingHtml();
+        getNonExistingHtml();
+        getNonExistingHtml();
+        getNonExistingHtml();
+
+        // Remote-requests answered with 404 are repeated
+        server.verify(FETCH("/peter.html"), exactly(14));
+      }
+
+      private void getNonExistingHtml() throws Exception
+      {
+        Resource resource = context.getResource(address("/peter.html"));
+        assertNotNull(resource);
+        assertFalse(resource.exists());
+      }
+
+      @Test
+      public void testModifiedResource() throws Exception
+      {
+        LOG.info("<-- Start of test-case");
+
+        mvc
+            .perform(get(URI.create("http://test/remote.html")))
+            .andExpect(status().isOk())
+            .andExpect(content().string(read(remote)));
+
+        CLOCK.timetravel(Duration.ofSeconds(10));
+        server.when(FETCH("/remote.html")).forward(NGINX("/modified.html"));
+
+        mvc
+            .perform(get(URI.create("http://test/remote.html")))
+                .andExpect(status().isOk())
+                .andExpect(content().string(read(modified)));
+
+        server.verify(FETCH("/remote.html"), exactly(2));
+        server.verify(
+            request()
+                .withPath("/remote.html")
+                .withHeader("If-Modified-Since")
+                .withHeader("If-None-Match"),
+            exactly(1));
+      }
+
+
+      @SpringBootApplication
+      public static class Application implements WebMvcConfigurer
+      {
+        @Autowired
+        ClientAndServer server;
+
+        @Override
+        public void addResourceHandlers(ResourceHandlerRegistry registry)
+        {
+          LOG.info(
+              "{} resource-handler for static location {}",
+              registry.hasMappingForPattern("/**") ? "Overwriting" : "Setting",
+              "/**"
+              );
+          registry
+              .addResourceHandler("/**")
+              .addResourceLocations(
+                  "classpath:/static/",
+                  "classpath:/public/",
+                  "http://localhost:" + server.getLocalPort(),
+                  "classpath:/fallback/")
+              .resourceChain(false);
+        }
+      }
+    }
+