renderers/oc/src/test/java/org/opendaylight/groupbasedpolicy/renderer/oc/TestL2DomainManager.java

   1 /*
   2  * Copyright (C) 2015 Juniper Networks, Inc.
   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.groupbasedpolicy.renderer.oc;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.mockito.Mockito.mock;
  14 import static org.mockito.Mockito.when;
  15
  16 import java.io.IOException;
  17 import java.net.HttpURLConnection;
  18 import java.util.ArrayList;
  19 import java.util.List;
  20 import java.util.Map;
  21 import java.util.Set;
  22 import java.util.concurrent.ScheduledExecutorService;
  23
  24 import net.juniper.contrail.api.ApiConnector;
  25 import net.juniper.contrail.api.types.FloatingIpPool;
  26 import net.juniper.contrail.api.types.Project;
  27 import net.juniper.contrail.api.types.VirtualNetwork;
  28
  29 import org.junit.After;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32 import org.mockito.Mock;
  33 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  34 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  35 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  36 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  37 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  38 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  39 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  40 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  41 import org.opendaylight.groupbasedpolicy.jsonrpc.JsonRpcEndpoint;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L2FloodDomain;
  45 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  46 import org.opendaylight.yangtools.yang.binding.DataObject;
  47 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 import com.google.common.base.Optional;
  52 import com.google.common.util.concurrent.CheckedFuture;
  53
  54 /**
  55  * Test Class for L2 Flood Domain.
  56  */
  57
  58 public class TestL2DomainManager {
  59     L2DomainManager domainmanager;
  60     ApiConnector apiconnector;
  61     ApiConnector mockedApiConnector = mock(ApiConnector.class);
  62     VirtualNetwork mockedVirtualNetwork = mock(VirtualNetwork.class);
  63     Project mockedProject = mock(Project.class);
  64     FloatingIpPool mockedFloatingIpPool = mock(FloatingIpPool.class);
  65     L2FloodDomain mockFd = mock(L2FloodDomain.class);
  66     L2FloodDomain mockFdNew = mock(L2FloodDomain.class);
  67     @Mock
  68     private DataBroker mockBroker;
  69     @Mock
  70     private RpcProviderRegistry mockRpcRegistry;
  71     @Mock
  72     private ScheduledExecutorService mockExecutor;
  73     @Mock
  74     private ListenerRegistration<DataChangeListener> mockListener;
  75     @Mock
  76     private ListenerRegistration<DataChangeListener> mockL3Listener;
  77     @Mock
  78     private CheckedFuture<Optional<L2FloodDomain>,ReadFailedException> mockReadFuture;
  79     @Mock
  80     private JsonRpcEndpoint mockAgent;
  81     @Mock
  82     private OcRenderer mockOcRenderer;
  83     @Mock
  84     private WriteTransaction mockWriteTransaction;
  85     @Mock
  86     private ReadOnlyTransaction mockReadTransaction;
  87     @Mock
  88     private CheckedFuture<Void, TransactionCommitFailedException> mockWriteFuture;
  89     @Mock
  90     private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> mockChange;
  91     @Mock
  92     private Map<InstanceIdentifier<?>, DataObject> mockDaoMap;
  93     @Mock
  94     private Set<InstanceIdentifier<?>> mockDaoSet;
  95     @Mock
  96     private DataObject mockDao;
  97     @Mock
  98     private InstanceIdentifier<?> mockIid;
  99     protected static final Logger logger = LoggerFactory.getLogger(L2DomainManager.class);
 100     private static final String TENANT_ID = "22282cca-9a13-4d0c-a67e-a933ebb0b0ae";
 101     private static final String TENANT_ID_VALUE = "[_value=22282cca-9a13-4d0c-a67e-a933ebb0b0ae]";
 102     private static final L2FloodDomainId FLOOD_DOMAIN_ID = new L2FloodDomainId("08e3904c-7850-41c0-959a-1a646a83598a");
 103     private static final Name FLOOD_DOMAIN_NAME = new Name("MOCK_DOMAIN");
 104
 105     List<DataObject> daoList =
 106             new ArrayList<DataObject>();
 107
 108     @Before
 109     public void beforeTest() {
 110         domainmanager = new L2DomainManager(mockBroker, mockRpcRegistry, mockExecutor);
 111         assertNotNull(mockedApiConnector);
 112         assertNotNull(mockedVirtualNetwork);
 113         assertNotNull(mockedProject);
 114         assertNotNull(mockedFloatingIpPool);
 115     }
 116
 117     @After
 118     public void AfterTest() {
 119         domainmanager = null;
 120         apiconnector = null;
 121     }
 122
 123    /*  Test method to check if flood domain id is null*/
 124     @Test
 125     public void testCanCreateFloodDomainIDNull() {
 126         OcRenderer.apiConnector = mockedApiConnector;
 127         when(mockFd.getId()).thenReturn(null);
 128         assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,domainmanager.canCreateFloodDomain(mockFd, TENANT_ID));
 129     }
 130
 131     /* Test method to check if flood domain name is null*/
 132     @Test
 133     public void testCanCreateFloodDomainNameNull() {
 134         OcRenderer.apiConnector = mockedApiConnector;
 135         when(mockFd.getName()).thenReturn(null);
 136         assertEquals(HttpURLConnection.HTTP_BAD_REQUEST,domainmanager.canCreateFloodDomain(mockFd, TENANT_ID));
 137     }
 138
 139      /*Test method to check if FloodDomain ProjctUUID is not found */
 140     @Test
 141     public void testCanCreateFloodDomainProjctUUIDNotFound() throws IOException {
 142         OcRenderer.apiConnector = mockedApiConnector;
 143         when(mockFd.getId()).thenReturn(FLOOD_DOMAIN_ID);
 144         when(mockFd.getName()).thenReturn(FLOOD_DOMAIN_NAME);
 145         when(mockedApiConnector.findById(Project.class, TENANT_ID)).thenReturn(null);
 146         assertEquals(HttpURLConnection.HTTP_NOT_FOUND,domainmanager.canCreateFloodDomain(mockFd ,TENANT_ID_VALUE));
 147     }
 148
 149     /*Test method to check if FloodDomain ProjctUUID is forbidden */
 150     @Test
 151     public void testCanCreateFloodDomainForbidden() throws IOException {
 152         OcRenderer.apiConnector = mockedApiConnector;
 153         when(mockFd.getId()).thenReturn(FLOOD_DOMAIN_ID);
 154         when(mockFd.getName()).thenReturn(FLOOD_DOMAIN_NAME);
 155         String mockL2FloodDomainUUID = "08e3904c-7850-41c0-959a-1a646a83598a";
 156         when(mockedApiConnector.findById(Project.class, TENANT_ID)).thenReturn(mockedProject);
 157         when(mockedApiConnector.findById(VirtualNetwork.class, mockL2FloodDomainUUID)).thenReturn(mockedVirtualNetwork);
 158         assertEquals(HttpURLConnection.HTTP_FORBIDDEN,domainmanager.canCreateFloodDomain(mockFd ,TENANT_ID_VALUE));
 159     }
 160
 161     /*Test method to check if FloodDomain is created ok. */
 162     @Test
 163     public void testCanCreateFloodDomainOk() throws IOException {
 164         OcRenderer.apiConnector = mockedApiConnector;
 165         when(mockFd.getId()).thenReturn(FLOOD_DOMAIN_ID);
 166         when(mockFd.getName()).thenReturn(FLOOD_DOMAIN_NAME);
 167         String mockL2FloodDomainUUID = "08e3904c-7850-41c0-959a-1a646a83598a";
 168         when(mockedApiConnector.findById(Project.class, TENANT_ID)).thenReturn(mockedProject);
 169         when(mockedApiConnector.findById(VirtualNetwork.class, mockL2FloodDomainUUID)).thenReturn(null);
 170         assertEquals(HttpURLConnection.HTTP_OK,domainmanager.canCreateFloodDomain(mockFd ,TENANT_ID_VALUE));
 171     }
 172
 173     /*Test method to check if FloodDomain Name is null */
 174     @Test
 175     public void testCanUpdateFloodDomainNameisNull(){
 176         OcRenderer.apiConnector = mockedApiConnector;
 177         when(mockFd.getId()).thenReturn(FLOOD_DOMAIN_ID);
 178         when(mockFdNew.getName()).thenReturn(null);
 179         assertEquals(HttpURLConnection.HTTP_BAD_REQUEST, domainmanager.canUpdateFloodDomain(mockFdNew, mockFd, TENANT_ID_VALUE));
 180     }
 181
 182     /*Test method to check if FloodDomainName already exists */
 183     @Test
 184     public void testCanUpdateFloodDomainNameALreadyExist() throws IOException{
 185         OcRenderer.apiConnector = mockedApiConnector;
 186         String mockL2FloodDomainUUID = "08e3904c-7850-41c0-959a-1a646a83598a";
 187         String name = "MOCK_DOMAIN";
 188         when(mockFd.getId()).thenReturn(FLOOD_DOMAIN_ID);
 189         when(mockFdNew.getName()).thenReturn(FLOOD_DOMAIN_NAME);
 190         when(mockedApiConnector.findById(Project.class, TENANT_ID)).thenReturn(mockedProject);
 191         when(mockedApiConnector.findById(VirtualNetwork.class, mockL2FloodDomainUUID)).thenReturn(mockedVirtualNetwork);
 192         when(mockedApiConnector.findByName(VirtualNetwork.class, mockedProject, mockFdNew.getName().toString())).thenReturn(name);
 193         assertEquals(HttpURLConnection.HTTP_FORBIDDEN, domainmanager.canUpdateFloodDomain(mockFdNew, mockFd, TENANT_ID_VALUE));
 194     }
 195
 196     /*Test method to check if FloodDomain ID is null */
 197     @Test
 198     public void testCanUpdateFloodDomainIDisNull() throws IOException{
 199         OcRenderer.apiConnector = mockedApiConnector;
 200         String mockL2FloodDomainUUID = "08e3904c-7850-41c0-959a-1a646a83598a";
 201         when(mockFd.getId()).thenReturn(FLOOD_DOMAIN_ID);
 202         when(mockFdNew.getName()).thenReturn(FLOOD_DOMAIN_NAME);
 203         when(mockedApiConnector.findById(Project.class, TENANT_ID)).thenReturn(mockedProject);
 204         when(mockedApiConnector.findById(VirtualNetwork.class, mockL2FloodDomainUUID)).thenReturn(null);
 205         when(mockedApiConnector.findByName(VirtualNetwork.class, mockedProject, mockFdNew.getName().toString())).thenReturn(null);
 206         assertEquals(HttpURLConnection.HTTP_FORBIDDEN, domainmanager.canUpdateFloodDomain(mockFdNew, mockFd, TENANT_ID_VALUE));
 207     }
 208
 209     /*Test method to check if FloodDomain Name can be updated */
 210     @Test
 211     public void testCanUpdateFloodDomainOK() throws IOException{
 212         OcRenderer.apiConnector = mockedApiConnector;
 213         String mockL2FloodDomainUUID = "08e3904c-7850-41c0-959a-1a646a83598a";
 214         when(mockFd.getId()).thenReturn(FLOOD_DOMAIN_ID);
 215         when(mockFdNew.getName()).thenReturn(FLOOD_DOMAIN_NAME);
 216         when(mockedApiConnector.findById(Project.class, TENANT_ID)).thenReturn(mockedProject);
 217         when(mockedApiConnector.findById(VirtualNetwork.class, mockL2FloodDomainUUID)).thenReturn(mockedVirtualNetwork);
 218         when(mockedApiConnector.findByName(VirtualNetwork.class, mockedProject, mockFdNew.getName().toString())).thenReturn(null);
 219         assertEquals(HttpURLConnection.HTTP_OK, domainmanager.canUpdateFloodDomain(mockFdNew, mockFd, TENANT_ID_VALUE));
 220     }
 221 }