Adding Unit Tests for netvirt/providers/openflow13/PipelineOrchestratorImpl

Change-Id: Ie1bd6844ec64171a7d338bab495b010a31cf8420
Signed-off-by: beze <beze@inocybe.ca>

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 (file)
index 0000000..3f2bf62
--- /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));
+    }
+
+}