gerrit.onap Code Review - appc.git/blob

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