[mesos] 05/05: Added agent reactivations to the existing agent draining tests.

[jo...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

josephwu pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/mesos.git

commit 50dcd56a42ee03d354f39cb029befe9e60e7f0bf
Author: Joseph Wu <jo...@apache.org>
AuthorDate: Mon Aug 19 14:35:34 2019 -0700

    Added agent reactivations to the existing agent draining tests.
    
    This adds an extra step to a couple of the agent draining tests,
    which calls REACTIVATE_AGENT at the end.
    
    Review: https://reviews.apache.org/r/71318
---
 src/tests/master_draining_tests.cpp | 93 +++++++++++++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/src/tests/master_draining_tests.cpp b/src/tests/master_draining_tests.cpp
index 235bf1b..f1a00df 100644
--- a/src/tests/master_draining_tests.cpp
+++ b/src/tests/master_draining_tests.cpp
@@ -563,11 +563,18 @@ TEST_P(MasterDrainingTest, DrainAgent)
         FutureArg<1>(&killedUpdate),
         v1::scheduler::SendAcknowledge(frameworkId, agentId)));
 
+  Future<StatusUpdateAcknowledgementMessage> killedAck =
+    FUTURE_PROTOBUF(StatusUpdateAcknowledgementMessage(), _, _);
+
   Future<Nothing> registrarApplyDrained;
+  Future<Nothing> registrarApplyReactivated;
   EXPECT_CALL(*master->registrar, apply(_))
     .WillOnce(DoDefault())
     .WillOnce(DoAll(
         FutureSatisfy(&registrarApplyDrained),
+        Invoke(master->registrar.get(), &MockRegistrar::unmocked_apply)))
+    .WillOnce(DoAll(
+        FutureSatisfy(&registrarApplyReactivated),
         Invoke(master->registrar.get(), &MockRegistrar::unmocked_apply)));
 
   ContentType contentType = GetParam();
@@ -587,6 +594,7 @@ TEST_P(MasterDrainingTest, DrainAgent)
   }
 
   AWAIT_READY(killedUpdate);
+  AWAIT_READY(killedAck);
   AWAIT_READY(registrarApplyDrained);
 
   // Ensure that the update acknowledgement has been processed.
@@ -676,6 +684,33 @@ TEST_P(MasterDrainingTest, DrainAgent)
     ASSERT_SOME(stateDrainStartTime);
     EXPECT_LT(0, stateDrainStartTime->as<int>());
   }
+
+  // Reactivate the agent and expect to get the agent in an offer.
+  Future<v1::scheduler::Event::Offers> offers;
+  EXPECT_CALL(*scheduler, offers(_, _))
+    .WillOnce(FutureArg<1>(&offers));
+
+  {
+    v1::master::Call::ReactivateAgent reactivateAgent;
+    reactivateAgent.mutable_agent_id()->CopyFrom(agentId);
+
+    v1::master::Call call;
+    call.set_type(v1::master::Call::REACTIVATE_AGENT);
+    call.mutable_reactivate_agent()->CopyFrom(reactivateAgent);
+
+    AWAIT_EXPECT_RESPONSE_STATUS_EQ(
+        http::OK().status,
+        post(master->pid, call, contentType));
+  }
+
+  AWAIT_READY(registrarApplyReactivated);
+
+  Clock::advance(masterFlags.allocation_interval);
+  Clock::settle();
+
+  AWAIT_READY(offers);
+  ASSERT_FALSE(offers->offers().empty());
+  EXPECT_EQ(agentId, offers->offers(0).agent_id());
 }
 
 
@@ -788,6 +823,9 @@ TEST_P(MasterDrainingTest, DrainAgentDisconnected)
         FutureArg<1>(&killedUpdate),
         v1::scheduler::SendAcknowledge(frameworkId, agentId)));
 
+  Future<StatusUpdateAcknowledgementMessage> killedAck =
+    FUTURE_PROTOBUF(StatusUpdateAcknowledgementMessage(), _, _);
+
   Try<Owned<cluster::Slave>> recoveredSlave =
     StartSlave(detector.get(), agentFlags);
   ASSERT_SOME(recoveredSlave);
@@ -802,6 +840,7 @@ TEST_P(MasterDrainingTest, DrainAgentDisconnected)
   // The agent should be told to drain once it reregisters.
   AWAIT_READY(drainSlaveMesage);
   AWAIT_READY(killedUpdate);
+  AWAIT_READY(killedAck);
 
   // Ensure that the agent is marked as DRAINED in the master now.
   {
@@ -825,6 +864,31 @@ TEST_P(MasterDrainingTest, DrainAgentDisconnected)
     EXPECT_EQ(agent.deactivated(), true);
     EXPECT_EQ(mesos::v1::DRAINED, agent.drain_info().state());
   }
+
+  // Reactivate the agent and expect to get the agent in an offer.
+  Future<v1::scheduler::Event::Offers> offers;
+  EXPECT_CALL(*scheduler, offers(_, _))
+    .WillOnce(FutureArg<1>(&offers));
+
+  {
+    v1::master::Call::ReactivateAgent reactivateAgent;
+    reactivateAgent.mutable_agent_id()->CopyFrom(agentId);
+
+    v1::master::Call call;
+    call.set_type(v1::master::Call::REACTIVATE_AGENT);
+    call.mutable_reactivate_agent()->CopyFrom(reactivateAgent);
+
+    AWAIT_EXPECT_RESPONSE_STATUS_EQ(
+        http::OK().status,
+        post(master->pid, call, contentType));
+  }
+
+  Clock::advance(masterFlags.allocation_interval);
+  Clock::settle();
+
+  AWAIT_READY(offers);
+  ASSERT_FALSE(offers->offers().empty());
+  EXPECT_EQ(agentId, offers->offers(0).agent_id());
 }
 
 
@@ -870,6 +934,9 @@ TEST_P(MasterDrainingTest, DrainAgentUnreachable)
         FutureArg<1>(&killedUpdate),
         v1::scheduler::SendAcknowledge(frameworkId, agentId)));
 
+  Future<StatusUpdateAcknowledgementMessage> killedAck =
+    FUTURE_PROTOBUF(StatusUpdateAcknowledgementMessage(), _, _);
+
   // Simulate an agent crash, so that it disconnects from the master.
   slave->terminate();
   slave.reset();
@@ -918,6 +985,32 @@ TEST_P(MasterDrainingTest, DrainAgentUnreachable)
   AWAIT_READY(drainSlaveMesage);
   AWAIT_READY(runningUpdate);
   AWAIT_READY(killedUpdate);
+  AWAIT_READY(killedAck);
+
+  // Reactivate the agent and expect to get the agent in an offer.
+  Future<v1::scheduler::Event::Offers> offers;
+  EXPECT_CALL(*scheduler, offers(_, _))
+    .WillOnce(FutureArg<1>(&offers));
+
+  {
+    v1::master::Call::ReactivateAgent reactivateAgent;
+    reactivateAgent.mutable_agent_id()->CopyFrom(agentId);
+
+    v1::master::Call call;
+    call.set_type(v1::master::Call::REACTIVATE_AGENT);
+    call.mutable_reactivate_agent()->CopyFrom(reactivateAgent);
+
+    AWAIT_EXPECT_RESPONSE_STATUS_EQ(
+        http::OK().status,
+        post(master->pid, call, contentType));
+  }
+
+  Clock::advance(masterFlags.allocation_interval);
+  Clock::settle();
+
+  AWAIT_READY(offers);
+  ASSERT_FALSE(offers->offers().empty());
+  EXPECT_EQ(agentId, offers->offers(0).agent_id());
 }
 
 } // namespace tests {