/**
 * Copyright 2017 ZTE Corporation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.onap.workflow.common;

import static org.powermock.api.mockito.PowerMockito.mock;

import java.io.IOException;

import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpRequest;
import org.apache.http.StatusLine;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.params.HttpParams;
import org.apache.http.protocol.HttpContext;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.onap.workflow.WorkflowAppConfig;
import org.onap.workflow.common.RestClient.HttpMethod;
import org.onap.workflow.entity.MsbClientConfig;
import org.onap.workflow.externalservice.entity.activitientitiy.ActivitiStartProcessRequest;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;


@PrepareForTest({HttpClients.class})
@RunWith(PowerMockRunner.class)
public class RestClientTest {
  @Test
  public void testExecuteHttp() throws Exception {
    HttpEntity httpEntity = mock(HttpEntity.class);
    PowerMockito.mockStatic(HttpClients.class);
    CloseableHttpClient httpclient = mock(CloseableHttpClient.class);
    PowerMockito.when(HttpClients.createDefault()).thenReturn(httpclient);
    PowerMockito.when(httpclient.execute(Mockito.any(HttpHost.class), Mockito.any(HttpRequest.class)))
        .thenThrow(new IOException());
    try{
    RestClient.executeHttp(HttpMethod.POST, "127.0.0.1", 80, "test", httpEntity);
    }catch(IOException e){
      Assert.assertTrue(true);
    }
  }

  @Test
  public void testExecuteHttpException() throws Exception {
    HttpEntity httpEntity = mock(HttpEntity.class);
    PowerMockito.mockStatic(HttpClients.class);
    CloseableHttpClient tt = mock(CloseableHttpClient.class);
    CloseableHttpResponse reponse = mock(CloseableHttpResponse.class);
    StatusLine sl = mock(StatusLine.class);
    PowerMockito.when(HttpClients.createDefault()).thenReturn(tt);
    PowerMockito.when(tt.execute(Mockito.any(HttpHost.class), Mockito.any(HttpRequest.class)))
        .thenReturn(reponse);
    PowerMockito.when(reponse.getEntity()).thenReturn(httpEntity);
    PowerMockito.when(reponse.getStatusLine()).thenReturn(sl);
    RestClient.executeHttp(HttpMethod.POST, "127.0.0.1", 80, "test", httpEntity);
    
    WorkflowAppConfig workflowconfig = makeWorkFlowConfig("127.0.0.1", 80);
    Config.setWorkflowAppConfig(workflowconfig);
    RestClient.executeHttp(HttpMethod.POST, null, null, "test", httpEntity);
  }
  
  private WorkflowAppConfig makeWorkFlowConfig(String msbSvrIp, int msbSvrPort) {
    MsbClientConfig msbClientConfig = new MsbClientConfig();
    msbClientConfig.setMsbSvrIp(msbSvrIp);
    msbClientConfig.setMsbSvrPort(msbSvrPort);
    WorkflowAppConfig workflowconfig = new WorkflowAppConfig();
    workflowconfig.setMsbClientConfig(msbClientConfig);
    return workflowconfig;
  }
  
  @Test
  public void testExecuteHttpDeleteDeploy() throws Exception {
    HttpEntity httpEntity = mock(HttpEntity.class);
    PowerMockito.mockStatic(HttpClients.class);
    CloseableHttpClient tt = mock(CloseableHttpClient.class);
    CloseableHttpResponse reponse = mock(CloseableHttpResponse.class);
    PowerMockito.when(HttpClients.createDefault()).thenReturn(tt);
    PowerMockito.when(tt.execute(Mockito.any(HttpHost.class), Mockito.any(HttpRequest.class)))
        .thenReturn(reponse);
    PowerMockito.when(reponse.getEntity()).thenReturn(httpEntity);
    RestClient.executeHttpDeleteDeploy(HttpMethod.DELETE, "127.0.0.1", 80, "test");
    
    WorkflowAppConfig workflowconfig = makeWorkFlowConfig("127.0.0.1", 80);
    Config.setWorkflowAppConfig(workflowconfig);
    RestClient.executeHttpDeleteDeploy(HttpMethod.DELETE, null, null, "test");
  }

  @Test
  public void testExecuteHttpStartIntance() throws Exception {
    ActivitiStartProcessRequest activitiStartProcessRequest =
        mock(ActivitiStartProcessRequest.class);

    HttpEntity httpEntity = mock(HttpEntity.class);
    PowerMockito.mockStatic(HttpClients.class);
    CloseableHttpClient tt = mock(CloseableHttpClient.class);
    CloseableHttpResponse reponse = mock(CloseableHttpResponse.class);
    PowerMockito.when(HttpClients.createDefault()).thenReturn(tt);
    PowerMockito.when(tt.execute(Mockito.any(HttpHost.class), Mockito.any(HttpRequest.class)))
        .thenReturn(reponse);
    PowerMockito.when(reponse.getEntity()).thenReturn(httpEntity);
    RestClient.executeHttpStartIntance(HttpMethod.POST, "127.0.0.1", 80, "test",activitiStartProcessRequest);

    WorkflowAppConfig workflowconfig = makeWorkFlowConfig("127.0.0.1", 80);
    Config.setWorkflowAppConfig(workflowconfig);
    RestClient.executeHttpStartIntance(HttpMethod.POST, null, null, "test", activitiStartProcessRequest);
  }
  
  @Test
  public void testgetRequest() {
    HttpRequest request = RestClient.getRequest(HttpMethod.GET, "/test/", null);
    Assert.assertTrue (request.getRequestLine().getMethod().equals(HttpMethod.GET.toString()));
    request = RestClient.getRequest(HttpMethod.POST, "/test/", null);
    Assert.assertTrue (request.getRequestLine().getMethod().equals(HttpMethod.POST.toString()));
    request = RestClient.getRequest(HttpMethod.DELETE, "/test/", null);
    Assert.assertTrue (request.getRequestLine().getMethod().equals(HttpMethod.DELETE.toString()));
    request = RestClient.getRequest(HttpMethod.PUT, "/test/", null);
    Assert.assertTrue (request.getRequestLine().getMethod().equals(HttpMethod.PUT.toString()));
    try {
      request = RestClient.getRequest(null, "/test/", null);
    } catch (NullPointerException e) {
      Assert.assertTrue (true);
    }
  }
  
  @Test
  public void testPost() throws Exception {
    HttpEntity httpEntity = mock(HttpEntity.class);
    PowerMockito.mockStatic(HttpClients.class);
    CloseableHttpClient tt = mock(CloseableHttpClient.class);
    CloseableHttpResponse reponse = mock(CloseableHttpResponse.class);
    
    PowerMockito.when(HttpClients.createDefault()).thenReturn(tt);
    PowerMockito.when(tt.execute(Mockito.any(HttpHost.class), Mockito.any(HttpRequest.class)))
        .thenReturn(reponse);
    PowerMockito.when(reponse.getEntity()).thenReturn(httpEntity);
    WorkflowAppConfig workflowconfig = makeWorkFlowConfig("127.0.0.1", 80);
    Config.setWorkflowAppConfig(workflowconfig);
    RestClient.post("127.0.0.1", 80, "test", null);
    RestClient.post("127.0.0.1", 80, "test");
  }
  
  @Test
  public void testCloseHttpClient(){
    Assert.assertTrue(RestClient.closeHttpClient(mock(CloseableHttpClient.class)));
    Assert.assertTrue(RestClient.closeHttpClient(null));
    Assert.assertFalse(RestClient.closeHttpClient(new CloseableHttpClientTest()));
  }
  
  public class CloseableHttpClientTest extends CloseableHttpClient{
    @Override
    public void close() throws IOException {
      throw new IOException();
    }

    @Override
    protected CloseableHttpResponse doExecute(HttpHost target, HttpRequest request,
        HttpContext context) throws IOException, ClientProtocolException {
      return null;
    }

    @SuppressWarnings("deprecation")
    @Override
    public HttpParams getParams() {
      return null;
    }

    @SuppressWarnings("deprecation")
    @Override
    public ClientConnectionManager getConnectionManager() {
      return null;
    }
  }
}