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