2 * ============LICENSE_START=======================================================
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
17 * http://www.apache.org/licenses/LICENSE-2.0
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.
25 * ============LICENSE_END=========================================================
28 package org.onap.appc.dg.flowbuilder;
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;
41 import java.util.HashSet;
42 import java.util.Iterator;
43 import java.util.List;
47 public class TestFlowBuilder {
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();
56 List<Vnfc> list = itr.next();
57 Assert.assertTrue(list.contains(createVnfc("SMP","Active-Passive","SMP_Name")));
60 Assert.assertTrue(list.contains(createVnfc("BE","Active-Active","BE_Name")));
63 Assert.assertTrue(list.contains(createVnfc("FE","Active-Active","FE_Name")));
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);
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();
82 List<Vnfc> list = itr.next();
83 Assert.assertTrue(list.contains(createVnfc("FE","Active-Active","FE_Name")));
86 Assert.assertTrue(list.contains(createVnfc("BE","Active-Active","BE_Name")));
89 Assert.assertTrue(list.contains(createVnfc("SMP","Active-Passive","SMP_Name")));
91 Assert.assertThat(flowModel.toString(), CoreMatchers.containsString("Flow Model : Vnfc : vnfcType = FE"));
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();
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")));
107 Assert.assertTrue(list.contains(createVnfc("B","Active-Active","B_Name")));
108 Assert.assertTrue(list.contains(createVnfc("C","Active-Active","C_Name")));
111 Assert.assertTrue(list.contains(createVnfc("D","Active-Active","D_Name")));
112 Assert.assertTrue(list.contains(createVnfc("F","Active-Active","F_Name")));
115 Assert.assertTrue(list.contains(createVnfc("G","Active-Active","G_Name")));
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();
130 List<Vnfc> list = itr.next();
131 Assert.assertTrue(list.contains(createVnfc("D","Active-Active","D_Name")));
133 Assert.assertTrue(list.contains(createVnfc("G","Active-Active","G_Name")));
136 Assert.assertTrue(list.contains(createVnfc("B","Active-Active","B_Name")));
137 Assert.assertTrue(list.contains(createVnfc("F","Active-Active","F_Name")));
140 Assert.assertTrue(list.contains(createVnfc("C","Active-Active","C_Name")));
143 Assert.assertTrue(list.contains(createVnfc("E","Active-Active","E_Name")));
144 Assert.assertTrue(list.contains(createVnfc("A","Active-Active","A_Name")));
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);
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);
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());
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);
177 Node aNode = new Node(a);
178 Node bNode = new Node(b);
179 Node cNode = new Node(c);
181 Assert.assertTrue(aNode.equals(aNode));
182 Assert.assertFalse(aNode.equals(bNode));
188 Set<Node<Vnfc>> dependencies = new HashSet<>();
189 dependencies.add(aNode);
190 dependencies.add(bNode);
191 dependencies.add(cNode);
193 return new VnfcDependencyModel(dependencies);
196 private InventoryModel readComplexInventoryModel() {
197 Vnf vnf = createVnf("vnf_1","vABCD","1");
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");
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));
215 return new InventoryModel(vnf);
218 private Vnf createVnf(String vnfId,String vnfType,String vnfVersion) {
221 vnf.setVnfType(vnfType);
222 vnf.setVnfVersion(vnfVersion);
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);
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);
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);
266 return new VnfcDependencyModel(dependencies);
269 private VnfcDependencyModel readCyclicDependencyModel() {
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);
277 Node aNode = new Node(a);
278 Node bNode = new Node(b);
279 Node cNode = new Node(c);
280 Node dNode = new Node(d);
289 Set<Node<Vnfc>> dependencies = new HashSet<>();
290 dependencies.add(aNode);
291 dependencies.add(bNode);
292 dependencies.add(cNode);
293 dependencies.add(dNode);
295 return new VnfcDependencyModel(dependencies);
299 private InventoryModel readInventoryModel() {
300 Vnf vnf = createVnf("vnf_1","vSCP","1");
302 Vnfc smp = createVnfc("SMP",null,"SMP_Name");
303 Vserver smpVm1 = createVserver("SMP_URL1",smp);
304 Vserver smpVm2 = createVserver("SMP_URL2",smp);
306 vnf.addVserver(smpVm1);
307 vnf.addVserver(smpVm2);
309 Vnfc be = createVnfc("BE",null,"BE_Name");
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);
317 vnf.addVserver(beVm1);
318 vnf.addVserver(beVm2);
319 vnf.addVserver(beVm3);
320 vnf.addVserver(beVm4);
321 vnf.addVserver(beVm5);
323 Vnfc fe = createVnfc("FE",null,"FE_Name");
325 Vserver feVm1 = createVserver("FE_URL1",fe);
326 Vserver feVm2 = createVserver("FE_URL2",fe);
328 vnf.addVserver(feVm1);
329 vnf.addVserver(feVm2);
331 return new InventoryModel(vnf);
334 private Vserver createVserver(String url,Vnfc vnfc) {
335 Vserver vserver = new Vserver();
337 vserver.setVnfc(vnfc);
338 vnfc.addVserver(vserver);
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);
348 Node smpNode = new Node(smp);
349 Node beNode = new Node(be);
350 Node feNode = new Node(fe);
352 beNode.addParent(smp);
353 feNode.addParent(be);
355 Set<Node<Vnfc>> dependencies = new HashSet<>();
356 dependencies.add(smpNode);
357 dependencies.add(feNode);
358 dependencies.add(beNode);
360 return new VnfcDependencyModel(dependencies);