openstack/net-virt/src/test/java/org/opendaylight/ovsdb/openstack/netvirt/impl/BridgeConfigurationManagerImplTest.java

   1 /*
   2 * Copyright (c) 2014 Intel Corp. and others.  All rights reserved.
   3 *
   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
   7 *
   8 * Authors : Marcus Koontz
   9 */
  10 package org.opendaylight.ovsdb.openstack.netvirt.impl;
  11
  12 import com.fasterxml.jackson.annotation.JsonIgnoreType;
  13 import org.junit.Ignore;
  14 import org.junit.runner.RunWith;
  15 import org.junit.Test;
  16 import org.mockito.InjectMocks;
  17 import org.mockito.Mock;
  18 import org.mockito.Spy;
  19 import org.mockito.invocation.InvocationOnMock;
  20 import org.mockito.runners.MockitoJUnitRunner;
  21 import org.mockito.stubbing.Answer;
  22 import org.opendaylight.neutron.spi.NeutronNetwork;
  23 //import org.opendaylight.controller.sal.core.Node;
  24 import org.opendaylight.ovsdb.lib.notation.Column;
  25 import org.opendaylight.ovsdb.lib.notation.Row;
  26 import org.opendaylight.ovsdb.lib.notation.UUID;
  27 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  28 import org.opendaylight.ovsdb.openstack.netvirt.api.ConfigurationService;
  29 import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProvider;
  30 import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
  31 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  32 import org.opendaylight.ovsdb.schema.openvswitch.OpenVSwitch;
  33 import org.opendaylight.ovsdb.schema.openvswitch.Port;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  35 import java.util.ArrayList;
  36 import java.util.List;
  37 import java.util.concurrent.ConcurrentHashMap;
  38 import java.util.Map;
  39 import java.util.HashMap;
  40 import java.util.HashSet;
  41 import java.util.Set;
  42
  43 import static org.junit.Assert.assertTrue;
  44 import static org.junit.Assert.assertEquals;
  45 import static org.mockito.Matchers.any;
  46 import static org.mockito.Matchers.anyString;
  47 import static org.mockito.Matchers.same;
  48 import static org.mockito.Mockito.doAnswer;
  49 import static org.mockito.Mockito.mock;
  50 import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
  51 import static org.mockito.Mockito.RETURNS_MOCKS;
  52 import static org.mockito.Mockito.reset;
  53 import static org.mockito.Mockito.times;
  54 import static org.mockito.Mockito.verify;
  55 import static org.mockito.Mockito.verifyNoMoreInteractions;
  56 import static org.mockito.Mockito.when;
  57
  58 /* TODO SB_MIGRATION */ @Ignore
  59 @RunWith(MockitoJUnitRunner.class)
  60 public class BridgeConfigurationManagerImplTest {
  61
  62     private Node nodeMock = mock(Node.class, RETURNS_DEEP_STUBS);
  63     private Bridge bridgeMock = mock(Bridge.class, RETURNS_DEEP_STUBS);
  64
  65     @Mock private ConfigurationService configurationService;
  66     @Mock private NetworkingProviderManager networkingProviderManager;
  67
  68
  69     @InjectMocks public static BridgeConfigurationManagerImpl bridgeConfigurationManagerImpl;
  70     @InjectMocks public static BridgeConfigurationManagerImpl bridgeConfigMock =
  71             mock(BridgeConfigurationManagerImpl.class, RETURNS_DEEP_STUBS);
  72     @Spy public static BridgeConfigurationManagerImpl bridgeConfigurationManagerImplSpy;
  73
  74     @Test
  75     public void testGetBridgeUuid() throws Exception {
  76         Row row = mock(Row.class);
  77         Bridge bridge = mock(Bridge.class, RETURNS_DEEP_STUBS);
  78
  79         ConcurrentHashMap<String, Row> hashMap;
  80         hashMap = new ConcurrentHashMap<>();
  81         hashMap.put("mockUUID", row);
  82
  83         /* TODO SB_MIGRATION */
  84         //verifyNoMoreInteractions(ovsdbConfigurationService);
  85         verifyNoMoreInteractions(configurationService);
  86         verifyNoMoreInteractions(networkingProviderManager);
  87
  88         //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(hashMap);
  89         //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Bridge.class),
  90         //        any(Row.class))).thenReturn(bridge);
  91         when(bridge.getName()).thenReturn("test-bridge");
  92
  93         /* TODO SB_MIGRATION */
  94         //assertEquals("Error, did not return UUID of correct bridge", "mockUUID",
  95         //        bridgeConfigurationManagerImpl.getBridgeUuid(nodeMock, "test-bridge"));
  96
  97         //verify(ovsdbConfigurationService).getTableName(nodeMock, Bridge.class);
  98         verifyNoMoreInteractions(configurationService);
  99         verifyNoMoreInteractions(networkingProviderManager);
 100     }
 101
 102     @Test
 103     public void testIsNodeNeutronReady() throws Exception {
 104         Row row = mock(Row.class);
 105         Bridge bridge = mock(Bridge.class, RETURNS_DEEP_STUBS);
 106
 107         ConcurrentHashMap<String, Row> hashMap;
 108         hashMap = new ConcurrentHashMap<>();
 109         hashMap.put("mockUUID", row);
 110
 111         /* TODO SB_MIGRATION */
 112         //verifyNoMoreInteractions(ovsdbConfigurationService);
 113         verifyNoMoreInteractions(configurationService);
 114         verifyNoMoreInteractions(networkingProviderManager);
 115
 116         assertEquals("Error, did not return correct boolean from isNodeNeutronReady", false,
 117                 bridgeConfigurationManagerImpl.isNodeNeutronReady(nodeMock));
 118
 119         //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(hashMap);
 120         //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Bridge.class),
 121         //        any(Row.class))).thenReturn(bridge);
 122         when(bridge.getName()).thenReturn("test-bridge");
 123         when(configurationService.getIntegrationBridgeName()).thenReturn("test-bridge");
 124
 125         assertEquals("Error, did not return correct boolean from isNodeNeutronReady", true,
 126                 bridgeConfigurationManagerImpl.isNodeNeutronReady(nodeMock));
 127
 128         verify(configurationService, times(2)).getIntegrationBridgeName();
 129         verifyNoMoreInteractions(networkingProviderManager);
 130     }
 131
 132     /* TODO SB_MIGRATION */ @Ignore
 133     @Test
 134     public void testIsNodeOverlayReady() throws Exception {
 135         Row row = mock(Row.class);
 136         Bridge bridge = mock(Bridge.class, RETURNS_DEEP_STUBS);
 137
 138         ConcurrentHashMap<String, Row> hashMap;
 139         hashMap = new ConcurrentHashMap<>();
 140         hashMap.put("mockUUID", row);
 141
 142         /* TODO SB_MIGRATION */
 143         //verifyNoMoreInteractions(ovsdbConfigurationService);
 144         verifyNoMoreInteractions(configurationService);
 145         verifyNoMoreInteractions(networkingProviderManager);
 146
 147         assertEquals("Error, did not return correct boolean from isNodeOverlayReady", false,
 148                 bridgeConfigurationManagerImpl.isNodeOverlayReady(nodeMock));
 149
 150         //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(hashMap);
 151         //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Bridge.class),
 152         //        any(Row.class))).thenReturn(bridge);
 153         when(bridge.getName()).thenReturn("test-bridge");
 154         when(configurationService.getIntegrationBridgeName()).thenReturn("test-bridge");
 155         when(configurationService.getNetworkBridgeName()).thenReturn("test-bridge");
 156
 157         /* TODO SB_MIGRATION */
 158         //assertEquals("Error, did not return correct boolean from isNodeOverlayReady", true,
 159         //        bridgeConfigurationManagerImpl.isNodeOverlayReady(nodeMock));
 160
 161         verify(configurationService, times(2)).getIntegrationBridgeName();
 162         verify(configurationService, times(1)).getNetworkBridgeName();
 163         //verify(ovsdbConfigurationService, times(3)).getTableName(nodeMock, Bridge.class);
 164         verifyNoMoreInteractions(networkingProviderManager);
 165     }
 166
 167     /* TODO SB_MIGRATION */
 168     @Ignore
 169     @Test
 170     public void testIsPortOnBridge() throws Exception {
 171         UUID uuid = mock(UUID.class);
 172         Set<UUID> uuidSet = new HashSet<>();
 173         uuidSet.add(uuid);
 174         Column<GenericTableSchema, Set<UUID>> columnMock = mock(Column.class);
 175         Port port = mock(Port.class, RETURNS_DEEP_STUBS);
 176         String portName = "portNameMock";
 177
 178         /* TODO SB_MIGRATION */
 179         //verifyNoMoreInteractions(ovsdbConfigurationService);
 180         verifyNoMoreInteractions(configurationService);
 181         verifyNoMoreInteractions(networkingProviderManager);
 182
 183         when(bridgeMock.getPortsColumn()).thenReturn(columnMock);
 184         when(columnMock.getData()).thenReturn(uuidSet);
 185         assertEquals("Error, did not return correct boolean from isPortOnBridge", false,
 186                 bridgeConfigurationManagerImpl.isPortOnBridge(nodeMock, bridgeMock, portName));
 187
 188         when(port.getName()).thenReturn(portName);
 189
 190         //when(ovsdbConfigurationService.getTypedRow(any(Node.class), any(Class.class), any(Row.class))).thenReturn(port);
 191         when(port.getName()).thenReturn(portName);
 192
 193         /* TODO SB_MIGRATION */
 194         //assertEquals("Error, did not return correct boolean from isPortOnBridge", true,
 195         //        bridgeConfigurationManagerImpl.isPortOnBridge(nodeMock, bridgeMock, portName));
 196
 197         verify(bridgeMock, times(2)).getPortsColumn();
 198         //verify(ovsdbConfigurationService, times(2)).getRow(any(Node.class), anyString(), anyString());
 199         //verify(ovsdbConfigurationService, times(2)).getTableName(any(Node.class), any(Class.class));
 200         //verify(ovsdbConfigurationService, times(2)).getTypedRow(any(Node.class), any(Class.class), any(Row.class));
 201         verifyNoMoreInteractions(networkingProviderManager);
 202         verifyNoMoreInteractions(configurationService);
 203     }
 204
 205     @Test
 206     public void testIsNodeTunnelReady() throws Exception {
 207         String bridgeMockName = "BridgeMockName";
 208
 209         /* TODO SB_MIGRATION */
 210         //verifyNoMoreInteractions(ovsdbConfigurationService);
 211         verifyNoMoreInteractions(configurationService);
 212         verifyNoMoreInteractions(networkingProviderManager);
 213
 214         when(configurationService.getIntegrationBridgeName()).thenReturn(bridgeMockName);
 215         // getBridge() is private method - cannot be mocked with mockito
 216         // when(bridgeConfigurationManagerImpl.getBridge(any(Node.class), anyString())).thenReturn(bridgeMock);
 217
 218         // Negative testing only due to private method call
 219         assertEquals("Error, did not return correct boolean from isNodeTunnelReady", false,
 220                 bridgeConfigurationManagerImpl.isNodeTunnelReady(nodeMock));
 221
 222         verify(configurationService, times(1)).getIntegrationBridgeName();
 223         verify(networkingProviderManager, times(0)).getProvider(nodeMock);
 224         verify(configurationService, times(0)).getNetworkBridgeName();
 225         //verify(ovsdbConfigurationService, times(1)).getRows(any(Node.class), anyString());
 226         //verify(ovsdbConfigurationService, times(1)).getTableName(any(Node.class), any(Class.class));
 227         //verify(ovsdbConfigurationService, times(0)).getTypedRow(any(Node.class), any(Class.class), any(Row.class));
 228     }
 229
 230     @Test
 231     public void testIsNodeVlanReady() throws Exception {
 232         NeutronNetwork neutronNetworkMock = mock(NeutronNetwork.class);
 233
 234         /* TODO SB_MIGRATION */
 235         //verifyNoMoreInteractions(ovsdbConfigurationService);
 236         verifyNoMoreInteractions(configurationService);
 237         verifyNoMoreInteractions(networkingProviderManager);
 238
 239         // getBridge() is private method - cannot be mocked with mockito
 240         // Negative testing only due to private method call
 241         assertEquals("Error, did not return correct boolean from isNodeVlanReady", false,
 242                 bridgeConfigurationManagerImpl.isNodeVlanReady(nodeMock, neutronNetworkMock));
 243
 244         verify(configurationService, times(1)).getIntegrationBridgeName();
 245         verify(networkingProviderManager, times(0)).getProvider(any(Node.class));
 246         verify(configurationService, times(0)).getNetworkBridgeName();
 247         //verify(ovsdbConfigurationService, times(1)).getRows(any(Node.class), anyString());
 248         //verify(ovsdbConfigurationService, times(1)).getTableName(any(Node.class), any(Class.class));
 249         //verify(ovsdbConfigurationService, times(0)).getTypedRow(any(Node.class), any(Class.class), any(Row.class));
 250         verify(neutronNetworkMock, times(0)).getProviderPhysicalNetwork();
 251     }
 252
 253     /* TODO SB_MIGRATION */
 254     @Ignore
 255     @Test
 256     public void testPrepareNode() throws Exception {
 257         NetworkingProvider netProvider = mock(NetworkingProvider.class);
 258         when(configurationService.getIntegrationBridgeName()).thenReturn("intBridgeName");
 259         when(networkingProviderManager.getProvider(any(Node.class))).thenReturn(netProvider);
 260
 261         // createIntegrationBridge() is private method - cannot be mocked with mockito
 262         // Negative testing only due to private method call
 263         bridgeConfigurationManagerImpl.prepareNode(nodeMock);
 264
 265         verify(configurationService, times(1)).getIntegrationBridgeName();
 266         /* TODO SB_MIGRATION */
 267         //verify(networkingProviderManager, times(0)).getProvider(any(Node.class));
 268         verify(netProvider, times(0)).initializeFlowRules(any(Node.class));
 269     }
 270
 271     @Test
 272     public void testCreateLocalNetwork() throws Exception {
 273         NeutronNetwork neutronNetworkMock = mock(NeutronNetwork.class, RETURNS_MOCKS);
 274         String networkTypes[] = {"vlan", "vxlan", "gre"};
 275
 276         for (String networkType : networkTypes) {
 277             when(neutronNetworkMock.getProviderNetworkType()).thenReturn(networkType);
 278
 279             doAnswer(new Answer<Boolean>() {
 280                 @Override
 281                 public Boolean answer(InvocationOnMock invocation) {
 282                     return Boolean.TRUE;
 283                 }
 284             }).when(bridgeConfigurationManagerImplSpy).isNodeVlanReady(any(Node.class), any(NeutronNetwork.class));
 285
 286             doAnswer(new Answer<Boolean>() {
 287                 @Override
 288                 public Boolean answer(InvocationOnMock invocation) {
 289                     return Boolean.TRUE;
 290                 }
 291             }).when(bridgeConfigurationManagerImplSpy).isNodeTunnelReady(any(Node.class));
 292
 293             assertTrue("bridgeConfigMock.isNodeVlanReady is not true",
 294                     bridgeConfigurationManagerImplSpy.isNodeVlanReady(nodeMock, neutronNetworkMock));
 295             assertTrue("bridgeConfigMock.isNodeTunnelReady is not true",
 296                     bridgeConfigurationManagerImplSpy.isNodeTunnelReady(nodeMock));
 297
 298             assertTrue("Error, isCreated is not true for " + networkType,
 299                     bridgeConfigurationManagerImplSpy.createLocalNetwork(nodeMock, neutronNetworkMock));
 300             if (networkType == "vlan") {
 301                 verify(neutronNetworkMock, times(1)).getProviderNetworkType();
 302             } else if (networkType == "vxlan") {
 303                 verify(neutronNetworkMock, times(2)).getProviderNetworkType();
 304             } else if (networkType == "gre") {
 305                 verify(neutronNetworkMock, times(3)).getProviderNetworkType();
 306             }
 307             reset(neutronNetworkMock);
 308             reset(nodeMock);
 309             reset(bridgeConfigurationManagerImplSpy);
 310         }
 311     }
 312
 313     @Test
 314     public void testGetPhysicalInterfaceName() throws Exception {
 315         ConcurrentHashMap ovsTable = mock(ConcurrentHashMap.class, RETURNS_DEEP_STUBS);
 316         Row row = mock(Row.class);
 317         OpenVSwitch ovsRowOVS = mock(OpenVSwitch.class);
 318         Column<GenericTableSchema, Map<String, String>> col = mock(Column.class);
 319         Map<String, String> colMap = mock(Map.class);
 320
 321         HashMap<String, OpenVSwitch> hashMapOVS = new HashMap<>();
 322         hashMapOVS.put("ovsRow", ovsRowOVS);
 323         ConcurrentHashMap<String, Row> hashMap;
 324         hashMap = new ConcurrentHashMap<>();
 325         hashMap.put("row1", row);
 326
 327         String networkNames[] = {"network-0", "network-1", "network-2", "network-3"};
 328         String interfaceNames[] = {"interfaceName-0", "interfaceName-1", "interfaceName-2", "interfaceName-3"};
 329         int count = 0;
 330
 331         for (String networkName : networkNames) {
 332             /* TODO SB_MIGRATION */
 333             //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(hashMap);
 334             when(ovsTable.values()).thenReturn(hashMapOVS.values());
 335
 336             when(ovsRowOVS.getOtherConfigColumn()).thenReturn(col);
 337             when(col.getData()).thenReturn(colMap);
 338             when(configurationService.getProviderMappingsKey()).thenReturn("network-0:interfaceName-0," +
 339                     "network-1:interfaceName-1,network-2:interfaceName-2,network-3:interfaceName-3");
 340             when(colMap.get(anyString())).thenReturn("network-0:interfaceName-0,network-1:interfaceName-1," +
 341                     "network-2:interfaceName-2,network-3:interfaceName-3");
 342
 343             when(configurationService.getDefaultProviderMapping()).thenReturn("network-0:interfaceName-0," +
 344                     "network-1:interfaceName-1,network-2:interfaceName-2,network-3:interfaceName-3");
 345
 346             //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(OpenVSwitch.class),
 347             //        any(Row.class))).thenReturn(ovsRowOVS);
 348
 349             assertEquals("Error, network: " + networkName + ", did not match interface: " + interfaceNames[count],
 350                     interfaceNames[count], bridgeConfigurationManagerImpl.getPhysicalInterfaceName(nodeMock,
 351                             networkName));
 352
 353             //verify(ovsdbConfigurationService, times(count + 1)).getRows(any(Node.class), anyString());
 354             //verify(ovsdbConfigurationService, times(count + 1)).getTableName(any(Node.class), any(Class.class));
 355             //verify(ovsdbConfigurationService, times(count + 1)).getTypedRow(any(Node.class), any(Class.class),
 356             //        any(Row.class));
 357             verify(configurationService, times(count + 1)).getProviderMappingsKey();
 358             verify(configurationService, times(0)).getDefaultProviderMapping();
 359             count++;
 360         }
 361     }
 362
 363     @Test
 364     public void testGetAllPhysicalInterfaceNames() throws Exception {
 365         String interfaceNames[] = {"interfaceName-0", "interfaceName-1", "interfaceName-2", "interfaceName-3"};
 366         List<String> intNameList = new ArrayList<>();
 367         for (String name: interfaceNames){
 368             intNameList.add(name);
 369         }
 370         Row row = mock(Row.class);
 371         OpenVSwitch ovsRowOVS = mock(OpenVSwitch.class);
 372         Column<GenericTableSchema, Map<String, String>> col = mock(Column.class);
 373         Map<String, String> colMap = mock(Map.class);
 374         ConcurrentHashMap<String, Row> hashMap;
 375         hashMap = new ConcurrentHashMap<>();
 376         hashMap.put("row1", row);
 377
 378         /* TODO SB_MIGRATION */
 379         //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(hashMap);
 380         //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(OpenVSwitch.class),
 381         //        any(Row.class))).thenReturn(ovsRowOVS);
 382         when(ovsRowOVS.getOtherConfigColumn()).thenReturn(col);
 383         when(col.getData()).thenReturn(colMap);
 384         when(colMap.get(anyString())).thenReturn("network-0:interfaceName-0,network-1:interfaceName-1," +
 385                 "network-2:interfaceName-2,network-3:interfaceName-3");
 386
 387         assertEquals("Error, did not get all interface names", intNameList,
 388                 bridgeConfigurationManagerImpl.getAllPhysicalInterfaceNames(nodeMock));
 389         //verify(ovsdbConfigurationService, times(1)).getRows(any(Node.class), anyString());
 390         //verify(ovsdbConfigurationService, times(1)).getTableName(any(Node.class), any(Class.class));
 391         //verify(ovsdbConfigurationService, times(1)).getTypedRow(any(Node.class), any(Class.class), any(Row.class));
 392         verify(configurationService, times(1)).getProviderMappingsKey();
 393         verify(configurationService, times(0)).getDefaultProviderMapping();
 394     }
 395
 396     @Test
 397     public void testGetBridge() throws Exception {
 398         Row row = mock(Row.class);
 399         Bridge bridge = mock(Bridge.class);
 400         ConcurrentHashMap<String, Row> hashMap;
 401         hashMap = new ConcurrentHashMap<>();
 402         hashMap.put("row1", row);
 403
 404         /* TODO SB_MIGRATION */
 405         //when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(hashMap);
 406         //when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Bridge.class),
 407         //        any(Row.class))).thenReturn(bridge);
 408         when(bridge.getName()).thenReturn("test-bridge");
 409
 410         assertEquals("Error, did not get correct bridge", bridge,
 411                 bridgeConfigurationManagerImpl.getBridge(nodeMock, "test-bridge"));
 412         //verify(ovsdbConfigurationService, times(1)).getRows(any(Node.class), anyString());
 413         //verify(ovsdbConfigurationService, times(1)).getTableName(any(Node.class), any(Class.class));
 414         //verify(ovsdbConfigurationService, times(1)).getTypedRow(any(Node.class), any(Class.class), any(Row.class));
 415     }
 416 }