package org.opendaylight.controller.config.yang.bmp.impl;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
-import com.google.common.base.Optional;
+
import com.google.common.collect.Lists;
-import com.google.common.io.ByteSource;
-import com.google.common.io.Resources;
import com.google.common.util.concurrent.CheckedFuture;
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.net.URL;
+import io.netty.channel.nio.NioEventLoopGroup;
+import java.io.InputStream;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.Collections;
import java.util.List;
import javax.management.InstanceAlreadyExistsException;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.Matchers;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
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;
import org.opendaylight.controller.config.util.ConfigTransactionJMXClient;
import org.opendaylight.controller.config.yang.bgp.rib.spi.RIBExtensionsImplModuleFactory;
import org.opendaylight.controller.config.yang.bgp.rib.spi.RIBExtensionsImplModuleMXBean;
-import org.opendaylight.controller.config.yang.bmp.spi.SimpleBmpExtensionProviderContextModuleFactory;
import org.opendaylight.controller.config.yang.md.sal.binding.impl.RuntimeMappingModuleFactory;
import org.opendaylight.controller.config.yang.md.sal.binding.impl.RuntimeMappingModuleMXBean;
import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModuleFactory;
import org.opendaylight.controller.config.yang.md.sal.dom.impl.DomInmemoryDataBrokerModuleMXBean;
import org.opendaylight.controller.config.yang.md.sal.dom.impl.SchemaServiceImplSingletonModuleFactory;
import org.opendaylight.controller.config.yang.md.sal.dom.impl.SchemaServiceImplSingletonModuleMXBean;
-import org.opendaylight.controller.config.yang.netty.eventexecutor.GlobalEventExecutorModuleFactory;
-import org.opendaylight.controller.config.yang.netty.threadgroup.NettyThreadgroupModuleFactory;
-import org.opendaylight.controller.config.yang.protocol.framework.TimedReconnectStrategyFactoryModuleFactory;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
+import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodecFactory;
import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.controller.sal.core.api.model.SchemaService;
-import org.opendaylight.controller.sal.dom.broker.GlobalBundleScanningSchemaServiceImpl;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
-import org.opendaylight.yangtools.sal.binding.generator.impl.GeneratedClassLoadingStrategy;
+import org.opendaylight.controller.sal.core.api.model.YangTextSourceProvider;
+import org.opendaylight.mdsal.binding.generator.api.ClassLoadingStrategy;
+import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
+import org.opendaylight.protocol.bmp.api.BmpDispatcher;
+import org.opendaylight.protocol.bmp.impl.BmpDispatcherImpl;
+import org.opendaylight.protocol.bmp.impl.session.DefaultBmpSessionFactory;
+import org.opendaylight.protocol.bmp.spi.registry.SimpleBmpMessageRegistry;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.opendaylight.yangtools.yang.model.parser.api.YangContextParser;
-import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl;
-import org.opendaylight.yangtools.yang.parser.repo.URLSchemaContextResolver;
+import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
+import org.opendaylight.yangtools.yang.parser.spi.meta.ReactorException;
+import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleListener;
-import org.osgi.framework.Filter;
-import org.osgi.framework.ServiceListener;
import org.osgi.framework.ServiceReference;
-public class BmpMonitorImplModuleTest extends AbstractConfigTest {
+public class BmpMonitorImplModuleTest extends AbstractBmpModuleTest {
private static final String FACTORY_NAME = BmpMonitorImplModuleFactory.NAME;
private static final String INSTANCE_NAME = "bmp-monitor-impl-instance";
@Mock private CheckedFuture<Void, TransactionCommitFailedException> mockedFuture;
@Mock private RpcResult<TransactionStatus> mockedResult;
+ @Override
@SuppressWarnings("unchecked")
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
+ super.setUp();
super.initConfigTransactionManagerImpl(new HardcodedModuleFactoriesResolver(this.mockedContext,
new BmpMonitorImplModuleFactory(),
new RIBExtensionsImplModuleFactory(),
new RuntimeMappingModuleFactory(),
new DomInmemoryDataBrokerModuleFactory(),
new BmpDispatcherImplModuleFactory(),
- new NettyThreadgroupModuleFactory(),
- new SimpleBmpExtensionProviderContextModuleFactory(),
- new TimedReconnectStrategyFactoryModuleFactory(),
- new GlobalEventExecutorModuleFactory(),
new SchemaServiceImplSingletonModuleFactory()));
- final Filter mockedFilter = mock(Filter.class);
- Mockito.doReturn(mockedFilter).when(this.mockedContext).createFilter(Mockito.anyString());
-
final ServiceReference<?> emptyServiceReference = mock(ServiceReference.class, "Empty");
final ServiceReference<?> classLoadingStrategySR = mock(ServiceReference.class, "ClassLoadingStrategy");
final ServiceReference<?> dataProviderServiceReference = mock(ServiceReference.class, "Data Provider");
final ServiceReference<?> schemaServiceReference = mock(ServiceReference.class, "schemaServiceReference");
- Mockito.doReturn(mockedFilter).when(this.mockedContext).createFilter(Mockito.anyString());
-
- Mockito.doNothing().when(this.mockedContext).addServiceListener(any(ServiceListener.class), Mockito.anyString());
- Mockito.doNothing().when(this.mockedContext).removeServiceListener(any(ServiceListener.class));
-
Mockito.doNothing().when(this.mockedContext).addBundleListener(any(BundleListener.class));
Mockito.doNothing().when(this.mockedContext).removeBundleListener(any(BundleListener.class));
Mockito.doReturn(new Bundle[] {}).when(this.mockedContext).getBundles();
- Mockito.doReturn(new ServiceReference[] {}).when(this.mockedContext).getServiceReferences(Matchers.anyString(), Matchers.anyString());
-
Mockito.doReturn("Empty reference").when(emptyServiceReference).toString();
Mockito.doReturn("Data Provider Service Reference").when(dataProviderServiceReference).toString();
Mockito.doReturn("Class loading stategy reference").when(classLoadingStrategySR).toString();
Mockito.doReturn(dataProviderServiceReference).when(this.mockedContext).getServiceReference(DataBroker.class);
Mockito.doReturn(classLoadingStrategySR).when(this.mockedContext).getServiceReference(GeneratedClassLoadingStrategy.class);
Mockito.doReturn(schemaServiceReference).when(this.mockedContext).getServiceReference(SchemaService.class);
+ Mockito.doReturn(classLoadingStrategySR).when(this.mockedContext).getServiceReference(ClassLoadingStrategy.class);
Mockito.doReturn(this.mockedDataProvider).when(this.mockedContext).getService(dataProviderServiceReference);
Mockito.doReturn(GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy()).when(this.mockedContext).getService(classLoadingStrategySR);
Mockito.doReturn(null).when(this.mockedContext).getService(emptyServiceReference);
- final GlobalBundleScanningSchemaServiceImpl schemaService = GlobalBundleScanningSchemaServiceImpl.createInstance(this.mockedContext);
- Mockito.doReturn(schemaService).when(this.mockedContext).getService(schemaServiceReference);
Mockito.doReturn(this.mockedTransaction).when(this.mockedDataProvider).newReadWriteTransaction();
Mockito.doReturn(null).when(this.mockedFuture).get();
- final YangContextParser parser = new YangParserImpl();
- final SchemaContext context = parser.parseSources(getFilesAsByteSources(getYangModelsPaths()));
- final URLSchemaContextResolver mockedContextResolver = Mockito.mock(URLSchemaContextResolver.class);
- Mockito.doReturn(Optional.of(context)).when(mockedContextResolver).getSchemaContext();
-
- final Field contextResolverField = schemaService.getClass().getDeclaredField("contextResolver");
- contextResolverField.setAccessible(true);
-
- final Field modifiersField = Field.class.getDeclaredField("modifiers");
- modifiersField.setAccessible(true);
- modifiersField.setInt(contextResolverField, contextResolverField.getModifiers() & ~Modifier.FINAL);
+ final SchemaContext context = parseYangStreams(getFilesAsStreams(getYangModelsPaths()));
+ final SchemaService mockedSchemaService = mock(SchemaService.class);
+ doReturn(context).when(mockedSchemaService).getGlobalContext();
+ doAnswer(invocation -> {
+ invocation.getArgumentAt(0, SchemaContextListener.class).onGlobalContextUpdated(context);
+ final ListenerRegistration<SchemaContextListener> reg = mock(ListenerRegistration.class);
+ doNothing().when(reg).close();
+ return reg;
+ }).when(mockedSchemaService).registerSchemaContextListener(any(SchemaContextListener.class));
+
+ setupMockService(SchemaService.class, mockedSchemaService);
+ setupMockService(YangTextSourceProvider.class, mock(YangTextSourceProvider.class));
+ Mockito.doReturn(mockedSchemaService).when(this.mockedContext).getService(schemaServiceReference);
+
+ final BindingToNormalizedNodeCodec bindingCodec = BindingToNormalizedNodeCodecFactory.newInstance(
+ GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy());
+ BindingToNormalizedNodeCodecFactory.registerInstance(bindingCodec, mockedSchemaService);
+ setupMockService(BindingToNormalizedNodeCodec.class, bindingCodec);
+
+ final BmpDispatcher bmpDispatcher = new BmpDispatcherImpl(new NioEventLoopGroup(), new NioEventLoopGroup(),
+ new SimpleBmpMessageRegistry(), new DefaultBmpSessionFactory());
+ setupMockService(BmpDispatcher.class, bmpDispatcher);
+ }
- contextResolverField.set(schemaService, mockedContextResolver);
+ private static SchemaContext parseYangStreams(final List<InputStream> streams) {
+ try {
+ return YangParserTestUtils.parseYangStreams(streams);
+ } catch (final ReactorException e) {
+ throw new RuntimeException("Unable to build schema context from " + streams, e);
+ }
}
private List<String> getYangModelsPaths() {
- final List<String> paths = Lists.newArrayList("/META-INF/yang/bgp-rib.yang", "/META-INF/yang/ietf-inet-types.yang",
+ final List<String> paths = Lists.newArrayList("/META-INF/yang/bgp-rib.yang", "/META-INF/yang/ietf-inet-types@2013-07-15.yang",
"/META-INF/yang/bgp-message.yang", "/META-INF/yang/bgp-multiprotocol.yang", "/META-INF/yang/bgp-types.yang",
"/META-INF/yang/network-concepts.yang", "/META-INF/yang/ieee754.yang", "/META-INF/yang/yang-ext.yang",
- "/META-INF/yang/bmp-monitor.yang", "/META-INF/yang/bmp-message.yang", "/META-INF/yang/ietf-yang-types.yang");
+ "/META-INF/yang/bmp-monitor.yang", "/META-INF/yang/bmp-message.yang", "/META-INF/yang/ietf-yang-types@2013-07-15.yang");
return paths;
}
- private Collection<ByteSource> getFilesAsByteSources(final List<String> paths) {
- final Collection<ByteSource> resources = new ArrayList<>();
+ private List<InputStream> getFilesAsStreams(final List<String> paths) {
+ final List<InputStream> resources = new ArrayList<>();
final List<String> failedToFind = new ArrayList<>();
for (final String path : paths) {
- final URL url = BmpMonitorImplModuleTest.class.getResource(path);
- if (url == null) {
+ final InputStream is = BmpMonitorImplModuleTest.class.getResourceAsStream(path);
+ if (is == null) {
failedToFind.add(path);
} else {
- resources.add(Resources.asByteSource(url));
+ resources.add(is);
}
}
- Assert.assertEquals("Some files were not found", Collections.<String> emptyList(), failedToFind);
+ Assert.assertEquals("Some files were not found", Collections.emptyList(), failedToFind);
return resources;
}
@After
public void closeAllModules() throws Exception {
super.destroyAllConfigBeans();
- GlobalBundleScanningSchemaServiceImpl.destroyInstance();
}
@Test
public void testCreateBean() throws Exception {
final CommitStatus status = createInstance();
assertBeanCount(1, FACTORY_NAME);
- assertStatus(status, 11, 0, 0);
+ assertStatus(status, 6, 0, 0);
}
@Test
assertBeanCount(1, FACTORY_NAME);
final CommitStatus status = transaction.commit();
assertBeanCount(1, FACTORY_NAME);
- assertStatus(status, 0, 0, 11);
+ assertStatus(status, 0, 0, 6);
}
private CommitStatus createInstance() throws Exception {
}
private static ObjectName createDispatcher(final ConfigTransactionJMXClient transaction) throws InstanceAlreadyExistsException {
- return BmpDispatcherImplModuleTest.createInstance(transaction);
+ final ObjectName nameCreated = transaction.createModule(BmpDispatcherImplModuleFactory.NAME, "bmp-message-fct");
+ transaction.newMXBeanProxy(nameCreated, BmpDispatcherImplModuleMXBean.class);
+ return nameCreated;
}
}
Code Review / bgpcep.git / blobdiff