package com.atlassian.sal.core.net;
   
   import java.io.IOException;
   import java.net.SocketException;
   import java.util.concurrent.atomic.AtomicInteger;
   
   import com.atlassian.sal.api.net.Request.MethodType;
   import com.atlassian.sal.api.net.ResponseConnectTimeoutException;
   import com.atlassian.sal.api.net.ResponseException;
  import com.atlassian.sal.api.net.ResponseHandler;
  import com.atlassian.sal.api.net.ResponseProtocolException;
  import com.atlassian.sal.api.net.ResponseReadTimeoutException;
  import com.atlassian.sal.api.net.ResponseStatusException;
  import com.atlassian.sal.api.net.ResponseTransportException;
  import com.atlassian.sal.api.user.UserManager;
  import com.atlassian.sal.core.net.auth.HttpClientAuthenticator;
  import com.atlassian.sal.core.trusted.CertificateFactory;
  import com.atlassian.security.auth.trustedapps.EncryptedCertificate;
  
  import org.apache.commons.httpclient.ConnectTimeoutException;
  import org.apache.commons.httpclient.Header;
  import org.apache.commons.httpclient.HostConfiguration;
  import org.apache.commons.httpclient.HttpClient;
  import org.apache.commons.httpclient.HttpException;
  import org.apache.commons.httpclient.HttpMethod;
  import org.apache.commons.httpclient.NoHttpResponseException;
  import org.apache.commons.httpclient.methods.GetMethod;
  import org.apache.commons.httpclient.methods.PostMethod;
  import org.apache.commons.httpclient.methods.PutMethod;
  import org.apache.commons.httpclient.params.HttpClientParams;
  import org.easymock.classextension.EasyMock;
  import org.easymock.classextension.IMocksControl;
  import org.junit.After;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.mockito.Mock;
  import org.mockito.Mockito;
  import org.mockito.runners.MockitoJUnitRunner;
  
  import junit.framework.TestCase;
  
  import static org.easymock.EasyMock.isA;
  import static org.hamcrest.Matchers.hasItemInArray;
  import static org.junit.Assert.assertThat;
  import static org.mockito.Mockito.mock;
  import static org.mockito.Mockito.times;
  import static org.mockito.Mockito.when;
  
  @RunWith (MockitoJUnitRunner.class)
  public class TestHttpClientRequest extends TestCase
  {
      @Mock
      private CertificateFactory certificateFactory;
      @Mock
      private UserManager userManager;
      @Mock
      private HttpClient httpClient;
      @Mock
      private ResponseHandler responseHandler;
      @Mock
      private PutMethod putMethod;
      @Mock
      private PostMethod postMethod;
      @Mock
      private GetMethod getMethod;
      @Mock
      private EncryptedCertificate encryptedCertificate;
  
  
      @After
      public void tearDown()
      {
          System.clearProperty(HttpClientParams.MAX_REDIRECTS);
      }
  
      @Test
      public void testAuthentication() throws IOException, ResponseException
      {
          final IMocksControl httpClientMockControl = EasyMock.createNiceControl();
          final HttpClient mockHttpClient = httpClientMockControl.createMock(HttpClient.class);
          httpClientMockControl.replay();
  
  
          // counter how many time was authentication called
          final AtomicInteger authenticatorCounter = new AtomicInteger(0);
  
          // lets create new GET request to http://url
          HttpClientRequest request = new HttpClientRequest(mockHttpClient, MethodType.GET, "http://url",
                  mock(CertificateFactory.class), mock(UserManager.class));
  
          // this is our authenticator
          final HttpClientAuthenticator authenticator = new HttpClientAuthenticator()
          {
              public void process(HttpClient httpClient, HttpMethod method)
              {
                  assertEquals("It should use mockClient", httpClient, mockHttpClient);
                  assertTrue("We asked it for GetMethod", method instanceof GetMethod);
                  authenticatorCounter.addAndGet(1);
              }
         };
 
         // lets add 2 authenticator to the request
         request.addAuthentication(authenticator);
         request.addAuthentication(authenticator);
 
         // and we are ready to execute the request
         request.execute(EasyMock.createMock(ResponseHandler.class));
 
         // and assert that authenticators were used
         assertEquals("Two authenticator should be called.", 2, authenticatorCounter.intValue());
     }
 
     @Test
     public void verifyThatTrustedAuthentcationUsesAbsoluteUrl() throws ResponseException
     {
         // the url of interest
         String targetUrl = "http://url/abc";
         // create a certificate
         String id = "1";
         when(encryptedCertificate.getID()).thenReturn(id);
 
         // make sure that certificate is returned for the correct url
         when(certificateFactory.createCertificate("barry", targetUrl)).thenReturn(encryptedCertificate);
 
         // build the request
         HttpClientRequestFactory httpClientRequestFactory = new HttpClientRequestFactory(certificateFactory, userManager);
         HttpClientRequest request = httpClientRequestFactory.createRequest(MethodType.GET, targetUrl);
 
         // add the trusted authenticaTION
         request.addTrustedTokenAuthentication("barry");
 
         // get the trusted authenticaTOR
         HttpClientAuthenticator httpClientAuthenticator = request.getAuthenticators().get(0);
 
         // verify that applying the authenticator applies the trusted headers
         HttpMethod httpMethod = new GetMethod();
         httpClientAuthenticator.process(httpClient, httpMethod);
 
         // look for a sample trusted header.
         assertThat(httpMethod.getRequestHeaders(), hasItemInArray(new Header("X-Seraph-Trusted-App-ID", id)));
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void verifyThatRelativeUrlCannotBeUsed() throws ResponseException
     {
         // the url of interest
         String targetUrl = "/abc";
         // create a certificate
         String id = "1";
         when(encryptedCertificate.getID()).thenReturn(id);
 
         // make sure that certificate is returned for the correct url
         when(certificateFactory.createCertificate("barry", targetUrl)).thenReturn(encryptedCertificate);
 
         // build the request
         HttpClientRequestFactory httpClientRequestFactory = new HttpClientRequestFactory(certificateFactory, userManager);
         httpClientRequestFactory.createRequest(MethodType.GET, targetUrl);
     }
 
     @Test
     public void testConnectTimeout() throws IOException, ResponseException
     {
         // create HttpClient that will throw a ConnectTimeoutException
         final IMocksControl httpClientMockControl = EasyMock.createNiceControl();
         final HttpClient httpClientMock = httpClientMockControl.createMock(HttpClient.class);
         httpClientMock.executeMethod(isA(GetMethod.class));
         httpClientMockControl.andThrow(new ConnectTimeoutException("errordescription"));
         httpClientMockControl.replay();
 
         HttpClientRequest request = createMockRequest(httpClientMock, MethodType.GET, "http://url");
 
         try
         {
             request.execute(EasyMock.createMock(ResponseHandler.class));
             fail("Should throw ResponseConnectTimeoutException");
         }
         catch (ResponseConnectTimeoutException e)
         {
             // expect Exception
             assertEquals(ConnectTimeoutException.class, e.getCause().getClass());
             assertEquals("errordescription", e.getMessage());
         }
     }
 
     @Test
     public void testReadTimeout() throws IOException, ResponseException
     {
         // create HttpClient that will throw a NoHttpResponseException
         final IMocksControl httpClientMockControl = EasyMock.createNiceControl();
         final HttpClient httpClientMock = httpClientMockControl.createMock(HttpClient.class);
         httpClientMock.executeMethod(isA(GetMethod.class));
         httpClientMockControl.andThrow(new NoHttpResponseException("errordescription"));
         httpClientMockControl.replay();
 
         HttpClientRequest request = createMockRequest(httpClientMock, MethodType.GET, "http://url");
 
         try
         {
             request.execute(EasyMock.createMock(ResponseHandler.class));
             fail("Should throw ResponseConnectTimeoutException");
         }
         catch (ResponseReadTimeoutException e)
         {
             // expect Exception
             assertEquals(NoHttpResponseException.class, e.getCause().getClass());
             assertEquals("errordescription", e.getMessage());
         }
     }
 
     @Test
     public void testHttpException() throws IOException, ResponseException
     {
         // create HttpClient that will throw an HttpException
         final IMocksControl httpClientMockControl = EasyMock.createNiceControl();
         final HttpClient httpClientMock = httpClientMockControl.createMock(HttpClient.class);
         httpClientMock.executeMethod(isA(GetMethod.class));
         httpClientMockControl.andThrow(new HttpException("errordescription"));
         httpClientMockControl.replay();
 
         HttpClientRequest request = createMockRequest(httpClientMock, MethodType.GET, "http://url");
 
         try
         {
             request.execute(EasyMock.createMock(ResponseHandler.class));
             fail("Should throw ResponseProtocolException");
         }
         catch (ResponseProtocolException e)
         {
             // expect Exception
             assertEquals(HttpException.class, e.getCause().getClass());
             assertEquals("errordescription", e.getMessage());
         }
     }
 
     @Test
     public void testSocketException() throws IOException, ResponseException
     {
         // create HttpClient that will throw a SocketException
         final IMocksControl httpClientMockControl = EasyMock.createNiceControl();
         final HttpClient httpClientMock = httpClientMockControl.createMock(HttpClient.class);
         httpClientMock.executeMethod(isA(GetMethod.class));
         httpClientMockControl.andThrow(new SocketException("errordescription"));
         httpClientMockControl.replay();
 
         HttpClientRequest request = createMockRequest(httpClientMock, MethodType.GET, "http://url");
 
         try
         {
             request.execute(EasyMock.createMock(ResponseHandler.class));
             fail("Should throw ResponseTransportException");
         }
         catch (ResponseTransportException e)
         {
             // expect Exception
             assertEquals(SocketException.class, e.getCause().getClass());
             assertEquals("errordescription", e.getMessage());
         }
     }
 
     @Test
     public void testStatusException() throws IOException, ResponseException
     {
         // create mock GetMethod that returns a 400 error
         final IMocksControl mockControl = EasyMock.createNiceControl();
         final GetMethod mockGetMethod = mockControl.createMock(GetMethod.class);
         mockGetMethod.getStatusCode();
         mockControl.andReturn(400);
         mockControl.anyTimes();
         mockControl.replay();
 
         // create HttpClient that will return this response
         final IMocksControl httpClientMockControl = EasyMock.createNiceControl();
         final HttpClient httpClientMock = httpClientMockControl.createMock(HttpClient.class);
         httpClientMock.executeMethod(mockGetMethod);
         httpClientMockControl.andReturn(400);
         httpClientMockControl.replay();
 
         HttpClientRequest request = createMockRequest(httpClientMock, mockGetMethod, MethodType.GET, "http://url");
 
         try
         {
             request.execute();
             fail("Should throw ResponseStatusException");
         }
         catch (ResponseStatusException e)
         {
             // expect Exception
             assertNotNull(e.getResponse());
             assertEquals(400, e.getResponse().getStatusCode());
         }
     }
     
     @Test
     public void testMaxNumberOfRedirectionReached() throws IOException, ResponseException
     {
         final GetMethod mockGetMethod = mock(GetMethod.class);
         when(mockGetMethod.getResponseHeader("location")).thenReturn(new Header("location", "http://someRedirectionUrl"));
 
         final HttpClient httpClientMock = mock(HttpClient.class);
         when(httpClientMock.getHostConfiguration()).thenReturn(new HostConfiguration());
         when(httpClientMock.executeMethod(mockGetMethod)).thenReturn(302);
 
         HttpClientRequest request = createMockRequest(httpClientMock, mockGetMethod, MethodType.GET, "http://url");
 
         // now use it
         try
         {
             request.execute(mock(ResponseHandler.class));
             fail("Should throw ResponseProtocolException - maximum retries reached.");
         }
         catch (ResponseProtocolException e)
         {
             // expect Exception
         }
 
         // and assert results
         // methods are called once for the initial call and then once per redirect.
         Mockito.verify(mockGetMethod, times(HttpClientRequest.MAX_REDIRECTS + 1)).getResponseHeader("location");
         Mockito.verify(httpClientMock, times(HttpClientRequest.MAX_REDIRECTS + 1)).executeMethod(mockGetMethod);
     }
 
     @Test
     public void testOverriddenMaxNumberOfRedirectionReached() throws IOException, ResponseException
     {
         // override the default MAX_REQUESTS
         int redirectsAllowed = 10;
         System.setProperty(HttpClientParams.MAX_REDIRECTS, "" + redirectsAllowed);
 
         final GetMethod mockGetMethod = mock(GetMethod.class);
         when(mockGetMethod.getResponseHeader("location")).thenReturn(new Header("location", "http://someRedirectionUrl"));
 
         final HttpClient httpClientMock = mock(HttpClient.class);
         when(httpClientMock.getHostConfiguration()).thenReturn(new HostConfiguration());
         when(httpClientMock.executeMethod(mockGetMethod)).thenReturn(302);
 
         HttpClientRequest request = createMockRequest(httpClientMock, mockGetMethod, MethodType.GET, "http://url");
 
         // now use it
         try
         {
             request.execute(mock(ResponseHandler.class));
             fail("Should throw ResponseProtocolException - maximum retries reached.");
         }
         catch (ResponseProtocolException e)
         {
             // expect Exception
         }
 
         // and assert results
         // methods are called once for the initial call and then once per redirect.
         Mockito.verify(mockGetMethod, times(redirectsAllowed + 1)).getResponseHeader("location");
         Mockito.verify(httpClientMock, times(redirectsAllowed + 1)).executeMethod(mockGetMethod);
     }
 
     @Test
     public void testNoFollowRedirect() throws IOException
     {
         // create mock GetMethod - it should not redirect automatically
         final IMocksControl mockControl = EasyMock.createNiceControl();
         final GetMethod mockGetMethod = mockControl.createMock(GetMethod.class);
         mockGetMethod.getResponseHeader("location");
         mockControl.andReturn(new Header("location", "http://someRedirectionUrl")).anyTimes();
         mockControl.replay();
 
         // create HttpClient that will return 301 Moved Permanently
         final IMocksControl httpClientMockControl = EasyMock.createNiceControl();
         final HttpClient httpClientMock = httpClientMockControl.createMock(HttpClient.class);
         httpClientMock.executeMethod(mockGetMethod);
         httpClientMockControl.andReturn(302).anyTimes();
         httpClientMockControl.replay();
 
         HttpClientRequest request = createMockRequest(httpClientMock, mockGetMethod, MethodType.GET, "http://url");
         request.setFollowRedirects(false);
                
         // now use it
         try
         {
             request.execute(EasyMock.createMock(ResponseHandler.class));
             
         }
         catch (ResponseException e)
         {
             fail(e.getMessage());
         }
 
         // and assert results
         mockControl.verify();
     }
 
     @Test
     public void testFollowRedirectForPostMethodsNotPossible() throws Exception
     {
         // create a request that will return mockGetMethod
         HttpClientRequest request = createMockRequest(MethodType.POST, "http://url");
         try
         {
             request.setFollowRedirects(true);
             fail("Should have thrown an exception because we can't follow redirects for Post methods");
         } catch (IllegalStateException ex)
         {
             //Expected
             assertEquals("Entity enclosing requests cannot be redirected without user intervention!", ex.getMessage());
         }
     }
 
     @Test
     public void testFollowRedirectForPutMethodsNotPossible() throws Exception
     {
         HttpClientRequest request = createMockRequest(MethodType.PUT, "http://url");
 
         try
         {
             request.setFollowRedirects(true);
             fail("Should have thrown an exception because we can't follow redirects for Post methods");
         } catch (IllegalStateException ex)
         {
             //Expected
             assertEquals("Entity enclosing requests cannot be redirected without user intervention!", ex.getMessage());
         }
     }
 
     @Test
     public void testExecutePostMethodNoFollowRedirects() throws Exception
     {
         final HttpClient httpClientMock = mock(HttpClient.class);
         final PostMethod postMethod = mock(PostMethod.class);
 
         HttpClientRequest request = createMockRequest(httpClientMock, postMethod, MethodType.POST, "http://url");
 
         request.execute(new ResponseHandler<HttpClientResponse>(){
             public void handle(final HttpClientResponse response) throws ResponseException
             {
 
             }
         });
         Mockito.verify(postMethod).setFollowRedirects(false);
     }
 
     @Test
     public void testExecutePutMethodNoFollowRedirects() throws Exception
     {
         final HttpClient httpClientMock = mock(HttpClient.class);
         final PutMethod putMethod = mock(PutMethod.class);
 
         HttpClientRequest request = createMockRequest(httpClientMock, putMethod, MethodType.PUT, "http://url");
 
         request.execute(new ResponseHandler<HttpClientResponse>(){
             public void handle(final HttpClientResponse response) throws ResponseException
             {
 
             }
         });
         Mockito.verify(putMethod).setFollowRedirects(false);
     }
 
     @Test
     public void testAddRequestParametersFails()
     {
         // Lets try to add parameters to GET method
         try
         {
             HttpClientRequest request = createMockRequest(MethodType.GET, "http://url");
             request.addRequestParameters("doIt", "quickly!");
             fail("Should throw exception that only the POST method can have parameters.");
         }
         catch (UnsupportedOperationException e)
         {
             // expected
         }
 
         // Lets try to add parameters to PUT method
         try
         {
             HttpClientRequest request = createMockRequest(MethodType.PUT, "http://url");
             request.addRequestParameters("Isaid", "doIt", "now");
             fail("Should throw exception that only the POST method can have parameters.");
         }
         catch (UnsupportedOperationException e)
         {
             // expected
         }
 
         // Lets try to add uneven amount of parameters to POST method
         try
         {
             HttpClientRequest request = createMockRequest(MethodType.POST, "http://url");
             request.addRequestParameters("doIt", "quickly!", "now");
             fail("Should throw exception that You must enter an even number of arguments.");
         }
         catch (IllegalArgumentException e)
         {
             // expected
         }
     }
 
     @Test
     public void testAddRequestParameters() throws IOException, ResponseException
     {
         // create mock PostMethod - someone should call addParamater() on it
         final IMocksControl mockControl = EasyMock.createNiceControl();
         final PostMethod mockPostMethod = mockControl.createMock(PostMethod.class);
         mockPostMethod.setRequestHeader("Content-type", "application/x-www-form-urlencoded; charset=UTF-8");
         mockPostMethod.addParameter("a", "b");
         mockPostMethod.addParameter("a", "b");
         mockPostMethod.addParameter("a", "c");
         mockPostMethod.addParameter("x", "y");
         mockControl.replay();
 
 
         final IMocksControl httpClientMockControl = EasyMock.createNiceControl();
         final HttpClient mockHttpClient = httpClientMockControl.createMock(HttpClient.class);
         httpClientMockControl.replay();
 
 
         // create a request that will return mockPostMethod
         HttpClientRequest request = createMockRequest(mockHttpClient, mockPostMethod, MethodType.POST, "http://url");
 
         // now use it
         request.addRequestParameters("a", "b", "a", "b", "a", "c", "x", "y");
         request.execute(EasyMock.createMock(ResponseHandler.class));
 
         // and assert results
         mockControl.verify();
     }
 
     private HttpClientRequest createMockRequest(MethodType methodType, String url)
     {
         return createMockRequest(EasyMock.createMock(HttpClient.class), methodType, url);
     }
 
     private HttpClientRequest createMockRequest(HttpClient client, MethodType methodType, String url)
     {
         return new HttpClientRequest(client, methodType, url,
                                      mock(CertificateFactory.class), mock(UserManager.class));
     }
 
     private HttpClientRequest createMockRequest(HttpClient client, final HttpMethod method, MethodType methodType,
                                                 String url)
     {
         return new HttpClientRequest(client, methodType, url, mock(CertificateFactory.class), mock(UserManager.class))
             {
                 @Override
                 protected HttpMethod makeMethod()
                 {
                     return method;
                 }
             };
     }
 }