vid-app-common/src/test/java/org/onap/vid/aai/AAITreeConverterTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * VID
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
   6  * Modifications Copyright (C) 2019 Nokia. All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21 package org.onap.vid.aai;
  22
  23 import com.google.common.collect.ImmutableList;
  24 import org.mockito.InjectMocks;
  25 import org.mockito.MockitoAnnotations;
  26 import org.onap.vid.aai.util.AAITreeConverter;
  27 import org.onap.vid.model.Action;
  28 import org.onap.vid.model.aaiTree.*;
  29 import org.onap.vid.model.aaiTree.ServiceInstance;
  30 import org.onap.vid.mso.model.CloudConfiguration;
  31 import org.testng.annotations.BeforeTest;
  32 import org.testng.annotations.DataProvider;
  33 import org.testng.annotations.Test;
  34
  35 import java.util.List;
  36
  37 import static org.hamcrest.CoreMatchers.*;
  38 import static org.hamcrest.MatcherAssert.assertThat;
  39 import static org.hamcrest.Matchers.emptyOrNullString;
  40 import static org.hamcrest.Matchers.hasKey;
  41 import static org.hamcrest.Matchers.hasSize;
  42 import static org.hamcrest.Matchers.is;
  43 import static org.hamcrest.Matchers.not;
  44 import static org.onap.vid.asdc.parser.ToscaParserImpl2.Constants.A_LA_CARTE;
  45 import static org.testng.Assert.assertNull;
  46
  47 public class AAITreeConverterTest {
  48
  49     @InjectMocks
  50     private AAITreeConverter aaiTreeConverter;
  51
  52     @BeforeTest
  53     public void initMocks() {
  54         MockitoAnnotations.initMocks(this);
  55     }
  56
  57     @Test
  58     public void testConvertTreeToUIModel_NoChildren() throws Exception {
  59
  60         AAITreeNode aaiTree = generateAaiTreeToConvert(0, 0);
  61
  62         ServiceInstance result = aaiTreeConverter.convertTreeToUIModel(aaiTree, "global-customer-id", "service-type", A_LA_CARTE, "", "");
  63
  64         assertService(result, 0, 0, true);
  65     }
  66
  67     @Test
  68     public void testConvertTreeToUIModel_MultipleChildren() {
  69
  70         AAITreeNode aaiTree = generateAaiTreeToConvert(2, 2);
  71
  72         ServiceInstance serviceInstance = aaiTreeConverter.convertTreeToUIModel(aaiTree, "global-customer-id", "service-type", null, "", "");
  73
  74         assertService(serviceInstance, 2, 2, false);
  75
  76         int nodesCounter = 0;
  77         assertThat(serviceInstance.getVnfs().entrySet(), hasSize(2));
  78         assertVnf(serviceInstance.getVnfs().get("vnf-instance-id" + (nodesCounter++)), 0, 0);
  79         assertVnf(serviceInstance.getVnfs().get("vnf-instance-id" + (nodesCounter++)), 0, 0);
  80
  81         assertThat(serviceInstance.getNetworks().entrySet(), hasSize(2));
  82         assertNetwork(serviceInstance.getNetworks().get("network-instance-id" + (nodesCounter++)), false);
  83         assertNetwork(serviceInstance.getNetworks().get("network-instance-id" + (nodesCounter++)), false);
  84
  85         assertThat(serviceInstance.getVnfGroups().size(), equalTo(1));
  86         assertThat(serviceInstance.getVnfGroups().get("vnf-group-id" + (nodesCounter++)).getInstanceId(), startsWith("vnf-group-id"));
  87
  88         assertThat(serviceInstance.getCollectionResources().size(), equalTo(1));
  89         CollectionResource cr = serviceInstance.getCollectionResources().get("cr-id" + (nodesCounter++));
  90         assertThat(cr.getInstanceId(), startsWith("cr-id"));
  91
  92         assertThat(cr.getNcfs().size(), equalTo(1));
  93         assertThat(cr.getNcfs().get("ncf-id").getInstanceId(), startsWith("ncf-id"));
  94
  95         assertThat(serviceInstance.getExistingVNFCounterMap().get("vnf-model-customization-id"), equalTo(2L));
  96         assertThat(serviceInstance.getExistingNetworksCounterMap().get("network-model-customization-id"), equalTo(2L));
  97     }
  98
  99     @DataProvider
 100     public static Object[][] vnfWithChildren() {
 101         return new Object[][]{
 102                 {ImmutableList.of(), ImmutableList.of()},
 103                 {ImmutableList.of(true, false), ImmutableList.of()},
 104                 {ImmutableList.of(), ImmutableList.of(false)}
 105         };
 106     }
 107
 108     @Test(dataProvider = "vnfWithChildren")
 109     public void testComplexVnfConversion(List<Boolean> vfModules, List<Boolean> networks) {
 110
 111         AAITreeNode vnfTreeNode = createVnf(1, false);
 112         int nodesCounter = 0;
 113
 114         for (Boolean customizationName: vfModules) {
 115             vnfTreeNode.getChildren().add(createVfModule(customizationName));
 116         }
 117
 118         for (Boolean customizationName: networks) {
 119             vnfTreeNode.getChildren().add(createNetwork(nodesCounter++, customizationName));
 120         }
 121
 122         Vnf actualVnf = Vnf.from(vnfTreeNode);
 123
 124         assertVnf(actualVnf, vfModules.size(), networks.size());
 125
 126         nodesCounter = 0;
 127         for (Boolean customizationName: vfModules) {
 128             String key = customizationName ? "vfModule key in model" : "vfModule-model-version-id";
 129
 130             assertThat(actualVnf.getVfModules(), hasKey(key));
 131             assertThat(actualVnf.getVfModules().get(key), hasKey("vfModule-instance-id"));
 132             VfModule actualVfModule = actualVnf.getVfModules().get(key).get("vfModule-instance-id");
 133             assertVfModule(actualVfModule, customizationName);
 134         }
 135
 136         for (Boolean customizationName: networks) {
 137             assertThat(actualVnf.getNetworks(), hasKey("network-instance-id" + nodesCounter));
 138             Network actualNetwork = actualVnf.getNetworks().get("network-instance-id" + nodesCounter);
 139             assertNetwork(actualNetwork, customizationName);
 140             nodesCounter++;
 141         }
 142     }
 143
 144     @Test
 145     public void testNetworkConversion() {
 146         AAITreeNode networkTreeNode = createNetwork(1, true);
 147
 148         Network actualNetwork = Network.from(networkTreeNode);
 149
 150         assertNetwork(actualNetwork, true);
 151     }
 152
 153     private AAITreeNode createVnf(int uniqueNumber, boolean hasCustomizationName) {
 154         AAITreeNode vnfTreeNode = new AAITreeNode();
 155         vnfTreeNode.setId("vnf-instance-id" + uniqueNumber);
 156         vnfTreeNode.setName("vnf-instance-name");
 157         vnfTreeNode.setType(NodeType.GENERIC_VNF);
 158         vnfTreeNode.setModelVersionId("vnf-model-version-id");
 159         vnfTreeNode.setModelCustomizationId("vnf-model-customization-id");
 160         if (hasCustomizationName) {
 161             vnfTreeNode.setModelCustomizationName("vnf model customization name");
 162             vnfTreeNode.setKeyInModel("vnf key in model");
 163         }
 164         return vnfTreeNode;
 165     }
 166
 167     private AAITreeNode createVnfGroup(int uniqueNumber) {
 168         AAITreeNode treeNode = new AAITreeNode();
 169         treeNode.setId("vnf-group-id" + uniqueNumber);
 170         treeNode.setType(NodeType.INSTANCE_GROUP);
 171         treeNode.getAdditionalProperties().put("instance-group-type", "vnfGroup-type");
 172         return treeNode;
 173     }
 174
 175     private AAITreeNode createCollectionResource(int uniqueNumber) {
 176         AAITreeNode treeNode = new AAITreeNode();
 177         treeNode.setId("cr-id" + uniqueNumber);
 178         treeNode.setType(NodeType.COLLECTION_RESOURCE);
 179         treeNode.getChildren().add(createNCF());
 180         return treeNode;
 181     }
 182
 183     private AAITreeNode createNCF() {
 184         AAITreeNode treeNode = new AAITreeNode();
 185         treeNode.setId("ncf-id");
 186         treeNode.setType(NodeType.INSTANCE_GROUP);
 187         treeNode.getAdditionalProperties().put("instance-group-type", "L3-NETWORK");
 188         return treeNode;
 189     }
 190
 191     @Test
 192     public void givenPlacementIsNull_whenConvertToNetwork_relevantFieldsAreAlsoNull() {
 193         AAITreeNode aaiTreeNode = new AAITreeNode();
 194         aaiTreeNode.setType(NodeType.NETWORK);
 195         Network actualNetwork = Network.from(aaiTreeNode);
 196         assertNull(actualNetwork.getCloudOwner());
 197         assertNull(actualNetwork.getLcpCloudRegionId());
 198         assertNull(actualNetwork.getTenantId());
 199     }
 200
 201     private AAITreeNode createVfModule(boolean hasCustomizationName) {
 202         AAITreeNode vfModuleTreeNode = new AAITreeNode();
 203         vfModuleTreeNode.setId("vfModule-instance-id");
 204         vfModuleTreeNode.setName("vfModule-instance-name");
 205         vfModuleTreeNode.setType(NodeType.VF_MODULE);
 206         vfModuleTreeNode.setModelVersionId("vfModule-model-version-id");
 207         vfModuleTreeNode.setModelCustomizationId("vfModule-model-customization-id");
 208         if (hasCustomizationName) {
 209             vfModuleTreeNode.setModelCustomizationName("vfModule model customization name");
 210             vfModuleTreeNode.setKeyInModel("vfModule key in model");
 211         }
 212         vfModuleTreeNode.setCloudConfiguration(new CloudConfiguration("lcpRegion2", "tenant3", "cloudOwner1"));
 213         return vfModuleTreeNode;
 214     }
 215
 216     private AAITreeNode createNetwork(int uniqueNumber, boolean hasCustomizationName) {
 217         AAITreeNode networkTreeNode = new AAITreeNode();
 218         networkTreeNode.setId("network-instance-id" + uniqueNumber);
 219         networkTreeNode.setName("network-instance-name");
 220         networkTreeNode.setType(NodeType.NETWORK);
 221         networkTreeNode.setModelVersionId("network-model-version-id");
 222         networkTreeNode.setModelCustomizationId("network-model-customization-id");
 223         if (hasCustomizationName) {
 224             networkTreeNode.setModelCustomizationName("network model customization name");
 225             networkTreeNode.setKeyInModel("network key in model");
 226         }
 227         networkTreeNode.setCloudConfiguration(new CloudConfiguration("auk51a", "b530fc990b6d4334bd45518bebca6a51", "att-nc"));
 228         return networkTreeNode;
 229     }
 230
 231     private void assertService(ServiceInstance serviceInstance, int expectedVnfs, int expectedNetworks, boolean isALaCarte) {
 232         assertThat(serviceInstance.getInstanceId(), is("service-instance-id"));
 233         assertThat(serviceInstance.getInstanceName(), is("service-instance-name"));
 234         assertThat(serviceInstance.getAction(), is(Action.None));
 235         assertThat(serviceInstance.getGlobalSubscriberId(), is("global-customer-id"));
 236         assertThat(serviceInstance.getSubscriptionServiceType(), is("service-type"));
 237         assertThat(serviceInstance.getModelInfo().getModelType(), is("service"));
 238         assertThat(serviceInstance.getVnfs().entrySet(), hasSize(expectedVnfs));
 239         assertThat(serviceInstance.getNetworks().entrySet(), hasSize(expectedNetworks));
 240         assertThat(serviceInstance.getIsALaCarte(), is(isALaCarte));
 241     }
 242
 243     private void assertVnf(Vnf actualVnf, int expectedVfModules, int expectedNetworks) {
 244         assertThat(actualVnf.getInstanceId(), containsString("vnf-instance-id"));
 245         assertThat(actualVnf.getInstanceName(), is("vnf-instance-name"));
 246         assertThat(actualVnf.getAction(), is(Action.None));
 247         assertThat(actualVnf.getModelInfo().getModelType(), is("vnf"));
 248         assertThat(actualVnf.getModelInfo().getModelVersionId(), is("vnf-model-version-id"));
 249         assertThat(actualVnf.getVfModules().entrySet(), hasSize(expectedVfModules));
 250         assertThat(actualVnf.getNetworks().entrySet(), hasSize(expectedNetworks));
 251         assertThat(actualVnf.getTrackById(), containsString("vnf-instance-id"));
 252         assertNull(actualVnf.getModelInfo().getModelCustomizationName());
 253     }
 254
 255     private void assertVfModule(VfModule actualVfModule, boolean hasCustomizationName) {
 256         assertThat(actualVfModule.getInstanceId(), is("vfModule-instance-id"));
 257         assertThat(actualVfModule.getInstanceName(), is("vfModule-instance-name"));
 258         assertThat(actualVfModule.getAction(), is(Action.None));
 259         assertThat(actualVfModule.getModelInfo().getModelType(), is("vfModule"));
 260         assertThat(actualVfModule.getModelInfo().getModelVersionId(), is("vfModule-model-version-id"));
 261         assertThat(actualVfModule.getTrackById(), is("vfModule-instance-id"));
 262         String expectedCustomizationName = hasCustomizationName ? "vfModule model customization name" : null;
 263         assertThat(actualVfModule.getModelInfo().getModelCustomizationName(), is(expectedCustomizationName));
 264         assertThat(actualVfModule.getCloudOwner(), is("cloudOwner1"));
 265         assertThat(actualVfModule.getLcpCloudRegionId(), is("lcpRegion2"));
 266         assertThat(actualVfModule.getTenantId(), is("tenant3"));
 267     }
 268
 269     private void assertNetwork(Network actualNetwork, boolean hasCustomizationName) {
 270         assertThat(actualNetwork.getInstanceId(), containsString("network-instance-id"));
 271         assertThat(actualNetwork.getInstanceName(), is("network-instance-name"));
 272         assertThat(actualNetwork.getAction(), is(Action.None));
 273         assertThat(actualNetwork.getModelInfo().getModelType(), is("network"));
 274         assertThat(actualNetwork.getModelInfo().getModelVersionId(), is("network-model-version-id"));
 275         assertThat(actualNetwork.getTrackById(), containsString("network-instance-id"));
 276         String expectedCustomizationName = hasCustomizationName ? "network model customization name" : null;
 277         assertThat(actualNetwork.getModelInfo().getModelCustomizationName(), is(expectedCustomizationName));
 278         assertThat(actualNetwork.getCloudOwner(), is("att-nc"));
 279         assertThat(actualNetwork.getLcpCloudRegionId(), is("auk51a"));
 280         assertThat(actualNetwork.getTenantId(), is("b530fc990b6d4334bd45518bebca6a51"));
 281
 282     }
 283
 284     private AAITreeNode generateAaiTreeToConvert(int numberOfVnfs, int numberOfNetworks) {
 285         int counter = 0;
 286         AAITreeNode aaiTree = new AAITreeNode();
 287         aaiTree.setId("service-instance-id");
 288         aaiTree.setName("service-instance-name");
 289         aaiTree.setType(NodeType.SERVICE_INSTANCE);
 290
 291         for (int i = 0; i < numberOfVnfs; i++) {
 292             aaiTree.getChildren().add(createVnf(counter++, false));
 293         }
 294
 295         for (int i = 0; i < numberOfNetworks; i++) {
 296             aaiTree.getChildren().add(createNetwork(counter++, false));
 297         }
 298
 299         aaiTree.getChildren().add(createVnfGroup(counter++));
 300         aaiTree.getChildren().add(createCollectionResource(counter++));
 301
 302         return aaiTree;
 303     }
 304 }