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

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