Adding some code to test for gzip no-recompress logic

jetty-servlets/src/test/java/org/eclipse/jetty/servlets/GzipFilterDefaultNoRecompressTest.java

@@ -8,10 +8,10 @@ import java.util.List;
 import org.eclipse.jetty.servlet.DefaultServlet;
 import org.eclipse.jetty.servlet.FilterHolder;
 import org.eclipse.jetty.servlets.gzip.GzipTester;
+import org.eclipse.jetty.servlets.gzip.TestStaticMimeTypeServlet;
 import org.eclipse.jetty.toolchain.test.IO;
 import org.eclipse.jetty.toolchain.test.MavenTestingUtils;
 import org.eclipse.jetty.toolchain.test.TestingDir;
-import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -19,9 +19,8 @@ import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
 /**
- * Tests {@link GzipFilter} in combination with {@link DefaultServlet} for 
+ * Tests {@link GzipFilter} in combination with {@link DefaultServlet} for ability to configure {@link GzipFilter} to
- * ability to configure {@link GzipFilter} to ignore recompress situations
+ * ignore recompress situations from upstream.
- * from upstream.
  */
 @RunWith(Parameterized.class)
 public class GzipFilterDefaultNoRecompressTest
@@ -32,59 +31,52 @@ public class GzipFilterDefaultNoRecompressTest
         return Arrays.asList(new Object[][]
         {
                 // Some already compressed files
-                { "test_quotes.gz" },
+                { "test_quotes.gz", "application/gzip" },
-                { "test_quotes.bz2" },
+                { "test_quotes.bz2", "application/bzip2" },
-                { "test_quotes.zip" },
+                { "test_quotes.zip", "application/zip" },
-                { "test_quotes.rar" },
+                { "test_quotes.rar", "application/octet-stream" },
                 // Some images (common first)
-                { "jetty_logo.png" },
+                { "jetty_logo.png", "image/png" },
-                { "jetty_logo.gif" },
+                { "jetty_logo.gif", "image/gif" },
-                { "jetty_logo.jpeg" },
+                { "jetty_logo.jpeg", "image/jpeg" },
-                { "jetty_logo.jpg" },
+                { "jetty_logo.jpg", "image/jpeg" },
                 // Lesser encountered images (usually found being requested from non-browser clients)
-                { "jetty_logo.bmp" },
+                { "jetty_logo.bmp", "image/bmp" },
-                { "jetty_logo.tga" },
+                { "jetty_logo.tga", "application/tga" },
-                { "jetty_logo.tif" },
+                { "jetty_logo.tif", "image/tiff" },
-                { "jetty_logo.tiff" },
+                { "jetty_logo.tiff", "image/tiff" },
-                { "jetty_logo.xcf" },
+                { "jetty_logo.xcf", "image/xcf" },
-                { "jetty_logo.jp2" } });
+                { "jetty_logo.jp2", "image/jpeg2000" } });
     }
 
     @Rule
     public TestingDir testingdir = new TestingDir();
 
     private String alreadyCompressedFilename;
+    private String expectedContentType;
 
-    public GzipFilterDefaultNoRecompressTest(String testFilename) {
+    public GzipFilterDefaultNoRecompressTest(String testFilename, String expectedContentType)
+    {
         this.alreadyCompressedFilename = testFilename;
+        this.expectedContentType = expectedContentType;
     }
 
     @Test
-    @Ignore("Cannot find a configuration that would allow this to pass")
     public void testNotGzipFiltered_Default_AlreadyCompressed() throws Exception
     {
         GzipTester tester = new GzipTester(testingdir);
 
         copyTestFileToServer(alreadyCompressedFilename);
 
-        // Using DefaultServlet, with default GzipFilter setup
+        FilterHolder holder = tester.setContentServlet(TestStaticMimeTypeServlet.class);
-        FilterHolder holder = tester.setContentServlet(DefaultServlet.class);
-        // TODO: find a configuration of the GzipFilter to allow
-        //       each of these test cases to pass.
-        
         StringBuilder mimeTypes = new StringBuilder();
-        mimeTypes.append("images/png");
+        mimeTypes.append("text/plain");
-        mimeTypes.append(",images/jpeg");
-        mimeTypes.append(",images/gif");
-        mimeTypes.append(",images/jp2");
-        
         holder.setInitParameter("mimeTypes",mimeTypes.toString());
 
         try
         {
             tester.start();
-            tester.assertIsResponseNotGzipFiltered(alreadyCompressedFilename,
+            tester.assertIsResponseNotGzipFiltered(alreadyCompressedFilename,alreadyCompressedFilename + ".sha1",expectedContentType);
-                    alreadyCompressedFilename + ".sha1");
         }
         finally
         {

jetty-servlets/src/test/java/org/eclipse/jetty/servlets/gzip/GzipTester.java

@@ -111,8 +111,9 @@ public class GzipTester
      * @param testResourceSha1Sum
      *            the sha1sum file that contains the SHA1SUM checksum that will be used to verify that the response
      *            contents are what is intended.
+     * @param expectedContentType
      */
-    public void assertIsResponseNotGzipFiltered(String requestedFilename, String testResourceSha1Sum) throws Exception
+    public void assertIsResponseNotGzipFiltered(String requestedFilename, String testResourceSha1Sum, String expectedContentType) throws Exception
     {
         System.err.printf("[GzipTester] requesting /context/%s%n",requestedFilename);
         HttpTester request = new HttpTester();
@@ -133,13 +134,13 @@ public class GzipTester
         dumpHeaders(requestedFilename + " / Response Headers",response);
 
         // Assert the response headers
-        Assert.assertThat(requestedFilename + " / Response.method",response.getMethod(),nullValue());
+        String prefix = requestedFilename + " / Response";
-        Assert.assertThat(requestedFilename + " / Response.status",response.getStatus(),is(HttpServletResponse.SC_OK));
+        Assert.assertThat(prefix + ".method",response.getMethod(),nullValue());
-        Assert.assertThat(requestedFilename + " / Response.header[Content-Length]",response.getHeader("Content-Length"),notNullValue());
+        Assert.assertThat(prefix + ".status",response.getStatus(),is(HttpServletResponse.SC_OK));
-        Assert.assertThat(requestedFilename + " / Response.header[Content-Encoding] (should not be recompressed by GzipFilter)",
+        Assert.assertThat(prefix + ".header[Content-Length]",response.getHeader("Content-Length"),notNullValue());
-                response.getHeader("Content-Encoding"),nullValue());
+        Assert.assertThat(prefix + ".header[Content-Encoding] (should not be recompressed by GzipFilter)",response.getHeader("Content-Encoding"),nullValue());
-        Assert.assertThat(requestedFilename + " / Response.header[Content-Type] (should have a Content-Type associated with it)",
+        Assert.assertThat(prefix + ".header[Content-Type] (should have a Content-Type associated with it)",response.getHeader("Content-Type"),notNullValue());
-                response.getHeader("Content-Type"),notNullValue());
+        Assert.assertThat(prefix + ".header[Content-Type]",response.getHeader("Content-Type"),is(expectedContentType));
 
         ByteArrayInputStream bais = null;
         DigestOutputStream digester = null;

jetty-servlets/src/test/java/org/eclipse/jetty/servlets/gzip/TestStaticMimeTypeServlet.java

@@ -0,0 +1,67 @@
+package org.eclipse.jetty.servlets.gzip;
+
+import java.io.IOException;
+
+import javax.servlet.ServletConfig;
+import javax.servlet.ServletException;
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.eclipse.jetty.http.MimeTypes;
+import org.eclipse.jetty.io.Buffer;
+
+/**
+ * Test servlet for testing against unusual MimeTypes and Content-Types.
+ */
+@SuppressWarnings("serial")
+public class TestStaticMimeTypeServlet extends TestDirContentServlet
+{
+    private MimeTypes mimeTypes;
+
+    @Override
+    public void init(ServletConfig config) throws ServletException
+    {
+        super.init(config);
+        mimeTypes = new MimeTypes();
+        // Some real world, yet not terribly common, mime type mappings.
+        mimeTypes.addMimeMapping("bz2","application/bzip2");
+        mimeTypes.addMimeMapping("bmp","image/bmp");
+        mimeTypes.addMimeMapping("tga","application/tga");
+        mimeTypes.addMimeMapping("xcf","image/xcf");
+        mimeTypes.addMimeMapping("jp2","image/jpeg2000");
+        
+        // Some of the other gzip mime-types seen in the wild.
+        // NOTE: Using oddball extensions just so that the calling request can specify
+        //       which strange mime type to use.
+        mimeTypes.addMimeMapping("x-gzip","application/x-gzip");
+        mimeTypes.addMimeMapping("x-gunzip","application/x-gunzip");
+        mimeTypes.addMimeMapping("gzipped","application/gzippped");
+        mimeTypes.addMimeMapping("gzip-compressed","application/gzip-compressed");
+        mimeTypes.addMimeMapping("x-compressed","application/x-compressed");
+        mimeTypes.addMimeMapping("x-compress","application/x-compress");
+        mimeTypes.addMimeMapping("gzipdoc","gzip/document");
+    }
+
+    @Override
+    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
+    {
+        String fileName = request.getServletPath();
+        byte[] dataBytes = loadContentFileBytes(fileName);
+
+        response.setContentLength(dataBytes.length);
+
+        Buffer buf = mimeTypes.getMimeByExtension(fileName);
+        if (buf == null)
+        {
+            response.setContentType("application/octet-stream");
+        }
+        else
+        {
+            response.setContentType(buf.toString());
+        }
+
+        ServletOutputStream out = response.getOutputStream();
+        out.write(dataBytes);
+    }
+}