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

   1 /*
   2  * Copyright (c) 2015 Inocybe 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
   9 package org.opendaylight.ovsdb.openstack.netvirt.impl;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertTrue;
  13 import static org.mockito.Matchers.any;
  14 import static org.mockito.Matchers.anyString;
  15 import static org.mockito.Matchers.eq;
  16 import static org.mockito.Matchers.same;
  17 import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
  18 import static org.mockito.Mockito.mock;
  19 import static org.mockito.Mockito.times;
  20 import static org.mockito.Mockito.verify;
  21 import static org.mockito.Mockito.when;
  22
  23 import java.util.ArrayList;
  24 import java.util.HashMap;
  25 import java.util.List;
  26 import java.util.Map;
  27 import java.util.concurrent.ConcurrentHashMap;
  28
  29 import org.junit.Test;
  30 import org.junit.runner.RunWith;
  31 import org.mockito.InjectMocks;
  32 import org.mockito.Mock;
  33 import org.mockito.runners.MockitoJUnitRunner;
  34 import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
  35 import org.opendaylight.neutron.spi.INeutronPortCRUD;
  36 import org.opendaylight.neutron.spi.NeutronNetwork;
  37 import org.opendaylight.neutron.spi.NeutronPort;
  38 import org.opendaylight.ovsdb.lib.notation.Column;
  39 import org.opendaylight.ovsdb.lib.notation.Row;
  40 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  41 import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
  42 import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProvider;
  43 import org.opendaylight.ovsdb.openstack.netvirt.api.NetworkingProviderManager;
  44 import org.opendaylight.ovsdb.openstack.netvirt.api.VlanConfigurationCache;
  45 import org.opendaylight.ovsdb.plugin.api.OvsdbConfigurationService;
  46 import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
  47 import org.opendaylight.ovsdb.plugin.api.Status;
  48 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  49 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
  50 import org.opendaylight.ovsdb.schema.openvswitch.Port;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  52
  53 /**
  54  * Unit test for {@link TenantNetworkManagerImpl}
  55  */
  56 @RunWith(MockitoJUnitRunner.class)
  57 public class TenantNetworkManagerImplTest {
  58
  59     @Mock private VlanConfigurationCache vlanConfigurationCache;
  60     @Mock private INeutronPortCRUD neutronCache;
  61     @Mock private OvsdbConfigurationService ovsdbConfigurationService;
  62     @Mock private NetworkingProviderManager networkingProviderManager;
  63     @Mock private OvsdbConnectionService ovsdbConnectionService;
  64
  65     @InjectMocks private TenantNetworkManagerImpl tenantNetworkManagerImpl;
  66     @InjectMocks private INeutronPortCRUD neutronPortCache = mock(INeutronPortCRUD.class);
  67     @InjectMocks private INeutronNetworkCRUD neutronNetworkCache = mock(INeutronNetworkCRUD.class);
  68
  69     private static final String NETWORK_ID= "networkId";
  70
  71     /**
  72      * Test method {@link TenantNetworkManagerImpl#getInternalVlan(Node, String)}
  73      */
  74     @Test
  75     public void testGetInternalVlan() {
  76         when(vlanConfigurationCache.getInternalVlan(any(Node.class), eq(NETWORK_ID))).thenReturn(10);
  77
  78         assertEquals("Error, did not return the correct internalVlan" , 10, tenantNetworkManagerImpl.getInternalVlan(mock(Node.class), NETWORK_ID));
  79         assertEquals("Error, did not return the correct internalVlan", 0, tenantNetworkManagerImpl.getInternalVlan(mock(Node.class), "unexistingNetwork"));
  80
  81         verify(vlanConfigurationCache, times(2)).getInternalVlan(any(Node.class), anyString());
  82     }
  83
  84     /**
  85      * Test method {@link TenantNetworkManagerImpl#reclaimInternalVlan(Node, String, NeutronNetwork)}
  86      */
  87     @Test
  88     public void testReclaimInternalVlan() {
  89         when(vlanConfigurationCache.reclaimInternalVlan(any(Node.class), eq(NETWORK_ID))).thenReturn(10);
  90
  91         tenantNetworkManagerImpl.reclaimInternalVlan(mock(Node.class), NETWORK_ID, mock(NeutronNetwork.class));
  92         tenantNetworkManagerImpl.reclaimInternalVlan(mock(Node.class), "unexistingNetwork", mock(NeutronNetwork.class));
  93
  94         verify(vlanConfigurationCache, times(2)).reclaimInternalVlan(any(Node.class), anyString());
  95     }
  96
  97     /**
  98      * Test method {@link TenantNetworkManagerImpl#programInternalVlan(Node, String, NeutronNetwork)}
  99      */
 100     @Test
 101     public void testProgramInternalVlan(){
 102         Port port = mock(Port.class);
 103         Row row = mock(Row.class);
 104         GenericTableSchema tableSchema = mock(GenericTableSchema.class);
 105         Status status = mock(Status.class);
 106
 107         when(port.getRow()).thenReturn(row);
 108         when(port.getSchema()).thenReturn(tableSchema);
 109
 110         when(vlanConfigurationCache.getInternalVlan(any(Node.class), anyString())).thenReturn(10);
 111         when(ovsdbConfigurationService.createTypedRow(any(Node.class), same(Port.class))).thenReturn(port);
 112         when(ovsdbConfigurationService.updateRow(any(Node.class), anyString(), anyString(), anyString(), any(Row.class))).thenReturn(status);
 113
 114         tenantNetworkManagerImpl.programInternalVlan(mock(Node.class), NETWORK_ID, mock(NeutronNetwork.class));
 115
 116         verify(vlanConfigurationCache, times(1)).getInternalVlan(any(Node.class), anyString());
 117     }
 118
 119     /**
 120      * Test method {@link TenantNetworkManagerImpl#isTenantNetworkPresentInNode(Node, String)}
 121      */
 122     @Test
 123     public void testIsTenantNetworkPresentInNode() {
 124         NetworkingProvider networkingProvider = mock(NetworkingProvider.class);
 125
 126         Interface intf = mock(Interface.class);
 127         Column<GenericTableSchema, Map<String, String>> columnMock = mock(Column.class);
 128         Map<String, String> externalIds = new HashMap<String, String>();
 129         externalIds.put(Constants.EXTERNAL_ID_INTERFACE_ID, "interfaceId");
 130
 131         Row row = mock(Row.class);
 132         Bridge bridge = mock(Bridge.class, RETURNS_DEEP_STUBS);
 133
 134         ConcurrentHashMap<String, Row> map;
 135         map = new ConcurrentHashMap<>();
 136         map.put("row", row);
 137
 138         NeutronNetwork neutronNetwork = mock(NeutronNetwork.class);
 139         NeutronPort neutronPort = mock(NeutronPort.class);
 140         ArrayList<NeutronNetwork> listNeutronNetwork = new ArrayList<NeutronNetwork>();
 141         listNeutronNetwork.add(neutronNetwork);
 142
 143         when(neutronNetwork.getProviderSegmentationID()).thenReturn("segId");
 144         when(neutronNetwork.getNetworkUUID()).thenReturn("networkUUID");
 145         when(neutronNetworkCache.getAllNetworks()).thenReturn(listNeutronNetwork);
 146
 147         assertEquals("Error, did not return the UUID of the correct network", listNeutronNetwork.get(0).getNetworkUUID(), tenantNetworkManagerImpl.getNetworkId("segId"));
 148
 149         when(networkingProviderManager.getProvider(any(Node.class))).thenReturn(networkingProvider);
 150         when(networkingProvider.hasPerTenantTunneling()).thenReturn(true);
 151
 152         when(vlanConfigurationCache.getInternalVlan(any(Node.class), anyString())).thenReturn(10);
 153
 154         when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(map);
 155         when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Interface.class),
 156                 any(Row.class))).thenReturn(intf);
 157
 158         when(intf.getExternalIdsColumn()).thenReturn(columnMock);
 159         when(columnMock.getData()).thenReturn(externalIds);
 160
 161         when(neutronPortCache.getPort(anyString())).thenReturn(neutronPort);
 162         when(neutronPort.getNetworkUUID()).thenReturn("networkUUID");
 163
 164         assertTrue("Error, did not return correct boolean for isTenantNetworkPresentInNode", tenantNetworkManagerImpl.isTenantNetworkPresentInNode(mock(Node.class), "segId"));
 165
 166
 167         verify(networkingProviderManager, times(1)).getProvider(any(Node.class));
 168         verify(vlanConfigurationCache, times(1)).getInternalVlan(any(Node.class), anyString());
 169     }
 170
 171     /**
 172      * Test method {@link TenantNetworkManagerImpl#getNetworkId(String)}
 173      */
 174     @Test
 175     public void testGetNetworkId() {
 176         NeutronNetwork neutronNetwork = mock(NeutronNetwork.class);
 177         ArrayList<NeutronNetwork> listNeutronNetwork = new ArrayList<NeutronNetwork>();
 178         listNeutronNetwork.add(neutronNetwork);
 179
 180         when(neutronNetwork.getProviderSegmentationID()).thenReturn("segId");
 181         when(neutronNetwork.getNetworkUUID()).thenReturn("networkUUID");
 182         when(neutronNetworkCache.getAllNetworks()).thenReturn(listNeutronNetwork);
 183
 184         assertEquals("Error, did not return the UUID of the correct network", listNeutronNetwork.get(0).getNetworkUUID(), tenantNetworkManagerImpl.getNetworkId("segId"));
 185
 186         verify(neutronNetworkCache, times(1)).getAllNetworks();
 187     }
 188
 189     /**
 190      * Test method {@link TenantNetworkManagerImpl#getTenantNetwork(Interface)}
 191      */
 192     @Test
 193     public void testGetTenantNetwork() {
 194         Interface intf = mock(Interface.class);
 195         Column<GenericTableSchema, Map<String, String>> columnMock = mock(Column.class);
 196         Map<String, String> externalIds = new HashMap<String, String>();
 197         externalIds.put(Constants.EXTERNAL_ID_INTERFACE_ID, "tenantValue");
 198         NeutronPort neutronPort = mock(NeutronPort.class);
 199         NeutronNetwork neutronNetwork = mock(NeutronNetwork.class);
 200
 201         when(intf.getExternalIdsColumn()).thenReturn(columnMock);
 202         when(columnMock.getData()).thenReturn(externalIds);
 203
 204         when(neutronPort.getNetworkUUID()).thenReturn("neutronUUID");
 205         when(neutronPortCache.getPort(anyString())).thenReturn(neutronPort);
 206         when(neutronNetworkCache.getNetwork(anyString())).thenReturn(neutronNetwork);
 207
 208         assertEquals("Error, did not return the correct tenant", neutronNetwork, tenantNetworkManagerImpl.getTenantNetwork(intf));
 209
 210         verify(neutronPortCache, times(1)).getPort(anyString());
 211         verify(neutronNetworkCache, times(1)).getNetwork(anyString());
 212     }
 213
 214     /**
 215      * Test method {@link TenantNetworkManagerImpl#networkCreated(String)}
 216      */
 217     @Test
 218     public void testNetworkCreated() {
 219         int numberOfNode = 10;
 220         when(vlanConfigurationCache.assignInternalVlan(any(Node.class), anyString())).thenReturn(10);
 221
 222         List<Node> nodes = new ArrayList();
 223         for (int i = 0; i<numberOfNode; i++) {
 224             nodes.add(mock(Node.class));
 225         }
 226         when(ovsdbConnectionService.getNodes()).thenReturn(nodes);
 227
 228         tenantNetworkManagerImpl.networkCreated(NETWORK_ID);
 229
 230         verify(ovsdbConnectionService, times(1)).getNodes();
 231         verify(vlanConfigurationCache, times(numberOfNode)).assignInternalVlan(any(Node.class), anyString());
 232
 233         assertEquals("Error, did not return the correct network id", 10,tenantNetworkManagerImpl.networkCreated(mock(Node.class), NETWORK_ID));
 234     }
 235 }