func TestIsHostReachable(t *testing.T) {
Convey("A reachable static host should return true", t, func() {
// try with a reachable static host
reachableHost := &host.Host{
Host: "localhost",
Provisioned: true,
Provider: evergreen.HostTypeStatic,
}
cloudManager, err := GetCloudManager(reachableHost.Provider, evergreen.TestConfig())
So(err, ShouldBeNil)
reachable, err := cloudManager.IsSSHReachable(reachableHost, "")
So(reachable, ShouldBeTrue)
So(err, ShouldBeNil)
})
Convey("An unreachable static host should return false", t, func() {
// try with an unreachable static host
reachableHost := &host.Host{
Host: "fakehost",
Provisioned: true,
Provider: evergreen.HostTypeStatic,
}
cloudManager, err := GetCloudManager(reachableHost.Provider, evergreen.TestConfig())
So(err, ShouldBeNil)
reachable, err := cloudManager.IsSSHReachable(reachableHost, "")
So(reachable, ShouldBeFalse)
So(err, ShouldBeNil)
})
}
func TestPatchPluginAPI(t *testing.T) {
testConfig := evergreen.TestConfig()
cwd := testutil.GetDirectoryOfFile()
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 := service.CreateTestServer(testConfig, nil, plugin.APIPlugins, false)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
taskConfig, _ := plugintest.CreateTestConfig(filepath.Join(cwd, "testdata", "plugin_patch.yml"), t)
testCommand := GitGetProjectCommand{Directory: "dir"}
_, _, err = plugintest.SetupAPITestData("testTask", filepath.Join(cwd, "testdata", "testmodule.patch"), 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 := agentutil.NewTestLogger(sliceAppender)
Convey("calls to existing tasks with patches should succeed", func() {
httpCom := plugintest.TestAgentCommunicator(testTask.Id, testTask.Secret, server.URL)
pluginCom := &comm.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 := &comm.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 := &comm.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 TestFindRunningSpawnedHosts(t *testing.T) {
testConfig := evergreen.TestConfig()
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
testutil.HandleTestingErr(db.Clear(Collection), t, "Error"+
" clearing '%v' collection", Collection)
Convey("With calling FindRunningSpawnedHosts...", t, func() {
Convey("if there are no spawned hosts, nothing should be returned",
func() {
spawnedHosts, err := Find(IsRunningAndSpawned)
So(err, ShouldBeNil)
// make sure we only returned no document
So(len(spawnedHosts), ShouldEqual, 0)
})
Convey("if there are spawned hosts, they should be returned", func() {
host := &Host{}
host.Id = "spawned-1"
host.Status = "running"
host.StartedBy = "user1"
testutil.HandleTestingErr(host.Insert(), t, "error from "+
"FindRunningSpawnedHosts")
spawnedHosts, err := Find(IsRunningAndSpawned)
testutil.HandleTestingErr(err, t, "error from "+
"FindRunningSpawnedHosts: %v", err)
// make sure we only returned no document
So(len(spawnedHosts), ShouldEqual, 1)
})
})
}
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 TestShellExecuteCommand(t *testing.T) {
stopper := make(chan bool)
defer close(stopper)
testConfig := evergreen.TestConfig()
server, err := service.CreateTestServer(testConfig, nil, plugin.APIPlugins, true)
if err != nil {
t.Fatalf("failed to create test server %+v", err)
}
httpCom := plugintest.TestAgentCommunicator("testTaskId", "testTaskSecret", server.URL)
jsonCom := &comm.TaskJSONCommunicator{"shell", httpCom}
conf := &model.TaskConfig{Expansions: &command.Expansions{}, Task: &task.Task{}, Project: &model.Project{}}
Convey("With a shell command", t, func() {
Convey("if unset, default is determined by local command", func() {
cmd := &ShellExecCommand{}
So(cmd.Execute(&plugintest.MockLogger{}, jsonCom, conf, stopper), ShouldBeNil)
So(cmd.Shell, ShouldEqual, "")
})
for _, sh := range []string{"/bin/sh", "/bin/bash", "sh", "bash", "python", "/usr/bin/python"} {
Convey(fmt.Sprintf("when set, %s is not overwritten during execution", sh), func() {
cmd := &ShellExecCommand{Shell: sh}
So(cmd.Execute(&plugintest.MockLogger{}, jsonCom, conf, stopper), ShouldBeNil)
So(cmd.Shell, ShouldEqual, sh)
})
}
})
}
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()
cwd := testutil.GetDirectoryOfFile()
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 := service.CreateTestServer(testConfig, nil, plugin.APIPlugins, true)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom := plugintest.TestAgentCommunicator("mocktaskid", "mocktasksecret", server.URL)
configFile := filepath.Join(cwd, "testdata", "plugin_attach_results.yml")
resultsLoc := filepath.Join(cwd, "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 := agentutil.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 := &comm.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)
// 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 := &task.TestResults{}
err = util.ReadJSONInto(reportFile, results)
testutil.HandleTestingErr(err, t, "Couldn't read report file: '%v'", err)
testResults := *results
So(testTask.TestResults, ShouldResemble, testResults.Results)
testutil.HandleTestingErr(err, t, "Couldn't clean up test temp dir")
}
}
})
})
}
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 TestPatchPlugin(t *testing.T) {
cwd := testutil.GetDirectoryOfFile()
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 := service.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 := agentutil.NewTestLogger(sliceAppender)
Convey("all commands in test project should execute successfully", func() {
taskConfig, err := plugintest.CreateTestConfig(filepath.Join(cwd, "testdata", "plugin_patch.yml"), t)
testutil.HandleTestingErr(err, t, "could not create test config")
taskConfig.Task.Requester = evergreen.PatchVersionRequester
_, _, err = plugintest.SetupAPITestData("testTask", filepath.Join(cwd, "testdata", "testmodule.patch"), 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 := &comm.TaskJSONCommunicator{pluginCmds[0].Plugin(), httpCom}
err = pluginCmds[0].Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
}
}
})
})
}
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 TestFlaggingProvisioningFailedHosts(t *testing.T) {
testConfig := evergreen.TestConfig()
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
Convey("When flagging hosts whose provisioning failed", t, func() {
// reset the db
testutil.HandleTestingErr(db.ClearCollections(host.Collection),
t, "error clearing hosts collection")
Convey("only hosts whose provisioning failed should be"+
" picked up", func() {
host1 := &host.Host{
Id: "h1",
Status: evergreen.HostRunning,
}
testutil.HandleTestingErr(host1.Insert(), t, "error inserting host")
host2 := &host.Host{
Id: "h2",
Status: evergreen.HostUninitialized,
}
testutil.HandleTestingErr(host2.Insert(), t, "error inserting host")
host3 := &host.Host{
Id: "h3",
Status: evergreen.HostProvisionFailed,
}
testutil.HandleTestingErr(host3.Insert(), t, "error inserting host")
unprovisioned, err := flagProvisioningFailedHosts(nil, nil)
So(err, ShouldBeNil)
So(len(unprovisioned), ShouldEqual, 1)
So(unprovisioned[0].Id, ShouldEqual, "h3")
})
})
}
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 := service.CreateTestServer(evergreen.TestConfig(), nil, apiPlugins, false)
testutil.HandleTestingErr(err, t, "Couldn't set up testing server")
httpCom, err := comm.NewHTTPCommunicator(testServer.URL, "mocktaskid", "mocktasksecret", "", nil)
So(err, ShouldBeNil)
So(httpCom, ShouldNotBeNil)
pluginConfigPath := filepath.Join(testutil.GetDirectoryOfFile(), "testdata", "plugin_project.yml")
taskConfig, err := createTestConfig(pluginConfigPath, t)
testutil.HandleTestingErr(err, t, "failed to create test config: %v", err)
sliceAppender := &evergreen.SliceAppender{[]*slogger.Log{}}
logger := agentutil.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 := &comm.TaskJSONCommunicator{c.Plugin(), httpCom}
err = c.Execute(logger, pluginCom, taskConfig, make(chan bool))
So(err, ShouldBeNil)
}
}
}
})
})
}
func TestGetCloudManager(t *testing.T) {
Convey("GetCloudManager() should return non-nil for all valid provider names", t, func() {
Convey("EC2 should be returned for ec2 provider name", func() {
cloudMgr, err := GetCloudManager("ec2", evergreen.TestConfig())
So(cloudMgr, ShouldNotBeNil)
So(err, ShouldBeNil)
So(cloudMgr, ShouldHaveSameTypeAs, &ec2.EC2Manager{})
})
Convey("EC2Spot should be returned for ec2-spot provider name", func() {
cloudMgr, err := GetCloudManager("ec2-spot", evergreen.TestConfig())
So(cloudMgr, ShouldNotBeNil)
So(err, ShouldBeNil)
So(cloudMgr, ShouldHaveSameTypeAs, &ec2.EC2SpotManager{})
})
Convey("Static should be returned for static provider name", func() {
cloudMgr, err := GetCloudManager("static", evergreen.TestConfig())
So(cloudMgr, ShouldNotBeNil)
So(err, ShouldBeNil)
So(cloudMgr, ShouldHaveSameTypeAs, &static.StaticManager{})
})
Convey("Mock should be returned for mock provider name", func() {
cloudMgr, err := GetCloudManager("mock", evergreen.TestConfig())
So(cloudMgr, ShouldNotBeNil)
So(err, ShouldBeNil)
So(cloudMgr, ShouldHaveSameTypeAs, &mock.MockCloudManager{})
})
Convey("DigitalOcean should be returned for digitalocean provider name", func() {
cloudMgr, err := GetCloudManager("digitalocean", evergreen.TestConfig())
So(cloudMgr, ShouldNotBeNil)
So(err, ShouldBeNil)
So(cloudMgr, ShouldHaveSameTypeAs, &digitalocean.DigitalOceanManager{})
})
Convey("Invalid provider names should return nil with err", func() {
cloudMgr, err := GetCloudManager("bogus", evergreen.TestConfig())
So(cloudMgr, ShouldBeNil)
So(err, ShouldNotBeNil)
})
})
}
// 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")
}
})
})
}
package scheduler
import (
"testing"
"github.com/evergreen-ci/evergreen"
"github.com/evergreen-ci/evergreen/db"
"github.com/evergreen-ci/evergreen/model/task"
. "github.com/smartystreets/goconvey/convey"
)
var (
taskFinderTestConf = evergreen.TestConfig()
)
func init() {
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(taskFinderTestConf))
if taskFinderTestConf.Scheduler.LogFile != "" {
evergreen.SetLogger(taskFinderTestConf.Scheduler.LogFile)
}
}
func TestDBTaskFinder(t *testing.T) {
var taskIds []string
var tasks []*task.Task
var depTaskIds []string
var depTasks []*task.Task
var taskFinder *DBTaskFinder
Convey("With a DBTaskFinder", t, func() {
package model
import (
"github.com/evergreen-ci/evergreen"
"github.com/evergreen-ci/evergreen/db"
"github.com/evergreen-ci/evergreen/model/build"
"github.com/evergreen-ci/evergreen/model/host"
"github.com/evergreen-ci/evergreen/testutil"
. "github.com/smartystreets/goconvey/convey"
"gopkg.in/mgo.v2/bson"
"testing"
"time"
)
var (
conf = evergreen.TestConfig()
oneMs = time.Millisecond
)
func init() {
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(conf))
evergreen.SetLogger("/tmp/task_test.log")
}
var depTaskIds = []Dependency{
{"td1", evergreen.TaskSucceeded},
{"td2", evergreen.TaskSucceeded},
{"td3", ""}, // Default == "success"
{"td4", evergreen.TaskFailed},
{"td5", AllStatuses},
}
import (
"fmt"
"github.com/evergreen-ci/evergreen"
"github.com/evergreen-ci/evergreen/cloud/providers/mock"
"github.com/evergreen-ci/evergreen/db"
"github.com/evergreen-ci/evergreen/model"
"github.com/evergreen-ci/evergreen/model/distro"
"github.com/evergreen-ci/evergreen/model/host"
"github.com/evergreen-ci/evergreen/model/version"
. "github.com/smartystreets/goconvey/convey"
"testing"
)
var (
schedulerTestConf = evergreen.TestConfig()
)
func init() {
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(schedulerTestConf))
if schedulerTestConf.Scheduler.LogFile != "" {
evergreen.SetLogger(schedulerTestConf.Scheduler.LogFile)
}
}
const versionProjectString = `
buildvariants:
- name: ubuntu
display_name: ubuntu1404
run_on:
- ubuntu1404-test
"github.com/evergreen-ci/evergreen" "github.com/evergreen-ci/evergreen/db" "github.com/evergreen-ci/evergreen/model" "github.com/evergreen-ci/evergreen/model/build" "github.com/evergreen-ci/evergreen/model/distro" "github.com/evergreen-ci/evergreen/model/patch" "github.com/evergreen-ci/evergreen/model/task" modelutil "github.com/evergreen-ci/evergreen/model/testutil" "github.com/evergreen-ci/evergreen/model/version" "github.com/evergreen-ci/evergreen/testutil" . "github.com/smartystreets/goconvey/convey" "gopkg.in/yaml.v2" ) var ( patchTestConfig = evergreen.TestConfig() configFilePath = "testing/mci.yml" patchedProject = "mci-config" unpatchedProject = "mci-test" patchedRevision = "582257a4ca3a9c890959b04d4dd2de5e4d34e9e7" unpatchedRevision = "99162ee5bc41eb314f5bb01bd12f0c43e9cb5f32" patchFile = "testdata/patch.diff" patchOwner = "deafgoat" patchRepo = "config" patchBranch = "master" // newProjectPatchFile is a diff that adds a new project configuration file // located at newConfigFilePath. newProjectPatchFile = "testdata/project.diff" newConfigFilePath = "testing/project2.config" )
func TestNotify(t *testing.T) {
if evergreen.TestConfig().Notify.LogFile != "" {
evergreen.SetLogger(evergreen.TestConfig().Notify.LogFile)
}
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(TestConfig))
emailSubjects = make([]string, 0)
emailBodies = make([]string, 0)
Convey("When running notification handlers", t, func() {
ae, err := createEnvironment(TestConfig, map[string]interface{}{})
So(err, ShouldBeNil)
Convey("Build-specific handlers should return the correct emails", func() {
cleanupdb()
timeNow := time.Now()
// insert the test documents
insertBuildDocs(timeNow)
version := &version.Version{Id: "version"}
So(version.Insert(), ShouldBeNil)
Convey("BuildFailureHandler should return 1 email per failed build", func() {
handler := BuildFailureHandler{}
emails, err := handler.GetNotifications(ae, "config_test",
&buildFailureNotificationKey)
So(err, ShouldBeNil)
// check that we only returned 2 failed notifications
So(len(emails), ShouldEqual, 2)
So(emails[0].GetSubject(), ShouldEqual,
"[MCI-FAILURE ] Build #build1 failed on displayName")
So(emails[1].GetSubject(), ShouldEqual,
"[MCI-FAILURE ] Build #build9 failed on displayName")
})
Convey("BuildSuccessHandler should return 1 email per successful build", func() {
handler := BuildSuccessHandler{}
emails, err := handler.GetNotifications(ae, "config_test",
&buildSucceessNotificationKey)
So(err, ShouldBeNil)
// check that we only returned 2 success notifications
So(len(emails), ShouldEqual, 2)
So(emails[0].GetSubject(), ShouldEqual,
"[MCI-SUCCESS ] Build #build3 succeeded on displayName")
So(emails[1].GetSubject(), ShouldEqual,
"[MCI-SUCCESS ] Build #build8 succeeded on displayName")
})
Convey("BuildCompletionHandler should return 1 email per completed build", func() {
handler := BuildCompletionHandler{}
emails, err := handler.GetNotifications(ae, "config_test",
&buildCompletionNotificationKey)
So(err, ShouldBeNil)
// check that we only returned 6 completed notifications
So(len(emails), ShouldEqual, 4)
So(emails[0].GetSubject(), ShouldEqual,
"[MCI-COMPLETION ] Build #build1 completed on displayName")
So(emails[1].GetSubject(), ShouldEqual,
"[MCI-COMPLETION ] Build #build3 completed on displayName")
So(emails[2].GetSubject(), ShouldEqual,
"[MCI-COMPLETION ] Build #build8 completed on displayName")
So(emails[3].GetSubject(), ShouldEqual,
"[MCI-COMPLETION ] Build #build9 completed on displayName")
})
Convey("BuildSuccessToFailureHandler should return 1 email per "+
"build success to failure transition", func() {
handler := BuildSuccessToFailureHandler{}
emails, err := handler.GetNotifications(ae, "config_test",
&buildSuccessToFailureNotificationKey)
So(err, ShouldBeNil)
// check that we only returned 1 success_to_failure notifications
So(len(emails), ShouldEqual, 1)
So(emails[0].GetSubject(), ShouldEqual,
"[MCI-FAILURE ] Build #build9 transitioned to failure on displayName")
})
})
Convey("Task-specific handlers should return the correct emails", func() {
cleanupdb()
timeNow := time.Now()
// insert the test documents
insertTaskDocs(timeNow)
v := &version.Version{Id: "version"}
So(v.Insert(), ShouldBeNil)
Convey("TaskFailureHandler should return 1 email per task failure", func() {
handler := TaskFailureHandler{}
emails, err := handler.GetNotifications(ae, "config_test",
&taskFailureNotificationKey)
So(err, ShouldBeNil)
// check that we only returned 2 failed notifications
So(len(emails), ShouldEqual, 2)
So(emails[0].GetSubject(), ShouldEqual,
"[MCI-FAILURE ] possible MCI failure in displayName (failed on build1)")
So(emails[1].GetSubject(), ShouldEqual,
"[MCI-FAILURE ] possible MCI failure in displayName (failed on build1)")
})
Convey("TaskSuccessHandler should return 1 email per task success", func() {
handler := TaskSuccessHandler{}
emails, err := handler.GetNotifications(ae, "config_test",
&taskSucceessNotificationKey)
So(err, ShouldBeNil)
// check that we only returned 2 success notifications
So(len(emails), ShouldEqual, 2)
So(emails[0].GetSubject(), ShouldEqual,
"[MCI-SUCCESS ] possible MCI failure in displayName (succeeded on build1)")
So(emails[1].GetSubject(), ShouldEqual,
"[MCI-SUCCESS ] possible MCI failure in displayName (succeeded on build1)")
})
Convey("TaskCompletionHandler should return 1 email per completed task", func() {
handler := TaskCompletionHandler{}
emails, err := handler.GetNotifications(ae, "config_test",
&taskCompletionNotificationKey)
So(err, ShouldBeNil)
// check that we only returned 6 completion notifications
So(len(emails), ShouldEqual, 4)
So(emails[0].GetSubject(), ShouldEqual,
"[MCI-COMPLETION ] possible MCI failure in displayName (completed on build1)")
So(emails[1].GetSubject(), ShouldEqual,
"[MCI-COMPLETION ] possible MCI failure in displayName (completed on build1)")
So(emails[2].GetSubject(), ShouldEqual,
"[MCI-COMPLETION ] possible MCI failure in displayName (completed on build1)")
So(emails[3].GetSubject(), ShouldEqual,
"[MCI-COMPLETION ] possible MCI failure in displayName (completed on build1)")
})
Convey("TaskSuccessToFailureHandler should return 1 email per "+
"task success to failure transition", func() {
handler := TaskSuccessToFailureHandler{}
emails, err := handler.GetNotifications(ae, "config_test",
&taskSuccessToFailureNotificationKey)
So(err, ShouldBeNil)
// check that we only returned 1 success to failure notifications
So(len(emails), ShouldEqual, 1)
So(emails[0].GetSubject(), ShouldEqual,
"[MCI-FAILURE ] possible MCI failure in displayName (transitioned to "+
"failure on build1)")
})
})
})
Convey("When running notifications pipeline", t, func() {
cleanupdb()
timeNow := time.Now()
// insert the test documents
insertTaskDocs(timeNow)
v := &version.Version{Id: "version"}
So(v.Insert(), ShouldBeNil)
Convey("Should run the correct notification handlers for given "+
"notification keys", func() {
notificationSettings := &MCINotification{}
notificationSettings.Notifications = []Notification{
Notification{"task_failure", "project", []string{"user@mongodb"}, []string{}},
Notification{"task_success_to_failure", "project", []string{"user@mongodb"}, []string{}},
}
notificationSettings.Teams = []Team{
Team{
"myteam",
"*****@*****.**",
[]Subscription{Subscription{"task", []string{}, []string{"task_failure"}}},
},
}
notificationSettings.PatchNotifications = []Subscription{
Subscription{"patch_project", []string{}, []string{}},
}
notificationKeyFailure := NotificationKey{"project", "task_failure", "task", "gitter_request"}
notificationKeyToFailure := NotificationKey{"project", "task_success_to_failure", "task",
"gitter_request"}
ae, err := createEnvironment(TestConfig, map[string]interface{}{})
So(err, ShouldBeNil)
emails, err := ProcessNotifications(ae, "config_test", notificationSettings, false)
So(err, ShouldBeNil)
So(len(emails[notificationKeyFailure]), ShouldEqual, 2)
So(emails[notificationKeyFailure][0].GetSubject(), ShouldEqual,
"[MCI-FAILURE ] possible MCI failure in displayName (failed on build1)")
So(emails[notificationKeyFailure][1].GetSubject(), ShouldEqual,
"[MCI-FAILURE ] possible MCI failure in displayName (failed on build1)")
So(len(emails[notificationKeyToFailure]), ShouldEqual, 1)
So(emails[notificationKeyToFailure][0].GetSubject(), ShouldEqual,
"[MCI-FAILURE ] possible MCI failure in displayName (transitioned to "+
"failure on build1)")
})
Convey("SendNotifications should send emails correctly", func() {
notificationSettings := &MCINotification{}
notificationSettings.Notifications = []Notification{
Notification{"task_failure", "project", []string{"user@mongodb"}, []string{}},
}
notificationSettings.Teams = []Team{
Team{
"myteam",
"*****@*****.**",
[]Subscription{Subscription{"task", []string{}, []string{"task_failure"}}},
},
}
notificationSettings.PatchNotifications = []Subscription{
Subscription{"patch_project", []string{}, []string{}},
}
fakeTask, err := model.FindOneTask(bson.M{"_id": "task8"}, bson.M{}, []string{})
notificationKey := NotificationKey{"project", "task_failure", "task", "gitter_request"}
triggeredNotification := TriggeredTaskNotification{
fakeTask,
nil,
[]ChangeInfo{},
notificationKey,
"[MCI-FAILURE]",
"failed",
}
email := TaskEmail{
EmailBase{
"This is the email body",
"This is the email subject",
triggeredNotification.Info,
},
triggeredNotification,
}
m := make(map[NotificationKey][]Email)
m[notificationKey] = []Email{&email}
mailer := MockMailer{}
mockSettings := evergreen.Settings{Notify: evergreen.NotifyConfig{}}
err = SendNotifications(&mockSettings, notificationSettings, m, mailer)
So(err, ShouldBeNil)
So(len(emailSubjects), ShouldEqual, 1)
So(emailSubjects[0], ShouldEqual,
"This is the email subject")
So(emailBodies[0], ShouldEqual,
"This is the email body")
})
})
}
func TestWarnExpiringSpawnedHosts(t *testing.T) {
testConfig := evergreen.TestConfig()
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
Convey("When building warnings for spawned hosts that will be expiring"+
" soon", t, func() {
// reset the db
testutil.HandleTestingErr(db.ClearCollections(host.Collection),
t, "error clearing hosts collection")
Convey("any hosts not expiring within a threshold should not trigger"+
" warnings", func() {
// this host does not expire within the first notification
// threshold
host1 := &host.Host{
Id: "h1",
ExpirationTime: time.Now().Add(time.Hour * 15),
}
testutil.HandleTestingErr(host1.Insert(), t, "error inserting host")
warnings, err := spawnHostExpirationWarnings(testConfig)
So(err, ShouldBeNil)
So(len(warnings), ShouldEqual, 0)
})
Convey("any thresholds for which warnings have already been sent"+
" should be ignored", func() {
// this host meets the first notification warning threshold
host1 := &host.Host{
Id: "h1",
ExpirationTime: time.Now().Add(time.Hour * 10),
Notifications: map[string]bool{
"720": true, // the first threshold in minutes
},
}
testutil.HandleTestingErr(host1.Insert(), t, "error inserting host")
warnings, err := spawnHostExpirationWarnings(testConfig)
So(err, ShouldBeNil)
So(len(warnings), ShouldEqual, 0)
})
Convey("the most recent threshold crossed should be used to create"+
" the warning", func() {
// this host meets both notification warning thresholds
host1 := &host.Host{
Id: "h1",
ExpirationTime: time.Now().Add(time.Minute * 10),
}
testutil.HandleTestingErr(host1.Insert(), t, "error inserting host")
warnings, err := spawnHostExpirationWarnings(testConfig)
So(err, ShouldBeNil)
So(len(warnings), ShouldEqual, 1)
// execute the callback, make sure the correct threshold is set
So(warnings[0].callback(warnings[0].host, warnings[0].threshold), ShouldBeNil)
host1, err = host.FindOne(host.ById("h1"))
So(err, ShouldBeNil)
So(host1.Notifications["120"], ShouldBeTrue)
})
Convey("hosts that are quarantined or have already expired should not"+
" merit warnings", func() {
// quarantined host
host1 := &host.Host{
Id: "h1",
Status: evergreen.HostQuarantined,
ExpirationTime: time.Now().Add(time.Minute * 10),
}
testutil.HandleTestingErr(host1.Insert(), t, "error inserting host")
// terminated host
host2 := &host.Host{
Id: "h2",
Status: evergreen.HostTerminated,
ExpirationTime: time.Now().Add(time.Minute * 10),
}
testutil.HandleTestingErr(host2.Insert(), t, "error inserting host")
// past the expiration. no warning needs to be sent since this host
// is theoretically about to be terminated, at which time a
// notification will be sent
host3 := &host.Host{
Id: "h3",
ExpirationTime: time.Now().Add(-time.Minute * 10),
}
testutil.HandleTestingErr(host3.Insert(), t, "error inserting host")
warnings, err := spawnHostExpirationWarnings(testConfig)
So(err, ShouldBeNil)
So(len(warnings), ShouldEqual, 0)
})
})
}
func init() {
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(evergreen.TestConfig()))
}
NotificationType: taskType,
NotificationRequester: evergreen.RepotrackerVersionRequester,
}
allNotificationKeys = []NotificationKey{
buildFailureNotificationKey,
buildSucceessNotificationKey,
buildCompletionNotificationKey,
buildSuccessToFailureNotificationKey,
taskFailureNotificationKey,
taskSucceessNotificationKey,
taskCompletionNotificationKey,
taskSuccessToFailureNotificationKey,
}
)
var TestConfig = evergreen.TestConfig()
func TestNotify(t *testing.T) {
if evergreen.TestConfig().Notify.LogFile != "" {
evergreen.SetLogger(evergreen.TestConfig().Notify.LogFile)
}
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(TestConfig))
emailSubjects = make([]string, 0)
emailBodies = make([]string, 0)
Convey("When running notification handlers", t, func() {
ae, err := createEnvironment(TestConfig, map[string]interface{}{})
So(err, ShouldBeNil)
Convey("Build-specific handlers should return the correct emails", func() {
"github.com/evergreen-ci/evergreen/model/artifact"
"github.com/evergreen-ci/evergreen/rest"
"github.com/evergreen-ci/evergreen/testutil"
"github.com/evergreen-ci/render"
. "github.com/smartystreets/goconvey/convey"
"math/rand"
"net/http"
"net/http/httptest"
"path/filepath"
"testing"
"time"
)
var (
taskTestConfig = evergreen.TestConfig()
)
func init() {
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(taskTestConfig))
}
func TestGetTaskInfo(t *testing.T) {
userManager, err := auth.LoadUserManager(taskTestConfig.AuthConfig)
testutil.HandleTestingErr(err, t, "Failure in loading UserManager from config")
uis := UIServer{
RootURL: taskTestConfig.Ui.Url,
Settings: *taskTestConfig,
UserManager: userManager,
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")
})
})
})
}
}
}
package taskrunner
import (
"fmt"
"github.com/evergreen-ci/evergreen"
"github.com/evergreen-ci/evergreen/db"
"github.com/evergreen-ci/evergreen/model"
"github.com/evergreen-ci/evergreen/model/host"
. "github.com/smartystreets/goconvey/convey"
"testing"
)
var (
taskRunnerTestConf = evergreen.TestConfig()
)
func init() {
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(taskRunnerTestConf))
if taskRunnerTestConf.TaskRunner.LogFile != "" {
evergreen.SetLogger(taskRunnerTestConf.TaskRunner.LogFile)
}
}
// mock implementations, for testing purposes
type MockHostFinder struct{}
func (self *MockHostFinder) FindAvailableHosts() ([]host.Host, error) {
return nil, fmt.Errorf("FindAvailableHosts not implemented")
}
package scheduler
import (
"github.com/evergreen-ci/evergreen"
"github.com/evergreen-ci/evergreen/db"
"github.com/evergreen-ci/evergreen/model"
"github.com/evergreen-ci/evergreen/model/build"
"github.com/evergreen-ci/evergreen/testutil"
. "github.com/smartystreets/goconvey/convey"
"testing"
)
var (
setupFuncsTestConf = evergreen.TestConfig()
)
func init() {
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(taskFinderTestConf))
if setupFuncsTestConf.Scheduler.LogFile != "" {
evergreen.SetLogger(setupFuncsTestConf.Scheduler.LogFile)
}
}
func TestSetupFuncs(t *testing.T) {
var taskPrioritizer *CmpBasedTaskPrioritizer
var taskIds []string
var tasks []model.Task
Convey("When running the setup funcs for task prioritizing", t, func() {
func TestWarnSlowProvisioningHosts(t *testing.T) {
testConfig := evergreen.TestConfig()
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
Convey("When building warnings for hosts that are taking a long time to"+
" provision", t, func() {
// reset the db
testutil.HandleTestingErr(db.ClearCollections(host.Collection),
t, "error clearing hosts collection")
Convey("hosts that have not hit the threshold should not trigger a"+
" warning", func() {
host1 := &host.Host{
Id: "h1",
StartedBy: evergreen.User,
CreationTime: time.Now().Add(-10 * time.Minute),
}
testutil.HandleTestingErr(host1.Insert(), t, "error inserting host")
warnings, err := slowProvisioningWarnings(testConfig)
So(err, ShouldBeNil)
So(len(warnings), ShouldEqual, 0)
})
Convey("hosts that have already triggered a notification should not"+
" trigger another", func() {
host1 := &host.Host{
Id: "h1",
StartedBy: evergreen.User,
CreationTime: time.Now().Add(-1 * time.Hour),
Notifications: map[string]bool{
slowProvisioningWarning: true,
},
}
testutil.HandleTestingErr(host1.Insert(), t, "error inserting host")
warnings, err := slowProvisioningWarnings(testConfig)
So(err, ShouldBeNil)
So(len(warnings), ShouldEqual, 0)
})
Convey("terminated hosts should not trigger a warning", func() {
host1 := &host.Host{
Id: "h1",
StartedBy: evergreen.User,
Status: evergreen.HostTerminated,
CreationTime: time.Now().Add(-1 * time.Hour),
}
testutil.HandleTestingErr(host1.Insert(), t, "error inserting host")
warnings, err := slowProvisioningWarnings(testConfig)
So(err, ShouldBeNil)
So(len(warnings), ShouldEqual, 0)
})
Convey("hosts that are at the threshold and have not previously"+
" triggered a warning should trigger one", func() {
host1 := &host.Host{
Id: "h1",
StartedBy: evergreen.User,
CreationTime: time.Now().Add(-1 * time.Hour),
}
testutil.HandleTestingErr(host1.Insert(), t, "error inserting host")
warnings, err := slowProvisioningWarnings(testConfig)
So(err, ShouldBeNil)
So(len(warnings), ShouldEqual, 1)
// make sure running the callback sets the notification key
So(warnings[0].callback(warnings[0].host, warnings[0].threshold), ShouldBeNil)
host1, err = host.FindOne(host.ById("h1"))
So(err, ShouldBeNil)
So(host1.Notifications[slowProvisioningWarning], ShouldBeTrue)
})
})
}
