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