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 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 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 SetupAPITestData(taskDisplayName string, isPatch bool, t *testing.T) (*model.Task, *build.Build, error) {
//ignore errs here because the ns might just not exist.
testutil.HandleTestingErr(
db.ClearCollections(model.TasksCollection, build.Collection,
host.Collection, version.Collection, patch.Collection),
t, "Failed to clear test collections")
testHost := &host.Host{
Id: "testHost",
Host: "testHost",
RunningTask: "testTaskId",
StartedBy: evergreen.User,
}
testutil.HandleTestingErr(testHost.Insert(), t, "failed to insert host")
task := &model.Task{
Id: "testTaskId",
BuildId: "testBuildId",
DistroId: "rhel55",
BuildVariant: "linux-64",
Project: "mongodb-mongo-master",
DisplayName: taskDisplayName,
HostId: "testHost",
Version: "testVersionId",
Secret: "testTaskSecret",
Status: evergreen.TaskDispatched,
Requester: evergreen.RepotrackerVersionRequester,
}
if isPatch {
task.Requester = evergreen.PatchVersionRequester
}
testutil.HandleTestingErr(task.Insert(), t, "failed to insert task")
version := &version.Version{Id: "testVersionId", BuildIds: []string{task.BuildId}}
testutil.HandleTestingErr(version.Insert(), t, "failed to insert version %v")
if isPatch {
modulePatchContent, err := ioutil.ReadFile("testdata/testmodule.patch")
testutil.HandleTestingErr(err, t, "failed to read test module patch file %v")
patch := &patch.Patch{
Status: evergreen.PatchCreated,
Version: version.Id,
Patches: []patch.ModulePatch{
{
ModuleName: "enterprise",
Githash: "c2d7ce942a96d7dacd27c55b257e3f2774e04abf",
PatchSet: patch.PatchSet{Patch: string(modulePatchContent)},
},
},
}
testutil.HandleTestingErr(patch.Insert(), t, "failed to insert patch %v")
}
session, _, err := db.GetGlobalSessionFactory().GetSession()
testutil.HandleTestingErr(err, t, "couldn't get db session!")
//Remove any logs for our test task from previous runs.
_, err = session.DB(model.TaskLogDB).C(model.TaskLogCollection).RemoveAll(bson.M{"t_id": task.Id})
testutil.HandleTestingErr(err, t, "failed to remove logs")
build := &build.Build{Id: "testBuildId", Tasks: []build.TaskCache{build.NewTaskCache(task.Id, task.DisplayName, true)}}
testutil.HandleTestingErr(build.Insert(), t, "failed to insert build %v")
return task, build, nil
}