Re-activate disabled test

The test was deactivated due to deficiencies in testing framework.

Change-Id: I3846dfbf44219e3ddde45a01094ca16ac1e167fb
Signed-off-by: Maros Marsalek <mmarsale@cisco.com>
Signed-off-by: Robert Varga <rovarga@cisco.com>

diff --git a/bgp/rib-impl-config/pom.xml b/bgp/rib-impl-config/pom.xml
index 409574f98633e40296dc4f464cb1001a11c09148..8dc49c830b00cd3cbad53f3e41c6be5b30dad939 100644 (file)
--- a/bgp/rib-impl-config/pom.xml
+++ b/bgp/rib-impl-config/pom.xml
@@ -80,6 +80,12 @@
             <scope>test</scope>
             <type>test-jar</type>
         </dependency>
+        <dependency>
+            <groupId>org.opendaylight.controller</groupId>
+            <artifactId>yang-store-impl</artifactId>
+            <version>${controller.config.version}</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.opendaylight.controller</groupId>
             <artifactId>config-manager</artifactId>

diff --git a/bgp/rib-impl-config/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModuleTest.java b/bgp/rib-impl-config/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModuleTest.java
index f67bcf4effea44d1f26a6f64711538433a994757..e79c7bb1431ddb91db4cd91fe68fc7cdf4aa9946 100644 (file)
--- a/bgp/rib-impl-config/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModuleTest.java
+++ b/bgp/rib-impl-config/src/test/java/org/opendaylight/controller/config/yang/bgp/rib/impl/RIBImplModuleTest.java
@@ -7,9 +7,14 @@
  */
 package org.opendaylight.controller.config.yang.bgp.rib.impl;
 
-import java.io.Closeable;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+
 import java.math.BigDecimal;
-import java.util.Dictionary;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Future;
 
 import javax.management.InstanceAlreadyExistsException;
 import javax.management.InstanceNotFoundException;
@@ -17,10 +22,11 @@ import javax.management.ObjectName;
 
 import org.junit.After;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.mockito.Matchers;
+import org.mockito.Mock;
 import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
 import org.opendaylight.controller.config.api.jmx.CommitStatus;
 import org.opendaylight.controller.config.manager.impl.AbstractConfigTest;
 import org.opendaylight.controller.config.manager.impl.factoriesresolver.HardcodedModuleFactoriesResolver;
@@ -39,12 +45,18 @@ import org.opendaylight.controller.config.yang.md.sal.dom.impl.HashMapDataStoreM
 import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleFactory;
 import org.opendaylight.controller.config.yang.netty.threadgroup.NettyThreadgroupModuleFactory;
 import org.opendaylight.controller.config.yang.reconnectstrategy.TimedReconnectStrategyModuleFactory;
+import org.opendaylight.controller.config.yang.store.impl.YangParserWrapper;
+import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
 import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler;
+import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction;
 import org.opendaylight.controller.sal.core.api.data.DataProviderService;
+import org.opendaylight.controller.sal.core.api.model.SchemaServiceListener;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.rib.rev130925.RibId;
 import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.yang.common.RpcResult;
 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
 import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.model.api.SchemaContext;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleListener;
 import org.osgi.framework.Filter;
@@ -54,8 +66,8 @@ import org.osgi.framework.ServiceReference;
 import com.google.common.collect.Lists;
 
 public class RIBImplModuleTest extends AbstractConfigTest {
-
-       private final String instanceName = "bgp-rib-impl";
+       private static final String INSTANCE_NAME = "bgp-rib-impl";
+       private static final String TRANSACTION_NAME = "testTransaction";
 
        private RIBImplModuleFactory factory;
        private DataBrokerImplModuleFactory dataBrokerFactory;
@@ -71,9 +83,23 @@ public class RIBImplModuleTest extends AbstractConfigTest {
        private RuntimeMappingModuleFactory runtimeMappingFactory;
        private HashMapDataStoreModuleFactory dataStroreFactory;
 
+       @Mock
+       private DataModificationTransaction mockedTransaction;
+
+       @Mock
+       private DataProviderService mockedDataProvider;
+
+       @Mock
+       private Future<RpcResult<TransactionStatus>> mockedFuture;
+
+       @Mock
+       private RpcResult<TransactionStatus> mockedResult;
+
        @SuppressWarnings("unchecked")
        @Before
        public void setUp() throws Exception {
+               MockitoAnnotations.initMocks(this);
+
                this.factory = new RIBImplModuleFactory();
                this.dataBrokerFactory = new DataBrokerImplModuleFactory();
                this.bgpFactory = new BGPImplModuleFactory();
@@ -92,41 +118,61 @@ public class RIBImplModuleTest extends AbstractConfigTest {
                                this.reconnectFactory, this.dataBrokerFactory, this.executorFactory, this.extensionFactory,
                                this.ribExtensionsFactory, this.domBrokerFactory, this.runtimeMappingFactory,
                                this.dataStroreFactory));
-               Mockito.doReturn(mockedServiceRegistration).when(mockedContext).registerService(
-                               Matchers.any(String.class), Mockito.any(Closeable.class),
-                               Mockito.any(Dictionary.class));
-               Mockito.doReturn(mockedServiceRegistration).when(mockedContext).registerService(
-                               Matchers.any(Class.class), Mockito.any(Closeable.class),
-                               Mockito.any(Dictionary.class));
-               Filter mockedFilter = Mockito.mock(Filter.class);
+
+               Filter mockedFilter = mock(Filter.class);
                Mockito.doReturn(mockedFilter).when(mockedContext).createFilter(Mockito.anyString());
 
-               Mockito.doNothing().when(mockedContext).addServiceListener(Mockito.any(ServiceListener.class), Mockito.anyString());
+               Mockito.doNothing().when(mockedContext).addServiceListener(any(ServiceListener.class), Mockito.anyString());
 
-               Mockito.doNothing().when(mockedContext).addBundleListener(Mockito.any(BundleListener.class));
+               Mockito.doNothing().when(mockedContext).addBundleListener(any(BundleListener.class));
 
                Mockito.doReturn(new Bundle[]{}).when(mockedContext).getBundles();
 
                Mockito.doReturn(new ServiceReference[]{}).when(mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
 
-               ServiceReference<?> mockedserviceReference = Mockito.mock(ServiceReference.class);
+               ServiceReference<?> mockedserviceReference = mock(ServiceReference.class);
                Mockito.doReturn(new String()).when(mockedserviceReference).toString();
-               Mockito.doReturn(mockedserviceReference).when(mockedContext).getServiceReference(Matchers.any(Class.class));
+               Mockito.doReturn(mockedserviceReference).when(mockedContext).getServiceReference(any(Class.class));
+
+               Registration<DataCommitHandler<InstanceIdentifier, CompositeNode>> registration = mock(Registration.class);
+               Mockito.doReturn(registration).when(mockedDataProvider).registerCommitHandler(any(InstanceIdentifier.class),
+                               any(DataCommitHandler.class));
+               Mockito.doReturn(mockedDataProvider).when(mockedContext).getService(any(ServiceReference.class));
 
-               DataProviderService mockedService = Mockito.mock(DataProviderService.class);
-               Registration<DataCommitHandler<InstanceIdentifier, CompositeNode>> registration = Mockito.mock(Registration.class);
-               Mockito.doReturn(registration).when(mockedService).registerCommitHandler(Matchers.any(InstanceIdentifier.class),
-                               Matchers.any(DataCommitHandler.class));
-               Mockito.doReturn(mockedService).when(mockedContext).getService(Matchers.any(ServiceReference.class));
+               Mockito.doReturn(null).when(mockedDataProvider).readOperationalData(any(InstanceIdentifier.class));
+               Mockito.doReturn(mockedTransaction).when(mockedDataProvider).beginTransaction();
+
+               Mockito.doNothing().when(mockedTransaction).putOperationalData(any(InstanceIdentifier.class), any(CompositeNode.class));
+               Mockito.doReturn(mockedFuture).when(mockedTransaction).commit();
+               Mockito.doReturn(TRANSACTION_NAME).when(mockedTransaction).getIdentifier();
+
+               Mockito.doReturn(mockedResult).when(mockedFuture).get();
+               Mockito.doReturn(true).when(mockedResult).isSuccessful();
+               Mockito.doReturn(Collections.emptySet()).when(mockedResult).getErrors();
+
+               // FIXME This needs further mocking
+       }
+
+       @Override
+       protected BundleContextServiceRegistrationHandler getBundleContextServiceRegistrationHandler(final Class<?> serviceType) {
+               if (serviceType.equals(SchemaServiceListener.class)) {
+                       return new BundleContextServiceRegistrationHandler() {
+                               @Override
+                               public void handleServiceRegistration(final Object o) {
+                                       SchemaServiceListener listener = (SchemaServiceListener) o;
+                                       listener.onGlobalContextUpdated(getMockedSchemaContext());
+                               }
+                       };
+               }
+
+               return super.getBundleContextServiceRegistrationHandler(serviceType);
        }
 
-       // FIXME: make data broker operational, otherwise the test freezes
-       @Ignore
        @Test
        public void testCreateBean() throws Exception {
                ConfigTransactionJMXClient transaction = configRegistryClient
                                .createTransaction();
-               createInstance(transaction, this.factory.getImplementationName(), instanceName, this.dataBrokerFactory.getImplementationName(),
+               createInstance(transaction, this.factory.getImplementationName(), INSTANCE_NAME, this.dataBrokerFactory.getImplementationName(),
                                this.reconnectFactory.getImplementationName(), this.executorFactory.getImplementationName(), this.bgpFactory.getImplementationName(),
                                this.sessionFacotry.getImplementationName(), this.dispactherFactory.getImplementationName(), this.threadgropFactory.getImplementationName(),
                                this.extensionFactory.getImplementationName(), this.ribExtensionsFactory.getImplementationName(), this.domBrokerFactory.getImplementationName(),
@@ -150,7 +196,7 @@ public class RIBImplModuleTest extends AbstractConfigTest {
                                        throws Exception {
                ObjectName nameCreated = transaction.createModule(
                                moduleName, instanceName);
-               RIBImplModuleMXBean mxBean = transaction.newMBeanProxy(
+               RIBImplModuleMXBean mxBean = transaction.newMXBeanProxy(
                                nameCreated, RIBImplModuleMXBean.class);
                ObjectName reconnectObjectName = TimedReconnectStrategyModuleTest.createInstance(transaction, reconnectModueName, "session-reconnect-strategy", 100, 1000L, new BigDecimal(1.0), 5000L, 2000L, null, executorModuleName,
                                "global-event-executor1");
@@ -162,6 +208,8 @@ public class RIBImplModuleTest extends AbstractConfigTest {
                mxBean.setBgp(Lists.newArrayList(BGPImplModuleTest.createInstance(transaction, bgpModuleName, "bgp-impl1", "localhost", 1, sessionModuleName, dispatcherModuleName, threadgroupModuleName, ribExtensionsModuleName, extensionModuleName)));
                mxBean.setExtensions(createRibExtensionsInstance(transaction, ribExtensionsModuleName, "rib-extensions-privider1"));
                mxBean.setRibId(new RibId("test"));
+               mxBean.setLocalAs(5000L);
+               mxBean.setBgpId("192.168.1.1");
                return nameCreated;
        }
 
@@ -210,4 +258,10 @@ public class RIBImplModuleTest extends AbstractConfigTest {
                                nameCreated, RIBExtensionsImplModuleMXBean.class);
                return nameCreated;
        }
+
+       public SchemaContext getMockedSchemaContext() {
+               List<String> paths = Arrays.asList("/META-INF/yang/bgp-rib.yang", "/META-INF/yang/ietf-inet-types.yang",
+                               "/META-INF/yang/bgp-message.yang", "/META-INF/yang/bgp-multiprotocol.yang", "/META-INF/yang/bgp-types.yang");
+               return YangParserWrapper.parseYangFiles(getFilesAsInputStreams(paths));
+       }
 }