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

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * openECOMP : APP-C
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights
   6  *                                              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
  22 package org.openecomp.appc.dg.flowbuilder;
  23
  24 import org.junit.Assert;
  25 import org.junit.Test;
  26 import org.openecomp.appc.dg.flowbuilder.FlowBuilder;
  27 import org.openecomp.appc.dg.flowbuilder.exception.InvalidDependencyModel;
  28 import org.openecomp.appc.dg.flowbuilder.impl.FlowBuilderFactory;
  29 import org.openecomp.appc.dg.objects.*;
  30 import org.openecomp.appc.domainmodel.Vnf;
  31 import org.openecomp.appc.domainmodel.Vnfc;
  32 import org.openecomp.appc.domainmodel.Vserver;
  33
  34 import java.util.HashSet;
  35 import java.util.Iterator;
  36 import java.util.List;
  37 import java.util.Set;
  38
  39
  40 public class TestFlowBuilder {
  41
  42     @Test
  43     public void testForwardFlowBuilder(){
  44         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.FORWARD);
  45         VnfcDependencyModel dependencyModel = readDependencyModel();
  46         InventoryModel inventoryModel = readInventoryModel();
  47         VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel,inventoryModel);
  48         Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
  49
  50         List<Vnfc> list = itr.next();
  51         Assert.assertTrue(list.contains(new Vnfc("SMP","Active-Passive","SMP_Name")));
  52
  53         list = itr.next();
  54         Assert.assertTrue(list.contains(new Vnfc("BE","Active-Active","BE_Name")));
  55
  56         list = itr.next();
  57         Assert.assertTrue(list.contains(new Vnfc("FE","Active-Active","FE_Name")));
  58     }
  59
  60     @Test
  61     public void testReverseFlowBuilder(){
  62         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.REVERSE);
  63         VnfcDependencyModel dependencyModel = readDependencyModel();
  64         InventoryModel inventoryModel = readInventoryModel();
  65         VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel,inventoryModel);
  66         Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
  67
  68         List<Vnfc> list = itr.next();
  69         Assert.assertTrue(list.contains(new Vnfc("FE","Active-Active","FE_Name")));
  70
  71         list = itr.next();
  72         Assert.assertTrue(list.contains(new Vnfc("BE","Active-Active","BE_Name")));
  73
  74         list = itr.next();
  75         Assert.assertTrue(list.contains(new Vnfc("SMP","Active-Passive","SMP_Name")));
  76     }
  77
  78     @Test
  79     public void testComplexFlowBuilderForward(){
  80         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.FORWARD);
  81         VnfcDependencyModel dependencyModel = readComplexDependencyModel();
  82         InventoryModel inventoryModel = readComplexInventoryModel();
  83         VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel,inventoryModel);
  84         Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
  85
  86         List<Vnfc> list = itr.next();
  87         Assert.assertTrue(list.contains(new Vnfc("A","Active-Active","A_Name")));
  88         Assert.assertTrue(list.contains(new Vnfc("E","Active-Active","E_Name")));
  89
  90         list = itr.next();
  91         Assert.assertTrue(list.contains(new Vnfc("B","Active-Active","B_Name")));
  92         Assert.assertTrue(list.contains(new Vnfc("C","Active-Active","C_Name")));
  93
  94         list = itr.next();
  95         Assert.assertTrue(list.contains(new Vnfc("D","Active-Active","D_Name")));
  96         Assert.assertTrue(list.contains(new Vnfc("F","Active-Active","F_Name")));
  97
  98         list = itr.next();
  99         Assert.assertTrue(list.contains(new Vnfc("G","Active-Active","G_Name")));
 100
 101     }
 102
 103     @Test
 104     public void testComplexFlowBuilderReverse(){
 105         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.REVERSE);
 106         VnfcDependencyModel dependencyModel = readComplexDependencyModel();
 107         InventoryModel inventoryModel = readComplexInventoryModel();
 108         VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel,inventoryModel);
 109         Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
 110
 111         List<Vnfc> list = itr.next();
 112         Assert.assertTrue(list.contains(new Vnfc("D","Active-Active","D_Name")));
 113
 114         Assert.assertTrue(list.contains(new Vnfc("G","Active-Active","G_Name")));
 115
 116         list = itr.next();
 117         Assert.assertTrue(list.contains(new Vnfc("B","Active-Active","B_Name")));
 118         Assert.assertTrue(list.contains(new Vnfc("F","Active-Active","F_Name")));
 119
 120         list = itr.next();
 121         Assert.assertTrue(list.contains(new Vnfc("C","Active-Active","C_Name")));
 122
 123         list = itr.next();
 124         Assert.assertTrue(list.contains(new Vnfc("E","Active-Active","E_Name")));
 125         Assert.assertTrue(list.contains(new Vnfc("A","Active-Active","A_Name")));
 126
 127     }
 128
 129     @Test(expected = InvalidDependencyModel.class)
 130     public void testCyclicBuilder(){
 131         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.FORWARD);
 132         VnfcDependencyModel dependencyModel = readCyclicDependencyModel();
 133         InventoryModel inventoryModel = readInventoryModel();
 134         builder.buildFlowModel(dependencyModel,inventoryModel);
 135     }
 136
 137     @Test(expected = InvalidDependencyModel.class)
 138     public void testCyclicBuilderWithRootNode(){
 139         FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.FORWARD);
 140         VnfcDependencyModel dependencyModel = readCyclicDependencyModelWithRootNode();
 141         InventoryModel inventoryModel = readInventoryModel();
 142         builder.buildFlowModel(dependencyModel,inventoryModel);
 143     }
 144
 145     private VnfcDependencyModel readCyclicDependencyModelWithRootNode() {
 146         Vnfc a = new Vnfc("A","Active-Passive",null);
 147         Vnfc b = new Vnfc("B","Active-Active",null);
 148         Vnfc c = new Vnfc("C","Active-Active",null);
 149
 150
 151         Node aNode = new Node(a);
 152         Node bNode = new Node(b);
 153         Node cNode = new Node(c);
 154
 155         bNode.addParent(c);
 156         cNode.addParent(b);
 157
 158
 159         Set<Node<Vnfc>> dependencies = new HashSet<>();
 160         dependencies.add(aNode);
 161         dependencies.add(bNode);
 162         dependencies.add(cNode);
 163
 164         return new VnfcDependencyModel(dependencies);
 165     }
 166
 167     private InventoryModel readComplexInventoryModel() {
 168         Vnf vnf = new Vnf("vnf_1","vABCD","1");
 169
 170         Vnfc vnfcA = new Vnfc("A","Active-Active","A_Name");
 171         Vnfc vnfcB = new Vnfc("B","Active-Active","B_Name");
 172         Vnfc vnfcC = new Vnfc("C","Active-Active","C_Name");
 173         Vnfc vnfcD = new Vnfc("D","Active-Active","D_Name");
 174         Vnfc vnfcE = new Vnfc("E","Active-Active","E_Name");
 175         Vnfc vnfcF = new Vnfc("F","Active-Active","F_Name");
 176         Vnfc vnfcG = new Vnfc("G","Active-Active","G_Name");
 177
 178         vnfcA.addVm(new Vserver("VM_URL_A1"));
 179         vnfcB.addVm(new Vserver("VM_URL_B1"));
 180         vnfcC.addVm(new Vserver("VM_URL_C1"));
 181         vnfcD.addVm(new Vserver("VM_URL_D1"));
 182         vnfcE.addVm(new Vserver("VM_URL_E1"));
 183         vnfcF.addVm(new Vserver("VM_URL_F1"));
 184         vnfcG.addVm(new Vserver("VM_URL_G1"));
 185
 186         vnf.addVnfc(vnfcA);
 187         vnf.addVnfc(vnfcB);
 188         vnf.addVnfc(vnfcC);
 189         vnf.addVnfc(vnfcD);
 190         vnf.addVnfc(vnfcE);
 191         vnf.addVnfc(vnfcF);
 192         vnf.addVnfc(vnfcG);
 193
 194         return new InventoryModel(vnf);
 195     }
 196
 197     private VnfcDependencyModel readComplexDependencyModel() {
 198         Vnfc a = new Vnfc("A","Active-Active",null);
 199         Vnfc b = new Vnfc("B","Active-Active",null);
 200         Vnfc c = new Vnfc("C","Active-Active",null);
 201         Vnfc d = new Vnfc("D","Active-Active",null);
 202         Vnfc e = new Vnfc("E","Active-Active",null);
 203         Vnfc f = new Vnfc("F","Active-Active",null);
 204         Vnfc g = new Vnfc("G","Active-Active",null);
 205
 206
 207         Node aNode = new Node(a);
 208         Node bNode = new Node(b);
 209         Node cNode = new Node(c);
 210         Node dNode = new Node(d);
 211         Node eNode = new Node(e);
 212         Node fNode = new Node(f);
 213         Node gNode = new Node(g);
 214
 215         bNode.addParent(a);
 216         cNode.addParent(a);
 217
 218         bNode.addParent(e);
 219         cNode.addParent(e);
 220
 221         dNode.addParent(b);
 222         gNode.addParent(b);
 223
 224         fNode.addParent(c);
 225
 226         gNode.addParent(f);
 227
 228         Set<Node<Vnfc>> dependencies = new HashSet<>();
 229         dependencies.add(aNode);
 230         dependencies.add(bNode);
 231         dependencies.add(cNode);
 232         dependencies.add(dNode);
 233         dependencies.add(eNode);
 234         dependencies.add(fNode);
 235         dependencies.add(gNode);
 236
 237         return new VnfcDependencyModel(dependencies);
 238     }
 239
 240     private VnfcDependencyModel readCyclicDependencyModel() {
 241
 242         Vnfc a = new Vnfc("A","Active-Passive",null);
 243         Vnfc b = new Vnfc("B","Active-Active",null);
 244         Vnfc c = new Vnfc("C","Active-Active",null);
 245         Vnfc d = new Vnfc("D","Active-Active",null);
 246
 247
 248         Node aNode = new Node(a);
 249         Node bNode = new Node(b);
 250         Node cNode = new Node(c);
 251         Node dNode = new Node(d);
 252
 253         bNode.addParent(a);
 254
 255         bNode.addParent(d);
 256         dNode.addParent(c);
 257         cNode.addParent(b);
 258
 259
 260         Set<Node<Vnfc>> dependencies = new HashSet<>();
 261         dependencies.add(aNode);
 262         dependencies.add(bNode);
 263         dependencies.add(cNode);
 264         dependencies.add(dNode);
 265
 266         return new VnfcDependencyModel(dependencies);
 267
 268     }
 269
 270     private InventoryModel readInventoryModel() {
 271         Vnf vnf = new Vnf("vnf_1","vSCP","1");
 272
 273         Vnfc smp = new Vnfc("SMP",null,"SMP_Name");
 274         Vserver smpVm1 = new Vserver("SMP_URL1");
 275         Vserver smpVm2 = new Vserver("SMP_URL2");
 276
 277         smp.addVm(smpVm1);
 278         smp.addVm(smpVm2);
 279
 280         Vnfc be = new Vnfc("BE",null,"BE_Name");
 281
 282         Vserver beVm1 = new Vserver("BE_URL1");
 283         Vserver beVm2 = new Vserver("BE_URL2");
 284         Vserver beVm3 = new Vserver("BE_URL3");
 285         Vserver beVm4 = new Vserver("BE_URL4");
 286         Vserver beVm5 = new Vserver("BE_URL5");
 287
 288         be.addVm(beVm1);
 289         be.addVm(beVm2);
 290         be.addVm(beVm3);
 291         be.addVm(beVm4);
 292         be.addVm(beVm5);
 293
 294         Vnfc fe = new Vnfc("FE",null,"FE_Name");
 295
 296         Vserver feVm1 = new Vserver("FE_URL1");
 297         Vserver feVm2 = new Vserver("FE_URL2");
 298
 299         fe.addVm(feVm1);
 300         fe.addVm(feVm2);
 301
 302         vnf.addVnfc(smp);
 303         vnf.addVnfc(be);
 304         vnf.addVnfc(fe);
 305
 306         return new InventoryModel(vnf);
 307     }
 308
 309     private VnfcDependencyModel readDependencyModel() {
 310         Vnfc smp = new Vnfc("SMP","Active-Passive",null);
 311         Vnfc be = new Vnfc("BE","Active-Active",null);
 312         Vnfc fe = new Vnfc("FE","Active-Active",null);
 313
 314
 315         Node smpNode = new Node(smp);
 316         Node beNode = new Node(be);
 317         Node feNode = new Node(fe);
 318
 319         beNode.addParent(smp);
 320         feNode.addParent(be);
 321
 322         Set<Node<Vnfc>> dependencies = new HashSet<>();
 323         dependencies.add(smpNode);
 324         dependencies.add(feNode);
 325         dependencies.add(beNode);
 326
 327         return new VnfcDependencyModel(dependencies);
 328     }
 329 }