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