// Create and return the waterfall data we need to render the page.
// Http handler for the waterfall page
func (uis *UIServer) waterfallPage(w http.ResponseWriter, r *http.Request) {
projCtx := MustHaveProjectContext(r)
if projCtx.Project == nil {
uis.ProjectNotFound(projCtx, w, r)
return
}
skip, err := skipValue(r)
if err != nil {
skip = 0
}
finalData := waterfallData{}
// first, get all of the versions and variants we will need
vvData, err := getVersionsAndVariants(skip,
VersionItemsToCreate, projCtx.Project)
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
var wfv waterfallVersions = vvData.Versions
sort.Sort(wfv)
finalData.Versions = wfv
sort.Sort(vvData.BuildVariants)
rows := []waterfallRow{}
for _, bv := range vvData.BuildVariants {
rows = append(rows, vvData.Rows[bv.Id])
}
finalData.Rows = rows
// compute the total number of versions that exist
finalData.TotalVersions, err = version.Count(version.ByProjectId(projCtx.Project.Identifier))
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
// compute the number of versions on the previous page
finalData.PreviousPageCount, err = countOnPreviousPage(skip, VersionItemsToCreate, projCtx.Project)
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
// add in the skip value
finalData.CurrentSkip = skip
// pass it the current time
finalData.CurrentTime = time.Now().UnixNano()
uis.WriteHTML(w, http.StatusOK, struct {
ProjectData projectContext
User *user.DBUser
Data waterfallData
}{projCtx, GetUser(r), finalData}, "base", "waterfall.html", "base_angular.html", "menu.html")
}
func TestFetchRevisions(t *testing.T) {
dropTestDB(t)
testutil.ConfigureIntegrationTest(t, testConfig, "TestFetchRevisions")
Convey("With a GithubRepositoryPoller with a valid OAuth token...", t, func() {
err := modelutil.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.Count(version.All)
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.Count(version.All)
testutil.HandleTestingErr(err, t, "Error finding all versions")
So(numVersions, ShouldEqual, 2)
})
Reset(func() {
dropTestDB(t)
})
})
}
func getTimelineData(projectName, requester string, versionsToSkip, versionsPerPage int) (*timelineData, error) {
data := &timelineData{}
// get the total number of versions in the database (used for pagination)
totalVersions, err := version.Count(version.ByProjectId(projectName))
if err != nil {
return nil, err
}
data.TotalVersions = totalVersions
q := version.ByMostRecentForRequester(projectName, requester).WithoutFields(version.ConfigKey).
Skip(versionsToSkip * versionsPerPage).Limit(versionsPerPage)
// get the most recent versions, to display in their entirety on the page
versionsFromDB, err := version.Find(q)
if err != nil {
return nil, err
}
// create the necessary uiVersion struct for each version
uiVersions := make([]uiVersion, len(versionsFromDB))
for versionIdx, version := range versionsFromDB {
versionAsUI := uiVersion{Version: version}
uiVersions[versionIdx] = versionAsUI
buildIds := version.BuildIds
dbBuilds, err := build.Find(build.ByIds(buildIds))
if err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Ids: %v", buildIds)
}
buildsMap := make(map[string]build.Build)
for _, dbBuild := range dbBuilds {
buildsMap[dbBuild.Id] = dbBuild
}
uiBuilds := make([]uiBuild, len(dbBuilds))
for buildIdx, buildId := range buildIds {
build := buildsMap[buildId]
buildAsUI := uiBuild{Build: build}
uiBuilds[buildIdx] = buildAsUI
}
versionAsUI.Builds = uiBuilds
uiVersions[versionIdx] = versionAsUI
}
data.Versions = uiVersions
return data, nil
}
// Create and return the waterfall data we need to render the page.
// Http handler for the waterfall page
func (uis *UIServer) waterfallPage(w http.ResponseWriter, r *http.Request) {
projCtx := MustHaveProjectContext(r)
if projCtx.Project == nil {
uis.ProjectNotFound(projCtx, w, r)
return
}
skip, err := skipValue(r)
if err != nil {
skip = 0
}
finalData := waterfallData{}
// first, get all of the versions and variants we will need
finalData.Versions, finalData.BuildVariants, err = getVersionsAndVariants(skip,
VersionItemsToCreate, projCtx.Project)
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
// compute the total number of versions that exist
finalData.TotalVersions, err = version.Count(version.ByProjectId(projCtx.Project.Identifier))
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
// compute the number of versions on the previous page
finalData.PreviousPageCount, err = countOnPreviousPage(skip, VersionItemsToCreate, projCtx.Project)
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
// add in the skip value
finalData.CurrentSkip = skip
uis.WriteHTML(w, http.StatusOK, struct {
ProjectData projectContext
User *user.DBUser
Data waterfallData
}{projCtx, GetUser(r), finalData}, "base", "waterfall.html", "base_angular.html", "menu.html")
}