Java TestActorRef.tell方法代码示例

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testOnEntityOwnershipChanged() {
    DOMEntityOwnershipListener mockListener = mock(DOMEntityOwnershipListener.class);

    TestActorRef<EntityOwnershipListenerActor> listenerActor = actorFactory.createTestActor(
            EntityOwnershipListenerActor.props(mockListener), actorFactory.generateActorId("listener"));

    DOMEntity entity = new DOMEntity("test", YangInstanceIdentifier.of(QName.create("test", "id1")));
    boolean wasOwner = false;
    boolean isOwner = true;
    boolean hasOwner = true;
    listenerActor.tell(new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(
            wasOwner, isOwner, hasOwner)), ActorRef.noSender());

    verify(mockListener, timeout(5000)).ownershipChanged(ownershipChange(entity, wasOwner, isOwner, hasOwner));
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testRemoveServerWithNoLeader() {
    LOG.info("testRemoveServerWithNoLeader starting");

    DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
    configParams.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));

    TestActorRef<MockRaftActor> leaderActor = actorFactory.createTestActor(
            MockRaftActor.builder().id(LEADER_ID).peerAddresses(ImmutableMap.of(FOLLOWER_ID,
                    followerActor.path().toString())).config(configParams).persistent(Optional.of(false))
                    .props().withDispatcher(Dispatchers.DefaultDispatcherId()),
            actorFactory.generateActorId(LEADER_ID));
    leaderActor.underlyingActor().waitForInitializeBehaviorComplete();

    leaderActor.tell(new RemoveServer(FOLLOWER_ID), testKit.getRef());
    RemoveServerReply removeServerReply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"),
            RemoveServerReply.class);
    assertEquals("getStatus", ServerChangeStatus.NO_LEADER, removeServerReply.getStatus());

    LOG.info("testRemoveServerWithNoLeader ending");
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testPeerAddressResolved() throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final ShardIdentifier peerID = ShardIdentifier.create("inventory", MemberName.forName("member-2"),
                    "config");
            final TestActorRef<Shard> shard = actorFactory.createTestActor(newShardBuilder()
                    .peerAddresses(Collections.<String, String>singletonMap(peerID.toString(), null))
                    .props().withDispatcher(Dispatchers.DefaultDispatcherId()), "testPeerAddressResolved");

            final String address = "akka://foobar";
            shard.tell(new PeerAddressResolved(peerID.toString(), address), ActorRef.noSender());

            shard.tell(GetOnDemandRaftState.INSTANCE, getRef());
            final OnDemandRaftState state = expectMsgClass(OnDemandRaftState.class);
            assertEquals("getPeerAddress", address, state.getPeerAddresses().get(peerID.toString()));
        }
    };
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testRemoveServerLeaderWithNoFollowers() {
    LOG.info("testRemoveServerLeaderWithNoFollowers starting");

    TestActorRef<MockLeaderRaftActor> leaderActor = actorFactory.createTestActor(
            MockLeaderRaftActor.props(Collections.<String, String>emptyMap(),
                    new MockRaftActorContext()).withDispatcher(Dispatchers.DefaultDispatcherId()),
            actorFactory.generateActorId(LEADER_ID));

    leaderActor.tell(new RemoveServer(LEADER_ID), testKit.getRef());
    RemoveServerReply removeServerReply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"),
            RemoveServerReply.class);
    assertEquals("getStatus", ServerChangeStatus.NOT_SUPPORTED, removeServerReply.getStatus());

    LOG.info("testRemoveServerLeaderWithNoFollowers ending");
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testOnRegisterCandidateLocalWithNoInitialLeader() throws Exception {
    testLog.info("testOnRegisterCandidateLocalWithNoInitialLeader starting");

    final ShardTestKit kit = new ShardTestKit(getSystem());

    dataStoreContextBuilder.shardHeartbeatIntervalInMillis(100).shardElectionTimeoutFactor(2);

    ShardIdentifier leaderId = newShardId(LOCAL_MEMBER_NAME);
    ShardIdentifier peerId = newShardId(PEER_MEMBER_1_NAME);

    TestActorRef<TestEntityOwnershipShard> peer = actorFactory.createTestActor(TestEntityOwnershipShard.props(
            newShardBuilder(peerId, peerMap(leaderId.toString()), PEER_MEMBER_1_NAME)), peerId.toString());
    TestEntityOwnershipShard peerShard = peer.underlyingActor();
    peerShard.startDroppingMessagesOfType(RequestVote.class);
    peerShard.startDroppingMessagesOfType(ElectionTimeout.class);

    TestActorRef<EntityOwnershipShard> shard = actorFactory.createTestActor(
            newShardProps(leaderId, peerMap(peerId.toString()), LOCAL_MEMBER_NAME), leaderId.toString());

    YangInstanceIdentifier entityId = ENTITY_ID1;
    DOMEntity entity = new DOMEntity(ENTITY_TYPE, entityId);

    shard.tell(new RegisterCandidateLocal(entity), kit.getRef());
    kit.expectMsgClass(SuccessReply.class);

    // Now allow RequestVotes to the peer so the shard becomes the leader. This should retry the commit.
    peerShard.stopDroppingMessagesOfType(RequestVote.class);

    verifyCommittedEntityCandidate(shard, ENTITY_TYPE, entityId, LOCAL_MEMBER_NAME);
    verifyOwner(shard, ENTITY_TYPE, entityId, LOCAL_MEMBER_NAME);

    testLog.info("testOnRegisterCandidateLocalWithNoInitialLeader ending");
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
protected void killActor(TestActorRef<TestRaftActor> actor) {
    JavaTestKit testkit = new JavaTestKit(getSystem());
    testkit.watch(actor);

    actor.tell(PoisonPill.getInstance(), null);
    testkit.expectMsgClass(JavaTestKit.duration("5 seconds"), Terminated.class);

    testkit.unwatch(actor);
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testLeaderTransitioning() throws Exception {
    TEST_LOG.info("testLeaderTransitioning starting");

    ActorRef notifierActor = factory.createActor(MessageCollectorActor.props());

    DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
    config.setCustomRaftPolicyImplementationClass(DisableElectionsRaftPolicy.class.getName());

    String persistenceId = factory.generateActorId("test-actor-");

    TestActorRef<MockRaftActor> raftActorRef = factory.createTestActor(MockRaftActor.builder().id(persistenceId)
            .config(config).roleChangeNotifier(notifierActor).props()
            .withDispatcher(Dispatchers.DefaultDispatcherId()), persistenceId);
    MockRaftActor mockRaftActor = raftActorRef.underlyingActor();

    mockRaftActor.waitForInitializeBehaviorComplete();

    raftActorRef.tell(new AppendEntries(1L, "leader", 0L, 1L, Collections.<ReplicatedLogEntry>emptyList(),
            0L, -1L, (short)1), ActorRef.noSender());
    LeaderStateChanged leaderStateChange = MessageCollectorActor.expectFirstMatching(
            notifierActor, LeaderStateChanged.class);
    assertEquals("getLeaderId", "leader", leaderStateChange.getLeaderId());

    MessageCollectorActor.clearMessages(notifierActor);

    raftActorRef.tell(new LeaderTransitioning("leader"), ActorRef.noSender());

    leaderStateChange = MessageCollectorActor.expectFirstMatching(notifierActor, LeaderStateChanged.class);
    assertEquals("getMemberId", persistenceId, leaderStateChange.getMemberId());
    assertEquals("getLeaderId", null, leaderStateChange.getLeaderId());

    TEST_LOG.info("testLeaderTransitioning ending");
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testBatchedModificationsWithOperationFailure() throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testBatchedModificationsWithOperationFailure");

            waitUntilLeader(shard);

            // Test merge with invalid data. An exception should occur when
            // the merge is applied. Note that
            // write will not validate the children for performance reasons.

            final TransactionIdentifier transactionID = nextTransactionId();

            final ContainerNode invalidData = ImmutableContainerNodeBuilder.create()
                    .withNodeIdentifier(new YangInstanceIdentifier.NodeIdentifier(TestModel.TEST_QNAME))
                    .withChild(ImmutableNodes.leafNode(TestModel.JUNK_QNAME, "junk")).build();

            BatchedModifications batched = new BatchedModifications(transactionID, CURRENT_VERSION);
            batched.addModification(new MergeModification(TestModel.TEST_PATH, invalidData));
            shard.tell(batched, getRef());
            Failure failure = expectMsgClass(duration("5 seconds"), akka.actor.Status.Failure.class);

            final Throwable cause = failure.cause();

            batched = new BatchedModifications(transactionID, DataStoreVersions.CURRENT_VERSION);
            batched.setReady(true);
            batched.setTotalMessagesSent(2);

            shard.tell(batched, getRef());

            failure = expectMsgClass(duration("5 seconds"), akka.actor.Status.Failure.class);
            assertEquals("Failure cause", cause, failure.cause());
        }
    };
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testChangeLeaderToNonVotingInSingleNode() {
    LOG.info("testChangeLeaderToNonVotingInSingleNode starting");

    TestActorRef<MockLeaderRaftActor> leaderActor = actorFactory.createTestActor(
            MockLeaderRaftActor.props(ImmutableMap.of(), new MockRaftActorContext())
                    .withDispatcher(Dispatchers.DefaultDispatcherId()), actorFactory.generateActorId(LEADER_ID));

    leaderActor.tell(new ChangeServersVotingStatus(ImmutableMap.of(LEADER_ID, false)), testKit.getRef());
    ServerChangeReply reply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"), ServerChangeReply.class);
    assertEquals("getStatus", ServerChangeStatus.INVALID_REQUEST, reply.getStatus());

    LOG.info("testChangeLeaderToNonVotingInSingleNode ending");
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
void sendHeartbeat(final TestActorRef<MemberActor> leaderActor) {
    Uninterruptibles.sleepUninterruptibly(HEARTBEAT_INTERVAL, TimeUnit.MILLISECONDS);
    leaderActor.tell(SendImmediateHeartBeat.INSTANCE, ActorRef.noSender());
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testAbortAfterReady() throws Exception {
    dataStoreContextBuilder.shardTransactionCommitTimeoutInSeconds(1);
    new ShardTestKit(getSystem()) {
        {
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()), "testAbortAfterReady");

            waitUntilLeader(shard);

            final FiniteDuration duration = duration("5 seconds");

            // Ready a tx.

            final TransactionIdentifier transactionID1 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID1, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            // Send the AbortTransaction message.

            shard.tell(new AbortTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, AbortTransactionReply.class);

            assertEquals("getPendingTxCommitQueueSize", 0, shard.underlyingActor().getPendingTxCommitQueueSize());

            // Now send CanCommitTransaction - should fail.

            shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            final Throwable failure = expectMsgClass(duration, akka.actor.Status.Failure.class).cause();
            assertTrue("Failure type", failure instanceof IllegalStateException);

            // Ready and CanCommit another and verify success.

            final TransactionIdentifier transactionID2 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID2, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            shard.tell(new CanCommitTransaction(transactionID2, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CanCommitTransactionReply.class);
        }
    };
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
private void testImmediateCommitWithCanCommitPhaseFailure(final boolean readWrite) throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final TipProducingDataTree dataTree = createDelegatingMockDataTree();
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardBuilder().dataTree(dataTree).props().withDispatcher(Dispatchers.DefaultDispatcherId()),
                    "testImmediateCommitWithCanCommitPhaseFailure-" + readWrite);

            waitUntilLeader(shard);

            doThrow(new DataValidationFailedException(YangInstanceIdentifier.EMPTY, "mock canCommit failure"))
                    .doNothing().when(dataTree).validate(any(DataTreeModification.class));

            final FiniteDuration duration = duration("5 seconds");

            final TransactionIdentifier transactionID1 = nextTransactionId();

            if (readWrite) {
                shard.tell(prepareForwardedReadyTransaction(shard, transactionID1, TestModel.TEST_PATH,
                        ImmutableNodes.containerNode(TestModel.TEST_QNAME), true), getRef());
            } else {
                shard.tell(prepareBatchedModifications(transactionID1, TestModel.TEST_PATH,
                        ImmutableNodes.containerNode(TestModel.TEST_QNAME), true), getRef());
            }

            expectMsgClass(duration, akka.actor.Status.Failure.class);

            // Send another can commit to ensure the failed one got cleaned
            // up.

            final TransactionIdentifier transactionID2 = nextTransactionId();
            if (readWrite) {
                shard.tell(prepareForwardedReadyTransaction(shard, transactionID2, TestModel.TEST_PATH,
                        ImmutableNodes.containerNode(TestModel.TEST_QNAME), true), getRef());
            } else {
                shard.tell(prepareBatchedModifications(transactionID2, TestModel.TEST_PATH,
                        ImmutableNodes.containerNode(TestModel.TEST_QNAME), true), getRef());
            }

            expectMsgClass(duration, CommitTransactionReply.class);
        }
    };
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testRealSnapshotWhenReplicatedToAllIndexMinusOne() throws Exception {
    String persistenceId = factory.generateActorId("leader-");
    DefaultConfigParamsImpl config = new DefaultConfigParamsImpl();
    config.setHeartBeatInterval(new FiniteDuration(1, TimeUnit.DAYS));
    config.setIsolatedLeaderCheckInterval(new FiniteDuration(1, TimeUnit.DAYS));
    config.setSnapshotBatchCount(5);

    DataPersistenceProvider dataPersistenceProvider = createProvider();

    Map<String, String> peerAddresses = ImmutableMap.<String, String>builder().put("member1", "address").build();

    TestActorRef<MockRaftActor> mockActorRef = factory.createTestActor(
            MockRaftActor.props(persistenceId, peerAddresses, config, dataPersistenceProvider), persistenceId);

    MockRaftActor leaderActor = mockActorRef.underlyingActor();
    leaderActor.getRaftActorContext().setCommitIndex(3);
    leaderActor.getRaftActorContext().setLastApplied(3);
    leaderActor.getRaftActorContext().getTermInformation().update(1, persistenceId);

    leaderActor.waitForInitializeBehaviorComplete();
    for (int i = 0; i < 4; i++) {
        leaderActor.getReplicatedLog().append(new SimpleReplicatedLogEntry(i, 1,
                new MockRaftActorContext.MockPayload("A")));
    }

    Leader leader = new Leader(leaderActor.getRaftActorContext());
    leaderActor.setCurrentBehavior(leader);
    assertEquals(RaftState.Leader, leaderActor.getCurrentBehavior().state());

    // Simulate an install snaphost to a follower.
    leaderActor.getRaftActorContext().getSnapshotManager().captureToInstall(
            leaderActor.getReplicatedLog().last(), -1, "member1");

    // Now send a CaptureSnapshotReply
    mockActorRef.tell(new CaptureSnapshotReply(ByteState.of(fromObject("foo").toByteArray()),
            java.util.Optional.empty()), mockActorRef);

    // Trimming log in this scenario is a no-op
    assertEquals(-1, leaderActor.getReplicatedLog().getSnapshotIndex());
    assertTrue(leaderActor.getRaftActorContext().getSnapshotManager().isCapturing());
    assertEquals(-1, leader.getReplicatedToAllIndex());
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testAbortQueuedTransaction() throws Exception {
    new ShardTestKit(getSystem()) {
        {
            final TestActorRef<Shard> shard = actorFactory.createTestActor(
                    newShardProps().withDispatcher(Dispatchers.DefaultDispatcherId()), "testAbortAfterReady");

            waitUntilLeader(shard);

            final FiniteDuration duration = duration("5 seconds");

            // Ready 3 tx's.

            final TransactionIdentifier transactionID1 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID1, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            final TransactionIdentifier transactionID2 = nextTransactionId();
            shard.tell(newBatchedModifications(transactionID2, TestModel.TEST_PATH,
                    ImmutableNodes.containerNode(TestModel.TEST_QNAME), true, false, 1), getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            final TransactionIdentifier transactionID3 = nextTransactionId();
            shard.tell(
                    newBatchedModifications(transactionID3, TestModel.OUTER_LIST_PATH,
                            ImmutableNodes.mapNodeBuilder(TestModel.OUTER_LIST_QNAME).build(), true, false, 1),
                    getRef());
            expectMsgClass(duration, ReadyTransactionReply.class);

            // Abort the second tx while it's queued.

            shard.tell(new AbortTransaction(transactionID2, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, AbortTransactionReply.class);

            // Commit the other 2.

            shard.tell(new CanCommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CanCommitTransactionReply.class);

            shard.tell(new CommitTransaction(transactionID1, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CommitTransactionReply.class);

            shard.tell(new CanCommitTransaction(transactionID3, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CanCommitTransactionReply.class);

            shard.tell(new CommitTransaction(transactionID3, CURRENT_VERSION).toSerializable(), getRef());
            expectMsgClass(duration, CommitTransactionReply.class);

            assertEquals("getPendingTxCommitQueueSize", 0, shard.underlyingActor().getPendingTxCommitQueueSize());
        }
    };
}
 

import akka.testkit.TestActorRef; //导入方法依赖的package包/类
@Test
public void testChangeToVotingWithNoLeaderAndElectionTimeout() {
    LOG.info("testChangeToVotingWithNoLeaderAndElectionTimeout starting");

    final String node1ID = "node1";
    final String node2ID = "node2";

    final PeerAddressResolver peerAddressResolver = peerId -> peerId.equals(node1ID)
            ? actorFactory.createTestActorPath(node1ID) : peerId.equals(node2ID)
                    ? actorFactory.createTestActorPath(node2ID) : null;

    ServerConfigurationPayload persistedServerConfig = new ServerConfigurationPayload(Arrays.asList(
            new ServerInfo(node1ID, false), new ServerInfo(node2ID, true)));
    SimpleReplicatedLogEntry persistedServerConfigEntry = new SimpleReplicatedLogEntry(0, 1, persistedServerConfig);

    InMemoryJournal.addEntry(node1ID, 1, new UpdateElectionTerm(1, "node1"));
    InMemoryJournal.addEntry(node1ID, 2, persistedServerConfigEntry);
    InMemoryJournal.addEntry(node2ID, 1, new UpdateElectionTerm(1, "node1"));
    InMemoryJournal.addEntry(node2ID, 2, persistedServerConfigEntry);

    DefaultConfigParamsImpl configParams1 = new DefaultConfigParamsImpl();
    configParams1.setHeartBeatInterval(new FiniteDuration(100, TimeUnit.MILLISECONDS));
    configParams1.setElectionTimeoutFactor(1);
    configParams1.setPeerAddressResolver(peerAddressResolver);
    ActorRef node1Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    TestActorRef<CollectingMockRaftActor> node1RaftActorRef = actorFactory.createTestActor(
            CollectingMockRaftActor.props(node1ID, ImmutableMap.<String, String>of(), configParams1,
                    PERSISTENT, node1Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node1ID);
    final CollectingMockRaftActor node1RaftActor = node1RaftActorRef.underlyingActor();

    DefaultConfigParamsImpl configParams2 = new DefaultConfigParamsImpl();
    configParams2.setElectionTimeoutFactor(1000000);
    configParams2.setPeerAddressResolver(peerAddressResolver);
    ActorRef node2Collector = actorFactory.createActor(
            MessageCollectorActor.props(), actorFactory.generateActorId("collector"));
    TestActorRef<CollectingMockRaftActor> node2RaftActorRef = actorFactory.createTestActor(
            CollectingMockRaftActor.props(node2ID, ImmutableMap.<String, String>of(), configParams2,
                    PERSISTENT, node2Collector).withDispatcher(Dispatchers.DefaultDispatcherId()), node2ID);
    CollectingMockRaftActor node2RaftActor = node2RaftActorRef.underlyingActor();

    // Send a ChangeServersVotingStatus message to node1 to change mode1 to voting. This should cause
    // node1 to try to elect itself as leader in order to apply the new server config. But we'll drop
    // RequestVote messages in node2 which should cause node1 to time out and revert back to the previous
    // server config and fail with NO_LEADER. Note that node1 shouldn't forward the request to node2 b/c
    // node2 was previously voting.

    node2RaftActor.setDropMessageOfType(RequestVote.class);

    ChangeServersVotingStatus changeServers = new ChangeServersVotingStatus(ImmutableMap.of(node1ID, true));
    node1RaftActorRef.tell(changeServers, testKit.getRef());
    ServerChangeReply reply = testKit.expectMsgClass(JavaTestKit.duration("5 seconds"), ServerChangeReply.class);
    assertEquals("getStatus", ServerChangeStatus.NO_LEADER, reply.getStatus());

    assertEquals("Server config", Sets.newHashSet(nonVotingServer(node1ID), votingServer(node2ID)),
            Sets.newHashSet(node1RaftActor.getRaftActorContext().getPeerServerInfo(true).getServerConfig()));
    assertEquals("getRaftState", RaftState.Follower, node1RaftActor.getRaftState());

    LOG.info("testChangeToVotingWithNoLeaderAndElectionTimeout ending");
}