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 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 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 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 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) } } }) }) }
// 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 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 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 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 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 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 TestAttachRawResults(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_raw.yml") resultsLoc := filepath.Join(cwd, "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 := agentutil.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 := &comm.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) }) }) }) } } }) }) }