func TestExecutorDriverJoin(t *testing.T) {
setEnvironments(t, "", false)
// Set expections and return values.
messenger := mock_messenger.NewMessenger()
messenger.On("Start").Return(nil)
messenger.On("UPID").Return(upid.UPID{})
messenger.On("Send").Return(nil)
messenger.On("Stop").Return(nil)
exec := mock_executor.New()
exec.On("Error").Return(nil)
driver := newTestExecutorDriver(t, exec)
driver.SetMessenger(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 (suite *SchedulerTestSuite) TestSchedulerDriverStartWithRegistrationFailure() {
sched := mock_scheduler.New()
sched.On("Error").Return()
// Set expections and return values.
messenger := mock_messenger.NewMessenger()
messenger.On("Start").Return(nil)
messenger.On("UPID").Return(upid.UPID{})
messenger.On("Stop").Return(nil)
messenger.On("Install").Return(nil)
driver := newTestDriver(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 TestExecutorDriverRun(t *testing.T) {
setEnvironments(t, "", false)
// Set expections and return values.
messenger := mock_messenger.NewMessenger()
messenger.On("Start").Return(nil)
messenger.On("UPID").Return(upid.UPID{})
messenger.On("Send").Return(nil)
messenger.On("Stop").Return(nil)
exec := mock_executor.New()
exec.On("Error").Return(nil)
driver := newTestExecutorDriver(t, exec)
driver.SetMessenger(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 TestExecutorDriverStartSucceed(t *testing.T) {
setEnvironments(t, "", false)
exec := mock_executor.New()
exec.On("Error").Return(nil)
driver := newTestExecutorDriver(t, exec)
messenger := mock_messenger.NewMessenger()
driver.SetMessenger(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 mockedMessenger() *mock_messenger.Messenger {
m := mock_messenger.NewMessenger()
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) TestSchdulerDriverLaunchTasksUnstarted() {
sched := mock_scheduler.New()
sched.On("Error").Return()
// Set expections and return values.
messenger := mock_messenger.NewMessenger()
messenger.On("Route").Return(nil)
messenger.On("Install").Return(nil)
driver := newTestDriver(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 := mock_scheduler.New()
sched.On("Error").Return()
messenger := mock_messenger.NewMessenger()
messenger.On("Start").Return(fmt.Errorf("Failed to start messenger"))
messenger.On("Stop").Return(nil)
messenger.On("Install").Return(nil)
driver := newTestDriver(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 createTestExecutorDriver(t *testing.T) (
*TestDriver,
*mock_messenger.Messenger) {
exec := mock_executor.New()
exec.On("Error").Return(nil)
setEnvironments(t, "", false)
driver := newTestExecutorDriver(t, exec)
messenger := mock_messenger.NewMessenger()
messenger.On("Start").Return(nil)
messenger.On("UPID").Return(upid.UPID{})
messenger.On("Send").Return(nil)
messenger.On("Stop").Return(nil)
driver.SetMessenger(messenger)
return driver, messenger
}
func TestExecutorDriverStartFailedToStartMessenger(t *testing.T) {
exec := mock_executor.New()
setEnvironments(t, "", false)
driver := newTestExecutorDriver(t, exec)
assert.NotNil(t, driver)
messenger := mock_messenger.NewMessenger()
driver.SetMessenger(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 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 *mock_sasl.Transport
factory := transportFactoryFunc(func() messenger.Messenger {
transport = &mock_sasl.Transport{mock_messenger.NewMessenger()}
transport.On("Install").Return(nil)
transport.On("UPID").Return(tpid)
transport.On("Start").Return(nil)
transport.On("Stop").Return(nil)
mechMsg := make(chan struct{})
stepMsg := make(chan struct{})
transport.On("Send", mock.Anything, &server, &mesos.AuthenticateMessage{
Pid: proto.String(client.String()),
}).Return(nil).Run(func(_ mock.Arguments) {
defer close(mechMsg)
transport.Recv(&server, &mesos.AuthenticationMechanismsMessage{
Mechanisms: []string{crammd5.Name},
})
}).Once()
transport.On("Send", mock.Anything, &server, &mesos.AuthenticationStartMessage{
Mechanism: proto.String(crammd5.Name),
}).Return(nil).Run(func(_ mock.Arguments) {
defer close(stepMsg)
<-mechMsg
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) {
<-stepMsg
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)
}