X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2FBasicIntegrationTest.java;h=11ad559744a3923aebfbb07472771b98a4439ab0;hp=8c3ec82a54eb7c50d195675cffc122b6ed13d546;hb=5ffd4b46ca00fc8f3d801050670c890117dc0811;hpb=81aa5072801e6453306e296b91dba3dbeeaf046d diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/BasicIntegrationTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/BasicIntegrationTest.java index 8c3ec82a54..11ad559744 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/BasicIntegrationTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/BasicIntegrationTest.java @@ -16,7 +16,6 @@ import akka.testkit.JavaTestKit; import junit.framework.Assert; import org.junit.Test; import org.opendaylight.controller.cluster.datastore.messages.CommitTransaction; -import org.opendaylight.controller.cluster.datastore.messages.CommitTransactionReply; import org.opendaylight.controller.cluster.datastore.messages.CreateTransaction; import org.opendaylight.controller.cluster.datastore.messages.CreateTransactionChain; import org.opendaylight.controller.cluster.datastore.messages.CreateTransactionChainReply; @@ -30,11 +29,17 @@ import org.opendaylight.controller.cluster.datastore.messages.WriteData; import org.opendaylight.controller.cluster.datastore.messages.WriteDataReply; import org.opendaylight.controller.md.cluster.datastore.model.TestModel; import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; +import scala.concurrent.Await; +import scala.concurrent.Future; +import scala.concurrent.duration.FiniteDuration; + +import java.util.Collections; public class BasicIntegrationTest extends AbstractActorTest { @Test - public void integrationTest() { + public void integrationTest() throws Exception{ + // System.setProperty("shard.persistent", "true"); // This test will // - create a Shard // - initiate a transaction @@ -44,24 +49,33 @@ public class BasicIntegrationTest extends AbstractActorTest { new JavaTestKit(getSystem()) {{ - final Props props = Shard.props("config"); + final Props props = Shard.props("config", Collections.EMPTY_MAP); final ActorRef shard = getSystem().actorOf(props); new Within(duration("5 seconds")) { protected void run() { + shard.tell( new UpdateSchemaContext(TestModel.createTestContext()), getRef()); - shard.tell(new CreateTransactionChain(), getRef()); + + // Wait for Shard to become a Leader + try { + Thread.sleep(1000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + // 1. Create a TransactionChain + shard.tell(new CreateTransactionChain().toSerializable(), getRef()); final ActorSelection transactionChain = - new ExpectMsg("match hint") { + new ExpectMsg("CreateTransactionChainReply") { protected ActorSelection match(Object in) { - if (in instanceof CreateTransactionChainReply) { + if (in.getClass().equals(CreateTransactionChainReply.SERIALIZABLE_CLASS)) { ActorPath transactionChainPath = - ((CreateTransactionChainReply) in) + CreateTransactionChainReply.fromSerializable(getSystem(),in) .getTransactionChainPath(); return getSystem() .actorSelection(transactionChainPath); @@ -73,17 +87,19 @@ public class BasicIntegrationTest extends AbstractActorTest { Assert.assertNotNull(transactionChain); - transactionChain.tell(new CreateTransaction(), getRef()); + System.out.println("Successfully created transaction chain"); + + // 2. Create a Transaction on the TransactionChain + transactionChain.tell(new CreateTransaction("txn-1").toSerializable(), getRef()); final ActorSelection transaction = - new ExpectMsg("match hint") { + new ExpectMsg("CreateTransactionReply") { protected ActorSelection match(Object in) { - if (in instanceof CreateTransactionReply) { - ActorPath transactionPath = - ((CreateTransactionReply) in) - .getTransactionPath(); + if (CreateTransactionReply.SERIALIZABLE_CLASS.equals(in.getClass())) { + CreateTransactionReply reply = CreateTransactionReply.fromSerializable(in); return getSystem() - .actorSelection(transactionPath); + .actorSelection(reply + .getTransactionPath()); } else { throw noMatch(); } @@ -92,13 +108,16 @@ public class BasicIntegrationTest extends AbstractActorTest { Assert.assertNotNull(transaction); + System.out.println("Successfully created transaction"); + + // 3. Write some data transaction.tell(new WriteData(TestModel.TEST_PATH, - ImmutableNodes.containerNode(TestModel.TEST_QNAME)), + ImmutableNodes.containerNode(TestModel.TEST_QNAME), TestModel.createTestContext()).toSerializable(), getRef()); - Boolean writeDone = new ExpectMsg("match hint") { + Boolean writeDone = new ExpectMsg("WriteDataReply") { protected Boolean match(Object in) { - if (in instanceof WriteDataReply) { + if (in.getClass().equals(WriteDataReply.SERIALIZABLE_CLASS)) { return true; } else { throw noMatch(); @@ -108,14 +127,18 @@ public class BasicIntegrationTest extends AbstractActorTest { Assert.assertTrue(writeDone); - transaction.tell(new ReadyTransaction(), getRef()); + System.out.println("Successfully wrote data"); + + // 4. Ready the transaction for commit + + transaction.tell(new ReadyTransaction().toSerializable(), getRef()); final ActorSelection cohort = - new ExpectMsg("match hint") { + new ExpectMsg("ReadyTransactionReply") { protected ActorSelection match(Object in) { - if (in instanceof ReadyTransactionReply) { + if (in.getClass().equals(ReadyTransactionReply.SERIALIZABLE_CLASS)) { ActorPath cohortPath = - ((ReadyTransactionReply) in) + ReadyTransactionReply.fromSerializable(getSystem(),in) .getCohortPath(); return getSystem() .actorSelection(cohortPath); @@ -127,12 +150,16 @@ public class BasicIntegrationTest extends AbstractActorTest { Assert.assertNotNull(cohort); - cohort.tell(new PreCommitTransaction(), getRef()); + System.out.println("Successfully readied the transaction"); + + // 5. PreCommit the transaction + + cohort.tell(new PreCommitTransaction().toSerializable(), getRef()); Boolean preCommitDone = - new ExpectMsg("match hint") { + new ExpectMsg("PreCommitTransactionReply") { protected Boolean match(Object in) { - if (in instanceof PreCommitTransactionReply) { + if (in.getClass().equals(PreCommitTransactionReply.SERIALIZABLE_CLASS)) { return true; } else { throw noMatch(); @@ -142,26 +169,37 @@ public class BasicIntegrationTest extends AbstractActorTest { Assert.assertTrue(preCommitDone); - cohort.tell(new CommitTransaction(), getRef()); + System.out.println("Successfully pre-committed the transaction"); - final Boolean commitDone = - new ExpectMsg("match hint") { - protected Boolean match(Object in) { - if (in instanceof CommitTransactionReply) { - return true; - } else { - throw noMatch(); - } - } - }.get(); // this extracts the received message + // 6. Commit the transaction + cohort.tell(new CommitTransaction().toSerializable(), getRef()); - Assert.assertTrue(commitDone); + // FIXME : Add assertions that the commit worked and that the cohort and transaction actors were terminated + System.out.println("TODO : Check Successfully committed the transaction"); } }; - }}; + } + + private ActorRef watchActor(ActorSelection actor) { + Future future = actor + .resolveOne(FiniteDuration.apply(100, "milliseconds")); + + try { + ActorRef actorRef = Await.result(future, + FiniteDuration.apply(100, "milliseconds")); + + watch(actorRef); + + return actorRef; + } catch (Exception e) { + throw new RuntimeException(e); + } + + } + }; }