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