opendaylight/md-sal/cds-access-client/src/test/java/org/opendaylight/controller/cluster/access/client/ActorBehaviorTest.java

   1 /*
   2  * Copyright (c) 2017 Pantheon Technologies s.r.o. 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.access.client;
   9
  10 import static org.mockito.ArgumentMatchers.any;
  11 import static org.mockito.Mockito.mock;
  12 import static org.mockito.Mockito.timeout;
  13 import static org.mockito.Mockito.verify;
  14 import static org.mockito.Mockito.when;
  15
  16 import akka.actor.ActorRef;
  17 import akka.actor.ActorSystem;
  18 import akka.actor.Props;
  19 import akka.persistence.Persistence;
  20 import akka.persistence.SelectedSnapshot;
  21 import akka.persistence.SnapshotMetadata;
  22 import akka.testkit.TestProbe;
  23 import akka.testkit.javadsl.TestKit;
  24 import com.typesafe.config.ConfigFactory;
  25 import java.lang.reflect.Field;
  26 import java.util.Optional;
  27 import java.util.concurrent.TimeUnit;
  28 import org.junit.After;
  29 import org.junit.Assert;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32 import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier;
  33 import org.opendaylight.controller.cluster.access.concepts.FrontendIdentifier;
  34 import org.opendaylight.controller.cluster.access.concepts.FrontendType;
  35 import org.opendaylight.controller.cluster.access.concepts.MemberName;
  36 import scala.concurrent.duration.FiniteDuration;
  37
  38 public class ActorBehaviorTest {
  39
  40     private static final String MEMBER_1_FRONTEND_TYPE_1 = "member-1-frontend-type-1";
  41     private static final FiniteDuration TIMEOUT = FiniteDuration.create(5, TimeUnit.SECONDS);
  42
  43     private ActorSystem system;
  44     private TestProbe probe;
  45     private ClientActorBehavior<BackendInfo> initialBehavior;
  46     private MockedSnapshotStore.SaveRequest saveRequest;
  47     private FrontendIdentifier id;
  48     private ActorRef mockedActor;
  49
  50     @Before
  51     public void setUp() throws Exception {
  52         initialBehavior = createInitialBehaviorMock();
  53         system = ActorSystem.apply("system1");
  54         final ActorRef storeRef = system.registerExtension(Persistence.lookup()).snapshotStoreFor(null,
  55             ConfigFactory.empty());
  56         probe = new TestProbe(system);
  57         storeRef.tell(probe.ref(), ActorRef.noSender());
  58         final MemberName name = MemberName.forName("member-1");
  59         id = FrontendIdentifier.create(name, FrontendType.forName("type-1"));
  60         mockedActor = system.actorOf(MockedActor.props(id, initialBehavior));
  61         //handle initial actor recovery
  62         saveRequest = handleRecovery(null);
  63     }
  64
  65     @After
  66     public void tearDown() {
  67         TestKit.shutdownActorSystem(system);
  68     }
  69
  70     @Test
  71     public void testInitialBehavior() {
  72         final InternalCommand<BackendInfo> cmd = mock(InternalCommand.class);
  73         when(cmd.execute(any())).thenReturn(initialBehavior);
  74         mockedActor.tell(cmd, ActorRef.noSender());
  75         verify(cmd, timeout(1000)).execute(initialBehavior);
  76     }
  77
  78     @Test
  79     public void testCommandStashing() {
  80         system.stop(mockedActor);
  81         mockedActor = system.actorOf(MockedActor.props(id, initialBehavior));
  82         final InternalCommand<BackendInfo> cmd = mock(InternalCommand.class);
  83         when(cmd.execute(any())).thenReturn(initialBehavior);
  84         //send messages before recovery is completed
  85         mockedActor.tell(cmd, ActorRef.noSender());
  86         mockedActor.tell(cmd, ActorRef.noSender());
  87         mockedActor.tell(cmd, ActorRef.noSender());
  88         //complete recovery
  89         handleRecovery(null);
  90         verify(cmd, timeout(1000).times(3)).execute(initialBehavior);
  91     }
  92
  93     @Test
  94     public void testRecoveryAfterRestart() {
  95         system.stop(mockedActor);
  96         mockedActor = system.actorOf(MockedActor.props(id, initialBehavior));
  97         final MockedSnapshotStore.SaveRequest newSaveRequest =
  98                 handleRecovery(new SelectedSnapshot(saveRequest.getMetadata(), saveRequest.getSnapshot()));
  99         Assert.assertEquals(MEMBER_1_FRONTEND_TYPE_1, newSaveRequest.getMetadata().persistenceId());
 100     }
 101
 102     @Test
 103     public void testRecoveryAfterRestartFrontendIdMismatch() {
 104         system.stop(mockedActor);
 105         //start actor again
 106         mockedActor = system.actorOf(MockedActor.props(id, initialBehavior));
 107         probe.expectMsgClass(MockedSnapshotStore.LoadRequest.class);
 108         //offer snapshot with incorrect client id
 109         final SnapshotMetadata metadata = saveRequest.getMetadata();
 110         final FrontendIdentifier anotherFrontend = FrontendIdentifier.create(MemberName.forName("another"),
 111                 FrontendType.forName("type-2"));
 112         final ClientIdentifier incorrectClientId = ClientIdentifier.create(anotherFrontend, 0);
 113         probe.watch(mockedActor);
 114         probe.reply(Optional.of(new SelectedSnapshot(metadata, incorrectClientId)));
 115         //actor should be stopped
 116         probe.expectTerminated(mockedActor, TIMEOUT);
 117     }
 118
 119     @Test
 120     public void testRecoveryAfterRestartSaveSnapshotFail() {
 121         system.stop(mockedActor);
 122         mockedActor = system.actorOf(MockedActor.props(id, initialBehavior));
 123         probe.watch(mockedActor);
 124         probe.expectMsgClass(MockedSnapshotStore.LoadRequest.class);
 125         probe.reply(Optional.empty());
 126         probe.expectMsgClass(MockedSnapshotStore.SaveRequest.class);
 127         probe.reply(new RuntimeException("save failed"));
 128         probe.expectMsgClass(MockedSnapshotStore.DeleteByMetadataRequest.class);
 129         probe.expectTerminated(mockedActor, TIMEOUT);
 130     }
 131
 132     @Test
 133     public void testRecoveryAfterRestartDeleteSnapshotsFail() {
 134         system.stop(mockedActor);
 135         mockedActor = system.actorOf(MockedActor.props(id, initialBehavior));
 136         probe.watch(mockedActor);
 137         probe.expectMsgClass(MockedSnapshotStore.LoadRequest.class);
 138         probe.reply(Optional.empty());
 139         probe.expectMsgClass(MockedSnapshotStore.SaveRequest.class);
 140         probe.reply(Void.TYPE);
 141         probe.expectMsgClass(MockedSnapshotStore.DeleteByCriteriaRequest.class);
 142         probe.reply(new RuntimeException("delete failed"));
 143         //actor shouldn't terminate
 144         probe.expectNoMessage();
 145     }
 146
 147     @SuppressWarnings("unchecked")
 148     private static ClientActorBehavior<BackendInfo> createInitialBehaviorMock() throws Exception {
 149         final ClientActorBehavior<BackendInfo> initialBehavior = mock(ClientActorBehavior.class);
 150         //persistenceId() in AbstractClientActorBehavior is final and can't be mocked
 151         //use reflection to work around this
 152         final Field context = AbstractClientActorBehavior.class.getDeclaredField("context");
 153         context.setAccessible(true);
 154         final AbstractClientActorContext ctx = mock(AbstractClientActorContext.class);
 155         context.set(initialBehavior, ctx);
 156         final Field persistenceId = AbstractClientActorContext.class.getDeclaredField("persistenceId");
 157         persistenceId.setAccessible(true);
 158         persistenceId.set(ctx, MEMBER_1_FRONTEND_TYPE_1);
 159         return initialBehavior;
 160     }
 161
 162     private MockedSnapshotStore.SaveRequest handleRecovery(final SelectedSnapshot savedState) {
 163         probe.expectMsgClass(MockedSnapshotStore.LoadRequest.class);
 164         //offer snapshot
 165         probe.reply(Optional.ofNullable(savedState));
 166         final MockedSnapshotStore.SaveRequest nextSaveRequest =
 167                 probe.expectMsgClass(MockedSnapshotStore.SaveRequest.class);
 168         probe.reply(Void.TYPE);
 169         //check old snapshots deleted
 170         probe.expectMsgClass(MockedSnapshotStore.DeleteByCriteriaRequest.class);
 171         probe.reply(Void.TYPE);
 172         return nextSaveRequest;
 173     }
 174
 175     private static class MockedActor extends AbstractClientActor {
 176
 177         private final ClientActorBehavior<?> initialBehavior;
 178         private final ClientActorConfig mockConfig = AccessClientUtil.newMockClientActorConfig();
 179
 180         private static Props props(final FrontendIdentifier frontendId, final ClientActorBehavior<?> initialBehavior) {
 181             return Props.create(MockedActor.class, () -> new MockedActor(frontendId, initialBehavior));
 182         }
 183
 184         MockedActor(final FrontendIdentifier frontendId, final ClientActorBehavior<?> initialBehavior) {
 185             super(frontendId);
 186             this.initialBehavior = initialBehavior;
 187         }
 188
 189         @Override
 190         protected ClientActorBehavior<?> initialBehavior(final ClientActorContext context) {
 191             return initialBehavior;
 192         }
 193
 194         @Override
 195         protected ClientActorConfig getClientActorConfig() {
 196             return mockConfig;
 197         }
 198     }
 199
 200 }