Function TEST_F

src/tests/containerizer/composing_containerizer_tests.cpp:67–124

This test ensures that destroy can be called while in the launch loop. The composing containerizer still calls the underlying containerizer's destroy (because it's not sure if the containerizer can handle the type of container being launched). If the launch is not supported by the 1st containerizer, the composing containerizer should stop the launch.

// launched). If the launch is not supported by the 1st containerizer,
// the composing containerizer should stop the launch.
TEST_F(ComposingContainerizerTest, DestroyDuringUnsupportedLaunchLoop)
{
  vector<Containerizer*> containerizers;

  MockContainerizer* mockContainerizer1 = new MockContainerizer();
  MockContainerizer* mockContainerizer2 = new MockContainerizer();

  containerizers.push_back(mockContainerizer1);
  containerizers.push_back(mockContainerizer2);

  ComposingContainerizer containerizer(containerizers);
  ContainerID containerId;
  containerId.set_value("container");
  TaskInfo taskInfo;
  ExecutorInfo executorInfo;
  map<string, string> environment;

  Promise<Containerizer::LaunchResult> launchPromise;

  EXPECT_CALL(*mockContainerizer1, launch(_, _, _, _))
    .WillOnce(Return(launchPromise.future()));

  Future<Nothing> destroy;
  Promise<Option<ContainerTermination>> destroyPromise;
  EXPECT_CALL(*mockContainerizer1, destroy(_))
    .WillOnce(DoAll(FutureSatisfy(&destroy),
                    Return(destroyPromise.future())));

  Future<Containerizer::LaunchResult> launched = containerizer.launch(
      containerId,
      createContainerConfig(taskInfo, executorInfo, "dir", "user"),
      environment,
      None());

  EXPECT_TRUE(launched.isPending());

  Future<Option<ContainerTermination>> destroyed =
    containerizer.destroy(containerId);

  EXPECT_CALL(*mockContainerizer2, launch(_, _, _, _))
    .Times(0);

  // We make sure the destroy is being called on the first containerizer.
  // The second containerizer shouldn't be called as well since the
  // container is already destroyed.
  AWAIT_READY(destroy);

  launchPromise.set(Containerizer::LaunchResult::NOT_SUPPORTED);
  destroyPromise.set(Option<ContainerTermination>::none());

  // `launched` should be a failure and `destroyed` should be `None`
  // because there was no container in `RUNNING` or `LAUNCHING` state
  // at the moment `destroy()` was called.
  AWAIT_FAILED(launched);

  AWAIT_READY(destroyed);
  EXPECT_NONE(destroyed.get());
}