gerrit.onap Code Review - so.git/blob

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