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

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