EVG-13846 EVG-13946 Mainline commits query and graphql resolver.

graphql/resolvers.go

@@ -825,14 +825,7 @@ func (r *patchResolver) TaskStatuses(ctx context.Context, obj *restModel.APIPatc
 		{Key: task.DisplayNameKey, Order: 1},
 	}
 	opts := data.TaskFilterOptions{
-		Statuses:        []string{},
-		BaseStatuses:    []string{},
-		Variants:        []string{},
-		TaskNames:       []string{},
-		Page:            0,
-		Limit:           0,
-		FieldsToProject: []string{},
-		Sorts:           defaultSort,
+		Sorts: defaultSort,
 	}
 	tasks, _, err := r.sc.FindTasksByVersion(*obj.Id, opts)
 	if err != nil {
@@ -955,13 +948,7 @@ func (r *queryResolver) Patch(ctx context.Context, id string) (*restModel.APIPat
 	failedAndAbortedStatuses := append(evergreen.TaskFailureStatuses, evergreen.TaskAborted)
 	opts := data.TaskFilterOptions{
 		Statuses:        failedAndAbortedStatuses,
-		BaseStatuses:    []string{},
-		Variants:        []string{},
-		TaskNames:       []string{},
-		Page:            0,
-		Limit:           0,
 		FieldsToProject: []string{task.DisplayStatusKey},
-		Sorts:           []task.TasksSortOrder{},
 	}
 	tasks, _, err := r.sc.FindTasksByVersion(id, opts)
 	if err != nil {
@@ -1172,14 +1159,13 @@ func (r *queryResolver) PatchTasks(ctx context.Context, patchID string, sorts []
 		}
 	}
 	opts := data.TaskFilterOptions{
-		Statuses:        statuses,
-		BaseStatuses:    baseStatuses,
-		Variants:        []string{variantParam},
-		TaskNames:       []string{taskNameParam},
-		Page:            pageParam,
-		Limit:           limitParam,
-		FieldsToProject: []string{},
-		Sorts:           taskSorts,
+		Statuses:     statuses,
+		BaseStatuses: baseStatuses,
+		Variants:     []string{variantParam},
+		TaskNames:    []string{taskNameParam},
+		Page:         pageParam,
+		Limit:        limitParam,
+		Sorts:        taskSorts,
 	}
 	tasks, count, err := r.sc.FindTasksByVersion(patchID, opts)
 	if err != nil {
@@ -2526,47 +2512,42 @@ func (r *queryResolver) BbGetCreatedTickets(ctx context.Context, taskID string)
 
 // Will return an array of activated and unactivated versions
 func (r *queryResolver) MainlineCommits(ctx context.Context, options MainlineCommitsOptions) (*MainlineCommits, error) {
-
-	opts := model.MainlineCommitVersionOptions{
-		Activated:       true,
-		SkipOrderNumber: 0,
-		Limit:           0,
+	projectId, err := model.GetIdForProject(options.ProjectID)
+	if err != nil {
+		return nil, ResourceNotFound.Send(ctx, fmt.Sprintf("Could not find project with id: %s", options.ProjectID))
 	}
-	if options.Limit != nil {
-		opts.Limit = *options.Limit
+	limit := model.DefaultMainlineCommitVersionLimit
+	if utility.FromIntPtr(options.Limit) != 0 {
+		limit = utility.FromIntPtr(options.Limit)
 	}
-	if options.SkipOrderNumber != nil {
-		opts.SkipOrderNumber = *options.SkipOrderNumber
+	opts := model.MainlineCommitVersionOptions{
+		Activated:       true,
+		Limit:           limit,
+		SkipOrderNumber: utility.FromIntPtr(options.SkipOrderNumber),
 	}
 
-	activatedVersions, err := model.GetMainlineCommitVersionsWithOptions(options.ProjectID, opts)
+	activatedVersions, err := model.GetMainlineCommitVersionsWithOptions(projectId, opts)
 	if err != nil {
-		return nil, ResourceNotFound.Send(ctx, fmt.Sprintf("Error getting activated versions %s", err.Error()))
+		return nil, ResourceNotFound.Send(ctx, fmt.Sprintf("Error getting activated versions: %s", err.Error()))
 	}
+
 	opts = model.MainlineCommitVersionOptions{
 		Activated:       false,
-		SkipOrderNumber: 0,
-		Limit:           0,
-	}
-	if options.Limit != nil {
-		opts.Limit = *options.Limit
-	}
-	if options.SkipOrderNumber != nil {
-		opts.SkipOrderNumber = *options.SkipOrderNumber
+		SkipOrderNumber: utility.FromIntPtr(options.SkipOrderNumber),
 	}
-
-	unactivatedVersions, err := model.GetMainlineCommitVersionsWithOptions(options.ProjectID, opts)
+	unactivatedVersions, err := model.GetMainlineCommitVersionsWithOptions(projectId, opts)
 	if err != nil {
-		return nil, ResourceNotFound.Send(ctx, fmt.Sprintf("Error getting unactivated versions %s", err.Error()))
+		return nil, ResourceNotFound.Send(ctx, fmt.Sprintf("Error getting unactivated versions: %s", err.Error()))
 	}
+
 	versions := append(activatedVersions, unactivatedVersions...)
 	sort.Slice(versions, func(i, j int) bool {
 		return versions[i].RevisionOrderNumber > versions[j].RevisionOrderNumber
 	})
 	var mainlineCommits MainlineCommits
 	activatedVersionCount := 0
 	for _, v := range versions {
-		if activatedVersionCount == *options.Limit {
+		if activatedVersionCount == limit {
 			break
 		}
 		apiVersion := restModel.APIVersion{}
@@ -2582,14 +2563,7 @@ func (r *queryResolver) MainlineCommits(ctx context.Context, options MainlineCom
 				{Key: task.DisplayNameKey, Order: 1},
 			}
 			opts := data.TaskFilterOptions{
-				Statuses:        []string{},
-				BaseStatuses:    []string{},
-				Variants:        []string{},
-				TaskNames:       []string{},
-				Page:            0,
-				Limit:           0,
-				FieldsToProject: []string{},
-				Sorts:           defaultSort,
+				Sorts: defaultSort,
 			}
 			tasks, _, err := r.sc.FindTasksByVersion(v.Id, opts)
 			if err != nil {
@@ -2609,24 +2583,37 @@ func (r *queryResolver) MainlineCommits(ctx context.Context, options MainlineCom
 		}
 		mainlineCommitVersion := MainlineCommitVersion{}
 
+		// If a version is activated we append it directly to our returned list of mainlineCommits
+		// If a version is not activated we roll up all the unactivated versions that are sequentially near each other
+		// into a single MainlineCommitVersion and then append it to our returned list
 		if utility.FromBoolPtr(v.Activated) {
 			activatedVersionCount++
 			mainlineCommits.NextPageOrderNumber = &v.RevisionOrderNumber
 			mainlineCommitVersion.Version = &apiVersion
-			mainlineCommits.Versions = append(mainlineCommits.Versions, &mainlineCommitVersion)
+
 		} else {
+			// If we have any versions already we should check the most recent one first otherwise create a new one
 			if len(mainlineCommits.Versions) > 0 {
 				lastMainlineCommit := mainlineCommits.Versions[len(mainlineCommits.Versions)-1]
+
+				// If the previous mainlineCommit contains rolled up unactivated versions append the latest RolledUp unactivated version
 				if lastMainlineCommit.RolledUpVersions != nil {
 					lastMainlineCommit.RolledUpVersions = append(lastMainlineCommit.RolledUpVersions, &apiVersion)
+				} else {
+					mainlineCommitVersion.RolledUpVersions = []*restModel.APIVersion{&apiVersion}
 				}
+
 			} else {
 				mainlineCommitVersion.RolledUpVersions = []*restModel.APIVersion{&apiVersion}
-				mainlineCommits.Versions = append(mainlineCommits.Versions, &mainlineCommitVersion)
+
 			}
 
 		}
 
+		// Only add a mainlineCommit if a new one was added and its not a modified existing RolledUpVersion
+		if mainlineCommitVersion.Version != nil || mainlineCommitVersion.RolledUpVersions != nil {
+			mainlineCommits.Versions = append(mainlineCommits.Versions, &mainlineCommitVersion)
+		}
 	}
 
 	return &mainlineCommits, nil
@@ -2639,19 +2626,7 @@ func (r *versionResolver) BuildVariants(ctx context.Context, v *restModel.APIVer
 	if !utility.FromBoolPtr(v.Activated) {
 		return nil, nil
 	}
-	variants := []string{}
-	tasks := []string{}
-	statuses := []string{}
-	if options.Variants != nil {
-		variants = options.Variants
-	}
-	if options.Tasks != nil {
-		tasks = options.Tasks
-	}
-	if options.Statuses != nil {
-		statuses = options.Statuses
-	}
-	return generateBuildVariants(ctx, r.sc, *v.Id, variants, tasks, statuses)
+	return generateBuildVariants(ctx, r.sc, *v.Id, options.Variants, options.Tasks, options.Statuses)
 }
 
 func (r *Resolver) Version() VersionResolver { return &versionResolver{r} }

graphql/tests/mainlineCommits/data.json

@@ -29,6 +29,26 @@
       "author": "mohamed.khelif",
       "status": "created",
       "order": 3
+    },
+                        {
+      "_id": "evergreen_version4",
+      "gitspec": "5e823e1f28baeaa22ae00823d83e03082cd148ab",
+      "identifier": "evergreen",
+      "r": "gitter_request",
+      "activated": false,
+      "author": "mohamed.khelif",
+      "status": "created",
+      "order": 4
+    },
+                        {
+      "_id": "evergreen_version5",
+      "gitspec": "5e823e1f28baeaa22ae00823d83e03082cd148ab",
+      "identifier": "evergreen",
+      "r": "gitter_request",
+      "activated": true,
+      "author": "mohamed.khelif",
+      "status": "created",
+      "order": 5
     }
     ],
     "tasks" : [
@@ -70,6 +90,16 @@
             "build_variant" : "enterprise-ubuntu1604-64",
             "build_id": "evergreen_version2_build"
 
+        },
+                        {
+            "_id": "task_5",
+            "version": "evergreen_version5",
+            "status": "success",
+            "display_name": "Some Other Task",
+            "activated": true,
+            "build_variant" : "enterprise-ubuntu1604-64",
+            "build_id": "evergreen_version5_build"
+
         }
     ],
     "project_ref": [
@@ -88,6 +118,11 @@
             "_id": "evergreen_version2_build",
             "build_variant": "enterprise-ubuntu1604-64",
             "display_name": "Ubuntu 16.04"
+        },
+                        {
+            "_id": "evergreen_version5_build",
+            "build_variant": "enterprise-ubuntu1604-64",
+            "display_name": "Ubuntu 16.04"
         }
     ]
 }

graphql/tests/mainlineCommits/queries/pagination.graphql

@@ -21,7 +21,7 @@
     }
   }
   page2: mainlineCommits(
-    options: { projectID: "evergreen", limit: 1, skipOrderNumber: 2 }
+    options: { projectID: "evergreen", limit: 1, skipOrderNumber: 5 }
   ) {
     versions {
       version {