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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2018 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.mockito.Matchers.any;
  24 import static org.mockito.Matchers.anyList;
  25 import static org.mockito.Matchers.anyLong;
  26 import static org.mockito.Matchers.anyString;
  27 import static org.mockito.Matchers.anyBoolean;
  28 import static org.mockito.Mockito.doReturn;
  29 import static org.mockito.Mockito.when;
  30
  31 import java.util.ArrayList;
  32 import java.util.HashMap;
  33 import java.util.List;
  34 import java.util.Map;
  35 import java.util.Optional;
  36
  37 import javax.xml.ws.Holder;
  38
  39 import org.junit.Test;
  40 import org.mockito.Mockito;
  41 import org.openecomp.mso.adapters.network.exceptions.NetworkException;
  42 import org.openecomp.mso.cloud.CloudConfig;
  43 import org.openecomp.mso.cloud.CloudConfigFactory;
  44 import org.openecomp.mso.cloud.CloudSite;
  45 import org.openecomp.mso.db.catalog.CatalogDatabase;
  46 import org.openecomp.mso.db.catalog.beans.HeatTemplate;
  47 import org.openecomp.mso.db.catalog.beans.NetworkResource;
  48 import org.openecomp.mso.openstack.beans.HeatStatus;
  49 import org.openecomp.mso.openstack.beans.NetworkInfo;
  50 import org.openecomp.mso.openstack.beans.NetworkRollback;
  51 import org.openecomp.mso.openstack.beans.NetworkStatus;
  52 import org.openecomp.mso.openstack.beans.StackInfo;
  53 import org.openecomp.mso.openstack.beans.Subnet;
  54 import org.openecomp.mso.openstack.exceptions.MsoException;
  55 import org.openecomp.mso.openstack.utils.MsoHeatUtils;
  56 import org.openecomp.mso.openstack.utils.MsoHeatUtilsWithUpdate;
  57 import org.openecomp.mso.openstack.utils.MsoNeutronUtils;
  58 import org.openecomp.mso.properties.MsoJavaProperties;
  59 import org.openecomp.mso.properties.MsoPropertiesException;
  60 import org.openecomp.mso.properties.MsoPropertiesFactory;
  61
  62 public class MsoNetworkAdapterImplTest {
  63
  64         @Test
  65         public void createNetworkImplTest_CloudSiteNotPresent() throws NetworkException {
  66                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
  67                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
  68                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
  69                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
  70                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(null);
  71                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
  72                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
  73                 try {
  74                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
  75                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
  76                 } catch (Exception e) {
  77
  78                 }
  79         }
  80
  81         @Test
  82         public void createNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkThrowsException()
  83                         throws NetworkException, MsoException {
  84                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
  85                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
  86                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
  87                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
  88                 CloudSite cloudSite = new CloudSite();
  89                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
  90                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
  91                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
  92                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
  93                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
  94                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
  95                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
  96                 doReturn(catalogDB).when(impl).getCatalogDB();
  97                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
  98                                 anyString(), anyList(), anyList(), any());
  99                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 100                 MsoException exception = Mockito.mock(MsoException.class);
 101                 when(impl.neutron.queryNetwork(any(), any(), any())).thenThrow(exception);
 102                 try {
 103                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 104                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
 105                 } catch (Exception e) {
 106
 107                 }
 108         }
 109
 110         @Test
 111         public void createNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkExists_FailIfExistsTrue()
 112                         throws NetworkException, MsoException {
 113                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 114                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 115                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 116                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 117                 CloudSite cloudSite = new CloudSite();
 118                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 119                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 120                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 121                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 122                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 123                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 124                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 125                 doReturn(catalogDB).when(impl).getCatalogDB();
 126                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 127                                 anyString(), anyList(), anyList(), any());
 128                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 129                 NetworkInfo netInfo = Mockito.mock(NetworkInfo.class);
 130                 when(impl.neutron.queryNetwork(any(), any(), any())).thenReturn(netInfo);
 131                 try {
 132                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 133                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
 134                 } catch (Exception e) {
 135
 136                 }
 137         }
 138
 139         @Test
 140         public void createNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkExists_FailIfExistsNotTrue()
 141                         throws NetworkException, MsoException {
 142                 Holder<String> networkId = new Holder<>();
 143                 Holder<String> neutronNetworkId = new Holder<>();
 144                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 145                 Holder<NetworkRollback> rollback = new Holder<>();
 146                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 147                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 148                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 149                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 150                 CloudSite cloudSite = new CloudSite();
 151                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 152                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 153                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 154                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 155                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 156                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 157                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 158                 doReturn(catalogDB).when(impl).getCatalogDB();
 159                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 160                                 anyString(), anyList(), anyList(), any());
 161                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 162                 NetworkInfo netInfo = Mockito.mock(NetworkInfo.class);
 163                 when(impl.neutron.queryNetwork(any(), any(), any())).thenReturn(netInfo);
 164                 try {
 165                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 166                                         "physicalNetworkName", null, false, true, null, null, networkId, neutronNetworkId, subnetIdMap,
 167                                         rollback);
 168                 } catch (Exception e) {
 169
 170                 }
 171         }
 172
 173         @Test
 174         public void createNetworkImplTest_CloudSitePresent_NeutronMode_NetInfoDoesntExist_CreateNetworkException()
 175                         throws NetworkException, MsoException {
 176                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 177                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 178                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 179                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 180                 CloudSite cloudSite = new CloudSite();
 181                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 182                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 183                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 184                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 185                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 186                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 187                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 188                 doReturn(catalogDB).when(impl).getCatalogDB();
 189                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 190                                 anyString(), anyList(), anyList(), any());
 191                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 192                 NetworkInfo netInfo = null;
 193                 MsoException exception = Mockito.mock(MsoException.class);
 194                 when(impl.neutron.queryNetwork(any(), any(), any())).thenReturn(netInfo);
 195                 when(impl.neutron.createNetwork(any(), any(), any(), any(), any(), any())).thenThrow(exception);
 196                 try {
 197                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 198                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
 199                 } catch (Exception e) {
 200
 201                 }
 202         }
 203
 204         @Test
 205         public void createNetworkImplTest_CloudSitePresent_NeutronMode_NetInfoDoesntExist_CreateNetwork()
 206                         throws NetworkException, MsoException {
 207                 Holder<String> networkId = new Holder<>();
 208                 Holder<String> neutronNetworkId = new Holder<>();
 209                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 210                 Holder<NetworkRollback> rollback = new Holder<>();
 211                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 212                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 213                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 214                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 215                 CloudSite cloudSite = new CloudSite();
 216                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 217                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 218                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 219                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 220                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 221                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 222                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 223                 doReturn(catalogDB).when(impl).getCatalogDB();
 224                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 225                                 anyString(), anyList(), anyList(), any());
 226                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 227                 NetworkInfo netInfo = Mockito.mock(NetworkInfo.class);
 228                 when(netInfo.getId()).thenReturn("Id");
 229                 when(impl.neutron.queryNetwork(any(), any(), any())).thenReturn(null);
 230                 when(impl.neutron.createNetwork(any(), any(), any(), any(), any(), anyList())).thenReturn(netInfo);
 231                 try {
 232                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 233                                         "physicalNetworkName", null, true, true, null, null, networkId, neutronNetworkId, subnetIdMap,
 234                                         rollback);
 235                 } catch (Exception e) {
 236
 237                 }
 238         }
 239
 240         @Test
 241         public void createNetworkImplTest_CloudSitePresent_NeutronMode_NetInfoExists()
 242                         throws NetworkException, MsoException {
 243                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 244                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 245                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 246                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 247                 CloudSite cloudSite = new CloudSite();
 248                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 249                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 250                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 251                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 252                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 253                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 254                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 255                 doReturn(catalogDB).when(impl).getCatalogDB();
 256                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 257                                 anyString(), anyList(), anyList(), any());
 258                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 259                 NetworkInfo netInfo = null;
 260                 when(impl.neutron.queryNetwork(any(), any(), any())).thenReturn(netInfo);
 261                 try {
 262                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 263                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
 264                 } catch (Exception e) {
 265
 266                 }
 267         }
 268
 269         @Test
 270         public void createNetworkImplTest_CloudSitePresent_HeatMode_HeatTemplateNull() throws NetworkException {
 271                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 272                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 273                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 274                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 275                 CloudSite cloudSite = new CloudSite();
 276                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 277                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 278                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 279                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 280                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 281                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 282                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 283                 doReturn(catalogDB).when(impl).getCatalogDB();
 284                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 285                                 anyString(), anyList(), anyList(), any());
 286                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 287                 try {
 288                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 289                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
 290                 } catch (Exception e) {
 291
 292                 }
 293         }
 294
 295         @Test
 296         public void createNetworkImplTest_CloudSitePresent_HeatMode_HeatTemplateNotNull_ThrowMsoPropsException()
 297                         throws NetworkException, MsoPropertiesException {
 298                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 299                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 300                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 301                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 302                 CloudSite cloudSite = new CloudSite();
 303                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 304                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 305                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 306                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 307                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 308                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 309                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 310                 doReturn(catalogDB).when(impl).getCatalogDB();
 311                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 312                                 anyString(), anyList(), anyList(), any());
 313                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 314                 HeatTemplate heatTemplate = Mockito.mock(HeatTemplate.class);
 315                 when(heatTemplate.toString()).thenReturn("heatTemplate");
 316                 when(heatTemplate.getHeatTemplate()).thenReturn("heatTemplate");
 317                 when(catalogDB.getHeatTemplateByArtifactUuidRegularQuery(any())).thenReturn(heatTemplate);
 318                 MsoPropertiesException exception = Mockito.mock(MsoPropertiesException.class);
 319                 when(impl.msoPropertiesFactory.getMsoJavaProperties(any())).thenThrow(exception);
 320                 try {
 321                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 322                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
 323                 } catch (Exception e) {
 324
 325                 }
 326         }
 327
 328         @Test
 329         public void createNetworkImplTest_CloudSitePresent_HeatMode_HeatTemplateNotNull()
 330                         throws NetworkException, MsoPropertiesException {
 331                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 332                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 333                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 334                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 335                 CloudSite cloudSite = new CloudSite();
 336                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 337                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 338                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 339                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 340                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 341                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 342                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 343                 doReturn(catalogDB).when(impl).getCatalogDB();
 344                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 345                                 anyString(), anyList(), anyList(), any());
 346                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 347                 HeatTemplate heatTemplate = Mockito.mock(HeatTemplate.class);
 348                 when(heatTemplate.toString()).thenReturn("heatTemplate");
 349                 when(heatTemplate.getHeatTemplate()).thenReturn("heatTemplateaic");
 350                 when(catalogDB.getHeatTemplateByArtifactUuidRegularQuery(any())).thenReturn(heatTemplate);
 351                 MsoPropertiesException exception = Mockito.mock(MsoPropertiesException.class);
 352                 MsoJavaProperties props = Mockito.mock(MsoJavaProperties.class);
 353                 when(impl.msoPropertiesFactory.getMsoJavaProperties(any())).thenReturn(props);
 354                 when(props.getProperty(anyString(), anyString())).thenReturn("aic");
 355                 try {
 356                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 357                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
 358                 } catch (Exception e) {
 359
 360                 }
 361         }
 362
 363         @Test
 364         public void createNetworkImplTest_CloudSitePresent_HeatMode_HeatTemplateNotNull_QueryStackThrowsException()
 365                         throws NetworkException, MsoPropertiesException, MsoException {
 366                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 367                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 368                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 369                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 370                 CloudSite cloudSite = new CloudSite();
 371                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 372                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 373                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 374                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 375                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 376                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 377                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 378                 doReturn(catalogDB).when(impl).getCatalogDB();
 379                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 380                                 anyString(), anyList(), anyList(), any());
 381                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 382                 HeatTemplate heatTemplate = Mockito.mock(HeatTemplate.class);
 383                 when(heatTemplate.toString()).thenReturn("heatTemplate");
 384                 when(heatTemplate.getHeatTemplate()).thenReturn("heatTemplateaic");
 385                 when(catalogDB.getHeatTemplateByArtifactUuidRegularQuery(any())).thenReturn(heatTemplate);
 386                 MsoJavaProperties props = Mockito.mock(MsoJavaProperties.class);
 387                 when(impl.msoPropertiesFactory.getMsoJavaProperties(any())).thenReturn(props);
 388                 when(props.getProperty(anyString(), anyString())).thenReturn("aic");
 389                 MsoException exception = Mockito.mock(MsoException.class);
 390                 impl.heat = Mockito.mock(MsoHeatUtils.class);
 391                 when(impl.heat.queryStack(anyString(), anyString(), anyString())).thenThrow(exception);
 392                 try {
 393                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 394                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
 395                 } catch (Exception e) {
 396
 397                 }
 398         }
 399
 400         @Test
 401         public void createNetworkImplTest_CloudSitePresent_HeatMode_HeatTemplateNotNull_QueryStack_HeatStackNull()
 402                         throws NetworkException, MsoPropertiesException, MsoException {
 403                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 404                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 405                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 406                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 407                 CloudSite cloudSite = new CloudSite();
 408                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 409                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 410                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 411                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 412                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 413                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 414                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 415                 doReturn(catalogDB).when(impl).getCatalogDB();
 416                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 417                                 anyString(), anyList(), anyList(), any());
 418                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 419                 HeatTemplate heatTemplate = Mockito.mock(HeatTemplate.class);
 420                 when(heatTemplate.toString()).thenReturn("heatTemplate");
 421                 when(heatTemplate.getHeatTemplate()).thenReturn("heatTemplateaic");
 422                 when(catalogDB.getHeatTemplateByArtifactUuidRegularQuery(any())).thenReturn(heatTemplate);
 423                 MsoJavaProperties props = Mockito.mock(MsoJavaProperties.class);
 424                 when(impl.msoPropertiesFactory.getMsoJavaProperties(any())).thenReturn(props);
 425                 when(props.getProperty(anyString(), anyString())).thenReturn("aic");
 426                 StackInfo heatStack = null;
 427                 impl.heat = Mockito.mock(MsoHeatUtils.class);
 428                 when(impl.heat.queryStack(anyString(), anyString(), anyString())).thenReturn(heatStack);
 429                 try {
 430                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 431                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
 432                 } catch (Exception e) {
 433
 434                 }
 435         }
 436
 437         @Test
 438         public void createNetworkImplTest_CloudSitePresent_HeatMode_HeatTemplateNotNull_QueryStack_HeatStackNotNull_FailIfExists()
 439                         throws NetworkException, MsoPropertiesException, MsoException {
 440                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 441                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 442                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 443                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 444                 CloudSite cloudSite = new CloudSite();
 445                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 446                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 447                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 448                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 449                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 450                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 451                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 452                 doReturn(catalogDB).when(impl).getCatalogDB();
 453                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 454                                 anyString(), anyList(), anyList(), any());
 455                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 456                 HeatTemplate heatTemplate = Mockito.mock(HeatTemplate.class);
 457                 when(heatTemplate.toString()).thenReturn("heatTemplate");
 458                 when(heatTemplate.getHeatTemplate()).thenReturn("heatTemplateaic");
 459                 when(catalogDB.getHeatTemplateByArtifactUuidRegularQuery(any())).thenReturn(heatTemplate);
 460                 MsoJavaProperties props = Mockito.mock(MsoJavaProperties.class);
 461                 when(impl.msoPropertiesFactory.getMsoJavaProperties(any())).thenReturn(props);
 462                 when(props.getProperty(anyString(), anyString())).thenReturn("aic");
 463                 StackInfo heatStack = Mockito.mock(StackInfo.class);
 464                 impl.heat = Mockito.mock(MsoHeatUtils.class);
 465                 when(impl.heat.queryStack(anyString(), anyString(), anyString())).thenReturn(heatStack);
 466                 try {
 467                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 468                                         "physicalNetworkName", null, true, true, null, null, null, null, null, null);
 469                 } catch (Exception e) {
 470
 471                 }
 472         }
 473
 474         @Test
 475         public void createNetworkImplTest_CloudSitePresent_HeatMode_HeatTemplateNotNull_QueryStack_HeatStackNotNull_DontFailIfExists()
 476                         throws NetworkException, MsoPropertiesException, MsoException {
 477                 Holder<String> networkId = new Holder<>();
 478                 Holder<String> neutronNetworkId = new Holder<>();
 479                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 480                 Holder<NetworkRollback> rollback = new Holder<>();
 481                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 482                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 483                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 484                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 485                 CloudSite cloudSite = new CloudSite();
 486                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 487                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 488                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 489                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 490                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 491                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 492                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 493                 doReturn(catalogDB).when(impl).getCatalogDB();
 494                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 495                                 anyString(), anyList(), anyList(), any());
 496                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 497                 HeatTemplate heatTemplate = Mockito.mock(HeatTemplate.class);
 498                 when(heatTemplate.toString()).thenReturn("heatTemplate");
 499                 when(heatTemplate.getHeatTemplate()).thenReturn("heatTemplateaic");
 500                 when(catalogDB.getHeatTemplateByArtifactUuidRegularQuery(any())).thenReturn(heatTemplate);
 501                 MsoJavaProperties props = Mockito.mock(MsoJavaProperties.class);
 502                 when(impl.msoPropertiesFactory.getMsoJavaProperties(any())).thenReturn(props);
 503                 when(props.getProperty(anyString(), anyString())).thenReturn("aic");
 504                 StackInfo heatStack = Mockito.mock(StackInfo.class);
 505                 Map<String, Object> outputs = new HashMap<>();
 506                 outputs.put("subnet", "");
 507                 when(heatStack.getOutputs()).thenReturn(outputs);
 508                 impl.heat = Mockito.mock(MsoHeatUtils.class);
 509                 when(impl.heat.queryStack(anyString(), anyString(), anyString())).thenReturn(heatStack);
 510                 try {
 511                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 512                                         "physicalNetworkName", null, false, true, null, null, networkId, neutronNetworkId, subnetIdMap,
 513                                         rollback);
 514                 } catch (Exception e) {
 515
 516                 }
 517         }
 518
 519         @Test
 520         public void createNetworkImplTest_CloudSitePresent_HeatMode_HeatTemplateNotNull_QueryStack_HeatStackNotNull_DontFailIfExists_Validate()
 521                         throws NetworkException, MsoPropertiesException, MsoException {
 522                 List<Subnet> subnets = new ArrayList<>();
 523                 Holder<String> networkId = new Holder<>();
 524                 Holder<String> neutronNetworkId = new Holder<>();
 525                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 526                 Holder<NetworkRollback> rollback = new Holder<>();
 527                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 528                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 529                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 530                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 531                 CloudSite cloudSite = new CloudSite();
 532                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 533                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 534                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 535                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 536                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 537                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 538                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 539                 doReturn(catalogDB).when(impl).getCatalogDB();
 540                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 541                                 anyString(), anyList(), anyList(), any());
 542                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 543                 HeatTemplate heatTemplate = Mockito.mock(HeatTemplate.class);
 544                 when(heatTemplate.toString()).thenReturn("heatTemplate");
 545                 when(heatTemplate.getHeatTemplate()).thenReturn("heatTemplateaic");
 546                 when(catalogDB.getHeatTemplateByArtifactUuidRegularQuery(any())).thenReturn(heatTemplate);
 547                 MsoJavaProperties props = Mockito.mock(MsoJavaProperties.class);
 548                 when(impl.msoPropertiesFactory.getMsoJavaProperties(any())).thenReturn(props);
 549                 when(props.getProperty(anyString(), anyString())).thenReturn("aic");
 550                 StackInfo heatStack = Mockito.mock(StackInfo.class);
 551                 Map<String, Object> outputs = new HashMap<>();
 552                 outputs.put("subnet", "");
 553                 when(heatStack.getOutputs()).thenReturn(outputs);
 554                 impl.heat = Mockito.mock(MsoHeatUtils.class);
 555                 when(impl.heat.queryStack(anyString(), anyString(), anyString())).thenReturn(heatStack);
 556                 try {
 557                         impl.createNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkName",
 558                                         "physicalNetworkName", null, false, true, subnets, null, networkId, neutronNetworkId, subnetIdMap,
 559                                         rollback);
 560                 } catch (Exception e) {
 561
 562                 }
 563         }
 564
 565         @Test
 566         public void updateNetworkImplTest_CloudSiteNotPresent() throws NetworkException {
 567                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 568                 Holder<NetworkRollback> rollback = new Holder<>();
 569                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 570                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 571                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 572                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 573                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(null);
 574                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 575                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 576                 try {
 577                         impl.updateNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkId",
 578                                         "networkName", "physicalNetworkName", null, null, null, subnetIdMap, rollback);
 579                 } catch (Exception e) {
 580
 581                 }
 582         }
 583
 584         @Test
 585         public void updateNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkThrowsException()
 586                         throws NetworkException, MsoException {
 587                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 588                 Holder<NetworkRollback> rollback = new Holder<>();
 589                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 590                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 591                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 592                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 593                 CloudSite cloudSite = new CloudSite();
 594                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 595                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 596                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 597                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 598                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 599                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 600                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 601                 doReturn(catalogDB).when(impl).getCatalogDB();
 602                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 603                                 anyString(), anyList(), anyList(), any());
 604                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 605                 MsoException exception = Mockito.mock(MsoException.class);
 606                 when(impl.neutron.queryNetwork(any(), any(), any())).thenThrow(exception);
 607                 try {
 608                         impl.updateNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkId",
 609                                         "networkName", "physicalNetworkName", null, null, null, subnetIdMap, rollback);
 610                 } catch (Exception e) {
 611
 612                 }
 613         }
 614
 615         @Test
 616         public void updateNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkReturnsNull()
 617                         throws NetworkException, MsoException {
 618                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 619                 Holder<NetworkRollback> rollback = new Holder<>();
 620                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 621                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 622                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 623                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 624                 CloudSite cloudSite = new CloudSite();
 625                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 626                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 627                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 628                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 629                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 630                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 631                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 632                 doReturn(catalogDB).when(impl).getCatalogDB();
 633                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 634                                 anyString(), anyList(), anyList(), any());
 635                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 636                 when(impl.neutron.queryNetwork(any(), any(), any())).thenReturn(null);
 637                 try {
 638                         impl.updateNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkId",
 639                                         "networkName", "physicalNetworkName", null, null, null, subnetIdMap, rollback);
 640                 } catch (Exception e) {
 641
 642                 }
 643         }
 644
 645         @Test
 646         public void updateNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkDoesntExist_UpdateNetworkException()
 647                         throws NetworkException, MsoException {
 648                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 649                 Holder<NetworkRollback> rollback = new Holder<>();
 650                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 651                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 652                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 653                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 654                 CloudSite cloudSite = new CloudSite();
 655                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 656                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 657                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 658                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 659                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 660                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 661                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 662                 doReturn(catalogDB).when(impl).getCatalogDB();
 663                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 664                                 anyString(), anyList(), anyList(), any());
 665                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 666                 NetworkInfo netInfo = new NetworkInfo(null);
 667                 MsoException exception = Mockito.mock(MsoException.class);
 668                 when(impl.neutron.queryNetwork(any(), any(), any())).thenReturn(netInfo);
 669                 when(impl.neutron.updateNetwork(any(), any(), any(), any(), any(), anyList())).thenThrow(exception);
 670                 try {
 671                         impl.updateNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkId",
 672                                         "networkName", "physicalNetworkName", null, null, null, subnetIdMap, rollback);
 673                 } catch (Exception e) {
 674
 675                 }
 676         }
 677
 678         @Test
 679         public void updateNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkDoesntExist_UpdateNetwork()
 680                         throws NetworkException, MsoException {
 681                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 682                 Holder<NetworkRollback> rollback = new Holder<>();
 683                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 684                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 685                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 686                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 687                 CloudSite cloudSite = new CloudSite();
 688                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 689                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 690                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 691                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 692                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 693                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 694                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 695                 doReturn(catalogDB).when(impl).getCatalogDB();
 696                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 697                                 anyString(), anyList(), anyList(), any());
 698                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 699                 NetworkInfo netInfo = new NetworkInfo(null);
 700                 NetworkInfo mockedNetworkInfo = Mockito.mock(NetworkInfo.class);
 701                 when(mockedNetworkInfo.getId()).thenReturn("Id");
 702                 when(impl.neutron.queryNetwork(any(), any(), any())).thenReturn(netInfo);
 703                 when(impl.neutron.updateNetwork(any(), any(), any(), any(), any(), anyList())).thenReturn(mockedNetworkInfo);
 704                 try {
 705                         impl.updateNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkId",
 706                                         "networkName", "physicalNetworkName", null, null, null, subnetIdMap, rollback);
 707                 } catch (Exception e) {
 708
 709                 }
 710         }
 711
 712         @Test
 713         public void updateNetworkImplTest_CloudSitePresent_HeatMode_QueryStackThrowException()
 714                         throws NetworkException, MsoException {
 715                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 716                 Holder<NetworkRollback> rollback = new Holder<>();
 717                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 718                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 719                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 720                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 721                 CloudSite cloudSite = new CloudSite();
 722                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 723                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 724                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 725                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 726                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 727                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 728                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 729                 doReturn(catalogDB).when(impl).getCatalogDB();
 730                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 731                                 anyString(), anyList(), anyList(), any());
 732                 impl.heatWithUpdate = Mockito.mock(MsoHeatUtilsWithUpdate.class);
 733                 MsoException exception = Mockito.mock(MsoException.class);
 734                 when(impl.heatWithUpdate.queryStack(any(), any(), any())).thenThrow(exception);
 735                 try {
 736                         impl.updateNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkId",
 737                                         "networkName", "physicalNetworkName", null, null, null, subnetIdMap, rollback);
 738                 } catch (Exception e) {
 739
 740                 }
 741         }
 742
 743         @Test
 744         public void updateNetworkImplTest_CloudSitePresent_HeatMode_QueryStackReturnNull()
 745                         throws NetworkException, MsoException {
 746                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 747                 Holder<NetworkRollback> rollback = new Holder<>();
 748                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 749                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 750                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 751                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 752                 CloudSite cloudSite = new CloudSite();
 753                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 754                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 755                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 756                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 757                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 758                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 759                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 760                 doReturn(catalogDB).when(impl).getCatalogDB();
 761                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 762                                 anyString(), anyList(), anyList(), any());
 763                 impl.heatWithUpdate = Mockito.mock(MsoHeatUtilsWithUpdate.class);
 764                 MsoException exception = Mockito.mock(MsoException.class);
 765                 when(impl.heatWithUpdate.queryStack(any(), any(), any())).thenReturn(null);
 766                 try {
 767                         impl.updateNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkId",
 768                                         "networkName", "physicalNetworkName", null, null, null, subnetIdMap, rollback);
 769                 } catch (Exception e) {
 770
 771                 }
 772         }
 773
 774         @Test
 775         public void updateNetworkImplTest_CloudSitePresent_HeatMode_QueryStackReturnInfo()
 776                         throws NetworkException, MsoException {
 777                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 778                 Holder<NetworkRollback> rollback = new Holder<>();
 779                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 780                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 781                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 782                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 783                 CloudSite cloudSite = new CloudSite();
 784                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 785                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 786                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 787                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 788                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 789                 when(networkResource.getOrchestrationMode()).thenReturn("HEAT");
 790                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 791                 doReturn(catalogDB).when(impl).getCatalogDB();
 792                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 793                                 anyString(), anyList(), anyList(), any());
 794                 impl.heatWithUpdate = Mockito.mock(MsoHeatUtilsWithUpdate.class);
 795                 MsoException exception = Mockito.mock(MsoException.class);
 796                 StackInfo stackInfo = Mockito.mock(StackInfo.class);
 797                 when(impl.heatWithUpdate.queryStack(any(), any(), any())).thenReturn(stackInfo);
 798                 try {
 799                         impl.updateNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkId",
 800                                         "networkName", "physicalNetworkName", null, null, null, subnetIdMap, rollback);
 801                 } catch (Exception e) {
 802
 803                 }
 804         }
 805
 806         @Test
 807         public void queryNetworkImplTest_CloudSiteNotPresent() throws NetworkException {
 808                 Holder<Boolean> networkExists = new Holder<>();
 809                 Holder<String> networkId = new Holder<>();
 810                 Holder<String> neutronNetworkId = new Holder<>();
 811                 Holder<NetworkStatus> status = new Holder<>();
 812                 Holder<List<Integer>> vlans = new Holder<>();
 813                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 814                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 815                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 816                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 817                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 818                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(null);
 819                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 820                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 821                 try {
 822                         impl.queryNetwork("cloudSiteId", "tenantId", "networkNameOrId", null, networkExists, networkId,
 823                                         neutronNetworkId, status, vlans, subnetIdMap);
 824                 } catch (Exception e) {
 825
 826                 }
 827         }
 828
 829         @Test
 830         public void queryNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkThrowsException()
 831                         throws NetworkException, MsoException {
 832                 Holder<Boolean> networkExists = new Holder<>();
 833                 Holder<String> networkId = new Holder<>();
 834                 Holder<String> neutronNetworkId = new Holder<>();
 835                 Holder<NetworkStatus> status = new Holder<>();
 836                 Holder<List<Integer>> vlans = new Holder<>();
 837                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 838                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 839                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 840                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 841                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 842                 CloudSite cloudSite = new CloudSite();
 843                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 844                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 845                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 846                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 847                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 848                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 849                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 850                 doReturn(catalogDB).when(impl).getCatalogDB();
 851                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 852                                 anyString(), anyList(), anyList(), any());
 853                 impl.heat = Mockito.mock(MsoHeatUtils.class);
 854                 MsoException exception = Mockito.mock(MsoException.class);
 855                 when(impl.heat.queryStack(any(), any(), any())).thenThrow(exception);
 856                 try {
 857                         impl.queryNetwork("cloudSiteId", "tenantId", "networkNameOrId", null, networkExists, networkId,
 858                                         neutronNetworkId, status, vlans, subnetIdMap);
 859                 } catch (Exception e) {
 860
 861                 }
 862         }
 863
 864         @Test
 865         public void queryNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkHeatStackNull()
 866                         throws NetworkException, MsoException {
 867                 Holder<Boolean> networkExists = new Holder<>();
 868                 Holder<String> networkId = new Holder<>();
 869                 Holder<String> neutronNetworkId = new Holder<>();
 870                 Holder<NetworkStatus> status = new Holder<>();
 871                 Holder<List<Integer>> vlans = new Holder<>();
 872                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 873                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 874                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 875                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 876                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 877                 CloudSite cloudSite = new CloudSite();
 878                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 879                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 880                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 881                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 882                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 883                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 884                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 885                 doReturn(catalogDB).when(impl).getCatalogDB();
 886                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 887                                 anyString(), anyList(), anyList(), any());
 888                 impl.heat = Mockito.mock(MsoHeatUtils.class);
 889                 when(impl.heat.queryStack(any(), any(), any())).thenReturn(null);
 890                 try {
 891                         impl.queryNetwork("cloudSiteId", "tenantId", "networkNameOrId", null, networkExists, networkId,
 892                                         neutronNetworkId, status, vlans, subnetIdMap);
 893                 } catch (Exception e) {
 894
 895                 }
 896         }
 897
 898         @Test
 899         public void queryNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkHeatStackReturned()
 900                         throws NetworkException, MsoException {
 901                 Holder<Boolean> networkExists = new Holder<>();
 902                 Holder<String> networkId = new Holder<>();
 903                 Holder<String> neutronNetworkId = new Holder<>();
 904                 Holder<NetworkStatus> status = new Holder<>();
 905                 Holder<List<Integer>> vlans = new Holder<>();
 906                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 907                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 908                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 909                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 910                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 911                 CloudSite cloudSite = new CloudSite();
 912                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 913                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 914                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 915                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 916                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 917                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 918                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 919                 doReturn(catalogDB).when(impl).getCatalogDB();
 920                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 921                                 anyString(), anyList(), anyList(), any());
 922                 impl.heat = Mockito.mock(MsoHeatUtils.class);
 923                 StackInfo stackInfo = Mockito.mock(StackInfo.class);
 924                 when(stackInfo.getStatus()).thenReturn(HeatStatus.CREATED);
 925                 when(impl.heat.queryStack(any(), any(), any())).thenReturn(stackInfo);
 926                 try {
 927                         impl.queryNetwork("cloudSiteId", "tenantId", "networkNameOrId", null, networkExists, networkId,
 928                                         neutronNetworkId, status, vlans, subnetIdMap);
 929                 } catch (Exception e) {
 930
 931                 }
 932         }
 933
 934         @Test
 935         public void queryNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkHeatStackNull_QueryNeutronNetworkThrows()
 936                         throws NetworkException, MsoException {
 937                 Holder<Boolean> networkExists = new Holder<>();
 938                 Holder<String> networkId = new Holder<>();
 939                 Holder<String> neutronNetworkId = new Holder<>();
 940                 Holder<NetworkStatus> status = new Holder<>();
 941                 Holder<List<Integer>> vlans = new Holder<>();
 942                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 943                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 944                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 945                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 946                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 947                 CloudSite cloudSite = new CloudSite();
 948                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 949                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 950                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 951                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 952                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 953                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 954                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 955                 doReturn(catalogDB).when(impl).getCatalogDB();
 956                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 957                                 anyString(), anyList(), anyList(), any());
 958                 impl.heat = Mockito.mock(MsoHeatUtils.class);
 959                 when(impl.heat.queryStack(any(), any(), any())).thenReturn(null);
 960                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 961                 MsoException exception = Mockito.mock(MsoException.class);
 962                 when(impl.neutron.queryNetwork(any(), any(), any())).thenThrow(exception);
 963                 try {
 964                         impl.queryNetwork("cloudSiteId", "tenantId", "networkNameOrId", null, networkExists, networkId,
 965                                         neutronNetworkId, status, vlans, subnetIdMap);
 966                 } catch (Exception e) {
 967
 968                 }
 969         }
 970
 971         @Test
 972         public void queryNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkHeatStackNull_QueryNeutronNetworkReturns()
 973                         throws NetworkException, MsoException {
 974                 Holder<Boolean> networkExists = new Holder<>();
 975                 Holder<String> networkId = new Holder<>();
 976                 Holder<String> neutronNetworkId = new Holder<>();
 977                 Holder<NetworkStatus> status = new Holder<>();
 978                 Holder<List<Integer>> vlans = new Holder<>();
 979                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
 980                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
 981                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
 982                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
 983                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
 984                 CloudSite cloudSite = new CloudSite();
 985                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
 986                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
 987                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
 988                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
 989                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
 990                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
 991                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
 992                 doReturn(catalogDB).when(impl).getCatalogDB();
 993                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
 994                                 anyString(), anyList(), anyList(), any());
 995                 impl.heat = Mockito.mock(MsoHeatUtils.class);
 996                 when(impl.heat.queryStack(any(), any(), any())).thenReturn(null);
 997                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
 998                 NetworkInfo networkInfo = Mockito.mock(NetworkInfo.class);
 999                 when(impl.neutron.queryNetwork(any(), any(), any())).thenReturn(networkInfo);
1000                 try {
1001                         impl.queryNetwork("cloudSiteId", "tenantId", "networkNameOrId", null, networkExists, networkId,
1002                                         neutronNetworkId, status, vlans, subnetIdMap);
1003                 } catch (Exception e) {
1004
1005                 }
1006         }
1007
1008         @Test
1009         public void queryNetworkImplTest_CloudSitePresent_NeutronMode_QueryNetworkHeatStackNull_QueryNeutronNetworkNull()
1010                         throws NetworkException, MsoException {
1011                 Holder<Boolean> networkExists = new Holder<>();
1012                 Holder<String> networkId = new Holder<>();
1013                 Holder<String> neutronNetworkId = new Holder<>();
1014                 Holder<NetworkStatus> status = new Holder<>();
1015                 Holder<List<Integer>> vlans = new Holder<>();
1016                 Holder<Map<String, String>> subnetIdMap = new Holder<>();
1017                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
1018                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
1019                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
1020                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
1021                 CloudSite cloudSite = new CloudSite();
1022                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(cloudSite);
1023                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
1024                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
1025                 CatalogDatabase catalogDB = Mockito.mock(CatalogDatabase.class);
1026                 NetworkResource networkResource = Mockito.mock(NetworkResource.class);
1027                 when(networkResource.getOrchestrationMode()).thenReturn("NEUTRON");
1028                 when(networkResource.getNeutronNetworkType()).thenReturn("BASIC");
1029                 doReturn(catalogDB).when(impl).getCatalogDB();
1030                 doReturn(networkResource).when(impl).networkCheck(any(), anyLong(), anyString(), anyString(), anyString(),
1031                                 anyString(), anyList(), anyList(), any());
1032                 impl.heat = Mockito.mock(MsoHeatUtils.class);
1033                 when(impl.heat.queryStack(any(), any(), any())).thenReturn(null);
1034                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
1035                 when(impl.neutron.queryNetwork(any(), any(), any())).thenReturn(null);
1036                 try {
1037                         impl.queryNetwork("cloudSiteId", "tenantId", "networkNameOrId", null, networkExists, networkId,
1038                                         neutronNetworkId, status, vlans, subnetIdMap);
1039                 } catch (Exception e) {
1040
1041                 }
1042         }
1043
1044         @Test
1045         public void deleteNetworkImplTest_CloudSiteNotPresent_NullOrNotPresentCondition() throws NetworkException {
1046                 Holder<Boolean> networkDeleted = new Holder<>();
1047                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
1048                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
1049                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
1050                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
1051                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(null);
1052                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
1053                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
1054                 try {
1055                         impl.deleteNetwork(null, null, "networkType", "modelCustomizationUuid", null, null,
1056                                         networkDeleted);
1057                 } catch (Exception e) {
1058
1059                 }
1060         }
1061
1062         @Test
1063         public void deleteNetworkImplTest_CloudSiteNotPresent() throws NetworkException {
1064                 Holder<Boolean> networkDeleted = new Holder<>();
1065                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
1066                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
1067                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
1068                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
1069                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(null);
1070                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
1071                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
1072
1073                 try {
1074                         impl.deleteNetwork("cloudSiteId", "tenantId", "networkType", "modelCustomizationUuid", "networkId", null,
1075                                         networkDeleted);
1076                 } catch (Exception e) {
1077
1078                 }
1079         }
1080
1081         @Test
1082         public void deleteNetworkImplTest_CloudSiteNotPresent_DBGetNetworkResource_DeleteNetworkThrows() throws NetworkException, MsoException {
1083                 Holder<Boolean> networkDeleted = new Holder<>();
1084                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
1085                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
1086                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
1087                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
1088                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(null);
1089                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
1090                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
1091                 CatalogDatabase db = Mockito.mock(CatalogDatabase.class);
1092                 when(impl.getCatalogDB()).thenReturn(db);
1093                 NetworkResource resource = Mockito.mock(NetworkResource.class);
1094                 when(resource.getOrchestrationMode()).thenReturn("NEUTRON");
1095                 when(db.getNetworkResource(any())).thenReturn(resource);
1096                 MsoException exception = Mockito.mock(MsoException.class);
1097                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
1098                 when(impl.neutron.deleteNetwork(any(), any(), any())).thenThrow(exception);
1099                 try {
1100                         impl.deleteNetwork("cloudSiteId", "tenantId", "networkType", null, "networkId", null,
1101                                         networkDeleted);
1102                 } catch (Exception e) {
1103
1104                 }
1105         }
1106
1107         @Test
1108         public void deleteNetworkImplTest_CloudSiteNotPresent_DBGetNetworkResource_NeutronDeleteNetwork() throws NetworkException, MsoException {
1109                 Holder<Boolean> networkDeleted = new Holder<>();
1110                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
1111                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
1112                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
1113                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
1114                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(null);
1115                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
1116                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
1117                 CatalogDatabase db = Mockito.mock(CatalogDatabase.class);
1118                 when(impl.getCatalogDB()).thenReturn(db);
1119                 NetworkResource resource = Mockito.mock(NetworkResource.class);
1120                 when(resource.getOrchestrationMode()).thenReturn("NEUTRON");
1121                 when(db.getNetworkResource(any())).thenReturn(resource);
1122                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
1123                 when(impl.neutron.deleteNetwork(any(), any(), any())).thenReturn(true);
1124                 try {
1125                         impl.deleteNetwork("cloudSiteId", "tenantId", "networkType", null, "networkId", null,
1126                                         networkDeleted);
1127                 } catch (Exception e) {
1128
1129                 }
1130         }
1131
1132         @Test
1133         public void deleteNetworkImplTest_CloudSiteNotPresent_DBGetNetworkResource_ModeHeat_QueryStack_DeleteStack() throws NetworkException, MsoException {
1134                 Holder<Boolean> networkDeleted = new Holder<>();
1135                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
1136                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
1137                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
1138                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
1139                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(null);
1140                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
1141                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
1142                 CatalogDatabase db = Mockito.mock(CatalogDatabase.class);
1143                 when(impl.getCatalogDB()).thenReturn(db);
1144                 NetworkResource resource = Mockito.mock(NetworkResource.class);
1145                 when(resource.getOrchestrationMode()).thenReturn("HEAT");
1146                 when(db.getNetworkResource(any())).thenReturn(resource);
1147                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
1148                 when(impl.neutron.deleteNetwork(any(), any(), any())).thenReturn(true);
1149                 impl.heat = Mockito.mock(MsoHeatUtils.class);
1150                 StackInfo stackInfo = new StackInfo();
1151                 stackInfo.setStatus(HeatStatus.CREATED);
1152                 when(impl.heat.queryStack(any(), any(), any())).thenReturn(stackInfo);
1153                 StackInfo stackInfoDeleted = new StackInfo();
1154                 stackInfo.setStatus(HeatStatus.DELETING);
1155                 when(impl.heat.deleteStack(any(), any(), any(), anyBoolean())).thenReturn(stackInfoDeleted);
1156                 try {
1157                         impl.deleteNetwork("cloudSiteId", "tenantId", "networkType", null, "networkId", null,
1158                                         networkDeleted);
1159                 } catch (Exception e) {
1160
1161                 }
1162         }
1163
1164         @Test
1165         public void deleteNetworkImplTest_CloudSiteNotPresent_DBGetNetworkResource_ModeHeat_QueryStackException() throws NetworkException, MsoException {
1166                 Holder<Boolean> networkDeleted = new Holder<>();
1167                 MsoNetworkAdapterImpl impl = Mockito.spy(MsoNetworkAdapterImpl.class);
1168                 impl.cloudConfigFactory = Mockito.mock(CloudConfigFactory.class);
1169                 CloudConfig cloudConfig = Mockito.mock(CloudConfig.class);
1170                 when(impl.cloudConfigFactory.getCloudConfig()).thenReturn(cloudConfig);
1171                 Optional<CloudSite> cloudSiteOpt = Optional.ofNullable(null);
1172                 when(cloudConfig.getCloudSite(any())).thenReturn(cloudSiteOpt);
1173                 impl.msoPropertiesFactory = Mockito.mock(MsoPropertiesFactory.class);
1174                 CatalogDatabase db = Mockito.mock(CatalogDatabase.class);
1175                 when(impl.getCatalogDB()).thenReturn(db);
1176                 NetworkResource resource = Mockito.mock(NetworkResource.class);
1177                 when(resource.getOrchestrationMode()).thenReturn("HEAT");
1178                 when(db.getNetworkResource(any())).thenReturn(resource);
1179                 impl.neutron = Mockito.mock(MsoNeutronUtils.class);
1180                 when(impl.neutron.deleteNetwork(any(), any(), any())).thenReturn(true);
1181                 impl.heat = Mockito.mock(MsoHeatUtils.class);
1182                 StackInfo stackInfo = new StackInfo();
1183                 stackInfo.setStatus(HeatStatus.CREATED);
1184                 MsoException exception = Mockito.mock(MsoException.class);
1185                 when(impl.heat.queryStack(any(), any(), any())).thenThrow(exception);
1186                 try {
1187                         impl.deleteNetwork("cloudSiteId", "tenantId", "networkType", null, "networkId", null,
1188                                         networkDeleted);
1189                 } catch (Exception e) {
1190
1191                 }
1192         }
1193 }