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 TestFinalizePatch(t *testing.T) {
testutil.ConfigureIntegrationTest(t, patchTestConfig, "TestFinalizePatch")
Convey("With FinalizePatch on a project and commit event generated from GetPatchedProject path",
t, func() {
configPatch := resetPatchSetup(t, configFilePath)
Convey("a patched config should drive version creation", func() {
project, err := GetPatchedProject(configPatch, patchTestConfig)
So(err, ShouldBeNil)
yamlBytes, err := yaml.Marshal(project)
So(err, ShouldBeNil)
configPatch.PatchedConfig = string(yamlBytes)
version, err := model.FinalizePatch(configPatch, patchTestConfig)
So(err, ShouldBeNil)
So(version, ShouldNotBeNil)
// ensure the relevant builds/tasks were created
builds, err := build.Find(build.All)
So(err, ShouldBeNil)
So(len(builds), ShouldEqual, 1)
So(len(builds[0].Tasks), ShouldEqual, 2)
tasks, err := task.Find(task.All)
So(err, ShouldBeNil)
So(len(tasks), ShouldEqual, 2)
})
Convey("a patch that does not include the remote config should not "+
"drive version creation", func() {
patchedConfigFile := "fakeInPatchSoNotPatched"
configPatch := resetPatchSetup(t, patchedConfigFile)
project, err := GetPatchedProject(configPatch, patchTestConfig)
So(err, ShouldBeNil)
yamlBytes, err := yaml.Marshal(project)
So(err, ShouldBeNil)
configPatch.PatchedConfig = string(yamlBytes)
version, err := model.FinalizePatch(configPatch, patchTestConfig)
So(err, ShouldBeNil)
So(version, ShouldNotBeNil)
So(err, ShouldBeNil)
So(version, ShouldNotBeNil)
// ensure the relevant builds/tasks were created
builds, err := build.Find(build.All)
So(err, ShouldBeNil)
So(len(builds), ShouldEqual, 1)
So(len(builds[0].Tasks), ShouldEqual, 1)
tasks, err := task.Find(task.All)
So(err, ShouldBeNil)
So(len(tasks), ShouldEqual, 1)
})
Reset(func() {
db.Clear(distro.Collection)
})
})
}
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 TestS3ParseUrl(t *testing.T) {
testutil.ConfigureIntegrationTest(t, testConfig, "TestS3ParseUrl")
Convey("When given an S3 location to parse...", t, func() {
Convey("the bucket and path should be parsed correctly", func() {
bucket, path, err := GetS3Location(testURL)
So(err, ShouldEqual, nil)
So(bucket, ShouldEqual, testURLBucket)
So(path, ShouldEqual, testURLPath)
})
})
}
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 TestJiraIntegration(t *testing.T) {
testutil.ConfigureIntegrationTest(t, testConfig, "TestJiraIntegration")
Convey("With a JIRA rest interface that makes a valid request", t, func() {
jira := JiraHandler{liveHttp{}, testConfig.Jira.Host, testConfig.Jira.Username, testConfig.Jira.Password}
Convey("the request for a ticket should return a valid ticket response", func() {
ticket, err := jira.GetJIRATicket("BF-1")
So(err, ShouldBeNil)
So(ticket.Key, ShouldEqual, "BF-1")
So(ticket.Fields.Project.Name, ShouldEqual, "Build Failures")
})
})
}
func TestCLIFetchSource(t *testing.T) {
testutil.ConfigureIntegrationTest(t, testConfig, "TestCLIFetchSource")
Convey("with a task containing patches and modules", t, func() {
testSetup := setupCLITestHarness()
err := os.RemoveAll("source-patch-1_sample")
So(err, ShouldBeNil)
// first, create a patch
patchSub := patchSubmission{"sample",
testPatch,
"sample patch",
"3c7bfeb82d492dc453e7431be664539c35b5db4b",
"all",
[]string{"all"},
false}
// Set up a test patch that contains module changes
ac, rc, _, err := getAPIClients(&Options{testSetup.settingsFilePath})
So(err, ShouldBeNil)
newPatch, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
err = ac.UpdatePatchModule(newPatch.Id.Hex(), "render-module", testModulePatch, "1e5232709595db427893826ce19289461cba3f75")
So(ac.FinalizePatch(newPatch.Id.Hex()), ShouldBeNil)
patches, err = ac.GetPatches(0)
So(err, ShouldBeNil)
testTask, err := task.FindOne(
db.Query(bson.M{
task.VersionKey: patches[0].Version,
task.BuildVariantKey: "ubuntu",
}))
So(err, ShouldBeNil)
So(testTask, ShouldNotBeNil)
err = fetchSource(ac, rc, "", testTask.Id, false)
So(err, ShouldBeNil)
fileStat, err := os.Stat("./source-patch-1_sample/README.md")
So(err, ShouldBeNil)
// If patch was applied correctly, README.md will have a non-zero size
So(fileStat.Size, ShouldNotEqual, 0)
// If module was fetched, "render" directory should have been created.
// The "blah.md" file should have been created if the patch was applied successfully.
fileStat, err = os.Stat("./source-patch-1_sample/modules/render-module/blah.md")
So(err, ShouldBeNil)
So(fileStat.Size, ShouldNotEqual, 0)
})
}
func TestGetPatchedProject(t *testing.T) {
testutil.ConfigureIntegrationTest(t, patchTestConfig, "TestConfigurePatch")
Convey("With calling GetPatchedProject with a config and remote configuration path",
t, func() {
configPatch := resetPatchSetup(t, configFilePath)
Convey("Calling GetPatchedProject returns a valid project given a patch and settings", func() {
project, err := GetPatchedProject(configPatch, patchTestConfig)
So(err, ShouldBeNil)
So(project, ShouldNotBeNil)
})
Reset(func() {
db.Clear(distro.Collection)
})
})
}
func TestTaskAbortion(t *testing.T) {
setupTlsConfigs(t)
testutil.ConfigureIntegrationTest(t, testConfig, "TestTaskAbortion")
for tlsString, tlsConfig := range tlsConfigs {
for _, testSetup := range testSetups {
Convey(testSetup.testSpec, t, func() {
Convey("With agent running a slow test and live API server over "+tlsString, func() {
testTask, _, err := setupAPITestData(testConfig, "very_slow_task", "linux-64", NoPatch, t)
testutil.HandleTestingErr(err, t, "Failed to find test task")
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
Convey("when the abort signal is triggered on the task", func() {
go func() {
// Wait for a few seconds, then switch the task to aborted!
time.Sleep(3 * time.Second)
err := testTask.Abort("", true)
testutil.HandleTestingErr(err, t, "Failed to abort test task")
fmt.Println("aborted task.")
}()
// actually run the task.
// this function won't return until the whole thing is done.
_, err := testAgent.RunTask()
So(err, ShouldBeNil)
testAgent.APILogger.Flush()
time.Sleep(1 * time.Second)
printLogsForTask(testTask.Id)
Convey("the pre and post-run scripts should have run", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "Received abort signal - stopping."), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "done with very_slow_task!"), ShouldBeFalse)
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Failed to find test task")
So(testTask.Status, ShouldEqual, evergreen.TaskUndispatched)
})
})
})
})
}
}
}
func TestTaskFailures(t *testing.T) {
setupTlsConfigs(t)
testutil.ConfigureIntegrationTest(t, testConfig, "TestTaskFailures")
for tlsString, tlsConfig := range tlsConfigs {
for _, testSetup := range testSetups {
Convey(testSetup.testSpec, t, func() {
Convey("With agent running a failing test and live API server over "+tlsString, func() {
testTask, _, err := setupAPITestData(testConfig, "failing_task",
"linux-64", NoPatch, t)
testutil.HandleTestingErr(err, t, "Couldn't create test data: %v", err)
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
printLogsForTask(testTask.Id)
Convey("the pre and post-run scripts should have run", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
Convey("the task should have run up until its first failure", func() {
So(scanLogsForTask(testTask.Id, "starting failing_task!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "done with failing_task!"), ShouldBeFalse)
})
Convey("the tasks's final status should be FAILED", func() {
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Failed to find test task")
So(testTask.Status, ShouldEqual, evergreen.TaskFailed)
So(testTask.Details.Status, ShouldEqual, evergreen.TaskFailed)
So(testTask.Details.Description, ShouldEqual, "failing shell command")
So(testTask.Details.TimedOut, ShouldBeFalse)
So(testTask.Details.Type, ShouldEqual, model.SystemCommandType)
})
})
})
})
}
}
}
func 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 TestGetRemoteConfig(t *testing.T) {
dropTestDB(t)
var self GithubRepositoryPoller
testutil.ConfigureIntegrationTest(t, testConfig, "TestGetRemoteConfig")
Convey("When fetching a specific github revision configuration...",
t, func() {
self.ProjectRef = &model.ProjectRef{
Identifier: "mci-test",
DisplayName: "MCI Test",
Owner: "deafgoat",
Repo: "config",
Branch: "master",
RepoKind: "github",
RemotePath: "random.txt",
Enabled: true,
Private: false,
BatchTime: 60,
Tracked: true,
}
self.OauthToken = testConfig.Credentials[self.ProjectRef.RepoKind]
Convey("The config file at the requested revision should be "+
"exactly what is returned", func() {
projectConfig, err := self.GetRemoteConfig(firstRemoteConfigRef)
testutil.HandleTestingErr(err, t, "Error fetching github "+
"configuration file")
So(projectConfig, ShouldNotBeNil)
So(len(projectConfig.Tasks), ShouldEqual, 0)
projectConfig, err = self.GetRemoteConfig(secondRemoteConfigRef)
testutil.HandleTestingErr(err, t, "Error fetching github "+
"configuration file")
So(projectConfig, ShouldNotBeNil)
So(len(projectConfig.Tasks), ShouldEqual, 1)
})
Convey("an invalid revision should return an error", func() {
_, err := self.GetRemoteConfig("firstRemoteConfRef")
So(err, ShouldNotBeNil)
})
Convey("an invalid project configuration should error out", func() {
_, err := self.GetRemoteConfig(badRemoteConfigRef)
So(err, ShouldNotBeNil)
})
})
}
func TestGetRevisionsSinceWithPaging(t *testing.T) {
dropTestDB(t)
testutil.ConfigureIntegrationTest(t, testConfig, "TestGetRevisionsSince")
grp := &GithubRepositoryPoller{
ProjectRef: evgProjectRef,
OauthToken: testConfig.Credentials[evgProjectRef.RepoKind],
}
Convey("When fetching commits from the evergreen repository", t, func() {
Convey("fetching > the size of a github page should succeed", func() {
revisions, err := grp.GetRevisionsSince(distantEvgRevision, 5000)
So(err, ShouldBeNil)
Convey("and the revision should be found", func() {
So(len(revisions), ShouldNotEqual, 0)
})
})
})
}
func TestGetGithubCommits(t *testing.T) {
testutil.ConfigureIntegrationTest(t, testConfig, "TestGetGithubCommits")
Convey("When requesting github commits with a valid OAuth token...", t, func() {
Convey("Fetching commits from the repository should not return any errors", func() {
commitsURL := "https://api.github.com/repos/deafgoat/mci-test/commits"
_, _, err := GetGithubCommits(testConfig.Credentials["github"], commitsURL)
So(err, ShouldBeNil)
})
Convey("Fetching commits from the repository should return all available commits", func() {
commitsURL := "https://api.github.com/repos/deafgoat/mci-test/commits"
githubCommits, _, err := GetGithubCommits(testConfig.Credentials["github"], commitsURL)
So(err, ShouldBeNil)
So(len(githubCommits), ShouldEqual, 3)
})
})
}
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 TestFetchRevisions(t *testing.T) {
dropTestDB(t)
testutil.ConfigureIntegrationTest(t, testConfig, "TestFetchRevisions")
Convey("With a GithubRepositoryPoller with a valid OAuth token...", t, func() {
err := testutil.CreateTestLocalConfig(testConfig, "mci-test", "")
So(err, ShouldBeNil)
repoTracker := RepoTracker{
testConfig,
projectRef,
NewGithubRepositoryPoller(projectRef, testConfig.Credentials["github"]),
}
Convey("Fetching commits from the repository should not return "+
"any errors", func() {
So(repoTracker.FetchRevisions(10), ShouldBeNil)
})
Convey("Only get 3 revisions from the given repository if given a "+
"limit of 4 commits where only 3 exist", func() {
testutil.HandleTestingErr(repoTracker.FetchRevisions(4), t,
"Error running repository process %v")
numVersions, err := version.TotalVersions(bson.M{})
testutil.HandleTestingErr(err, t, "Error finding all versions")
So(numVersions, ShouldEqual, 3)
})
Convey("Only get 2 revisions from the given repository if given a "+
"limit of 2 commits where 3 exist", func() {
testutil.HandleTestingErr(repoTracker.FetchRevisions(2), t,
"Error running repository process %v")
numVersions, err := version.TotalVersions(bson.M{})
testutil.HandleTestingErr(err, t, "Error finding all versions")
So(numVersions, ShouldEqual, 2)
})
Reset(func() {
dropTestDB(t)
})
})
}
func TestPutS3File(t *testing.T) {
testutil.ConfigureIntegrationTest(t, testConfig, "TestPutS3File")
Convey("When given a file to copy to S3...", t, func() {
Convey("a valid source file with a long key should return an error ", func() {
//Make a test file with some random content.
tempfile, err := ioutil.TempFile("", "randomString")
So(err, ShouldEqual, nil)
randStr := util.RandomString()
_, err = tempfile.Write([]byte(randStr))
So(err, ShouldEqual, nil)
tempfile.Close()
// put the test file on S3
auth := &aws.Auth{
AccessKey: testConfig.Providers.AWS.Id,
SecretKey: testConfig.Providers.AWS.Secret,
}
longURLKey := sourceURL + strings.Repeat("suffix", 300)
err = PutS3File(auth, tempfile.Name(), longURLKey, "application/x-tar", "public-read")
So(err, ShouldNotEqual, nil)
})
Convey("a valid source file with a valid key should return no errors", func() {
//Make a test file with some random content.
tempfile, err := ioutil.TempFile("", "randomString")
So(err, ShouldEqual, nil)
randStr := util.RandomString()
_, err = tempfile.Write([]byte(randStr))
So(err, ShouldEqual, nil)
tempfile.Close()
// put the test file on S3
auth := &aws.Auth{
AccessKey: testConfig.Providers.AWS.Id,
SecretKey: testConfig.Providers.AWS.Secret,
}
err = PutS3File(auth, tempfile.Name(), sourceURL, "application/x-tar", "public-read")
So(err, ShouldEqual, nil)
})
})
}
func TestGetRevisionsSince(t *testing.T) {
dropTestDB(t)
var self GithubRepositoryPoller
testutil.ConfigureIntegrationTest(t, testConfig, "TestGetRevisionsSince")
Convey("When fetching github revisions (by commit) - from a repo "+
"containing 3 commits - given a valid Oauth token...", t, func() {
self.ProjectRef = projectRef
self.OauthToken = testConfig.Credentials[self.ProjectRef.RepoKind]
Convey("There should be only two revisions since the first revision",
func() {
// The test repository contains only 3 revisions with revision
// 99162ee5bc41eb314f5bb01bd12f0c43e9cb5f32 being the first
// revision
revisions, err := self.GetRevisionsSince(firstRevision, 10)
testutil.HandleTestingErr(err, t, "Error fetching github revisions")
So(len(revisions), ShouldEqual, 2)
})
Convey("There should be no revisions since the last revision", func() {
// The test repository contains only 3 revisions with revision
// d0d878e81b303fd2abbf09331e54af41d6cd0c7d being the last revision
revisions, err := self.GetRevisionsSince(lastRevision, 10)
testutil.HandleTestingErr(err, t, "Error fetching github revisions")
So(len(revisions), ShouldEqual, 0)
})
Convey("There should be an error returned if the requested revision "+
"isn't found", func() {
// The test repository contains only 3 revisions with revision
// d0d878e81b303fd2abbf09331e54af41d6cd0c7d being the last revision
revisions, err := self.GetRevisionsSince("lastRevision", 10)
So(len(revisions), ShouldEqual, 0)
So(err, ShouldNotBeNil)
})
})
}
func TestGetAllRevisions(t *testing.T) {
dropTestDB(t)
var self GithubRepositoryPoller
testutil.ConfigureIntegrationTest(t, testConfig, "TestGetAllRevisions")
Convey("When fetching recent github revisions (by count) - from a repo "+
"containing 3 commits - given a valid Oauth token...", t, func() {
self.ProjectRef = projectRef
self.OauthToken = testConfig.Credentials[self.ProjectRef.RepoKind]
// Even though we're requesting far more revisions than exists in the
// remote repository, we should only get the revisions that actually
// exist upstream - a total of 3
Convey("There should be only three revisions even if you request more "+
"than 3", func() {
revisions, err := self.GetRecentRevisions(123)
testutil.HandleTestingErr(err, t, "Error fetching github revisions")
So(len(revisions), ShouldEqual, 3)
})
// Get only one recent revision and ensure it's the right revision
Convey("There should be only be one if you request 1 and it should be "+
"the latest", func() {
revisions, err := self.GetRecentRevisions(1)
testutil.HandleTestingErr(err, t, "Error fetching github revisions")
So(len(revisions), ShouldEqual, 1)
So(revisions[0].Revision, ShouldEqual, lastRevision)
})
// Get no recent revisions
Convey("There should be no revisions if you request 0", func() {
revisions, err := self.GetRecentRevisions(0)
testutil.HandleTestingErr(err, t, "Error fetching github revisions")
So(len(revisions), ShouldEqual, 0)
})
})
}
func TestGetChangedFiles(t *testing.T) {
dropTestDB(t)
var grp GithubRepositoryPoller
testutil.ConfigureIntegrationTest(t, testConfig, "TestGetAllRevisions")
Convey("When fetching changed files from evergreen-ci/evergreen ", t, func() {
grp.ProjectRef = evgProjectRef
grp.OauthToken = testConfig.Credentials[grp.ProjectRef.RepoKind]
r1 := "b11fcb25624c6a0649dd35b895f5b550d649a128"
Convey("the revision "+r1+" should have 8 files", func() {
files, err := grp.GetChangedFiles(r1)
So(err, ShouldBeNil)
So(len(files), ShouldEqual, 8)
So(files, ShouldContain, "cloud/providers/ec2/ec2.go")
So(files, ShouldContain, "public/static/dist/css/styles.css")
// ...probably don't need to check all 8
})
r2 := "3c0133dbd4b35418c11df7b6e3a1ae31f966de42"
Convey("the revision "+r2+" should have 1 file", func() {
files, err := grp.GetChangedFiles(r2)
So(err, ShouldBeNil)
So(len(files), ShouldEqual, 1)
So(files, ShouldContain, "ui/rest_project.go")
})
Convey("a revision that does not exist should fail", func() {
files, err := grp.GetChangedFiles("00000000000000000000000000")
So(err, ShouldNotBeNil)
So(err.Error(), ShouldContainSubstring, "Not Found")
So(files, ShouldBeNil)
})
})
}
func TestStoreRepositoryRevisions(t *testing.T) {
dropTestDB(t)
testutil.ConfigureIntegrationTest(t, testConfig, "TestStoreRepositoryRevisions")
Convey("When storing revisions gotten from a repository...", t, func() {
err := testutil.CreateTestLocalConfig(testConfig, "mci-test", "")
So(err, ShouldBeNil)
repoTracker := RepoTracker{testConfig, projectRef, NewGithubRepositoryPoller(projectRef,
testConfig.Credentials["github"])}
// insert distros used in testing.
d := distro.Distro{Id: "test-distro-one"}
So(d.Insert(), ShouldBeNil)
d.Id = "test-distro-two"
So(d.Insert(), ShouldBeNil)
Convey("On storing a single repo revision, we expect a version to be created"+
" in the database for this project, which should be retrieved when we search"+
" for this project's most recent version", func() {
createTime := time.Now()
revisionOne := *createTestRevision("firstRevision", createTime)
revisions := []model.Revision{revisionOne}
resultVersion, err := repoTracker.StoreRevisions(revisions)
testutil.HandleTestingErr(err, t, "Error storing repository revisions %v")
newestVersion, err := version.FindOne(version.ByMostRecentForRequester(projectRef.String(), evergreen.RepotrackerVersionRequester))
testutil.HandleTestingErr(err, t, "Error retreiving newest version %v")
So(resultVersion, ShouldResemble, newestVersion)
})
Convey("On storing several repo revisions, we expect a version to be created "+
"for each revision", func() {
createTime := time.Now()
laterCreateTime := createTime.Add(time.Duration(4 * time.Hour))
revisionOne := *createTestRevision("one", laterCreateTime)
revisionTwo := *createTestRevision("two", createTime)
revisions := []model.Revision{revisionOne, revisionTwo}
_, err := repoTracker.StoreRevisions(revisions)
testutil.HandleTestingErr(err, t, "Error storing repository revisions %v")
versionOne, err := version.FindOne(version.ByProjectIdAndRevision(projectRef.Identifier, revisionOne.Revision))
testutil.HandleTestingErr(err, t, "Error retrieving first stored version %v")
versionTwo, err := version.FindOne(version.ByProjectIdAndRevision(projectRef.Identifier, revisionTwo.Revision))
testutil.HandleTestingErr(err, t, "Error retreiving second stored version %v")
So(versionOne.Revision, ShouldEqual, revisionOne.Revision)
So(versionTwo.Revision, ShouldEqual, revisionTwo.Revision)
})
Reset(func() {
dropTestDB(t)
})
})
Convey("When storing versions from repositories with remote configuration files...", t, func() {
project := createTestProject(nil, nil)
revisions := []model.Revision{
*createTestRevision("foo", time.Now().Add(1*time.Minute)),
}
poller := NewMockRepoPoller(project, revisions)
repoTracker := RepoTracker{
testConfig,
&model.ProjectRef{
Identifier: "testproject",
BatchTime: 10,
},
poller,
}
// insert distros used in testing.
d := distro.Distro{Id: "test-distro-one"}
So(d.Insert(), ShouldBeNil)
d.Id = "test-distro-two"
So(d.Insert(), ShouldBeNil)
Convey("We should not fetch configs for versions we already have stored.",
func() {
So(poller.ConfigGets, ShouldBeZeroValue)
// Store revisions the first time
_, err := repoTracker.StoreRevisions(revisions)
So(err, ShouldBeNil)
// We should have fetched the config once for each revision
So(poller.ConfigGets, ShouldEqual, len(revisions))
// Store them again
_, err = repoTracker.StoreRevisions(revisions)
So(err, ShouldBeNil)
// We shouldn't have fetched the config any additional times
// since we have already stored these versions
So(poller.ConfigGets, ShouldEqual, len(revisions))
},
)
Convey("We should handle invalid configuration files gracefully by storing a stub version",
func() {
errStrs := []string{"Someone dun' goof'd"}
poller.setNextError(projectConfigError{errStrs})
stubVersion, err := repoTracker.StoreRevisions(revisions)
// We want this error to get swallowed so a config error
// doesn't stop additional versions from getting created
So(err, ShouldBeNil)
So(stubVersion.Errors, ShouldResemble, errStrs)
},
)
Convey("If there is an error other than a config error while fetching a config, we should fail hard",
func() {
unexpectedError := errors.New("Something terrible has happened!!")
poller.setNextError(unexpectedError)
v, err := repoTracker.StoreRevisions(revisions)
So(v, ShouldBeNil)
So(err, ShouldEqual, unexpectedError)
},
)
Reset(func() {
dropTestDB(t)
})
})
}
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 TestS3PutAndGetMultiFile(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() {
testDataDir := "testdata"
bucket := "mci-test-uploads"
permissions := "private"
contentType := "application/x-tar"
remoteFilePrefix := "remote_mci_put_test-"
displayNamePrefix := "testfile-"
// create the local directory
localDir := filepath.Join(testDataDir, "put_test")
localFilePrefix := filepath.Join(localDir, "put_test_file")
defer func() {
testutil.HandleTestingErr(os.RemoveAll(testDataDir), t, "error removing test dir")
}()
testutil.HandleTestingErr(os.RemoveAll(localDir), t,
"Error removing directory")
testutil.HandleTestingErr(os.MkdirAll(localDir, 0755), t,
"Error creating directory")
fileInfos := []multiPutFileInfo{}
for i := 0; i < 5; i++ {
randStr := util.RandomString()
localPath := fmt.Sprintf("%s%d.txt", localFilePrefix, i)
localName := filepath.Base(localPath)
remoteName := fmt.Sprintf("%s%s", remoteFilePrefix, localName)
displayName := fmt.Sprintf("%s%s", displayNamePrefix, localName)
So(ioutil.WriteFile(localPath, []byte(randStr), 0755), ShouldBeNil)
fileInfo := multiPutFileInfo{
remoteName: remoteName,
localPath: localPath,
displayName: displayName,
data: randStr,
}
fileInfos = append(fileInfos, fileInfo)
}
Convey("the files should be put without error", func() {
includesFilter := []string{fmt.Sprintf("%s/*.txt", localDir)}
// 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_files_include_filter": includesFilter,
"remote_file": remoteFilePrefix,
"bucket": bucket,
"permissions": permissions,
"content_type": contentType,
"display_name": displayNamePrefix,
}
So(putCmd.ParseParams(putParams), ShouldBeNil)
So(putCmd.Put(), ShouldBeNil)
Convey("the files should each be gotten without error", func() {
for _, f := range fileInfos {
// next, get the file
getCmd := &S3GetCommand{}
getParams := map[string]interface{}{
"aws_key": conf.Providers.AWS.Id,
"aws_secret": conf.Providers.AWS.Secret,
"remote_file": f.remoteName,
"bucket": bucket,
"local_file": f.localPath,
"display_name": f.displayName,
}
So(getCmd.ParseParams(getParams), ShouldBeNil)
So(getCmd.Get(), ShouldBeNil)
// read in the file that was pulled down
fileContents, err := ioutil.ReadFile(f.localPath)
So(err, ShouldBeNil)
So(string(fileContents), ShouldEqual, f.data)
}
})
})
})
}
func TestS3Copy(t *testing.T) {
testutil.ConfigureIntegrationTest(t, testConfig, "TestS3Copy")
Convey("When given a source and destination URL to copy from/to...", t, func() {
Convey("a valid source file should be copied to the valid destination", func() {
//Make a test file with some random content.
tempfile, err := ioutil.TempFile("", "randomString")
So(err, ShouldEqual, nil)
randStr := util.RandomString()
_, err = tempfile.Write([]byte(randStr))
So(err, ShouldEqual, nil)
tempfile.Close()
// Put the test file on S3
auth := &aws.Auth{
AccessKey: testConfig.Providers.AWS.Id,
SecretKey: testConfig.Providers.AWS.Secret,
}
err = PutS3File(auth, tempfile.Name(), sourceURL, "application/x-tar", "public-read")
So(err, ShouldEqual, nil)
// Copy the test file over to another location
err = CopyS3File(auth, sourceURL, destUrl, "public-read")
So(err, ShouldEqual, nil)
// Ensure that the file was actually copied
rdr, err := GetS3File(auth, destUrl)
defer rdr.Close()
So(err, ShouldEqual, nil)
fileContents, err := ioutil.ReadAll(rdr)
So(err, ShouldEqual, nil)
So(string(fileContents), ShouldEqual, randStr)
})
Convey("a valid source file with a long key should return an error "+
"even if sent to a valid destination", func() {
//Make a test file with some random content.
tempfile, err := ioutil.TempFile("", "randomString")
So(err, ShouldEqual, nil)
randStr := util.RandomString()
_, err = tempfile.Write([]byte(randStr))
So(err, ShouldEqual, nil)
tempfile.Close()
// put the test file on S3
auth := &aws.Auth{
AccessKey: testConfig.Providers.AWS.Id,
SecretKey: testConfig.Providers.AWS.Secret,
}
longURLKey := sourceURL + strings.Repeat("suffix", 300)
err = PutS3File(auth, tempfile.Name(), longURLKey, "application/x-tar", "public-read")
So(err, ShouldNotEqual, nil)
})
Convey("a valid source file copied to a destination with too long a "+
"key name should return an error", func() {
//Make a test file with some random content.
tempfile, err := ioutil.TempFile("", "randomString")
So(err, ShouldEqual, nil)
randStr := util.RandomString()
_, err = tempfile.Write([]byte(randStr))
So(err, ShouldEqual, nil)
tempfile.Close()
// put the test file on S3
auth := &aws.Auth{
AccessKey: testConfig.Providers.AWS.Id,
SecretKey: testConfig.Providers.AWS.Secret,
}
err = PutS3File(auth, tempfile.Name(), sourceURL, "application/x-tar", "public-read")
So(err, ShouldEqual, nil)
longURLKey := sourceURL + strings.Repeat("suffix", 300)
// Attempt to copy the test file over to another location
err = CopyS3File(auth, sourceURL, longURLKey, "public-read")
So(err, ShouldNotEqual, nil)
// Ensure that the file was not copied
rdr, err := GetS3File(auth, longURLKey)
So(rdr, ShouldEqual, nil)
So(err, ShouldNotEqual, nil)
})
})
}
func TestPushTask(t *testing.T) {
testConfig := evergreen.TestConfig()
setupTlsConfigs(t)
db.SetGlobalSessionProvider(db.SessionFactoryFromConfig(testConfig))
testutil.ConfigureIntegrationTest(t, testConfig, "TestPushTask")
for tlsString, tlsConfig := range tlsConfigs {
for _, testSetup := range testSetups {
Convey(testSetup.testSpec, t, func() {
Convey("With agent running a push task "+tlsString, func() {
testTask, _, err := setupAPITestData(testConfig, evergreen.PushStage,
"linux-64", false, t)
testutil.HandleTestingErr(err, t, "Error setting up test data: %v", err)
testutil.HandleTestingErr(db.ClearCollections(artifact.Collection), t, "can't clear files collection")
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.Published, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := New(testServer.URL, testTask.Id, testTask.Secret, "", testConfig.Expansions["api_httpscert"])
testutil.HandleTestingErr(err, t, "Error making test agent: %v", err)
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
printLogsForTask(testTask.Id)
newDate := testAgent.taskConfig.Expansions.Get("new_date")
Convey("all scripts in task should have been run successfully", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "push task pre-run!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "push task post-run!"), ShouldBeTrue)
Convey("s3.put attaches task file properly", func() {
entry, err := artifact.FindOne(artifact.ByTaskId(testTask.Id))
So(err, ShouldBeNil)
So(len(entry.Files), ShouldEqual, 2)
for _, element := range entry.Files {
So(element.Name, ShouldNotEqual, "")
}
So(entry.Files[0].Name, ShouldEqual, "push_file")
link := "https://s3.amazonaws.com/build-push-testing/pushtest-stage/unittest-testTaskId-DISTRO_EXP-BUILDVAR_EXP-FILE_EXP.txt"
So(entry.Files[0].Link, ShouldEqual, link)
})
Convey("s3.copy attached task file properly", func() {
entry, err := artifact.FindOne(artifact.ByTaskId(testTask.Id))
So(err, ShouldBeNil)
So(len(entry.Files), ShouldNotEqual, 0)
So(entry.Files[0].Name, ShouldEqual, "push_file")
So(entry.Files[1].Name, ShouldEqual, "copy_file")
So(entry.Files[0].Link, ShouldEqual, "https://s3.amazonaws.com/build-push-testing/pushtest-stage/unittest-testTaskId-DISTRO_EXP-BUILDVAR_EXP-FILE_EXP.txt")
So(entry.Files[1].Link, ShouldEqual,
"https://s3.amazonaws.com/build-push-testing/pushtest/unittest-DISTRO_EXP-BUILDVAR_EXP-FILE_EXP-latest.txt")
})
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Error finding test task: %v", err)
So(testTask.Status, ShouldEqual, evergreen.TaskSucceeded)
// Check the file written to s3 is what we expected
auth := &aws.Auth{
AccessKey: testConfig.Providers.AWS.Id,
SecretKey: testConfig.Providers.AWS.Secret,
}
// check the staging location first
filebytes, err := getS3FileBytes(auth, "build-push-testing", "/pushtest-stage/unittest-testTaskId-DISTRO_EXP-BUILDVAR_EXP-FILE_EXP.txt")
testutil.HandleTestingErr(err, t, "Failed to get file from s3: %v", err)
So(string(filebytes), ShouldEqual, newDate+"\n")
// now check remote location (after copy)
filebytes, err = getS3FileBytes(auth, "build-push-testing", "/pushtest/unittest-DISTRO_EXP-BUILDVAR_EXP-FILE_EXP-latest.txt")
testutil.HandleTestingErr(err, t, "Failed to get remote file from s3: %v", err)
So(string(filebytes), ShouldEqual, newDate+"\n")
})
})
})
}
}
}
func TestCLIFunctions(t *testing.T) {
testutil.ConfigureIntegrationTest(t, testConfig, "TestCLIFunctions")
Convey("with API test server running", t, func() {
// create a test API server
testServer, err := apiserver.CreateTestServer(testConfig, nil, plugin.APIPlugins, true)
// create a test user
So(db.Clear(user.Collection), ShouldBeNil)
So(db.Clear(patch.Collection), ShouldBeNil)
So(db.Clear(model.ProjectRefCollection), ShouldBeNil)
So((&user.DBUser{Id: "testuser", APIKey: "testapikey", EmailAddress: "*****@*****.**"}).Insert(), ShouldBeNil)
localConfBytes, err := ioutil.ReadFile("testdata/sample.yml")
So(err, ShouldBeNil)
projectRef := &model.ProjectRef{
Identifier: "sample",
Owner: "evergreen-ci",
Repo: "sample",
RepoKind: "github",
Branch: "master",
RemotePath: "evergreen.yml",
LocalConfig: string(localConfBytes),
Enabled: true,
BatchTime: 180,
}
So(projectRef.Insert(), ShouldBeNil)
// create a settings file for the command line client
settings := Settings{
APIServerHost: testServer.URL + "/api",
UIServerHost: "http://dev-evg.mongodb.com",
APIKey: "testapikey",
User: "******",
}
settingsFile, err := ioutil.TempFile("", "settings")
So(err, ShouldBeNil)
settingsBytes, err := yaml.Marshal(settings)
So(err, ShouldBeNil)
_, err = settingsFile.Write(settingsBytes)
So(err, ShouldBeNil)
settingsFile.Close()
t.Log("Wrote settings file to ", settingsFile.Name())
ac, _, err := getAPIClient(&Options{settingsFile.Name()})
So(err, ShouldBeNil)
Convey("check that creating a patch works", func() {
Convey("user should start with no patches present", func() {
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 0)
})
Convey("Creating a simple patch should be successful", func() {
patchSub := patchSubmission{"sample",
testPatch,
"sample patch",
"3c7bfeb82d492dc453e7431be664539c35b5db4b",
"all",
[]string{"all"},
false}
newPatch, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
Convey("Newly created patch should be fetchable via API", func() {
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 1)
})
Convey("Adding a module to the patch should work", func() {
err = ac.UpdatePatchModule(newPatch.Id.Hex(), "render-module", testPatch, "1e5232709595db427893826ce19289461cba3f75")
So(err, ShouldBeNil)
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
So(patches[0].Patches[0].ModuleName, ShouldEqual, "")
So(patches[0].Patches[1].ModuleName, ShouldEqual, "render-module")
Convey("Removing the module from the patch should work", func() {
So(ac.DeletePatchModule(newPatch.Id.Hex(), "render-module"), ShouldBeNil)
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
So(len(patches[0].Patches), ShouldEqual, 1)
Convey("Finalizing the patch should work", func() {
// First double check that the patch starts with no "version" field
So(patches[0].Version, ShouldEqual, "")
So(ac.FinalizePatch(newPatch.Id.Hex()), ShouldBeNil)
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
// After finalizing, the patch should now have a version populated
So(patches[0].Version, ShouldNotEqual, "")
Convey("Cancelling the patch should work", func() {
So(ac.CancelPatch(newPatch.Id.Hex()), ShouldBeNil)
patches, err := ac.GetPatches()
So(err, ShouldBeNil)
// After cancelling, tasks in the version should be deactivated
tasks, err := model.FindTasks(db.Query(bson.M{model.TaskVersionKey: patches[0].Version}))
So(err, ShouldBeNil)
for _, t := range tasks {
So(t.Activated, ShouldBeFalse)
}
})
})
})
})
})
Convey("Creating a complex patch should be successful", func() {
patchSub := patchSubmission{"sample",
testPatch,
"sample patch #2",
"3c7bfeb82d492dc453e7431be664539c35b5db4b",
"osx-108",
[]string{"failing_test"},
false}
_, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
Convey("Newly created patch should be fetchable via API", func() {
patches, err := ac.GetPatches()
Println(patches)
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 1)
So(len(patches[0].BuildVariants), ShouldEqual, 1)
So(patches[0].BuildVariants[0], ShouldEqual, "osx-108")
So(len(patches[0].Tasks), ShouldEqual, 2)
So(patches[0].Tasks, ShouldContain, "failing_test")
Convey("and have expanded dependencies", func() {
So(patches[0].Tasks, ShouldContain, "compile")
})
})
})
})
})
}
func TestCLIFetchArtifacts(t *testing.T) {
testutil.ConfigureIntegrationTest(t, testConfig, "TestCLIFetchArtifacts")
Convey("with API test server running", t, func() {
testSetup := setupCLITestHarness()
err := os.RemoveAll("artifacts-abcdef-rest_task_variant_task_one")
So(err, ShouldBeNil)
err = os.RemoveAll("artifacts-abcdef-rest_task_variant_task_two")
So(err, ShouldBeNil)
err = (&task.Task{
Id: "rest_task_test_id1",
BuildVariant: "rest_task_variant",
Revision: "abcdef1234",
DependsOn: []task.Dependency{{TaskId: "rest_task_test_id2"}},
DisplayName: "task_one",
}).Insert()
So(err, ShouldBeNil)
err = (&task.Task{
Id: "rest_task_test_id2",
Revision: "abcdef1234",
BuildVariant: "rest_task_variant",
DependsOn: []task.Dependency{},
DisplayName: "task_two",
}).Insert()
err = (&artifact.Entry{
TaskId: "rest_task_test_id1",
TaskDisplayName: "task_one",
Files: []artifact.File{{Link: "http://www.google.com/robots.txt"}},
}).Upsert()
So(err, ShouldBeNil)
err = (&artifact.Entry{
TaskId: "rest_task_test_id2",
TaskDisplayName: "task_two",
Files: []artifact.File{{Link: "http://www.google.com/humans.txt"}},
}).Upsert()
So(err, ShouldBeNil)
ac, rc, _, err := getAPIClients(&Options{testSetup.settingsFilePath})
So(err, ShouldBeNil)
Convey("shallow fetch artifacts should download a single task's artifacts successfully", func() {
err = fetchArtifacts(ac, rc, "rest_task_test_id1", "", true)
So(err, ShouldBeNil)
// downloaded file should exist where we expect
fileStat, err := os.Stat("./artifacts-abcdef-rest_task_variant_task_one/robots.txt")
So(err, ShouldBeNil)
So(fileStat.Size(), ShouldBeGreaterThan, 0)
fileStat, err = os.Stat("./rest_task_variant_task_two/humans.txt")
So(os.IsNotExist(err), ShouldBeTrue)
Convey("deep fetch artifacts should also download artifacts from dependency", func() {
err = fetchArtifacts(ac, rc, "rest_task_test_id1", "", false)
So(err, ShouldBeNil)
fileStat, err = os.Stat("./artifacts-abcdef-rest_task_variant_task_two/humans.txt")
So(os.IsNotExist(err), ShouldBeFalse)
})
})
})
}
func TestCLIFunctions(t *testing.T) {
testutil.ConfigureIntegrationTest(t, testConfig, "TestCLIFunctions")
Convey("with API test server running", t, func() {
testSetup := setupCLITestHarness()
ac, _, _, err := getAPIClients(&Options{testSetup.settingsFilePath})
So(err, ShouldBeNil)
Convey("check that creating a patch works", func() {
Convey("user should start with no patches present", func() {
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 0)
})
Convey("Creating a simple patch should be successful", func() {
patchSub := patchSubmission{"sample",
testPatch,
"sample patch",
"3c7bfeb82d492dc453e7431be664539c35b5db4b",
"all",
[]string{"all"},
false}
newPatch, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
Convey("Newly created patch should be fetchable via API", func() {
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 1)
})
Convey("Adding a module to the patch should work", func() {
err = ac.UpdatePatchModule(newPatch.Id.Hex(), "render-module", testPatch, "1e5232709595db427893826ce19289461cba3f75")
So(err, ShouldBeNil)
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
So(patches[0].Patches[0].ModuleName, ShouldEqual, "")
So(patches[0].Patches[1].ModuleName, ShouldEqual, "render-module")
Convey("Removing the module from the patch should work", func() {
So(ac.DeletePatchModule(newPatch.Id.Hex(), "render-module"), ShouldBeNil)
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
So(len(patches[0].Patches), ShouldEqual, 1)
Convey("Finalizing the patch should work", func() {
// First double check that the patch starts with no "version" field
So(patches[0].Version, ShouldEqual, "")
So(ac.FinalizePatch(newPatch.Id.Hex()), ShouldBeNil)
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
// After finalizing, the patch should now have a version populated
So(patches[0].Version, ShouldNotEqual, "")
Convey("Cancelling the patch should work", func() {
So(ac.CancelPatch(newPatch.Id.Hex()), ShouldBeNil)
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
// After cancelling, tasks in the version should be deactivated
tasks, err := task.Find(task.ByVersion(patches[0].Version))
So(err, ShouldBeNil)
for _, t := range tasks {
So(t.Activated, ShouldBeFalse)
}
})
})
})
})
})
Convey("Creating a patch without variants should be successful", func() {
patchSub := patchSubmission{
"sample",
testPatch,
"sample patch",
"3c7bfeb82d492dc453e7431be664539c35b5db4b",
"all",
[]string{},
false,
}
_, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
})
Convey("Creating a complex patch should be successful", func() {
patchSub := patchSubmission{"sample",
testPatch,
"sample patch #2",
"3c7bfeb82d492dc453e7431be664539c35b5db4b",
"osx-108",
[]string{"failing_test"},
false}
_, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
Convey("Newly created patch should be fetchable via API", func() {
patches, err := ac.GetPatches(1)
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 1)
So(len(patches[0].BuildVariants), ShouldEqual, 1)
So(patches[0].BuildVariants[0], ShouldEqual, "osx-108")
So(len(patches[0].Tasks), ShouldEqual, 2)
So(patches[0].Tasks, ShouldContain, "failing_test")
Convey("and have expanded dependencies", func() {
So(patches[0].Tasks, ShouldContain, "compile")
})
Convey("putting the patch again", func() {
_, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
Convey("GetPatches where n=1 should return 1 patch", func() {
patches, err := ac.GetPatches(1)
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 1)
})
Convey("GetPatches where n=2 should return 2 patches", func() {
patches, err := ac.GetPatches(2)
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 2)
})
})
})
})
Convey("Creating an empty patch should not error out anything", func() {
patchSub := patchSubmission{
projectId: "sample",
patchData: emptyPatch,
description: "sample patch",
base: "3c7bfeb82d492dc453e7431be664539c35b5db4b",
variants: "all",
tasks: []string{"all"},
finalize: false}
newPatch, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
Convey("Newly created patch should be fetchable via API", func() {
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 1)
})
Convey("Adding a module to the patch should still work as designed even with empty patch", func() {
err = ac.UpdatePatchModule(newPatch.Id.Hex(), "render-module", emptyPatch, "1e5232709595db427893826ce19289461cba3f75")
So(err, ShouldBeNil)
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
So(patches[0].Patches[0].ModuleName, ShouldEqual, "")
So(patches[0].Patches[1].ModuleName, ShouldEqual, "render-module")
Convey("Removing the module from the patch should work as designed even with empty patch", func() {
So(ac.DeletePatchModule(newPatch.Id.Hex(), "render-module"), ShouldBeNil)
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
So(len(patches[0].Patches), ShouldEqual, 1)
Convey("Finalizing the patch should start with no version field and then be populated", func() {
So(patches[0].Version, ShouldEqual, "")
So(ac.FinalizePatch(newPatch.Id.Hex()), ShouldBeNil)
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
So(patches[0].Version, ShouldNotEqual, "")
Convey("Cancelling the patch should work and the version should be deactivated", func() {
So(ac.CancelPatch(newPatch.Id.Hex()), ShouldBeNil)
patches, err := ac.GetPatches(0)
So(err, ShouldBeNil)
tasks, err := task.Find(task.ByVersion(patches[0].Version))
So(err, ShouldBeNil)
for _, t := range tasks {
So(t.Activated, ShouldBeFalse)
}
})
})
})
})
})
Convey("Listing variants or tasks for a project should list all variants", func() {
tasks, err := ac.ListTasks("sample")
So(err, ShouldBeNil)
So(tasks, ShouldNotBeEmpty)
So(len(tasks), ShouldEqual, 4)
})
Convey("Listing variants for a project should list all variants", func() {
variants, err := ac.ListVariants("sample")
So(err, ShouldBeNil)
So(variants, ShouldNotBeEmpty)
So(len(variants), ShouldEqual, 2)
})
Convey("Creating a patch using 'all' as variants should schedule all variants", func() {
patchSub := patchSubmission{"sample",
testPatch,
"sample patch #2",
"3c7bfeb82d492dc453e7431be664539c35b5db4b",
"all",
[]string{"failing_test"},
false}
_, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
Convey("Newly created patch should be fetchable via API", func() {
patches, err := ac.GetPatches(1)
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 1)
So(len(patches[0].BuildVariants), ShouldEqual, 2)
So(patches[0].BuildVariants, ShouldContain, "osx-108")
So(patches[0].BuildVariants, ShouldContain, "ubuntu")
So(len(patches[0].Tasks), ShouldEqual, 2)
So(patches[0].Tasks, ShouldContain, "failing_test")
Convey("and have expanded dependencies", func() {
So(patches[0].Tasks, ShouldContain, "compile")
})
})
})
Convey("Creating a patch using 'all' as tasks should schedule all tasks", func() {
patchSub := patchSubmission{"sample",
testPatch,
"sample patch #2",
"3c7bfeb82d492dc453e7431be664539c35b5db4b",
"osx-108",
[]string{"all"},
false}
_, err := ac.PutPatch(patchSub)
So(err, ShouldBeNil)
Convey("Newly created patch should be fetchable via API", func() {
patches, err := ac.GetPatches(1)
So(err, ShouldBeNil)
So(len(patches), ShouldEqual, 1)
So(len(patches[0].BuildVariants), ShouldEqual, 1)
So(patches[0].BuildVariants[0], ShouldEqual, "osx-108")
So(len(patches[0].Tasks), ShouldEqual, 4)
So(patches[0].Tasks, ShouldContain, "compile")
So(patches[0].Tasks, ShouldContain, "passing_test")
So(patches[0].Tasks, ShouldContain, "failing_test")
So(patches[0].Tasks, ShouldContain, "timeout_test")
})
})
})
})
}
func TestTaskSuccess(t *testing.T) {
setupTlsConfigs(t)
testutil.ConfigureIntegrationTest(t, testConfig, "TestTaskSuccess")
for tlsString, tlsConfig := range tlsConfigs {
for _, testSetup := range testSetups {
for _, variant := range buildVariantsToTest {
Convey(testSetup.testSpec, t, func() {
Convey("With agent running 'compile' step and live API server over "+
tlsString+" with variant "+variant, func() {
testTask, _, err := setupAPITestData(testConfig, "compile", variant, NoPatch, t)
testutil.HandleTestingErr(err, t, "Couldn't create test task: %v", err)
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
Convey("expansions should be fetched", func() {
So(testAgent.taskConfig.Expansions.Get("aws_key"), ShouldEqual, testConfig.Providers.AWS.Id)
So(scanLogsForTask(testTask.Id, "fetch_expansion_value"), ShouldBeTrue)
})
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
printLogsForTask(testTask.Id)
Convey("all scripts in task should have been run successfully", func() {
So(scanLogsForTask(testTask.Id, "Executing script: echo \"predefined command!\""), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "predefined command!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "this should not end up in the logs"), ShouldBeFalse)
So(scanLogsForTask(testTask.Id, "Command timeout set to 21m40s"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "Command timeout set to 43m20s"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "Cloning into") || // git 1.8
scanLogsForTask(testTask.Id, "Initialized empty Git repository"), // git 1.7
ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am compiling!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "i am sanity testing!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "Skipping command 'git.apply_patch' on variant"), ShouldBeTrue)
// Check that functions with args are working correctly
So(scanLogsForTask(testTask.Id, "arg1 is FOO"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "arg2 is BAR"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "arg3 is Expanded: qux"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "arg4 is Default: default_value"), ShouldBeTrue)
// Check that multi-command functions are working correctly
So(scanLogsForTask(testTask.Id, "step 1 of multi-command func"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "step 2 of multi-command func"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "step 3 of multi-command func"), ShouldBeTrue)
// Check that logging output is only flushing on a newline
So(scanLogsForTask(testTask.Id, "this should be on the same line...as this."), ShouldBeTrue)
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Couldn't find test task: %v", err)
So(testTask.Status, ShouldEqual, evergreen.TaskSucceeded)
// use function display name as description when none is specified in command
So(testTask.Details.Status, ShouldEqual, evergreen.TaskSucceeded)
So(testTask.Details.Description, ShouldEqual, `'shell.exec' in "silent shell test"`)
So(testTask.Details.TimedOut, ShouldBeFalse)
So(testTask.Details.Type, ShouldEqual, model.SystemCommandType)
})
Convey("manifest should be created", func() {
m, err := manifest.FindOne(manifest.ById(testTask.Version))
So(testTask.Version, ShouldEqual, "testVersionId")
So(err, ShouldBeNil)
So(m, ShouldNotBeNil)
So(m.ProjectName, ShouldEqual, testTask.Project)
So(m.Id, ShouldEqual, testTask.Version)
So(m.Modules, ShouldNotBeEmpty)
So(m.Modules["recursive"], ShouldNotBeNil)
So(m.Modules["recursive"].URL, ShouldNotEqual, "")
})
})
Convey("With agent running a regular test and live API server over "+
tlsString+" on variant "+variant, func() {
testTask, _, err := setupAPITestData(testConfig, "normal_task", variant, NoPatch, t)
testutil.HandleTestingErr(err, t, "Couldn't create test data: %v", err)
testServer, err := apiserver.CreateTestServer(testConfig, tlsConfig, plugin.APIPlugins, Verbose)
testutil.HandleTestingErr(err, t, "Couldn't create apiserver: %v", err)
testAgent, err := createAgent(testServer, testTask)
testutil.HandleTestingErr(err, t, "failed to create agent: %v")
// actually run the task.
// this function won't return until the whole thing is done.
testAgent.RunTask()
time.Sleep(100 * time.Millisecond)
testAgent.APILogger.FlushAndWait()
Convey("all scripts in task should have been run successfully", func() {
So(scanLogsForTask(testTask.Id, "executing the pre-run script"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "executing the post-run script!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "starting normal_task!"), ShouldBeTrue)
So(scanLogsForTask(testTask.Id, "done with normal_task!"), ShouldBeTrue)
testTask, err = model.FindTask(testTask.Id)
testutil.HandleTestingErr(err, t, "Couldn't find test task: %v", err)
So(testTask.Status, ShouldEqual, evergreen.TaskSucceeded)
expectedResults := []model.TestResult{
model.TestResult{
Status: "success",
TestFile: "t1",
URL: "url",
ExitCode: 0,
StartTime: 0,
EndTime: 10,
},
}
So(testTask.TestResults, ShouldResemble, expectedResults)
})
})
})
}
}
}
}
func 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")
})
})
})
})
}