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