You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@mesos.apache.org by be...@apache.org on 2011/06/05 10:54:14 UTC

svn commit: r1132173 - /incubator/mesos/trunk/src/tests/master_test.cpp

Author: benh
Date: Sun Jun  5 08:54:14 2011
New Revision: 1132173

URL: http://svn.apache.org/viewvc?rev=1132173&view=rev
Log:
Changed some variable naming to make things more consistent.

Modified:
    incubator/mesos/trunk/src/tests/master_test.cpp

Modified: incubator/mesos/trunk/src/tests/master_test.cpp
URL: http://svn.apache.org/viewvc/incubator/mesos/trunk/src/tests/master_test.cpp?rev=1132173&r1=1132172&r2=1132173&view=diff
==============================================================================
--- incubator/mesos/trunk/src/tests/master_test.cpp (original)
+++ incubator/mesos/trunk/src/tests/master_test.cpp Sun Jun  5 08:54:14 2011
@@ -225,7 +225,7 @@ TEST(MasterTest, ResourcesReofferedAfter
 
   WAIT_UNTIL(sched1ResourceOfferCall);
 
-  EXPECT_EQ(1, offers.size());
+  EXPECT_NE(0, offers.size());
 
   map<string, string> params;
   params["cpus"] = "0";
@@ -234,17 +234,17 @@ TEST(MasterTest, ResourcesReofferedAfter
   vector<TaskDescription> tasks;
   tasks.push_back(TaskDescription(1, offers[0].slaveId, "", params, bytes()));
 
-  trigger errorCall;
+  trigger sched1ErrorCall;
 
   EXPECT_CALL(sched1, error(&driver1, _, "Invalid task size: <0 CPUs, 1024 MEM>"))
-    .WillOnce(Trigger(&errorCall));
+    .WillOnce(Trigger(&sched1ErrorCall));
 
   EXPECT_CALL(sched1, offerRescinded(&driver1, offerId))
     .Times(AtMost(1));
 
   driver1.replyToOffer(offerId, tasks, map<string, string>());
 
-  WAIT_UNTIL(errorCall);
+  WAIT_UNTIL(sched1ErrorCall);
 
   driver1.stop();
   driver1.join();
@@ -318,7 +318,7 @@ TEST(MasterTest, SlaveLost)
 
   WAIT_UNTIL(resourceOfferCall);
 
-  EXPECT_EQ(1, offers.size());
+  EXPECT_NE(0, offers.size());
 
   trigger offerRescindedCall, slaveLostCall;
 
@@ -353,68 +353,68 @@ TEST(MasterTest, SchedulerFailover)
   // registered gets called to launch the second (i.e., failover)
   // scheduler.
 
-  MockScheduler failingSched;
-  MesosSchedulerDriver failingDriver(&failingSched, master);
+  MockScheduler sched1;
+  MesosSchedulerDriver driver1(&sched1, master);
 
   FrameworkID frameworkId;
 
-  trigger failingRegisteredCall;
+  trigger sched1RegisteredCall;
 
-  EXPECT_CALL(failingSched, getFrameworkName(&failingDriver))
+  EXPECT_CALL(sched1, getFrameworkName(&driver1))
     .WillOnce(Return(""));
 
-  EXPECT_CALL(failingSched, getExecutorInfo(&failingDriver))
+  EXPECT_CALL(sched1, getExecutorInfo(&driver1))
     .WillOnce(Return(ExecutorInfo("noexecutor", "")));
 
-  EXPECT_CALL(failingSched, registered(&failingDriver, _))
-    .WillOnce(DoAll(SaveArg<1>(&frameworkId), Trigger(&failingRegisteredCall)));
+  EXPECT_CALL(sched1, registered(&driver1, _))
+    .WillOnce(DoAll(SaveArg<1>(&frameworkId), Trigger(&sched1RegisteredCall)));
 
-  EXPECT_CALL(failingSched, resourceOffer(&failingDriver, _, _))
+  EXPECT_CALL(sched1, resourceOffer(&driver1, _, _))
     .Times(AtMost(1));
 
-  EXPECT_CALL(failingSched, offerRescinded(&failingDriver, _))
+  EXPECT_CALL(sched1, offerRescinded(&driver1, _))
     .Times(AtMost(1));
 
-  EXPECT_CALL(failingSched, error(&failingDriver, _, "Framework failover"))
+  EXPECT_CALL(sched1, error(&driver1, _, "Framework failover"))
     .Times(1);
 
-  failingDriver.start();
+  driver1.start();
 
-  WAIT_UNTIL(failingRegisteredCall);
+  WAIT_UNTIL(sched1RegisteredCall);
 
   // Now launch the second (i.e., failover) scheduler using the
   // framework id recorded from the first scheduler and wait until it
   // gets a registered callback..
 
-  MockScheduler failoverSched;
-  MesosSchedulerDriver failoverDriver(&failoverSched, master, frameworkId);
+  MockScheduler sched2;
+  MesosSchedulerDriver driver2(&sched2, master, frameworkId);
 
-  trigger failoverRegisteredCall;
+  trigger sched2RegisteredCall;
 
-  EXPECT_CALL(failoverSched, getFrameworkName(&failoverDriver))
+  EXPECT_CALL(sched2, getFrameworkName(&driver2))
     .WillOnce(Return(""));
 
-  EXPECT_CALL(failoverSched, getExecutorInfo(&failoverDriver))
+  EXPECT_CALL(sched2, getExecutorInfo(&driver2))
     .WillOnce(Return(ExecutorInfo("noexecutor", "")));
 
-  EXPECT_CALL(failoverSched, registered(&failoverDriver, frameworkId))
-    .WillOnce(Trigger(&failoverRegisteredCall));
+  EXPECT_CALL(sched2, registered(&driver2, frameworkId))
+    .WillOnce(Trigger(&sched2RegisteredCall));
 
-  EXPECT_CALL(failoverSched, resourceOffer(&failoverDriver, _, _))
+  EXPECT_CALL(sched2, resourceOffer(&driver2, _, _))
     .Times(AtMost(1));
 
-  EXPECT_CALL(failoverSched, offerRescinded(&failoverDriver, _))
+  EXPECT_CALL(sched2, offerRescinded(&driver2, _))
     .Times(AtMost(1));
 
-  failoverDriver.start();
+  driver2.start();
 
-  WAIT_UNTIL(failoverRegisteredCall);
+  WAIT_UNTIL(sched2RegisteredCall);
 
-  failingDriver.stop();
-  failoverDriver.stop();
+  driver1.stop();
+  driver2.stop();
 
-  failingDriver.join();
-  failoverDriver.join();
+  driver1.join();
+  driver2.join();
 
   local::shutdown();
 }
@@ -531,7 +531,7 @@ TEST(MasterTest, TaskRunning)
 
   WAIT_UNTIL(resourceOfferCall);
 
-  EXPECT_EQ(1, offers.size());
+  EXPECT_NE(0, offers.size());
 
   vector<TaskDescription> tasks;
   tasks.push_back(TaskDescription(1, offers[0].slaveId, "", offers[0].params, ""));
@@ -589,50 +589,48 @@ TEST(MasterTest, SchedulerFailoverStatus
   // Launch the first (i.e., failing) scheduler and wait until the
   // first status update message is sent to it (drop the message).
 
-  MockScheduler failingSched;
-  MesosSchedulerDriver failingDriver(&failingSched, master);
+  MockScheduler sched1;
+  MesosSchedulerDriver driver1(&sched1, master);
 
   FrameworkID frameworkId;
   OfferID offerId;
   vector<SlaveOffer> offers;
 
-  trigger resourceOfferCall;
+  trigger resourceOfferCall, statusUpdateMsg;
 
-  EXPECT_CALL(failingSched, getFrameworkName(&failingDriver))
+  EXPECT_CALL(sched1, getFrameworkName(&driver1))
     .WillOnce(Return(""));
 
-  EXPECT_CALL(failingSched, getExecutorInfo(&failingDriver))
+  EXPECT_CALL(sched1, getExecutorInfo(&driver1))
     .WillOnce(Return(ExecutorInfo("noexecutor", "")));
 
-  EXPECT_CALL(failingSched, registered(&failingDriver, _))
+  EXPECT_CALL(sched1, registered(&driver1, _))
     .WillOnce(SaveArg<1>(&frameworkId));
 
-  EXPECT_CALL(failingSched, resourceOffer(&failingDriver, _, _))
+  EXPECT_CALL(sched1, resourceOffer(&driver1, _, _))
     .WillOnce(DoAll(SaveArg<1>(&offerId), SaveArg<2>(&offers),
                     Trigger(&resourceOfferCall)));
 
-  EXPECT_CALL(failingSched, error(&failingDriver, _, "Framework failover"))
-    .Times(1);
-
-  EXPECT_CALL(failingSched, statusUpdate(&failingDriver, _))
+  EXPECT_CALL(sched1, statusUpdate(&driver1, _))
     .Times(0);
 
-  trigger statusUpdateMsg;
+  EXPECT_CALL(sched1, error(&driver1, _, "Framework failover"))
+    .Times(1);
 
   EXPECT_MSG(filter, Eq(S2M_FT_STATUS_UPDATE), _, Ne(master))
     .WillOnce(DoAll(Trigger(&statusUpdateMsg), Return(true)))
     .RetiresOnSaturation();
 
-  failingDriver.start();
+  driver1.start();
 
   WAIT_UNTIL(resourceOfferCall);
 
-  EXPECT_EQ(1, offers.size());
+  EXPECT_NE(0, offers.size());
 
   vector<TaskDescription> tasks;
   tasks.push_back(TaskDescription(1, offers[0].slaveId, "", offers[0].params, ""));
 
-  failingDriver.replyToOffer(offerId, tasks, map<string, string>());
+  driver1.replyToOffer(offerId, tasks, map<string, string>());
 
   WAIT_UNTIL(statusUpdateMsg);
 
@@ -641,24 +639,24 @@ TEST(MasterTest, SchedulerFailoverStatus
   // registers, at which point advance time enough for the reliable
   // timeout to kick in and another status update message is sent.
 
-  MockScheduler failoverSched;
-  MesosSchedulerDriver failoverDriver(&failoverSched, master, frameworkId);
+  MockScheduler sched2;
+  MesosSchedulerDriver driver2(&sched2, master, frameworkId);
 
   trigger registeredCall, statusUpdateCall;
 
-  EXPECT_CALL(failoverSched, getFrameworkName(&failoverDriver))
+  EXPECT_CALL(sched2, getFrameworkName(&driver2))
     .WillOnce(Return(""));
 
-  EXPECT_CALL(failoverSched, getExecutorInfo(&failoverDriver))
+  EXPECT_CALL(sched2, getExecutorInfo(&driver2))
     .WillOnce(Return(ExecutorInfo("noexecutor", "")));
 
-  EXPECT_CALL(failoverSched, registered(&failoverDriver, frameworkId))
+  EXPECT_CALL(sched2, registered(&driver2, frameworkId))
     .WillOnce(Trigger(&registeredCall));
 
-  EXPECT_CALL(failoverSched, statusUpdate(&failoverDriver, _))
+  EXPECT_CALL(sched2, statusUpdate(&driver2, _))
     .WillOnce(Trigger(&statusUpdateCall));
 
-  failoverDriver.start();
+  driver2.start();
 
   WAIT_UNTIL(registeredCall);
 
@@ -666,11 +664,11 @@ TEST(MasterTest, SchedulerFailoverStatus
 
   WAIT_UNTIL(statusUpdateCall);
 
-  failingDriver.stop();
-  failoverDriver.stop();
+  driver1.stop();
+  driver2.stop();
 
-  failingDriver.join();
-  failoverDriver.join();
+  driver1.join();
+  driver2.join();
 
   MesosProcess::post(slave, pack<S2S_SHUTDOWN>());
   Process::wait(slave);
@@ -684,9 +682,7 @@ TEST(MasterTest, SchedulerFailoverStatus
 }
 
 
-
-
-TEST(MasterTest, FrameworkMessages)
+TEST(MasterTest, FrameworkMessage)
 {
   ASSERT_TRUE(GTEST_IS_THREADSAFE);
 
@@ -758,7 +754,7 @@ TEST(MasterTest, FrameworkMessages)
 
   WAIT_UNTIL(resourceOfferCall);
 
-  EXPECT_EQ(1, offers.size());
+  EXPECT_NE(0, offers.size());
 
   vector<TaskDescription> tasks;
   tasks.push_back(TaskDescription(1, offers[0].slaveId, "", offers[0].params, ""));
@@ -794,3 +790,111 @@ TEST(MasterTest, FrameworkMessages)
 }
 
 
+TEST(MasterTest, SchedulerFailoverFrameworkMessage)
+{
+  ASSERT_TRUE(GTEST_IS_THREADSAFE);
+
+  MockExecutor exec;
+
+  ExecutorDriver *execDriver;
+
+  EXPECT_CALL(exec, init(_, _))
+    .WillOnce(SaveArg<0>(&execDriver));
+
+  EXPECT_CALL(exec, launchTask(_, _))
+    .Times(1);
+
+  EXPECT_CALL(exec, shutdown(_))
+    .Times(1);
+
+  LocalIsolationModule isolationModule(&exec);
+
+  Master m;
+  PID master = Process::spawn(&m);
+
+  Slave s(Resources(2, 1 * Gigabyte), true, &isolationModule);
+  PID slave = Process::spawn(&s);
+
+  BasicMasterDetector detector(master, slave, true);
+
+  MockScheduler sched1;
+  MesosSchedulerDriver driver1(&sched1, master);
+
+  FrameworkID frameworkId;
+  OfferID offerId;
+  vector<SlaveOffer> offers;
+  TaskStatus status;
+
+  trigger sched1ResourceOfferCall, sched1StatusUpdateCall;
+
+  EXPECT_CALL(sched1, getFrameworkName(&driver1))
+    .WillOnce(Return(""));
+
+  EXPECT_CALL(sched1, getExecutorInfo(&driver1))
+    .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+
+  EXPECT_CALL(sched1, registered(&driver1, _))
+    .WillOnce(SaveArg<1>(&frameworkId));
+
+  EXPECT_CALL(sched1, statusUpdate(&driver1, _))
+    .WillOnce(DoAll(SaveArg<1>(&status), Trigger(&sched1StatusUpdateCall)));
+
+  EXPECT_CALL(sched1, resourceOffer(&driver1, _, ElementsAre(_)))
+    .WillOnce(DoAll(SaveArg<1>(&offerId), SaveArg<2>(&offers),
+                    Trigger(&sched1ResourceOfferCall)));
+
+  EXPECT_CALL(sched1, error(&driver1, _, "Framework failover"))
+    .Times(1);
+
+  driver1.start();
+
+  WAIT_UNTIL(sched1ResourceOfferCall);
+
+  EXPECT_NE(0, offers.size());
+
+  vector<TaskDescription> tasks;
+  tasks.push_back(TaskDescription(1, offers[0].slaveId, "", offers[0].params, ""));
+
+  driver1.replyToOffer(offerId, tasks, map<string, string>());
+
+  WAIT_UNTIL(sched1StatusUpdateCall);
+
+  EXPECT_EQ(TASK_RUNNING, status.state);
+
+  MockScheduler sched2;
+  MesosSchedulerDriver driver2(&sched2, master, frameworkId);
+
+  trigger sched2RegisteredCall, sched2FrameworkMessageCall;
+
+  EXPECT_CALL(sched2, getFrameworkName(&driver2))
+    .WillOnce(Return(""));
+
+  EXPECT_CALL(sched2, getExecutorInfo(&driver2))
+    .WillOnce(Return(ExecutorInfo("noexecutor", "")));
+
+  EXPECT_CALL(sched2, registered(&driver2, frameworkId))
+    .WillOnce(Trigger(&sched2RegisteredCall));
+
+  EXPECT_CALL(sched2, frameworkMessage(&driver2, _))
+    .WillOnce(Trigger(&sched2FrameworkMessageCall));
+
+  driver2.start();
+
+  WAIT_UNTIL(sched2RegisteredCall);
+
+  execDriver->sendFrameworkMessage(FrameworkMessage());
+
+  WAIT_UNTIL(sched2FrameworkMessageCall);
+
+  driver1.stop();
+  driver2.stop();
+
+  driver1.join();
+  driver2.join();
+
+  MesosProcess::post(slave, pack<S2S_SHUTDOWN>());
+  Process::wait(slave);
+
+  MesosProcess::post(master, pack<M2M_SHUTDOWN>());
+  Process::wait(master);
+}