adapters/mso-network-adapter/src/test/java/org/openecomp/mso/adapters/network/NetworkAdapterRestTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.mso.adapters.network;
  22
  23 import static org.junit.Assert.*;
  24 import java.util.ArrayList;
  25 import java.util.Arrays;
  26 import java.util.HashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29
  30 import javax.ws.rs.core.Response;
  31 import javax.xml.ws.Holder;
  32
  33 import org.apache.http.HttpStatus;
  34 import org.apache.http.protocol.HTTP;
  35 import org.junit.Ignore;
  36 import org.junit.Test;
  37 import org.junit.runner.RunWith;
  38 import org.mockito.Mock;
  39 import org.mockito.Mockito;
  40 import org.mockito.invocation.InvocationOnMock;
  41 import org.mockito.stubbing.Answer;
  42 import org.openecomp.mso.adapters.network.NetworkAdapterRest.CreateNetworkTask;
  43 import org.openecomp.mso.adapters.network.NetworkAdapterRest.DeleteNetworkTask;
  44 import org.openecomp.mso.adapters.network.NetworkAdapterRest.RollbackNetworkTask;
  45 import org.openecomp.mso.adapters.network.NetworkAdapterRest.UpdateNetworkTask;
  46 import org.openecomp.mso.adapters.network.exceptions.NetworkException;
  47 import org.openecomp.mso.adapters.nwrest.ContrailNetwork;
  48 import org.openecomp.mso.adapters.nwrest.CreateNetworkRequest;
  49 import org.openecomp.mso.adapters.nwrest.CreateNetworkResponse;
  50 import org.openecomp.mso.adapters.nwrest.DeleteNetworkRequest;
  51 import org.openecomp.mso.adapters.nwrest.NetworkTechnology;
  52 import org.openecomp.mso.adapters.nwrest.ProviderVlanNetwork;
  53 import org.openecomp.mso.adapters.nwrest.QueryNetworkResponse;
  54 import org.openecomp.mso.adapters.nwrest.RollbackNetworkRequest;
  55 import org.openecomp.mso.adapters.nwrest.UpdateNetworkRequest;
  56 import org.openecomp.mso.adapters.nwrest.UpdateNetworkResponse;
  57 import org.openecomp.mso.cloud.CloudConfigFactory;
  58 import org.openecomp.mso.entity.MsoRequest;
  59 import org.openecomp.mso.openstack.beans.NetworkRollback;
  60 import org.openecomp.mso.openstack.beans.NetworkStatus;
  61 import org.openecomp.mso.openstack.beans.RouteTarget;
  62 import org.openecomp.mso.openstack.beans.Subnet;
  63 import org.openecomp.mso.properties.MsoPropertiesFactory;
  64 import org.powermock.api.mockito.PowerMockito;
  65 import org.powermock.core.classloader.annotations.PrepareForTest;
  66 import org.powermock.modules.junit4.PowerMockRunner;
  67
  68 @RunWith(PowerMockRunner.class)
  69 @PrepareForTest({NetworkAdapterRest.class, CreateNetworkTask.class, CreateNetworkRequest.class, DeleteNetworkTask.class, DeleteNetworkRequest.class})
  70 public class NetworkAdapterRestTest {
  71         @Mock
  72         private static CreateNetworkTask taskMock;
  73         @Mock
  74         private static CreateNetworkRequest reqMock;
  75         @Mock
  76         private static DeleteNetworkRequest delReqMock;
  77         @Mock
  78         private static DeleteNetworkTask delTaskMock;
  79         @Mock
  80         private static RollbackNetworkRequest rollbackReqMock;
  81         @Mock
  82         private static RollbackNetworkTask rollbackTaskMock;
  83
  84         private static final String TESTING_KEYWORD = "___TESTING___";
  85
  86         @Test
  87         public void NetworkAdapterRest_createNetwork_async_Test()
  88         {
  89                 NetworkAdapterRest api = new NetworkAdapterRest();
  90                 taskMock = PowerMockito.mock(CreateNetworkTask.class);
  91                 reqMock = PowerMockito.mock(CreateNetworkRequest.class);
  92
  93                 try {
  94                         PowerMockito.whenNew(CreateNetworkRequest.class).withAnyArguments().thenReturn(reqMock);
  95                         PowerMockito.when(reqMock.isSynchronous()).thenReturn(false);
  96                         PowerMockito.when(reqMock.getNetworkId()).thenReturn("b4a6af8c-a22b-45d5-a880-29527f8f59a7");
  97                         PowerMockito.when(reqMock.getCloudSiteId()).thenReturn(TESTING_KEYWORD);
  98                         PowerMockito.when(reqMock.getTenantId()).thenReturn("b4a6af8c-a22b-45d5-a880-29527f8f59a7");
  99                         PowerMockito.when(reqMock.getNetworkType()).thenReturn("PROVIDER");
 100                         PowerMockito.when(reqMock.getModelCustomizationUuid()).thenReturn("modelCustUuid");
 101                         PowerMockito.when(reqMock.getNetworkName()).thenReturn("networkName");
 102
 103                         ProviderVlanNetwork vlan = new ProviderVlanNetwork();
 104                         vlan.setPhysicalNetworkName("PhysicalNetworkName");
 105                         vlan.setVlans(new ArrayList<Integer>(Arrays.asList(123,456,654,321)));
 106                         PowerMockito.when(reqMock.getProviderVlanNetwork()).thenReturn(vlan);
 107
 108                         PowerMockito.when(reqMock.getFailIfExists()).thenReturn(true);
 109                         PowerMockito.when(reqMock.getBackout()).thenReturn(false);
 110
 111                         List<Subnet> subnets = new ArrayList<Subnet>();
 112                         Subnet s1 = new Subnet();
 113                         s1.setSubnetName("Subnet1");
 114                         subnets.add(s1);
 115                         Subnet s2 = new Subnet();
 116                         s1.setSubnetName("Subnet2");
 117                         subnets.add(s2);
 118                         Subnet s3 = new Subnet();
 119                         s1.setSubnetName("Subnet3");
 120                         subnets.add(s3);
 121                         PowerMockito.when(reqMock.getSubnets()).thenReturn(subnets);
 122
 123                         MsoRequest msoRequest = new MsoRequest ();
 124                         msoRequest.setRequestId("MSORequestID123");
 125                         PowerMockito.when(reqMock.getMsoRequest()).thenReturn(msoRequest);
 126                         // setup spy on CreateNetworkTask
 127
 128                         PowerMockito.whenNew(CreateNetworkTask.class).withArguments(reqMock).thenReturn(taskMock);
 129                         PowerMockito.spy(taskMock);
 130
 131                         Response resp = api.createNetwork(new CreateNetworkRequest());
 132                         assertEquals(resp.getStatus(),HttpStatus.SC_ACCEPTED);
 133
 134                         // test if another thread has executed run method
 135                         //Mockito.verify(taskMock, Mockito.times(1)).run();
 136
 137                 } catch (Exception e) {
 138                         e.printStackTrace();
 139                 }
 140
 141
 142         }
 143
 144         @Test
 145         public void NetworkAdapterRest_createNetwork_sync_Test()
 146         {
 147                 NetworkAdapterRest api = new NetworkAdapterRest();
 148                 // setup createNetwork parameter
 149                 // setup sync to spy on run method
 150                 CreateNetworkRequest req = new CreateNetworkRequest();
 151                 req.setNetworkId("b4a6af8c-a22b-45d5-a880-29527f8f59a7");
 152                 req.setCloudSiteId(TESTING_KEYWORD);
 153                 req.setTenantId("b4a6af8c-a22b-45d5-a880-29527f8f59a7");
 154                 req.setNetworkType("PROVIDER");
 155                 req.setModelCustomizationUuid("modelCustUuid");
 156                 req.setNetworkName("networkName");
 157                 ProviderVlanNetwork vlan = new ProviderVlanNetwork();
 158                 vlan.setPhysicalNetworkName("PhysicalNetworkName");
 159                 vlan.setVlans(new ArrayList<Integer>(Arrays.asList(123,456,654,321)));
 160                 req.setProviderVlanNetwork(vlan);
 161                 req.setFailIfExists(true);
 162                 req.setBackout(false);
 163                 List<Subnet> subnets = new ArrayList<Subnet>();
 164                 Subnet s1 = new Subnet();
 165                 s1.setSubnetName("Subnet1");
 166                 subnets.add(s1);
 167                 Subnet s2 = new Subnet();
 168                 s1.setSubnetName("Subnet2");
 169                 subnets.add(s2);
 170                 Subnet s3 = new Subnet();
 171                 s1.setSubnetName("Subnet3");
 172                 subnets.add(s3);
 173                 req.setSubnets(subnets);
 174                 MsoRequest msoRequest = new MsoRequest ();
 175                 msoRequest.setRequestId("MSORequestID123");
 176                 req.setMsoRequest(msoRequest);
 177                 // set sync
 178                 req.setNotificationUrl(null);
 179                 // setup spy on CreateNetworkTask
 180                 CreateNetworkTask task = api.new CreateNetworkTask(req);
 181
 182                 try {
 183                         PowerMockito.whenNew(CreateNetworkTask.class).withArguments(req).thenReturn(task);
 184                         Response resp = api.createNetwork(req);
 185
 186                         CreateNetworkResponse cnresp = (CreateNetworkResponse) resp.getEntity();
 187
 188                         assertEquals(cnresp.getNetworkFqdn(), "086f70b6-28fb-11e6-8260-0017f20fe1b8");
 189                         assertEquals(cnresp.getNetworkId(), "b4a6af8c-a22b-45d5-a880-29527f8f59a7");
 190                         assertEquals(cnresp.getNeutronNetworkId(), "55e55884-28fa-11e6-8971-0017f20fe1b8");
 191                         assertEquals(resp.getStatus(), HttpStatus.SC_OK);
 192
 193                 } catch (Exception e) {
 194                         e.printStackTrace();
 195                 }
 196         }
 197
 198         @Test
 199         public void NetworkAdapterRest_deleteNetwork_async_Test()
 200         {
 201                 NetworkAdapterRest api = new NetworkAdapterRest();
 202                 delTaskMock = PowerMockito.mock(DeleteNetworkTask.class);
 203                 delReqMock = PowerMockito.mock(DeleteNetworkRequest.class);
 204
 205                 try{
 206                         PowerMockito.whenNew(DeleteNetworkRequest.class).withAnyArguments().thenReturn(delReqMock);
 207                         PowerMockito.when(delReqMock.isSynchronous()).thenReturn(false);
 208                         PowerMockito.when(delReqMock.getCloudSiteId()).thenReturn(TESTING_KEYWORD);
 209                         PowerMockito.when(delReqMock.getNetworkId()).thenReturn("b4a6af8c-a22b-45d5-a880-29527f8f59a7");
 210                         PowerMockito.when(delReqMock.getMessageId()).thenReturn("b4a6af8c-a22b-45d5-a880-29527f8f59a7");
 211
 212                         PowerMockito.whenNew(DeleteNetworkTask.class).withArguments(delReqMock).thenReturn(delTaskMock);
 213                         PowerMockito.spy(delTaskMock);
 214
 215                         Response resp = api.deleteNetwork("b4a6af8c-a22b-45d5-a880-29527f8f59a7", delReqMock);
 216                         assertEquals(resp.getStatus(), HttpStatus.SC_ACCEPTED);
 217
 218                         // test if another thread has executed run method
 219                         // Mockito.verify(delTaskMock, Mockito.times(1)).run();
 220
 221                 }
 222                 catch(Exception e)
 223                 {
 224                         e.printStackTrace();
 225                 }
 226         }
 227
 228         @Test
 229         public void NetworkAdapterRest_deleteNetwork_sync_Test()
 230         {
 231                 NetworkAdapterRest api = new NetworkAdapterRest();
 232                 DeleteNetworkRequest req = new DeleteNetworkRequest();
 233                 req.setNotificationUrl(null);
 234                 req.setCloudSiteId(TESTING_KEYWORD);
 235                 req.setNetworkId("b4a6af8c-a22b-45d5-a880-29527f8f59a7");
 236                 req.setMessageId("b4a6af8c-a22b-45d5-a880-29527f8f59a7");
 237
 238                 DeleteNetworkTask task = api.new DeleteNetworkTask(req);
 239
 240                 try {
 241                         PowerMockito.whenNew(DeleteNetworkTask.class).withArguments(req).thenReturn(task);
 242                         PowerMockito.spy(task);
 243                         Response resp = api.deleteNetwork("b4a6af8c-a22b-45d5-a880-29527f8f59a7", req);
 244
 245                         assertEquals(resp.getStatus(), HttpStatus.SC_OK);
 246
 247                 } catch (Exception e) {
 248                         e.printStackTrace();
 249                 }
 250         }
 251
 252         @Test
 253         public void NetworkAdapterRest_queryNetwork_Test()
 254         {
 255                 /*
 256                  * test when network found as well as network not found
 257                  */
 258                 String networkStackId = "networkStackId";
 259                 String skipAAI = "skipAAI";
 260                 String requestId = "msoRequest.requestId";
 261                 String serviceInstanceId = "msoRequest.serviceInstanceId";
 262                 String aaiNetworkId = "aaiNetworkId";
 263                 String cloudSiteId = "cloudSiteId";
 264                 String tenantId = "tenantId";
 265                 String networkNameOrId = "networkNameOrId";
 266                 MsoRequest msoRequestMock = Mockito.mock(MsoRequest.class);
 267                 try {
 268                         PowerMockito.whenNew(MsoRequest.class).withArguments("msoRequest.requestId", "msoRequest.serviceInstanceId").thenReturn(msoRequestMock);
 269
 270                 } catch (Exception e1) {
 271                         e1.printStackTrace();
 272                 }
 273                 MsoRequest msoRequest = new MsoRequest("msoRequest.requestId", "msoRequest.serviceInstanceId");
 274                 Holder<Boolean> networkExists = new Holder<Boolean>();
 275         Holder<String> networkId = new Holder<String>();
 276         Holder<String> neutronNetworkId = new Holder<String>();
 277         Holder<NetworkStatus> status = new Holder<NetworkStatus>();
 278         Holder<List<String>> routeTargets = new Holder<List<String>>();
 279         Holder<Map<String, String>> subnetIdMap = new Holder<Map<String, String>>();
 280
 281                 MsoNetworkAdapterImpl mockImpl = Mockito.mock(MsoNetworkAdapterImpl.class);
 282                 CloudConfigFactory cloudConfigMock = Mockito.mock(CloudConfigFactory.class);
 283                 MsoPropertiesFactory msoPropertiesFactoryMock = Mockito.mock(MsoPropertiesFactory.class);
 284
 285                 try {
 286                         PowerMockito.whenNew(MsoPropertiesFactory.class).withAnyArguments().thenReturn(msoPropertiesFactoryMock);
 287                         PowerMockito.whenNew(CloudConfigFactory.class).withAnyArguments().thenReturn(cloudConfigMock);
 288                         PowerMockito.whenNew(MsoNetworkAdapterImpl.class).withArguments(msoPropertiesFactoryMock, cloudConfigMock).thenReturn(mockImpl);
 289
 290                         Mockito.doAnswer(new Answer<Void>() {
 291                                 @SuppressWarnings("unchecked")
 292                                 @Override
 293                                 public Void answer(InvocationOnMock invocation) throws Throwable {
 294                                         Object[] args = invocation.getArguments();
 295                                         System.out.println("called with arguments: " + Arrays.toString(args));
 296                                         Holder<Boolean> networkExists = (Holder<Boolean>) args[4];
 297                                         networkExists.value = Boolean.TRUE;
 298
 299                                 Holder<String> networkId = (Holder<String>) args[5];
 300                                 networkId.value = "networkId";
 301
 302                                 Holder<String> neutronNetworkId = (Holder<String>) args[6];
 303                                 neutronNetworkId.value = "neutronNetworkId";
 304
 305                                 Holder<NetworkStatus> status = (Holder<NetworkStatus>) args[7];
 306                                 status.value = NetworkStatus.ACTIVE;
 307
 308                                 Holder<List<String>> routeTargets = (Holder<List<String>>) args[8];
 309                                 routeTargets.value = new ArrayList<String>(Arrays.asList("routeTarget1","routeTarget2"));
 310
 311                                 Holder<Map<String, String>> subnetIdMap = (Holder<Map<String, String>>) args[9];
 312                                 subnetIdMap.value = new HashMap<String,String>();
 313                                 subnetIdMap.value.put("Key1", "Val1");
 314                                 subnetIdMap.value.put("Key2", "Val2");
 315                                 subnetIdMap.value.put("Key3", "Val3");
 316
 317                                         return null;
 318                                 }
 319                         }).when(mockImpl).queryNetworkContrail(Mockito.anyString(),
 320                                         Mockito.anyString(),
 321                                         Mockito.anyString(),
 322                                         Mockito.any(MsoRequest.class),
 323                                         Mockito.anyObject(),
 324                                         Mockito.anyObject(),
 325                                         Mockito.anyObject(),
 326                                         Mockito.anyObject(),
 327                                         Mockito.anyObject(),
 328                                         Mockito.anyObject());
 329
 330                         NetworkAdapterRest api = new NetworkAdapterRest();
 331                         Response resp = api.queryNetwork(cloudSiteId, tenantId, networkStackId, skipAAI, requestId, serviceInstanceId, aaiNetworkId);
 332                         QueryNetworkResponse entity = (QueryNetworkResponse) resp.getEntity();
 333
 334                         assertEquals(entity.getNetworkExists(), Boolean.TRUE);
 335                         assertEquals(entity.getNetworkId(), "networkId");
 336                         assertEquals(entity.getNeutronNetworkId(), "neutronNetworkId");
 337                         assertEquals(entity.getNetworkStatus(), NetworkStatus.ACTIVE);
 338                         assertEquals(entity.getRouteTargets().size(), 2);
 339                         assertEquals(entity.getRouteTargets().get(0), "routeTarget1");
 340                         assertEquals(entity.getRouteTargets().get(1), "routeTarget2");
 341
 342                         assertEquals(entity.getSubnetIdMap().size(), 3);
 343                         assertEquals(entity.getSubnetIdMap().get("Key1"), "Val1");
 344                         assertEquals(entity.getSubnetIdMap().get("Key2"), "Val2");
 345                         assertEquals(entity.getSubnetIdMap().get("Key3"), "Val3");
 346                         assertEquals(resp.getStatus(), HttpStatus.SC_OK);
 347                 }
 348                 catch (NetworkException e)
 349                 {
 350                         e.printStackTrace();
 351                 }
 352                 catch(Exception ex)
 353                 {
 354                         ex.printStackTrace();
 355                 }
 356         }
 357
 358         @Test
 359         public void NetworkAdapterRest_rollBackNetwork_async_Test()
 360         {
 361                 rollbackReqMock = PowerMockito.mock(RollbackNetworkRequest.class);
 362                 rollbackTaskMock = PowerMockito.mock(RollbackNetworkTask.class);
 363                 NetworkRollback ntRollbackMock = PowerMockito.mock(NetworkRollback.class);
 364                 MsoNetworkAdapterImpl adapterImplMock = PowerMockito.mock(MsoNetworkAdapterImpl.class);
 365
 366                 try{
 367                         PowerMockito.whenNew(RollbackNetworkRequest.class).withAnyArguments().thenReturn(rollbackReqMock);
 368                         PowerMockito.when(rollbackReqMock.isSynchronous()).thenReturn(false);
 369                         PowerMockito.when(rollbackReqMock.getMessageId()).thenReturn("Rollback succeeded !");
 370
 371                         PowerMockito.whenNew(RollbackNetworkTask.class).withArguments(rollbackReqMock).thenReturn(rollbackTaskMock);
 372                         PowerMockito.spy(rollbackTaskMock);
 373
 374                         // PowerMockito.whenNew(NetworkRollback.class).withAnyArguments().thenReturn(ntRollbackMock);
 375                         PowerMockito.when(rollbackReqMock.getNetworkRollback()).thenReturn(ntRollbackMock);
 376
 377                         PowerMockito.whenNew(MsoNetworkAdapterImpl.class).withAnyArguments().thenReturn(adapterImplMock);
 378                         Mockito.doAnswer(new Answer<Void>() {
 379                                 @Override
 380                                 public Void answer(InvocationOnMock invocation) throws Throwable {
 381                                         Object[] args = invocation.getArguments();
 382                                         System.out.println("called with arguments: " + Arrays.toString(args));
 383                                         return null;
 384                                 }
 385                         }).when(adapterImplMock).rollbackNetwork(ntRollbackMock);
 386
 387                         NetworkAdapterRest api = new NetworkAdapterRest();
 388                         Response resp = api.rollbackNetwork(new RollbackNetworkRequest());
 389
 390                         assertEquals(resp.getStatus(), HttpStatus.SC_ACCEPTED);
 391                         // test if another thread has executed run method
 392                         // Mockito.verify(rollbackTaskMock, Mockito.times(1)).run();
 393                 }
 394                 catch(Exception ex)
 395                 {
 396                         ex.printStackTrace();
 397                 }
 398         }
 399
 400         @Test
 401         public void NetworkAdapterRest_rollBackNetwork_sync_Test()
 402         {
 403                 rollbackReqMock = PowerMockito.mock(RollbackNetworkRequest.class);
 404                 rollbackTaskMock = PowerMockito.mock(RollbackNetworkTask.class);
 405
 406                 try
 407                 {
 408                         PowerMockito.whenNew(RollbackNetworkRequest.class).withAnyArguments().thenReturn(rollbackReqMock);
 409                         PowerMockito.when(rollbackReqMock.isSynchronous()).thenReturn(true);
 410
 411                         PowerMockito.whenNew(RollbackNetworkTask.class).withArguments(rollbackReqMock).thenReturn(rollbackTaskMock);
 412                         PowerMockito.when(rollbackTaskMock.getStatusCode()).thenReturn(HttpStatus.SC_OK);
 413                         PowerMockito.when(rollbackTaskMock.getGenericEntityResponse()).thenReturn(null);
 414                         Mockito.doAnswer(new Answer<Void>() {
 415                                 @Override
 416                                 public Void answer(InvocationOnMock invocation) throws Throwable {
 417                                         System.out.println("run method called ");
 418                                         return null;
 419                                 }
 420                         }).when(rollbackTaskMock).run();
 421                         PowerMockito.spy(rollbackTaskMock);
 422
 423                         NetworkAdapterRest api = new NetworkAdapterRest();
 424                         Response resp = api.rollbackNetwork(new RollbackNetworkRequest());
 425
 426                         assertEquals(resp.getStatus(),HttpStatus.SC_OK);
 427                         Mockito.verify(rollbackTaskMock, Mockito.times(1)).run();
 428                 }
 429                 catch(Exception ex)
 430                 {
 431                         ex.printStackTrace();
 432                 }
 433
 434
 435         }
 436
 437         @Test
 438         public void NetworkAdapterRest_updateNetwork_sync_TestString_Test()
 439         {
 440                 UpdateNetworkRequest req = new UpdateNetworkRequest();
 441                 req.setCloudSiteId(TESTING_KEYWORD);
 442                 req.setTenantId("tenantId");
 443                 req.setNotificationUrl(null);
 444                 MsoRequest msoReq = new MsoRequest();
 445                 msoReq.setRequestId("MsoRequestId");
 446                 msoReq.setServiceInstanceId("serviceInstanceId");
 447                 req.setMsoRequest(msoReq);
 448                 req.setNetworkId("UpdateNetworkRequestNetworkId");
 449                 req.setMessageId("UpdateNetworkMessageWithTestString");
 450
 451                 NetworkAdapterRest api = new NetworkAdapterRest();
 452                 UpdateNetworkTask task = api.new UpdateNetworkTask(req);
 453
 454                 try {
 455                         PowerMockito.whenNew(UpdateNetworkTask.class).withArguments(req).thenReturn(task);
 456                         Response resp = api.updateNetwork("UpdateNetworkRequestNetworkId", req);
 457
 458                         assertEquals(resp.getStatus(),HttpStatus.SC_OK);
 459                         UpdateNetworkResponse unResp = (UpdateNetworkResponse) resp.getEntity();
 460                         assertEquals(unResp.getNetworkId(),"UpdateNetworkRequestNetworkId");
 461                         assertEquals(unResp.getMessageId(),"UpdateNetworkMessageWithTestString");
 462
 463                         Map<String, String> map = unResp.getSubnetMap();
 464                         for (Map.Entry<String, String> entry : map.entrySet()) {
 465                             String key = entry.getKey();
 466                             if(key.equalsIgnoreCase("mickey"))
 467                             {
 468                                     Object value = entry.getValue();
 469                                     assertEquals((String)value, "7");
 470                             }
 471
 472                             if(key.equalsIgnoreCase("clyde"))
 473                             {
 474                                     Object value = entry.getValue();
 475                                     assertEquals((String)value, "10");
 476                             }
 477
 478                             if(key.equalsIgnoreCase("wayne"))
 479                             {
 480                                     Object value = entry.getValue();
 481                                     assertEquals((String)value, "99");
 482                             }
 483                         }
 484
 485                 } catch (Exception e) {
 486                         e.printStackTrace();
 487                 }
 488         }
 489
 490         @SuppressWarnings("unchecked")
 491         @Test
 492         public void NetworkAdapterRest_updateNetwork_sync_ContrailRequest_Test()
 493         {
 494                 try {
 495                         MsoRequest msoReq = new MsoRequest();
 496                         msoReq.setRequestId("MsoRequestId");
 497                         msoReq.setServiceInstanceId("serviceInstanceId");
 498
 499                         UpdateNetworkRequest reqMock = PowerMockito.mock(UpdateNetworkRequest.class);
 500                         PowerMockito.whenNew(UpdateNetworkRequest.class).withAnyArguments().thenReturn(reqMock);
 501                         PowerMockito.when(reqMock.getCloudSiteId()).thenReturn("NON_"+TESTING_KEYWORD);
 502                         PowerMockito.when(reqMock.getTenantId()).thenReturn("tenantId");
 503                         PowerMockito.when(reqMock.getNetworkType()).thenReturn("NetworkType");
 504                         PowerMockito.when(reqMock.getModelCustomizationUuid()).thenReturn("b4a6af8c-a22b-45d5-a880-29527f8f59a7");
 505                         PowerMockito.when(reqMock.getNetworkStackId()).thenReturn("b4a6af8c-a22b-45d5-a880-29527f8f59a7");
 506                         PowerMockito.when(reqMock.getNetworkName()).thenReturn("NetworkName");
 507                         PowerMockito.when(reqMock.getSubnets()).thenReturn(new ArrayList<Subnet>());
 508
 509                         PowerMockito.when(reqMock.isSynchronous()).thenReturn(true);
 510                         PowerMockito.when(reqMock.getNetworkId()).thenReturn("UpdateNetworkRequestNetworkId");
 511                         PowerMockito.when(reqMock.getMessageId()).thenReturn("UpdateNetworkMessageWithTestString");
 512                         PowerMockito.when(reqMock.getMsoRequest()).thenReturn(msoReq);
 513                         PowerMockito.when(reqMock.isContrailRequest()).thenReturn(true);
 514                         ContrailNetwork cn = new ContrailNetwork();
 515                         cn.setRouteTargets(new ArrayList<RouteTarget>());
 516                         cn.setPolicyFqdns(new ArrayList<String>());
 517                         cn.setRouteTableFqdns(new ArrayList<String>());
 518
 519                         PowerMockito.when(reqMock.getContrailNetwork()).thenReturn(cn);
 520
 521                         MsoNetworkAdapterImpl msoImplMock = PowerMockito.mock(MsoNetworkAdapterImpl.class);
 522                         PowerMockito.whenNew(MsoNetworkAdapterImpl.class).withAnyArguments().thenReturn(msoImplMock);
 523
 524                         Mockito.doAnswer(new Answer<Void>() {
 525                                 @SuppressWarnings("unchecked")
 526                                 @Override
 527                                 public Void answer(InvocationOnMock invocation) throws Throwable {
 528                                         Object[] args = invocation.getArguments();
 529                                         System.out.println("updateNetworkContrail called with arguments: " + Arrays.toString(args));
 530
 531                                         return null;
 532                                 }
 533                         }).when(msoImplMock).updateNetworkContrail
 534                                         (Mockito.anyString(),
 535                                                         Mockito.anyString(),
 536                                                         Mockito.anyString(),
 537                                                         Mockito.anyString(),
 538                                                         Mockito.anyString(),
 539                                                         Mockito.anyString(),
 540                                                         Mockito.anyListOf(RouteTarget.class),
 541                                                         Mockito.anyString(),
 542                                                         Mockito.anyString(),
 543                                                         Mockito.anyListOf(Subnet.class),
 544                                                         Mockito.anyListOf(String.class),
 545                                                         Mockito.anyListOf(String.class),
 546                                                         Mockito.any(MsoRequest.class),
 547                                                         Mockito.any(Holder.class),
 548                                                         Mockito.any(Holder.class)
 549                                     );
 550                         PowerMockito.spy(msoImplMock);
 551
 552                         NetworkAdapterRest api = new NetworkAdapterRest();
 553                         Response resp = api.updateNetwork("UpdateNetworkRequestNetworkId", reqMock);
 554
 555                         Mockito.verify(msoImplMock, Mockito.times(1)).updateNetworkContrail
 556                         (Mockito.anyString(),
 557                                         Mockito.anyString(),
 558                                         Mockito.anyString(),
 559                                         Mockito.anyString(),
 560                                         Mockito.anyString(),
 561                                         Mockito.anyString(),
 562                                         Mockito.anyListOf(RouteTarget.class),
 563                                         Mockito.anyString(),
 564                                         Mockito.anyString(),
 565                                         Mockito.anyListOf(Subnet.class),
 566                                         Mockito.anyListOf(String.class),
 567                                         Mockito.anyListOf(String.class),
 568                                         Mockito.any(MsoRequest.class),
 569                                         Mockito.any(Holder.class),
 570                                         Mockito.any(Holder.class)
 571                     );
 572
 573                         assertEquals(resp.getStatus(),HttpStatus.SC_OK);
 574                         UpdateNetworkResponse unResp = (UpdateNetworkResponse) resp.getEntity();
 575                         assertEquals(unResp.getNetworkId(),"UpdateNetworkRequestNetworkId");
 576                         assertEquals(unResp.getMessageId(),"UpdateNetworkMessageWithTestString");
 577
 578                 } catch (Exception e) {
 579                         e.printStackTrace();
 580                 }
 581         }
 582
 583         @SuppressWarnings("unchecked")
 584         @Test
 585         public void NetworkAdapterRest_updateNetwork_async_Test()
 586         {
 587                 UpdateNetworkRequest updateReqMock = PowerMockito.mock(UpdateNetworkRequest.class);
 588                 UpdateNetworkTask updateTaskMock = PowerMockito.mock(UpdateNetworkTask.class);
 589                 MsoNetworkAdapterImpl adapterImplMock = PowerMockito.mock(MsoNetworkAdapterImpl.class);
 590
 591                 try{
 592                         PowerMockito.whenNew(UpdateNetworkRequest.class).withAnyArguments().thenReturn(updateReqMock);
 593                         PowerMockito.when(updateReqMock.isSynchronous()).thenReturn(false);
 594                         PowerMockito.when(updateReqMock.getMessageId()).thenReturn("Update succeeded !");
 595                         PowerMockito.when(updateReqMock.getNetworkId()).thenReturn("UpdateNetworkRequestNetworkId");
 596
 597                         PowerMockito.whenNew(UpdateNetworkTask.class).withArguments(updateReqMock).thenReturn(updateTaskMock);
 598                         PowerMockito.spy(updateTaskMock);
 599
 600                         PowerMockito.whenNew(MsoNetworkAdapterImpl.class).withAnyArguments().thenReturn(adapterImplMock);
 601                         Mockito.doAnswer(new Answer<Void>() {
 602                                 @Override
 603                                 public Void answer(InvocationOnMock invocation) throws Throwable {
 604                                         Object[] args = invocation.getArguments();
 605                                         System.out.println("updateNetworkContrail called with arguments: " + Arrays.toString(args));
 606                                         return null;
 607                                 }
 608                         }).when(adapterImplMock).updateNetworkContrail
 609                         (
 610                                         Mockito.anyString(),
 611                                         Mockito.anyString(),
 612                                         Mockito.anyString(),
 613                                         Mockito.anyString(),
 614                                         Mockito.anyString(),
 615                                         Mockito.anyString(),
 616                                         Mockito.anyListOf(RouteTarget.class),
 617                                         Mockito.anyString(),
 618                                         Mockito.anyString(),
 619                                         Mockito.anyListOf(Subnet.class),
 620                                         Mockito.anyListOf(String.class),
 621                                         Mockito.anyListOf(String.class),
 622                                         Mockito.any(MsoRequest.class),
 623                                         Mockito.any(Holder.class),
 624                                         Mockito.any(Holder.class)
 625                         );
 626
 627                         NetworkAdapterRest api = new NetworkAdapterRest();
 628                         Response resp = api.updateNetwork("UpdateNetworkRequestNetworkId", updateReqMock);
 629
 630                         assertEquals(resp.getStatus(), HttpStatus.SC_ACCEPTED);
 631                         // test if another thread has executed run method
 632                         // Mockito.verify(updateTaskMock, Mockito.times(1)).run();
 633                 }
 634                 catch(Exception ex)
 635                 {
 636                         ex.printStackTrace();
 637                 }
 638         }
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657 }