warn merge queue unsupported

Author: skarim

cmd/merge.go

@@ -140,6 +140,18 @@ func runMerge(cfg *config.Config, opts *mergeOptions, args []string) error {
 
 	base := remoteStack.Base.Ref
 
+	// Merge-queue and admin-bypass policy for the stack's base branch. The async
+	// stack merge cannot use a merge queue, so bail out early (before any
+	// prompting) when the base requires one.
+	policy, err := client.BaseBranchPolicy(base)
+	if err != nil {
+		cfg.Errorf("failed to check base branch merge settings: %s", err)
+		return ErrAPIFailure
+	}
+	if policy.RequiresMergeQueue {
+		return explainMergeQueueUnsupported(cfg, base)
+	}
+
 	if cfg.IsInteractive() && !opts.yes {
 		return runMergeInteractive(cfg, client, remoteStack.Number, base, candidates, allowed, mergeCfg.DefaultMethod, method, preselectIndex, opts)
 	}
@@ -476,6 +488,15 @@ func warnAsyncMergeUnavailable(cfg *config.Config) {
 	cfg.Warningf("Async stack merge is not available for this repository")
 }
 
+// explainMergeQueueUnsupported reports that the stack's base branch merges
+// through a merge queue, which the async stack merge cannot use, and points the
+// user to the web UI.
+func explainMergeQueueUnsupported(cfg *config.Config, base string) error {
+	cfg.Errorf("the base branch %q requires a merge queue, which \"gh stack merge\" does not support", base)
+	cfg.Printf("Merge this stack using `%q` or from the GitHub web UI instead.", "gh pr merge")
+	return ErrSilent
+}
+
 // mergeFailureExit maps a merge failure message to an exit code: rebase/merge
 // conflicts get ErrConflict, everything else ErrAPIFailure.
 func mergeFailureExit(message string) error {

cmd/merge_test.go

@@ -347,6 +347,30 @@ func TestRunMerge_AlreadyMergedOnSubmit(t *testing.T) {
 	assert.Contains(t, output, "Merged #1, #2 into main")
 }
 
+func TestRunMerge_MergeQueueRequired(t *testing.T) {
+	cfg, outR, errR := config.NewTestConfig()
+	cfg.GitHubClientOverride = &github.MockClient{
+		GetStackFn: func(n int) (*github.RemoteStack, error) {
+			return remoteStack(7, "main", openStackPR(1, "b1"), openStackPR(2, "b2")), nil
+		},
+		BaseBranchPolicyFn: func(base string) (*github.BaseBranchPolicy, error) {
+			assert.Equal(t, "main", base)
+			return &github.BaseBranchPolicy{RequiresMergeQueue: true}, nil
+		},
+		MergeStackAsyncFn: func(pr int, method string) (*github.AsyncMergeResult, error) {
+			t.Fatal("merge must not be attempted when the base requires a merge queue")
+			return nil, nil
+		},
+	}
+
+	err := runMerge(cfg, fastOptions(), []string{"7"})
+	output := collectOutput(cfg, outR, errR)
+
+	assert.ErrorIs(t, err, ErrSilent)
+	assert.Contains(t, output, "merge queue")
+	assert.Contains(t, output, "web UI")
+}
+
 func TestRunMerge_AsyncMergeUnavailable(t *testing.T) {
 	cfg, outR, errR := config.NewTestConfig()
 	cfg.GitHubClientOverride = &github.MockClient{

internal/github/client_interface.go

@@ -21,6 +21,7 @@ type ClientOps interface {
 	MergeStackAsync(prNumber int, method string) (*AsyncMergeResult, error)
 	GetAsyncMergeResult(prNumber int, uuid string) (*AsyncMergeResult, error)
 	PRTitles(numbers []int) (map[int]string, error)
+	BaseBranchPolicy(baseRef string) (*BaseBranchPolicy, error)
 }
 
 // Compile-time check that Client satisfies ClientOps.

internal/github/merge_async.go

@@ -121,6 +121,54 @@ func (c *Client) RepoMergeConfig() (*RepoMergeConfig, error) {
 	}, nil
 }
 
+// BaseBranchPolicy describes merge-relevant policy on a stack's base branch.
+type BaseBranchPolicy struct {
+	// RequiresMergeQueue reports that the base branch merges through a merge
+	// queue, so a direct async stack merge is not possible.
+	RequiresMergeQueue bool
+}
+
+// BaseBranchPolicy reports whether the given base branch requires a merge queue,
+// which the async stack merge cannot use.
+func (c *Client) BaseBranchPolicy(baseRef string) (*BaseBranchPolicy, error) {
+	var query struct {
+		Repository struct {
+			MergeQueue *struct {
+				ID string `graphql:"id"`
+			} `graphql:"mergeQueue(branch: $branch)"`
+			Ref *struct {
+				Rules struct {
+					Nodes []struct {
+						Type string `graphql:"type"`
+					} `graphql:"nodes"`
+				} `graphql:"rules(first: 50)"`
+			} `graphql:"ref(qualifiedName: $qualified)"`
+		} `graphql:"repository(owner: $owner, name: $name)"`
+	}
+
+	variables := map[string]interface{}{
+		"owner":     graphql.String(c.owner),
+		"name":      graphql.String(c.repo),
+		"branch":    graphql.String(baseRef),
+		"qualified": graphql.String("refs/heads/" + baseRef),
+	}
+
+	if err := c.gql.Query("BaseBranchPolicy", &query, variables); err != nil {
+		return nil, fmt.Errorf("querying base branch policy: %w", err)
+	}
+
+	r := query.Repository
+	policy := &BaseBranchPolicy{RequiresMergeQueue: r.MergeQueue != nil}
+	if r.Ref != nil {
+		for _, node := range r.Ref.Rules.Nodes {
+			if node.Type == "MERGE_QUEUE" {
+				policy.RequiresMergeQueue = true
+			}
+		}
+	}
+	return policy, nil
+}
+
 // MergeStackAsync requests an asynchronous merge of the given pull request. For
 // a stacked PR this merges all members of the stack up to and including
 // prNumber. A blank method lets the server apply its default.

internal/github/merge_async_test.go

@@ -169,3 +169,58 @@ func TestMergeStackAsync_OmitsEmptyMethod(t *testing.T) {
 	_, hasMethod := parsed["merge_method"]
 	assert.False(t, hasMethod, "merge_method should be omitted when empty")
 }
+
+// testPolicyClient builds a Client whose GraphQL client is backed by a stub
+// transport returning the given response body.
+func testPolicyClient(t *testing.T, graphqlResp string) *Client {
+	t.Helper()
+	rt := roundTripFunc(func(r *http.Request) (*http.Response, error) {
+		return &http.Response{
+			StatusCode: http.StatusOK,
+			Body:       io.NopCloser(strings.NewReader(graphqlResp)),
+			Header:     http.Header{"Content-Type": []string{"application/json"}},
+			Request:    r,
+		}, nil
+	})
+	gql, err := api.NewGraphQLClient(api.ClientOptions{Host: "github.com", AuthToken: "x", Transport: rt})
+	require.NoError(t, err)
+	return &Client{gql: gql, owner: "o", repo: "r"}
+}
+
+func TestBaseBranchPolicy(t *testing.T) {
+	tests := []struct {
+		name      string
+		body      string
+		wantQueue bool
+	}{
+		{
+			name: "no merge queue",
+			body: `{"data":{"repository":{"mergeQueue":null,"ref":{"rules":{"nodes":[]}}}}}`,
+		},
+		{
+			name:      "merge queue via mergeQueue field",
+			body:      `{"data":{"repository":{"mergeQueue":{"id":"MQ"},"ref":{"rules":{"nodes":[]}}}}}`,
+			wantQueue: true,
+		},
+		{
+			name:      "merge queue via ruleset type",
+			body:      `{"data":{"repository":{"mergeQueue":null,"ref":{"rules":{"nodes":[{"type":"MERGE_QUEUE"}]}}}}}`,
+			wantQueue: true,
+		},
+		{
+			name: "other rules, no merge queue",
+			body: `{"data":{"repository":{"mergeQueue":null,"ref":{"rules":{"nodes":[{"type":"PULL_REQUEST"}]}}}}}`,
+		},
+		{
+			name: "null ref",
+			body: `{"data":{"repository":{"mergeQueue":null,"ref":null}}}`,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			policy, err := testPolicyClient(t, tt.body).BaseBranchPolicy("main")
+			require.NoError(t, err)
+			assert.Equal(t, tt.wantQueue, policy.RequiresMergeQueue, "RequiresMergeQueue")
+		})
+	}
+}

internal/github/mock_client.go

@@ -21,6 +21,7 @@ type MockClient struct {
 	MergeStackAsyncFn        func(int, string) (*AsyncMergeResult, error)
 	GetAsyncMergeResultFn    func(int, string) (*AsyncMergeResult, error)
 	PRTitlesFn               func([]int) (map[int]string, error)
+	BaseBranchPolicyFn       func(string) (*BaseBranchPolicy, error)
 }
 
 // Compile-time check that MockClient satisfies ClientOps.
@@ -162,3 +163,10 @@ func (m *MockClient) PRTitles(numbers []int) (map[int]string, error) {
 	}
 	return map[int]string{}, nil
 }
+
+func (m *MockClient) BaseBranchPolicy(baseRef string) (*BaseBranchPolicy, error) {
+	if m.BaseBranchPolicyFn != nil {
+		return m.BaseBranchPolicyFn(baseRef)
+	}
+	return &BaseBranchPolicy{}, nil
+}