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.aaiclient.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         request.setRequestorId("testRequestorId");
  56         Map<String, String> reqConfigParams = new HashMap<>();
  57         reqConfigParams.put("name1", "value1");
  58         reqConfigParams.put("name2", "value2");
  59         request.setConfigParams(reqConfigParams);
  60         ApplicationControllerVnf applicationControllerVnf = new ApplicationControllerVnf();
  61         applicationControllerVnf.setVnfHostIpAddress("100.100");
  62         applicationControllerVnf.setVnfId("testVnfId");
  63         applicationControllerVnf.setVnfName("testVnfName");
  64         request.setApplicationControllerVnf(applicationControllerVnf);
  65         listener = new ApplicationControllerCallback(null, null, null);
  66
  67     }
  68
  69     @Test
  70     public void testExcute_healthCheck() throws JsonProcessingException, ApplicationControllerOrchestratorException {
  71         request.setAction(Action.HealthCheck);
  72
  73         Parameters parameters = new Parameters();
  74         RequestParameters requestParams = new RequestParameters();
  75         requestParams.setHostIpAddress(request.getApplicationControllerVnf().getVnfHostIpAddress());
  76         parameters.setRequestParameters(requestParams);
  77         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
  78
  79         Mockito.when(applicationControllerClient.vnfCommand(Action.HealthCheck, "testRequestId",
  80                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
  81                 listener, "testRequestorId")).thenReturn(new Status());
  82
  83         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
  84
  85         Mockito.verify(applicationControllerClient).vnfCommand(Action.HealthCheck, "testRequestId",
  86                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
  87                 listener, "testRequestorId");
  88
  89     }
  90
  91     @Test
  92     public void testExcute_resumeTraffic() throws JsonProcessingException, ApplicationControllerOrchestratorException {
  93         request.setAction(Action.ResumeTraffic);
  94
  95         Parameters parameters = new Parameters();
  96         ConfigurationParameters configParams = new ConfigurationParameters();
  97         configParams.setVnfName(request.getApplicationControllerVnf().getVnfName());
  98         parameters.setConfigurationParameters(configParams);
  99         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
 100
 101         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 102                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 103                 listener, "testRequestorId")).thenReturn(new Status());
 104
 105         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 106
 107         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 108                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 109                 listener, "testRequestorId");
 110     }
 111
 112     @Test
 113     public void testExcute_stop() throws JsonProcessingException, ApplicationControllerOrchestratorException {
 114         request.setAction(Action.Stop);
 115
 116         Identity identity = new Identity();
 117         identity.setIdentityUrl(request.getIdentityUrl());
 118         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(identity)));
 119
 120         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 121                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 122                 listener, "testRequestorId")).thenReturn(new Status());
 123
 124         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 125
 126         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 127                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 128                 listener, "testRequestorId");
 129     }
 130
 131     @Test
 132     public void testExcute_lock() throws JsonProcessingException, ApplicationControllerOrchestratorException {
 133         request.setAction(Action.Lock);
 134
 135         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 136                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), Optional.empty(),
 137                 "testControllerType", listener, "testRequestorId")).thenReturn(new Status());
 138
 139         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 140
 141         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 142                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), Optional.empty(),
 143                 "testControllerType", listener, "testRequestorId");
 144     }
 145
 146     @Test
 147     public void testExcute_quiesceTraffic() throws JsonProcessingException, ApplicationControllerOrchestratorException {
 148         request.setAction(Action.QuiesceTraffic);
 149
 150
 151         Parameters parameters = new Parameters();
 152         parameters.setOperationsTimeout(request.getOperationsTimeout());
 153         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
 154         System.out.println("PAYLOAD is: " + payload.get());
 155
 156         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 157                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 158                 listener, "testRequestorId")).thenReturn(new Status());
 159
 160         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 161
 162         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 163                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 164                 listener, "testRequestorId");
 165     }
 166
 167     @Test
 168     public void testExcute_distributeTraffic()
 169             throws JsonProcessingException, ApplicationControllerOrchestratorException {
 170         request.setAction(Action.DistributeTraffic);
 171
 172         Parameters parameters = new Parameters();
 173         ConfigurationParameters configParams = new ConfigurationParameters();
 174         configParams.setBookName(request.getBookName());
 175         configParams.setNodeList(request.getNodeList());
 176         configParams.setFileParameterContent(request.getFileParameters());
 177         configParams.setVnfName(request.getApplicationControllerVnf().getVnfName());
 178         parameters.setConfigurationParameters(configParams);
 179         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
 180
 181         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 182                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 183                 listener, "testRequestorId")).thenReturn(new Status());
 184
 185         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 186
 187         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 188                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 189                 listener, "testRequestorId");
 190     }
 191
 192     @Test
 193     public void testExcute_distributeTrafficCheck()
 194             throws JsonProcessingException, ApplicationControllerOrchestratorException {
 195         request.setAction(Action.DistributeTrafficCheck);
 196
 197         Parameters parameters = new Parameters();
 198         ConfigurationParameters configParams = new ConfigurationParameters();
 199         configParams.setBookName(request.getBookName());
 200         configParams.setNodeList(request.getNodeList());
 201         configParams.setFileParameterContent(request.getFileParameters());
 202         configParams.setVnfName(request.getApplicationControllerVnf().getVnfName());
 203         parameters.setConfigurationParameters(configParams);
 204         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
 205
 206         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 207                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 208                 listener, "testRequestorId")).thenReturn(new Status());
 209
 210         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 211
 212         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 213                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 214                 listener, "testRequestorId");
 215     }
 216
 217     @Test
 218     public void testExcute_upgradeBackup() throws JsonProcessingException, ApplicationControllerOrchestratorException {
 219         request.setAction(Action.UpgradeBackup);
 220
 221         Parameters parameters = new Parameters();
 222         parameters.setExistingSoftwareVersion(request.getExistingSoftwareVersion());
 223         parameters.setNewSoftwareVersion(request.getNewSoftwareVersion());
 224         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
 225
 226         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 227                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 228                 listener, "testRequestorId")).thenReturn(new Status());
 229
 230         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 231
 232         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 233                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 234                 listener, "testRequestorId");
 235     }
 236
 237     @Test
 238     public void testExcute_configModify() throws JsonProcessingException, ApplicationControllerOrchestratorException {
 239         request.setAction(Action.ConfigModify);
 240
 241         Parameters parameters = new Parameters();
 242         RequestParameters requestParams = new RequestParameters();
 243         requestParams.setHostIpAddress(request.getApplicationControllerVnf().getVnfHostIpAddress());
 244         parameters.setRequestParameters(requestParams);
 245         ConfigurationParameters configParams = new ConfigurationParameters();
 246         Map<String, String> configParamMap = new HashMap<>();
 247         configParamMap.put("name1", "value1");
 248         configParamMap.put("name2", "value2");
 249         configParams.setAdditionalProperties(configParamMap);
 250         parameters.setConfigurationParameters(configParams);
 251         Optional<String> payload = Optional.of((mapper.getMapper().writeValueAsString(parameters)));
 252
 253         Mockito.when(applicationControllerClient.vnfCommand(request.getAction(), "testRequestId",
 254                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 255                 listener, "testRequestorId")).thenReturn(new Status());
 256
 257         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 258
 259         Mockito.verify(applicationControllerClient).vnfCommand(request.getAction(), "testRequestId",
 260                 request.getApplicationControllerVnf().getVnfId(), Optional.empty(), payload, "testControllerType",
 261                 listener, "testRequestorId");
 262     }
 263
 264     @Test
 265     public void testListener() throws Exception {
 266         request.setAction(Action.QuiesceTraffic);
 267         Status status = applicationControllerTaskImpl.execute("testRequestId", request, listener);
 268     }
 269
 270 }