Support required statuses for Bulldozer to update PRs

README.md

@@ -210,6 +210,13 @@ update:
   # If true, bulldozer will ignore updating draft pull requests, unless they
   # explicitly match a configured trigger condition.
   ignore_drafts: false
+
+  # "required_statuses" is a list of additional status contexts that must pass
+  # before bulldozer will update a pull request, unless the pull request
+  # explicitly matches a configured trigger condition. This is useful if you want
+  # to require certain statuses to pass before automated updates are made.
+  required_statuses:
+    - "policy-bot: develop"
 ```
 
 #### Remote Configuration

bulldozer/config_test.go

@@ -38,13 +38,15 @@ merge:
     squash:
       body: summarize_commits
   delete_after_merge: true
+  required_statuses: ["Test 1", "Test 2"]
 
 update:
   trigger:
     labels: ["wip", "update me"]
   ignore:
     labels: ["do not update"]
   ignore_drafts: true
+  required_statuses: ["Test 3", "Test 4"]
 `
 
 		actual, err := ParseConfig([]byte(config))
@@ -57,7 +59,34 @@ update:
 			Labels:            []string{"do not merge"},
 			CommentSubstrings: []string{"==DO_NOT_MERGE=="},
 		}, actual.Merge.Ignore)
+		assert.Equal(t, []string{"Test 1", "Test 2"}, actual.Merge.RequiredStatuses)
+
 		assert.Equal(t, *actual.Update.IgnoreDrafts, true)
+		assert.Equal(t, []string{"Test 3", "Test 4"}, actual.Update.RequiredStatuses)
+	})
+
+	t.Run("parseDefaults", func(t *testing.T) {
+		config := `
+version: 1
+
+merge:
+  method: squash
+  options:
+    squash:
+      body: summarize_commits
+`
+
+		actual, err := ParseConfig([]byte(config))
+		require.Nil(t, err)
+
+		assert.Empty(t, actual.Merge.Trigger)
+		assert.Empty(t, actual.Merge.Ignore)
+		assert.Empty(t, actual.Merge.RequiredStatuses)
+
+		assert.Empty(t, actual.Update.Trigger)
+		assert.Empty(t, actual.Update.Ignore)
+		assert.Nil(t, actual.Update.IgnoreDrafts)
+		assert.Empty(t, actual.Update.RequiredStatuses)
 	})
 
 	t.Run("parseExisting", func(t *testing.T) {
@@ -102,7 +131,6 @@ update:
 		assert.Equal(t, Signals{
 			Labels: []string{"do not update"},
 		}, actual.Update.Ignore)
-		assert.Nil(t, actual.Update.IgnoreDrafts)
 	})
 
 	t.Run("ignoresOldConfig", func(t *testing.T) {

bulldozer/config_v1.go

@@ -76,6 +76,10 @@ type UpdateConfig struct {
 
 	IgnoreDrafts *bool `yaml:"ignore_drafts"`
 
+	// Additional status checks that bulldozer should require
+	// (even if the branch protection settings doesn't require it)
+	RequiredStatuses []string `yaml:"required_statuses"`
+
 	// Blacklist and Whitelist are legacy options that will be disabled in a future v2 format
 	Blacklist Signals `yaml:"blacklist"`
 	Whitelist Signals `yaml:"whitelist"`

bulldozer/evaluate.go

@@ -102,34 +102,34 @@ func ShouldMergePR(ctx context.Context, pullCtx pull.Context, mergeConfig MergeC
 	if mergeConfig.Ignore.Enabled() {
 		ignored, reason, err := IsPRIgnored(ctx, pullCtx, mergeConfig.Ignore)
 		if err != nil {
-			return false, errors.Wrap(err, "failed to determine if pull request is ignored")
+			return false, errors.Wrap(err, "failed to determine if pull request is ignored for merge")
 		}
 		if ignored {
 			logger.Debug().Msgf("%s is deemed not mergeable because ignoring is enabled and %s", pullCtx.Locator(), reason)
 			return false, nil
 		}
 	} else {
-		logger.Debug().Msg("ignoring is not enabled")
+		logger.Debug().Msg("ignoring for merge is not enabled")
 	}
 
 	if mergeConfig.Trigger.Enabled() {
 		triggered, reason, err := IsPRTriggered(ctx, pullCtx, mergeConfig.Trigger)
 		if err != nil {
-			return false, errors.Wrap(err, "failed to determine if pull request is triggered")
+			return false, errors.Wrap(err, "failed to determine if pull request is triggered for merge")
 		}
 		if !triggered {
 			logger.Debug().Msgf("%s is deemed not mergeable because triggering is enabled and no trigger signal detected", pullCtx.Locator())
 			return false, nil
 		}
 
-		logger.Debug().Msgf("%s is triggered because triggering is enabled and %s", pullCtx.Locator(), reason)
+		logger.Debug().Msgf("%s is triggered for merge because triggering is enabled and %s", pullCtx.Locator(), reason)
 	} else {
-		logger.Debug().Msg("triggering is not enabled")
+		logger.Debug().Msg("triggering for merge is not enabled")
 	}
 
 	requiredStatuses, err := pullCtx.RequiredStatuses(ctx)
 	if err != nil {
-		return false, errors.Wrap(err, "failed to determine required Github status checks")
+		return false, errors.Wrap(err, "failed to determine required Github status checks for merge")
 	}
 	requiredStatuses = append(requiredStatuses, mergeConfig.RequiredStatuses...)
 
@@ -140,7 +140,7 @@ func ShouldMergePR(ctx context.Context, pullCtx pull.Context, mergeConfig MergeC
 
 	successStatuses, err := pullCtx.CurrentSuccessStatuses(ctx)
 	if err != nil {
-		return false, errors.Wrap(err, "failed to determine currently successful status checks")
+		return false, errors.Wrap(err, "failed to determine currently successful status checks for merge")
 	}
 
 	unsatisfiedStatuses := statusSetDifference(requiredStatuses, successStatuses)
@@ -152,3 +152,58 @@ func ShouldMergePR(ctx context.Context, pullCtx pull.Context, mergeConfig MergeC
 	// Ignore required reviews and try a merge (which may fail with a 4XX).
 	return true, nil
 }
+
+func ShouldUpdatePR(ctx context.Context, pullCtx pull.Context, updateConfig UpdateConfig) (bool, error) {
+	logger := zerolog.Ctx(ctx)
+
+	if !updateConfig.Ignore.Enabled() && !updateConfig.Trigger.Enabled() && updateConfig.IgnoreDrafts == nil && len(updateConfig.RequiredStatuses) == 0 {
+		return false, nil
+	}
+
+	if updateConfig.Ignore.Enabled() {
+		ignored, reason, err := IsPRIgnored(ctx, pullCtx, updateConfig.Ignore)
+		if err != nil {
+			return false, errors.Wrap(err, "failed to determine if pull request is ignored for update")
+		}
+		if ignored {
+			logger.Debug().Msgf("%s is deemed not updateable because ignoring is enabled and %s", pullCtx.Locator(), reason)
+			return false, nil
+		}
+	}
+
+	if updateConfig.Trigger.Enabled() {
+		triggered, reason, err := IsPRTriggered(ctx, pullCtx, updateConfig.Trigger)
+		if err != nil {
+			return false, errors.Wrap(err, "failed to determine if pull request is triggered for update")
+		}
+		if !triggered {
+			logger.Debug().Msgf("%s is deemed not updateable because triggering is enabled and no trigger signal detected", pullCtx.Locator())
+			return false, nil
+		}
+
+		logger.Debug().Msgf("%s is triggered for update because triggering is enabled and %s", pullCtx.Locator(), reason)
+		return true, nil
+	}
+
+	if updateConfig.IgnoreDrafts != nil && *updateConfig.IgnoreDrafts && pullCtx.IsDraft(ctx) {
+		logger.Debug().Msgf("%s is deemed not updateable because PR is in a draft state", pullCtx.Locator())
+		return false, nil
+	}
+
+	requiredStatuses := updateConfig.RequiredStatuses
+
+	if len(requiredStatuses) > 0 {
+		successStatuses, err := pullCtx.CurrentSuccessStatuses(ctx)
+		if err != nil {
+			return false, errors.Wrap(err, "failed to determine currently successful status checks for update")
+		}
+
+		unsatisfiedStatuses := statusSetDifference(requiredStatuses, successStatuses)
+		if len(unsatisfiedStatuses) > 0 {
+			logger.Debug().Msgf("%s is deemed not updateable because of unfulfilled status checks: [%s]", pullCtx.Locator(), strings.Join(unsatisfiedStatuses, ","))
+			return false, nil
+		}
+	}
+
+	return true, nil
+}