func TestCheckProjectSyntax(t *testing.T) {
Convey("When validating a project's syntax", t, func() {
Convey("if the project passes all of the validation funcs, no errors"+
" should be returned", func() {
distros := []distro.Distro{
{Id: "test-distro-one"},
{Id: "test-distro-two"},
}
err := testutil.CreateTestLocalConfig(projectValidatorConf, "project_test", "")
So(err, ShouldBeNil)
projectRef, err := model.FindOneProjectRef("project_test")
So(err, ShouldBeNil)
for _, d := range distros {
So(d.Insert(), ShouldBeNil)
}
project, err := model.FindProject("", projectRef)
So(err, ShouldBeNil)
So(CheckProjectSyntax(project), ShouldResemble, []ValidationError{})
})
Reset(func() {
db.Clear(distro.Collection)
})
})
}
func TestProjectRef(t *testing.T) {
Convey("When inserting a project ref", t, func() {
err := testutil.CreateTestLocalConfig(patchTestConfig, "mci-test", "")
So(err, ShouldBeNil)
projectRef, err := model.FindOneProjectRef("mci-test")
So(err, ShouldBeNil)
So(projectRef, ShouldNotBeNil)
So(projectRef.Identifier, ShouldEqual, "mci-test")
})
}
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 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 setupAPITestData(testConfig *evergreen.Settings, taskDisplayName string,
variant string, patchMode patchTestMode, t *testing.T) (*model.Task, *build.Build, error) {
//ignore errs here because the ns might just not exist.
clearDataMsg := "Failed to clear test data collection"
testCollections := []string{
model.TasksCollection, build.Collection, host.Collection,
distro.Collection, version.Collection, patch.Collection,
model.PushlogCollection, model.ProjectVarsCollection, model.TaskQueuesCollection,
manifest.Collection, model.ProjectRefCollection}
testutil.HandleTestingErr(dbutil.ClearCollections(testCollections...), t, clearDataMsg)
projectVars := &model.ProjectVars{
Id: "evergreen-ci-render",
Vars: map[string]string{
"aws_key": testConfig.Providers.AWS.Id,
"aws_secret": testConfig.Providers.AWS.Secret,
"fetch_key": "fetch_expansion_value",
},
}
_, err := projectVars.Upsert()
testutil.HandleTestingErr(err, t, clearDataMsg)
taskOne := &model.Task{
Id: "testTaskId",
BuildId: "testBuildId",
DistroId: "test-distro-one",
BuildVariant: variant,
Project: "evergreen-ci-render",
DisplayName: taskDisplayName,
HostId: "testHost",
Secret: "testTaskSecret",
Version: "testVersionId",
Status: evergreen.TaskDispatched,
Requester: evergreen.RepotrackerVersionRequester,
}
taskTwo := &model.Task{
Id: "testTaskIdTwo",
BuildId: "testBuildId",
DistroId: "test-distro-one",
BuildVariant: variant,
Project: "evergreen-ci-render",
DisplayName: taskDisplayName,
HostId: "",
Secret: "testTaskSecret",
Activated: true,
Version: "testVersionId",
Status: evergreen.TaskUndispatched,
Requester: evergreen.RepotrackerVersionRequester,
}
if patchMode != NoPatch {
taskOne.Requester = evergreen.PatchVersionRequester
}
testutil.HandleTestingErr(taskOne.Insert(), t, "failed to insert taskOne")
testutil.HandleTestingErr(taskTwo.Insert(), t, "failed to insert taskTwo")
// set up task queue for task end tests
taskQueue := &model.TaskQueue{
Distro: "test-distro-one",
Queue: []model.TaskQueueItem{
model.TaskQueueItem{
Id: "testTaskIdTwo",
DisplayName: taskDisplayName,
},
},
}
testutil.HandleTestingErr(taskQueue.Save(), t, "failed to insert taskqueue")
workDir, err := ioutil.TempDir("", "agent_test_")
testutil.HandleTestingErr(err, t, "failed to create working directory")
host := &host.Host{
Id: "testHost",
Host: "testHost",
Distro: distro.Distro{
Id: "test-distro-one",
WorkDir: workDir,
Expansions: []distro.Expansion{{"distro_exp", "DISTRO_EXP"}},
},
RunningTask: "testTaskId",
StartedBy: evergreen.User,
AgentRevision: agentRevision,
}
testutil.HandleTestingErr(host.Insert(), t, "failed to insert host")
// read in the project configuration
projectFile := "testdata/config_test_plugin/project/evergreen-ci-render.yml"
projectConfig, err := ioutil.ReadFile(projectFile)
testutil.HandleTestingErr(err, t, "failed to read project config")
projectRef := &model.ProjectRef{
Identifier: "evergreen-ci-render",
Owner: "evergreen-ci",
Repo: "render",
RepoKind: "github",
Branch: "master",
Enabled: true,
BatchTime: 180,
}
testutil.HandleTestingErr(projectRef.Insert(), t, "failed to insert projectRef")
err = testutil.CreateTestLocalConfig(testConfig, "evergreen-ci-render", "testdata/config_test_plugin/project/evergreen-ci-render.yml")
testutil.HandleTestingErr(err, t, "failed to marshall project config")
// unmarshall the project configuration into a struct
project := &model.Project{}
testutil.HandleTestingErr(yaml.Unmarshal(projectConfig, project), t, "failed to unmarshal project config")
// now then marshall the project YAML for storage
projectYamlBytes, err := yaml.Marshal(project)
testutil.HandleTestingErr(err, t, "failed to marshall project config")
// insert the version document
v := &version.Version{
Id: "testVersionId",
BuildIds: []string{taskOne.BuildId},
Config: string(projectYamlBytes),
}
testutil.HandleTestingErr(v.Insert(), t, "failed to insert version")
if patchMode != NoPatch {
mainPatchContent, err := ioutil.ReadFile("testdata/test.patch")
testutil.HandleTestingErr(err, t, "failed to read test patch file")
modulePatchContent, err := ioutil.ReadFile("testdata/testmodule.patch")
testutil.HandleTestingErr(err, t, "failed to read test module patch file")
ptch := &patch.Patch{
Status: evergreen.PatchCreated,
Version: v.Id,
}
if patchMode == InlinePatch {
ptch.Patches = []patch.ModulePatch{
{
ModuleName: "",
Githash: "1e5232709595db427893826ce19289461cba3f75",
PatchSet: patch.PatchSet{Patch: string(mainPatchContent)},
},
{
ModuleName: "recursive",
Githash: "1e5232709595db427893826ce19289461cba3f75",
PatchSet: patch.PatchSet{Patch: string(modulePatchContent)},
},
}
} else {
p1Id, p2Id := bson.NewObjectId().Hex(), bson.NewObjectId().Hex()
So(dbutil.WriteGridFile(patch.GridFSPrefix, p1Id, strings.NewReader(string(mainPatchContent))), ShouldBeNil)
So(dbutil.WriteGridFile(patch.GridFSPrefix, p2Id, strings.NewReader(string(modulePatchContent))), ShouldBeNil)
ptch.Patches = []patch.ModulePatch{
{
ModuleName: "",
Githash: "1e5232709595db427893826ce19289461cba3f75",
PatchSet: patch.PatchSet{PatchFileId: p1Id},
},
{
ModuleName: "recursive",
Githash: "1e5232709595db427893826ce19289461cba3f75",
PatchSet: patch.PatchSet{PatchFileId: p2Id},
},
}
}
testutil.HandleTestingErr(ptch.Insert(), t, "failed to insert patch")
}
session, _, err := dbutil.GetGlobalSessionFactory().GetSession()
testutil.HandleTestingErr(err, t, "couldn't get db session!")
// Remove any logs for our test task from previous runs.
_, err = session.DB(model.TaskLogDB).C(model.TaskLogCollection).
RemoveAll(bson.M{"t_id": bson.M{"$in": []string{taskOne.Id, taskTwo.Id}}})
testutil.HandleTestingErr(err, t, "failed to remove logs")
build := &build.Build{
Id: "testBuildId",
Tasks: []build.TaskCache{
build.NewTaskCache(taskOne.Id, taskOne.DisplayName, true),
build.NewTaskCache(taskTwo.Id, taskTwo.DisplayName, true),
},
Version: "testVersionId",
}
testutil.HandleTestingErr(build.Insert(), t, "failed to insert build")
return taskOne, build, nil
}
func TestGetBuildInfo(t *testing.T) {
userManager, err := auth.LoadUserManager(buildTestConfig.AuthConfig)
testutil.HandleTestingErr(err, t, "Failure in loading UserManager from config")
uis := UIServer{
RootURL: buildTestConfig.Ui.Url,
Settings: *buildTestConfig,
UserManager: userManager,
}
home := evergreen.FindEvergreenHome()
uis.Render = render.New(render.Options{
Directory: filepath.Join(home, WebRootPath, Templates),
DisableCache: true,
Funcs: nil,
})
router, err := uis.NewRouter()
testutil.HandleTestingErr(err, t, "Failure in uis.NewRouter()")
Convey("When finding info on a particular build", t, func() {
testutil.HandleTestingErr(db.Clear(build.Collection), t,
"Error clearing '%v' collection", build.Collection)
buildId := "my-build"
versionId := "my-version"
projectName := "mci-test"
err := testutil.CreateTestLocalConfig(buildTestConfig, "mci-test")
So(err, ShouldBeNil)
err = testutil.CreateTestLocalConfig(buildTestConfig, "render")
So(err, ShouldBeNil)
err = testutil.CreateTestLocalConfig(buildTestConfig, "project_test")
task := build.TaskCache{
Id: "some-task-id",
DisplayName: "some-task-name",
Status: "success",
TimeTaken: time.Duration(100 * time.Millisecond),
}
build := &build.Build{
Id: buildId,
CreateTime: time.Now().Add(-20 * time.Minute),
StartTime: time.Now().Add(-10 * time.Minute),
FinishTime: time.Now().Add(-5 * time.Second),
PushTime: time.Now().Add(-1 * time.Millisecond),
Version: versionId,
Project: projectName,
Revision: fmt.Sprintf("%x", rand.Int()),
BuildVariant: "some-build-variant",
BuildNumber: "42",
Status: "success",
Activated: true,
ActivatedTime: time.Now().Add(-15 * time.Minute),
RevisionOrderNumber: rand.Int(),
Tasks: []build.TaskCache{task},
TimeTaken: time.Duration(10 * time.Minute),
DisplayName: "My build",
Requester: evergreen.RepotrackerVersionRequester,
}
So(build.Insert(), ShouldBeNil)
url, err := router.Get("build_info").URL("build_id", buildId)
So(err, ShouldBeNil)
request, err := http.NewRequest("GET", url.String(), nil)
So(err, ShouldBeNil)
response := httptest.NewRecorder()
// Need match variables to be set so can call mux.Vars(request)
// in the actual handler function
router.ServeHTTP(response, request)
So(response.Code, ShouldEqual, http.StatusOK)
Convey("response should match contents of database", func() {
var jsonBody map[string]interface{}
err = json.Unmarshal(response.Body.Bytes(), &jsonBody)
So(err, ShouldBeNil)
var rawJsonBody map[string]*json.RawMessage
err = json.Unmarshal(response.Body.Bytes(), &rawJsonBody)
So(err, ShouldBeNil)
So(jsonBody["id"], ShouldEqual, build.Id)
var createTime time.Time
err = json.Unmarshal(*rawJsonBody["create_time"], &createTime)
So(err, ShouldBeNil)
So(createTime, ShouldHappenWithin, rest.TimePrecision, build.CreateTime)
var startTime time.Time
err = json.Unmarshal(*rawJsonBody["start_time"], &startTime)
So(err, ShouldBeNil)
So(startTime, ShouldHappenWithin, rest.TimePrecision, build.StartTime)
var finishTime time.Time
err = json.Unmarshal(*rawJsonBody["finish_time"], &finishTime)
So(err, ShouldBeNil)
So(finishTime, ShouldHappenWithin, rest.TimePrecision, build.FinishTime)
var pushTime time.Time
err = json.Unmarshal(*rawJsonBody["push_time"], &pushTime)
So(err, ShouldBeNil)
So(pushTime, ShouldHappenWithin, rest.TimePrecision, build.PushTime)
So(jsonBody["version"], ShouldEqual, build.Version)
So(jsonBody["project"], ShouldEqual, build.Project)
So(jsonBody["revision"], ShouldEqual, build.Revision)
So(jsonBody["variant"], ShouldEqual, build.BuildVariant)
So(jsonBody["number"], ShouldEqual, build.BuildNumber)
So(jsonBody["status"], ShouldEqual, build.Status)
So(jsonBody["activated"], ShouldEqual, build.Activated)
var activatedTime time.Time
err = json.Unmarshal(*rawJsonBody["activated_time"], &activatedTime)
So(err, ShouldBeNil)
So(activatedTime, ShouldHappenWithin, rest.TimePrecision, build.ActivatedTime)
So(jsonBody["order"], ShouldEqual, build.RevisionOrderNumber)
_jsonTasks, ok := jsonBody["tasks"]
So(ok, ShouldBeTrue)
jsonTasks, ok := _jsonTasks.(map[string]interface{})
So(ok, ShouldBeTrue)
So(len(jsonTasks), ShouldEqual, 1)
_jsonTask, ok := jsonTasks[task.DisplayName]
So(ok, ShouldBeTrue)
jsonTask, ok := _jsonTask.(map[string]interface{})
So(ok, ShouldBeTrue)
So(jsonTask["task_id"], ShouldEqual, task.Id)
So(jsonTask["status"], ShouldEqual, task.Status)
So(jsonTask["time_taken"], ShouldEqual, task.TimeTaken)
So(jsonBody["time_taken"], ShouldEqual, build.TimeTaken)
So(jsonBody["name"], ShouldEqual, build.DisplayName)
So(jsonBody["requester"], ShouldEqual, build.Requester)
})
})
Convey("When finding info on a nonexistent build", t, func() {
buildId := "not-present"
url, err := router.Get("build_info").URL("build_id", buildId)
So(err, ShouldBeNil)
request, err := http.NewRequest("GET", url.String(), nil)
So(err, ShouldBeNil)
response := httptest.NewRecorder()
// Need match variables to be set so can call mux.Vars(request)
// in the actual handler function
router.ServeHTTP(response, request)
So(response.Code, ShouldEqual, http.StatusNotFound)
Convey("response should contain a sensible error message", func() {
var jsonBody map[string]interface{}
err = json.Unmarshal(response.Body.Bytes(), &jsonBody)
So(err, ShouldBeNil)
So(jsonBody["message"], ShouldEqual,
fmt.Sprintf("Error finding build '%v'", buildId))
})
})
}
func TestGetRecentVersions(t *testing.T) {
userManager, err := auth.LoadUserManager(versionTestConfig.AuthConfig)
testutil.HandleTestingErr(err, t, "Failure in loading UserManager from config")
uis := UIServer{
RootURL: versionTestConfig.Ui.Url,
Settings: *versionTestConfig,
UserManager: userManager,
}
home := evergreen.FindEvergreenHome()
uis.Render = render.New(render.Options{
Directory: filepath.Join(home, WebRootPath, Templates),
DisableCache: true,
Funcs: nil,
})
router, err := uis.NewRouter()
testutil.HandleTestingErr(err, t, "Failure in uis.NewRouter()")
err = testutil.CreateTestLocalConfig(buildTestConfig, "mci-test", "")
testutil.HandleTestingErr(err, t, "Error loading local config mci-test")
err = testutil.CreateTestLocalConfig(buildTestConfig, "render", "")
testutil.HandleTestingErr(err, t, "Error loading local config render")
Convey("When finding recent versions", t, func() {
testutil.HandleTestingErr(db.ClearCollections(version.Collection, build.Collection), t,
"Error clearing '%v' collection", version.Collection)
projectName := "project_test"
err = testutil.CreateTestLocalConfig(buildTestConfig, projectName, "")
So(err, ShouldBeNil)
otherProjectName := "my-other-project"
So(projectName, ShouldNotEqual, otherProjectName) // sanity-check
buildIdPreface := "build-id-for-version%v"
So(rest.NumRecentVersions, ShouldBeGreaterThan, 0)
versions := make([]*version.Version, 0, rest.NumRecentVersions)
// Insert a bunch of versions into the database
for i := 0; i < rest.NumRecentVersions; i++ {
v := &version.Version{
Id: fmt.Sprintf("version%v", i),
Identifier: projectName,
Author: fmt.Sprintf("author%v", i),
Revision: fmt.Sprintf("%x", rand.Int()),
Message: fmt.Sprintf("message%v", i),
RevisionOrderNumber: i + 1,
Requester: evergreen.RepotrackerVersionRequester,
}
So(v.Insert(), ShouldBeNil)
versions = append(versions, v)
}
// Construct a version that should not be present in the response
// since the length of the build ids slice is different than that
// of the build variants slice
earlyVersion := &version.Version{
Id: "some-id",
Identifier: projectName,
Author: "some-author",
Revision: fmt.Sprintf("%x", rand.Int()),
Message: "some-message",
RevisionOrderNumber: 0,
Requester: evergreen.RepotrackerVersionRequester,
}
So(earlyVersion.Insert(), ShouldBeNil)
// Construct a version that should not be present in the response
// since it belongs to a different project
otherVersion := &version.Version{
Id: "some-other-id",
Identifier: otherProjectName,
Author: "some-other-author",
Revision: fmt.Sprintf("%x", rand.Int()),
Message: "some-other-message",
RevisionOrderNumber: rest.NumRecentVersions + 1,
Requester: evergreen.RepotrackerVersionRequester,
}
So(otherVersion.Insert(), ShouldBeNil)
builds := make([]*build.Build, 0, rest.NumRecentVersions)
task := build.TaskCache{
Id: "some-task-id",
DisplayName: "some-task-name",
Status: "success",
TimeTaken: time.Duration(100 * time.Millisecond),
}
for i := 0; i < rest.NumRecentVersions; i++ {
build := &build.Build{
Id: fmt.Sprintf(buildIdPreface, i),
Version: versions[i].Id,
BuildVariant: "some-build-variant",
DisplayName: "Some Build Variant",
Tasks: []build.TaskCache{task},
}
So(build.Insert(), ShouldBeNil)
builds = append(builds, build)
}
url, err := router.Get("recent_versions").URL("project_id", projectName)
So(err, ShouldBeNil)
request, err := http.NewRequest("GET", url.String(), nil)
So(err, ShouldBeNil)
response := httptest.NewRecorder()
// Need match variables to be set so can call mux.Vars(request)
// in the actual handler function
router.ServeHTTP(response, request)
So(response.Code, ShouldEqual, http.StatusOK)
Convey("response should match contents of database", func() {
var jsonBody map[string]interface{}
err = json.Unmarshal(response.Body.Bytes(), &jsonBody)
So(err, ShouldBeNil)
var rawJsonBody map[string]*json.RawMessage
err = json.Unmarshal(response.Body.Bytes(), &rawJsonBody)
So(err, ShouldBeNil)
So(jsonBody["project"], ShouldEqual, projectName)
var jsonVersions []map[string]interface{}
err = json.Unmarshal(*rawJsonBody["versions"], &jsonVersions)
So(err, ShouldBeNil)
So(len(jsonVersions), ShouldEqual, len(versions))
for i, v := range versions {
jsonVersion := jsonVersions[len(jsonVersions)-i-1] // reverse order
So(jsonVersion["version_id"], ShouldEqual, v.Id)
So(jsonVersion["author"], ShouldEqual, v.Author)
So(jsonVersion["revision"], ShouldEqual, v.Revision)
So(jsonVersion["message"], ShouldEqual, v.Message)
_jsonBuilds, ok := jsonVersion["builds"]
So(ok, ShouldBeTrue)
jsonBuilds, ok := _jsonBuilds.(map[string]interface{})
So(ok, ShouldBeTrue)
So(len(jsonBuilds), ShouldEqual, 1)
_jsonBuild, ok := jsonBuilds[builds[i].BuildVariant]
So(ok, ShouldBeTrue)
jsonBuild, ok := _jsonBuild.(map[string]interface{})
So(ok, ShouldBeTrue)
So(jsonBuild["build_id"], ShouldEqual, builds[i].Id)
So(jsonBuild["name"], ShouldEqual, builds[i].DisplayName)
_jsonTasks, ok := jsonBuild["tasks"]
So(ok, ShouldBeTrue)
jsonTasks, ok := _jsonTasks.(map[string]interface{})
So(ok, ShouldBeTrue)
So(len(jsonTasks), ShouldEqual, 1)
_jsonTask, ok := jsonTasks[task.DisplayName]
So(ok, ShouldBeTrue)
jsonTask, ok := _jsonTask.(map[string]interface{})
So(ok, ShouldBeTrue)
So(jsonTask["task_id"], ShouldEqual, task.Id)
So(jsonTask["status"], ShouldEqual, task.Status)
So(jsonTask["time_taken"], ShouldEqual, task.TimeTaken)
}
})
})
Convey("When finding recent versions for a nonexistent project", t, func() {
projectName := "not-present"
url, err := router.Get("recent_versions").URL("project_id", projectName)
So(err, ShouldBeNil)
request, err := http.NewRequest("GET", url.String(), nil)
So(err, ShouldBeNil)
response := httptest.NewRecorder()
// Need match variables to be set so can call mux.Vars(request)
// in the actual handler function
router.ServeHTTP(response, request)
So(response.Code, ShouldEqual, http.StatusOK)
Convey("response should contain no versions", func() {
var jsonBody map[string]interface{}
err = json.Unmarshal(response.Body.Bytes(), &jsonBody)
So(err, ShouldBeNil)
var rawJsonBody map[string]*json.RawMessage
err = json.Unmarshal(response.Body.Bytes(), &rawJsonBody)
So(err, ShouldBeNil)
So(jsonBody["project"], ShouldEqual, projectName)
var jsonVersions []map[string]interface{}
err = json.Unmarshal(*rawJsonBody["versions"], &jsonVersions)
So(err, ShouldBeNil)
So(jsonVersions, ShouldBeEmpty)
})
})
}
func TestGetVersionInfo(t *testing.T) {
userManager, err := auth.LoadUserManager(versionTestConfig.AuthConfig)
testutil.HandleTestingErr(err, t, "Failure in loading UserManager from config")
uis := UIServer{
RootURL: versionTestConfig.Ui.Url,
Settings: *versionTestConfig,
UserManager: userManager,
}
home := evergreen.FindEvergreenHome()
uis.Render = render.New(render.Options{
Directory: filepath.Join(home, WebRootPath, Templates),
DisableCache: true,
Funcs: nil,
})
router, err := uis.NewRouter()
testutil.HandleTestingErr(err, t, "Failure in uis.NewRouter()")
err = testutil.CreateTestLocalConfig(buildTestConfig, "mci-test", "")
testutil.HandleTestingErr(err, t, "Error loading local config mci-test")
err = testutil.CreateTestLocalConfig(buildTestConfig, "render", "")
testutil.HandleTestingErr(err, t, "Error loading local config render")
Convey("When finding info on a particular version", t, func() {
testutil.HandleTestingErr(db.Clear(version.Collection), t,
"Error clearing '%v' collection", version.Collection)
versionId := "my-version"
projectName := "project_test"
err = testutil.CreateTestLocalConfig(buildTestConfig, projectName, "")
So(err, ShouldBeNil)
v := &version.Version{
Id: versionId,
CreateTime: time.Now().Add(-20 * time.Minute),
StartTime: time.Now().Add(-10 * time.Minute),
FinishTime: time.Now().Add(-5 * time.Second),
Revision: fmt.Sprintf("%x", rand.Int()),
Author: "some-author",
AuthorEmail: "some-email",
Message: "some-message",
Status: "success",
BuildIds: []string{"some-build-id"},
BuildVariants: []version.BuildStatus{{"some-build-variant", true, time.Now().Add(-20 * time.Minute), "some-build-id"}},
RevisionOrderNumber: rand.Int(),
Owner: "some-owner",
Repo: "some-repo",
Branch: "some-branch",
RepoKind: "github",
Identifier: versionId,
Remote: false,
RemotePath: "",
Requester: evergreen.RepotrackerVersionRequester,
}
So(v.Insert(), ShouldBeNil)
url, err := router.Get("version_info").URL("version_id", versionId)
So(err, ShouldBeNil)
request, err := http.NewRequest("GET", url.String(), nil)
So(err, ShouldBeNil)
response := httptest.NewRecorder()
// Need match variables to be set so can call mux.Vars(request)
// in the actual handler function
router.ServeHTTP(response, request)
So(response.Code, ShouldEqual, http.StatusOK)
validateVersionInfo(v, response)
})
Convey("When finding info on a nonexistent version", t, func() {
versionId := "not-present"
url, err := router.Get("version_info").URL("version_id", versionId)
So(err, ShouldBeNil)
request, err := http.NewRequest("GET", url.String(), nil)
So(err, ShouldBeNil)
response := httptest.NewRecorder()
// Need match variables to be set so can call mux.Vars(request)
// in the actual handler function
router.ServeHTTP(response, request)
So(response.Code, ShouldEqual, http.StatusNotFound)
Convey("response should contain a sensible error message", func() {
var jsonBody map[string]interface{}
err = json.Unmarshal(response.Body.Bytes(), &jsonBody)
So(err, ShouldBeNil)
So(jsonBody["message"], ShouldEqual,
fmt.Sprintf("Error finding version '%v'", versionId))
})
})
}
