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