opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/compat/PreLithiumTransactionProxyTest.java

   1 /*
   2  * Copyright (c) 2015 Brocade Communications Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.controller.cluster.datastore.compat;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertTrue;
  12 import static org.mockito.Matchers.argThat;
  13 import static org.mockito.Matchers.eq;
  14 import static org.mockito.Matchers.isA;
  15 import static org.mockito.Mockito.doReturn;
  16 import static org.mockito.Mockito.verify;
  17 import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.READ_WRITE;
  18 import static org.opendaylight.controller.cluster.datastore.TransactionProxy.TransactionType.WRITE_ONLY;
  19 import akka.actor.ActorRef;
  20 import akka.dispatch.Futures;
  21 import com.google.common.base.Optional;
  22 import java.util.concurrent.TimeUnit;
  23 import org.junit.Ignore;
  24 import org.junit.Test;
  25 import org.mockito.ArgumentMatcher;
  26 import org.mockito.Mockito;
  27 import org.opendaylight.controller.cluster.datastore.AbstractTransactionProxyTest;
  28 import org.opendaylight.controller.cluster.datastore.DataStoreVersions;
  29 import org.opendaylight.controller.cluster.datastore.ThreePhaseCommitCohortProxy;
  30 import org.opendaylight.controller.cluster.datastore.TransactionProxy;
  31 import org.opendaylight.controller.cluster.datastore.messages.DeleteData;
  32 import org.opendaylight.controller.cluster.datastore.messages.DeleteDataReply;
  33 import org.opendaylight.controller.cluster.datastore.messages.MergeData;
  34 import org.opendaylight.controller.cluster.datastore.messages.MergeDataReply;
  35 import org.opendaylight.controller.cluster.datastore.messages.ReadyTransaction;
  36 import org.opendaylight.controller.cluster.datastore.messages.WriteData;
  37 import org.opendaylight.controller.cluster.datastore.messages.WriteDataReply;
  38 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
  39 import org.opendaylight.controller.protobuff.messages.transaction.ShardTransactionMessages;
  40 import org.opendaylight.controller.sal.core.spi.data.DOMStoreThreePhaseCommitCohort;
  41 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  42 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  43 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  44
  45 /**
  46  * Unit tests for backwards compatibility with pre-Lithium versions.
  47  *
  48  * @author Thomas Pantelis
  49  */
  50 public class PreLithiumTransactionProxyTest extends AbstractTransactionProxyTest {
  51
  52     private WriteData eqLegacyWriteData(final NormalizedNode<?, ?> nodeToWrite) {
  53         ArgumentMatcher<WriteData> matcher = new ArgumentMatcher<WriteData>() {
  54             @Override
  55             public boolean matches(Object argument) {
  56                 if(ShardTransactionMessages.WriteData.class.equals(argument.getClass())) {
  57                     WriteData obj = WriteData.fromSerializable(argument);
  58                     return obj.getPath().equals(TestModel.TEST_PATH) && obj.getData().equals(nodeToWrite);
  59                 }
  60
  61                 return false;
  62             }
  63         };
  64
  65         return argThat(matcher);
  66     }
  67
  68     private MergeData eqLegacyMergeData(final NormalizedNode<?, ?> nodeToWrite) {
  69         ArgumentMatcher<MergeData> matcher = new ArgumentMatcher<MergeData>() {
  70             @Override
  71             public boolean matches(Object argument) {
  72                 if(ShardTransactionMessages.MergeData.class.equals(argument.getClass())) {
  73                     MergeData obj = MergeData.fromSerializable(argument);
  74                     return obj.getPath().equals(TestModel.TEST_PATH) && obj.getData().equals(nodeToWrite);
  75                 }
  76
  77                 return false;
  78             }
  79         };
  80
  81         return argThat(matcher);
  82     }
  83
  84     private DeleteData eqLegacyDeleteData(final YangInstanceIdentifier expPath) {
  85         ArgumentMatcher<DeleteData> matcher = new ArgumentMatcher<DeleteData>() {
  86             @Override
  87             public boolean matches(Object argument) {
  88                 return ShardTransactionMessages.DeleteData.class.equals(argument.getClass()) &&
  89                        DeleteData.fromSerializable(argument).getPath().equals(expPath);
  90             }
  91         };
  92
  93         return argThat(matcher);
  94     }
  95
  96     private ActorRef testCompatibilityWithHeliumVersion(short version) throws Exception {
  97         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), READ_WRITE, version);
  98
  99         NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 100
 101         doReturn(readSerializedDataReply(testNode, version)).when(mockActorContext).executeOperationAsync(
 102                 eq(actorSelection(actorRef)), eqSerializedReadData(TestModel.TEST_PATH));
 103
 104         doReturn(Futures.successful(new WriteDataReply().toSerializable(version))).when(mockActorContext).
 105                 executeOperationAsync(eq(actorSelection(actorRef)), eqLegacyWriteData(testNode));
 106
 107         doReturn(Futures.successful(new MergeDataReply().toSerializable(version))).when(mockActorContext).
 108                 executeOperationAsync(eq(actorSelection(actorRef)), eqLegacyMergeData(testNode));
 109
 110         doReturn(Futures.successful(new DeleteDataReply().toSerializable(version))).when(mockActorContext).
 111                 executeOperationAsync(eq(actorSelection(actorRef)), eqLegacyDeleteData(TestModel.TEST_PATH));
 112
 113         doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
 114                 eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
 115
 116         doReturn(actorRef.path().toString()).when(mockActorContext).resolvePath(eq(actorRef.path().toString()),
 117                 eq(actorRef.path().toString()));
 118
 119         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, READ_WRITE);
 120
 121         Optional<NormalizedNode<?, ?>> readOptional = transactionProxy.read(TestModel.TEST_PATH).
 122                 get(5, TimeUnit.SECONDS);
 123
 124         assertEquals("NormalizedNode isPresent", true, readOptional.isPresent());
 125         assertEquals("Response NormalizedNode", testNode, readOptional.get());
 126
 127         transactionProxy.write(TestModel.TEST_PATH, testNode);
 128
 129         transactionProxy.merge(TestModel.TEST_PATH, testNode);
 130
 131         transactionProxy.delete(TestModel.TEST_PATH);
 132
 133         DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
 134
 135         assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
 136
 137         ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
 138
 139         verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path()));
 140
 141         return actorRef;
 142     }
 143
 144     @Test
 145     public void testCompatibilityWithBaseHeliumVersion() throws Exception {
 146         ActorRef actorRef = testCompatibilityWithHeliumVersion(DataStoreVersions.BASE_HELIUM_VERSION);
 147
 148         verify(mockActorContext).resolvePath(eq(actorRef.path().toString()),
 149                 eq(actorRef.path().toString()));
 150     }
 151
 152     @Test
 153     public void testCompatibilityWithHeliumR1Version() throws Exception {
 154         ActorRef actorRef = testCompatibilityWithHeliumVersion(DataStoreVersions.HELIUM_1_VERSION);
 155
 156         verify(mockActorContext, Mockito.never()).resolvePath(eq(actorRef.path().toString()),
 157                 eq(actorRef.path().toString()));
 158     }
 159
 160     @Test
 161     @Ignore
 162     // FIXME: disabled until we can get the primary shard version from the ShardManager as we now skip
 163     // creating transaction actors for write-only Tx's.
 164     public void testWriteOnlyCompatibilityWithHeliumR2Version() throws Exception {
 165         short version = DataStoreVersions.HELIUM_2_VERSION;
 166         ActorRef actorRef = setupActorContextWithInitialCreateTransaction(getSystem(), WRITE_ONLY, version);
 167
 168         NormalizedNode<?, ?> testNode = ImmutableNodes.containerNode(TestModel.TEST_QNAME);
 169
 170         doReturn(Futures.successful(new WriteDataReply().toSerializable(version))).when(mockActorContext).
 171                 executeOperationAsync(eq(actorSelection(actorRef)), eqLegacyWriteData(testNode));
 172
 173         doReturn(readySerializedTxReply(actorRef.path().toString())).when(mockActorContext).executeOperationAsync(
 174                 eq(actorSelection(actorRef)), isA(ReadyTransaction.SERIALIZABLE_CLASS));
 175
 176         doReturn(actorRef.path().toString()).when(mockActorContext).resolvePath(eq(actorRef.path().toString()),
 177                 eq(actorRef.path().toString()));
 178
 179         TransactionProxy transactionProxy = new TransactionProxy(mockActorContext, WRITE_ONLY);
 180
 181         transactionProxy.write(TestModel.TEST_PATH, testNode);
 182
 183         DOMStoreThreePhaseCommitCohort ready = transactionProxy.ready();
 184
 185         assertTrue(ready instanceof ThreePhaseCommitCohortProxy);
 186
 187         ThreePhaseCommitCohortProxy proxy = (ThreePhaseCommitCohortProxy) ready;
 188
 189         verifyCohortFutures(proxy, getSystem().actorSelection(actorRef.path()));
 190     }
 191 }