package com.atlassian.johnson.filters;
   
   import com.atlassian.johnson.DefaultJohnsonEventContainer;
   import com.atlassian.johnson.Johnson;
   import com.atlassian.johnson.JohnsonEventContainer;
   import com.atlassian.johnson.event.Event;
   import com.atlassian.johnson.event.EventType;
   import com.atlassian.johnson.test.SimpleSetupConfig;
   import org.easymock.EasyMockSupport;
  import org.junit.AfterClass;
  import org.junit.Before;
  import org.junit.BeforeClass;
  import org.junit.Test;
  
  import javax.servlet.FilterChain;
  import javax.servlet.FilterConfig;
  import javax.servlet.ServletContext;
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import java.io.IOException;
  import java.util.Arrays;
  
  import static org.easymock.EasyMock.*;
  import static org.junit.Assert.assertEquals;
  
  public class JohnsonFilterTest extends EasyMockSupport
  {
      public static final String ALREADY_FILTERED = JohnsonFilter.class.getName() + "_already_filtered";
  
      private JohnsonEventContainer container;
      private JohnsonFilter filter;
      private FilterChain filterChain;
      private HttpServletRequest request;
      private HttpServletResponse response;
  
      @AfterClass
      public static void clearConfig()
      {
          Johnson.terminate();
      }
  
      @BeforeClass
      public static void setConfig()
      {
          Johnson.initialize("test-johnson-config.xml");
      }
  
      @Before
      public void setUp() throws Exception
      {
          SimpleSetupConfig.IS_SETUP = false;
  
          filter = new JohnsonFilter();
          container = new DefaultJohnsonEventContainer();
          request = getRequest();
          response = getResponse();
          filterChain = getFilterChain();
      }
  
      @Test
      public void testErrorNotIgnorableURI() throws Exception
      {
          container.addEvent(new Event(EventType.get("database"), "foo")); // add an event
          expect(request.getServletPath()).andReturn("somepage.jsp").times(2);
          response.sendRedirect(eq("/the/error/path.jsp")); // verify redirect
          
          replayAll();
          filter.doFilter(request, response, filterChain);
          verifyAll();
      }
  
      @Test
      public void testErrorsIgnorableUri() throws Exception
      {
          container.addEvent(new Event(EventType.get("export"), "foo")); // add an event
          expect(request.getServletPath()).andReturn("/the/error/path.jsp");
          filterChain.doFilter(same(request), same(response)); // verify that doFilter is called
          
          replayAll();
          filter.doFilter(request, response, filterChain);
          verifyAll();
      }
  
      @Test
      public void testNoErrorsAndNotSetup() throws Exception
      {
          expect(request.getServletPath()).andReturn("somepage.jsp").times(2);
          response.sendRedirect(eq("/the/setup/path.jsp")); // verify redirect
  
          replayAll();
          filter.doFilter(request, response, filterChain);
          verifyAll();
      }
  
      @Test
      public void testNoErrorsSetup() throws Exception
      {
          SimpleSetupConfig.IS_SETUP = true;
 
         expect(request.getServletPath()).andReturn("somepage.jsp");
         filterChain.doFilter(same(request), same(response));
         
         replayAll();
         filter.doFilter(request, response, filterChain);
         verifyAll();
     }
 
     @Test
     public void testNoErrorsSetupButSetupURI() throws Exception
     {
         SimpleSetupConfig.IS_SETUP = true;
 
         expect(request.getServletPath()).andReturn("/setuppage.jsp");
         filterChain.doFilter(same(request), same(response));
 
         replayAll();
         filter.doFilter(request, response, filterChain);
         verifyAll();
     }
 
     @Test
     public void testNoErrorsNotSetupButSetupURI() throws Exception
     {
         expect(request.getServletPath()).andReturn("/setup.jsp"); // setup URI as containing 'setup'
         filterChain.doFilter(same(request), same(response));
 
         replayAll();
         filter.doFilter(request, response, filterChain);
         verifyAll();
     }
 
     @Test
     public void testNoErrorsNotSetupIgnorableURI() throws Exception
     {
         expect(request.getServletPath()).andReturn("/ignore/path/1.jsp"); // setup URI as ignorable
         filterChain.doFilter(same(request), same(response));
 
         replayAll();
         filter.doFilter(request, response, filterChain);
         verifyAll();
     }
 
     @Test
     public void testNoErrorsNotSetupNotIgnorableURI() throws Exception
     {
         expect(request.getServletPath()).andReturn("/somepage.jsp").times(2); // setup URI as not ignorable
         response.sendRedirect(eq("/the/setup/path.jsp")); // verify redirect
 
         replayAll();
         filter.doFilter(request, response, filterChain);
         verifyAll();
     }
 
     @Test
     public void testNotAppliedTwice() throws ServletException, IOException
     {
         expect(request.getServletPath()).andReturn("/somepage.jsp").times(2);
         response.sendRedirect(eq("/the/setup/path.jsp")); // verify redirect
 
         replayAll();
         filter.doFilter(request, response, filterChain);
         verifyAll();
 
         reset(request);
         expect(request.getAttribute(eq(ALREADY_FILTERED))).andReturn(Boolean.TRUE);
 
         reset(filterChain);
         filterChain.doFilter(same(request), same(response));
 
         replay(filterChain, request);
         filter.doFilter(request, response, filterChain);
         verify(filterChain, request);
     }
 
     @Test
     public void testEmptyServletPaths() throws ServletException, IOException
     {
         expect(request.getServletPath()).andStubReturn("");
         expect(request.getContextPath()).andStubReturn("");
         expect(request.getRequestURI()).andStubReturn("/requestpage.jsp");
         expect(request.getPathInfo()).andStubReturn(null);
         response.sendRedirect(eq("/the/setup/path.jsp")); // verify redirect
 
         replayAll();
         filter.doFilter(request, response, filterChain);
         verifyAll();
     }
 
     @Test
     public void testGetStringForEvents()
     {
         JohnsonFilter filter = new JohnsonFilter();
         EventType type = new EventType("mytype", "mydesc");
         Event[] eventsArr = new Event[]{new Event(type, "Error 1"), new Event(type, "Error 2")};
         String stringForEvents = filter.getStringForEvents(Arrays.asList(eventsArr));
         assertEquals("Error 1\nError 2", stringForEvents);
     }
 
     private FilterChain getFilterChain() throws ServletException
     {
         container = new DefaultJohnsonEventContainer();
 
         ServletContext servletContext = createNiceMock(ServletContext.class);
         expect(servletContext.getAttribute(same(Johnson.EVENT_CONTAINER_ATTRIBUTE))).andStubReturn(container);
 
         FilterChain filterChain = createNiceMock(FilterChain.class);
 
         FilterConfig filterConfig = createNiceMock(FilterConfig.class);
         expect(filterConfig.getServletContext()).andStubReturn(servletContext);
 
         filter.init(filterConfig);
         return filterChain;
     }
 
     private HttpServletResponse getResponse()
     {
         return createStrictMock(HttpServletResponse.class);
     }
 
     private HttpServletRequest getRequest()
     {
         HttpServletRequest request = createStrictMock(HttpServletRequest.class);
         expect(request.getContextPath()).andStubReturn("");
         expect(request.getAttribute(eq(ALREADY_FILTERED))).andReturn(null);
         request.setAttribute(eq(ALREADY_FILTERED), eq(Boolean.TRUE));
 
         return request;
     }
 }