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