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

   1 package org.opencomp.vid.services;
   2
   3 import com.google.common.collect.ImmutableList;
   4 import org.mockito.InjectMocks;
   5 import org.mockito.MockitoAnnotations;
   6 import org.onap.vid.aai.util.AAITreeConverter;
   7 import org.onap.vid.model.Action;
   8 import org.onap.vid.model.aaiTree.*;
   9 import org.testng.annotations.BeforeTest;
  10 import org.testng.annotations.DataProvider;
  11 import org.testng.annotations.Test;
  12
  13 import java.util.List;
  14
  15 import static org.hamcrest.MatcherAssert.assertThat;
  16 import static org.hamcrest.Matchers.*;
  17 import static org.onap.vid.asdc.parser.ToscaParserImpl2.Constants.A_LA_CARTE;
  18
  19 public class AAITreeConverterTest {
  20
  21     @InjectMocks
  22     private AAITreeConverter aaiTreeConverter;
  23
  24     @BeforeTest
  25     public void initMocks() {
  26         MockitoAnnotations.initMocks(this);
  27     }
  28
  29     @Test
  30     public void testConvertTreeToUIModel_NoChildren() throws Exception {
  31
  32         AAITreeNode aaiTree = generateAaiTreeToConvert(0, 0);
  33
  34         ServiceInstance result = aaiTreeConverter.convertTreeToUIModel(aaiTree, "global-customer-id", "service-type", A_LA_CARTE);
  35
  36         assertService(result, 0, 0, true);
  37     }
  38
  39     @Test
  40     public void testConvertTreeToUIModel_MultipleChildren() throws Exception {
  41
  42         AAITreeNode aaiTree = generateAaiTreeToConvert(2, 2);
  43
  44         ServiceInstance serviceInstance = aaiTreeConverter.convertTreeToUIModel(aaiTree, "global-customer-id", "service-type", null);
  45
  46         assertService(serviceInstance, 2, 2, false);
  47
  48         int nodesCounter = 0;
  49         assertThat(serviceInstance.getVnfs().entrySet(), hasSize(2));
  50         assertVnf(serviceInstance.getVnfs().get("vnf-model-version-id:00"+(nodesCounter++)), 0, 0, false);
  51         assertVnf(serviceInstance.getVnfs().get("vnf-model-version-id:00"+(nodesCounter++)), 0, 0, false);
  52
  53         assertThat(serviceInstance.getNetworks().entrySet(), hasSize(2));
  54         assertNetwork(serviceInstance.getNetworks().get("network-model-version-id:00"+(nodesCounter++)), false);
  55         assertNetwork(serviceInstance.getNetworks().get("network-model-version-id:00"+(nodesCounter)), false);
  56     }
  57
  58     @DataProvider
  59     public static Object[][] vnfWithChildren() {
  60         return new Object[][]{
  61                 {ImmutableList.of(), ImmutableList.of()},
  62                 {ImmutableList.of(true, false), ImmutableList.of()},
  63                 {ImmutableList.of(), ImmutableList.of(false)}
  64         };
  65     }
  66
  67     @Test(dataProvider = "vnfWithChildren")
  68     public void testComplexVnfConversion(List<Boolean> vfModules, List<Boolean> networks) {
  69
  70         AAITreeNode vnfTreeNode = createVnf(1, false);
  71         int nodesCounter = 0;
  72
  73         for (Boolean customizationName: vfModules) {
  74             vnfTreeNode.getChildren().add(createVfModule(nodesCounter++, customizationName));
  75         }
  76
  77         for (Boolean customizationName: networks) {
  78             vnfTreeNode.getChildren().add(createNetwork(nodesCounter++, customizationName));
  79         }
  80
  81         Vnf actualVnf = Vnf.from(vnfTreeNode);
  82
  83         assertVnf(actualVnf, vfModules.size(), networks.size(), false);
  84
  85         nodesCounter = 0;
  86         for (Boolean customizationName: vfModules) {
  87             String key = customizationName ? "vfModule key in model" : "vfModule-model-version-id";
  88
  89             assertThat(actualVnf.getVfModules(), hasKey(key));
  90             assertThat(actualVnf.getVfModules().get(key), hasKey(key + ":00" + nodesCounter));
  91             VfModule actualVfModule = actualVnf.getVfModules().get(key).get(key + ":00" + nodesCounter);
  92             assertVfModule(actualVfModule, customizationName);
  93             nodesCounter++;
  94         }
  95
  96         for (Boolean customizationName: networks) {
  97             String key = customizationName ? "network key in model" : "network-model-version-id";
  98
  99             assertThat(actualVnf.getNetworks(), hasKey(key + ":00" + nodesCounter));
 100             Network actualNetwork = actualVnf.getNetworks().get(key + ":00" + nodesCounter);
 101             assertNetwork(actualNetwork, customizationName);
 102             nodesCounter++;
 103         }
 104     }
 105
 106     @Test
 107     public void testNetworkConversion() {
 108         AAITreeNode networkTreeNode = createNetwork(1, true);
 109
 110         Network actualNetwork = Network.from(networkTreeNode);
 111
 112         assertNetwork(actualNetwork, true);
 113     }
 114
 115     private AAITreeNode createVnf(int uniqueNumber, boolean hasCustomizationName) {
 116         AAITreeNode vnfTreeNode = new AAITreeNode();
 117         vnfTreeNode.setId("vnf-instance-id");
 118         vnfTreeNode.setName("vnf-instance-name");
 119         vnfTreeNode.setType("generic-vnf");
 120         vnfTreeNode.setModelVersionId("vnf-model-version-id");
 121         if (hasCustomizationName) {
 122             vnfTreeNode.setModelCustomizationName("vnf model customization name");
 123             vnfTreeNode.setKeyInModel("vnf key in model");
 124         }
 125         vnfTreeNode.setUniqueNumber(uniqueNumber);
 126         return vnfTreeNode;
 127     }
 128
 129     private AAITreeNode createVfModule(int uniqueNumber, boolean hasCustomizationName) {
 130         AAITreeNode vfModuleTreeNode = new AAITreeNode();
 131         vfModuleTreeNode.setId("vfModule-instance-id");
 132         vfModuleTreeNode.setName("vfModule-instance-name");
 133         vfModuleTreeNode.setType("vf-module");
 134         vfModuleTreeNode.setModelVersionId("vfModule-model-version-id");
 135         if (hasCustomizationName) {
 136             vfModuleTreeNode.setModelCustomizationName("vfModule model customization name");
 137             vfModuleTreeNode.setKeyInModel("vfModule key in model");
 138         }
 139         vfModuleTreeNode.setUniqueNumber(uniqueNumber);
 140
 141         return vfModuleTreeNode;
 142     }
 143
 144     private AAITreeNode createNetwork(int uniqueNumber, boolean hasCustomizationName) {
 145         AAITreeNode networkTreeNode = new AAITreeNode();
 146         networkTreeNode.setId("network-instance-id");
 147         networkTreeNode.setName("network-instance-name");
 148         networkTreeNode.setType("l3-network");
 149         networkTreeNode.setModelVersionId("network-model-version-id");
 150         if (hasCustomizationName) {
 151             networkTreeNode.setModelCustomizationName("network model customization name");
 152             networkTreeNode.setKeyInModel("network key in model");
 153         }
 154         networkTreeNode.setUniqueNumber(uniqueNumber);
 155
 156         return networkTreeNode;
 157     }
 158
 159     private void assertService(ServiceInstance serviceInstance, int expectedVnfs, int expectedNetworks, boolean isALaCarte) {
 160         assertThat(serviceInstance.getInstanceId(), is("service-instance-id"));
 161         assertThat(serviceInstance.getInstanceName(), is("service-instance-name"));
 162         assertThat(serviceInstance.getAction(), is(Action.None));
 163         assertThat(serviceInstance.getGlobalSubscriberId(), is("global-customer-id"));
 164         assertThat(serviceInstance.getSubscriptionServiceType(), is("service-type"));
 165         assertThat(serviceInstance.getModelInfo().getModelType(), is("service"));
 166         assertThat(serviceInstance.getVnfs().entrySet(), hasSize(expectedVnfs));
 167         assertThat(serviceInstance.getNetworks().entrySet(), hasSize(expectedNetworks));
 168         assertThat(serviceInstance.getIsALaCarte(), is(isALaCarte));
 169     }
 170
 171     private void assertVnf(Vnf actualVnf, int expectedVfModules, int expectedNetworks, boolean hasCustomizationName) {
 172         assertThat(actualVnf.getInstanceId(), is("vnf-instance-id"));
 173         assertThat(actualVnf.getInstanceName(), is("vnf-instance-name"));
 174         assertThat(actualVnf.getAction(), is(Action.None));
 175         assertThat(actualVnf.getModelInfo().getModelType(), is("vnf"));
 176         assertThat(actualVnf.getModelInfo().getModelVersionId(), is("vnf-model-version-id"));
 177         assertThat(actualVnf.getVfModules().entrySet(), hasSize(expectedVfModules));
 178         assertThat(actualVnf.getNetworks().entrySet(), hasSize(expectedNetworks));
 179         assertThat(actualVnf.getTrackById(), is(not(emptyOrNullString())));
 180         String expectedCustomizationName = hasCustomizationName ? "vnf model customization name" : null;
 181         assertThat(actualVnf.getModelInfo().getModelCustomizationName(), is(expectedCustomizationName));
 182     }
 183
 184     private void assertVfModule(VfModule actualVfModule, boolean hasCustomizationName) {
 185         assertThat(actualVfModule.getInstanceId(), is("vfModule-instance-id"));
 186         assertThat(actualVfModule.getInstanceName(), is("vfModule-instance-name"));
 187         assertThat(actualVfModule.getAction(), is(Action.None));
 188         assertThat(actualVfModule.getModelInfo().getModelType(), is("vfModule"));
 189         assertThat(actualVfModule.getModelInfo().getModelVersionId(), is("vfModule-model-version-id"));
 190         assertThat(actualVfModule.getTrackById(), is(not(emptyOrNullString())));
 191         String expectedCustomizationName = hasCustomizationName ? "vfModule model customization name" : null;
 192         assertThat(actualVfModule.getModelInfo().getModelCustomizationName(), is(expectedCustomizationName));
 193     }
 194
 195     private void assertNetwork(Network actualNetwork, boolean hasCustomizationName) {
 196         assertThat(actualNetwork.getInstanceId(), is("network-instance-id"));
 197         assertThat(actualNetwork.getInstanceName(), is("network-instance-name"));
 198         assertThat(actualNetwork.getAction(), is(Action.None));
 199         assertThat(actualNetwork.getModelInfo().getModelType(), is("network"));
 200         assertThat(actualNetwork.getModelInfo().getModelVersionId(), is("network-model-version-id"));
 201         assertThat(actualNetwork.getTrackById(), is(not(emptyOrNullString())));
 202         String expectedCustomizationName = hasCustomizationName ? "network model customization name" : null;
 203         assertThat(actualNetwork.getModelInfo().getModelCustomizationName(), is(expectedCustomizationName));
 204     }
 205
 206     private AAITreeNode generateAaiTreeToConvert(int numberOfVnfs, int numberOfNetworks) {
 207         int counter = 0;
 208         AAITreeNode aaiTree = new AAITreeNode();
 209         aaiTree.setId("service-instance-id");
 210         aaiTree.setName("service-instance-name");
 211
 212         for (int i = 0; i < numberOfVnfs; i++) {
 213             aaiTree.getChildren().add(createVnf(counter++, false));
 214         }
 215
 216         for (int i = 0; i < numberOfNetworks; i++) {
 217             aaiTree.getChildren().add(createNetwork(counter++, false));
 218         }
 219
 220         return aaiTree;
 221     }
 222 }