From: Ben Eze Date: Tue, 14 Apr 2015 15:21:26 +0000 (-0400) Subject: Adding Unit Tests for netvirt/providers/openflow13/PipelineOrchestratorImpl X-Git-Tag: release/beryllium-sr2~667^2 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=9491ba52a3361d52a1025dec845d8a84955f04fd;p=netvirt.git Adding Unit Tests for netvirt/providers/openflow13/PipelineOrchestratorImpl Change-Id: Ie1bd6844ec64171a7d338bab495b010a31cf8420 Signed-off-by: beze --- diff --git a/openstack/net-virt-providers/src/test/java/org/opendaylight/ovsdb/openstack/netvirt/providers/openflow13/PipelineOrchestratorImplTest.java b/openstack/net-virt-providers/src/test/java/org/opendaylight/ovsdb/openstack/netvirt/providers/openflow13/PipelineOrchestratorImplTest.java new file mode 100644 index 0000000000..3f2bf622b4 --- /dev/null +++ b/openstack/net-virt-providers/src/test/java/org/opendaylight/ovsdb/openstack/netvirt/providers/openflow13/PipelineOrchestratorImplTest.java @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2015 Inocybe Technologies. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.ovsdb.openstack.netvirt.providers.openflow13; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.lang.reflect.Field; +import java.util.Random; +import java.util.concurrent.BlockingQueue; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; +import org.opendaylight.neutron.spi.INeutronNetworkCRUD; +import org.opendaylight.neutron.spi.INeutronPortCRUD; +import org.opendaylight.neutron.spi.INeutronSubnetCRUD; +import org.opendaylight.neutron.spi.NeutronLoadBalancerPool; +import org.opendaylight.ovsdb.openstack.netvirt.AbstractEvent; +import org.opendaylight.ovsdb.openstack.netvirt.AbstractHandler; +import org.opendaylight.ovsdb.openstack.netvirt.LBaaSHandler; +import org.opendaylight.ovsdb.openstack.netvirt.LBaaSPoolHandler; +import org.opendaylight.ovsdb.openstack.netvirt.NeutronCacheUtils; +import org.opendaylight.ovsdb.openstack.netvirt.api.Constants; +import org.opendaylight.ovsdb.openstack.netvirt.impl.EventDispatcherImpl; +import org.osgi.framework.ServiceReference; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +/** + * Unit test for {@link PipelineOrchestratorImplTest} + */ +@PrepareForTest(PipelineOrchestratorImpl.class) +@RunWith(PowerMockRunner.class) +public class PipelineOrchestratorImplTest { + + @Mock + private ServiceReference ref; + @Mock + private ServiceReference ref2; + @Mock + private AbstractServiceInstance serviceInstance; + @Mock + private AbstractServiceInstance serviceInstance2; + + @InjectMocks + private PipelineOrchestratorImpl orchestrator; + + private AbstractEvent.HandlerType handlerTypeObject = AbstractEvent.HandlerType.NEUTRON_FLOATING_IP; + + @Before + public void setUp() { + Random r = new Random(); + + orchestrator = new PipelineOrchestratorImpl(); + orchestrator.init(); + orchestrator.start(); + + when(ref.getProperty(org.osgi.framework.Constants.SERVICE_ID)) + .thenReturn(r.nextLong()); + when(ref.getProperty(Constants.EVENT_HANDLER_TYPE_PROPERTY)) + .thenReturn(handlerTypeObject); + when(ref.getProperty(AbstractServiceInstance.SERVICE_PROPERTY)) + .thenReturn(Service.CLASSIFIER); + + when(ref2.getProperty(org.osgi.framework.Constants.SERVICE_ID)) + .thenReturn(r.nextLong()); + when(ref2.getProperty(Constants.EVENT_HANDLER_TYPE_PROPERTY)) + .thenReturn(handlerTypeObject); + when(ref2.getProperty(AbstractServiceInstance.SERVICE_PROPERTY)) + .thenReturn(Service.INBOUND_NAT); + + when(serviceInstance.getService()).thenReturn(Service.CLASSIFIER); + when(serviceInstance2.getService()).thenReturn(Service.INBOUND_NAT); + } + + /*** + * Registers a mock service and verifies the registration by asking the + * pipeline orchestrator to return the associated service from its internal + * registry + */ + @Test + public void testRegisterService() { + orchestrator.registerService(ref, serviceInstance); + assertEquals("Error, registerService() service registration fails", + serviceInstance, + orchestrator.getServiceInstance(Service.CLASSIFIER)); + } + + /*** + * Test method {@link PipelineOrchestratorImplr#registerService(Service)} + * + * Unregisters a mock service and verifies the process by asking the + * pipeline orchestrator to return the associated service from its internal + * registry + */ + @Test + public void testUnRegisterService() { + + orchestrator = new PipelineOrchestratorImpl(); + orchestrator.init(); + orchestrator.start(); + orchestrator.registerService(ref, serviceInstance); + orchestrator.unregisterService(ref); + + assertEquals("Error, unregisterService() service registration fails", + null, orchestrator.getServiceInstance(Service.CLASSIFIER)); + + } + + /** + * Test method + * {@link PipelineOrchestratorImplr#getNextServiceInPipeline(Service)} + */ + @Test + public void testGetNextServiceInPipeline() { + + assertEquals(orchestrator.getNextServiceInPipeline(Service.CLASSIFIER), + Service.ARP_RESPONDER); + assertEquals( + orchestrator.getNextServiceInPipeline(Service.ARP_RESPONDER), + Service.INBOUND_NAT); + assertEquals( + orchestrator.getNextServiceInPipeline(Service.INBOUND_NAT), + Service.EGRESS_ACL); + assertEquals(orchestrator.getNextServiceInPipeline(Service.EGRESS_ACL), + Service.LOAD_BALANCER); + assertEquals( + orchestrator.getNextServiceInPipeline(Service.LOAD_BALANCER), + Service.ROUTING); + assertEquals(orchestrator.getNextServiceInPipeline(Service.ROUTING), + Service.L3_FORWARDING); + assertEquals( + orchestrator.getNextServiceInPipeline(Service.L3_FORWARDING), + Service.L2_REWRITE); + assertEquals(orchestrator.getNextServiceInPipeline(Service.L2_REWRITE), + Service.INGRESS_ACL); + assertEquals( + orchestrator.getNextServiceInPipeline(Service.INGRESS_ACL), + Service.OUTBOUND_NAT); + assertEquals( + orchestrator.getNextServiceInPipeline(Service.OUTBOUND_NAT), + Service.L2_FORWARDING); + assertNull(orchestrator.getNextServiceInPipeline(Service.L2_FORWARDING)); + + } + + /** + * Test method {@link PipelineOrchestratorImpl#getServiceInstance(Service)} + */ + @Test + public void testGetServiceInstance() { + + orchestrator = new PipelineOrchestratorImpl(); + orchestrator.init(); + orchestrator.start(); + orchestrator.registerService(ref, serviceInstance); + orchestrator.registerService(ref2, serviceInstance2); + + assertEquals( + "Error, getServiceInstance() fails to return an instance of a registered service", + serviceInstance, + orchestrator.getServiceInstance(Service.CLASSIFIER)); + + assertEquals( + "Error, getServiceInstance() returned an instance of a service that wasn't registered.", + null, orchestrator.getServiceInstance(Service.DIRECTOR)); + } + +}