2 * Copyright (c) 2015 Inocybe Technologies. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
9 package org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13;
11 import static org.junit.Assert.assertEquals;
12 import static org.junit.Assert.assertNull;
13 import static org.junit.Assert.assertTrue;
14 import static org.mockito.Matchers.any;
15 import static org.mockito.Matchers.anyString;
16 import static org.mockito.Matchers.same;
17 import static org.mockito.Mockito.mock;
18 import static org.mockito.Mockito.times;
19 import static org.mockito.Mockito.verify;
20 import static org.mockito.Mockito.when;
22 import java.lang.reflect.Field;
23 import java.net.InetAddress;
24 import java.util.ArrayList;
25 import java.util.Arrays;
26 import java.util.HashMap;
27 import java.util.HashSet;
28 import java.util.List;
30 import java.util.Random;
32 import java.util.concurrent.BlockingQueue;
33 import java.util.concurrent.ConcurrentHashMap;
34 import java.util.concurrent.ConcurrentMap;
36 import org.junit.Before;
37 import org.junit.Ignore;
38 import org.junit.Test;
39 import org.junit.runner.RunWith;
40 import org.mockito.InjectMocks;
41 import org.mockito.Mock;
42 import org.mockito.Mockito;
43 import org.mockito.runners.MockitoJUnitRunner;
44 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
45 import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
46 import org.opendaylight.neutron.spi.INeutronPortCRUD;
47 import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
48 import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
49 import org.opendaylight.neutron.spi.NeutronNetwork;
50 import org.opendaylight.ovsdb.openstack.netvirt.AbstractEvent;
51 import org.opendaylight.ovsdb.openstack.netvirt.AbstractHandler;
52 import org.opendaylight.ovsdb.openstack.netvirt.LBaaSHandler;
53 import org.opendaylight.ovsdb.openstack.netvirt.LBaaSPoolHandler;
54 import org.opendaylight.ovsdb.openstack.netvirt.NetworkHandler;
55 import org.opendaylight.ovsdb.openstack.netvirt.NeutronCacheUtils;
56 import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
57 import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
58 import org.opendaylight.ovsdb.openstack.netvirt.api.ClassifierProvider;
59 import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
60 import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
61 import org.opendaylight.ovsdb.openstack.netvirt.api.EgressAclProvider;
62 import org.opendaylight.ovsdb.openstack.netvirt.api.IngressAclProvider;
63 import org.opendaylight.ovsdb.openstack.netvirt.api.L2ForwardingProvider;
64 import org.opendaylight.ovsdb.openstack.netvirt.api.SecurityServicesManager;
65 import org.opendaylight.ovsdb.openstack.netvirt.api.Status;
66 import org.opendaylight.ovsdb.openstack.netvirt.api.StatusCode;
67 import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
68 import org.opendaylight.ovsdb.openstack.netvirt.impl.EventDispatcherImpl;
69 //import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
70 //import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
71 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
72 //import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
75 //import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
76 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
77 import org.osgi.framework.ServiceReference;
78 import org.powermock.api.mockito.PowerMockito;
79 import org.powermock.core.classloader.annotations.PrepareForTest;
80 import org.powermock.modules.junit4.PowerMockRunner;
83 * Unit test for {@link OF13Provider}
85 @Ignore // TODO SB_MIGRATION
86 @PrepareForTest(OF13Provider.class)
87 @RunWith(PowerMockRunner.class)
88 public class OF13ProviderTest {
90 @InjectMocks private OF13Provider of13Provider;
91 @Mock private NeutronNetwork network;
92 @Mock private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node openflowNode;
93 @Mock private Node node;
94 @Mock private Node node2;
95 @Mock private Node node3;
96 //@Mock private Interface intf;
98 @Mock private ConfigurationService configurationService;
99 @Mock private BridgeConfigurationManager bridgeConfigurationManager;
100 @Mock private TenantNetworkManager tenantNetworkManager;
101 /* TODO SB_MIGRATION */
102 //@Mock private OvsdbConnectionService connectionService;
103 @Mock private MdsalConsumer mdsalConsumer;
104 @Mock private SecurityServicesManager securityServicesManager;
105 @Mock private IngressAclProvider ingressAclProvider;
106 @Mock private EgressAclProvider egressAclProvider;
107 @Mock private ClassifierProvider classifierProvider;
108 @Mock private L2ForwardingProvider l2ForwardingProvider;
109 @Mock private DataBroker dataBroker;
113 public void setUp() throws Exception{
114 of13Provider = new OF13Provider();
116 //Setup mock dependency services.
117 configurationService = Mockito.mock(ConfigurationService.class);
118 bridgeConfigurationManager = Mockito.mock(BridgeConfigurationManager.class);
119 tenantNetworkManager = Mockito.mock(TenantNetworkManager.class);
120 /* TODO SB_MIGRATION */
121 //connectionService = Mockito.mock(OvsdbConnectionService.class);
122 mdsalConsumer = Mockito.mock(MdsalConsumer.class);
123 securityServicesManager = Mockito.mock(SecurityServicesManager.class);
124 ingressAclProvider = Mockito.mock(IngressAclProvider.class);
125 egressAclProvider = Mockito.mock(EgressAclProvider.class);
126 classifierProvider = Mockito.mock(ClassifierProvider.class);
127 l2ForwardingProvider = Mockito.mock(L2ForwardingProvider.class);
128 dataBroker = Mockito.mock(DataBroker.class);
130 this.SeedMockDependencies();
132 List<Node> nodeList = new ArrayList();
133 NodeId nodeId = new NodeId("Node1");
134 NodeKey nodeKey = new NodeKey(nodeId);
136 node = Mockito.mock(Node.class);
137 when(node.getNodeId()).thenReturn(nodeId);
138 when(node.getKey()).thenReturn(new NodeKey(nodeId));
139 when(configurationService.getTunnelEndPoint(node)).thenReturn(InetAddress.getByName("192.168.0.1"));
142 nodeId = new NodeId("Node2");
143 node2 = Mockito.mock(Node.class);
144 when(node2.getNodeId()).thenReturn(nodeId);
145 when(node2.getKey()).thenReturn(new NodeKey(nodeId));
146 when(configurationService.getTunnelEndPoint(node2)).thenReturn(InetAddress.getByName("192.168.0.2"));
149 nodeId = new NodeId("Node3");
150 node3 = Mockito.mock(Node.class);
151 when(node3.getNodeId()).thenReturn(nodeId);
152 when(node3.getKey()).thenReturn(new NodeKey(nodeId));
153 when(configurationService.getTunnelEndPoint(node3)).thenReturn(InetAddress.getByName("192.168.0.3"));
157 //when(connectionService.getBridgeNodes()).thenReturn(nodeList);
159 final String key = "key";
160 ConcurrentHashMap<String, Row> bridgeTable = new ConcurrentHashMap();
161 bridgeTable.put(key, new Row());
163 Row bridgeRow = Mockito.mock(Row.class);
164 Bridge bridge = Mockito.mock(Bridge.class);
167 Set<String> paths = new HashSet<String>(Arrays.asList(new String[] { "100"}));
168 Column<GenericTableSchema, Set<String>> dataPathIdColumns = Mockito.mock(Column.class);
170 when(dataPathIdColumns.getData()).thenReturn(paths);
171 when(bridge.getDatapathIdColumn()).thenReturn(dataPathIdColumns);
173 when(configurationService.getIntegrationBridgeName()).thenReturn(key);
174 //when(ovsdbConfigurationService.getTableName(node, Bridge.class)).thenReturn(key);
175 //when(ovsdbConfigurationService.getRows(node, key)).thenReturn(bridgeTable);
176 //when(ovsdbConfigurationService.getRow(node, ovsdbConfigurationService.getTableName(node, Bridge.class), key)).thenReturn(bridgeRow);
177 //when(ovsdbConfigurationService.getTypedRow(node, Bridge.class, bridgeRow)).thenReturn(bridge);
179 Bridge bridge1 = Mockito.mock(Bridge.class);
180 when(bridge1.getName()).thenReturn(key);
181 //when(ovsdbConfigurationService.getTypedRow(node, Bridge.class, bridgeTable.get(key))).thenReturn(bridge1);
183 Port port = mock(Port.class);
184 Column<GenericTableSchema, Set<UUID>> itfaceColumns = mock(Column.class);
185 when(port.getInterfacesColumn()).thenReturn(itfaceColumns);
186 Set<UUID> ifaceUUIDs = new HashSet();
187 ifaceUUIDs.add(mock(UUID.class));
188 when(itfaceColumns.getData()).thenReturn(ifaceUUIDs );
189 //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Port.class), any(Row.class))).thenReturn(port);
191 intf = mock(Interface.class);
193 Set<Long> ports = new HashSet<Long>(Arrays.asList(new Long[] { 21L, 23L ,80L}));
194 Column<GenericTableSchema, Set<Long>> openFlowPortColumns = Mockito.mock(Column.class);
195 when(openFlowPortColumns.getData()).thenReturn(ports);
197 when(intf.getName()).thenReturn("intf1");
198 when(intf.getOpenFlowPortColumn()).thenReturn(openFlowPortColumns);
200 Column<GenericTableSchema, Map<String, String>> externalIdColumns = mock(Column.class);
201 Map<String, String> externalIds = new HashMap();
202 externalIds.put(Constants.EXTERNAL_ID_INTERFACE_ID, "portUUID");
203 externalIds.put(Constants.EXTERNAL_ID_VM_MAC, "extMac");
204 when(externalIdColumns.getData()).thenReturn(externalIds);
206 when(intf.getExternalIdsColumn()).thenReturn(externalIdColumns);
207 //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Interface.class), any(Row.class))).thenReturn(intf);
216 * hasPerTenantTunneling()
219 public void verifyObjectDefaultSettings(){
220 assertEquals("Error, getName() - Default provider name is invalid","OF13Provider",of13Provider.getName());
221 assertEquals("Error, supportsServices() - Support services is disabled", true, of13Provider.supportsServices());
222 assertEquals("Error, hasPerTenantTunneling() - Support for per tenant tunnelling is enabled", false, of13Provider.hasPerTenantTunneling());
227 * {@link OF13Provider#notifyFlowCapableNodeEventTest(Long, Action)}
230 public void notifyFlowCapableNodeEventTest(){
233 Action action = Action.ADD;
235 //of13Provider.notifyFlowCapableNodeEvent(flowId, action);
236 //verify(mdsalConsumer, times(1)).notifyFlowCapableNodeCreateEvent(Constants.OPENFLOW_NODE_PREFIX + flowId, action);
241 * {@link OF13Provider#initializeFlowRules(Node)}
244 public void initializeFlowRulesTest(){
246 //Row row = Mockito.mock(Row.class);
247 //when(ovsdbConfigurationService.getTypedRow(node, Interface.class, row)).thenReturn(intf);
249 //ConcurrentHashMap<String, Row> intfs = new ConcurrentHashMap();
250 //intfs.put("intf1", row);
252 NeutronNetwork network = Mockito.mock(NeutronNetwork.class);
253 when(network.getProviderNetworkType()).thenReturn(NetworkHandler.NETWORK_TYPE_VLAN);
254 //when(tenantNetworkManager.getTenantNetwork(intf)).thenReturn(network);
255 //when(ovsdbConfigurationService.getRows(node, ovsdbConfigurationService.getTableName(node, Interface.class))).thenReturn(intfs);
257 of13Provider.initializeFlowRules(node);
260 * The final phase of the initialization process is to call triggerInterfaceUpdates(node)
261 * This must call tenantNetworkManager.getTenantNetwork(Interface) for each interface.
262 * Verify that this is called once since we are initializing flow rules for only one interface.
264 /* TODO SB_MIGRATION */
265 //verify(tenantNetworkManager, times(1)).getTenantNetwork(intf);
270 * {@link OF13Provider#initializeOFFlowRulesTest(Node)}
273 public void initializeOFFlowRulesTest(){
274 /* TODO SB_MIGRATION */
275 //of13Provider.initializeOFFlowRules(openflowNode);
276 //verify(connectionService, times(1)).getBridgeNodes();
281 * {@link OF13Provider#handleInterfaceUpdateTest(NeutronNetwork, Node, Interface)}
284 public void handleInterfaceUpdateTest(){
285 NeutronNetwork network = Mockito.mock(NeutronNetwork.class);
288 * For Vlan network type, test ensures that all parameter validations
289 * passed by ensuring that ovsdbConfigurationService.getRows(node,"interface_table_name))
290 * is called at least once.
293 when(network.getProviderNetworkType()).thenReturn(NetworkHandler.NETWORK_TYPE_VLAN);
294 /* TODO SB_MIGRATION */
295 //this.of13Provider.handleInterfaceUpdate(network, node, intf);
296 //verify(ovsdbConfigurationService, times(1)).getRows(node, ovsdbConfigurationService.getTableName(node, Interface.class));
299 * Ideally we want to verify that the right rule tables are constructed for
300 * each type of network (vlan, gre, vxlan). However, to simplify things, we just
301 * verify that configurationService.getTunnelEndPoint() is called twice for the appropriate
302 * network types and for each of the two remaining nodes.
305 when(network.getProviderNetworkType()).thenReturn(NetworkHandler.NETWORK_TYPE_GRE);
306 /* TODO SB_MIGRATION */
307 //this.of13Provider.handleInterfaceUpdate(network, node, intf);this.of13Provider.handleInterfaceUpdate(network, node, intf);
308 /* TODO SB_MIGRATION */
309 //verify(configurationService, times(4)).getTunnelEndPoint(node);
311 when(network.getProviderNetworkType()).thenReturn(NetworkHandler.NETWORK_TYPE_VXLAN);
312 /* TODO SB_MIGRATION */
313 //this.of13Provider.handleInterfaceUpdate(network, node, intf);this.of13Provider.handleInterfaceUpdate(network, node, intf);
314 //verify(configurationService, times(8)).getTunnelEndPoint(node);
316 //assertEquals("Error, handleInterfaceUpdate(String, String) - is returning a non NULL value.", null, this.of13Provider.handleInterfaceUpdate("",""));
321 * {@link OF13Provider#handleInterfaceDelete(String, NeutronNetwork, Node, Interface, boolean)}
324 public void handleInterfaceDeleteTest(){
325 NeutronNetwork network = Mockito.mock(NeutronNetwork.class);
328 when(network.getProviderNetworkType()).thenReturn(NetworkHandler.NETWORK_TYPE_VLAN);
329 when(bridgeConfigurationManager.getAllPhysicalInterfaceNames(node)).thenReturn(Arrays.asList(new String[] { "eth0", "eth1" ,"eth2"}));
331 //Column<GenericTableSchema, String> typeColumn = Mockito.mock(Column.class);
332 //when(typeColumn.getData()).thenReturn(NetworkHandler.NETWORK_TYPE_VXLAN);
333 //when(intf.getTypeColumn()).thenReturn(typeColumn);
335 Map<String, String> options = new HashMap();
336 options.put("local_ip", "192.168.0.1");
337 options.put("remote_ip", "10.0.12.0");
339 //Column<GenericTableSchema, Map<String, String>> optionColumns = Mockito.mock(Column.class);
340 //when(intf.getOptionsColumn()).thenReturn(optionColumns);
342 /* TODO SB_MIGRATION */
343 Status status = null;//this.of13Provider.handleInterfaceDelete("tunnel1", network, node, intf, true);
345 assertEquals("Error, handleInterfaceDelete(String, NeutronNetwor, Node, Interface, boolean) - returned the wrong status.", new Status(StatusCode.SUCCESS), status);
351 * {@link OF13Provider#createNodeBuilderTest(String)}
354 public void createNodeBuilderTest(){
355 final String nodeId="node1";
357 NodeBuilder builder = new NodeBuilder();
358 builder.setId(new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId(nodeId));
359 builder.setKey(new org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey(builder.getId()));
361 NodeBuilder builderStatic = OF13Provider.createNodeBuilder(nodeId);
363 assertEquals("Error, createNodeBuilder() returned an invalid Node Builder Id", builderStatic.getId(), builder.getId());
364 assertEquals("Error, createNodeBuilder() returned an invalid Node Builder key", builderStatic.getKey(), builder.getKey());
368 * Seeds mock dependencies into the of13Provider object
371 private void SeedMockDependencies() throws Exception{
373 SeedClassFieldValue(of13Provider, "configurationService", configurationService);
374 SeedClassFieldValue(of13Provider, "bridgeConfigurationManager", bridgeConfigurationManager);
375 SeedClassFieldValue(of13Provider, "tenantNetworkManager", tenantNetworkManager);
376 /* TODO SB_MIGRATION */
377 //SeedClassFieldValue(of13Provider, "ovsdbConfigurationService", ovsdbConfigurationService);
378 //SeedClassFieldValue(of13Provider, "connectionService", connectionService);
379 SeedClassFieldValue(of13Provider, "mdsalConsumer", mdsalConsumer);
380 SeedClassFieldValue(of13Provider, "securityServicesManager", securityServicesManager);
381 SeedClassFieldValue(of13Provider, "ingressAclProvider", ingressAclProvider);
382 SeedClassFieldValue(of13Provider, "egressAclProvider", egressAclProvider);
383 SeedClassFieldValue(of13Provider, "classifierProvider", classifierProvider);
384 SeedClassFieldValue(of13Provider, "l2ForwardingProvider", l2ForwardingProvider);
385 SeedClassFieldValue(of13Provider, "dataBroker", dataBroker);
389 * Get the specified field from OF13Provider using reflection
390 * @param instance - the class instance
391 * @param fieldName - the field to retrieve
393 * @return the desired field
395 private Object getClassField(OF13Provider instance, String fieldName) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
396 Field field = OF13Provider.class.getDeclaredField(fieldName);
397 field.setAccessible(true);
398 return field.get(instance);
402 * Sets the internal value of a field from OF13Provider using reflection
406 * @throws NoSuchFieldException
407 * @throws SecurityException
408 * @throws IllegalArgumentException
409 * @throws IllegalAccessException
411 private void SeedClassFieldValue(OF13Provider instance, String fieldName, Object value)throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException{
413 Field field = OF13Provider.class.getDeclaredField(fieldName);
414 field.setAccessible(true);
415 field.set(instance, value);