func TestExecutorDriverRun(t *testing.T) {
setEnvironments(t, "", false)
// Set expections and return values.
messenger := messenger.NewMockedMessenger()
messenger.On("Start").Return(nil)
messenger.On("UPID").Return(upid.UPID{})
messenger.On("Send").Return(nil)
messenger.On("Stop").Return(nil)
exec := NewMockedExecutor()
exec.On("Error").Return(nil)
driver := newTestExecutorDriver(t, exec)
driver.messenger = messenger
assert.False(t, driver.Running())
checker := healthchecker.NewMockedHealthChecker()
checker.On("Start").Return()
checker.On("Stop").Return()
ch := make(chan struct{})
go func() {
defer close(ch)
stat, err := driver.Run()
assert.NoError(t, err)
assert.Equal(t, mesosproto.Status_DRIVER_STOPPED, stat)
}()
<-driver.started
assert.True(t, driver.Running())
driver.Stop()
<-ch
}
func (suite *SchedulerTestSuite) TestSchedulerDriverStartWithRegistrationFailure() {
sched := NewMockScheduler()
sched.On("Error").Return()
// Set expections and return values.
messenger := messenger.NewMockedMessenger()
messenger.On("Start").Return(nil)
messenger.On("UPID").Return(upid.UPID{})
messenger.On("Stop").Return(nil)
messenger.On("Install").Return(nil)
driver := newTestSchedulerDriver(suite.T(), driverConfigMessenger(sched, suite.framework, suite.master, nil, messenger))
// reliable registration loops until the driver is stopped, connected, etc..
stat, err := driver.Start()
suite.NoError(err)
suite.Equal(mesos.Status_DRIVER_RUNNING, stat)
time.Sleep(5 * time.Second) // wait a bit, registration should be looping...
suite.True(driver.Running())
suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status())
// stop the driver, should not panic!
driver.Stop(false) // intentionally not failing over
suite.False(driver.Running())
suite.Equal(mesos.Status_DRIVER_STOPPED, driver.Status())
messenger.AssertExpectations(suite.T())
}
func TestExecutorDriverStartSucceed(t *testing.T) {
setEnvironments(t, "", false)
exec := NewMockedExecutor()
exec.On("Error").Return(nil)
driver := newTestExecutorDriver(t, exec)
messenger := messenger.NewMockedMessenger()
driver.messenger = messenger
messenger.On("Start").Return(nil)
messenger.On("UPID").Return(upid.UPID{})
messenger.On("Send").Return(nil)
messenger.On("Stop").Return(nil)
checker := healthchecker.NewMockedHealthChecker()
checker.On("Start").Return()
checker.On("Stop").Return()
assert.False(t, driver.Running())
status, err := driver.Start()
assert.True(t, driver.Running())
assert.NoError(t, err)
assert.Equal(t, mesosproto.Status_DRIVER_RUNNING, status)
messenger.AssertNumberOfCalls(t, "Start", 1)
messenger.AssertNumberOfCalls(t, "UPID", 1)
messenger.AssertNumberOfCalls(t, "Send", 1)
}
func (suite *SchedulerTestSuite) TestSchdulerDriverLunchTasksUnstarted() {
sched := NewMockScheduler()
sched.On("Error").Return()
// Set expections and return values.
messenger := messenger.NewMockedMessenger()
messenger.On("Route").Return(nil)
messenger.On("Install").Return(nil)
driver := newTestSchedulerDriver(suite.T(), driverConfigMessenger(sched, suite.framework, suite.master, nil, messenger))
stat, err := driver.LaunchTasks(
[]*mesos.OfferID{{}},
[]*mesos.TaskInfo{},
&mesos.Filters{},
)
suite.Error(err)
suite.Equal(mesos.Status_DRIVER_NOT_STARTED, stat)
}
func (suite *SchedulerTestSuite) TestSchedulerDriverStartWithMessengerFailure() {
sched := NewMockScheduler()
sched.On("Error").Return()
messenger := messenger.NewMockedMessenger()
messenger.On("Start").Return(fmt.Errorf("Failed to start messenger"))
messenger.On("Stop").Return(nil)
messenger.On("Install").Return(nil)
driver := newTestSchedulerDriver(suite.T(), driverConfigMessenger(sched, suite.framework, suite.master, nil, messenger))
suite.False(driver.Running())
stat, err := driver.Start()
suite.Error(err)
suite.False(driver.Running())
suite.False(driver.Connected())
suite.Equal(mesos.Status_DRIVER_NOT_STARTED, driver.Status())
suite.Equal(mesos.Status_DRIVER_NOT_STARTED, stat)
}
func TestExecutorDriverStartFailedToStartMessenger(t *testing.T) {
exec := NewMockedExecutor()
setEnvironments(t, "", false)
driver := newTestExecutorDriver(t, exec)
assert.NotNil(t, driver)
messenger := messenger.NewMockedMessenger()
driver.messenger = messenger
// Set expections and return values.
messenger.On("Start").Return(fmt.Errorf("messenger failed to start"))
messenger.On("Stop").Return(nil)
status, err := driver.Start()
assert.Error(t, err)
assert.Equal(t, mesosproto.Status_DRIVER_NOT_STARTED, status)
messenger.Stop()
messenger.AssertNumberOfCalls(t, "Start", 1)
messenger.AssertNumberOfCalls(t, "Stop", 1)
}
func createTestExecutorDriver(t *testing.T) (
*testExecutorDriver,
*messenger.MockedMessenger,
*healthchecker.MockedHealthChecker) {
exec := NewMockedExecutor()
exec.On("Error").Return(nil)
setEnvironments(t, "", false)
driver := newTestExecutorDriver(t, exec)
messenger := messenger.NewMockedMessenger()
messenger.On("Start").Return(nil)
messenger.On("UPID").Return(upid.UPID{})
messenger.On("Send").Return(nil)
messenger.On("Stop").Return(nil)
checker := healthchecker.NewMockedHealthChecker()
checker.On("Start").Return()
checker.On("Stop").Return()
driver.messenger = messenger
return &testExecutorDriver{driver}, messenger, checker
}
func TestExecutorDriverJoin(t *testing.T) {
setEnvironments(t, "", false)
// Set expections and return values.
messenger := messenger.NewMockedMessenger()
messenger.On("Start").Return(nil)
messenger.On("UPID").Return(upid.UPID{})
messenger.On("Send").Return(nil)
messenger.On("Stop").Return(nil)
exec := NewMockedExecutor()
exec.On("Error").Return(nil)
driver := newTestExecutorDriver(t, exec)
driver.messenger = messenger
assert.False(t, driver.Running())
checker := healthchecker.NewMockedHealthChecker()
checker.On("Start").Return()
checker.On("Stop").Return()
stat, err := driver.Start()
assert.NoError(t, err)
assert.True(t, driver.Running())
assert.Equal(t, mesosproto.Status_DRIVER_RUNNING, stat)
testCh := make(chan mesosproto.Status)
go func() {
stat, _ := driver.Join()
testCh <- stat
}()
driver.Stop()
stat = <-testCh // when Stop() is called, stat will be DRIVER_STOPPED.
assert.Equal(t, mesosproto.Status_DRIVER_STOPPED, stat)
}
