func TestLastKnownGoodConfig(t *testing.T) {
Convey("When calling LastKnownGoodConfig..", t, func() {
identifier := "identifier"
Convey("no versions should be returned if there're no good "+
"last known configurations", func() {
v := &version.Version{
Identifier: identifier,
Requester: evergreen.RepotrackerVersionRequester,
Errors: []string{"error 1", "error 2"},
}
testutil.HandleTestingErr(v.Insert(), t, "Error inserting test version: %v")
lastGood, err := version.FindOne(version.ByLastKnownGoodConfig(identifier))
testutil.HandleTestingErr(err, t, "error finding last known good: %v")
So(lastGood, ShouldBeNil)
})
Convey("a version should be returned if there is a last known good configuration", func() {
v := &version.Version{
Identifier: identifier,
Requester: evergreen.RepotrackerVersionRequester,
}
testutil.HandleTestingErr(v.Insert(), t, "Error inserting test version: %v")
lastGood, err := version.FindOne(version.ByLastKnownGoodConfig(identifier))
testutil.HandleTestingErr(err, t, "error finding last known good: %v")
So(lastGood, ShouldNotBeNil)
})
Convey("most recent version should be found if there are several recent good configs", func() {
v := &version.Version{
Id: "1",
Identifier: identifier,
Requester: evergreen.RepotrackerVersionRequester,
RevisionOrderNumber: 1,
Config: "1",
}
testutil.HandleTestingErr(v.Insert(), t, "Error inserting test version: %v")
v.Id = "5"
v.RevisionOrderNumber = 5
v.Config = "5"
testutil.HandleTestingErr(v.Insert(), t, "Error inserting test version: %v")
v.Id = "2"
v.RevisionOrderNumber = 2
v.Config = "2"
testutil.HandleTestingErr(v.Insert(), t, "Error inserting test version: %v")
lastGood, err := version.FindOne(version.ByLastKnownGoodConfig(identifier))
testutil.HandleTestingErr(err, t, "error finding last known good: %v")
So(lastGood, ShouldNotBeNil)
So(lastGood.Config, ShouldEqual, "5")
})
Reset(func() {
db.Clear(version.Collection)
})
})
}
func FindProject(revision string, projectRef *ProjectRef) (*Project, error) {
if projectRef == nil {
return nil, fmt.Errorf("projectRef given is nil")
}
if projectRef.Identifier == "" {
return nil, fmt.Errorf("Invalid project with blank identifier")
}
project := &Project{}
project.Identifier = projectRef.Identifier
// when the revision is empty we find the last known good configuration from the versions
// If the last known good configuration does not exist,
// load the configuration from the local config in the project ref.
if revision == "" {
lastGoodVersion, err := version.FindOne(version.ByLastKnownGoodConfig(projectRef.Identifier))
if err != nil {
return nil, fmt.Errorf("Error finding recent valid version for %v: %v", projectRef.Identifier, err)
}
if lastGoodVersion != nil {
// for new repositories, we don't want to error out when we don't have
// any versions stored in the database so we default to the skeletal
// information we already have from the project file on disk
err = LoadProjectInto([]byte(lastGoodVersion.Config), projectRef.Identifier, project)
if err != nil {
return nil, fmt.Errorf("Error loading project from "+
"last good version for project, %v: %v", lastGoodVersion.Identifier, err)
}
} else {
// Check to see if there is a local configuration in the project ref
if projectRef.LocalConfig != "" {
err = LoadProjectInto([]byte(projectRef.LocalConfig), projectRef.Identifier, project)
if err != nil {
return nil, fmt.Errorf("Error loading local config for project ref, %v : %v", projectRef.Identifier, err)
}
}
}
}
if revision != "" {
// we immediately return an error if the repotracker version isn't found
// for the given project at the given revision
version, err := version.FindOne(version.ByProjectIdAndRevision(projectRef.Identifier, revision))
if err != nil {
return nil, fmt.Errorf("error fetching version for project %v revision %v: %v", projectRef.Identifier, revision, err)
}
if version == nil {
// fall back to the skeletal project
return project, nil
}
project = &Project{}
if err = LoadProjectInto([]byte(version.Config), projectRef.Identifier, project); err != nil {
return nil, fmt.Errorf("Error loading project from version: %v", err)
}
}
return project, nil
}
// Construct a map of project names to build variants for that project
func findProjectBuildVariants(configName string) (map[string][]string, error) {
projectNameToBuildVariants := make(map[string][]string)
allProjects, err := model.FindAllTrackedProjectRefs()
if err != nil {
return nil, err
}
for _, projectRef := range allProjects {
if !projectRef.Enabled {
continue
}
var buildVariants []string
var proj *model.Project
var err error
if projectRef.LocalConfig != "" {
proj, err = model.FindProject("", &projectRef)
if err != nil {
return nil, fmt.Errorf("unable to find project file: %v", err)
}
} else {
lastGood, err := version.FindOne(version.ByLastKnownGoodConfig(projectRef.Identifier))
if err != nil {
return nil, fmt.Errorf("unable to find last valid config: %v", err)
}
if lastGood == nil { // brand new project + no valid config yet, just return an empty map
return projectNameToBuildVariants, nil
}
proj = &model.Project{}
err = model.LoadProjectInto([]byte(lastGood.Config), projectRef.Identifier, proj)
if err != nil {
return nil, fmt.Errorf("error loading project '%v' from version: %v", projectRef.Identifier, err)
}
}
for _, buildVariant := range proj.BuildVariants {
buildVariants = append(buildVariants, buildVariant.Name)
}
projectNameToBuildVariants[projectRef.Identifier] = buildVariants
}
return projectNameToBuildVariants, nil
}