From: Tony Tkacik Date: Thu, 10 Jul 2014 15:24:07 +0000 (+0200) Subject: Bug 1225: Added DataBroker and DataChangeListener test suite. X-Git-Tag: release/helium~492 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=797ebcb9bb6631538d8deee1ef6a0098e94788a2 Bug 1225: Added DataBroker and DataChangeListener test suite. Change-Id: I53a06845024936253f576e5095b3d00c15a47e99 Signed-off-by: Tony Tkacik --- diff --git a/opendaylight/commons/opendaylight/pom.xml b/opendaylight/commons/opendaylight/pom.xml index bf84183b75..28c23c8259 100644 --- a/opendaylight/commons/opendaylight/pom.xml +++ b/opendaylight/commons/opendaylight/pom.xml @@ -1244,6 +1244,11 @@ sal-restconf-broker ${mdsal.version} + + org.opendaylight.controller + sal-test-model + ${mdsal.version} + diff --git a/opendaylight/md-sal/sal-binding-broker/pom.xml b/opendaylight/md-sal/sal-binding-broker/pom.xml index 2f3410dedc..74cceb1cbd 100644 --- a/opendaylight/md-sal/sal-binding-broker/pom.xml +++ b/opendaylight/md-sal/sal-binding-broker/pom.xml @@ -111,7 +111,7 @@ org.opendaylight.controller sal-test-model - ${project.version} + test org.slf4j diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/BindingNormalizedCodecTest.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/BindingNormalizedCodecTest.java index 5ad474a9a3..6b05b1046f 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/BindingNormalizedCodecTest.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/BindingNormalizedCodecTest.java @@ -5,9 +5,9 @@ import javassist.ClassPool; import org.junit.Test; import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec; +import org.opendaylight.controller.md.sal.binding.test.AbstractSchemaAwareTest; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugment; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeLeafOnlyAugment; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeLeafOnlyUsesAugment; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.Top; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListKey; @@ -24,7 +24,6 @@ public class BindingNormalizedCodecTest extends AbstractSchemaAwareTest { private static final InstanceIdentifier BA_TOP_LEVEL_LIST = InstanceIdentifier .builder(Top.class).child(TopLevelList.class, TOP_FOO_KEY).toInstance(); private static final InstanceIdentifier BA_TREE_LEAF_ONLY = BA_TOP_LEVEL_LIST.augmentation(TreeLeafOnlyAugment.class); - private static final InstanceIdentifier BA_TREE_LEAF_ONLY_USES = BA_TOP_LEVEL_LIST.augmentation(TreeLeafOnlyUsesAugment.class); private static final InstanceIdentifier BA_TREE_COMPLEX_USES = BA_TOP_LEVEL_LIST.augmentation(TreeComplexUsesAugment.class); private static final QName SIMPLE_VALUE_QNAME = QName.create(TreeComplexUsesAugment.QNAME, "simple-value"); diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/ListInsertionDataChangeListenerTest.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/ListInsertionDataChangeListenerTest.java new file mode 100644 index 0000000000..05bc857969 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/ListInsertionDataChangeListenerTest.java @@ -0,0 +1,193 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. 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.controller.md.sal.binding.impl.test; +import static org.junit.Assert.assertFalse; +import static org.opendaylight.controller.md.sal.binding.test.AssertCollections.assertContains; +import static org.opendaylight.controller.md.sal.binding.test.AssertCollections.assertEmpty; +import static org.opendaylight.controller.md.sal.binding.test.AssertCollections.assertNotContains; +import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION; +import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.TOP_BAR_KEY; +import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.TOP_FOO_KEY; +import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.top; +import static org.opendaylight.controller.md.sal.test.model.util.ListsBindingUtils.topLevelList; + +import org.junit.Test; +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.api.WriteTransaction; +import org.opendaylight.controller.md.sal.binding.test.AbstractDataChangeListenerTest; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.Top; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +/** + * + * This testsuite tests explanation for data change scope and data modifications + * which were described in + * https://lists.opendaylight.org/pipermail/controller-dev/2014-July/005541.html + * + * + */ +public class ListInsertionDataChangeListenerTest extends AbstractDataChangeListenerTest{ + + private static final InstanceIdentifier TOP = InstanceIdentifier.create(Top.class); + private static final InstanceIdentifier WILDCARDED = TOP.child(TopLevelList.class); + private static final InstanceIdentifier TOP_FOO = TOP.child(TopLevelList.class, TOP_FOO_KEY); + private static final InstanceIdentifier TOP_BAR = TOP.child(TopLevelList.class, TOP_BAR_KEY); + + + @Override + protected void setupWithDataBroker(final DataBroker dataBroker) { + WriteTransaction initialTx = dataBroker.newWriteOnlyTransaction(); + initialTx.put(CONFIGURATION, TOP, top(topLevelList(TOP_FOO_KEY))); + assertCommit(initialTx.commit()); + } + + @Test + public void replaceTopNodeSubtreeListeners() { + TestListener topListener = createListener(CONFIGURATION, TOP, DataChangeScope.SUBTREE); + TestListener allListener = createListener(CONFIGURATION, WILDCARDED, DataChangeScope.SUBTREE); + TestListener fooListener = createListener(CONFIGURATION, TOP_FOO, DataChangeScope.SUBTREE); + TestListener barListener = createListener(CONFIGURATION, TOP_BAR, DataChangeScope.SUBTREE); + + ReadWriteTransaction writeTx = getDataBroker().newReadWriteTransaction(); + writeTx.put(CONFIGURATION, TOP, top(topLevelList(TOP_BAR_KEY))); + assertCommit(writeTx.commit()); + AsyncDataChangeEvent, DataObject> top = topListener.event(); + AsyncDataChangeEvent, DataObject> all = allListener.event(); + AsyncDataChangeEvent, DataObject> foo = fooListener.event(); + AsyncDataChangeEvent, DataObject> bar = barListener.event(); + + // Listener for TOP element + assertContains(top.getOriginalData(), TOP,TOP_FOO); + assertContains(top.getCreatedData(), TOP_BAR); + assertContains(top.getUpdatedData(), TOP); + assertContains(top.getRemovedPaths(), TOP_FOO); + + /* + * Listener for all list items + * + * Updated should be empty, since no list item was + * updated, items were only removed and added + */ + assertContains(all.getOriginalData(), TOP_FOO); + assertContains(all.getCreatedData(), TOP_BAR); + assertEmpty(all.getUpdatedData()); + assertContains(all.getRemovedPaths(), TOP_FOO); + + + /* + * Listener for all Foo item + * + * This one should see only Foo item removed + */ + assertContains(foo.getOriginalData(), TOP_FOO); + assertEmpty(foo.getCreatedData()); + assertEmpty(foo.getUpdatedData()); + assertContains(foo.getRemovedPaths(), TOP_FOO); + + /* + * Listener for bar list items + * + * Updated should be empty, since no list item was + * updated, items were only removed and added + */ + assertEmpty(bar.getOriginalData()); + assertContains(bar.getCreatedData(), TOP_BAR); + assertEmpty(bar.getUpdatedData()); + assertEmpty(bar.getRemovedPaths()); + } + + @Test + public void mergeTopNodeSubtreeListeners() { + TestListener topListener = createListener(CONFIGURATION, TOP, DataChangeScope.SUBTREE); + TestListener allListener = createListener(CONFIGURATION, WILDCARDED, DataChangeScope.SUBTREE); + TestListener fooListener = createListener(CONFIGURATION, TOP_FOO, DataChangeScope.SUBTREE); + TestListener barListener = createListener(CONFIGURATION, TOP_BAR, DataChangeScope.SUBTREE); + + ReadWriteTransaction writeTx = getDataBroker().newReadWriteTransaction(); + writeTx.merge(CONFIGURATION, TOP, top(topLevelList(TOP_BAR_KEY))); + assertCommit(writeTx.commit()); + + verifyBarOnlyAdded(topListener,allListener,fooListener,barListener); + } + + @Test + public void putTopBarNodeSubtreeListeners() { + TestListener topListener = createListener(CONFIGURATION, TOP, DataChangeScope.SUBTREE); + TestListener allListener = createListener(CONFIGURATION, WILDCARDED, DataChangeScope.SUBTREE); + TestListener fooListener = createListener(CONFIGURATION, TOP_FOO, DataChangeScope.SUBTREE); + TestListener barListener = createListener(CONFIGURATION, TOP_BAR, DataChangeScope.SUBTREE); + + ReadWriteTransaction writeTx = getDataBroker().newReadWriteTransaction(); + writeTx.put(CONFIGURATION, TOP_BAR, topLevelList(TOP_BAR_KEY)); + assertCommit(writeTx.commit()); + + verifyBarOnlyAdded(topListener,allListener,fooListener,barListener); + } + + @Test + public void mergeTopBarNodeSubtreeListeners() { + TestListener topListener = createListener(CONFIGURATION, TOP, DataChangeScope.SUBTREE); + TestListener allListener = createListener(CONFIGURATION, WILDCARDED, DataChangeScope.SUBTREE); + TestListener fooListener = createListener(CONFIGURATION, TOP_FOO, DataChangeScope.SUBTREE); + TestListener barListener = createListener(CONFIGURATION, TOP_BAR, DataChangeScope.SUBTREE); + + ReadWriteTransaction writeTx = getDataBroker().newReadWriteTransaction(); + writeTx.merge(CONFIGURATION, TOP_BAR, topLevelList(TOP_BAR_KEY)); + assertCommit(writeTx.commit()); + + verifyBarOnlyAdded(topListener,allListener,fooListener,barListener); + } + + private void verifyBarOnlyAdded(final TestListener top, final TestListener all, final TestListener foo, + final TestListener bar) { + + assertFalse(foo.hasEvent()); + + // Listener for TOP element + assertContains(top.event().getOriginalData(), TOP); + assertNotContains(top.event().getOriginalData(),TOP_FOO); + assertContains(top.event().getCreatedData(), TOP_BAR); + assertContains(top.event().getUpdatedData(), TOP); + assertEmpty(top.event().getRemovedPaths()); + + /* + * Listener for all list items + * + * Updated should be empty, since no list item was + * updated, items were only removed and added + */ + assertEmpty(all.event().getOriginalData()); + assertContains(all.event().getCreatedData(), TOP_BAR); + assertEmpty(all.event().getUpdatedData()); + assertEmpty(all.event().getRemovedPaths()); + + /* + * Listener for all Foo item + * + * Foo Listener should not have foo event + */ + assertFalse(foo.hasEvent()); + + /* + * Listener for bar list items + * + * Updated should be empty, since no list item was + * updated, items were only removed and added + */ + assertEmpty(bar.event().getOriginalData()); + assertContains(bar.event().getCreatedData(), TOP_BAR); + assertEmpty(bar.event().getUpdatedData()); + assertEmpty(bar.event().getRemovedPaths()); + } + +} diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/WriteTransactionTest.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/WriteTransactionTest.java index ad6e1a77ce..43e951423c 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/WriteTransactionTest.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/WriteTransactionTest.java @@ -12,42 +12,29 @@ import static org.junit.Assert.assertEquals; import java.util.concurrent.ExecutionException; import org.junit.Test; -import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest; import org.opendaylight.controller.md.sal.common.api.TransactionStatus; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.sal.binding.test.AbstractDataServiceTest; -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId; -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes; -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodesBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.Top; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.TopBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -public class WriteTransactionTest extends AbstractDataServiceTest { +public class WriteTransactionTest extends AbstractDataBrokerTest { - private DataBroker dataBroker; - - private static final InstanceIdentifier NODES_PATH = InstanceIdentifier.create(Nodes.class); - - private static final NodeKey NODE_KEY = new NodeKey(new NodeId("foo")); - - private static final InstanceIdentifier NODE_PATH = NODES_PATH.child(Node.class, NODE_KEY); - - @Override - public void setUp() { - super.setUp(); - - dataBroker = testContext.getDataBroker(); - } + private static final InstanceIdentifier TOP_PATH = InstanceIdentifier.create(Top.class); + private static final TopLevelListKey TOP_LIST_KEY = new TopLevelListKey("foo"); + private static final InstanceIdentifier NODE_PATH = TOP_PATH.child(TopLevelList.class, TOP_LIST_KEY); @Test public void test() throws InterruptedException, ExecutionException { - WriteTransaction writeTx = dataBroker.newWriteOnlyTransaction(); - writeTx.put(LogicalDatastoreType.OPERATIONAL, NODES_PATH, new NodesBuilder().build()); - writeTx.put(LogicalDatastoreType.OPERATIONAL, NODE_PATH, new NodeBuilder().setKey(NODE_KEY).build()); + WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction(); + writeTx.put(LogicalDatastoreType.OPERATIONAL, TOP_PATH, new TopBuilder().build()); + writeTx.put(LogicalDatastoreType.OPERATIONAL, NODE_PATH, new TopLevelListBuilder().setKey(TOP_LIST_KEY).build()); assertEquals(TransactionStatus.COMMITED, writeTx.commit().get().getResult()); } diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AbstractDataBrokerTest.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AbstractDataBrokerTest.java new file mode 100644 index 0000000000..7f23ac26b6 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AbstractDataBrokerTest.java @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. 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.controller.md.sal.binding.test; + +import static org.junit.Assert.assertEquals; + +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.common.api.TransactionStatus; +import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; +import org.opendaylight.yangtools.yang.common.RpcResult; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; + +import com.google.common.util.concurrent.ListenableFuture; + +public class AbstractDataBrokerTest extends AbstractSchemaAwareTest { + + private DataBrokerTestCustomizer testCustomizer; + private DataBroker dataBroker; + private DOMDataBroker domBroker; + + + @Override + protected void setupWithSchema(final SchemaContext context) { + testCustomizer = createDataBrokerTestCustomizer(); + dataBroker = testCustomizer.createDataBroker(); + domBroker = testCustomizer.createDOMDataBroker(); + testCustomizer.updateSchema(context); + setupWithDataBroker(dataBroker); + } + + protected void setupWithDataBroker(final DataBroker dataBroker) { + // Intentionally left No-op, subclasses may customize it + } + + protected DataBrokerTestCustomizer createDataBrokerTestCustomizer() { + return new DataBrokerTestCustomizer(); + } + + public DataBroker getDataBroker() { + return dataBroker; + } + + public DOMDataBroker getDomBroker() { + return domBroker; + } + + protected static final void assertCommit(final ListenableFuture> commit) { + try { + assertEquals(TransactionStatus.COMMITED,commit.get(500, TimeUnit.MILLISECONDS).getResult()); + } catch (InterruptedException | ExecutionException | TimeoutException e) { + throw new IllegalStateException(e); + } + } + + +} diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AbstractDataChangeListenerTest.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AbstractDataChangeListenerTest.java new file mode 100644 index 0000000000..7742f372cf --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AbstractDataChangeListenerTest.java @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. 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.controller.md.sal.binding.test; + +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; + +import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import com.google.common.util.concurrent.SettableFuture; + +public abstract class AbstractDataChangeListenerTest extends AbstractDataBrokerTest { + + protected static final class TestListener implements DataChangeListener { + + private final SettableFuture, DataObject>> event; + private boolean capture = false; + + private TestListener() { + event = SettableFuture.create(); + } + + @Override + public void onDataChanged(final AsyncDataChangeEvent, DataObject> arg) { + if (capture) { + event.set(arg); + } + } + + public AsyncDataChangeEvent, DataObject> event() { + try { + return event.get(500, TimeUnit.MILLISECONDS); + } catch (InterruptedException | TimeoutException | ExecutionException e) { + throw new IllegalStateException(e); + } + } + + public boolean hasEvent() { + return event.isDone(); + } + + public void startCapture() { + this.capture = true; + } + } + + protected final TestListener createListener(final LogicalDatastoreType store, final InstanceIdentifier path, + final DataChangeScope scope) { + TestListener listener = new TestListener(); + getDataBroker().registerDataChangeListener(store, path, listener, scope); + listener.startCapture(); + return listener; + } +} diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/AbstractSchemaAwareTest.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AbstractSchemaAwareTest.java similarity index 64% rename from opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/AbstractSchemaAwareTest.java rename to opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AbstractSchemaAwareTest.java index 61eb42648f..78febb50f7 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/impl/test/AbstractSchemaAwareTest.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AbstractSchemaAwareTest.java @@ -1,4 +1,11 @@ -package org.opendaylight.controller.md.sal.binding.impl.test; +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. 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.controller.md.sal.binding.test; import org.junit.Before; import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext; @@ -26,7 +33,12 @@ public abstract class AbstractSchemaAwareTest { setupWithSchema(schemaContext); } - + /** + * Setups test with Schema context. + * This method is called before {@link #setupWithSchemaService(SchemaService)} + * + * @param context + */ protected abstract void setupWithSchema(SchemaContext context); } diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AssertCollections.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AssertCollections.java new file mode 100644 index 0000000000..25b91bc3e4 --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/AssertCollections.java @@ -0,0 +1,42 @@ +package org.opendaylight.controller.md.sal.binding.test; + +import java.util.Collection; +import java.util.Map; + +import org.junit.Assert; + +public class AssertCollections { + + public static void assertEmpty(final Collection set) { + Assert.assertTrue(set.isEmpty()); + } + + public static void assertEmpty(final Map set) { + Assert.assertTrue(set.isEmpty()); + } + + public static void assertContains(final Collection set, final Object... values) { + for (Object key : values) { + Assert.assertTrue(set.contains(key)); + } + + } + + public static void assertNotContains(final Collection set, final Object... values) { + for (Object key : values) { + Assert.assertFalse(set.contains(key)); + } + } + + public static void assertContains(final Map map, final Object... values) { + for (Object key : values) { + Assert.assertTrue(map.containsKey(key)); + } + } + + public static void assertNotContains(final Map map, final Object... values) { + for (Object key : values) { + Assert.assertFalse(map.containsKey(key)); + } + } +} diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/DataBrokerTestCustomizer.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/DataBrokerTestCustomizer.java new file mode 100644 index 0000000000..79aa6b634b --- /dev/null +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/md/sal/binding/test/DataBrokerTestCustomizer.java @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. 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.controller.md.sal.binding.test; + +import javassist.ClassPool; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.impl.ForwardedBindingDataBroker; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; +import org.opendaylight.controller.md.sal.dom.broker.impl.DOMDataBrokerImpl; +import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore; +import org.opendaylight.controller.sal.binding.test.util.MockSchemaService; +import org.opendaylight.controller.sal.core.api.model.SchemaService; +import org.opendaylight.controller.sal.core.spi.data.DOMStore; +import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl; +import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; + +import com.google.common.collect.ImmutableMap; +import com.google.common.util.concurrent.ListeningExecutorService; +import com.google.common.util.concurrent.MoreExecutors; + +public class DataBrokerTestCustomizer { + + private DOMDataBroker domDataBroker; + private final RuntimeGeneratedMappingServiceImpl mappingService; + private final MockSchemaService schemaService; + private ImmutableMap datastores; + + public ImmutableMap createDatastores() { + return ImmutableMap.builder() + .put(LogicalDatastoreType.OPERATIONAL, createOperationalDatastore()) + .put(LogicalDatastoreType.CONFIGURATION,createConfigurationDatastore()) + .build(); + } + + public DataBrokerTestCustomizer() { + schemaService = new MockSchemaService(); + mappingService = new RuntimeGeneratedMappingServiceImpl(ClassPool.getDefault()); + } + + public DOMStore createConfigurationDatastore() { + InMemoryDOMDataStore store = new InMemoryDOMDataStore("CFG", MoreExecutors.sameThreadExecutor()); + schemaService.registerSchemaServiceListener(store); + return store; + } + + public DOMStore createOperationalDatastore() { + InMemoryDOMDataStore store = new InMemoryDOMDataStore("OPER", MoreExecutors.sameThreadExecutor()); + schemaService.registerSchemaServiceListener(store); + return store; + } + + public DOMDataBroker createDOMDataBroker() { + return new DOMDataBrokerImpl(getDatastores(), getCommitCoordinatorExecutor()); + } + + public ListeningExecutorService getCommitCoordinatorExecutor() { + return MoreExecutors.sameThreadExecutor(); + } + + public DataBroker createDataBroker() { + return new ForwardedBindingDataBroker(getDOMDataBroker(), getMappingService(), getSchemaService()); + } + + private SchemaService getSchemaService() { + return schemaService; + } + + private BindingIndependentMappingService getMappingService() { + return mappingService; + } + + private DOMDataBroker getDOMDataBroker() { + if(domDataBroker == null) { + domDataBroker = createDOMDataBroker(); + } + return domDataBroker; + } + + private ImmutableMap getDatastores() { + if(datastores == null) { + datastores = createDatastores(); + } + return datastores; + } + + public void updateSchema(final SchemaContext ctx) { + schemaService.changeSchema(ctx); + mappingService.onGlobalContextUpdated(ctx); + } + +} diff --git a/opendaylight/md-sal/sal-test-model/src/main/java/org/opendaylight/controller/md/sal/test/model/util/ListsBindingUtils.java b/opendaylight/md-sal/sal-test-model/src/main/java/org/opendaylight/controller/md/sal/test/model/util/ListsBindingUtils.java new file mode 100644 index 0000000000..a0c23aecb4 --- /dev/null +++ b/opendaylight/md-sal/sal-test-model/src/main/java/org/opendaylight/controller/md/sal/test/model/util/ListsBindingUtils.java @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. 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.controller.md.sal.test.model.util; + +import java.util.Arrays; + +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugment; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.TreeComplexUsesAugmentBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.complex.from.grouping.ListViaUses; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.complex.from.grouping.ListViaUsesBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.augment.rev140709.complex.from.grouping.ListViaUsesKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.Top; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.TopBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelList; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.TopLevelListKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.top.level.list.NestedList; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.controller.md.sal.test.list.rev140701.two.level.list.top.level.list.NestedListKey; +import org.opendaylight.yangtools.yang.binding.Augmentation; +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import com.google.common.collect.ImmutableList; + +public class ListsBindingUtils { + + private static final InstanceIdentifier TOP_PATH = InstanceIdentifier.create(Top.class); + + private ListsBindingUtils() { + throw new UnsupportedOperationException(); + } + + public static final TopLevelListKey TOP_FOO_KEY = new TopLevelListKey("foo"); + public static final TopLevelListKey TOP_BAR_KEY = new TopLevelListKey("bar"); + public static final ListViaUsesKey USES_ONE_KEY = new ListViaUsesKey("one"); + public static final ListViaUsesKey USES_TWO_KEY = new ListViaUsesKey("two"); + + + public static InstanceIdentifier path(final TopLevelListKey key) { + return TOP_PATH.child(TopLevelList.class, key); + } + + public static InstanceIdentifier path(final TopLevelListKey top,final NestedListKey nested) { + return path(top).child(NestedList.class, nested); + } + + public static InstanceIdentifier path(final TopLevelListKey top,final ListViaUsesKey uses) { + return path(top).augmentation(TreeComplexUsesAugment.class).child(ListViaUses.class, uses); + } + + public static > InstanceIdentifier path(final TopLevelListKey key, final Class augmentation) { + return path(key).augmentation(augmentation); + } + + public static Top top(final TopLevelList... listItems) { + return new TopBuilder().setTopLevelList(Arrays.asList(listItems)).build(); + } + + public static TopLevelList topLevelList(final TopLevelListKey key) { + return new TopLevelListBuilder().setKey(key).build(); + } + + public static TopLevelList topLevelList(final TopLevelListKey key, final TreeComplexUsesAugment augment) { + TopLevelListBuilder builder = new TopLevelListBuilder().setKey(key); + builder.addAugmentation(TreeComplexUsesAugment.class, augment); + return builder.build(); + } + + public static TreeComplexUsesAugment complexUsesAugment(final ListViaUsesKey... keys) { + ImmutableList.Builder listViaUses = ImmutableList. builder(); + for (ListViaUsesKey key : keys) { + listViaUses.add(new ListViaUsesBuilder().setKey(key).build()); + } + return new TreeComplexUsesAugmentBuilder().setListViaUses(listViaUses.build()).build(); + } + +}