func TestGitPlugin(t *testing.T) {
Convey("With git plugin installed into plugin registry", t, func() {
registry := plugin.NewSimpleRegistry()
gitPlugin := &GitPlugin{}
err := registry.Register(gitPlugin)
testutil.HandleTestingErr(err, t, "Couldn't register plugin: %v")
server, err := apiserver.CreateTestServer(evergreen.TestConfig(), nil, plugin.Published, false)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom := plugintest.TestAgentCommunicator("mocktaskid", "mocktasksecret", server.URL)
taskConfig, err := plugintest.CreateTestConfig("testdata/plugin_clone.yml", t)
testutil.HandleTestingErr(err, t, "failed to create test config")
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
Convey("all commands in test project should execute successfully", func() {
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{pluginCmds[0].Plugin(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
}
}
err = os.RemoveAll(taskConfig.WorkDir)
testutil.HandleTestingErr(err, t, "Couldn't clean up test temp dir")
})
})
}
func TestHeartbeatSignals(t *testing.T) {
setupTlsConfigs(t)
for tlsString, tlsConfig := range tlsConfigs {
testTask, _, err := setupAPITestData(testConfig, evergreen.CompileStage, "linux-64", NoPatch, t)
testutil.HandleTestingErr(err, t, "Couldn't make test data: %v", err)
Convey("With a live api server, agent, and test task over "+tlsString, t, func() {
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
testAgent.heartbeater.Interval = 100 * time.Millisecond
testAgent.StartBackgroundActions(&NoopSignalHandler{})
Convey("killing the server should result in failure signal", func() {
testServer.Listener.Close()
signal, ok := <-testAgent.signalHandler.heartbeatChan
So(ok, ShouldBeTrue)
So(signal, ShouldEqual, HeartbeatMaxFailed)
})
})
}
}
func TestTaskExecTimeout(t *testing.T) {
setupTlsConfigs(t)
for tlsString, tlsConfig := range tlsConfigs {
Convey("With agent running a slow test and live API server over "+tlsString, t, func() {
testTask, _, err := setupAPITestData(testConfig, "exec_timeout_task", "linux-64", NoPatch, t)
testutil.HandleTestingErr(err, t, "Failed to find test task")
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := New(testServer.URL, testTask.Id, testTask.Secret, "", testConfig.Expansions["api_httpscert"])
So(err, ShouldBeNil)
So(testAgent, ShouldNotBeNil)
Convey("after the slow test runs beyond the timeout threshold", func() {
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
testAgent.APILogger.Flush()
time.Sleep(5 * time.Second)
printLogsForTask(testTask.Id)
Convey("the test should be marked as failed and timed out", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the task-timeout script!"), ShouldBeTrue)
testTask, err = model.FindTask(testTask.Id)
So(testTask.Status, ShouldEqual, evergreen.TaskFailed)
So(testTask.Details.TimedOut, ShouldBeTrue)
So(testTask.Details.Description, ShouldEqual, "shell.exec")
})
})
})
}
}
func TestAgentDebugHandler(t *testing.T) {
setupTlsConfigs(t)
for tlsString, tlsConfig := range tlsConfigs {
Convey("With an agent that has not been started", t, func() {
testAgent, err := New("", "task1", "task1", "", testConfig.Api.HttpsCert)
So(err, ShouldBeNil)
Convey("no task or command should be listed", func() {
task, command := taskAndCommand(testAgent)
So(task, ShouldEqual, "no running task")
So(command, ShouldEqual, "no running command")
})
})
Convey("With agent running a slow test and live API server over "+tlsString, t, func() {
testTask, _, err := setupAPITestData(testConfig, "timeout_task", "linux-64", "testdata/config_test_plugin/project/evergreen-ci-render.yml", NoPatch, t)
testutil.HandleTestingErr(err, t, "Failed to find test task")
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := New(testServer.URL, testTask.Id, testTask.Secret, "", testConfig.Api.HttpsCert)
So(err, ShouldBeNil)
So(testAgent, ShouldNotBeNil)
Convey("the agent should return the correct running task, command, and trace", func() {
// run the slow task and take a debug trace during.
var stack []byte
var task, command string
go func() {
time.Sleep(time.Second)
task, command = taskAndCommand(testAgent)
stack = trace()
dumpToLogs(task, command, stack, testAgent)
}()
testAgent.RunTask()
testAgent.APILogger.Flush()
time.Sleep(5 * time.Second)
So(task, ShouldEqual, testTask.Id)
So(command, ShouldEqual, "shell.exec")
// we need to check for two kinds of stacktrace forms, to support GC and GCCGO traces
gcExecute := "(*ShellExecCommand).Execute"
gccExecute := "evergreen_plugin_builtin_shell.Execute"
gcAgent := "(*Agent).RunTask"
gccAgent := "agent.Agent"
executeIdx := strings.Index(string(stack), gcExecute) + strings.Index(string(stack), gccExecute)
So(executeIdx, ShouldBeGreaterThan, 0)
agentIdx := strings.Index(string(stack), gcAgent) + strings.Index(string(stack), gccAgent)
So(agentIdx, ShouldBeGreaterThan, 0)
Convey("which should also be present in the logs", func() {
So(
scanLogsForTask(testTask.Id, gcExecute) || scanLogsForTask(testTask.Id, gccExecute),
ShouldBeTrue,
)
So(
scanLogsForTask(testTask.Id, gcAgent) || scanLogsForTask(testTask.Id, gccAgent),
ShouldBeTrue,
)
})
})
})
}
}
func TestPatchPluginAPI(t *testing.T) {
testConfig := evergreen.TestConfig()
Convey("With a running api server and installed plugin", t, func() {
registry := plugin.NewSimpleRegistry()
gitPlugin := &GitPlugin{}
err := registry.Register(gitPlugin)
testutil.HandleTestingErr(err, t, "Couldn't register patch plugin")
server, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, false)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
taskConfig, _ := plugintest.CreateTestConfig("testdata/plugin_patch.yml", t)
testCommand := GitApplyPatchCommand{"dir"}
_, _, err = plugintest.SetupAPITestData("testTask", true, t)
testutil.HandleTestingErr(err, t, "Couldn't set up test documents")
testTask, err := task.FindOne(task.ById("testTaskId"))
testutil.HandleTestingErr(err, t, "Couldn't set up test patch task")
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
Convey("calls to existing tasks with patches should succeed", func() {
httpCom := plugintest.TestAgentCommunicator(testTask.Id, testTask.Secret, server.URL)
pluginCom := &agent.TaskJSONCommunicator{gitPlugin.Name(), httpCom}
patch, err := testCommand.GetPatch(taskConfig, pluginCom, logger)
So(err, ShouldBeNil)
So(patch, ShouldNotBeNil)
testutil.HandleTestingErr(db.Clear(version.Collection), t,
"unable to clear versions collection")
})
Convey("calls to non-existing tasks should fail", func() {
v := version.Version{Id: ""}
testutil.HandleTestingErr(v.Insert(), t, "Couldn't insert dummy version")
httpCom := plugintest.TestAgentCommunicator("BAD_TASK_ID", "", server.URL)
pluginCom := &agent.TaskJSONCommunicator{gitPlugin.Name(), httpCom}
patch, err := testCommand.GetPatch(taskConfig, pluginCom, logger)
So(err.Error(), ShouldContainSubstring, "not found")
So(err, ShouldNotBeNil)
So(patch, ShouldBeNil)
testutil.HandleTestingErr(db.Clear(version.Collection), t,
"unable to clear versions collection")
})
Convey("calls to existing tasks without patches should fail", func() {
noPatchTask := task.Task{Id: "noPatchTask", BuildId: "a"}
testutil.HandleTestingErr(noPatchTask.Insert(), t, "Couldn't insert patch task")
noPatchVersion := version.Version{Id: "noPatchVersion", BuildIds: []string{"a"}}
testutil.HandleTestingErr(noPatchVersion.Insert(), t, "Couldn't insert patch version")
v := version.Version{Id: ""}
testutil.HandleTestingErr(v.Insert(), t, "Couldn't insert dummy version")
httpCom := plugintest.TestAgentCommunicator(noPatchTask.Id, "", server.URL)
pluginCom := &agent.TaskJSONCommunicator{gitPlugin.Name(), httpCom}
patch, err := testCommand.GetPatch(taskConfig, pluginCom, logger)
So(err, ShouldNotBeNil)
So(err.Error(), ShouldContainSubstring, "no patch found for task")
So(patch, ShouldBeNil)
testutil.HandleTestingErr(db.Clear(version.Collection), t,
"unable to clear versions collection")
})
})
}
func TestPatchTask(t *testing.T) {
setupTlsConfigs(t)
testConfig := evergreen.TestConfig()
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
patchModes := []patchTestMode{InlinePatch, ExternalPatch}
testutil.ConfigureIntegrationTest(t, testConfig, "TestPatchTask")
for tlsString, tlsConfig := range tlsConfigs {
for _, testSetup := range testSetups {
Convey(testSetup.testSpec, t, func() {
Convey("With agent running a patched 'compile'"+tlsString, func() {
for _, mode := range patchModes {
Convey(fmt.Sprintf("Using patch mode %v", mode.String()), func() {
testTask, b, err := setupAPITestData(testConfig, "compile", "linux-64", "testdata/config_test_plugin/project/evergreen-ci-render.yml", mode, t)
githash := "1e5232709595db427893826ce19289461cba3f75"
setupPatches(mode, b, t,
patchRequest{"", "testdata/test.patch", githash},
patchRequest{"recursive", "testdata/testmodule.patch", githash})
testutil.HandleTestingErr(err, t, "Error setting up test data: %v", err)
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := New(testServer.URL, testTask.Id, testTask.Secret, "", testConfig.Api.HttpsCert)
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
printLogsForTask(testTask.Id)
Convey("all scripts in task should have been run successfully", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "Cloning into") || // git 1.8
scanLogsForTask(testTask.Id, "Initialized empty Git repository"), // git 1.7
ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am patched!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am a patched module"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am compiling!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am sanity testing!"), ShouldBeTrue)
testTask, err = task.FindOne(task.ById(testTask.Id))
testutil.HandleTestingErr(err, t, "Error finding test task: %v", err)
So(testTask.Status, ShouldEqual, evergreen.TaskSucceeded)
})
})
}
})
})
}
}
}
func TestS3CopyPluginExecution(t *testing.T) {
testConfig := evergreen.TestConfig()
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
testutil.ConfigureIntegrationTest(t, testConfig, "TestS3CopyPluginExecution")
Convey("With a SimpleRegistry and test project file", t, func() {
registry := plugin.NewSimpleRegistry()
s3CopyPlugin := &S3CopyPlugin{}
testutil.HandleTestingErr(registry.Register(s3CopyPlugin), t, "failed to register s3Copy plugin")
testutil.HandleTestingErr(registry.Register(&s3Plugin.S3Plugin{}), t, "failed to register S3 plugin")
testutil.HandleTestingErr(
db.ClearCollections(model.PushlogCollection, version.Collection), t,
"error clearing test collections")
version := &version.Version{
Id: "",
}
So(version.Insert(), ShouldBeNil)
server, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, false)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom := plugintest.TestAgentCommunicator("mocktaskid", "mocktasksecret", server.URL)
//server.InstallPlugin(s3CopyPlugin)
taskConfig, err := plugintest.CreateTestConfig("testdata/plugin_s3_copy.yml", t)
testutil.HandleTestingErr(err, t, "failed to create test config: %v", err)
taskConfig.WorkDir = "."
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
taskConfig.Expansions.Update(map[string]string{
"aws_key": testConfig.Providers.AWS.Id,
"aws_secret": testConfig.Providers.AWS.Secret,
})
Convey("the s3 copy command should execute successfully", func() {
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{s3CopyPlugin.Name(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig,
make(chan bool))
So(err, ShouldBeNil)
}
}
})
})
}
func TestPluginFunctions(t *testing.T) {
testConfig := evergreen.TestConfig()
testutil.ConfigureIntegrationTest(t, testConfig, "TestPatchTask")
Convey("With a SimpleRegistry", t, func() {
Convey("with a project file containing functions", func() {
registry := plugin.NewSimpleRegistry()
err := registry.Register(&shell.ShellPlugin{})
testutil.HandleTestingErr(err, t, "Couldn't register plugin")
err = registry.Register(&expansions.ExpansionsPlugin{})
testutil.HandleTestingErr(err, t, "Couldn't register plugin")
testServer, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, false)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
taskConfig, err := createTestConfig("testdata/plugin_project_functions.yml", t)
testutil.HandleTestingErr(err, t, "failed to create test config: %v", err)
Convey("all commands in project file should parse successfully", func() {
for _, newTask := range taskConfig.Project.Tasks {
for _, command := range newTask.Commands {
pluginCmd, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Got error getting plugin command: %v")
So(pluginCmd, ShouldNotBeNil)
So(err, ShouldBeNil)
}
}
})
httpCom, err := agent.NewHTTPCommunicator(testServer.URL, "mocktaskid", "mocktasksecret", "", nil)
So(err, ShouldBeNil)
So(httpCom, ShouldNotBeNil)
Convey("all commands in test project should execute successfully", func() {
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
for _, newTask := range taskConfig.Project.Tasks {
So(len(newTask.Commands), ShouldNotEqual, 0)
for _, command := range newTask.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
So(len(pluginCmds), ShouldEqual, 1)
cmd := pluginCmds[0]
pluginCom := &agent.TaskJSONCommunicator{cmd.Plugin(), httpCom}
err = cmd.Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
}
}
})
})
})
}
func TestAttachResults(t *testing.T) {
resetTasks(t)
testConfig := evergreen.TestConfig()
Convey("With attachResults plugin installed into plugin registry", t, func() {
registry := plugin.NewSimpleRegistry()
attachPlugin := &AttachPlugin{}
err := registry.Register(attachPlugin)
testutil.HandleTestingErr(err, t, "Couldn't register plugin: %v")
server, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, true)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom := plugintest.TestAgentCommunicator("mocktaskid", "mocktasksecret", server.URL)
configFile := "testdata/plugin_attach_results.yml"
resultsLoc := "testdata/plugin_attach_results.json"
taskConfig, err := plugintest.CreateTestConfig(configFile, t)
testutil.HandleTestingErr(err, t, "failed to create test config: %v")
taskConfig.WorkDir = "."
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
Convey("all commands in test project should execute successfully", func() {
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{pluginCmds[0].Plugin(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
task, err := model.FindTask(httpCom.TaskId)
testutil.HandleTestingErr(err, t, "Couldn't find task")
So(task, ShouldNotBeNil)
// ensure test results are exactly as expected
// attempt to open the file
reportFile, err := os.Open(resultsLoc)
testutil.HandleTestingErr(err, t, "Couldn't open report file: '%v'", err)
results := &model.TestResults{}
err = util.ReadJSONInto(reportFile, results)
testutil.HandleTestingErr(err, t, "Couldn't read report file: '%v'", err)
testResults := *results
So(task.TestResults, ShouldResemble, testResults.Results)
testutil.HandleTestingErr(err, t, "Couldn't clean up test temp dir")
}
}
})
})
}
func TestTaskFailures(t *testing.T) {
setupTlsConfigs(t)
testutil.ConfigureIntegrationTest(t, testConfig, "TestTaskFailures")
for tlsString, tlsConfig := range tlsConfigs {
for _, testSetup := range testSetups {
Convey(testSetup.testSpec, t, func() {
Convey("With agent running a failing test and live API server over "+tlsString, func() {
testTask, _, err := setupAPITestData(testConfig, "failing_task",
"linux-64", NoPatch, t)
testutil.HandleTestingErr(err, t, "Couldn't create test data: %v", err)
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
printLogsForTask(testTask.Id)
Convey("the pre and post-run scripts should have run", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
Convey("the task should have run up until its first failure", func() {
So(scanLogsForTask(testTask.Id, "starting failing_task!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "done with failing_task!"), ShouldBeFalse)
})
Convey("the tasks's final status should be FAILED", func() {
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Failed to find test task")
So(testTask.Status, ShouldEqual, evergreen.TaskFailed)
So(testTask.Details.Status, ShouldEqual, evergreen.TaskFailed)
So(testTask.Details.Description, ShouldEqual, "failing shell command")
So(testTask.Details.TimedOut, ShouldBeFalse)
So(testTask.Details.Type, ShouldEqual, model.SystemCommandType)
})
})
})
})
}
}
}
func TestTaskAbortion(t *testing.T) {
setupTlsConfigs(t)
testutil.ConfigureIntegrationTest(t, testConfig, "TestTaskAbortion")
for tlsString, tlsConfig := range tlsConfigs {
for _, testSetup := range testSetups {
Convey(testSetup.testSpec, t, func() {
Convey("With agent running a slow test and live API server over "+tlsString, func() {
testTask, _, err := setupAPITestData(testConfig, "very_slow_task", "linux-64", NoPatch, t)
testutil.HandleTestingErr(err, t, "Failed to find test task")
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
Convey("when the abort signal is triggered on the task", func() {
go func() {
// Wait for a few seconds, then switch the task to aborted!
time.Sleep(3 * time.Second)
err := testTask.Abort("", true)
testutil.HandleTestingErr(err, t, "Failed to abort test task")
fmt.Println("aborted task.")
}()
// actually run the task.
// this function won't return until the whole thing is done.
_, err := testAgent.RunTask()
So(err, ShouldBeNil)
testAgent.APILogger.Flush()
time.Sleep(1 * time.Second)
printLogsForTask(testTask.Id)
Convey("the pre and post-run scripts should have run", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "Received abort signal - stopping."), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "done with very_slow_task!"), ShouldBeFalse)
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Failed to find test task")
So(testTask.Status, ShouldEqual, evergreen.TaskUndispatched)
})
})
})
})
}
}
}
func TestPatchTask(t *testing.T) {
setupTlsConfigs(t)
testConfig := evergreen.TestConfig()
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
testutil.ConfigureIntegrationTest(t, testConfig, "TestPatchTask")
for tlsString, tlsConfig := range tlsConfigs {
for _, testSetup := range testSetups {
Convey(testSetup.testSpec, t, func() {
Convey("With agent running a patched 'compile'"+tlsString, func() {
testTask, _, err := setupAPITestData(testConfig, "compile", "linux-64", true, t)
testutil.HandleTestingErr(err, t, "Error setting up test data: %v", err)
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.Published, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := New(testServer.URL, testTask.Id, testTask.Secret, "", testConfig.Expansions["api_httpscert"])
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
printLogsForTask(testTask.Id)
Convey("all scripts in task should have been run successfully", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "Cloning into") || // git 1.8
scanLogsForTask(testTask.Id, "Initialized empty Git repository"), // git 1.7
ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am patched!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am a patched module"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am compiling!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am sanity testing!"), ShouldBeTrue)
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Error finding test task: %v", err)
So(testTask.Status, ShouldEqual, evergreen.TaskSucceeded)
})
})
})
}
}
}
func TestGotestPluginWithEnvironmentVariables(t *testing.T) {
Convey("With gotest plugin installed into plugin registry", t, func() {
reset(t)
testConfig := evergreen.TestConfig()
testutil.ConfigureIntegrationTest(t, testConfig, "TestGotestPluginWithEnvironmentVariables")
registry := plugin.NewSimpleRegistry()
testPlugin := &GotestPlugin{}
err := registry.Register(testPlugin)
testutil.HandleTestingErr(err, t, "Couldn't register plugin %v")
server, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, true)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom := plugintest.TestAgentCommunicator("testTaskId", "testTaskSecret", server.URL)
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
Convey("test command should get a copy of custom environment variables", func() {
curWD, err := os.Getwd()
testutil.HandleTestingErr(err, t, "Couldn't get working directory: %v")
taskConfig, err := plugintest.CreateTestConfig("testdata/env.yml", t)
// manually override working directory to the main repo, since this
// is much easier than copying over the required testing dependencies
// to a temporary directory
testutil.HandleTestingErr(err, t, "Couldn't set up test config %v")
taskConfig.WorkDir = curWD
_, _, err = plugintest.SetupAPITestData("testTask", false, t)
testutil.HandleTestingErr(err, t, "Couldn't set up test documents")
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{pluginCmds[0].Plugin(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
}
}
})
})
}
func TestAgentDebugHandler(t *testing.T) {
setupTlsConfigs(t)
for tlsString, tlsConfig := range tlsConfigs {
Convey("With an agent that has not been started", t, func() {
testAgent, err := New("", "task1", "task1", "", testConfig.Expansions["api_httpscert"])
So(err, ShouldBeNil)
Convey("no task or command should be listed", func() {
task, command := taskAndCommand(testAgent)
So(task, ShouldEqual, "no running task")
So(command, ShouldEqual, "no running command")
})
})
Convey("With agent running a slow test and live API server over "+tlsString, t, func() {
testTask, _, err := setupAPITestData(testConfig, "timeout_task", "linux-64", NoPatch, t)
testutil.HandleTestingErr(err, t, "Failed to find test task")
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := New(testServer.URL, testTask.Id, testTask.Secret, "", testConfig.Expansions["api_httpscert"])
So(err, ShouldBeNil)
So(testAgent, ShouldNotBeNil)
Convey("the agent should return the correct running task, command, and trace", func() {
// run the slow task and take a debug trace during.
go func() {
time.Sleep(time.Second)
task, command := taskAndCommand(testAgent)
So(task, ShouldEqual, testTask.Id)
So(command, ShouldEqual, "shell.exec")
stack := trace()
So(strings.Index(string(stack), "(*ShellExecCommand).Execute"), ShouldBeGreaterThan, 0)
So(strings.Index(string(stack), "(*Agent).RunTask"), ShouldBeGreaterThan, 0)
dumpToLogs(task, command, stack, testAgent)
}()
testAgent.RunTask()
testAgent.APILogger.Flush()
time.Sleep(5 * time.Second)
Convey("which should also be present in the logs", func() {
So(scanLogsForTask(testTask.Id, "(*ShellExecCommand).Execute"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "(*Agent).RunTask"), ShouldBeTrue)
})
})
})
}
}
func TestTaskEndEndpoint(t *testing.T) {
setupTlsConfigs(t)
for tlsString, tlsConfig := range tlsConfigs {
testTask, _, err := setupAPITestData(testConfig, "random", "linux-64", NoPatch, t)
testutil.HandleTestingErr(err, t, "Couldn't make test data: %v", err)
Convey("With a live api server, agent, and test task over "+tlsString, t, func() {
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
testAgent.heartbeater.Interval = 10 * time.Second
testAgent.StartBackgroundActions(&NoopSignalHandler{})
Convey("calling end() should update task's/host's status properly "+
"and start running the next task", func() {
subsequentTaskId := testTask.Id + "Two"
details := &apimodels.TaskEndDetail{Status: evergreen.TaskSucceeded}
taskEndResp, err := testAgent.End(details)
time.Sleep(1 * time.Second)
So(err, ShouldBeNil)
taskUpdate, err := model.FindTask(testTask.Id)
So(err, ShouldBeNil)
So(taskUpdate.Status, ShouldEqual, evergreen.TaskSucceeded)
testHost, err := host.FindOne(host.ById(testTask.HostId))
So(err, ShouldBeNil)
So(testHost.RunningTask, ShouldEqual, subsequentTaskId)
taskUpdate, err = model.FindTask(subsequentTaskId)
So(err, ShouldBeNil)
So(taskUpdate.Status, ShouldEqual, evergreen.TaskDispatched)
So(taskEndResp, ShouldNotBeNil)
So(taskEndResp.RunNext, ShouldBeTrue)
So(taskEndResp.TaskId, ShouldEqual, subsequentTaskId)
})
})
}
}
func TestPluginExecution(t *testing.T) {
Convey("With a SimpleRegistry and test project file", t, func() {
registry := plugin.NewSimpleRegistry()
plugins := []plugin.CommandPlugin{&MockPlugin{}, &expansions.ExpansionsPlugin{}, &shell.ShellPlugin{}}
apiPlugins := []plugin.APIPlugin{&MockPlugin{}, &expansions.ExpansionsPlugin{}}
for _, p := range plugins {
err := registry.Register(p)
testutil.HandleTestingErr(err, t, "failed to register plugin")
}
testServer, err := apiserver.CreateTestServer(evergreen.TestConfig(), nil, apiPlugins, false)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom, err := agent.NewHTTPCommunicator(testServer.URL, "mocktaskid", "mocktasksecret", "", nil)
So(err, ShouldBeNil)
So(httpCom, ShouldNotBeNil)
taskConfig, err := createTestConfig("testdata/plugin_project.yml", t)
testutil.HandleTestingErr(err, t, "failed to create test config: %v", err)
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
Convey("all commands in test project should execute successfully", func() {
for _, newTask := range taskConfig.Project.Tasks {
So(len(newTask.Commands), ShouldNotEqual, 0)
for _, command := range newTask.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
for _, c := range pluginCmds {
pluginCom := &agent.TaskJSONCommunicator{c.Plugin(), httpCom}
err = c.Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
}
}
}
})
})
}
func TestTaskCallbackTimeout(t *testing.T) {
setupTlsConfigs(t)
for tlsString, tlsConfig := range tlsConfigs {
Convey("With an agent with callback_timeout_secs=1 and a live API server over "+tlsString, t, func() {
testTask, _, err := setupAPITestData(testConfig, "timeout_task", "linux-64", "testdata/config_test_plugin/project/evergreen-ci-render.yml", NoPatch, t)
testutil.HandleTestingErr(err, t, "Failed to find test task")
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := New(testServer.URL, testTask.Id, testTask.Secret, "", testConfig.Api.HttpsCert)
So(err, ShouldBeNil)
So(testAgent, ShouldNotBeNil)
prependConfigToVersion(t, testTask.Version, "callback_timeout_secs: 1\n")
Convey("after the slow test runs beyond the timeout threshold", func() {
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
testAgent.APILogger.Flush()
time.Sleep(7 * time.Second)
//printLogsForTask(testTask.Id)
So(testAgent.taskConfig.Project.CallbackTimeout, ShouldEqual, 1)
Convey("the test should be marked as failed and timed out", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the task-timeout script!"), ShouldBeTrue)
testTask, err = model.FindTask(testTask.Id)
So(testTask.Status, ShouldEqual, evergreen.TaskFailed)
So(testTask.Details.TimedOut, ShouldBeTrue)
So(testTask.Details.Description, ShouldEqual, "shell.exec")
Convey("and the timeout task should have failed", func() {
So(scanLogsForTask(testTask.Id, "running task-timeout commands in 1"), ShouldBeTrue)
})
})
})
})
}
}
// runTest abstracts away common tests and setup between all attach xunit tests.
// It also takes as an argument a function which runs any additional tests desired.
func runTest(t *testing.T, configPath string, customTests func()) {
resetTasks(t)
testConfig := evergreen.TestConfig()
Convey("With attachResults plugin installed into plugin registry", t, func() {
registry := plugin.NewSimpleRegistry()
attachPlugin := &AttachPlugin{}
err := registry.Register(attachPlugin)
testutil.HandleTestingErr(err, t, "Couldn't register plugin: %v")
server, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, true)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom := plugintest.TestAgentCommunicator("mocktaskid", "mocktasksecret", server.URL)
taskConfig, err := plugintest.CreateTestConfig(configPath, t)
testutil.HandleTestingErr(err, t, "failed to create test config: %v")
taskConfig.WorkDir = "."
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
Convey("all commands in test project should execute successfully", func() {
for _, projTask := range taskConfig.Project.Tasks {
So(len(projTask.Commands), ShouldNotEqual, 0)
for _, command := range projTask.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{pluginCmds[0].Plugin(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
testTask, err := task.FindOne(task.ById(httpCom.TaskId))
testutil.HandleTestingErr(err, t, "Couldn't find task")
So(testTask, ShouldNotBeNil)
}
}
Convey("and the tests should be present in the db", customTests)
})
})
}
func TestIncKey(t *testing.T) {
Convey("With keyval plugin installed", t, func() {
err := db.Clear(keyval.KeyValCollection)
util.HandleTestingErr(err, t, "Couldn't clear test collection: %v")
registry := plugin.NewSimpleRegistry()
kvPlugin := &keyval.KeyValPlugin{}
err = registry.Register(kvPlugin)
util.HandleTestingErr(err, t, "Couldn't register plugin: %v")
server, err := apiserver.CreateTestServer(evergreen.TestConfig(), nil, []plugin.Plugin{kvPlugin}, false)
httpCom := testutil.TestAgentCommunicator("mocktaskid", "mocktasksecret", server.URL)
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestAgentLogger(sliceAppender)
taskConfig, err := testutil.CreateTestConfig("testdata/plugin_keyval.yml", t)
util.HandleTestingErr(err, t, "failed to create test config")
Convey("Inc command should increment a key successfully", func() {
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, nil)
util.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
for _, cmd := range pluginCmds {
pluginCom := &agent.TaskJSONCommunicator{cmd.Plugin(), httpCom}
err = cmd.Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
}
}
So(taskConfig.Expansions.Get("testkey"), ShouldEqual, "2")
So(taskConfig.Expansions.Get("testkey_x"), ShouldEqual, "1")
}
})
})
}
func TestAttachRawResults(t *testing.T) {
resetTasks(t)
testConfig := evergreen.TestConfig()
Convey("With attachResults plugin installed into plugin registry", t, func() {
registry := plugin.NewSimpleRegistry()
attachPlugin := &AttachPlugin{}
err := registry.Register(attachPlugin)
testutil.HandleTestingErr(err, t, "Couldn't register plugin: %v")
server, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, true)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom := plugintest.TestAgentCommunicator("mocktaskid", "mocktasksecret", server.URL)
configFile := "testdata/plugin_attach_results_raw.yml"
resultsLoc := "testdata/plugin_attach_results_raw.json"
taskConfig, err := plugintest.CreateTestConfig(configFile, t)
testutil.HandleTestingErr(err, t, "failed to create test config: %v")
taskConfig.WorkDir = "."
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
Convey("when attaching a raw log ", func() {
for _, projTask := range taskConfig.Project.Tasks {
So(len(projTask.Commands), ShouldNotEqual, 0)
for _, command := range projTask.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
// create a plugin communicator
pluginCom := &agent.TaskJSONCommunicator{pluginCmds[0].Plugin(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
Convey("when retrieving task", func() {
// fetch the task
testTask, err := task.FindOne(task.ById(httpCom.TaskId))
testutil.HandleTestingErr(err, t, "Couldn't find task")
So(testTask, ShouldNotBeNil)
Convey("test results should match and raw log should be in appropriate collection", func() {
reportFile, err := os.Open(resultsLoc)
testutil.HandleTestingErr(err, t, "Couldn't open report file: '%v'", err)
results := &task.TestResults{}
err = util.ReadJSONInto(reportFile, results)
testutil.HandleTestingErr(err, t, "Couldn't read report file: '%v'", err)
testResults := *results
So(len(testResults.Results), ShouldEqual, 3)
So(len(testTask.TestResults), ShouldEqual, 3)
firstResult := testTask.TestResults[0]
So(firstResult.LogRaw, ShouldEqual, "")
So(firstResult.LogId, ShouldNotEqual, "")
testLog, err := model.FindOneTestLogById(firstResult.LogId)
So(err, ShouldBeNil)
So(testLog.Lines[0], ShouldEqual, testResults.Results[0].LogRaw)
Convey("both URL and raw log should be stored appropriately if both exist", func() {
urlResult := testTask.TestResults[2]
So(urlResult.LogRaw, ShouldEqual, "")
So(urlResult.URL, ShouldNotEqual, "")
So(urlResult.LogId, ShouldNotEqual, "")
testLog, err := model.FindOneTestLogById(urlResult.LogId)
So(err, ShouldBeNil)
So(testLog.Lines[0], ShouldEqual, testResults.Results[2].LogRaw)
})
})
})
}
}
})
})
}
func TestPushTask(t *testing.T) {
testConfig := evergreen.TestConfig()
setupTlsConfigs(t)
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
testutil.ConfigureIntegrationTest(t, testConfig, "TestPushTask")
for tlsString, tlsConfig := range tlsConfigs {
for _, testSetup := range testSetups {
Convey(testSetup.testSpec, t, func() {
Convey("With agent running a push task "+tlsString, func() {
testTask, _, err := setupAPITestData(testConfig, evergreen.PushStage,
"linux-64", false, t)
testutil.HandleTestingErr(err, t, "Error setting up test data: %v", err)
testutil.HandleTestingErr(db.ClearCollections(artifact.Collection), t, "can't clear files collection")
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.Published, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := New(testServer.URL, testTask.Id, testTask.Secret, "", testConfig.Expansions["api_httpscert"])
testutil.HandleTestingErr(err, t, "Error making test agent: %v", err)
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
printLogsForTask(testTask.Id)
newDate := testAgent.taskConfig.Expansions.Get("new_date")
Convey("all scripts in task should have been run successfully", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "push task pre-run!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "push task post-run!"), ShouldBeTrue)
Convey("s3.put attaches task file properly", func() {
entry, err := artifact.FindOne(artifact.ByTaskId(testTask.Id))
So(err, ShouldBeNil)
So(len(entry.Files), ShouldEqual, 2)
for _, element := range entry.Files {
So(element.Name, ShouldNotEqual, "")
}
So(entry.Files[0].Name, ShouldEqual, "push_file")
link := "https://s3.amazonaws.com/build-push-testing/pushtest-stage/unittest-testTaskId-DISTRO_EXP-BUILDVAR_EXP-FILE_EXP.txt"
So(entry.Files[0].Link, ShouldEqual, link)
})
Convey("s3.copy attached task file properly", func() {
entry, err := artifact.FindOne(artifact.ByTaskId(testTask.Id))
So(err, ShouldBeNil)
So(len(entry.Files), ShouldNotEqual, 0)
So(entry.Files[0].Name, ShouldEqual, "push_file")
So(entry.Files[1].Name, ShouldEqual, "copy_file")
So(entry.Files[0].Link, ShouldEqual, "https://s3.amazonaws.com/build-push-testing/pushtest-stage/unittest-testTaskId-DISTRO_EXP-BUILDVAR_EXP-FILE_EXP.txt")
So(entry.Files[1].Link, ShouldEqual,
"https://s3.amazonaws.com/build-push-testing/pushtest/unittest-DISTRO_EXP-BUILDVAR_EXP-FILE_EXP-latest.txt")
})
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Error finding test task: %v", err)
So(testTask.Status, ShouldEqual, evergreen.TaskSucceeded)
// Check the file written to s3 is what we expected
auth := &aws.Auth{
AccessKey: testConfig.Providers.AWS.Id,
SecretKey: testConfig.Providers.AWS.Secret,
}
// check the staging location first
filebytes, err := getS3FileBytes(auth, "build-push-testing", "/pushtest-stage/unittest-testTaskId-DISTRO_EXP-BUILDVAR_EXP-FILE_EXP.txt")
testutil.HandleTestingErr(err, t, "Failed to get file from s3: %v", err)
So(string(filebytes), ShouldEqual, newDate+"\n")
// now check remote location (after copy)
filebytes, err = getS3FileBytes(auth, "build-push-testing", "/pushtest/unittest-DISTRO_EXP-BUILDVAR_EXP-FILE_EXP-latest.txt")
testutil.HandleTestingErr(err, t, "Failed to get remote file from s3: %v", err)
So(string(filebytes), ShouldEqual, newDate+"\n")
})
})
})
}
}
}
func TestGotestPluginOnPassingTests(t *testing.T) {
SkipConvey("With gotest plugin installed into plugin registry", t, func() {
reset(t)
testConfig := evergreen.TestConfig()
testutil.ConfigureIntegrationTest(t, testConfig, "TestGotestPluginOnPassingTests")
registry := plugin.NewSimpleRegistry()
testPlugin := &GotestPlugin{}
err := registry.Register(testPlugin)
testutil.HandleTestingErr(err, t, "Couldn't register plugin %v")
server, err := apiserver.CreateTestServer(evergreen.TestConfig(), nil, plugin.APIPlugins, true)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom := plugintest.TestAgentCommunicator("testTaskId", "testTaskSecret", server.URL)
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
Convey("all commands in test project should execute successfully", func() {
curWD, err := os.Getwd()
testutil.HandleTestingErr(err, t, "Couldn't get working directory: %v")
taskConfig, err := plugintest.CreateTestConfig("testdata/good.yml", t)
// manually override working directory to the main repo, since this
// is much easier than copying over the required testing dependencies
// to a temporary directory
testutil.HandleTestingErr(err, t, "Couldn't set up test config %v")
taskConfig.WorkDir = curWD
task, _, err := plugintest.SetupAPITestData("testTask", false, t)
testutil.HandleTestingErr(err, t, "Couldn't set up test documents")
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{pluginCmds[0].Plugin(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
}
}
Convey("and the tests in the task should be updated", func() {
updatedTask, err := model.FindTask(task.Id)
So(err, ShouldBeNil)
So(updatedTask, ShouldNotBeNil)
So(len(updatedTask.TestResults), ShouldEqual, 2)
So(updatedTask.TestResults[0].Status, ShouldEqual, "pass")
So(updatedTask.TestResults[1].Status, ShouldEqual, "pass")
So(updatedTask.TestResults[0].TestFile, ShouldEqual, "TestPass01")
So(updatedTask.TestResults[1].TestFile, ShouldEqual, "TestPass02")
So(updatedTask.TestResults[0].StartTime, ShouldBeLessThan,
updatedTask.TestResults[0].EndTime)
So(updatedTask.TestResults[1].StartTime, ShouldBeLessThan,
updatedTask.TestResults[1].EndTime)
Convey("with relevant logs present in the DB as well", func() {
log, err := model.FindOneTestLog("0_goodpkg", "testTaskId", 0)
So(log, ShouldNotBeNil)
So(err, ShouldBeNil)
So(log.Lines[0], ShouldContainSubstring, "TestPass01")
})
})
})
})
}
func TestAttachTaskFilesPlugin(t *testing.T) {
testConfig := evergreen.TestConfig()
Convey("With attach plugin installed into plugin registry", t, func() {
registry := plugin.NewSimpleRegistry()
attachPlugin := &AttachPlugin{}
err := registry.Register(attachPlugin)
testutil.HandleTestingErr(err, t, "Couldn't register plugin %v")
server, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, true)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom := plugintest.TestAgentCommunicator("testTaskId", "testTaskSecret", server.URL)
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
Convey("all commands in test project should execute successfully", func() {
taskConfig, _ := plugintest.CreateTestConfig("testdata/plugin_attach_files.yml", t)
_, _, err = plugintest.SetupAPITestData("testTask", true, t)
testutil.HandleTestingErr(err, t, "Couldn't set up test documents")
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{pluginCmds[0].Plugin(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
}
}
Convey("and these file entry fields should exist in the db:", func() {
entry, err := artifact.FindOne(artifact.ByTaskId("testTaskId"))
So(err, ShouldBeNil)
So(entry, ShouldNotBeNil)
So(entry.TaskDisplayName, ShouldEqual, "testTask")
So(len(entry.Files), ShouldEqual, 5)
var regular artifact.File
var expansion artifact.File
var overwritten artifact.File
for _, file := range entry.Files {
switch file.Name {
case "file1":
expansion = file
case "file2":
overwritten = file
case "file3":
regular = file
}
}
Convey("- regular link", func() {
So(regular, ShouldResemble,
artifact.File{"file3", "http://kyle.diamonds", ""})
})
Convey("- link with expansion", func() {
So(expansion, ShouldResemble,
artifact.File{"file1", "i am a FILE!", ""})
})
Convey("- link that is overwritten", func() {
So(overwritten, ShouldResemble,
artifact.File{"file2", "replaced!", ""})
})
})
})
})
}
func TestAttachFilesApi(t *testing.T) {
testConfig := evergreen.TestConfig()
Convey("With a running api server and installed api hook", t, func() {
reset(t)
taskConfig, _ := plugintest.CreateTestConfig("testdata/plugin_attach_files.yml", t)
registry := plugin.NewSimpleRegistry()
attachPlugin := &AttachPlugin{}
err := registry.Register(attachPlugin)
testutil.HandleTestingErr(err, t, "Couldn't register patch plugin")
server, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, true)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
testTask := task.Task{Id: "test1", DisplayName: "TASK!!!", BuildId: "build1"}
testutil.HandleTestingErr(testTask.Insert(), t, "couldn't insert test task")
taskConfig.Task = &testTask
httpCom := plugintest.TestAgentCommunicator(testTask.Id, testTask.Secret, server.URL)
pluginCom := &agent.TaskJSONCommunicator{attachPlugin.Name(), httpCom}
Convey("using a well-formed api call", func() {
testCommand := AttachTaskFilesCommand{
artifact.Params{
"upload": "gopher://evergreen.equipment",
"coverage": "http://www.blankets.com",
},
}
err := testCommand.SendTaskFiles(taskConfig, logger, pluginCom)
So(err, ShouldBeNil)
Convey("the given values should be written to the db", func() {
entry, err := artifact.FindOne(artifact.ByTaskId(testTask.Id))
So(err, ShouldBeNil)
So(entry, ShouldNotBeNil)
So(entry.TaskId, ShouldEqual, testTask.Id)
So(entry.TaskDisplayName, ShouldEqual, testTask.DisplayName)
So(entry.BuildId, ShouldEqual, testTask.BuildId)
So(len(entry.Files), ShouldEqual, 2)
})
Convey("with a second api call", func() {
testCommand := AttachTaskFilesCommand{
artifact.Params{
"3x5": "15",
"$b.o.o.l": "{\"json\":false}",
"coverage": "http://tumblr.com/tagged/tarp",
},
}
err := testCommand.SendTaskFiles(taskConfig, logger, pluginCom)
So(err, ShouldBeNil)
entry, err := artifact.FindOne(artifact.ByTaskId(testTask.Id))
So(err, ShouldBeNil)
So(entry, ShouldNotBeNil)
Convey("new values should be added", func() {
Convey("and old values should still remain", func() {
So(len(entry.Files), ShouldEqual, 5)
})
})
})
})
Convey("but the following malformed calls should fail:", func() {
Convey("- calls with garbage content", func() {
resp, err := pluginCom.TaskPostJSON(
AttachTaskFilesAPIEndpoint,
"I am not a proper post request for this endpoint",
)
So(err, ShouldBeNil)
So(resp, ShouldNotBeNil)
So(resp.StatusCode, ShouldEqual, http.StatusBadRequest)
})
Convey("- calls with nested subdocs", func() {
resp, err := pluginCom.TaskPostJSON(
AttachTaskFilesAPIEndpoint,
map[string]interface{}{
"cool": map[string]interface{}{
"this_is": "a",
"broken": "test",
},
})
So(err, ShouldBeNil)
So(resp, ShouldNotBeNil)
So(resp.StatusCode, ShouldEqual, http.StatusBadRequest)
})
})
})
}
func TestManifestLoad(t *testing.T) {
reset(t)
testConfig := evergreen.TestConfig()
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
testutil.ConfigureIntegrationTest(t, testConfig, "TestManifestFetch")
Convey("With a SimpleRegistry and test project file", t, func() {
registry := plugin.NewSimpleRegistry()
manifestPlugin := &ManifestPlugin{}
testutil.HandleTestingErr(registry.Register(manifestPlugin), t, "failed to register manifest plugin")
gitPlugin := &git.GitPlugin{}
testutil.HandleTestingErr(registry.Register(gitPlugin), t, "failed to register git plugin")
server, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, false)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
taskConfig, err := plugintest.CreateTestConfig("testdata/mongodb-mongo-master.yml", t)
testutil.HandleTestingErr(err, t, "Couldnt get task config from config file")
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agent.NewTestLogger(sliceAppender)
httpCom := plugintest.TestAgentCommunicator("mocktaskid", "mocktasksecret", server.URL)
Convey("the manifest load command should execute successfully", func() {
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{manifestPlugin.Name(),
httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig,
make(chan bool))
So(err, ShouldBeNil)
}
}
Convey("the manifest should be inserted properly into the database", func() {
currentManifest, err := manifest.FindOne(manifest.ById(taskConfig.Task.Version))
So(err, ShouldBeNil)
So(currentManifest, ShouldNotBeEmpty)
So(currentManifest.ProjectName, ShouldEqual, taskConfig.ProjectRef.Identifier)
So(currentManifest.Modules, ShouldNotBeNil)
So(len(currentManifest.Modules), ShouldEqual, 1)
for key, _ := range currentManifest.Modules {
So(key, ShouldEqual, "sample")
}
So(taskConfig.Expansions.Get("sample_rev"), ShouldEqual, "3c7bfeb82d492dc453e7431be664539c35b5db4b")
})
Convey("with a manifest already in the database the manifest should not create a new manifest", func() {
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{manifestPlugin.Name(),
httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig,
make(chan bool))
So(err, ShouldBeNil)
}
}
Convey("the manifest should be inserted properly into the database", func() {
currentManifest, err := manifest.FindOne(manifest.ById(taskConfig.Task.Version))
So(err, ShouldBeNil)
So(currentManifest, ShouldNotBeEmpty)
So(currentManifest.ProjectName, ShouldEqual, taskConfig.ProjectRef.Identifier)
So(currentManifest.Modules, ShouldNotBeNil)
So(len(currentManifest.Modules), ShouldEqual, 1)
for key, _ := range currentManifest.Modules {
So(key, ShouldEqual, "sample")
}
So(currentManifest.Modules["sample"].Repo, ShouldEqual, "sample")
So(taskConfig.Expansions.Get("sample_rev"), ShouldEqual, "3c7bfeb82d492dc453e7431be664539c35b5db4b")
So(currentManifest.Id, ShouldEqual, taskConfig.Task.Version)
})
})
})
})
}
func TestS3PutAndGet(t *testing.T) {
testutil.HandleTestingErr(
db.ClearCollections(task.Collection, artifact.Collection), t,
"error clearing test collections")
conf := evergreen.TestConfig()
testutil.ConfigureIntegrationTest(t, conf, "TestS3PutAndGet")
Convey("When putting to and retrieving from an s3 bucket", t, func() {
var putCmd *S3PutCommand
var getCmd *S3GetCommand
testDataDir := "testdata"
remoteFile := "remote_mci_put_test.tgz"
bucket := "mci-test-uploads"
permissions := "private"
contentType := "application/x-tar"
displayName := "testfile"
// create the local directory to be tarred
localDirToTar := filepath.Join(testDataDir, "put_test")
localFileToTar := filepath.Join(localDirToTar, "put_test_file.txt")
testutil.HandleTestingErr(os.RemoveAll(localDirToTar), t, "Error removing"+
" directory")
testutil.HandleTestingErr(os.MkdirAll(localDirToTar, 0755), t,
"Error creating directory")
randStr := util.RandomString()
So(ioutil.WriteFile(localFileToTar, []byte(randStr), 0755), ShouldBeNil)
// tar it
tarCmd := &command.LocalCommand{
CmdString: "tar czf put_test.tgz put_test",
WorkingDirectory: testDataDir,
Stdout: ioutil.Discard,
Stderr: ioutil.Discard,
}
testutil.HandleTestingErr(tarCmd.Run(), t, "Error tarring directories")
tarballSource := filepath.Join(testDataDir, "put_test.tgz")
// remove the untarred version
testutil.HandleTestingErr(os.RemoveAll(localDirToTar), t, "Error removing directories")
Convey("the file retrieved should be the exact same as the file put", func() {
// load params into the put command
putCmd = &S3PutCommand{}
putParams := map[string]interface{}{
"aws_key": conf.Providers.AWS.Id,
"aws_secret": conf.Providers.AWS.Secret,
"local_file": tarballSource,
"remote_file": remoteFile,
"bucket": bucket,
"permissions": permissions,
"content_type": contentType,
"display_name": displayName,
}
So(putCmd.ParseParams(putParams), ShouldBeNil)
So(putCmd.Put(), ShouldBeNil)
// next, get the file, untarring it
getCmd = &S3GetCommand{}
getParams := map[string]interface{}{
"aws_key": conf.Providers.AWS.Id,
"aws_secret": conf.Providers.AWS.Secret,
"remote_file": remoteFile,
"bucket": bucket,
"extract_to": testDataDir,
"display_name": displayName,
}
So(getCmd.ParseParams(getParams), ShouldBeNil)
So(getCmd.Get(), ShouldBeNil)
// read in the file that was pulled down
fileContents, err := ioutil.ReadFile(localFileToTar)
So(err, ShouldBeNil)
So(string(fileContents), ShouldEqual, randStr)
// now, get the tarball without untarring it
getCmd = &S3GetCommand{}
localDlTarget := filepath.Join(testDataDir, "put_test_dl.tgz")
getParams = map[string]interface{}{
"aws_key": conf.Providers.AWS.Id,
"aws_secret": conf.Providers.AWS.Secret,
"remote_file": remoteFile,
"bucket": bucket,
"local_file": localDlTarget,
"display_name": displayName,
}
So(getCmd.ParseParams(getParams), ShouldBeNil)
So(getCmd.Get(), ShouldBeNil)
exists, err := util.FileExists(localDlTarget)
So(err, ShouldBeNil)
So(exists, ShouldBeTrue)
})
Convey("the put command should always run if there is no variants filter", func() {
// load params into the put command
putCmd = &S3PutCommand{}
putParams := map[string]interface{}{
"aws_key": conf.Providers.AWS.Id,
"aws_secret": conf.Providers.AWS.Secret,
"local_file": tarballSource,
"remote_file": remoteFile,
"bucket": bucket,
"permissions": permissions,
"content_type": contentType,
"display_name": displayName,
}
So(putCmd.ParseParams(putParams), ShouldBeNil)
So(putCmd.shouldRunForVariant("linux-64"), ShouldBeTrue)
})
Convey("put cmd with variants filter should only run if variant is in list", func() {
// load params into the put command
putCmd = &S3PutCommand{}
putParams := map[string]interface{}{
"aws_key": conf.Providers.AWS.Id,
"aws_secret": conf.Providers.AWS.Secret,
"local_file": tarballSource,
"remote_file": remoteFile,
"bucket": bucket,
"permissions": permissions,
"content_type": contentType,
"display_name": displayName,
"build_variants": []string{"linux-64", "windows-64"},
}
So(putCmd.ParseParams(putParams), ShouldBeNil)
So(putCmd.shouldRunForVariant("linux-64"), ShouldBeTrue)
So(putCmd.shouldRunForVariant("osx-108"), ShouldBeFalse)
})
Convey("put cmd with 'optional' and missing file should not throw an error", func() {
// load params into the put command
putCmd = &S3PutCommand{}
putParams := map[string]interface{}{
"aws_key": conf.Providers.AWS.Id,
"aws_secret": conf.Providers.AWS.Secret,
"optional": true,
"local_file": "this_file_does_not_exist.txt",
"remote_file": "remote_file",
"bucket": "test_bucket",
"permissions": "private",
"content_type": "text/plain",
}
So(putCmd.ParseParams(putParams), ShouldBeNil)
server, err := apiserver.CreateTestServer(conf, nil, plugin.APIPlugins, false)
httpCom := plugintest.TestAgentCommunicator("testTask", "taskSecret", server.URL)
pluginCom := &agent.TaskJSONCommunicator{"s3", httpCom}
So(err, ShouldBeNil)
err = putCmd.Execute(&plugintest.MockLogger{}, pluginCom,
&model.TaskConfig{nil, nil, nil, nil, &model.BuildVariant{Name: "linux"}, &command.Expansions{}, "."}, make(chan bool))
So(err, ShouldBeNil)
})
})
}
func TestCLIFunctions(t *testing.T) {
testutil.ConfigureIntegrationTest(t, testConfig, "TestCLIFunctions")
Convey("with API test server running", t, func() {
// create a test API server
testServer, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, true)
// create a test user
So(db.Clear(user.Collection), ShouldBeNil)
So(db.Clear(patch.Collection), ShouldBeNil)
So(db.Clear(model.ProjectRefCollection), ShouldBeNil)
So((&user.DBUser{Id: "testuser", APIKey: "testapikey", EmailAddress: "*****@*****.**"}).Insert(), ShouldBeNil)
localConfBytes, err := ioutil.ReadFile("testdata/sample.yml")
So(err, ShouldBeNil)
projectRef := &model.ProjectRef{
Identifier: "sample",
Owner: "evergreen-ci",
Repo: "sample",
RepoKind: "github",
Branch: "master",
RemotePath: "evergreen.yml",
LocalConfig: string(localConfBytes),
Enabled: true,
BatchTime: 180,
}
So(projectRef.Insert(), ShouldBeNil)
// create a settings file for the command line client
settings := Settings{
APIServerHost: testServer.URL + "/api",
UIServerHost: "http://dev-evg.mongodb.com",
APIKey: "testapikey",
User: "******",
}
settingsFile, err := ioutil.TempFile("", "settings")
So(err, ShouldBeNil)
settingsBytes, err := yaml.Marshal(settings)
So(err, ShouldBeNil)
_, err = settingsFile.Write(settingsBytes)
So(err, ShouldBeNil)
settingsFile.Close()
t.Log("Wrote settings file to ", settingsFile.Name())
ac, _, err := getAPIClient(&Options{settingsFile.Name()})
So(err, ShouldBeNil)
Convey("check that creating a patch works", func() {
Convey("user should start with no patches present", func() {
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 0)
})
Convey("Creating a simple patch should be successful", func() {
patchSub := patchSubmission{"sample",
testPatch,
"sample patch",
"3c7bfeb82d492dc453e7431be664539c35b5db4b",
"all",
[]string{"all"},
false}
newPatch, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
Convey("Newly created patch should be fetchable via API", func() {
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 1)
})
Convey("Adding a module to the patch should work", func() {
err = ac.UpdatePatchModule(newPatch.Id.Hex(), "render-module", testPatch, "1e5232709595db427893826ce19289461cba3f75")
So(err, ShouldBeNil)
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
So(patches[0].Patches[0].ModuleName, ShouldEqual, "")
So(patches[0].Patches[1].ModuleName, ShouldEqual, "render-module")
Convey("Removing the module from the patch should work", func() {
So(ac.DeletePatchModule(newPatch.Id.Hex(), "render-module"), ShouldBeNil)
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
So(len(patches[0].Patches), ShouldEqual, 1)
Convey("Finalizing the patch should work", func() {
// First double check that the patch starts with no "version" field
So(patches[0].Version, ShouldEqual, "")
So(ac.FinalizePatch(newPatch.Id.Hex()), ShouldBeNil)
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
// After finalizing, the patch should now have a version populated
So(patches[0].Version, ShouldNotEqual, "")
Convey("Cancelling the patch should work", func() {
So(ac.CancelPatch(newPatch.Id.Hex()), ShouldBeNil)
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
// After cancelling, tasks in the version should be deactivated
tasks, err := model.FindTasks(db.Query(bson.M{model.TaskVersionKey: patches[0].Version}))
So(err, ShouldBeNil)
for _, t := range tasks {
So(t.Activated, ShouldBeFalse)
}
})
})
})
})
})
Convey("Creating a complex patch should be successful", func() {
patchSub := patchSubmission{"sample",
testPatch,
"sample patch #2",
"3c7bfeb82d492dc453e7431be664539c35b5db4b",
"osx-108",
[]string{"failing_test"},
false}
_, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
Convey("Newly created patch should be fetchable via API", func() {
patches, err := ac.GetPatches()
Println(patches)
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 1)
So(len(patches[0].BuildVariants), ShouldEqual, 1)
So(patches[0].BuildVariants[0], ShouldEqual, "osx-108")
So(len(patches[0].Tasks), ShouldEqual, 2)
So(patches[0].Tasks, ShouldContain, "failing_test")
Convey("and have expanded dependencies", func() {
So(patches[0].Tasks, ShouldContain, "compile")
})
})
})
})
})
}
func TestPatchPlugin(t *testing.T) {
testConfig := evergreen.TestConfig()
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
Convey("With patch plugin installed into plugin registry", t, func() {
registry := plugin.NewSimpleRegistry()
gitPlugin := &GitPlugin{}
err := registry.Register(gitPlugin)
testutil.HandleTestingErr(err, t, "Couldn't register plugin %v")
testutil.HandleTestingErr(db.Clear(version.Collection), t,
"unable to clear versions collection")
version := &version.Version{
Id: "",
}
So(version.Insert(), ShouldBeNil)
server, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, false)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom := plugintest.TestAgentCommunicator("testTaskId", "testTaskSecret", server.URL)
//sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
sliceAppender := slogger.StdOutAppender()
logger := agent.NewTestLogger(sliceAppender)
Convey("all commands in test project should execute successfully", func() {
taskConfig, _ := plugintest.CreateTestConfig("testdata/plugin_patch.yml", t)
taskConfig.Task.Requester = evergreen.PatchVersionRequester
_, _, err = plugintest.SetupAPITestData("testTask", true, t)
testutil.HandleTestingErr(err, t, "Couldn't set up test documents")
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{pluginCmds[0].Plugin(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
}
}
})
Convey("broken test project should fail during execution", func() {
// this config tries to patch on an empty repo
taskConfig, _ := plugintest.CreateTestConfig("testdata/plugin_broken_patch.yml", t)
taskConfig.Task.Requester = evergreen.PatchVersionRequester
_, _, err = plugintest.SetupAPITestData("testTask", true, t)
testutil.HandleTestingErr(err, t, "Couldn't set up test documents")
for _, task := range taskConfig.Project.Tasks {
So(len(task.Commands), ShouldNotEqual, 0)
for _, command := range task.Commands {
pluginCmds, err := registry.GetCommands(command, taskConfig.Project.Functions)
testutil.HandleTestingErr(err, t, "Couldn't get plugin command: %v")
So(pluginCmds, ShouldNotBeNil)
So(err, ShouldBeNil)
pluginCom := &agent.TaskJSONCommunicator{pluginCmds[0].Plugin(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldNotBeNil)
}
}
})
})
}
func TestTaskSuccess(t *testing.T) {
setupTlsConfigs(t)
testutil.ConfigureIntegrationTest(t, testConfig, "TestTaskSuccess")
for tlsString, tlsConfig := range tlsConfigs {
for _, testSetup := range testSetups {
for _, variant := range buildVariantsToTest {
Convey(testSetup.testSpec, t, func() {
Convey("With agent running 'compile' step and live API server over "+
tlsString+" with variant "+variant, func() {
testTask, _, err := setupAPITestData(testConfig, "compile", variant, NoPatch, t)
testutil.HandleTestingErr(err, t, "Couldn't create test task: %v", err)
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
Convey("expansions should be fetched", func() {
So(testAgent.taskConfig.Expansions.Get("aws_key"), ShouldEqual, testConfig.Providers.AWS.Id)
So(scanLogsForTask(testTask.Id, "fetch_expansion_value"), ShouldBeTrue)
})
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
printLogsForTask(testTask.Id)
Convey("all scripts in task should have been run successfully", func() {
So(scanLogsForTask(testTask.Id, "Executing script: echo \"predefined command!\""), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "predefined command!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "this should not end up in the logs"), ShouldBeFalse)
So(scanLogsForTask(testTask.Id, "Command timeout set to 21m40s"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "Command timeout set to 43m20s"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "Cloning into") || // git 1.8
scanLogsForTask(testTask.Id, "Initialized empty Git repository"), // git 1.7
ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am compiling!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am sanity testing!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "Skipping command 'git.apply_patch' on variant"), ShouldBeTrue)
// Check that functions with args are working correctly
So(scanLogsForTask(testTask.Id, "arg1 is FOO"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "arg2 is BAR"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "arg3 is Expanded: qux"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "arg4 is Default: default_value"), ShouldBeTrue)
// Check that multi-command functions are working correctly
So(scanLogsForTask(testTask.Id, "step 1 of multi-command func"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "step 2 of multi-command func"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "step 3 of multi-command func"), ShouldBeTrue)
// Check that logging output is only flushing on a newline
So(scanLogsForTask(testTask.Id, "this should be on the same line...as this."), ShouldBeTrue)
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Couldn't find test task: %v", err)
So(testTask.Status, ShouldEqual, evergreen.TaskSucceeded)
// use function display name as description when none is specified in command
So(testTask.Details.Status, ShouldEqual, evergreen.TaskSucceeded)
So(testTask.Details.Description, ShouldEqual, `'shell.exec' in "silent shell test"`)
So(testTask.Details.TimedOut, ShouldBeFalse)
So(testTask.Details.Type, ShouldEqual, model.SystemCommandType)
})
Convey("manifest should be created", func() {
m, err := manifest.FindOne(manifest.ById(testTask.Version))
So(testTask.Version, ShouldEqual, "testVersionId")
So(err, ShouldBeNil)
So(m, ShouldNotBeNil)
So(m.ProjectName, ShouldEqual, testTask.Project)
So(m.Id, ShouldEqual, testTask.Version)
So(m.Modules, ShouldNotBeEmpty)
So(m.Modules["recursive"], ShouldNotBeNil)
So(m.Modules["recursive"].URL, ShouldNotEqual, "")
})
})
Convey("With agent running a regular test and live API server over "+
tlsString+" on variant "+variant, func() {
testTask, _, err := setupAPITestData(testConfig, "normal_task", variant, NoPatch, t)
testutil.HandleTestingErr(err, t, "Couldn't create test data: %v", err)
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
Convey("all scripts in task should have been run successfully", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "starting normal_task!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "done with normal_task!"), ShouldBeTrue)
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Couldn't find test task: %v", err)
So(testTask.Status, ShouldEqual, evergreen.TaskSucceeded)
expectedResults := []model.TestResult{
model.TestResult{
Status: "success",
TestFile: "t1",
URL: "url",
ExitCode: 0,
StartTime: 0,
EndTime: 10,
},
}
So(testTask.TestResults, ShouldResemble, expectedResults)
})
})
})
}
}
}
}
func TestBasicEndpoints(t *testing.T) {
setupTlsConfigs(t)
for tlsString, tlsConfig := range tlsConfigs {
testTask, _, err := setupAPITestData(testConfig, "task", "linux-64", NoPatch, t)
testutil.HandleTestingErr(err, t, "Couldn't make test data: %v", err)
Convey("With a live api server, agent, and test task over "+tlsString, t, func() {
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
Convey("sending logs should store the log messages properly", func() {
msg1 := "task logger initialized!"
msg2 := "system logger initialized!"
msg3 := "exec logger initialized!"
testAgent.logger.LogTask(slogger.INFO, msg1)
testAgent.logger.LogSystem(slogger.INFO, msg2)
testAgent.logger.LogExecution(slogger.INFO, msg3)
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
// This returns logs in order of NEWEST first.
logMessages, err := model.FindMostRecentLogMessages(testTask.Id, 0, 10, []string{}, []string{})
testutil.HandleTestingErr(err, t, "failed to get log msgs")
So(logMessages[2].Message, ShouldEndWith, msg1)
So(logMessages[1].Message, ShouldEndWith, msg2)
So(logMessages[0].Message, ShouldEndWith, msg3)
Convey("Task endpoints should work between agent and server", func() {
testAgent.StartBackgroundActions(&NoopSignalHandler{})
Convey("calling GetTask should get retrieve same task back", func() {
testTaskFromApi, err := testAgent.GetTask()
So(err, ShouldBeNil)
// ShouldResemble doesn't seem to work here, possibly because of
// omitempty? anyways, just assert equality of the important fields
So(testTaskFromApi.Id, ShouldEqual, testTask.Id)
So(testTaskFromApi.Status, ShouldEqual, testTask.Status)
So(testTaskFromApi.HostId, ShouldEqual, testTask.HostId)
})
Convey("calling start should flip the task's status to started", func() {
err := testAgent.Start("1")
testutil.HandleTestingErr(err, t, "Couldn't start task: %v", err)
testTask, err := model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Couldn't refresh task from db: %v", err)
So(testTask.Status, ShouldEqual, evergreen.TaskStarted)
testHost, err := host.FindOne(host.ByRunningTaskId(testTask.Id))
So(err, ShouldBeNil)
So(testHost.Id, ShouldEqual, "testHost")
So(testHost.RunningTask, ShouldEqual, testTask.Id)
})
Convey("calling end() should update task status properly", func() {
commandType := model.SystemCommandType
description := "random"
details := &apimodels.TaskEndDetail{
Description: description,
Type: commandType,
TimedOut: true,
Status: evergreen.TaskSucceeded,
}
testAgent.End(details)
time.Sleep(100 * time.Millisecond)
taskUpdate, err := model.FindTask(testTask.Id)
So(err, ShouldBeNil)
So(taskUpdate.Status, ShouldEqual, evergreen.TaskSucceeded)
So(taskUpdate.Details.Description, ShouldEqual, description)
So(taskUpdate.Details.Type, ShouldEqual, commandType)
So(taskUpdate.Details.TimedOut, ShouldEqual, true)
})
Convey("no checkins should trigger timeout signal", func() {
testAgent.idleTimeoutWatcher.SetDuration(2 * time.Second)
testAgent.idleTimeoutWatcher.CheckIn()
// sleep long enough for the timeout watcher to time out
time.Sleep(3 * time.Second)
timeoutSignal, ok := <-testAgent.signalHandler.idleTimeoutChan
So(ok, ShouldBeTrue)
So(timeoutSignal, ShouldEqual, IdleTimeout)
})
})
})
})
}
}