Add CompositeFilter to group all new filters

Author: KarstenSchnitter

cf-java-logging-support-servlet/src/main/java/com/sap/hcp/cf/logging/servlet/filter/CompositeFilter.java

@@ -0,0 +1,88 @@
+package com.sap.hcp.cf.logging.servlet.filter;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+
+/**
+ * <p>
+ * The {@link CompositeFilter} allows to group several servlet {@link Filter}
+ * into one. This is used to allow customizable filters and provide a backwards
+ * compatible {@link RequestLoggingFilter}.
+ * </p>
+ * 
+ * <p>
+ * You can easily create a subclass of {@link CompositeFilter} and add all the
+ * filters from com.sap.hcp.cf.logging.servlet.filter you wish. You can even
+ * bring your own filters.
+ * </p>
+ */
+public class CompositeFilter implements Filter {
+
+    private List<? extends Filter> filters;
+
+    public CompositeFilter(Filter... filters) {
+        this.filters = Arrays.asList(filters);
+    }
+
+    public void setFilters(List<? extends Filter> filters) {
+        this.filters = new ArrayList<>(filters);
+    }
+
+    public List<? extends Filter> getFilters() {
+        return Collections.unmodifiableList(filters);
+    }
+
+    @Override
+    public void init(FilterConfig config) throws ServletException {
+        for (Filter filter: this.filters) {
+            filter.init(config);
+        }
+    }
+
+    @Override
+    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException,
+                                                                                              ServletException {
+        new InternalFilterChain(chain, this.filters).doFilter(request, response);
+    }
+
+    @Override
+    public void destroy() {
+        for (int i = this.filters.size() - 1; i >= 0; i--) {
+            Filter filter = this.filters.get(i);
+            filter.destroy();
+        }
+    }
+
+    private static class InternalFilterChain implements FilterChain {
+
+        private final FilterChain originalChain;
+        private final Iterator<? extends Filter> current;
+
+        public InternalFilterChain(FilterChain chain, List<? extends Filter> additionalFilters) {
+            this.originalChain = chain;
+            this.current = additionalFilters.iterator();
+        }
+
+        @Override
+        public void doFilter(final ServletRequest request, final ServletResponse response) throws IOException,
+                                                                                           ServletException {
+            if (current.hasNext()) {
+                current.next().doFilter(request, response, this);
+            } else {
+                originalChain.doFilter(request, response);
+            }
+        }
+    }
+
+}

cf-java-logging-support-servlet/src/test/java/com/sap/hcp/cf/logging/servlet/filter/CompositeFilterTest.java

@@ -0,0 +1,92 @@
+package com.sap.hcp.cf.logging.servlet.filter;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.mock;
+
+import java.io.IOException;
+
+import javax.servlet.Filter;
+import javax.servlet.FilterChain;
+import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+
+@RunWith(MockitoJUnitRunner.class)
+public class CompositeFilterTest {
+
+    @Mock
+    private Filter filter1;
+    @Mock
+    private Filter filter2;
+
+    @Before
+    public void setUp() throws Exception {
+        Mockito.doAnswer(inv -> {
+            doFilter(inv.getArguments());
+            return null;
+        }).when(filter1).doFilter(any(), any(), any());
+        Mockito.doAnswer(inv -> {
+            doFilter(inv.getArguments());
+            return null;
+        }).when(filter2).doFilter(any(), any(), any());
+    }
+
+    private void doFilter(Object... arguments) throws IOException, ServletException {
+        ServletRequest request = (ServletRequest) arguments[0];
+        ServletResponse response = (ServletResponse) arguments[1];
+        FilterChain filterChain = (FilterChain) arguments[2];
+        filterChain.doFilter(request, response);
+    }
+
+    @Test
+    public void forwardsInitConfig() throws Exception {
+        CompositeFilter filter = new CompositeFilter(filter1, filter2);
+        FilterConfig config = mock(FilterConfig.class);
+
+        filter.init(config);
+
+        InOrder inOrder = inOrder(filter1, filter2);
+        inOrder.verify(filter1).init(config);
+        inOrder.verify(filter2).init(config);
+    }
+
+    @Test
+    public void destroysInCorrectOrder() throws Exception {
+        CompositeFilter filter = new CompositeFilter(filter1, filter2);
+
+        filter.destroy();
+
+        InOrder inOrder = inOrder(filter1, filter2);
+        inOrder.verify(filter2).destroy();
+        inOrder.verify(filter1).destroy();
+    }
+
+    @Test
+    public void callsFiltersInOrder() throws Exception {
+        CompositeFilter filter = new CompositeFilter(filter1, filter2);
+
+        ServletRequest request = mock(ServletRequest.class);
+        ServletResponse response = mock(ServletResponse.class);
+        FilterChain chain = mock(FilterChain.class);
+
+        filter.doFilter(request, response, chain);
+
+        InOrder inOrder = inOrder(filter1, filter2, chain);
+        inOrder.verify(filter1).doFilter(eq(request), eq(response), any());
+        inOrder.verify(filter2).doFilter(eq(request), eq(response), any());
+        inOrder.verify(chain).doFilter(request, response);
+
+    }
+
+}