gerrit.onap Code Review - so.git/blob

   1 package org.onap.so.adapters.appc.orchestrator.service;
   2
   3 import java.util.Optional;
   4 import org.junit.Before;
   5 import org.junit.Test;
   6 import org.junit.runner.RunWith;
   7 import org.mockito.InjectMocks;
   8 import org.mockito.Mock;
   9 import org.mockito.Mockito;
  10 import org.mockito.Spy;
  11 import org.mockito.junit.MockitoJUnitRunner;
  12 import org.onap.appc.client.lcm.model.Status;
  13 import org.onap.so.adapters.appc.orchestrator.client.ApplicationControllerCallback;
  14 import org.onap.so.adapters.appc.orchestrator.client.ApplicationControllerClient;
  15 import org.onap.so.adapters.appc.orchestrator.client.ApplicationControllerOrchestratorException;
  16 import org.onap.so.adapters.appc.orchestrator.client.beans.ConfigurationParameters;
  17 import org.onap.so.adapters.appc.orchestrator.client.beans.Identity;
  18 import org.onap.so.adapters.appc.orchestrator.client.beans.Parameters;
  19 import org.onap.so.adapters.appc.orchestrator.client.beans.RequestParameters;
  20 import org.onap.so.adapters.appc.orchestrator.service.ApplicationControllerTaskImpl;
  21 import org.onap.so.appc.orchestrator.service.beans.ApplicationControllerTaskRequest;
  22 import org.onap.so.appc.orchestrator.service.beans.ApplicationControllerVnf;
  23 import org.onap.so.client.graphinventory.GraphInventoryCommonObjectMapperProvider;
  24 import com.fasterxml.jackson.core.JsonProcessingException;
  25 import org.onap.appc.client.lcm.model.Action;
  26
  27 @RunWith(MockitoJUnitRunner.class)
  28 public class ApplicationControllerTaskImplTest {
  29
  30     @Mock
  31     ApplicationControllerClient applicationControllerClient;
  32
  33     @InjectMocks
  34     @Spy
  35     ApplicationControllerTaskImpl applicationControllerTaskImpl;
  36
  37     ApplicationControllerTaskRequest request;
  38
  39     ApplicationControllerCallback listener;
  40
  41     GraphInventoryCommonObjectMapperProvider mapper = new GraphInventoryCommonObjectMapperProvider();
  42
  43     @Before
  44     public void setup() {
  45         request = new ApplicationControllerTaskRequest();
  46         request.setBookName("testBookName");
  47         request.setControllerType("testControllerType");
  48         request.setFileParameters("testFileParams");
  49         request.setIdentityUrl("testIdentityUrl");
  50         request.setNewSoftwareVersion("2.0");
  51         request.setExistingSoftwareVersion("1.0");
  52         request.setOperationsTimeout("30");
  53         ApplicationControllerVnf applicationControllerVnf = new ApplicationControllerVnf();
  54         applicationControllerVnf.setVnfHostIpAddress("100.100");
  55         applicationControllerVnf.setVnfId("testVnfId");
  56         applicationControllerVnf.setVnfName("testVnfName");
  57         request.setApplicationControllerVnf(applicationControllerVnf);
  58         listener = new ApplicationControllerCallback(null, null, null);
  59
  60     }
  61
  62     @Test
  63     public void testExcute_healthCheck() throws JsonProcessingException, ApplicationControllerOrchestratorException {
  64         request.setAction(Action.HealthCheck);
  65
  66         Parameters parameters = new Parameters();
  67         RequestParameters requestParams = new RequestParameters();
  68         requestParams.setHostIpAddress(request.getApplicationControllerVnf().getVnfHostIpAddress());
  69         parameters.setRequestParameters(requestParams);
  70         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
  71
  72         Mockito.when(applicationControllerClient.vnfCommand(Action.HealthCheck, "testRequestId",
  73                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
  74                 listener)).thenReturn(new Status());
  75
  76         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
  77
  78         Mockito.verify(applicationControllerClient).vnfCommand(Action.HealthCheck, "testRequestId",
  79                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
  80                 listener);
  81
  82     }
  83
  84     @Test
  85     public void testExcute_resumeTraffic() throws JsonProcessingException, ApplicationControllerOrchestratorException {
  86         request.setAction(Action.ResumeTraffic);
  87
  88         Parameters parameters = new Parameters();
  89         ConfigurationParameters configParams = new ConfigurationParameters();
  90         configParams.setVnfName(request.getApplicationControllerVnf().getVnfName());
  91         parameters.setConfigurationParameters(configParams);
  92         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
  93
  94         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
  95                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
  96                 listener)).thenReturn(new Status());
  97
  98         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
  99
 100         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 101                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 102                 listener);
 103     }
 104
 105     @Test
 106     public void testExcute_stop() throws JsonProcessingException, ApplicationControllerOrchestratorException {
 107         request.setAction(Action.Stop);
 108
 109         Identity identity = new Identity();
 110         identity.setIdentityUrl(request.getIdentityUrl());
 111         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(identity)));
 112
 113         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 114                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 115                 listener)).thenReturn(new Status());
 116
 117         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 118
 119         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 120                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 121                 listener);
 122     }
 123
 124     @Test
 125     public void testExcute_lock() throws JsonProcessingException, ApplicationControllerOrchestratorException {
 126         request.setAction(Action.Lock);
 127
 128         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 129                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), Optional.empty(),
 130                 "testControllerType", listener)).thenReturn(new Status());
 131
 132         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 133
 134         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 135                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), Optional.empty(),
 136                 "testControllerType", listener);
 137     }
 138
 139     @Test
 140     public void testExcute_quiesceTraffic() throws JsonProcessingException, ApplicationControllerOrchestratorException {
 141         request.setAction(Action.QuiesceTraffic);
 142
 143
 144         Parameters parameters = new Parameters();
 145         parameters.setOperationsTimeout(request.getOperationsTimeout());
 146         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
 147         System.out.println("PAYLOAD is: " + payload.get());
 148
 149         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 150                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 151                 listener)).thenReturn(new Status());
 152
 153         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 154
 155         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 156                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 157                 listener);
 158     }
 159
 160     @Test
 161     public void testExcute_distributeTraffic()
 162             throws JsonProcessingException, ApplicationControllerOrchestratorException {
 163         request.setAction(Action.DistributeTraffic);
 164
 165         Parameters parameters = new Parameters();
 166         ConfigurationParameters configParams = new ConfigurationParameters();
 167         configParams.setBookName(request.getBookName());
 168         configParams.setNodeList(request.getNodeList());
 169         configParams.setFileParameterContent(request.getFileParameters());
 170         configParams.setVnfName(request.getApplicationControllerVnf().getVnfName());
 171         parameters.setConfigurationParameters(configParams);
 172         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
 173
 174         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 175                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 176                 listener)).thenReturn(new Status());
 177
 178         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 179
 180         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 181                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 182                 listener);
 183     }
 184
 185     @Test
 186     public void testExcute_distributeTrafficCheck()
 187             throws JsonProcessingException, ApplicationControllerOrchestratorException {
 188         request.setAction(Action.DistributeTrafficCheck);
 189
 190         Parameters parameters = new Parameters();
 191         ConfigurationParameters configParams = new ConfigurationParameters();
 192         configParams.setBookName(request.getBookName());
 193         configParams.setNodeList(request.getNodeList());
 194         configParams.setFileParameterContent(request.getFileParameters());
 195         configParams.setVnfName(request.getApplicationControllerVnf().getVnfName());
 196         parameters.setConfigurationParameters(configParams);
 197         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
 198
 199         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 200                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 201                 listener)).thenReturn(new Status());
 202
 203         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 204
 205         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 206                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 207                 listener);
 208     }
 209
 210     @Test
 211     public void testExcute_upgradeBackup() throws JsonProcessingException, ApplicationControllerOrchestratorException {
 212         request.setAction(Action.UpgradeBackup);
 213
 214         Parameters parameters = new Parameters();
 215         parameters.setExistingSoftwareVersion(request.getExistingSoftwareVersion());
 216         parameters.setNewSoftwareVersion(request.getNewSoftwareVersion());
 217         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
 218
 219         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 220                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 221                 listener)).thenReturn(new Status());
 222
 223         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 224
 225         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 226                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 227                 listener);
 228     }
 229
 230     @Test
 231     public void testListener() throws Exception {
 232         request.setAction(Action.QuiesceTraffic);
 233         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 234     }
 235
 236 }