2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2019 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.
24 * ============LICENSE_END=========================================================
27 package org.onap.appc.dg.flowbuilder;
29 import org.hamcrest.CoreMatchers;
30 import org.junit.Assert;
31 import org.junit.Test;
32 import org.onap.appc.dg.flowbuilder.FlowBuilder;
33 import org.onap.appc.dg.flowbuilder.exception.InvalidDependencyModelException;
34 import org.onap.appc.dg.flowbuilder.impl.FlowBuilderFactory;
35 import org.onap.appc.dg.objects.*;
36 import org.onap.appc.domainmodel.Vnf;
37 import org.onap.appc.domainmodel.Vnfc;
38 import org.onap.appc.domainmodel.Vserver;
40 import java.util.HashSet;
41 import java.util.Iterator;
42 import java.util.List;
46 public class TestFlowBuilder {
48 public void testForwardFlowBuilder() throws InvalidDependencyModelException {
49 FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.FORWARD);
50 VnfcDependencyModel dependencyModel = readDependencyModel();
51 InventoryModel inventoryModel = readInventoryModel();
52 VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel, inventoryModel);
53 Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
55 List<Vnfc> list = itr.next();
56 Assert.assertTrue(list.contains(createVnfc("SMP", "Active-Passive", "SMP_Name")));
59 Assert.assertTrue(list.contains(createVnfc("BE", "Active-Active", "BE_Name")));
62 Assert.assertTrue(list.contains(createVnfc("FE", "Active-Active", "FE_Name")));
65 private Vnfc createVnfc(String vnfcType, String resilienceType, String vnfcName) {
66 Vnfc vnfc = new Vnfc();
67 vnfc.setVnfcType(vnfcType);
68 vnfc.setVnfcName(vnfcName);
69 vnfc.setResilienceType(resilienceType);
74 public void testReverseFlowBuilder() throws InvalidDependencyModelException {
75 FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.REVERSE);
76 VnfcDependencyModel dependencyModel = readDependencyModel();
77 InventoryModel inventoryModel = readInventoryModel();
78 VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel, inventoryModel);
79 Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
81 List<Vnfc> list = itr.next();
82 Assert.assertTrue(list.contains(createVnfc("FE", "Active-Active", "FE_Name")));
85 Assert.assertTrue(list.contains(createVnfc("BE", "Active-Active", "BE_Name")));
88 Assert.assertTrue(list.contains(createVnfc("SMP", "Active-Passive", "SMP_Name")));
90 Assert.assertThat(flowModel.toString(), CoreMatchers.containsString("Flow Model : Vnfc : vnfcType = FE"));
94 public void testComplexFlowBuilderForward() throws InvalidDependencyModelException {
95 FlowBuilder builder = FlowBuilderFactory.getInstance().getFlowBuilder(FlowStrategies.FORWARD);
96 VnfcDependencyModel dependencyModel = readComplexDependencyModel();
97 InventoryModel inventoryModel = readComplexInventoryModel();
98 VnfcFlowModel flowModel = builder.buildFlowModel(dependencyModel, inventoryModel);
99 Iterator<List<Vnfc>> itr = flowModel.getModelIterator();
101 List<Vnfc> list = itr.next();
102 Assert.assertTrue(list.contains(createVnfc("A", "Active-Active", "A_Name")));
103 Assert.assertTrue(list.contains(createVnfc("E", "Active-Active", "E_Name")));
106 Assert.assertTrue(list.contains(createVnfc("B", "Active-Active", "B_Name")));
107 Assert.assertTrue(list.contains(createVnfc("C", "Active-Active", "C_Name")));
110 Assert.assertTrue(list.contains(createVnfc("D", "Active-Active", "D_Name")));
111 Assert.assertTrue(list.contains(createVnfc("F", "Active-Active", "F_Name")));
114 Assert.assertTrue(list.contains(createVnfc("G", "Active-Active", "G_Name")));
115 } catch (Exception e) {
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();
128 List<Vnfc> list = itr.next();
129 Assert.assertTrue(list.contains(createVnfc("D", "Active-Active", "D_Name")));
131 Assert.assertTrue(list.contains(createVnfc("G", "Active-Active", "G_Name")));
134 Assert.assertTrue(list.contains(createVnfc("B", "Active-Active", "B_Name")));
135 Assert.assertTrue(list.contains(createVnfc("F", "Active-Active", "F_Name")));
138 Assert.assertTrue(list.contains(createVnfc("C", "Active-Active", "C_Name")));
141 Assert.assertTrue(list.contains(createVnfc("E", "Active-Active", "E_Name")));
142 Assert.assertTrue(list.contains(createVnfc("A", "Active-Active", "A_Name")));
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);
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);
163 public void testInventoryModelToString() {
164 Vnf vnf = createVnf("vnf_1", "vABCD", "1");
165 InventoryModel inventoryModel = new InventoryModel(vnf);
166 Assert.assertEquals("InventoryModel = Vnf : vnfId = vnf_1 , vnfType = vABCD", inventoryModel.toString());
169 private VnfcDependencyModel readCyclicDependencyModelWithRootNode() {
170 Vnfc a = createVnfc("A", "Active-Passive", null);
171 Vnfc b = createVnfc("B", "Active-Active", null);
172 Vnfc c = createVnfc("C", "Active-Active", null);
175 Node aNode = new Node(a);
176 Node bNode = new Node(b);
177 Node cNode = new Node(c);
179 Assert.assertTrue(aNode.equals(aNode));
180 Assert.assertFalse(aNode.equals(bNode));
186 Set<Node<Vnfc>> dependencies = new HashSet<>();
187 dependencies.add(aNode);
188 dependencies.add(bNode);
189 dependencies.add(cNode);
191 return new VnfcDependencyModel(dependencies);
194 private InventoryModel readComplexInventoryModel() {
195 Vnf vnf = createVnf("vnf_1", "vABCD", "1");
197 Vnfc vnfcA = createVnfc("A", "Active-Active", "A_Name");
198 Vnfc vnfcB = createVnfc("B", "Active-Active", "B_Name");
199 Vnfc vnfcC = createVnfc("C", "Active-Active", "C_Name");
200 Vnfc vnfcD = createVnfc("D", "Active-Active", "D_Name");
201 Vnfc vnfcE = createVnfc("E", "Active-Active", "E_Name");
202 Vnfc vnfcF = createVnfc("F", "Active-Active", "F_Name");
203 Vnfc vnfcG = createVnfc("G", "Active-Active", "G_Name");
205 vnf.addVserver(createVserver("VM_URL_A1", vnfcA));
206 vnf.addVserver(createVserver("VM_URL_B1", vnfcB));
207 vnf.addVserver(createVserver("VM_URL_C1", vnfcC));
208 vnf.addVserver(createVserver("VM_URL_D1", vnfcD));
209 vnf.addVserver(createVserver("VM_URL_E1", vnfcE));
210 vnf.addVserver(createVserver("VM_URL_F1", vnfcF));
211 vnf.addVserver(createVserver("VM_URL_G1", vnfcG));
213 return new InventoryModel(vnf);
216 private Vnf createVnf(String vnfId, String vnfType, String vnfVersion) {
219 vnf.setVnfType(vnfType);
220 vnf.setVnfVersion(vnfVersion);
224 private VnfcDependencyModel readComplexDependencyModel() {
225 Vnfc a = createVnfc("A", "Active-Active", null);
226 Vnfc b = createVnfc("B", "Active-Active", null);
227 Vnfc c = createVnfc("C", "Active-Active", null);
228 Vnfc d = createVnfc("D", "Active-Active", null);
229 Vnfc e = createVnfc("E", "Active-Active", null);
230 Vnfc f = createVnfc("F", "Active-Active", null);
231 Vnfc g = createVnfc("G", "Active-Active", null);
234 Node aNode = new Node(a);
235 Node bNode = new Node(b);
236 Node cNode = new Node(c);
237 Node dNode = new Node(d);
238 Node eNode = new Node(e);
239 Node fNode = new Node(f);
240 Node gNode = new Node(g);
255 Set<Node<Vnfc>> dependencies = new HashSet<>();
256 dependencies.add(aNode);
257 dependencies.add(bNode);
258 dependencies.add(cNode);
259 dependencies.add(dNode);
260 dependencies.add(eNode);
261 dependencies.add(fNode);
262 dependencies.add(gNode);
264 return new VnfcDependencyModel(dependencies);
267 private VnfcDependencyModel readCyclicDependencyModel() {
269 Vnfc a = createVnfc("A", "Active-Passive", null);
270 Vnfc b = createVnfc("B", "Active-Active", null);
271 Vnfc c = createVnfc("C", "Active-Active", null);
272 Vnfc d = createVnfc("D", "Active-Active", null);
275 Node aNode = new Node(a);
276 Node bNode = new Node(b);
277 Node cNode = new Node(c);
278 Node dNode = new Node(d);
287 Set<Node<Vnfc>> dependencies = new HashSet<>();
288 dependencies.add(aNode);
289 dependencies.add(bNode);
290 dependencies.add(cNode);
291 dependencies.add(dNode);
293 return new VnfcDependencyModel(dependencies);
297 private InventoryModel readInventoryModel() {
298 Vnf vnf = createVnf("vnf_1", "vSCP", "1");
300 Vnfc smp = createVnfc("SMP", null, "SMP_Name");
301 Vserver smpVm1 = createVserver("SMP_URL1", smp);
302 Vserver smpVm2 = createVserver("SMP_URL2", smp);
304 vnf.addVserver(smpVm1);
305 vnf.addVserver(smpVm2);
307 Vnfc be = createVnfc("BE", null, "BE_Name");
309 Vserver beVm1 = createVserver("BE_URL1", be);
310 Vserver beVm2 = createVserver("BE_URL2", be);
311 Vserver beVm3 = createVserver("BE_URL3", be);
312 Vserver beVm4 = createVserver("BE_URL4", be);
313 Vserver beVm5 = createVserver("BE_URL5", be);
315 vnf.addVserver(beVm1);
316 vnf.addVserver(beVm2);
317 vnf.addVserver(beVm3);
318 vnf.addVserver(beVm4);
319 vnf.addVserver(beVm5);
321 Vnfc fe = createVnfc("FE", null, "FE_Name");
323 Vserver feVm1 = createVserver("FE_URL1", fe);
324 Vserver feVm2 = createVserver("FE_URL2", fe);
326 vnf.addVserver(feVm1);
327 vnf.addVserver(feVm2);
329 return new InventoryModel(vnf);
332 private Vserver createVserver(String url, Vnfc vnfc) {
333 Vserver vserver = new Vserver();
335 vserver.setVnfc(vnfc);
336 vnfc.addVserver(vserver);
340 private VnfcDependencyModel readDependencyModel() {
341 Vnfc smp = createVnfc("SMP", "Active-Passive", null);
342 Vnfc be = createVnfc("BE", "Active-Active", null);
343 Vnfc fe = createVnfc("FE", "Active-Active", null);
346 Node smpNode = new Node(smp);
347 Node beNode = new Node(be);
348 Node feNode = new Node(fe);
350 beNode.addParent(smp);
351 feNode.addParent(be);
353 Set<Node<Vnfc>> dependencies = new HashSet<>();
354 dependencies.add(smpNode);
355 dependencies.add(feNode);
356 dependencies.add(beNode);
358 return new VnfcDependencyModel(dependencies);