appc-dg/appc-dg-shared/appc-dg-dependency-model/src/test/java/org/onap/appc/dg/flowbuilder/TestFlowBuilder.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP : APPC
   4  * ================================================================================
   5  * Copyright (C) 2017-2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Copyright (C) 2017 Amdocs
   8  * ================================================================================
   9  * Modifications (C) 2019 Ericsson
  10  * ================================================================================
  11  * Modifications (C) 2019 IBM
  12  * =============================================================================
  13  * Licensed under the Apache License, Version 2.0 (the "License");
  14  * you may not use this file except in compliance with the License.
  15  * You may obtain a copy of the License at
  16  *
  17  *      http://www.apache.org/licenses/LICENSE-2.0
  18  *
  19  * Unless required by applicable law or agreed to in writing, software
  20  * distributed under the License is distributed on an "AS IS" BASIS,
  21  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  22  * See the License for the specific language governing permissions and
  23  * limitations under the License.
  24  * ============LICENSE_END=========================================================
  25  */
  26
  27 package org.onap.appc.dg.flowbuilder;
  28
  29 import org.hamcrest.CoreMatchers;
  30 import org.junit.Assert;
  31 import org.junit.Test;
  32 import org.onap.appc.dg.flowbuilder.FlowBuilder;
  33 import org.onap.appc.dg.flowbuilder.exception.InvalidDependencyModelException;
  34 import org.onap.appc.dg.flowbuilder.impl.FlowBuilderFactory;
  35 import org.onap.appc.dg.objects.*;
  36 import org.onap.appc.domainmodel.Vnf;
  37 import org.onap.appc.domainmodel.Vnfc;
  38 import org.onap.appc.domainmodel.Vserver;
  39
  40 import java.util.HashSet;
  41 import java.util.Iterator;
  42 import java.util.List;
  43 import java.util.Set;
  44
  45
  46 public class TestFlowBuilder {
  47     @Test
  48     public void testForwardFlowBuilder() throws InvalidDependencyModelException {
  49         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.FORWARD);
  50         VnfcDependencyModel dependencyModel = readDependencyModel();
  51         InventoryModel inventoryModel = readInventoryModel();
  52         VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel, inventoryModel);
  53         Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
  54
  55         List<Vnfc> list = itr.next();
  56         Assert.assertTrue(list.contains(createVnfc("SMP", "Active-Passive", "SMP_Name")));
  57
  58         list = itr.next();
  59         Assert.assertTrue(list.contains(createVnfc("BE", "Active-Active", "BE_Name")));
  60
  61         list = itr.next();
  62         Assert.assertTrue(list.contains(createVnfc("FE", "Active-Active", "FE_Name")));
  63     }
  64
  65     private Vnfc createVnfc(String vnfcType, String resilienceType, String vnfcName) {
  66         Vnfc vnfc = new Vnfc();
  67         vnfc.setVnfcType(vnfcType);
  68         vnfc.setVnfcName(vnfcName);
  69         vnfc.setResilienceType(resilienceType);
  70         return vnfc;
  71     }
  72
  73     @Test
  74     public void testReverseFlowBuilder() throws InvalidDependencyModelException {
  75         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.REVERSE);
  76         VnfcDependencyModel dependencyModel = readDependencyModel();
  77         InventoryModel inventoryModel = readInventoryModel();
  78         VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel, inventoryModel);
  79         Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
  80
  81         List<Vnfc> list = itr.next();
  82         Assert.assertTrue(list.contains(createVnfc("FE", "Active-Active", "FE_Name")));
  83
  84         list = itr.next();
  85         Assert.assertTrue(list.contains(createVnfc("BE", "Active-Active", "BE_Name")));
  86
  87         list = itr.next();
  88         Assert.assertTrue(list.contains(createVnfc("SMP", "Active-Passive", "SMP_Name")));
  89
  90         Assert.assertThat(flowModel.toString(), CoreMatchers.containsString("Flow Model : Vnfc : vnfcType = FE"));
  91     }
  92
  93     @Test
  94     public void testComplexFlowBuilderForward() throws InvalidDependencyModelException {
  95         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.FORWARD);
  96         VnfcDependencyModel dependencyModel = readComplexDependencyModel();
  97         InventoryModel inventoryModel = readComplexInventoryModel();
  98         VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel, inventoryModel);
  99         Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
 100         try {
 101             List<Vnfc> list = itr.next();
 102             Assert.assertTrue(list.contains(createVnfc("A", "Active-Active", "A_Name")));
 103             Assert.assertTrue(list.contains(createVnfc("E", "Active-Active", "E_Name")));
 104
 105             list = itr.next();
 106             Assert.assertTrue(list.contains(createVnfc("B", "Active-Active", "B_Name")));
 107             Assert.assertTrue(list.contains(createVnfc("C", "Active-Active", "C_Name")));
 108
 109             list = itr.next();
 110             Assert.assertTrue(list.contains(createVnfc("D", "Active-Active", "D_Name")));
 111             Assert.assertTrue(list.contains(createVnfc("F", "Active-Active", "F_Name")));
 112
 113             list = itr.next();
 114             Assert.assertTrue(list.contains(createVnfc("G", "Active-Active", "G_Name")));
 115         } catch (Exception e) {
 116             e.printStackTrace();
 117         }
 118     }
 119
 120     @Test
 121     public void testComplexFlowBuilderReverse() throws InvalidDependencyModelException {
 122         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.REVERSE);
 123         VnfcDependencyModel dependencyModel = readComplexDependencyModel();
 124         InventoryModel inventoryModel = readComplexInventoryModel();
 125         VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel, inventoryModel);
 126         Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
 127
 128         List<Vnfc> list = itr.next();
 129         Assert.assertTrue(list.contains(createVnfc("D", "Active-Active", "D_Name")));
 130
 131         Assert.assertTrue(list.contains(createVnfc("G", "Active-Active", "G_Name")));
 132
 133         list = itr.next();
 134         Assert.assertTrue(list.contains(createVnfc("B", "Active-Active", "B_Name")));
 135         Assert.assertTrue(list.contains(createVnfc("F", "Active-Active", "F_Name")));
 136
 137         list = itr.next();
 138         Assert.assertTrue(list.contains(createVnfc("C", "Active-Active", "C_Name")));
 139
 140         list = itr.next();
 141         Assert.assertTrue(list.contains(createVnfc("E", "Active-Active", "E_Name")));
 142         Assert.assertTrue(list.contains(createVnfc("A", "Active-Active", "A_Name")));
 143
 144     }
 145
 146     @Test(expected = InvalidDependencyModelException.class)
 147     public void testCyclicBuilder() throws InvalidDependencyModelException {
 148         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.findByString("FORWARD"));
 149         VnfcDependencyModel dependencyModel = readCyclicDependencyModel();
 150         InventoryModel inventoryModel = readInventoryModel();
 151         builder.buildFlowModel(dependencyModel, inventoryModel);
 152     }
 153
 154     @Test(expected = InvalidDependencyModelException.class)
 155     public void testCyclicBuilderWithRootNode() throws InvalidDependencyModelException {
 156         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.FORWARD);
 157         VnfcDependencyModel dependencyModel = readCyclicDependencyModelWithRootNode();
 158         InventoryModel inventoryModel = readInventoryModel();
 159         builder.buildFlowModel(dependencyModel, inventoryModel);
 160     }
 161
 162     @Test
 163     public void testInventoryModelToString() {
 164         Vnf vnf = createVnf("vnf_1", "vABCD", "1");
 165         InventoryModel inventoryModel = new InventoryModel(vnf);
 166         Assert.assertEquals("InventoryModel = Vnf : vnfId = vnf_1 , vnfType = vABCD", inventoryModel.toString());
 167     }
 168
 169     private VnfcDependencyModel readCyclicDependencyModelWithRootNode() {
 170         Vnfc a = createVnfc("A", "Active-Passive", null);
 171         Vnfc b = createVnfc("B", "Active-Active", null);
 172         Vnfc c = createVnfc("C", "Active-Active", null);
 173
 174
 175         Node aNode = new Node(a);
 176         Node bNode = new Node(b);
 177         Node cNode = new Node(c);
 178
 179         Assert.assertTrue(aNode.equals(aNode));
 180         Assert.assertFalse(aNode.equals(bNode));
 181
 182         bNode.addParent(c);
 183         cNode.addParent(b);
 184
 185
 186         Set<Node<Vnfc>> dependencies = new HashSet<>();
 187         dependencies.add(aNode);
 188         dependencies.add(bNode);
 189         dependencies.add(cNode);
 190
 191         return new VnfcDependencyModel(dependencies);
 192     }
 193
 194     private InventoryModel readComplexInventoryModel() {
 195         Vnf vnf = createVnf("vnf_1", "vABCD", "1");
 196
 197         Vnfc vnfcA = createVnfc("A", "Active-Active", "A_Name");
 198         Vnfc vnfcB = createVnfc("B", "Active-Active", "B_Name");
 199         Vnfc vnfcC = createVnfc("C", "Active-Active", "C_Name");
 200         Vnfc vnfcD = createVnfc("D", "Active-Active", "D_Name");
 201         Vnfc vnfcE = createVnfc("E", "Active-Active", "E_Name");
 202         Vnfc vnfcF = createVnfc("F", "Active-Active", "F_Name");
 203         Vnfc vnfcG = createVnfc("G", "Active-Active", "G_Name");
 204
 205         vnf.addVserver(createVserver("VM_URL_A1", vnfcA));
 206         vnf.addVserver(createVserver("VM_URL_B1", vnfcB));
 207         vnf.addVserver(createVserver("VM_URL_C1", vnfcC));
 208         vnf.addVserver(createVserver("VM_URL_D1", vnfcD));
 209         vnf.addVserver(createVserver("VM_URL_E1", vnfcE));
 210         vnf.addVserver(createVserver("VM_URL_F1", vnfcF));
 211         vnf.addVserver(createVserver("VM_URL_G1", vnfcG));
 212
 213         return new InventoryModel(vnf);
 214     }
 215
 216     private Vnf createVnf(String vnfId, String vnfType, String vnfVersion) {
 217         Vnf vnf = new Vnf();
 218         vnf.setVnfId(vnfId);
 219         vnf.setVnfType(vnfType);
 220         vnf.setVnfVersion(vnfVersion);
 221         return vnf;
 222     }
 223
 224     private VnfcDependencyModel readComplexDependencyModel() {
 225         Vnfc a = createVnfc("A", "Active-Active", null);
 226         Vnfc b = createVnfc("B", "Active-Active", null);
 227         Vnfc c = createVnfc("C", "Active-Active", null);
 228         Vnfc d = createVnfc("D", "Active-Active", null);
 229         Vnfc e = createVnfc("E", "Active-Active", null);
 230         Vnfc f = createVnfc("F", "Active-Active", null);
 231         Vnfc g = createVnfc("G", "Active-Active", null);
 232
 233
 234         Node aNode = new Node(a);
 235         Node bNode = new Node(b);
 236         Node cNode = new Node(c);
 237         Node dNode = new Node(d);
 238         Node eNode = new Node(e);
 239         Node fNode = new Node(f);
 240         Node gNode = new Node(g);
 241
 242         bNode.addParent(a);
 243         cNode.addParent(a);
 244
 245         bNode.addParent(e);
 246         cNode.addParent(e);
 247
 248         dNode.addParent(b);
 249         gNode.addParent(b);
 250
 251         fNode.addParent(c);
 252
 253         gNode.addParent(f);
 254
 255         Set<Node<Vnfc>> dependencies = new HashSet<>();
 256         dependencies.add(aNode);
 257         dependencies.add(bNode);
 258         dependencies.add(cNode);
 259         dependencies.add(dNode);
 260         dependencies.add(eNode);
 261         dependencies.add(fNode);
 262         dependencies.add(gNode);
 263
 264         return new VnfcDependencyModel(dependencies);
 265     }
 266
 267     private VnfcDependencyModel readCyclicDependencyModel() {
 268
 269         Vnfc a = createVnfc("A", "Active-Passive", null);
 270         Vnfc b = createVnfc("B", "Active-Active", null);
 271         Vnfc c = createVnfc("C", "Active-Active", null);
 272         Vnfc d = createVnfc("D", "Active-Active", null);
 273
 274
 275         Node aNode = new Node(a);
 276         Node bNode = new Node(b);
 277         Node cNode = new Node(c);
 278         Node dNode = new Node(d);
 279
 280         bNode.addParent(a);
 281
 282         bNode.addParent(d);
 283         dNode.addParent(c);
 284         cNode.addParent(b);
 285
 286
 287         Set<Node<Vnfc>> dependencies = new HashSet<>();
 288         dependencies.add(aNode);
 289         dependencies.add(bNode);
 290         dependencies.add(cNode);
 291         dependencies.add(dNode);
 292
 293         return new VnfcDependencyModel(dependencies);
 294
 295     }
 296
 297     private InventoryModel readInventoryModel() {
 298         Vnf vnf = createVnf("vnf_1", "vSCP", "1");
 299
 300         Vnfc smp = createVnfc("SMP", null, "SMP_Name");
 301         Vserver smpVm1 = createVserver("SMP_URL1", smp);
 302         Vserver smpVm2 = createVserver("SMP_URL2", smp);
 303
 304         vnf.addVserver(smpVm1);
 305         vnf.addVserver(smpVm2);
 306
 307         Vnfc be = createVnfc("BE", null, "BE_Name");
 308
 309         Vserver beVm1 = createVserver("BE_URL1", be);
 310         Vserver beVm2 = createVserver("BE_URL2", be);
 311         Vserver beVm3 = createVserver("BE_URL3", be);
 312         Vserver beVm4 = createVserver("BE_URL4", be);
 313         Vserver beVm5 = createVserver("BE_URL5", be);
 314
 315         vnf.addVserver(beVm1);
 316         vnf.addVserver(beVm2);
 317         vnf.addVserver(beVm3);
 318         vnf.addVserver(beVm4);
 319         vnf.addVserver(beVm5);
 320
 321         Vnfc fe = createVnfc("FE", null, "FE_Name");
 322
 323         Vserver feVm1 = createVserver("FE_URL1", fe);
 324         Vserver feVm2 = createVserver("FE_URL2", fe);
 325
 326         vnf.addVserver(feVm1);
 327         vnf.addVserver(feVm2);
 328
 329         return new InventoryModel(vnf);
 330     }
 331
 332     private Vserver createVserver(String url, Vnfc vnfc) {
 333         Vserver vserver = new Vserver();
 334         vserver.setUrl(url);
 335         vserver.setVnfc(vnfc);
 336         vnfc.addVserver(vserver);
 337         return vserver;
 338     }
 339
 340     private VnfcDependencyModel readDependencyModel() {
 341         Vnfc smp = createVnfc("SMP", "Active-Passive", null);
 342         Vnfc be = createVnfc("BE", "Active-Active", null);
 343         Vnfc fe = createVnfc("FE", "Active-Active", null);
 344
 345
 346         Node smpNode = new Node(smp);
 347         Node beNode = new Node(be);
 348         Node feNode = new Node(fe);
 349
 350         beNode.addParent(smp);
 351         feNode.addParent(be);
 352
 353         Set<Node<Vnfc>> dependencies = new HashSet<>();
 354         dependencies.add(smpNode);
 355         dependencies.add(feNode);
 356         dependencies.add(beNode);
 357
 358         return new VnfcDependencyModel(dependencies);
 359     }
 360 }