func (suite *SchedulerTestSuite) TestSchdulerDriverAbort() { // 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) messenger.On("Route").Return(nil) driver := newTestSchedulerDriver(suite.T(), NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.True(driver.Stopped()) go func() { stat, err := driver.Run() suite.NoError(err) suite.Equal(mesos.Status_DRIVER_ABORTED, stat) }() time.Sleep(time.Millisecond * 1) driver.setConnected(true) // simulated suite.False(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) stat, err := driver.Abort() time.Sleep(time.Millisecond * 1) suite.NoError(err) suite.True(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_ABORTED, stat) suite.Equal(mesos.Status_DRIVER_ABORTED, driver.Status()) }
func (suite *SchedulerTestSuite) TestSchedulerDriverJoinOK() { // 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) driver := newTestSchedulerDriver(suite.T(), NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.True(driver.Stopped()) stat, err := driver.Start() suite.NoError(err) suite.Equal(mesos.Status_DRIVER_RUNNING, stat) suite.False(driver.Stopped()) testCh := make(chan mesos.Status) go func() { stat, _ := driver.Join() testCh <- stat }() close(driver.stopCh) // manually stopping stat = <-testCh // when Stop() is called, stat will be DRIVER_STOPPED. }
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()) 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) }
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) 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) 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) driver := newTestSchedulerDriver(suite.T(), sched, suite.framework, suite.master, nil) driver.messenger = messenger suite.True(driver.Stopped()) // 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.False(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) // stop the driver, should not panic! driver.Stop(false) // not failing over suite.True(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_STOPPED, driver.Status()) messenger.AssertExpectations(suite.T()) }
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()) 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) TestSchedulerDriverRun() { // 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) driver := newTestSchedulerDriver(suite.T(), NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.True(driver.Stopped()) go func() { stat, err := driver.Run() suite.NoError(err) suite.Equal(mesos.Status_DRIVER_STOPPED, stat) }() time.Sleep(time.Millisecond * 1) suite.False(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) // close it all. driver.setStatus(mesos.Status_DRIVER_STOPPED) close(driver.stopCh) time.Sleep(time.Millisecond * 1) }
func (suite *SchedulerTestSuite) TestSchdulerDriverStop_WithoutFailover() { // Set expections and return values. messenger := &msgTracker{MockedMessenger: messenger.NewMockedMessenger()} messenger.On("Start").Return(nil) messenger.On("UPID").Return(&upid.UPID{}) messenger.On("Send").Return(nil) messenger.On("Stop").Return(nil) messenger.On("Route").Return(nil) driver := newTestSchedulerDriver(suite.T(), NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.True(driver.Stopped()) go func() { stat, err := driver.Run() suite.NoError(err) suite.Equal(mesos.Status_DRIVER_STOPPED, stat) }() time.Sleep(time.Millisecond * 1) suite.False(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) driver.connected = true // pretend that we're already registered driver.Stop(false) msg := messenger.lastMessage suite.NotNil(msg) _, isUnregMsg := msg.(proto.Message) suite.True(isUnregMsg, "expected UnregisterFrameworkMessage instead of %+v", msg) suite.True(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_STOPPED, driver.Status()) }
func (suite *SchedulerTestSuite) TestSchdulerDriverReconcileTasks() { messenger := messenger.NewMockedMessenger() messenger.On("Start").Return(nil) messenger.On("UPID").Return(&upid.UPID{}) messenger.On("Send").Return(nil) messenger.On("Stop").Return(nil) messenger.On("Route").Return(nil) driver, err := newTestSchedulerDriver(NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.NoError(err) suite.True(driver.Stopped()) driver.Start() driver.setConnected(true) // simulated suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) stat, err := driver.ReconcileTasks( []*mesos.TaskStatus{ util.NewTaskStatus(util.NewTaskID("test-task-001"), mesos.TaskState_TASK_FINISHED), }, ) suite.NoError(err) suite.Equal(mesos.Status_DRIVER_RUNNING, stat) }
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.True(t, driver.stopped) checker := healthchecker.NewMockedHealthChecker() checker.On("Start").Return() checker.On("Stop").Return() go func() { stat, err := driver.Run() assert.NoError(t, err) assert.Equal(t, mesosproto.Status_DRIVER_STOPPED, stat) }() time.Sleep(time.Millisecond * 1) // allow for things to settle assert.False(t, driver.Stopped()) assert.Equal(t, mesosproto.Status_DRIVER_RUNNING, driver.Status()) // mannually close it all driver.setStatus(mesosproto.Status_DRIVER_STOPPED) close(driver.stopCh) time.Sleep(time.Millisecond * 1) }
func (suite *SchedulerTestSuite) TestSchdulerDriverSendFrameworkMessage() { messenger := messenger.NewMockedMessenger() messenger.On("Start").Return(nil) messenger.On("UPID").Return(&upid.UPID{}) messenger.On("Send").Return(nil) messenger.On("Stop").Return(nil) messenger.On("Route").Return(nil) driver, err := newTestSchedulerDriver(NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.NoError(err) suite.True(driver.Stopped()) driver.Start() driver.setConnected(true) // simulated suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) stat, err := driver.SendFrameworkMessage( util.NewExecutorID("test-exec-001"), util.NewSlaveID("test-slave-001"), "Hello!", ) suite.NoError(err) suite.Equal(mesos.Status_DRIVER_RUNNING, stat) }
func (suite *SchedulerTestSuite) TestSchdulerDriverKillTask() { messenger := messenger.NewMockedMessenger() messenger.On("Start").Return(nil) messenger.On("UPID").Return(&upid.UPID{}) messenger.On("Send").Return(nil) messenger.On("Stop").Return(nil) messenger.On("Route").Return(nil) driver, err := newTestSchedulerDriver(NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.NoError(err) suite.True(driver.Stopped()) go func() { driver.Run() }() time.Sleep(time.Millisecond * 1) driver.setConnected(true) // simulated suite.False(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) stat, err := driver.KillTask(util.NewTaskID("test-task-1")) suite.NoError(err) suite.Equal(mesos.Status_DRIVER_RUNNING, stat) }
func (suite *SchedulerTestSuite) TestSchdulerDriverRequestResources() { messenger := messenger.NewMockedMessenger() messenger.On("Start").Return(nil) messenger.On("UPID").Return(&upid.UPID{}) messenger.On("Send").Return(nil) messenger.On("Stop").Return(nil) messenger.On("Route").Return(nil) driver := newTestSchedulerDriver(suite.T(), NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.True(driver.Stopped()) driver.Start() driver.setConnected(true) // simulated suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) stat, err := driver.RequestResources( []*mesos.Request{ { SlaveId: util.NewSlaveID("test-slave-001"), Resources: []*mesos.Resource{ util.NewScalarResource("test-res-001", 33.00), }, }, }, ) suite.NoError(err) suite.Equal(mesos.Status_DRIVER_RUNNING, stat) }
func (suite *SchedulerTestSuite) TestSchdulerDriverStopOK() { // 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) messenger.On("Route").Return(nil) driver, err := newTestSchedulerDriver(NewMockScheduler(), suite.framework, suite.master, nil) suite.NotNil(driver, "expected valid driver") suite.NoError(err) driver.messenger = messenger suite.NoError(err) suite.True(driver.Stopped()) go func() { stat, err := driver.Run() suite.NoError(err) suite.Equal(mesos.Status_DRIVER_STOPPED, stat) }() time.Sleep(time.Millisecond * 1) suite.False(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) driver.Stop(false) time.Sleep(time.Millisecond * 1) suite.True(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_STOPPED, driver.Status()) }
func mockedMessenger() *messenger.MockedMessenger { m := messenger.NewMockedMessenger() m.On("Start").Return(nil) m.On("UPID").Return(upid.UPID{}) m.On("Send").Return(nil) m.On("Stop").Return(nil) m.On("Route").Return(nil) m.On("Install").Return(nil) return m }
func (suite *SchedulerTestSuite) TestSchedulerDriverStartOK() { sched := NewMockScheduler() messenger := messenger.NewMockedMessenger() messenger.On("Start").Return(nil) messenger.On("UPID").Return(&upid.UPID{}) messenger.On("Send").Return(nil) messenger.On("Stop").Return(nil) driver := newTestSchedulerDriver(suite.T(), sched, suite.framework, suite.master, nil) driver.messenger = messenger suite.True(driver.Stopped()) stat, err := driver.Start() suite.NoError(err) suite.Equal(mesos.Status_DRIVER_RUNNING, stat) suite.False(driver.Stopped()) }
func createTestExecutorDriver(t *testing.T) ( *testExecutorDriver, *messenger.MockedMessenger) { 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) driver.messenger = messenger return &testExecutorDriver{driver}, messenger }
func (suite *SchedulerTestSuite) TestSchdulerDriverLaunchTasksUnstarted() { 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 (suite *SchedulerTestSuite) TestSchdulerDriverReviveOffers() { messenger := messenger.NewMockedMessenger() messenger.On("Start").Return(nil) messenger.On("UPID").Return(&upid.UPID{}) messenger.On("Send").Return(nil) messenger.On("Stop").Return(nil) messenger.On("Route").Return(nil) driver := newTestSchedulerDriver(suite.T(), NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.True(driver.Stopped()) driver.Start() driver.setConnected(true) // simulated suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) stat, err := driver.ReviveOffers() suite.NoError(err) suite.Equal(mesos.Status_DRIVER_RUNNING, stat) }
func (suite *SchedulerTestSuite) TestSchdulerDriverStop_WithFailover() { // Set expections and return values. messenger := &msgTracker{MockedMessenger: messenger.NewMockedMessenger()} messenger.On("Start").Return(nil) messenger.On("UPID").Return(&upid.UPID{}) messenger.On("Send").Return(nil) messenger.On("Stop").Return(nil) messenger.On("Route").Return(nil) driver := newTestSchedulerDriver(suite.T(), NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.True(driver.Stopped()) stat, err := driver.Start() suite.NoError(err) suite.Equal(mesos.Status_DRIVER_RUNNING, stat) suite.False(driver.Stopped()) driver.connected = true // pretend that we're already registered go func() { // Run() blocks until the driver is stopped or aborted stat, err := driver.Join() suite.NoError(err) suite.Equal(mesos.Status_DRIVER_STOPPED, stat) }() // wait for Join() to begin blocking (so that it has already validated the driver state) time.Sleep(200 * time.Millisecond) driver.Stop(true) // true = scheduler failover msg := messenger.lastMessage // we're expecting that lastMessage is nil because when failing over there's no // 'unregister' message sent by the scheduler. suite.Nil(msg) suite.True(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_STOPPED, driver.Status()) }
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 (suite *SchedulerTestSuite) TestSchdulerDriverLaunchTasks() { messenger := messenger.NewMockedMessenger() messenger.On("Start").Return(nil) messenger.On("UPID").Return(&upid.UPID{}) messenger.On("Send").Return(nil) messenger.On("Stop").Return(nil) messenger.On("Route").Return(nil) driver, err := newTestSchedulerDriver(NewMockScheduler(), suite.framework, suite.master, nil) driver.messenger = messenger suite.NoError(err) suite.True(driver.Stopped()) go func() { driver.Run() }() time.Sleep(time.Millisecond * 1) driver.setConnected(true) // simulated suite.False(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) task := util.NewTaskInfo( "simple-task", util.NewTaskID("simpe-task-1"), util.NewSlaveID("slave-1"), []*mesos.Resource{util.NewScalarResource("mem", 400)}, ) task.Command = util.NewCommandInfo("pwd") tasks := []*mesos.TaskInfo{task} stat, err := driver.LaunchTasks( []*mesos.OfferID{&mesos.OfferID{}}, tasks, &mesos.Filters{}, ) suite.NoError(err) suite.Equal(mesos.Status_DRIVER_RUNNING, stat) }
func createTestExecutorDriver(t *testing.T) ( *MesosExecutorDriver, *messenger.MockedMessenger, *healthchecker.MockedHealthChecker) { exec := NewMockedExecutor() 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 driver, messenger, checker }
func TestAuthticatee_validLogin(t *testing.T) { assert := assert.New(t) ctx := context.TODO() client := upid.UPID{ ID: "someFramework", Host: "b.net", Port: "789", } server := upid.UPID{ ID: "serv", Host: "a.com", Port: "123", } tpid := upid.UPID{ ID: "sasl_transport", Host: "g.org", Port: "456", } handler := callback.HandlerFunc(func(cb ...callback.Interface) error { for _, c := range cb { switch c := c.(type) { case *callback.Name: c.Set("foo") case *callback.Password: c.Set([]byte("bar")) case *callback.Interprocess: c.Set(server, client) default: return &callback.Unsupported{Callback: c} } } return nil }) var transport *MockTransport factory := transportFactoryFunc(func() messenger.Messenger { transport = &MockTransport{messenger.NewMockedMessenger()} transport.On("Install").Return(nil) transport.On("UPID").Return(&tpid) transport.On("Start").Return(nil) transport.On("Stop").Return(nil) transport.On("Send", mock.Anything, &server, &mesos.AuthenticateMessage{ Pid: proto.String(client.String()), }).Return(nil).Run(func(_ mock.Arguments) { transport.Recv(&server, &mesos.AuthenticationMechanismsMessage{ Mechanisms: []string{crammd5.Name}, }) }).Once() transport.On("Send", mock.Anything, &server, &mesos.AuthenticationStartMessage{ Mechanism: proto.String(crammd5.Name), Data: proto.String(""), // may be nil, depends on init step }).Return(nil).Run(func(_ mock.Arguments) { transport.Recv(&server, &mesos.AuthenticationStepMessage{ Data: []byte(`lsd;lfkgjs;dlfkgjs;dfklg`), }) }).Once() transport.On("Send", mock.Anything, &server, &mesos.AuthenticationStepMessage{ Data: []byte(`foo cc7fd96cd80123ea844a7dba29a594ed`), }).Return(nil).Run(func(_ mock.Arguments) { transport.Recv(&server, &mesos.AuthenticationCompletedMessage{}) }).Once() return transport }) login, err := makeAuthenticatee(handler, factory) assert.Nil(err) err = login.Authenticate(ctx, handler) assert.Nil(err) assert.NotNil(transport) time.Sleep(1 * time.Second) // wait for the authenticator to shut down transport.AssertExpectations(t) }
func (suite *SchedulerTestSuite) TestSchdulerDriverLaunchTasksWithError() { sched := NewMockScheduler() sched.On("StatusUpdate").Return(nil) sched.On("Error").Return() msgr := messenger.NewMockedMessenger() msgr.On("Start").Return(nil) msgr.On("Send").Return(nil) msgr.On("UPID").Return(&upid.UPID{}) msgr.On("Stop").Return(nil) msgr.On("Route").Return(nil) driver := newTestSchedulerDriver(suite.T(), sched, suite.framework, suite.master, nil) driver.messenger = msgr suite.True(driver.Stopped()) go func() { driver.Run() }() time.Sleep(time.Millisecond * 1) driver.setConnected(true) // simulated suite.False(driver.Stopped()) suite.Equal(mesos.Status_DRIVER_RUNNING, driver.Status()) // to trigger error msgr2 := messenger.NewMockedMessenger() msgr2.On("Start").Return(nil) msgr2.On("UPID").Return(&upid.UPID{}) msgr2.On("Send").Return(fmt.Errorf("Unable to send message")) msgr2.On("Stop").Return(nil) msgr.On("Route").Return(nil) driver.messenger = msgr2 // setup an offer offer := util.NewOffer( util.NewOfferID("test-offer-001"), suite.framework.Id, util.NewSlaveID("test-slave-001"), "test-slave(1)@localhost:5050", ) pid, err := upid.Parse("test-slave(1)@localhost:5050") suite.NoError(err) driver.cache.putOffer(offer, pid) // launch task task := util.NewTaskInfo( "simple-task", util.NewTaskID("simpe-task-1"), util.NewSlaveID("test-slave-001"), []*mesos.Resource{util.NewScalarResource("mem", 400)}, ) task.Command = util.NewCommandInfo("pwd") task.Executor = util.NewExecutorInfo(util.NewExecutorID("test-exec"), task.Command) tasks := []*mesos.TaskInfo{task} stat, err := driver.LaunchTasks( []*mesos.OfferID{offer.Id}, tasks, &mesos.Filters{}, ) suite.Error(err) suite.Equal(mesos.Status_DRIVER_RUNNING, stat) }