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