From bfd140c0e5f11f7fcbcb4ddbbc2ba4e0624604c5 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Wed, 6 Nov 2024 07:57:18 -0700
Subject: [PATCH 01/68] initial pass at fetching bundles with sas urls

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 go.mod                                        |  1 +
 go.sum                                        |  2 +
 pkg/cmd/attestation/api/attestation.go        |  1 +
 pkg/cmd/attestation/api/client.go             | 49 +++++++++++++++++++
 pkg/cmd/attestation/api/mock_client.go        |  4 ++
 .../attestation/verification/attestation.go   | 16 +++++-
 6 files changed, 71 insertions(+), 2 deletions(-)

diff --git a/go.mod b/go.mod
index 77be0c19d..9a2e53d38 100644
--- a/go.mod
+++ b/go.mod
@@ -92,6 +92,7 @@ require (
 	github.com/go-openapi/swag v0.23.0 // indirect
 	github.com/go-openapi/validate v0.24.0 // indirect
 	github.com/godbus/dbus/v5 v5.1.0 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/certificate-transparency-go v1.2.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/css v1.0.0 // indirect
diff --git a/go.sum b/go.sum
index fe7adc3e7..cc92ed459 100644
--- a/go.sum
+++ b/go.sum
@@ -198,6 +198,8 @@ github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l
 github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/certificate-transparency-go v1.2.1 h1:4iW/NwzqOqYEEoCBEFP+jPbBXbLqMpq3CifMyOnDUME=
 github.com/google/certificate-transparency-go v1.2.1/go.mod h1:bvn/ytAccv+I6+DGkqpvSsEdiVGramgaSC6RD3tEmeE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
diff --git a/pkg/cmd/attestation/api/attestation.go b/pkg/cmd/attestation/api/attestation.go
index ea055b293..d5c444ee2 100644
--- a/pkg/cmd/attestation/api/attestation.go
+++ b/pkg/cmd/attestation/api/attestation.go
@@ -26,6 +26,7 @@ func newErrNoAttestations(name, digest string) ErrNoAttestations {
 
 type Attestation struct {
 	Bundle *bundle.Bundle `json:"bundle"`
+	SASUrl string         `json:"signedAccessSignatureUrl"`
 }
 
 type AttestationsResponse struct {
diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index f47b5f759..f2f9f48f8 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -1,16 +1,21 @@
 package api
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"strings"
 	"time"
 
 	"github.com/cenkalti/backoff/v4"
 	"github.com/cli/cli/v2/api"
 	ioconfig "github.com/cli/cli/v2/pkg/cmd/attestation/io"
+	"github.com/golang/snappy"
+	v1 "github.com/sigstore/protobuf-specs/gen/pb-go/bundle/v1"
+	"github.com/sigstore/sigstore-go/pkg/bundle"
 )
 
 const (
@@ -25,6 +30,7 @@ type apiClient interface {
 }
 
 type Client interface {
+	FetchAttestationsWithSASURL(attestations []*Attestation) ([]*Attestation, error)
 	GetByRepoAndDigest(repo, digest string, limit int) ([]*Attestation, error)
 	GetByOwnerAndDigest(owner, digest string, limit int) ([]*Attestation, error)
 	GetTrustDomain() (string, error)
@@ -130,6 +136,49 @@ func (c *LiveClient) getAttestations(url, name, digest string, limit int) ([]*At
 	return attestations, nil
 }
 
+func (c *LiveClient) FetchAttestationsWithSASURL(attestations []*Attestation) ([]*Attestation, error) {
+	fetched := make([]*Attestation, len(attestations))
+	for i, a := range attestations {
+		b, err := c.fetchAttestationWithSASURL(a)
+		if err != nil {
+			return nil, fmt.Errorf("failed to fetch attestation with SAS URL: %w", err)
+		}
+		fetched[i] = &Attestation{
+			Bundle: b,
+		}
+	}
+	return fetched, nil
+}
+
+func (c *LiveClient) fetchAttestationWithSASURL(a *Attestation) (*bundle.Bundle, error) {
+	if a.SASUrl == "" {
+		return a.Bundle, nil
+	}
+
+	parsed, err := url.Parse(a.SASUrl)
+	if err != nil {
+		return nil, err
+	}
+
+	var resp []byte
+	if err = c.api.REST(parsed.Host, http.MethodGet, parsed.Path, nil, &resp); err != nil {
+		return nil, err
+	}
+
+	var decompressedBytes []byte
+	_, err = snappy.Decode(decompressedBytes, resp)
+	if err != nil {
+		return nil, err
+	}
+
+	var pbBundle *v1.Bundle
+	if err = json.Unmarshal(decompressedBytes, pbBundle); err != nil {
+		return nil, err
+	}
+
+	return bundle.NewBundle(pbBundle)
+}
+
 func shouldRetry(err error) bool {
 	var httpError api.HTTPError
 	if errors.As(err, &httpError) {
diff --git a/pkg/cmd/attestation/api/mock_client.go b/pkg/cmd/attestation/api/mock_client.go
index bcb51c414..17bfdadec 100644
--- a/pkg/cmd/attestation/api/mock_client.go
+++ b/pkg/cmd/attestation/api/mock_client.go
@@ -12,6 +12,10 @@ type MockClient struct {
 	OnGetTrustDomain      func() (string, error)
 }
 
+func (m MockClient) FetchAttestationsWithSASURL(attestations []*Attestation) ([]*Attestation, error) {
+	return nil, nil
+}
+
 func (m MockClient) GetByRepoAndDigest(repo, digest string, limit int) ([]*Attestation, error) {
 	return m.OnGetByRepoAndDigest(repo, digest, limit)
 }
diff --git a/pkg/cmd/attestation/verification/attestation.go b/pkg/cmd/attestation/verification/attestation.go
index 0ea91c2f7..a4548a72d 100644
--- a/pkg/cmd/attestation/verification/attestation.go
+++ b/pkg/cmd/attestation/verification/attestation.go
@@ -127,13 +127,25 @@ func GetRemoteAttestations(c FetchAttestationsConfig) ([]*api.Attestation, error
 		if err != nil {
 			return nil, fmt.Errorf("failed to fetch attestations from %s: %w", c.Repo, err)
 		}
-		return attestations, nil
+
+		fetched, err := c.APIClient.FetchAttestationsWithSASURL(attestations)
+		if err != nil {
+			return nil, fmt.Errorf("failed to fetch bundles from SAS URL: %w", err)
+		}
+
+		return fetched, nil
 	} else if c.Owner != "" {
 		attestations, err := c.APIClient.GetByOwnerAndDigest(c.Owner, c.Digest, c.Limit)
 		if err != nil {
 			return nil, fmt.Errorf("failed to fetch attestations from %s: %w", c.Owner, err)
 		}
-		return attestations, nil
+
+		fetched, err := c.APIClient.FetchAttestationsWithSASURL(attestations)
+		if err != nil {
+			return nil, fmt.Errorf("failed to fetch bundles from SAS URL: %w", err)
+		}
+
+		return fetched, nil
 	}
 	return nil, fmt.Errorf("owner or repo must be provided")
 }

From 5a6a7968a30b70e50dbc8521f2bcaf5d23c6102b Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 16 Dec 2024 11:25:43 -0700
Subject: [PATCH 02/68] fetch bundles with sas url

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/attestation.go        |  4 +-
 pkg/cmd/attestation/api/client.go             | 83 +++++++++++++------
 pkg/cmd/attestation/api/mock_client.go        |  7 +-
 .../attestation/verification/attestation.go   | 20 ++---
 4 files changed, 69 insertions(+), 45 deletions(-)

diff --git a/pkg/cmd/attestation/api/attestation.go b/pkg/cmd/attestation/api/attestation.go
index d5c444ee2..16b062a96 100644
--- a/pkg/cmd/attestation/api/attestation.go
+++ b/pkg/cmd/attestation/api/attestation.go
@@ -25,8 +25,8 @@ func newErrNoAttestations(name, digest string) ErrNoAttestations {
 }
 
 type Attestation struct {
-	Bundle *bundle.Bundle `json:"bundle"`
-	SASUrl string         `json:"signedAccessSignatureUrl"`
+	Bundle    *bundle.Bundle `json:"bundle"`
+	BundleURL string         `json:"bundle_url"`
 }
 
 type AttestationsResponse struct {
diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index f2f9f48f8..acc4a1014 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -1,12 +1,10 @@
 package api
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
-	"net/url"
 	"strings"
 	"time"
 
@@ -16,6 +14,7 @@ import (
 	"github.com/golang/snappy"
 	v1 "github.com/sigstore/protobuf-specs/gen/pb-go/bundle/v1"
 	"github.com/sigstore/sigstore-go/pkg/bundle"
+	"google.golang.org/protobuf/encoding/protojson"
 )
 
 const (
@@ -24,13 +23,16 @@ const (
 	maxLimitForFetch = 100
 )
 
+// Allow injecting backoff interval in tests.
+var getAttestationRetryInterval = time.Millisecond * 200
+
 type apiClient interface {
 	REST(hostname, method, p string, body io.Reader, data interface{}) error
 	RESTWithNext(hostname, method, p string, body io.Reader, data interface{}) (string, error)
 }
 
 type Client interface {
-	FetchAttestationsWithSASURL(attestations []*Attestation) ([]*Attestation, error)
+	// FetchAttestationsWithSASURL(attestations []*Attestation) ([]*Attestation, error)
 	GetByRepoAndDigest(repo, digest string, limit int) ([]*Attestation, error)
 	GetByOwnerAndDigest(owner, digest string, limit int) ([]*Attestation, error)
 	GetTrustDomain() (string, error)
@@ -58,7 +60,18 @@ func (c *LiveClient) BuildRepoAndDigestURL(repo, digest string) string {
 // GetByRepoAndDigest fetches the attestation by repo and digest
 func (c *LiveClient) GetByRepoAndDigest(repo, digest string, limit int) ([]*Attestation, error) {
 	url := c.BuildRepoAndDigestURL(repo, digest)
-	return c.getAttestations(url, repo, digest, limit)
+	attestations, err := c.getAttestations(url, repo, digest, limit)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch attestation by repo and digest: %w", err)
+	}
+
+	compressedBundles, err := c.fetchBundlesWithSASURL(attestations)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch attestation with SAS URL: %w", err)
+	}
+
+	// decompress before returning
+	return compressedBundles, nil
 }
 
 func (c *LiveClient) BuildOwnerAndDigestURL(owner, digest string) string {
@@ -69,7 +82,18 @@ func (c *LiveClient) BuildOwnerAndDigestURL(owner, digest string) string {
 // GetByOwnerAndDigest fetches attestation by owner and digest
 func (c *LiveClient) GetByOwnerAndDigest(owner, digest string, limit int) ([]*Attestation, error) {
 	url := c.BuildOwnerAndDigestURL(owner, digest)
-	return c.getAttestations(url, owner, digest, limit)
+	attestations, err := c.getAttestations(url, owner, digest, limit)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch attestation by repo and digest: %w", err)
+	}
+
+	compressedBundles, err := c.fetchBundlesWithSASURL(attestations)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch attestation with SAS URL: %w", err)
+	}
+
+	// decompress before returning
+	return compressedBundles, nil
 }
 
 // GetTrustDomain returns the current trust domain. If the default is used
@@ -78,9 +102,6 @@ func (c *LiveClient) GetTrustDomain() (string, error) {
 	return c.getTrustDomain(MetaPath)
 }
 
-// Allow injecting backoff interval in tests.
-var getAttestationRetryInterval = time.Millisecond * 200
-
 func (c *LiveClient) getAttestations(url, name, digest string, limit int) ([]*Attestation, error) {
 	c.logger.VerbosePrintf("Fetching attestations for artifact digest %s\n\n", digest)
 
@@ -136,12 +157,12 @@ func (c *LiveClient) getAttestations(url, name, digest string, limit int) ([]*At
 	return attestations, nil
 }
 
-func (c *LiveClient) FetchAttestationsWithSASURL(attestations []*Attestation) ([]*Attestation, error) {
+func (c *LiveClient) fetchBundlesWithSASURL(attestations []*Attestation) ([]*Attestation, error) {
 	fetched := make([]*Attestation, len(attestations))
 	for i, a := range attestations {
-		b, err := c.fetchAttestationWithSASURL(a)
+		b, err := c.fetchBundleWithSASURL(a)
 		if err != nil {
-			return nil, fmt.Errorf("failed to fetch attestation with SAS URL: %w", err)
+			return nil, fmt.Errorf("failed to fetch bundle with SAS URL: %w", err)
 		}
 		fetched[i] = &Attestation{
 			Bundle: b,
@@ -150,33 +171,45 @@ func (c *LiveClient) FetchAttestationsWithSASURL(attestations []*Attestation) ([
 	return fetched, nil
 }
 
-func (c *LiveClient) fetchAttestationWithSASURL(a *Attestation) (*bundle.Bundle, error) {
-	if a.SASUrl == "" {
-		return a.Bundle, nil
+func (c *LiveClient) fetchBundleWithSASURL(a *Attestation) (*bundle.Bundle, error) {
+	if a.BundleURL == "" {
+		//return a.Bundle, nil
+		return nil, fmt.Errorf("SAS URL is empty")
 	}
 
-	parsed, err := url.Parse(a.SASUrl)
+	c.logger.VerbosePrintf("Fetching attestation bundle\n\n")
+
+	httpClient := http.DefaultClient
+	r, err := httpClient.Get(a.BundleURL)
 	if err != nil {
 		return nil, err
 	}
 
-	var resp []byte
-	if err = c.api.REST(parsed.Host, http.MethodGet, parsed.Path, nil, &resp); err != nil {
-		return nil, err
+	defer r.Body.Close()
+	if r.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("unexpected status code: %d", r.StatusCode)
 	}
 
-	var decompressedBytes []byte
-	_, err = snappy.Decode(decompressedBytes, resp)
+	// parse the URL to get the host and path
+	resp, err := io.ReadAll(r.Body)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to read blob storage response body: %w", err)
 	}
 
-	var pbBundle *v1.Bundle
-	if err = json.Unmarshal(decompressedBytes, pbBundle); err != nil {
-		return nil, err
+	var out []byte
+	decompressed, err := snappy.Decode(out, resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decompress with snappy: %w", err)
 	}
 
-	return bundle.NewBundle(pbBundle)
+	var pbBundle v1.Bundle
+	if err = protojson.Unmarshal(decompressed, &pbBundle); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal to bundle: %w", err)
+	}
+
+	c.logger.VerbosePrintf("Successfully fetched bundle\n\n")
+
+	return bundle.NewBundle(&pbBundle)
 }
 
 func shouldRetry(err error) bool {
diff --git a/pkg/cmd/attestation/api/mock_client.go b/pkg/cmd/attestation/api/mock_client.go
index 17bfdadec..63dd3d244 100644
--- a/pkg/cmd/attestation/api/mock_client.go
+++ b/pkg/cmd/attestation/api/mock_client.go
@@ -7,9 +7,10 @@ import (
 )
 
 type MockClient struct {
-	OnGetByRepoAndDigest  func(repo, digest string, limit int) ([]*Attestation, error)
-	OnGetByOwnerAndDigest func(owner, digest string, limit int) ([]*Attestation, error)
-	OnGetTrustDomain      func() (string, error)
+	OnGetByRepoAndDigest          func(repo, digest string, limit int) ([]*Attestation, error)
+	OnGetByOwnerAndDigest         func(owner, digest string, limit int) ([]*Attestation, error)
+	OnGetTrustDomain              func() (string, error)
+	OnFetchAttestationsWithSASURL func(attestations []*Attestation) ([]*Attestation, error)
 }
 
 func (m MockClient) FetchAttestationsWithSASURL(attestations []*Attestation) ([]*Attestation, error) {
diff --git a/pkg/cmd/attestation/verification/attestation.go b/pkg/cmd/attestation/verification/attestation.go
index 9755e46f5..41da71010 100644
--- a/pkg/cmd/attestation/verification/attestation.go
+++ b/pkg/cmd/attestation/verification/attestation.go
@@ -102,29 +102,19 @@ func GetRemoteAttestations(client api.Client, params FetchRemoteAttestationsPara
 	// check if Repo is set first because if Repo has been set, Owner will be set using the value of Repo.
 	// If Repo is not set, the field will remain empty. It will not be populated using the value of Owner.
 	if params.Repo != "" {
-		attestations, err := client.GetByRepoAndDigest(params.Repo, params.Digest, params.Limit)
+		bundles, err := client.GetByRepoAndDigest(params.Repo, params.Digest, params.Limit)
 		if err != nil {
-			return nil, fmt.Errorf("failed to fetch attestations from %s: %w", params.Repo, err)
+			return nil, fmt.Errorf("failed to fetch attestation bundles from %s: %w", params.Repo, err)
 		}
 
-		fetched, err := client.FetchAttestationsWithSASURL(attestations)
-		if err != nil {
-			return nil, fmt.Errorf("failed to fetch bundles from SAS URL: %w", err)
-		}
-
-		return fetched, nil
+		return bundles, nil
 	} else if params.Owner != "" {
-		attestations, err := client.GetByOwnerAndDigest(params.Owner, params.Digest, params.Limit)
+		bundles, err := client.GetByOwnerAndDigest(params.Owner, params.Digest, params.Limit)
 		if err != nil {
 			return nil, fmt.Errorf("failed to fetch attestations from %s: %w", params.Owner, err)
 		}
 
-		fetched, err := client.FetchAttestationsWithSASURL(attestations)
-		if err != nil {
-			return nil, fmt.Errorf("failed to fetch bundles from SAS URL: %w", err)
-		}
-
-		return fetched, nil
+		return bundles, nil
 	}
 	return nil, fmt.Errorf("owner or repo must be provided")
 }

From e51b4efaa9008ebeaf373b91deed654987489c79 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 16 Dec 2024 11:50:46 -0700
Subject: [PATCH 03/68] remove unused method

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go      | 15 ++++++---------
 pkg/cmd/attestation/api/mock_client.go | 11 +++--------
 2 files changed, 9 insertions(+), 17 deletions(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index acc4a1014..47cff27ed 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -32,7 +32,6 @@ type apiClient interface {
 }
 
 type Client interface {
-	// FetchAttestationsWithSASURL(attestations []*Attestation) ([]*Attestation, error)
 	GetByRepoAndDigest(repo, digest string, limit int) ([]*Attestation, error)
 	GetByOwnerAndDigest(owner, digest string, limit int) ([]*Attestation, error)
 	GetTrustDomain() (string, error)
@@ -65,35 +64,33 @@ func (c *LiveClient) GetByRepoAndDigest(repo, digest string, limit int) ([]*Atte
 		return nil, fmt.Errorf("failed to fetch attestation by repo and digest: %w", err)
 	}
 
-	compressedBundles, err := c.fetchBundlesWithSASURL(attestations)
+	bundles, err := c.fetchBundlesWithSASURL(attestations)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch attestation with SAS URL: %w", err)
 	}
 
-	// decompress before returning
-	return compressedBundles, nil
+	return bundles, nil
 }
 
-func (c *LiveClient) BuildOwnerAndDigestURL(owner, digest string) string {
+func (c *LiveClient) buildOwnerAndDigestURL(owner, digest string) string {
 	owner = strings.Trim(owner, "/")
 	return fmt.Sprintf(GetAttestationByOwnerAndSubjectDigestPath, owner, digest)
 }
 
 // GetByOwnerAndDigest fetches attestation by owner and digest
 func (c *LiveClient) GetByOwnerAndDigest(owner, digest string, limit int) ([]*Attestation, error) {
-	url := c.BuildOwnerAndDigestURL(owner, digest)
+	url := c.buildOwnerAndDigestURL(owner, digest)
 	attestations, err := c.getAttestations(url, owner, digest, limit)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch attestation by repo and digest: %w", err)
 	}
 
-	compressedBundles, err := c.fetchBundlesWithSASURL(attestations)
+	bundles, err := c.fetchBundlesWithSASURL(attestations)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch attestation with SAS URL: %w", err)
 	}
 
-	// decompress before returning
-	return compressedBundles, nil
+	return bundles, nil
 }
 
 // GetTrustDomain returns the current trust domain. If the default is used
diff --git a/pkg/cmd/attestation/api/mock_client.go b/pkg/cmd/attestation/api/mock_client.go
index 63dd3d244..bcb51c414 100644
--- a/pkg/cmd/attestation/api/mock_client.go
+++ b/pkg/cmd/attestation/api/mock_client.go
@@ -7,14 +7,9 @@ import (
 )
 
 type MockClient struct {
-	OnGetByRepoAndDigest          func(repo, digest string, limit int) ([]*Attestation, error)
-	OnGetByOwnerAndDigest         func(owner, digest string, limit int) ([]*Attestation, error)
-	OnGetTrustDomain              func() (string, error)
-	OnFetchAttestationsWithSASURL func(attestations []*Attestation) ([]*Attestation, error)
-}
-
-func (m MockClient) FetchAttestationsWithSASURL(attestations []*Attestation) ([]*Attestation, error) {
-	return nil, nil
+	OnGetByRepoAndDigest  func(repo, digest string, limit int) ([]*Attestation, error)
+	OnGetByOwnerAndDigest func(owner, digest string, limit int) ([]*Attestation, error)
+	OnGetTrustDomain      func() (string, error)
 }
 
 func (m MockClient) GetByRepoAndDigest(repo, digest string, limit int) ([]*Attestation, error) {

From 6b95175363ccceb31259f88a216763a3dc02d345 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 16 Dec 2024 11:57:42 -0700
Subject: [PATCH 04/68] add httpClient field to LiveClient struct

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go      | 34 ++++++++++++++------------
 pkg/cmd/attestation/api/client_test.go | 18 +++++++-------
 2 files changed, 28 insertions(+), 24 deletions(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index 47cff27ed..34be1a6bb 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -26,11 +26,15 @@ const (
 // Allow injecting backoff interval in tests.
 var getAttestationRetryInterval = time.Millisecond * 200
 
-type apiClient interface {
+type githubApiClient interface {
 	REST(hostname, method, p string, body io.Reader, data interface{}) error
 	RESTWithNext(hostname, method, p string, body io.Reader, data interface{}) (string, error)
 }
 
+type httpClient interface {
+	Get(url string) (*http.Response, error)
+}
+
 type Client interface {
 	GetByRepoAndDigest(repo, digest string, limit int) ([]*Attestation, error)
 	GetByOwnerAndDigest(owner, digest string, limit int) ([]*Attestation, error)
@@ -38,27 +42,29 @@ type Client interface {
 }
 
 type LiveClient struct {
-	api    apiClient
-	host   string
-	logger *ioconfig.Handler
+	githubAPI  githubApiClient
+	httpClient httpClient
+	host       string
+	logger     *ioconfig.Handler
 }
 
 func NewLiveClient(hc *http.Client, host string, l *ioconfig.Handler) *LiveClient {
 	return &LiveClient{
-		api:    api.NewClientFromHTTP(hc),
-		host:   strings.TrimSuffix(host, "/"),
-		logger: l,
+		githubAPI:  api.NewClientFromHTTP(hc),
+		host:       strings.TrimSuffix(host, "/"),
+		httpClient: hc,
+		logger:     l,
 	}
 }
 
-func (c *LiveClient) BuildRepoAndDigestURL(repo, digest string) string {
+func (c *LiveClient) buildRepoAndDigestURL(repo, digest string) string {
 	repo = strings.Trim(repo, "/")
 	return fmt.Sprintf(GetAttestationByRepoAndSubjectDigestPath, repo, digest)
 }
 
 // GetByRepoAndDigest fetches the attestation by repo and digest
 func (c *LiveClient) GetByRepoAndDigest(repo, digest string, limit int) ([]*Attestation, error) {
-	url := c.BuildRepoAndDigestURL(repo, digest)
+	url := c.buildRepoAndDigestURL(repo, digest)
 	attestations, err := c.getAttestations(url, repo, digest, limit)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch attestation by repo and digest: %w", err)
@@ -121,7 +127,7 @@ func (c *LiveClient) getAttestations(url, name, digest string, limit int) ([]*At
 	// if no attestation or less than limit, then keep fetching
 	for url != "" && len(attestations) < limit {
 		err := backoff.Retry(func() error {
-			newURL, restErr := c.api.RESTWithNext(c.host, http.MethodGet, url, nil, &resp)
+			newURL, restErr := c.githubAPI.RESTWithNext(c.host, http.MethodGet, url, nil, &resp)
 
 			if restErr != nil {
 				if shouldRetry(restErr) {
@@ -170,14 +176,12 @@ func (c *LiveClient) fetchBundlesWithSASURL(attestations []*Attestation) ([]*Att
 
 func (c *LiveClient) fetchBundleWithSASURL(a *Attestation) (*bundle.Bundle, error) {
 	if a.BundleURL == "" {
-		//return a.Bundle, nil
-		return nil, fmt.Errorf("SAS URL is empty")
+		return nil, fmt.Errorf("bundle URL is empty")
 	}
 
 	c.logger.VerbosePrintf("Fetching attestation bundle\n\n")
 
-	httpClient := http.DefaultClient
-	r, err := httpClient.Get(a.BundleURL)
+	r, err := c.httpClient.Get(a.BundleURL)
 	if err != nil {
 		return nil, err
 	}
@@ -225,7 +229,7 @@ func (c *LiveClient) getTrustDomain(url string) (string, error) {
 
 	bo := backoff.NewConstantBackOff(getAttestationRetryInterval)
 	err := backoff.Retry(func() error {
-		restErr := c.api.REST(c.host, http.MethodGet, url, nil, &resp)
+		restErr := c.githubAPI.REST(c.host, http.MethodGet, url, nil, &resp)
 		if restErr != nil {
 			if shouldRetry(restErr) {
 				return restErr
diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index adac00598..fb3b338bf 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -22,7 +22,7 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 
 	if hasNextPage {
 		return &LiveClient{
-			api: mockAPIClient{
+			githubAPI: mockAPIClient{
 				OnRESTWithNext: fetcher.OnRESTSuccessWithNextPage,
 			},
 			logger: l,
@@ -30,7 +30,7 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 	}
 
 	return &LiveClient{
-		api: mockAPIClient{
+		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTSuccess,
 		},
 		logger: l,
@@ -50,7 +50,7 @@ func TestGetURL(t *testing.T) {
 	}
 
 	for _, data := range testData {
-		s := c.BuildRepoAndDigestURL(data.repo, data.digest)
+		s := c.buildRepoAndDigestURL(data.repo, data.digest)
 		require.Equal(t, data.expected, s)
 	}
 }
@@ -135,7 +135,7 @@ func TestGetByDigest_NoAttestationsFound(t *testing.T) {
 	}
 
 	c := LiveClient{
-		api: mockAPIClient{
+		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTWithNextNoAttestations,
 		},
 		logger: io.NewTestHandler(),
@@ -158,7 +158,7 @@ func TestGetByDigest_Error(t *testing.T) {
 	}
 
 	c := LiveClient{
-		api: mockAPIClient{
+		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTWithNextError,
 		},
 		logger: io.NewTestHandler(),
@@ -180,7 +180,7 @@ func TestGetTrustDomain(t *testing.T) {
 
 	t.Run("with returned trust domain", func(t *testing.T) {
 		c := LiveClient{
-			api: mockAPIClient{
+			githubAPI: mockAPIClient{
 				OnREST: fetcher.OnREST,
 			},
 			logger: io.NewTestHandler(),
@@ -193,7 +193,7 @@ func TestGetTrustDomain(t *testing.T) {
 
 	t.Run("with error", func(t *testing.T) {
 		c := LiveClient{
-			api: mockAPIClient{
+			githubAPI: mockAPIClient{
 				OnREST: fetcher.OnRESTError,
 			},
 			logger: io.NewTestHandler(),
@@ -213,7 +213,7 @@ func TestGetAttestationsRetries(t *testing.T) {
 	}
 
 	c := &LiveClient{
-		api: mockAPIClient{
+		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.FlakyOnRESTSuccessWithNextPageHandler(),
 		},
 		logger: io.NewTestHandler(),
@@ -252,7 +252,7 @@ func TestGetAttestationsMaxRetries(t *testing.T) {
 	}
 
 	c := &LiveClient{
-		api: mockAPIClient{
+		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnREST500ErrorHandler(),
 		},
 		logger: io.NewTestHandler(),

From 45121f6674345a7b56ec8ef1153f7b2aee8c1a6f Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 16 Dec 2024 12:02:42 -0700
Subject: [PATCH 05/68] go mod tidy

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 go.mod | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/go.mod b/go.mod
index d2179290d..5a3188875 100644
--- a/go.mod
+++ b/go.mod
@@ -21,6 +21,7 @@ require (
 	github.com/distribution/reference v0.5.0
 	github.com/gabriel-vasile/mimetype v1.4.7
 	github.com/gdamore/tcell/v2 v2.5.4
+	github.com/golang/snappy v0.0.4
 	github.com/google/go-cmp v0.6.0
 	github.com/google/go-containerregistry v0.20.2
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
@@ -92,7 +93,6 @@ require (
 	github.com/go-openapi/swag v0.23.0 // indirect
 	github.com/go-openapi/validate v0.24.0 // indirect
 	github.com/godbus/dbus/v5 v5.1.0 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/certificate-transparency-go v1.2.1 // indirect
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/gorilla/css v1.0.0 // indirect

From 8f5d7100f5056cc375a6c58dabc9dfaf55424769 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 16 Dec 2024 12:02:52 -0700
Subject: [PATCH 06/68] var naming

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index 34be1a6bb..7646b04e1 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -181,24 +181,24 @@ func (c *LiveClient) fetchBundleWithSASURL(a *Attestation) (*bundle.Bundle, erro
 
 	c.logger.VerbosePrintf("Fetching attestation bundle\n\n")
 
-	r, err := c.httpClient.Get(a.BundleURL)
+	resp, err := c.httpClient.Get(a.BundleURL)
 	if err != nil {
 		return nil, err
 	}
 
-	defer r.Body.Close()
-	if r.StatusCode != http.StatusOK {
-		return nil, fmt.Errorf("unexpected status code: %d", r.StatusCode)
+	defer resp.Body.Close()
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
 	}
 
 	// parse the URL to get the host and path
-	resp, err := io.ReadAll(r.Body)
+	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read blob storage response body: %w", err)
 	}
 
 	var out []byte
-	decompressed, err := snappy.Decode(out, resp)
+	decompressed, err := snappy.Decode(out, body)
 	if err != nil {
 		return nil, fmt.Errorf("failed to decompress with snappy: %w", err)
 	}

From fb020f2a79aefa878f1e84d33410e18c8bb4e5f1 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 16 Dec 2024 12:13:22 -0700
Subject: [PATCH 07/68] update error messages

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index 7646b04e1..fc5e06f7b 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -70,9 +70,9 @@ func (c *LiveClient) GetByRepoAndDigest(repo, digest string, limit int) ([]*Atte
 		return nil, fmt.Errorf("failed to fetch attestation by repo and digest: %w", err)
 	}
 
-	bundles, err := c.fetchBundlesWithSASURL(attestations)
+	bundles, err := c.fetchBundlesByURL(attestations)
 	if err != nil {
-		return nil, fmt.Errorf("failed to fetch attestation with SAS URL: %w", err)
+		return nil, fmt.Errorf("failed to fetch bundle with URL: %w", err)
 	}
 
 	return bundles, nil
@@ -91,9 +91,9 @@ func (c *LiveClient) GetByOwnerAndDigest(owner, digest string, limit int) ([]*At
 		return nil, fmt.Errorf("failed to fetch attestation by repo and digest: %w", err)
 	}
 
-	bundles, err := c.fetchBundlesWithSASURL(attestations)
+	bundles, err := c.fetchBundlesByURL(attestations)
 	if err != nil {
-		return nil, fmt.Errorf("failed to fetch attestation with SAS URL: %w", err)
+		return nil, fmt.Errorf("failed to fetch bundle with URL: %w", err)
 	}
 
 	return bundles, nil
@@ -160,12 +160,12 @@ func (c *LiveClient) getAttestations(url, name, digest string, limit int) ([]*At
 	return attestations, nil
 }
 
-func (c *LiveClient) fetchBundlesWithSASURL(attestations []*Attestation) ([]*Attestation, error) {
+func (c *LiveClient) fetchBundlesByURL(attestations []*Attestation) ([]*Attestation, error) {
 	fetched := make([]*Attestation, len(attestations))
 	for i, a := range attestations {
-		b, err := c.fetchBundleWithSASURL(a)
+		b, err := c.fetchBundleByURL(a)
 		if err != nil {
-			return nil, fmt.Errorf("failed to fetch bundle with SAS URL: %w", err)
+			return nil, fmt.Errorf("failed to fetch bundle with URL: %w", err)
 		}
 		fetched[i] = &Attestation{
 			Bundle: b,
@@ -174,7 +174,7 @@ func (c *LiveClient) fetchBundlesWithSASURL(attestations []*Attestation) ([]*Att
 	return fetched, nil
 }
 
-func (c *LiveClient) fetchBundleWithSASURL(a *Attestation) (*bundle.Bundle, error) {
+func (c *LiveClient) fetchBundleByURL(a *Attestation) (*bundle.Bundle, error) {
 	if a.BundleURL == "" {
 		return nil, fmt.Errorf("bundle URL is empty")
 	}

From e4431a3f55de6c9a20394e31aaa91f5f40a8d191 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 16 Dec 2024 12:22:20 -0700
Subject: [PATCH 08/68] add mock http client

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client_test.go        |  6 +++++
 pkg/cmd/attestation/api/mock_client.go        |  2 +-
 ...t_test.go => mock_githubApiClient_test.go} |  0
 .../attestation/api/mock_httpClient_test.go   | 25 +++++++++++++++++++
 4 files changed, 32 insertions(+), 1 deletion(-)
 rename pkg/cmd/attestation/api/{mock_apiClient_test.go => mock_githubApiClient_test.go} (100%)
 create mode 100644 pkg/cmd/attestation/api/mock_httpClient_test.go

diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index fb3b338bf..9e47870cf 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -25,6 +25,9 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 			githubAPI: mockAPIClient{
 				OnRESTWithNext: fetcher.OnRESTSuccessWithNextPage,
 			},
+			httpClient: mockHttpClient{
+				OnGet: fetcher.OnGetSuccess,
+			},
 			logger: l,
 		}
 	}
@@ -33,6 +36,9 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTSuccess,
 		},
+		httpClient: mockHttpClient{
+			OnGet: fetcher.OnGetSuccess,
+		},
 		logger: l,
 	}
 }
diff --git a/pkg/cmd/attestation/api/mock_client.go b/pkg/cmd/attestation/api/mock_client.go
index bcb51c414..b2fd334c0 100644
--- a/pkg/cmd/attestation/api/mock_client.go
+++ b/pkg/cmd/attestation/api/mock_client.go
@@ -25,7 +25,7 @@ func (m MockClient) GetTrustDomain() (string, error) {
 }
 
 func makeTestAttestation() Attestation {
-	return Attestation{Bundle: data.SigstoreBundle(nil)}
+	return Attestation{Bundle: data.SigstoreBundle(nil), BundleURL: "https://example.com"}
 }
 
 func OnGetByRepoAndDigestSuccess(repo, digest string, limit int) ([]*Attestation, error) {
diff --git a/pkg/cmd/attestation/api/mock_apiClient_test.go b/pkg/cmd/attestation/api/mock_githubApiClient_test.go
similarity index 100%
rename from pkg/cmd/attestation/api/mock_apiClient_test.go
rename to pkg/cmd/attestation/api/mock_githubApiClient_test.go
diff --git a/pkg/cmd/attestation/api/mock_httpClient_test.go b/pkg/cmd/attestation/api/mock_httpClient_test.go
new file mode 100644
index 000000000..70eceeea5
--- /dev/null
+++ b/pkg/cmd/attestation/api/mock_httpClient_test.go
@@ -0,0 +1,25 @@
+package api
+
+import (
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/cli/cli/v2/pkg/cmd/attestation/test/data"
+)
+
+type mockHttpClient struct {
+	OnGet func(url string) (*http.Response, error)
+}
+
+func (m mockHttpClient) Get(url string) (*http.Response, error) {
+	return m.OnGet(url)
+}
+
+func (m *mockDataGenerator) OnGetSuccess(url string) (*http.Response, error) {
+	bundle := data.SigstoreBundle(nil)
+	return &http.Response{
+		StatusCode: 200,
+		Body:       io.NopCloser(strings.NewReader(bundle.String())),
+	}, nil
+}

From ab4912ff48f8aea8ec48e96079e46ea4af8c546f Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 16 Dec 2024 12:40:13 -0700
Subject: [PATCH 09/68] fix failing tests

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go               | 6 +++++-
 pkg/cmd/attestation/api/client_test.go          | 6 ++++++
 pkg/cmd/attestation/api/mock_httpClient_test.go | 7 ++++---
 pkg/cmd/attestation/verification/attestation.go | 2 +-
 4 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index fc5e06f7b..2519aa9e4 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -88,7 +88,11 @@ func (c *LiveClient) GetByOwnerAndDigest(owner, digest string, limit int) ([]*At
 	url := c.buildOwnerAndDigestURL(owner, digest)
 	attestations, err := c.getAttestations(url, owner, digest, limit)
 	if err != nil {
-		return nil, fmt.Errorf("failed to fetch attestation by repo and digest: %w", err)
+		return nil, err
+	}
+
+	if len(attestations) == 0 {
+		return nil, newErrNoAttestations(owner, digest)
 	}
 
 	bundles, err := c.fetchBundlesByURL(attestations)
diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index 9e47870cf..540ae1366 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -144,6 +144,9 @@ func TestGetByDigest_NoAttestationsFound(t *testing.T) {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTWithNextNoAttestations,
 		},
+		httpClient: mockHttpClient{
+			OnGet: fetcher.OnGetSuccess,
+		},
 		logger: io.NewTestHandler(),
 	}
 
@@ -222,6 +225,9 @@ func TestGetAttestationsRetries(t *testing.T) {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.FlakyOnRESTSuccessWithNextPageHandler(),
 		},
+		httpClient: mockHttpClient{
+			OnGet: fetcher.OnGetSuccess,
+		},
 		logger: io.NewTestHandler(),
 	}
 
diff --git a/pkg/cmd/attestation/api/mock_httpClient_test.go b/pkg/cmd/attestation/api/mock_httpClient_test.go
index 70eceeea5..89584874f 100644
--- a/pkg/cmd/attestation/api/mock_httpClient_test.go
+++ b/pkg/cmd/attestation/api/mock_httpClient_test.go
@@ -1,11 +1,12 @@
 package api
 
 import (
+	"bytes"
 	"io"
 	"net/http"
-	"strings"
 
 	"github.com/cli/cli/v2/pkg/cmd/attestation/test/data"
+	"github.com/golang/snappy"
 )
 
 type mockHttpClient struct {
@@ -17,9 +18,9 @@ func (m mockHttpClient) Get(url string) (*http.Response, error) {
 }
 
 func (m *mockDataGenerator) OnGetSuccess(url string) (*http.Response, error) {
-	bundle := data.SigstoreBundle(nil)
+	compressed := snappy.Encode(nil, data.SigstoreBundleRaw)
 	return &http.Response{
 		StatusCode: 200,
-		Body:       io.NopCloser(strings.NewReader(bundle.String())),
+		Body:       io.NopCloser(bytes.NewReader(compressed)),
 	}, nil
 }
diff --git a/pkg/cmd/attestation/verification/attestation.go b/pkg/cmd/attestation/verification/attestation.go
index 41da71010..8022a4943 100644
--- a/pkg/cmd/attestation/verification/attestation.go
+++ b/pkg/cmd/attestation/verification/attestation.go
@@ -104,7 +104,7 @@ func GetRemoteAttestations(client api.Client, params FetchRemoteAttestationsPara
 	if params.Repo != "" {
 		bundles, err := client.GetByRepoAndDigest(params.Repo, params.Digest, params.Limit)
 		if err != nil {
-			return nil, fmt.Errorf("failed to fetch attestation bundles from %s: %w", params.Repo, err)
+			return nil, fmt.Errorf("failed to fetch attestations from %s: %w", params.Repo, err)
 		}
 
 		return bundles, nil

From 049332d8448cc8949f5bb2b3f9b8181efe51af4d Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Mon, 30 Dec 2024 15:41:18 -0600
Subject: [PATCH 10/68] gh gist delete: prompt for gist id

---
 pkg/cmd/gist/delete/delete.go | 38 ++++++++++++++++++++++++++---------
 1 file changed, 28 insertions(+), 10 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete.go b/pkg/cmd/gist/delete/delete.go
index 0b5224c8a..f9455ac17 100644
--- a/pkg/cmd/gist/delete/delete.go
+++ b/pkg/cmd/gist/delete/delete.go
@@ -8,6 +8,7 @@ import (
 
 	"github.com/cli/cli/v2/api"
 	"github.com/cli/cli/v2/internal/gh"
+	"github.com/cli/cli/v2/internal/prompter"
 	"github.com/cli/cli/v2/pkg/cmd/gist/shared"
 	"github.com/cli/cli/v2/pkg/cmdutil"
 	"github.com/cli/cli/v2/pkg/iostreams"
@@ -18,6 +19,7 @@ type DeleteOptions struct {
 	IO         *iostreams.IOStreams
 	Config     func() (gh.Config, error)
 	HttpClient func() (*http.Client, error)
+	Prompter   prompter.Prompter
 
 	Selector string
 }
@@ -27,14 +29,17 @@ func NewCmdDelete(f *cmdutil.Factory, runF func(*DeleteOptions) error) *cobra.Co
 		IO:         f.IOStreams,
 		Config:     f.Config,
 		HttpClient: f.HttpClient,
+		Prompter:   f.Prompter,
 	}
 
 	cmd := &cobra.Command{
 		Use:   "delete {<id> | <url>}",
 		Short: "Delete a gist",
-		Args:  cmdutil.ExactArgs(1, "cannot delete: gist argument required"),
+		Args:  cobra.MaximumNArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
-			opts.Selector = args[0]
+			if len(args) == 1 {
+				opts.Selector = args[0]
+			}
 			if runF != nil {
 				return runF(&opts)
 			}
@@ -46,14 +51,6 @@ func NewCmdDelete(f *cmdutil.Factory, runF func(*DeleteOptions) error) *cobra.Co
 
 func deleteRun(opts *DeleteOptions) error {
 	gistID := opts.Selector
-
-	if strings.Contains(gistID, "/") {
-		id, err := shared.GistIDFromURL(gistID)
-		if err != nil {
-			return err
-		}
-		gistID = id
-	}
 	client, err := opts.HttpClient()
 	if err != nil {
 		return err
@@ -66,6 +63,27 @@ func deleteRun(opts *DeleteOptions) error {
 
 	host, _ := cfg.Authentication().DefaultHost()
 
+	cs := opts.IO.ColorScheme()
+	if gistID == "" {
+		gistID, err = shared.PromptGists(opts.Prompter, client, host, cs)
+		if err != nil {
+			return err
+		}
+
+		if gistID == "" {
+			fmt.Fprintln(opts.IO.Out, "No gists found.")
+			return nil
+		}
+	}
+
+	if strings.Contains(gistID, "/") {
+		id, err := shared.GistIDFromURL(gistID)
+		if err != nil {
+			return err
+		}
+		gistID = id
+	}
+
 	apiClient := api.NewClientFromHTTP(client)
 	if err := deleteGist(apiClient, host, gistID); err != nil {
 		if errors.Is(err, shared.NotFoundErr) {

From 8f19d3b102b54fad2b7c9fe862b6eaea81203dc6 Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Mon, 30 Dec 2024 17:24:10 -0600
Subject: [PATCH 11/68] add gist delete tests for blank gist id

---
 pkg/cmd/gist/delete/delete_test.go | 63 +++++++++++++++++++++++++++---
 1 file changed, 57 insertions(+), 6 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index 00d9ab961..bc607d578 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -2,11 +2,14 @@ package delete
 
 import (
 	"bytes"
+	"fmt"
 	"net/http"
 	"testing"
+	"time"
 
 	"github.com/cli/cli/v2/internal/config"
 	"github.com/cli/cli/v2/internal/gh"
+	"github.com/cli/cli/v2/internal/prompter"
 	"github.com/cli/cli/v2/pkg/cmdutil"
 	"github.com/cli/cli/v2/pkg/httpmock"
 	"github.com/cli/cli/v2/pkg/iostreams"
@@ -27,6 +30,13 @@ func TestNewCmdDelete(t *testing.T) {
 				Selector: "123",
 			},
 		},
+		{
+			name: "no ID supplied",
+			cli:  "",
+			wants: DeleteOptions{
+				Selector: "",
+			},
+		},
 	}
 
 	for _, tt := range tests {
@@ -56,12 +66,13 @@ func TestNewCmdDelete(t *testing.T) {
 
 func Test_deleteRun(t *testing.T) {
 	tests := []struct {
-		name       string
-		opts       DeleteOptions
-		httpStubs  func(*httpmock.Registry)
-		wantErr    bool
-		wantStdout string
-		wantStderr string
+		name         string
+		opts         DeleteOptions
+		httpStubs    func(*httpmock.Registry)
+		wantErr      bool
+		wantStdout   string
+		wantStderr   string
+		mockGistList bool
 	}{
 		{
 			name: "successfully delete",
@@ -76,6 +87,20 @@ func Test_deleteRun(t *testing.T) {
 			wantStdout: "",
 			wantStderr: "",
 		},
+		{
+			name: "successfully delete with prompt",
+			opts: DeleteOptions{
+				Selector: "",
+			},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(httpmock.REST("DELETE", "gists/1234"),
+					httpmock.StatusStringResponse(200, "{}"))
+			},
+			mockGistList: true,
+			wantErr:      false,
+			wantStdout:   "",
+			wantStderr:   "",
+		},
 		{
 			name: "not found",
 			opts: DeleteOptions{
@@ -97,6 +122,32 @@ func Test_deleteRun(t *testing.T) {
 			tt.httpStubs(reg)
 		}
 
+		if tt.mockGistList {
+			sixHours, _ := time.ParseDuration("6h")
+			sixHoursAgo := time.Now().Add(-sixHours)
+			reg.Register(
+				httpmock.GraphQL(`query GistList\b`),
+				httpmock.StringResponse(fmt.Sprintf(
+					`{ "data": { "viewer": { "gists": { "nodes": [
+							{
+								"name": "1234",
+								"files": [{ "name": "cool.txt" }],
+								"description": "",
+								"updatedAt": "%s",
+								"isPublic": true
+							}
+						] } } } }`,
+					sixHoursAgo.Format(time.RFC3339),
+				)),
+			)
+
+			pm := prompter.NewMockPrompter(t)
+			pm.RegisterSelect("Select a gist", []string{"cool.txt  about 6 hours ago"}, func(_, _ string, opts []string) (int, error) {
+				return 0, nil
+			})
+			tt.opts.Prompter = pm
+		}
+
 		tt.opts.HttpClient = func() (*http.Client, error) {
 			return &http.Client{Transport: reg}, nil
 		}

From 8390b4154bed77441c1663246ab34844fa4c70fc Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Mon, 30 Dec 2024 18:18:50 -0600
Subject: [PATCH 12/68] rearrange struct vals for consistency

---
 pkg/cmd/gist/delete/delete_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index bc607d578..3e346da51 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -69,10 +69,10 @@ func Test_deleteRun(t *testing.T) {
 		name         string
 		opts         DeleteOptions
 		httpStubs    func(*httpmock.Registry)
+		mockGistList bool
 		wantErr      bool
 		wantStdout   string
 		wantStderr   string
-		mockGistList bool
 	}{
 		{
 			name: "successfully delete",

From 61ffbe157de8f85d8f8068ea0e765d567165b3a8 Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Tue, 31 Dec 2024 01:43:39 -0600
Subject: [PATCH 13/68] undo extra move

---
 pkg/cmd/gist/delete/delete.go | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete.go b/pkg/cmd/gist/delete/delete.go
index f9455ac17..a6be7053a 100644
--- a/pkg/cmd/gist/delete/delete.go
+++ b/pkg/cmd/gist/delete/delete.go
@@ -51,6 +51,14 @@ func NewCmdDelete(f *cmdutil.Factory, runF func(*DeleteOptions) error) *cobra.Co
 
 func deleteRun(opts *DeleteOptions) error {
 	gistID := opts.Selector
+
+	if strings.Contains(gistID, "/") {
+		id, err := shared.GistIDFromURL(gistID)
+		if err != nil {
+			return err
+		}
+		gistID = id
+	}
 	client, err := opts.HttpClient()
 	if err != nil {
 		return err
@@ -76,14 +84,6 @@ func deleteRun(opts *DeleteOptions) error {
 		}
 	}
 
-	if strings.Contains(gistID, "/") {
-		id, err := shared.GistIDFromURL(gistID)
-		if err != nil {
-			return err
-		}
-		gistID = id
-	}
-
 	apiClient := api.NewClientFromHTTP(client)
 	if err := deleteGist(apiClient, host, gistID); err != nil {
 		if errors.Is(err, shared.NotFoundErr) {

From f87d9f98f1ec6570b2f787cd813e310bb3bda0f0 Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Fri, 3 Jan 2025 12:51:09 -0600
Subject: [PATCH 14/68] gist delete prompt for confirmation

---
 pkg/cmd/gist/delete/delete.go      | 41 ++++++++++++++--
 pkg/cmd/gist/delete/delete_test.go | 79 +++++++++++++++++++++++-------
 2 files changed, 97 insertions(+), 23 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete.go b/pkg/cmd/gist/delete/delete.go
index a6be7053a..85021979b 100644
--- a/pkg/cmd/gist/delete/delete.go
+++ b/pkg/cmd/gist/delete/delete.go
@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"strings"
 
+	"github.com/MakeNowJust/heredoc"
 	"github.com/cli/cli/v2/api"
 	"github.com/cli/cli/v2/internal/gh"
 	"github.com/cli/cli/v2/internal/prompter"
@@ -21,7 +22,8 @@ type DeleteOptions struct {
 	HttpClient func() (*http.Client, error)
 	Prompter   prompter.Prompter
 
-	Selector string
+	Selector  string
+	Confirmed bool
 }
 
 func NewCmdDelete(f *cmdutil.Factory, runF func(*DeleteOptions) error) *cobra.Command {
@@ -33,9 +35,23 @@ func NewCmdDelete(f *cmdutil.Factory, runF func(*DeleteOptions) error) *cobra.Co
 	}
 
 	cmd := &cobra.Command{
-		Use:   "delete {<id> | <url>}",
+		Use:   "delete [<id> | <url>]",
 		Short: "Delete a gist",
-		Args:  cobra.MaximumNArgs(1),
+		Long: heredoc.Docf(`
+		Delete a GitHub gist.
+
+		To delete a gist interactively, use %[1]sgh gist delete%[1]s with no arguments.
+
+		To delete a gist non-interactively, supply the gist id or url.
+	`, "`"),
+		Example: heredoc.Doc(`
+		# delete a gist interactively
+		gh gist delete
+
+		# delete a gist non-interactively
+		gh gist delete 1234
+	`),
+		Args: cobra.MaximumNArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
 			if len(args) == 1 {
 				opts.Selector = args[0]
@@ -46,6 +62,7 @@ func NewCmdDelete(f *cmdutil.Factory, runF func(*DeleteOptions) error) *cobra.Co
 			return deleteRun(&opts)
 		},
 	}
+	cmd.Flags().BoolVar(&opts.Confirmed, "yes", false, "confirm deletion without prompting")
 	return cmd
 }
 
@@ -83,9 +100,16 @@ func deleteRun(opts *DeleteOptions) error {
 			return nil
 		}
 	}
+	if !opts.Confirmed {
+		err = opts.Prompter.ConfirmDeletion("delete")
+
+		if err != nil {
+			return cmdutil.CancelError
+		}
+	}
 
 	apiClient := api.NewClientFromHTTP(client)
-	if err := deleteGist(apiClient, host, gistID); err != nil {
+	if err := deleteGist(apiClient, host, gistID, opts); err != nil {
 		if errors.Is(err, shared.NotFoundErr) {
 			return fmt.Errorf("unable to delete gist %s: either the gist is not found or it is not owned by you", gistID)
 		}
@@ -95,7 +119,7 @@ func deleteRun(opts *DeleteOptions) error {
 	return nil
 }
 
-func deleteGist(apiClient *api.Client, hostname string, gistID string) error {
+func deleteGist(apiClient *api.Client, hostname string, gistID string, opts *DeleteOptions) error {
 	path := "gists/" + gistID
 	err := apiClient.REST(hostname, "DELETE", path, nil, nil)
 	if err != nil {
@@ -105,5 +129,12 @@ func deleteGist(apiClient *api.Client, hostname string, gistID string) error {
 		}
 		return err
 	}
+	if opts.IO.IsStdoutTTY() {
+		cs := opts.IO.ColorScheme()
+		fmt.Fprintf(opts.IO.Out,
+			"%s Deleted gist %s\n",
+			cs.SuccessIcon(),
+			gistID)
+	}
 	return nil
 }
diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index 3e346da51..c3db5f940 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -37,6 +37,13 @@ func TestNewCmdDelete(t *testing.T) {
 				Selector: "",
 			},
 		},
+		{
+			name: "yes flag",
+			cli:  "123 --yes",
+			wants: DeleteOptions{
+				Selector: "123",
+			},
+		},
 	}
 
 	for _, tt := range tests {
@@ -67,7 +74,7 @@ func TestNewCmdDelete(t *testing.T) {
 func Test_deleteRun(t *testing.T) {
 	tests := []struct {
 		name         string
-		opts         DeleteOptions
+		opts         *DeleteOptions
 		httpStubs    func(*httpmock.Registry)
 		mockGistList bool
 		wantErr      bool
@@ -76,21 +83,23 @@ func Test_deleteRun(t *testing.T) {
 	}{
 		{
 			name: "successfully delete",
-			opts: DeleteOptions{
-				Selector: "1234",
+			opts: &DeleteOptions{
+				Selector:  "1234",
+				Confirmed: false,
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			wantErr:    false,
-			wantStdout: "",
+			wantStdout: "✓ Deleted gist 1234\n",
 			wantStderr: "",
 		},
 		{
 			name: "successfully delete with prompt",
-			opts: DeleteOptions{
-				Selector: "",
+			opts: &DeleteOptions{
+				Selector:  "",
+				Confirmed: false,
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
@@ -98,13 +107,43 @@ func Test_deleteRun(t *testing.T) {
 			},
 			mockGistList: true,
 			wantErr:      false,
-			wantStdout:   "",
+			wantStdout:   "✓ Deleted gist 1234\n",
+			wantStderr:   "",
+		},
+		{
+			name: "successfully delete with --yes",
+			opts: &DeleteOptions{
+				Selector:  "1234",
+				Confirmed: true,
+			},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(httpmock.REST("DELETE", "gists/1234"),
+					httpmock.StatusStringResponse(200, "{}"))
+			},
+			wantErr:    false,
+			wantStdout: "✓ Deleted gist 1234\n",
+			wantStderr: "",
+		},
+		{
+			name: "successfully delete with prompt and --yes",
+			opts: &DeleteOptions{
+				Selector:  "",
+				Confirmed: true,
+			},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(httpmock.REST("DELETE", "gists/1234"),
+					httpmock.StatusStringResponse(200, "{}"))
+			},
+			mockGistList: true,
+			wantErr:      false,
+			wantStdout:   "✓ Deleted gist 1234\n",
 			wantStderr:   "",
 		},
 		{
 			name: "not found",
-			opts: DeleteOptions{
-				Selector: "1234",
+			opts: &DeleteOptions{
+				Selector:  "1234",
+				Confirmed: false,
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
@@ -112,14 +151,18 @@ func Test_deleteRun(t *testing.T) {
 			},
 			wantErr:    true,
 			wantStdout: "",
-			wantStderr: "",
+			wantStderr: "unable to delete gist 1234: either the gist is not found or it is not owned by you",
 		},
 	}
 
 	for _, tt := range tests {
 		reg := &httpmock.Registry{}
-		if tt.httpStubs != nil {
-			tt.httpStubs(reg)
+		tt.httpStubs(reg)
+		pm := prompter.NewMockPrompter(t)
+		if !tt.opts.Confirmed {
+			pm.RegisterConfirmDeletion("Type delete to confirm deletion:", func(_ string) error {
+				return nil
+			})
 		}
 
 		if tt.mockGistList {
@@ -141,12 +184,11 @@ func Test_deleteRun(t *testing.T) {
 				)),
 			)
 
-			pm := prompter.NewMockPrompter(t)
 			pm.RegisterSelect("Select a gist", []string{"cool.txt  about 6 hours ago"}, func(_, _ string, opts []string) (int, error) {
 				return 0, nil
 			})
-			tt.opts.Prompter = pm
 		}
+		tt.opts.Prompter = pm
 
 		tt.opts.HttpClient = func() (*http.Client, error) {
 			return &http.Client{Transport: reg}, nil
@@ -154,13 +196,13 @@ func Test_deleteRun(t *testing.T) {
 		tt.opts.Config = func() (gh.Config, error) {
 			return config.NewBlankConfig(), nil
 		}
-		ios, _, _, _ := iostreams.Test()
-		ios.SetStdoutTTY(false)
+		ios, _, stdout, stderr := iostreams.Test()
+		ios.SetStdoutTTY(true)
 		ios.SetStdinTTY(false)
 		tt.opts.IO = ios
 
 		t.Run(tt.name, func(t *testing.T) {
-			err := deleteRun(&tt.opts)
+			err := deleteRun(tt.opts)
 			reg.Verify(t)
 			if tt.wantErr {
 				assert.Error(t, err)
@@ -170,7 +212,8 @@ func Test_deleteRun(t *testing.T) {
 				return
 			}
 			assert.NoError(t, err)
-
+			assert.Equal(t, tt.wantStdout, stdout.String())
+			assert.Equal(t, tt.wantStderr, stderr.String())
 		})
 	}
 }

From 75ace410a3304bcdea9193acc527d8b78d8840a9 Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Fri, 3 Jan 2025 13:09:32 -0600
Subject: [PATCH 15/68] cleanup

---
 pkg/cmd/gist/delete/delete.go      | 6 +-----
 pkg/cmd/gist/delete/delete_test.go | 9 +++------
 2 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete.go b/pkg/cmd/gist/delete/delete.go
index 85021979b..23e929d5b 100644
--- a/pkg/cmd/gist/delete/delete.go
+++ b/pkg/cmd/gist/delete/delete.go
@@ -94,12 +94,8 @@ func deleteRun(opts *DeleteOptions) error {
 		if err != nil {
 			return err
 		}
-
-		if gistID == "" {
-			fmt.Fprintln(opts.IO.Out, "No gists found.")
-			return nil
-		}
 	}
+
 	if !opts.Confirmed {
 		err = opts.Prompter.ConfirmDeletion("delete")
 
diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index c3db5f940..fec3b4ffd 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -84,8 +84,7 @@ func Test_deleteRun(t *testing.T) {
 		{
 			name: "successfully delete",
 			opts: &DeleteOptions{
-				Selector:  "1234",
-				Confirmed: false,
+				Selector: "1234",
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
@@ -98,8 +97,7 @@ func Test_deleteRun(t *testing.T) {
 		{
 			name: "successfully delete with prompt",
 			opts: &DeleteOptions{
-				Selector:  "",
-				Confirmed: false,
+				Selector: "",
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
@@ -142,8 +140,7 @@ func Test_deleteRun(t *testing.T) {
 		{
 			name: "not found",
 			opts: &DeleteOptions{
-				Selector:  "1234",
-				Confirmed: false,
+				Selector: "1234",
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),

From 9051da39fc559ee73ffb1d870863c9100fd5c9f6 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 6 Jan 2025 10:19:47 -0700
Subject: [PATCH 16/68] provide additional logging and fallback

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index 2519aa9e4..51b67d33d 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -26,11 +26,13 @@ const (
 // Allow injecting backoff interval in tests.
 var getAttestationRetryInterval = time.Millisecond * 200
 
+// githubApiClient makes REST calls to the GitHub API
 type githubApiClient interface {
 	REST(hostname, method, p string, body io.Reader, data interface{}) error
 	RESTWithNext(hostname, method, p string, body io.Reader, data interface{}) (string, error)
 }
 
+// httpClient makes HTTP calls to all non-GitHub API endpoints
 type httpClient interface {
 	Get(url string) (*http.Response, error)
 }
@@ -180,7 +182,8 @@ func (c *LiveClient) fetchBundlesByURL(attestations []*Attestation) ([]*Attestat
 
 func (c *LiveClient) fetchBundleByURL(a *Attestation) (*bundle.Bundle, error) {
 	if a.BundleURL == "" {
-		return nil, fmt.Errorf("bundle URL is empty")
+		c.logger.VerbosePrintf("Bundle URL is empty. Falling back to bundle field\n\n")
+		return a.Bundle, nil
 	}
 
 	c.logger.VerbosePrintf("Fetching attestation bundle\n\n")

From 311f2b2e236dc0f5a60026e1a5e920e8b063799e Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 6 Jan 2025 10:39:40 -0700
Subject: [PATCH 17/68] return fetch attestations err directly

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index 51b67d33d..d681be446 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -69,7 +69,7 @@ func (c *LiveClient) GetByRepoAndDigest(repo, digest string, limit int) ([]*Atte
 	url := c.buildRepoAndDigestURL(repo, digest)
 	attestations, err := c.getAttestations(url, repo, digest, limit)
 	if err != nil {
-		return nil, fmt.Errorf("failed to fetch attestation by repo and digest: %w", err)
+		return nil, err
 	}
 
 	bundles, err := c.fetchBundlesByURL(attestations)

From 070b67e5a42c68b7db066e6dd6118113eb16e7d3 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 6 Jan 2025 10:44:55 -0700
Subject: [PATCH 18/68] fetch bundles in parallel

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index d681be446..1a29e3044 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -14,6 +14,7 @@ import (
 	"github.com/golang/snappy"
 	v1 "github.com/sigstore/protobuf-specs/gen/pb-go/bundle/v1"
 	"github.com/sigstore/sigstore-go/pkg/bundle"
+	"golang.org/x/sync/errgroup"
 	"google.golang.org/protobuf/encoding/protojson"
 )
 
@@ -168,15 +169,24 @@ func (c *LiveClient) getAttestations(url, name, digest string, limit int) ([]*At
 
 func (c *LiveClient) fetchBundlesByURL(attestations []*Attestation) ([]*Attestation, error) {
 	fetched := make([]*Attestation, len(attestations))
+	g := errgroup.Group{}
 	for i, a := range attestations {
-		b, err := c.fetchBundleByURL(a)
-		if err != nil {
-			return nil, fmt.Errorf("failed to fetch bundle with URL: %w", err)
-		}
-		fetched[i] = &Attestation{
-			Bundle: b,
-		}
+		g.Go(func() error {
+			b, err := c.fetchBundleByURL(a)
+			if err != nil {
+				return fmt.Errorf("failed to fetch bundle with URL: %w", err)
+			}
+			fetched[i] = &Attestation{
+				Bundle: b,
+			}
+			return nil
+		})
 	}
+
+	if err := g.Wait(); err != nil {
+		return nil, err
+	}
+
 	return fetched, nil
 }
 

From e03a36ea3c44e59bf0a1cf5e5a4fe082da13c734 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 6 Jan 2025 12:12:26 -0700
Subject: [PATCH 19/68] add tests for bundle url fetch and fallback

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go             |  2 +-
 pkg/cmd/attestation/api/client_test.go        | 53 ++++++++++++++++---
 .../attestation/api/mock_httpClient_test.go   |  8 +--
 3 files changed, 51 insertions(+), 12 deletions(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index 1a29e3044..d0ef3f21b 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -196,7 +196,7 @@ func (c *LiveClient) fetchBundleByURL(a *Attestation) (*bundle.Bundle, error) {
 		return a.Bundle, nil
 	}
 
-	c.logger.VerbosePrintf("Fetching attestation bundle\n\n")
+	c.logger.VerbosePrintf("Fetching attestation bundle with bundle URL\n\n")
 
 	resp, err := c.httpClient.Get(a.BundleURL)
 	if err != nil {
diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index 540ae1366..62b1c40cf 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -4,6 +4,7 @@ import (
 	"testing"
 
 	"github.com/cli/cli/v2/pkg/cmd/attestation/io"
+	"github.com/cli/cli/v2/pkg/cmd/attestation/test/data"
 
 	"github.com/stretchr/testify/require"
 )
@@ -25,8 +26,8 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 			githubAPI: mockAPIClient{
 				OnRESTWithNext: fetcher.OnRESTSuccessWithNextPage,
 			},
-			httpClient: mockHttpClient{
-				OnGet: fetcher.OnGetSuccess,
+			httpClient: &mockHttpClient{
+				OnGet: OnGetSuccess,
 			},
 			logger: l,
 		}
@@ -36,8 +37,8 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTSuccess,
 		},
-		httpClient: mockHttpClient{
-			OnGet: fetcher.OnGetSuccess,
+		httpClient: &mockHttpClient{
+			OnGet: OnGetSuccess,
 		},
 		logger: l,
 	}
@@ -144,8 +145,8 @@ func TestGetByDigest_NoAttestationsFound(t *testing.T) {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTWithNextNoAttestations,
 		},
-		httpClient: mockHttpClient{
-			OnGet: fetcher.OnGetSuccess,
+		httpClient: &mockHttpClient{
+			OnGet: OnGetSuccess,
 		},
 		logger: io.NewTestHandler(),
 	}
@@ -182,6 +183,42 @@ func TestGetByDigest_Error(t *testing.T) {
 	require.Nil(t, attestations)
 }
 
+func TestFetchBundleByURL(t *testing.T) {
+	t.Run("fetch by bundle URL successfully", func(t *testing.T) {
+		httpClient := mockHttpClient{
+			OnGet: OnGetSuccess,
+		}
+		c := &LiveClient{
+			httpClient: &httpClient,
+			logger:     io.NewTestHandler(),
+		}
+
+		attestation := makeTestAttestation()
+		bundle, err := c.fetchBundleByURL(&attestation)
+		require.NoError(t, err)
+		require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
+		require.True(t, httpClient.called)
+	})
+
+	t.Run("fallback to bundle field when BundleURL field is empty", func(t *testing.T) {
+		httpClient := mockHttpClient{
+			OnGet: OnGetSuccess,
+		}
+		c := &LiveClient{
+			httpClient: &mockHttpClient{
+				OnGet: OnGetSuccess,
+			},
+			logger: io.NewTestHandler(),
+		}
+
+		attestation := Attestation{Bundle: data.SigstoreBundle(t)}
+		bundle, err := c.fetchBundleByURL(&attestation)
+		require.NoError(t, err)
+		require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
+		require.False(t, httpClient.called)
+	})
+}
+
 func TestGetTrustDomain(t *testing.T) {
 	fetcher := mockMetaGenerator{
 		TrustDomain: "foo",
@@ -225,8 +262,8 @@ func TestGetAttestationsRetries(t *testing.T) {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.FlakyOnRESTSuccessWithNextPageHandler(),
 		},
-		httpClient: mockHttpClient{
-			OnGet: fetcher.OnGetSuccess,
+		httpClient: &mockHttpClient{
+			OnGet: OnGetSuccess,
 		},
 		logger: io.NewTestHandler(),
 	}
diff --git a/pkg/cmd/attestation/api/mock_httpClient_test.go b/pkg/cmd/attestation/api/mock_httpClient_test.go
index 89584874f..365619ac1 100644
--- a/pkg/cmd/attestation/api/mock_httpClient_test.go
+++ b/pkg/cmd/attestation/api/mock_httpClient_test.go
@@ -10,14 +10,16 @@ import (
 )
 
 type mockHttpClient struct {
-	OnGet func(url string) (*http.Response, error)
+	called bool
+	OnGet  func(url string) (*http.Response, error)
 }
 
-func (m mockHttpClient) Get(url string) (*http.Response, error) {
+func (m *mockHttpClient) Get(url string) (*http.Response, error) {
+	m.called = true
 	return m.OnGet(url)
 }
 
-func (m *mockDataGenerator) OnGetSuccess(url string) (*http.Response, error) {
+func OnGetSuccess(url string) (*http.Response, error) {
 	compressed := snappy.Encode(nil, data.SigstoreBundleRaw)
 	return &http.Response{
 		StatusCode: 200,

From 0202ca8df5b645dfc92330a08bac63a111d8ace9 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 6 Jan 2025 12:58:09 -0700
Subject: [PATCH 20/68] add test case for bundle url fetch failure

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client_test.go        | 71 +++++++++++--------
 .../attestation/api/mock_httpClient_test.go   |  7 ++
 2 files changed, 48 insertions(+), 30 deletions(-)

diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index 62b1c40cf..4fb0f539a 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -184,39 +184,50 @@ func TestGetByDigest_Error(t *testing.T) {
 }
 
 func TestFetchBundleByURL(t *testing.T) {
-	t.Run("fetch by bundle URL successfully", func(t *testing.T) {
-		httpClient := mockHttpClient{
-			OnGet: OnGetSuccess,
-		}
-		c := &LiveClient{
-			httpClient: &httpClient,
-			logger:     io.NewTestHandler(),
-		}
+	httpClient := mockHttpClient{
+		OnGet: OnGetSuccess,
+	}
+	c := &LiveClient{
+		httpClient: &httpClient,
+		logger:     io.NewTestHandler(),
+	}
 
-		attestation := makeTestAttestation()
-		bundle, err := c.fetchBundleByURL(&attestation)
-		require.NoError(t, err)
-		require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-		require.True(t, httpClient.called)
-	})
+	attestation := makeTestAttestation()
+	bundle, err := c.fetchBundleByURL(&attestation)
+	require.NoError(t, err)
+	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
+	require.True(t, httpClient.called)
+}
+func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
+	httpClient := mockHttpClient{
+		OnGet: OnGetFail,
+	}
+	c := &LiveClient{
+		httpClient: &httpClient,
+		logger:     io.NewTestHandler(),
+	}
 
-	t.Run("fallback to bundle field when BundleURL field is empty", func(t *testing.T) {
-		httpClient := mockHttpClient{
-			OnGet: OnGetSuccess,
-		}
-		c := &LiveClient{
-			httpClient: &mockHttpClient{
-				OnGet: OnGetSuccess,
-			},
-			logger: io.NewTestHandler(),
-		}
+	attestation := makeTestAttestation()
+	bundle, err := c.fetchBundleByURL(&attestation)
+	require.Error(t, err)
+	require.Nil(t, bundle)
+	require.True(t, httpClient.called)
+}
 
-		attestation := Attestation{Bundle: data.SigstoreBundle(t)}
-		bundle, err := c.fetchBundleByURL(&attestation)
-		require.NoError(t, err)
-		require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-		require.False(t, httpClient.called)
-	})
+func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
+	httpClient := mockHttpClient{
+		OnGet: OnGetSuccess,
+	}
+	c := &LiveClient{
+		httpClient: &httpClient,
+		logger:     io.NewTestHandler(),
+	}
+
+	attestation := Attestation{Bundle: data.SigstoreBundle(t)}
+	bundle, err := c.fetchBundleByURL(&attestation)
+	require.NoError(t, err)
+	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
+	require.False(t, httpClient.called)
 }
 
 func TestGetTrustDomain(t *testing.T) {
diff --git a/pkg/cmd/attestation/api/mock_httpClient_test.go b/pkg/cmd/attestation/api/mock_httpClient_test.go
index 365619ac1..b89c101fe 100644
--- a/pkg/cmd/attestation/api/mock_httpClient_test.go
+++ b/pkg/cmd/attestation/api/mock_httpClient_test.go
@@ -2,6 +2,7 @@ package api
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"net/http"
 
@@ -26,3 +27,9 @@ func OnGetSuccess(url string) (*http.Response, error) {
 		Body:       io.NopCloser(bytes.NewReader(compressed)),
 	}, nil
 }
+
+func OnGetFail(url string) (*http.Response, error) {
+	return &http.Response{
+		StatusCode: 500,
+	}, fmt.Errorf("failed to fetch with %s", url)
+}

From 69865117ab92abc2a1cb075b38f24302185de03e Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Mon, 6 Jan 2025 13:14:02 -0700
Subject: [PATCH 21/68] add mutex for test field

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/mock_httpClient_test.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pkg/cmd/attestation/api/mock_httpClient_test.go b/pkg/cmd/attestation/api/mock_httpClient_test.go
index b89c101fe..2914d7887 100644
--- a/pkg/cmd/attestation/api/mock_httpClient_test.go
+++ b/pkg/cmd/attestation/api/mock_httpClient_test.go
@@ -5,18 +5,22 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"sync"
 
 	"github.com/cli/cli/v2/pkg/cmd/attestation/test/data"
 	"github.com/golang/snappy"
 )
 
 type mockHttpClient struct {
+	mutex  sync.RWMutex
 	called bool
 	OnGet  func(url string) (*http.Response, error)
 }
 
 func (m *mockHttpClient) Get(url string) (*http.Response, error) {
+	m.mutex.Lock()
 	m.called = true
+	m.mutex.Unlock()
 	return m.OnGet(url)
 }
 

From 9ecd90c26ceb564e0dea8f492f9f42da952ab6c8 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 10:24:42 -0700
Subject: [PATCH 22/68] setup testing struct for test cases

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client_test.go        | 89 ++++++++++++-------
 .../attestation/api/mock_httpClient_test.go   | 26 +++---
 2 files changed, 71 insertions(+), 44 deletions(-)

diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index 4fb0f539a..0f91aff7e 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -21,15 +21,15 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 	}
 	l := io.NewTestHandler()
 
+	mockHTTPClient := &mockHttpClient{}
+
 	if hasNextPage {
 		return &LiveClient{
 			githubAPI: mockAPIClient{
 				OnRESTWithNext: fetcher.OnRESTSuccessWithNextPage,
 			},
-			httpClient: &mockHttpClient{
-				OnGet: OnGetSuccess,
-			},
-			logger: l,
+			httpClient: mockHTTPClient,
+			logger:     l,
 		}
 	}
 
@@ -37,10 +37,8 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTSuccess,
 		},
-		httpClient: &mockHttpClient{
-			OnGet: OnGetSuccess,
-		},
-		logger: l,
+		httpClient: mockHTTPClient,
+		logger:     l,
 	}
 }
 
@@ -145,10 +143,8 @@ func TestGetByDigest_NoAttestationsFound(t *testing.T) {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTWithNextNoAttestations,
 		},
-		httpClient: &mockHttpClient{
-			OnGet: OnGetSuccess,
-		},
-		logger: io.NewTestHandler(),
+		httpClient: &mockHttpClient{},
+		logger:     io.NewTestHandler(),
 	}
 
 	attestations, err := c.GetByRepoAndDigest(testRepo, testDigest, DefaultLimit)
@@ -183,12 +179,46 @@ func TestGetByDigest_Error(t *testing.T) {
 	require.Nil(t, attestations)
 }
 
-func TestFetchBundleByURL(t *testing.T) {
-	httpClient := mockHttpClient{
-		OnGet: OnGetSuccess,
+func TestFetchBundlesByURL(t *testing.T) {
+	mockHTTPClient := &mockHttpClient{}
+	client := LiveClient{
+		httpClient: mockHTTPClient,
+		logger:     io.NewTestHandler(),
 	}
+
+	att1 := makeTestAttestation()
+	att2 := makeTestAttestation()
+	attestations := []*Attestation{&att1, &att2}
+	fetched, err := client.fetchBundlesByURL(attestations)
+	require.NoError(t, err)
+	require.Len(t, fetched, 2)
+	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", fetched[0].Bundle.GetMediaType())
+	require.Equal(t, 2, mockHTTPClient.currNumCalls)
+}
+
+func TestFetchBundlesByURL_Fail(t *testing.T) {
+	mockHTTPClient := &mockHttpClient{
+		failAfterNumCalls: 2,
+	}
+
 	c := &LiveClient{
-		httpClient: &httpClient,
+		httpClient: mockHTTPClient,
+		logger:     io.NewTestHandler(),
+	}
+
+	att1 := makeTestAttestation()
+	att2 := makeTestAttestation()
+	attestations := []*Attestation{&att1, &att2}
+	fetched, err := c.fetchBundlesByURL(attestations)
+	require.Error(t, err)
+	require.Nil(t, fetched)
+}
+
+func TestFetchBundleByURL(t *testing.T) {
+	mockHTTPClient := &mockHttpClient{}
+
+	c := &LiveClient{
+		httpClient: mockHTTPClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -196,14 +226,16 @@ func TestFetchBundleByURL(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.NoError(t, err)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-	require.True(t, httpClient.called)
+	require.Equal(t, 1, mockHTTPClient.currNumCalls)
 }
+
 func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
-	httpClient := mockHttpClient{
-		OnGet: OnGetFail,
+	mockHTTPClient := &mockHttpClient{
+		failAfterNumCalls: 1,
 	}
+
 	c := &LiveClient{
-		httpClient: &httpClient,
+		httpClient: mockHTTPClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -211,15 +243,14 @@ func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.Error(t, err)
 	require.Nil(t, bundle)
-	require.True(t, httpClient.called)
+	require.Equal(t, 1, mockHTTPClient.currNumCalls)
 }
 
 func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
-	httpClient := mockHttpClient{
-		OnGet: OnGetSuccess,
-	}
+	mockHTTPClient := &mockHttpClient{}
+
 	c := &LiveClient{
-		httpClient: &httpClient,
+		httpClient: mockHTTPClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -227,7 +258,7 @@ func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.NoError(t, err)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-	require.False(t, httpClient.called)
+	require.Equal(t, 0, mockHTTPClient.currNumCalls)
 }
 
 func TestGetTrustDomain(t *testing.T) {
@@ -273,10 +304,8 @@ func TestGetAttestationsRetries(t *testing.T) {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.FlakyOnRESTSuccessWithNextPageHandler(),
 		},
-		httpClient: &mockHttpClient{
-			OnGet: OnGetSuccess,
-		},
-		logger: io.NewTestHandler(),
+		httpClient: &mockHttpClient{},
+		logger:     io.NewTestHandler(),
 	}
 
 	attestations, err := c.GetByRepoAndDigest(testRepo, testDigest, DefaultLimit)
diff --git a/pkg/cmd/attestation/api/mock_httpClient_test.go b/pkg/cmd/attestation/api/mock_httpClient_test.go
index 2914d7887..3218ed508 100644
--- a/pkg/cmd/attestation/api/mock_httpClient_test.go
+++ b/pkg/cmd/attestation/api/mock_httpClient_test.go
@@ -12,28 +12,26 @@ import (
 )
 
 type mockHttpClient struct {
-	mutex  sync.RWMutex
-	called bool
-	OnGet  func(url string) (*http.Response, error)
+	mutex             sync.RWMutex
+	currNumCalls      int
+	failAfterNumCalls int
 }
 
 func (m *mockHttpClient) Get(url string) (*http.Response, error) {
 	m.mutex.Lock()
-	m.called = true
+	m.currNumCalls++
 	m.mutex.Unlock()
-	return m.OnGet(url)
-}
 
-func OnGetSuccess(url string) (*http.Response, error) {
-	compressed := snappy.Encode(nil, data.SigstoreBundleRaw)
+	if m.failAfterNumCalls > 0 && m.currNumCalls >= m.failAfterNumCalls {
+		return &http.Response{
+			StatusCode: 500,
+		}, fmt.Errorf("failed to fetch with %s", url)
+	}
+
+	var compressed []byte
+	compressed = snappy.Encode(compressed, data.SigstoreBundleRaw)
 	return &http.Response{
 		StatusCode: 200,
 		Body:       io.NopCloser(bytes.NewReader(compressed)),
 	}, nil
 }
-
-func OnGetFail(url string) (*http.Response, error) {
-	return &http.Response{
-		StatusCode: 500,
-	}, fmt.Errorf("failed to fetch with %s", url)
-}

From e34e188ee2c38f345203cbfa1eeb000313e1763e Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 10:43:24 -0700
Subject: [PATCH 23/68] add http client test constructors

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client_test.go        | 37 +++++++++----------
 .../attestation/api/mock_httpClient_test.go   | 23 +++++++++++-
 2 files changed, 39 insertions(+), 21 deletions(-)

diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index 0f91aff7e..23dcb77d9 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -21,14 +21,14 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 	}
 	l := io.NewTestHandler()
 
-	mockHTTPClient := &mockHttpClient{}
+	mockHTTPClient := SuccessHTTPClient()
 
 	if hasNextPage {
 		return &LiveClient{
 			githubAPI: mockAPIClient{
 				OnRESTWithNext: fetcher.OnRESTSuccessWithNextPage,
 			},
-			httpClient: mockHTTPClient,
+			httpClient: &mockHTTPClient,
 			logger:     l,
 		}
 	}
@@ -37,7 +37,7 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTSuccess,
 		},
-		httpClient: mockHTTPClient,
+		httpClient: &mockHTTPClient,
 		logger:     l,
 	}
 }
@@ -139,11 +139,12 @@ func TestGetByDigest_NoAttestationsFound(t *testing.T) {
 		NumAttestations: 5,
 	}
 
+	httpClient := SuccessHTTPClient()
 	c := LiveClient{
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTWithNextNoAttestations,
 		},
-		httpClient: &mockHttpClient{},
+		httpClient: &httpClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -193,16 +194,14 @@ func TestFetchBundlesByURL(t *testing.T) {
 	require.NoError(t, err)
 	require.Len(t, fetched, 2)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", fetched[0].Bundle.GetMediaType())
-	require.Equal(t, 2, mockHTTPClient.currNumCalls)
+	require.Equal(t, 2, mockHTTPClient.TimesCalled())
 }
 
 func TestFetchBundlesByURL_Fail(t *testing.T) {
-	mockHTTPClient := &mockHttpClient{
-		failAfterNumCalls: 2,
-	}
+	mockHTTPClient := HTTPClientFailsAfterNumCalls(1)
 
 	c := &LiveClient{
-		httpClient: mockHTTPClient,
+		httpClient: &mockHTTPClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -215,10 +214,10 @@ func TestFetchBundlesByURL_Fail(t *testing.T) {
 }
 
 func TestFetchBundleByURL(t *testing.T) {
-	mockHTTPClient := &mockHttpClient{}
+	mockHTTPClient := SuccessHTTPClient()
 
 	c := &LiveClient{
-		httpClient: mockHTTPClient,
+		httpClient: &mockHTTPClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -226,16 +225,14 @@ func TestFetchBundleByURL(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.NoError(t, err)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-	require.Equal(t, 1, mockHTTPClient.currNumCalls)
+	require.Equal(t, 1, mockHTTPClient.TimesCalled())
 }
 
 func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
-	mockHTTPClient := &mockHttpClient{
-		failAfterNumCalls: 1,
-	}
+	mockHTTPClient := FailHTTPClient()
 
 	c := &LiveClient{
-		httpClient: mockHTTPClient,
+		httpClient: &mockHTTPClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -243,14 +240,14 @@ func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.Error(t, err)
 	require.Nil(t, bundle)
-	require.Equal(t, 1, mockHTTPClient.currNumCalls)
+	require.Equal(t, 1, mockHTTPClient.TimesCalled())
 }
 
 func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
-	mockHTTPClient := &mockHttpClient{}
+	mockHTTPClient := SuccessHTTPClient()
 
 	c := &LiveClient{
-		httpClient: mockHTTPClient,
+		httpClient: &mockHTTPClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -258,7 +255,7 @@ func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.NoError(t, err)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-	require.Equal(t, 0, mockHTTPClient.currNumCalls)
+	require.Equal(t, 0, mockHTTPClient.TimesCalled())
 }
 
 func TestGetTrustDomain(t *testing.T) {
diff --git a/pkg/cmd/attestation/api/mock_httpClient_test.go b/pkg/cmd/attestation/api/mock_httpClient_test.go
index 3218ed508..345d2c5c2 100644
--- a/pkg/cmd/attestation/api/mock_httpClient_test.go
+++ b/pkg/cmd/attestation/api/mock_httpClient_test.go
@@ -14,6 +14,7 @@ import (
 type mockHttpClient struct {
 	mutex             sync.RWMutex
 	currNumCalls      int
+	alwaysFail        bool
 	failAfterNumCalls int
 }
 
@@ -22,7 +23,7 @@ func (m *mockHttpClient) Get(url string) (*http.Response, error) {
 	m.currNumCalls++
 	m.mutex.Unlock()
 
-	if m.failAfterNumCalls > 0 && m.currNumCalls >= m.failAfterNumCalls {
+	if m.alwaysFail || (m.failAfterNumCalls > 0 && m.currNumCalls > m.failAfterNumCalls) {
 		return &http.Response{
 			StatusCode: 500,
 		}, fmt.Errorf("failed to fetch with %s", url)
@@ -35,3 +36,23 @@ func (m *mockHttpClient) Get(url string) (*http.Response, error) {
 		Body:       io.NopCloser(bytes.NewReader(compressed)),
 	}, nil
 }
+
+func (m *mockHttpClient) TimesCalled() int {
+	return m.currNumCalls
+}
+
+func FailHTTPClient() mockHttpClient {
+	return mockHttpClient{
+		alwaysFail: true,
+	}
+}
+
+func SuccessHTTPClient() mockHttpClient {
+	return mockHttpClient{}
+}
+
+func HTTPClientFailsAfterNumCalls(numCalls int) mockHttpClient {
+	return mockHttpClient{
+		failAfterNumCalls: numCalls,
+	}
+}

From ecf55c6c16f50279e98526b2a953630832e77a31 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 10:54:17 -0700
Subject: [PATCH 24/68] use mock to assert number of http calls

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client_test.go          |  8 ++++----
 pkg/cmd/attestation/api/mock_httpClient_test.go | 11 +++++++----
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index 23dcb77d9..3572689f8 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -194,7 +194,7 @@ func TestFetchBundlesByURL(t *testing.T) {
 	require.NoError(t, err)
 	require.Len(t, fetched, 2)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", fetched[0].Bundle.GetMediaType())
-	require.Equal(t, 2, mockHTTPClient.TimesCalled())
+	mockHTTPClient.AssertNumberOfCalls(t, "OnGet", 2)
 }
 
 func TestFetchBundlesByURL_Fail(t *testing.T) {
@@ -225,7 +225,7 @@ func TestFetchBundleByURL(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.NoError(t, err)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-	require.Equal(t, 1, mockHTTPClient.TimesCalled())
+	mockHTTPClient.AssertNumberOfCalls(t, "OnGet", 1)
 }
 
 func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
@@ -240,7 +240,7 @@ func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.Error(t, err)
 	require.Nil(t, bundle)
-	require.Equal(t, 1, mockHTTPClient.TimesCalled())
+	mockHTTPClient.AssertNumberOfCalls(t, "OnGet", 1)
 }
 
 func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
@@ -255,7 +255,7 @@ func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.NoError(t, err)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-	require.Equal(t, 0, mockHTTPClient.TimesCalled())
+	mockHTTPClient.AssertNotCalled(t, "OnGet")
 }
 
 func TestGetTrustDomain(t *testing.T) {
diff --git a/pkg/cmd/attestation/api/mock_httpClient_test.go b/pkg/cmd/attestation/api/mock_httpClient_test.go
index 345d2c5c2..dd0c139d5 100644
--- a/pkg/cmd/attestation/api/mock_httpClient_test.go
+++ b/pkg/cmd/attestation/api/mock_httpClient_test.go
@@ -9,26 +9,33 @@ import (
 
 	"github.com/cli/cli/v2/pkg/cmd/attestation/test/data"
 	"github.com/golang/snappy"
+	"github.com/stretchr/testify/mock"
 )
 
 type mockHttpClient struct {
+	mock.Mock
 	mutex             sync.RWMutex
 	currNumCalls      int
 	alwaysFail        bool
 	failAfterNumCalls int
+	OnGet             func(url string) (*http.Response, error)
 }
 
 func (m *mockHttpClient) Get(url string) (*http.Response, error) {
+	m.On("OnGet").Return()
 	m.mutex.Lock()
 	m.currNumCalls++
 	m.mutex.Unlock()
 
 	if m.alwaysFail || (m.failAfterNumCalls > 0 && m.currNumCalls > m.failAfterNumCalls) {
+		m.MethodCalled("OnGet")
 		return &http.Response{
 			StatusCode: 500,
 		}, fmt.Errorf("failed to fetch with %s", url)
 	}
 
+	m.MethodCalled("OnGet")
+
 	var compressed []byte
 	compressed = snappy.Encode(compressed, data.SigstoreBundleRaw)
 	return &http.Response{
@@ -37,10 +44,6 @@ func (m *mockHttpClient) Get(url string) (*http.Response, error) {
 	}, nil
 }
 
-func (m *mockHttpClient) TimesCalled() int {
-	return m.currNumCalls
-}
-
 func FailHTTPClient() mockHttpClient {
 	return mockHttpClient{
 		alwaysFail: true,

From 9d88ca8cf8e14b86275f4c5612fae576ac597572 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 11:32:49 -0700
Subject: [PATCH 25/68] simplify mock http client

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client_test.go        | 15 +++--
 .../attestation/api/mock_httpClient_test.go   | 67 ++++++++++++-------
 2 files changed, 49 insertions(+), 33 deletions(-)

diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index 3572689f8..feba1a942 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -181,9 +181,9 @@ func TestGetByDigest_Error(t *testing.T) {
 }
 
 func TestFetchBundlesByURL(t *testing.T) {
-	mockHTTPClient := &mockHttpClient{}
+	mockHTTPClient := SuccessHTTPClient()
 	client := LiveClient{
-		httpClient: mockHTTPClient,
+		httpClient: &mockHTTPClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -194,11 +194,11 @@ func TestFetchBundlesByURL(t *testing.T) {
 	require.NoError(t, err)
 	require.Len(t, fetched, 2)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", fetched[0].Bundle.GetMediaType())
-	mockHTTPClient.AssertNumberOfCalls(t, "OnGet", 2)
+	mockHTTPClient.AssertNumberOfCalls(t, "OnGetSuccess", 2)
 }
 
 func TestFetchBundlesByURL_Fail(t *testing.T) {
-	mockHTTPClient := HTTPClientFailsAfterNumCalls(1)
+	mockHTTPClient := FailsAfterNumCallsHTTPClient(1)
 
 	c := &LiveClient{
 		httpClient: &mockHTTPClient,
@@ -211,6 +211,7 @@ func TestFetchBundlesByURL_Fail(t *testing.T) {
 	fetched, err := c.fetchBundlesByURL(attestations)
 	require.Error(t, err)
 	require.Nil(t, fetched)
+	mockHTTPClient.AssertNumberOfCalls(t, "OnGetFailAfterOneCall", 2)
 }
 
 func TestFetchBundleByURL(t *testing.T) {
@@ -225,7 +226,7 @@ func TestFetchBundleByURL(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.NoError(t, err)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-	mockHTTPClient.AssertNumberOfCalls(t, "OnGet", 1)
+	mockHTTPClient.AssertNumberOfCalls(t, "OnGetSuccess", 1)
 }
 
 func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
@@ -240,7 +241,7 @@ func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.Error(t, err)
 	require.Nil(t, bundle)
-	mockHTTPClient.AssertNumberOfCalls(t, "OnGet", 1)
+	mockHTTPClient.AssertNumberOfCalls(t, "OnGetFail", 1)
 }
 
 func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
@@ -255,7 +256,7 @@ func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.NoError(t, err)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-	mockHTTPClient.AssertNotCalled(t, "OnGet")
+	mockHTTPClient.AssertNotCalled(t, "OnGetSuccess")
 }
 
 func TestGetTrustDomain(t *testing.T) {
diff --git a/pkg/cmd/attestation/api/mock_httpClient_test.go b/pkg/cmd/attestation/api/mock_httpClient_test.go
index dd0c139d5..8cbc91755 100644
--- a/pkg/cmd/attestation/api/mock_httpClient_test.go
+++ b/pkg/cmd/attestation/api/mock_httpClient_test.go
@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"sync"
 
 	"github.com/cli/cli/v2/pkg/cmd/attestation/test/data"
 	"github.com/golang/snappy"
@@ -14,27 +13,11 @@ import (
 
 type mockHttpClient struct {
 	mock.Mock
-	mutex             sync.RWMutex
-	currNumCalls      int
-	alwaysFail        bool
-	failAfterNumCalls int
-	OnGet             func(url string) (*http.Response, error)
 }
 
 func (m *mockHttpClient) Get(url string) (*http.Response, error) {
-	m.On("OnGet").Return()
-	m.mutex.Lock()
-	m.currNumCalls++
-	m.mutex.Unlock()
-
-	if m.alwaysFail || (m.failAfterNumCalls > 0 && m.currNumCalls > m.failAfterNumCalls) {
-		m.MethodCalled("OnGet")
-		return &http.Response{
-			StatusCode: 500,
-		}, fmt.Errorf("failed to fetch with %s", url)
-	}
-
-	m.MethodCalled("OnGet")
+	m.On("OnGetSuccess").Return()
+	m.MethodCalled("OnGetSuccess")
 
 	var compressed []byte
 	compressed = snappy.Encode(compressed, data.SigstoreBundleRaw)
@@ -44,18 +27,50 @@ func (m *mockHttpClient) Get(url string) (*http.Response, error) {
 	}, nil
 }
 
-func FailHTTPClient() mockHttpClient {
-	return mockHttpClient{
-		alwaysFail: true,
+type failHttpClient struct {
+	mock.Mock
+}
+
+func (m *failHttpClient) Get(url string) (*http.Response, error) {
+	m.On("OnGetFail").Return()
+	m.MethodCalled("OnGetFail")
+
+	return &http.Response{
+		StatusCode: 500,
+	}, fmt.Errorf("failed to fetch with %s", url)
+}
+
+type failAfterOneCallHttpClient struct {
+	mock.Mock
+}
+
+func (m *failAfterOneCallHttpClient) Get(url string) (*http.Response, error) {
+	m.On("OnGetFailAfterOneCall").Return()
+
+	if len(m.Calls) >= 1 {
+		m.MethodCalled("OnGetFailAfterOneCall")
+		return &http.Response{
+			StatusCode: 500,
+		}, fmt.Errorf("failed to fetch with %s", url)
 	}
+
+	m.MethodCalled("OnGetFailAfterOneCall")
+	var compressed []byte
+	compressed = snappy.Encode(compressed, data.SigstoreBundleRaw)
+	return &http.Response{
+		StatusCode: 200,
+		Body:       io.NopCloser(bytes.NewReader(compressed)),
+	}, nil
+}
+
+func FailHTTPClient() failHttpClient {
+	return failHttpClient{}
 }
 
 func SuccessHTTPClient() mockHttpClient {
 	return mockHttpClient{}
 }
 
-func HTTPClientFailsAfterNumCalls(numCalls int) mockHttpClient {
-	return mockHttpClient{
-		failAfterNumCalls: numCalls,
-	}
+func FailsAfterNumCallsHTTPClient(numCalls int) failAfterOneCallHttpClient {
+	return failAfterOneCallHttpClient{}
 }

From 7838e912b657f71371b96326790c7d5a0a84ba39 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 11:37:02 -0700
Subject: [PATCH 26/68] more mock http client cleanup

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client_test.go        | 36 +++++++++----------
 .../attestation/api/mock_httpClient_test.go   | 12 -------
 2 files changed, 18 insertions(+), 30 deletions(-)

diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index feba1a942..9b8dabc00 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -21,14 +21,14 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 	}
 	l := io.NewTestHandler()
 
-	mockHTTPClient := SuccessHTTPClient()
+	httpClient := &mockHttpClient{}
 
 	if hasNextPage {
 		return &LiveClient{
 			githubAPI: mockAPIClient{
 				OnRESTWithNext: fetcher.OnRESTSuccessWithNextPage,
 			},
-			httpClient: &mockHTTPClient,
+			httpClient: httpClient,
 			logger:     l,
 		}
 	}
@@ -37,7 +37,7 @@ func NewClientWithMockGHClient(hasNextPage bool) Client {
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTSuccess,
 		},
-		httpClient: &mockHTTPClient,
+		httpClient: httpClient,
 		logger:     l,
 	}
 }
@@ -139,12 +139,12 @@ func TestGetByDigest_NoAttestationsFound(t *testing.T) {
 		NumAttestations: 5,
 	}
 
-	httpClient := SuccessHTTPClient()
+	httpClient := &mockHttpClient{}
 	c := LiveClient{
 		githubAPI: mockAPIClient{
 			OnRESTWithNext: fetcher.OnRESTWithNextNoAttestations,
 		},
-		httpClient: &httpClient,
+		httpClient: httpClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -181,9 +181,9 @@ func TestGetByDigest_Error(t *testing.T) {
 }
 
 func TestFetchBundlesByURL(t *testing.T) {
-	mockHTTPClient := SuccessHTTPClient()
+	httpClient := &mockHttpClient{}
 	client := LiveClient{
-		httpClient: &mockHTTPClient,
+		httpClient: httpClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -194,14 +194,14 @@ func TestFetchBundlesByURL(t *testing.T) {
 	require.NoError(t, err)
 	require.Len(t, fetched, 2)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", fetched[0].Bundle.GetMediaType())
-	mockHTTPClient.AssertNumberOfCalls(t, "OnGetSuccess", 2)
+	httpClient.AssertNumberOfCalls(t, "OnGetSuccess", 2)
 }
 
 func TestFetchBundlesByURL_Fail(t *testing.T) {
-	mockHTTPClient := FailsAfterNumCallsHTTPClient(1)
+	httpClient := &failAfterOneCallHttpClient{}
 
 	c := &LiveClient{
-		httpClient: &mockHTTPClient,
+		httpClient: httpClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -211,14 +211,14 @@ func TestFetchBundlesByURL_Fail(t *testing.T) {
 	fetched, err := c.fetchBundlesByURL(attestations)
 	require.Error(t, err)
 	require.Nil(t, fetched)
-	mockHTTPClient.AssertNumberOfCalls(t, "OnGetFailAfterOneCall", 2)
+	httpClient.AssertNumberOfCalls(t, "OnGetFailAfterOneCall", 2)
 }
 
 func TestFetchBundleByURL(t *testing.T) {
-	mockHTTPClient := SuccessHTTPClient()
+	httpClient := &mockHttpClient{}
 
 	c := &LiveClient{
-		httpClient: &mockHTTPClient,
+		httpClient: httpClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -226,14 +226,14 @@ func TestFetchBundleByURL(t *testing.T) {
 	bundle, err := c.fetchBundleByURL(&attestation)
 	require.NoError(t, err)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-	mockHTTPClient.AssertNumberOfCalls(t, "OnGetSuccess", 1)
+	httpClient.AssertNumberOfCalls(t, "OnGetSuccess", 1)
 }
 
 func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
-	mockHTTPClient := FailHTTPClient()
+	mockHTTPClient := &failHttpClient{}
 
 	c := &LiveClient{
-		httpClient: &mockHTTPClient,
+		httpClient: mockHTTPClient,
 		logger:     io.NewTestHandler(),
 	}
 
@@ -245,10 +245,10 @@ func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
 }
 
 func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
-	mockHTTPClient := SuccessHTTPClient()
+	mockHTTPClient := &mockHttpClient{}
 
 	c := &LiveClient{
-		httpClient: &mockHTTPClient,
+		httpClient: mockHTTPClient,
 		logger:     io.NewTestHandler(),
 	}
 
diff --git a/pkg/cmd/attestation/api/mock_httpClient_test.go b/pkg/cmd/attestation/api/mock_httpClient_test.go
index 8cbc91755..4dc34fbf8 100644
--- a/pkg/cmd/attestation/api/mock_httpClient_test.go
+++ b/pkg/cmd/attestation/api/mock_httpClient_test.go
@@ -62,15 +62,3 @@ func (m *failAfterOneCallHttpClient) Get(url string) (*http.Response, error) {
 		Body:       io.NopCloser(bytes.NewReader(compressed)),
 	}, nil
 }
-
-func FailHTTPClient() failHttpClient {
-	return failHttpClient{}
-}
-
-func SuccessHTTPClient() mockHttpClient {
-	return mockHttpClient{}
-}
-
-func FailsAfterNumCallsHTTPClient(numCalls int) failAfterOneCallHttpClient {
-	return failAfterOneCallHttpClient{}
-}

From 3c0280c4d7d1621412093f78e6870b0129fbfb4c Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 11:51:23 -0700
Subject: [PATCH 27/68] undo name change for now

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/verification/attestation.go | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/pkg/cmd/attestation/verification/attestation.go b/pkg/cmd/attestation/verification/attestation.go
index 8022a4943..5bca39700 100644
--- a/pkg/cmd/attestation/verification/attestation.go
+++ b/pkg/cmd/attestation/verification/attestation.go
@@ -102,19 +102,19 @@ func GetRemoteAttestations(client api.Client, params FetchRemoteAttestationsPara
 	// check if Repo is set first because if Repo has been set, Owner will be set using the value of Repo.
 	// If Repo is not set, the field will remain empty. It will not be populated using the value of Owner.
 	if params.Repo != "" {
-		bundles, err := client.GetByRepoAndDigest(params.Repo, params.Digest, params.Limit)
+		attestations, err := client.GetByRepoAndDigest(params.Repo, params.Digest, params.Limit)
 		if err != nil {
 			return nil, fmt.Errorf("failed to fetch attestations from %s: %w", params.Repo, err)
 		}
 
-		return bundles, nil
+		return attestations, nil
 	} else if params.Owner != "" {
-		bundles, err := client.GetByOwnerAndDigest(params.Owner, params.Digest, params.Limit)
+		attestations, err := client.GetByOwnerAndDigest(params.Owner, params.Digest, params.Limit)
 		if err != nil {
 			return nil, fmt.Errorf("failed to fetch attestations from %s: %w", params.Owner, err)
 		}
 
-		return bundles, nil
+		return attestations, nil
 	}
 	return nil, fmt.Errorf("owner or repo must be provided")
 }

From 37e0969f20cc6881ab7ccf3b4c675d13ea3a5dbd Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 11:51:51 -0700
Subject: [PATCH 28/68] remove spaces

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/verification/attestation.go | 2 --
 1 file changed, 2 deletions(-)

diff --git a/pkg/cmd/attestation/verification/attestation.go b/pkg/cmd/attestation/verification/attestation.go
index 5bca39700..fdfd667bd 100644
--- a/pkg/cmd/attestation/verification/attestation.go
+++ b/pkg/cmd/attestation/verification/attestation.go
@@ -106,14 +106,12 @@ func GetRemoteAttestations(client api.Client, params FetchRemoteAttestationsPara
 		if err != nil {
 			return nil, fmt.Errorf("failed to fetch attestations from %s: %w", params.Repo, err)
 		}
-
 		return attestations, nil
 	} else if params.Owner != "" {
 		attestations, err := client.GetByOwnerAndDigest(params.Owner, params.Digest, params.Limit)
 		if err != nil {
 			return nil, fmt.Errorf("failed to fetch attestations from %s: %w", params.Owner, err)
 		}
-
 		return attestations, nil
 	}
 	return nil, fmt.Errorf("owner or repo must be provided")

From 0a602fae073326f882834987492d7433c88a7f36 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 11:54:02 -0700
Subject: [PATCH 29/68] undo other name change

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go      | 4 ++--
 pkg/cmd/attestation/api/client_test.go | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index d0ef3f21b..dc3ab2cb4 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -60,14 +60,14 @@ func NewLiveClient(hc *http.Client, host string, l *ioconfig.Handler) *LiveClien
 	}
 }
 
-func (c *LiveClient) buildRepoAndDigestURL(repo, digest string) string {
+func (c *LiveClient) BuildRepoAndDigestURL(repo, digest string) string {
 	repo = strings.Trim(repo, "/")
 	return fmt.Sprintf(GetAttestationByRepoAndSubjectDigestPath, repo, digest)
 }
 
 // GetByRepoAndDigest fetches the attestation by repo and digest
 func (c *LiveClient) GetByRepoAndDigest(repo, digest string, limit int) ([]*Attestation, error) {
-	url := c.buildRepoAndDigestURL(repo, digest)
+	url := c.BuildRepoAndDigestURL(repo, digest)
 	attestations, err := c.getAttestations(url, repo, digest, limit)
 	if err != nil {
 		return nil, err
diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index 9b8dabc00..7a01809cf 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -55,7 +55,7 @@ func TestGetURL(t *testing.T) {
 	}
 
 	for _, data := range testData {
-		s := c.buildRepoAndDigestURL(data.repo, data.digest)
+		s := c.BuildRepoAndDigestURL(data.repo, data.digest)
 		require.Equal(t, data.expected, s)
 	}
 }

From 258c69cd266e725eb26de266281aa737241d4fbc Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 11:56:05 -0700
Subject: [PATCH 30/68] undo more name chanages

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index dc3ab2cb4..02b4d6758 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -81,14 +81,14 @@ func (c *LiveClient) GetByRepoAndDigest(repo, digest string, limit int) ([]*Atte
 	return bundles, nil
 }
 
-func (c *LiveClient) buildOwnerAndDigestURL(owner, digest string) string {
+func (c *LiveClient) BuildOwnerAndDigestURL(owner, digest string) string {
 	owner = strings.Trim(owner, "/")
 	return fmt.Sprintf(GetAttestationByOwnerAndSubjectDigestPath, owner, digest)
 }
 
 // GetByOwnerAndDigest fetches attestation by owner and digest
 func (c *LiveClient) GetByOwnerAndDigest(owner, digest string, limit int) ([]*Attestation, error) {
-	url := c.buildOwnerAndDigestURL(owner, digest)
+	url := c.BuildOwnerAndDigestURL(owner, digest)
 	attestations, err := c.getAttestations(url, owner, digest, limit)
 	if err != nil {
 		return nil, err

From f46cccbab4ecfdcfd9dd61743f2b53d19cf375ea Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 12:03:49 -0700
Subject: [PATCH 31/68] comment

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index 02b4d6758..20df51165 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -191,6 +191,7 @@ func (c *LiveClient) fetchBundlesByURL(attestations []*Attestation) ([]*Attestat
 }
 
 func (c *LiveClient) fetchBundleByURL(a *Attestation) (*bundle.Bundle, error) {
+	// for now, we fallback to the bundle field if the bundle URL is empty
 	if a.BundleURL == "" {
 		c.logger.VerbosePrintf("Bundle URL is empty. Falling back to bundle field\n\n")
 		return a.Bundle, nil

From 42cb2547cdcb8bf089bbdd055f7a0ac8114cc37f Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 14:13:50 -0700
Subject: [PATCH 32/68] remove old comment

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index 20df51165..9c5979d46 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -209,7 +209,6 @@ func (c *LiveClient) fetchBundleByURL(a *Attestation) (*bundle.Bundle, error) {
 		return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
 	}
 
-	// parse the URL to get the host and path
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		return nil, fmt.Errorf("failed to read blob storage response body: %w", err)

From bf6fdbdfd214c97f45d2610289236ae3537d3ea4 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Tue, 7 Jan 2025 11:31:46 -0800
Subject: [PATCH 33/68] Remove named returns from ReadBranchConfig and surface
 errors

---
 git/client.go                    | 14 ++++++++++----
 git/client_test.go               |  2 +-
 pkg/cmd/pr/create/create.go      |  6 +++++-
 pkg/cmd/pr/create/create_test.go |  2 +-
 pkg/cmd/pr/shared/finder.go      |  3 ++-
 pkg/cmd/pr/status/status.go      |  2 +-
 6 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/git/client.go b/git/client.go
index 1a6d9ae7f..501d1ba9d 100644
--- a/git/client.go
+++ b/git/client.go
@@ -377,16 +377,22 @@ func (c *Client) lookupCommit(ctx context.Context, sha, format string) ([]byte,
 }
 
 // ReadBranchConfig parses the `branch.BRANCH.(remote|merge|gh-merge-base)` part of git config.
-func (c *Client) ReadBranchConfig(ctx context.Context, branch string) (cfg BranchConfig) {
+// If no branch config is found or there is an error in the command, it returns an empty BranchConfig.
+// Downstream consumers of ReadBranchConfig should consider the behavior they desire if this errors,
+// as an empty config is not necessarily breaking.
+func (c *Client) ReadBranchConfig(ctx context.Context, branch string) (BranchConfig, error) {
+	var cfg BranchConfig
+
 	prefix := regexp.QuoteMeta(fmt.Sprintf("branch.%s.", branch))
 	args := []string{"config", "--get-regexp", fmt.Sprintf("^%s(remote|merge|%s)$", prefix, MergeBaseConfig)}
 	cmd, err := c.Command(ctx, args...)
 	if err != nil {
-		return
+		return cfg, err
 	}
+
 	out, err := cmd.Output()
 	if err != nil {
-		return
+		return cfg, err
 	}
 
 	for _, line := range outputLines(out) {
@@ -412,7 +418,7 @@ func (c *Client) ReadBranchConfig(ctx context.Context, branch string) (cfg Branc
 			cfg.MergeBase = parts[1]
 		}
 	}
-	return
+	return cfg, nil
 }
 
 // SetBranchConfig sets the named value on the given branch.
diff --git a/git/client_test.go b/git/client_test.go
index fff1397f3..182ce67ea 100644
--- a/git/client_test.go
+++ b/git/client_test.go
@@ -747,7 +747,7 @@ func TestClientReadBranchConfig(t *testing.T) {
 				GitPath:        "path/to/git",
 				commandContext: cmdCtx,
 			}
-			branchConfig := client.ReadBranchConfig(context.Background(), "trunk")
+			branchConfig, _ := client.ReadBranchConfig(context.Background(), "trunk")
 			assert.Equal(t, tt.wantCmdArgs, strings.Join(cmd.Args[3:], " "))
 			assert.Equal(t, tt.wantBranchConfig, branchConfig)
 		})
diff --git a/pkg/cmd/pr/create/create.go b/pkg/cmd/pr/create/create.go
index db160b419..638d8eed4 100644
--- a/pkg/cmd/pr/create/create.go
+++ b/pkg/cmd/pr/create/create.go
@@ -680,7 +680,11 @@ func NewCreateContext(opts *CreateOptions) (*CreateContext, error) {
 	var headRepo ghrepo.Interface
 	var headRemote *ghContext.Remote
 
-	headBranchConfig := gitClient.ReadBranchConfig(context.Background(), headBranch)
+	headBranchConfig, err := gitClient.ReadBranchConfig(context.Background(), headBranch)
+	if err != nil {
+		// We can still proceed without the branch config, so print to stderr but continue
+		fmt.Fprintf(opts.IO.ErrOut, "Error reading git branch config: %v\n", err)
+	}
 	if isPushEnabled {
 		// determine whether the head branch is already pushed to a remote
 		if trackingRef, found := tryDetermineTrackingRef(gitClient, remotes, headBranch, headBranchConfig); found {
diff --git a/pkg/cmd/pr/create/create_test.go b/pkg/cmd/pr/create/create_test.go
index 6c0ff11e2..66fe1c39a 100644
--- a/pkg/cmd/pr/create/create_test.go
+++ b/pkg/cmd/pr/create/create_test.go
@@ -1717,7 +1717,7 @@ func Test_tryDetermineTrackingRef(t *testing.T) {
 				GhPath:  "some/path/gh",
 				GitPath: "some/path/git",
 			}
-			headBranchConfig := gitClient.ReadBranchConfig(ctx.Background(), "feature")
+			headBranchConfig, _ := gitClient.ReadBranchConfig(ctx.Background(), "feature")
 			ref, found := tryDetermineTrackingRef(gitClient, tt.remotes, "feature", headBranchConfig)
 
 			assert.Equal(t, tt.expectedTrackingRef, ref)
diff --git a/pkg/cmd/pr/shared/finder.go b/pkg/cmd/pr/shared/finder.go
index e4a70eb22..3bc197b75 100644
--- a/pkg/cmd/pr/shared/finder.go
+++ b/pkg/cmd/pr/shared/finder.go
@@ -59,7 +59,8 @@ func NewFinder(factory *cmdutil.Factory) PRFinder {
 		httpClient: factory.HttpClient,
 		progress:   factory.IOStreams,
 		branchConfig: func(s string) git.BranchConfig {
-			return factory.GitClient.ReadBranchConfig(context.Background(), s)
+			branchConfig, _ := factory.GitClient.ReadBranchConfig(context.Background(), s)
+			return branchConfig
 		},
 	}
 }
diff --git a/pkg/cmd/pr/status/status.go b/pkg/cmd/pr/status/status.go
index 27666461d..2613a3a6b 100644
--- a/pkg/cmd/pr/status/status.go
+++ b/pkg/cmd/pr/status/status.go
@@ -186,7 +186,7 @@ func statusRun(opts *StatusOptions) error {
 
 func prSelectorForCurrentBranch(gitClient *git.Client, baseRepo ghrepo.Interface, prHeadRef string, rem ghContext.Remotes) (prNumber int, selector string, err error) {
 	selector = prHeadRef
-	branchConfig := gitClient.ReadBranchConfig(context.Background(), prHeadRef)
+	branchConfig, _ := gitClient.ReadBranchConfig(context.Background(), prHeadRef)
 
 	// the branch is configured to merge a special PR head ref
 	prHeadRE := regexp.MustCompile(`^refs/pull/(\d+)/head$`)

From f43da8ea9a4c4c3caccbaa082232b36e26fad380 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Tue, 7 Jan 2025 12:19:13 -0800
Subject: [PATCH 34/68] Refactor ReadBranchConfig for test coverage of newly
 returned erros

---
 git/client.go      | 22 +++++++++--
 git/client_test.go | 94 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 112 insertions(+), 4 deletions(-)

diff --git a/git/client.go b/git/client.go
index 501d1ba9d..b356e9ef5 100644
--- a/git/client.go
+++ b/git/client.go
@@ -383,19 +383,33 @@ func (c *Client) lookupCommit(ctx context.Context, sha, format string) ([]byte,
 func (c *Client) ReadBranchConfig(ctx context.Context, branch string) (BranchConfig, error) {
 	var cfg BranchConfig
 
+	branchConfigOutput, err := c.readGitBranchConfig(ctx, branch)
+	if err != nil {
+		return cfg, err
+	}
+
+	return c.createBranchConfig(outputLines(branchConfigOutput)), nil
+}
+
+func (c *Client) readGitBranchConfig(ctx context.Context, branch string) ([]byte, error) {
 	prefix := regexp.QuoteMeta(fmt.Sprintf("branch.%s.", branch))
 	args := []string{"config", "--get-regexp", fmt.Sprintf("^%s(remote|merge|%s)$", prefix, MergeBaseConfig)}
 	cmd, err := c.Command(ctx, args...)
 	if err != nil {
-		return cfg, err
+		return []byte{}, err
 	}
 
 	out, err := cmd.Output()
 	if err != nil {
-		return cfg, err
+		return []byte{}, err
 	}
 
-	for _, line := range outputLines(out) {
+	return out, nil
+}
+
+func (c *Client) createBranchConfig(gitBranchConfigOutput []string) BranchConfig {
+	var cfg BranchConfig
+	for _, line := range gitBranchConfigOutput {
 		parts := strings.SplitN(line, " ", 2)
 		if len(parts) < 2 {
 			continue
@@ -418,7 +432,7 @@ func (c *Client) ReadBranchConfig(ctx context.Context, branch string) (BranchCon
 			cfg.MergeBase = parts[1]
 		}
 	}
-	return cfg, nil
+	return cfg
 }
 
 // SetBranchConfig sets the named value on the given branch.
diff --git a/git/client_test.go b/git/client_test.go
index 182ce67ea..448908591 100644
--- a/git/client_test.go
+++ b/git/client_test.go
@@ -754,6 +754,100 @@ func TestClientReadBranchConfig(t *testing.T) {
 	}
 }
 
+func Test_readGitBranchConfig(t *testing.T) {
+	tests := []struct {
+		name        string
+		branch      string
+		cmdExitCode int
+		cmdStdout   string
+		cmdStderr   string
+		wantCmdArgs string
+		wantErr     *GitError
+	}{
+		{
+			name:        "read branch config",
+			branch:      "trunk",
+			cmdStdout:   "branch.trunk.remote origin\nbranch.trunk.merge refs/heads/trunk\nbranch.trunk.gh-merge-base trunk",
+			wantCmdArgs: `path/to/git config --get-regexp ^branch\.trunk\.(remote|merge|gh-merge-base)$`,
+		},
+		{
+			name:        "command failure",
+			branch:      "trunk",
+			wantCmdArgs: `path/to/git config --get-regexp ^branch\.trunk\.(remote|merge|gh-merge-base)$`,
+			cmdExitCode: 1,
+			cmdStderr:   "error",
+			wantErr:     &GitError{ExitCode: 1, Stderr: "error"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cmd, cmdCtx := createCommandContext(t, tt.cmdExitCode, tt.cmdStdout, tt.cmdStderr)
+			client := Client{
+				GitPath:        "path/to/git",
+				commandContext: cmdCtx,
+			}
+			out, err := client.readGitBranchConfig(context.Background(), tt.branch)
+			if tt.wantErr != nil {
+				assert.Equal(t, tt.wantErr.ExitCode, err.(*GitError).ExitCode)
+				assert.Equal(t, tt.wantErr.Stderr, err.(*GitError).Stderr)
+			} else {
+				assert.Equal(t, tt.wantCmdArgs, strings.Join(cmd.Args[3:], " "))
+				assert.Equal(t, tt.cmdStdout, string(out))
+			}
+		})
+	}
+}
+
+func Test_createBranchConfig(t *testing.T) {
+	tests := []struct {
+		name                  string
+		gitBranchConfigOutput []string
+		wantBranchConfig      BranchConfig
+	}{
+		{
+			name:                  "remote branch",
+			gitBranchConfigOutput: []string{"branch.trunk.remote origin"},
+			wantBranchConfig: BranchConfig{
+				RemoteName: "origin",
+			},
+		},
+		{
+			name:                  "merge ref",
+			gitBranchConfigOutput: []string{"branch.trunk.merge refs/heads/trunk"},
+			wantBranchConfig: BranchConfig{
+				MergeRef: "refs/heads/trunk",
+			},
+		},
+		{
+			name:                  "merge base",
+			gitBranchConfigOutput: []string{"branch.trunk.gh-merge-base gh-merge-base"},
+			wantBranchConfig: BranchConfig{
+				MergeBase: "gh-merge-base",
+			},
+		},
+		{
+			name: "remote, merge ref, and merge base all specified",
+			gitBranchConfigOutput: []string{
+				"branch.trunk.remote origin",
+				"branch.trunk.merge refs/heads/trunk",
+				"branch.trunk.gh-merge-base gh-merge-base",
+			},
+			wantBranchConfig: BranchConfig{
+				RemoteName: "origin",
+				MergeRef:   "refs/heads/trunk",
+				MergeBase:  "gh-merge-base",
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			client := Client{}
+			branchConfig := client.createBranchConfig(tt.gitBranchConfigOutput)
+			assert.Equal(t, tt.wantBranchConfig, branchConfig)
+		})
+	}
+}
+
 func TestClientDeleteLocalTag(t *testing.T) {
 	tests := []struct {
 		name          string

From c83cf32cff2027f6506203aca5858137fbe2ea72 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Tue, 7 Jan 2025 13:41:53 -0800
Subject: [PATCH 35/68] Remove named return values from
 prSelectorForCurrentBranch

---
 pkg/cmd/pr/status/status.go | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/pkg/cmd/pr/status/status.go b/pkg/cmd/pr/status/status.go
index 2613a3a6b..9245b1cdc 100644
--- a/pkg/cmd/pr/status/status.go
+++ b/pkg/cmd/pr/status/status.go
@@ -184,17 +184,17 @@ func statusRun(opts *StatusOptions) error {
 	return nil
 }
 
-func prSelectorForCurrentBranch(gitClient *git.Client, baseRepo ghrepo.Interface, prHeadRef string, rem ghContext.Remotes) (prNumber int, selector string, err error) {
-	selector = prHeadRef
+func prSelectorForCurrentBranch(gitClient *git.Client, baseRepo ghrepo.Interface, prHeadRef string, rem ghContext.Remotes) (int, string, error) {
 	branchConfig, _ := gitClient.ReadBranchConfig(context.Background(), prHeadRef)
 
 	// the branch is configured to merge a special PR head ref
 	prHeadRE := regexp.MustCompile(`^refs/pull/(\d+)/head$`)
 	if m := prHeadRE.FindStringSubmatch(branchConfig.MergeRef); m != nil {
-		prNumber, _ = strconv.Atoi(m[1])
-		return
+		prNumber, err := strconv.Atoi(m[1])
+		return prNumber, prHeadRef, err
 	}
 
+	var err error
 	var branchOwner string
 	if branchConfig.RemoteURL != nil {
 		// the branch merges from a remote specified by URL
@@ -208,6 +208,7 @@ func prSelectorForCurrentBranch(gitClient *git.Client, baseRepo ghrepo.Interface
 		}
 	}
 
+	selector := prHeadRef
 	if branchOwner != "" {
 		if strings.HasPrefix(branchConfig.MergeRef, "refs/heads/") {
 			selector = strings.TrimPrefix(branchConfig.MergeRef, "refs/heads/")
@@ -218,7 +219,7 @@ func prSelectorForCurrentBranch(gitClient *git.Client, baseRepo ghrepo.Interface
 		}
 	}
 
-	return
+	return 0, selector, err
 }
 
 func totalApprovals(pr *api.PullRequest) int {

From 51a74aed1daa4cff4452d847a79a4842ce17ec86 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@users.noreply.github.com>
Date: Tue, 7 Jan 2025 15:14:23 -0700
Subject: [PATCH 36/68] Update pkg/cmd/attestation/api/client.go

Co-authored-by: Phill MV <phillmv@github.com>
---
 pkg/cmd/attestation/api/client.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index 9c5979d46..ca6c0f3d5 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -172,7 +172,7 @@ func (c *LiveClient) fetchBundlesByURL(attestations []*Attestation) ([]*Attestat
 	g := errgroup.Group{}
 	for i, a := range attestations {
 		g.Go(func() error {
-			b, err := c.fetchBundleByURL(a)
+			b, err := c.GetBundle(url)
 			if err != nil {
 				return fmt.Errorf("failed to fetch bundle with URL: %w", err)
 			}

From 8d89dd97fdb487f8ad64d386de1d25d6ff3d36c8 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@users.noreply.github.com>
Date: Tue, 7 Jan 2025 15:14:53 -0700
Subject: [PATCH 37/68] Update pkg/cmd/attestation/api/client.go

Co-authored-by: Phill MV <phillmv@github.com>
---
 pkg/cmd/attestation/api/client.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index ca6c0f3d5..bf49756be 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -167,7 +167,7 @@ func (c *LiveClient) getAttestations(url, name, digest string, limit int) ([]*At
 	return attestations, nil
 }
 
-func (c *LiveClient) fetchBundlesByURL(attestations []*Attestation) ([]*Attestation, error) {
+func (c *LiveClient) fetchBundleFromAttestations(attestations []*Attestation) ([]*Attestation, error) {
 	fetched := make([]*Attestation, len(attestations))
 	g := errgroup.Group{}
 	for i, a := range attestations {

From 33d0002d214c4a94b063ba3cad36aa6f0ec24aaf Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Tue, 7 Jan 2025 15:22:02 -0700
Subject: [PATCH 38/68] update tests to use new function name

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go      | 25 +++++++++--------
 pkg/cmd/attestation/api/client_test.go | 37 +++++++++-----------------
 2 files changed, 26 insertions(+), 36 deletions(-)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index bf49756be..f8d0509ee 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -73,7 +73,7 @@ func (c *LiveClient) GetByRepoAndDigest(repo, digest string, limit int) ([]*Atte
 		return nil, err
 	}
 
-	bundles, err := c.fetchBundlesByURL(attestations)
+	bundles, err := c.fetchBundleFromAttestations(attestations)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch bundle with URL: %w", err)
 	}
@@ -98,7 +98,7 @@ func (c *LiveClient) GetByOwnerAndDigest(owner, digest string, limit int) ([]*At
 		return nil, newErrNoAttestations(owner, digest)
 	}
 
-	bundles, err := c.fetchBundlesByURL(attestations)
+	bundles, err := c.fetchBundleFromAttestations(attestations)
 	if err != nil {
 		return nil, fmt.Errorf("failed to fetch bundle with URL: %w", err)
 	}
@@ -172,7 +172,16 @@ func (c *LiveClient) fetchBundleFromAttestations(attestations []*Attestation) ([
 	g := errgroup.Group{}
 	for i, a := range attestations {
 		g.Go(func() error {
-			b, err := c.GetBundle(url)
+			// for now, we fallback to the bundle field if the bundle URL is empty
+			if a.BundleURL == "" {
+				c.logger.VerbosePrintf("Bundle URL is empty. Falling back to bundle field\n\n")
+				fetched[i] = &Attestation{
+					Bundle: a.Bundle,
+				}
+				return nil
+			}
+
+			b, err := c.GetBundle(a.BundleURL)
 			if err != nil {
 				return fmt.Errorf("failed to fetch bundle with URL: %w", err)
 			}
@@ -190,16 +199,10 @@ func (c *LiveClient) fetchBundleFromAttestations(attestations []*Attestation) ([
 	return fetched, nil
 }
 
-func (c *LiveClient) fetchBundleByURL(a *Attestation) (*bundle.Bundle, error) {
-	// for now, we fallback to the bundle field if the bundle URL is empty
-	if a.BundleURL == "" {
-		c.logger.VerbosePrintf("Bundle URL is empty. Falling back to bundle field\n\n")
-		return a.Bundle, nil
-	}
-
+func (c *LiveClient) GetBundle(url string) (*bundle.Bundle, error) {
 	c.logger.VerbosePrintf("Fetching attestation bundle with bundle URL\n\n")
 
-	resp, err := c.httpClient.Get(a.BundleURL)
+	resp, err := c.httpClient.Get(url)
 	if err != nil {
 		return nil, err
 	}
diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index 7a01809cf..fcceb33d7 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -180,7 +180,7 @@ func TestGetByDigest_Error(t *testing.T) {
 	require.Nil(t, attestations)
 }
 
-func TestFetchBundlesByURL(t *testing.T) {
+func TestFetchBundleFromAttestations(t *testing.T) {
 	httpClient := &mockHttpClient{}
 	client := LiveClient{
 		httpClient: httpClient,
@@ -190,14 +190,14 @@ func TestFetchBundlesByURL(t *testing.T) {
 	att1 := makeTestAttestation()
 	att2 := makeTestAttestation()
 	attestations := []*Attestation{&att1, &att2}
-	fetched, err := client.fetchBundlesByURL(attestations)
+	fetched, err := client.fetchBundleFromAttestations(attestations)
 	require.NoError(t, err)
 	require.Len(t, fetched, 2)
 	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", fetched[0].Bundle.GetMediaType())
 	httpClient.AssertNumberOfCalls(t, "OnGetSuccess", 2)
 }
 
-func TestFetchBundlesByURL_Fail(t *testing.T) {
+func TestFetchBundleFromAttestations_Fail(t *testing.T) {
 	httpClient := &failAfterOneCallHttpClient{}
 
 	c := &LiveClient{
@@ -208,28 +208,13 @@ func TestFetchBundlesByURL_Fail(t *testing.T) {
 	att1 := makeTestAttestation()
 	att2 := makeTestAttestation()
 	attestations := []*Attestation{&att1, &att2}
-	fetched, err := c.fetchBundlesByURL(attestations)
+	fetched, err := c.fetchBundleFromAttestations(attestations)
 	require.Error(t, err)
 	require.Nil(t, fetched)
 	httpClient.AssertNumberOfCalls(t, "OnGetFailAfterOneCall", 2)
 }
 
-func TestFetchBundleByURL(t *testing.T) {
-	httpClient := &mockHttpClient{}
-
-	c := &LiveClient{
-		httpClient: httpClient,
-		logger:     io.NewTestHandler(),
-	}
-
-	attestation := makeTestAttestation()
-	bundle, err := c.fetchBundleByURL(&attestation)
-	require.NoError(t, err)
-	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
-	httpClient.AssertNumberOfCalls(t, "OnGetSuccess", 1)
-}
-
-func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
+func TestFetchBundleFromAttestations_FetchByURLFail(t *testing.T) {
 	mockHTTPClient := &failHttpClient{}
 
 	c := &LiveClient{
@@ -237,8 +222,9 @@ func TestFetchBundleByURL_FetchByURLFail(t *testing.T) {
 		logger:     io.NewTestHandler(),
 	}
 
-	attestation := makeTestAttestation()
-	bundle, err := c.fetchBundleByURL(&attestation)
+	a := makeTestAttestation()
+	attestations := []*Attestation{&a}
+	bundle, err := c.fetchBundleFromAttestations(attestations)
 	require.Error(t, err)
 	require.Nil(t, bundle)
 	mockHTTPClient.AssertNumberOfCalls(t, "OnGetFail", 1)
@@ -252,10 +238,11 @@ func TestFetchBundleByURL_FallbackToBundleField(t *testing.T) {
 		logger:     io.NewTestHandler(),
 	}
 
-	attestation := Attestation{Bundle: data.SigstoreBundle(t)}
-	bundle, err := c.fetchBundleByURL(&attestation)
+	a := Attestation{Bundle: data.SigstoreBundle(t)}
+	attestations := []*Attestation{&a}
+	fetched, err := c.fetchBundleFromAttestations(attestations)
 	require.NoError(t, err)
-	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", bundle.GetMediaType())
+	require.Equal(t, "application/vnd.dev.sigstore.bundle.v0.3+json", fetched[0].Bundle.GetMediaType())
 	mockHTTPClient.AssertNotCalled(t, "OnGetSuccess")
 }
 

From 01371508486e86f5c4b772f0eee777e74cfa9b70 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Tue, 7 Jan 2025 14:56:27 -0800
Subject: [PATCH 39/68] Refactor Test_readGitBranchConfig for easier parsing

---
 git/client.go      | 10 ++++----
 git/client_test.go | 62 ++++++++++++++++++++++++++++------------------
 2 files changed, 43 insertions(+), 29 deletions(-)

diff --git a/git/client.go b/git/client.go
index b356e9ef5..20a489a29 100644
--- a/git/client.go
+++ b/git/client.go
@@ -388,23 +388,23 @@ func (c *Client) ReadBranchConfig(ctx context.Context, branch string) (BranchCon
 		return cfg, err
 	}
 
-	return c.createBranchConfig(outputLines(branchConfigOutput)), nil
+	return c.createBranchConfig(branchConfigOutput), nil
 }
 
-func (c *Client) readGitBranchConfig(ctx context.Context, branch string) ([]byte, error) {
+func (c *Client) readGitBranchConfig(ctx context.Context, branch string) ([]string, error) {
 	prefix := regexp.QuoteMeta(fmt.Sprintf("branch.%s.", branch))
 	args := []string{"config", "--get-regexp", fmt.Sprintf("^%s(remote|merge|%s)$", prefix, MergeBaseConfig)}
 	cmd, err := c.Command(ctx, args...)
 	if err != nil {
-		return []byte{}, err
+		return []string{}, err
 	}
 
 	out, err := cmd.Output()
 	if err != nil {
-		return []byte{}, err
+		return []string{}, err
 	}
 
-	return out, nil
+	return outputLines(out), nil
 }
 
 func (c *Client) createBranchConfig(gitBranchConfigOutput []string) BranchConfig {
diff --git a/git/client_test.go b/git/client_test.go
index 448908591..0930a6f72 100644
--- a/git/client_test.go
+++ b/git/client_test.go
@@ -756,43 +756,57 @@ func TestClientReadBranchConfig(t *testing.T) {
 
 func Test_readGitBranchConfig(t *testing.T) {
 	tests := []struct {
-		name        string
-		branch      string
-		cmdExitCode int
-		cmdStdout   string
-		cmdStderr   string
-		wantCmdArgs string
-		wantErr     *GitError
+		name           string
+		branch         string
+		cmdExitStatus  int
+		cmdStdout      string
+		cmdStderr      string
+		expectedOutput []string
+		expectedError  *GitError
 	}{
 		{
-			name:        "read branch config",
-			branch:      "trunk",
-			cmdStdout:   "branch.trunk.remote origin\nbranch.trunk.merge refs/heads/trunk\nbranch.trunk.gh-merge-base trunk",
-			wantCmdArgs: `path/to/git config --get-regexp ^branch\.trunk\.(remote|merge|gh-merge-base)$`,
+			name:          "read branch config",
+			branch:        "trunk",
+			cmdExitStatus: 0,
+			cmdStdout:     "branch.trunk.remote origin\nbranch.trunk.merge refs/heads/trunk\nbranch.trunk.gh-merge-base trunk",
+			expectedOutput: []string{
+				"branch.trunk.remote origin",
+				"branch.trunk.merge refs/heads/trunk",
+				"branch.trunk.gh-merge-base trunk"},
+			expectedError: nil,
 		},
 		{
-			name:        "command failure",
-			branch:      "trunk",
-			wantCmdArgs: `path/to/git config --get-regexp ^branch\.trunk\.(remote|merge|gh-merge-base)$`,
-			cmdExitCode: 1,
-			cmdStderr:   "error",
-			wantErr:     &GitError{ExitCode: 1, Stderr: "error"},
+			name:           "command failure",
+			branch:         "trunk",
+			cmdExitStatus:  1,
+			cmdStderr:      "git error message",
+			expectedOutput: []string{},
+			expectedError: &GitError{
+				ExitCode: 1,
+				Stderr:   "git error message",
+			},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			cmd, cmdCtx := createCommandContext(t, tt.cmdExitCode, tt.cmdStdout, tt.cmdStderr)
+			commandString := fmt.Sprintf("path/to/git config --get-regexp ^branch\\.%s\\.(remote|merge|gh-merge-base)$", tt.branch)
+			cmdCtx := createMockedCommandContext(t, map[args]commandResult{
+				args(commandString): {
+					ExitStatus: tt.cmdExitStatus,
+					Stdout:     tt.cmdStdout,
+					Stderr:     tt.cmdStderr,
+				},
+			})
 			client := Client{
 				GitPath:        "path/to/git",
 				commandContext: cmdCtx,
 			}
+
 			out, err := client.readGitBranchConfig(context.Background(), tt.branch)
-			if tt.wantErr != nil {
-				assert.Equal(t, tt.wantErr.ExitCode, err.(*GitError).ExitCode)
-				assert.Equal(t, tt.wantErr.Stderr, err.(*GitError).Stderr)
-			} else {
-				assert.Equal(t, tt.wantCmdArgs, strings.Join(cmd.Args[3:], " "))
-				assert.Equal(t, tt.cmdStdout, string(out))
+			assert.Equal(t, tt.expectedOutput, out)
+			if err != nil {
+				assert.Equal(t, tt.cmdStderr, err.(*GitError).Stderr)
+				assert.Equal(t, tt.cmdExitStatus, err.(*GitError).ExitCode)
 			}
 		})
 	}

From a8f0aaeb3d3c89ab4d6e2eca054216ca44dd77ae Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Wed, 8 Jan 2025 02:22:21 -0600
Subject: [PATCH 40/68] tentative updates for acceptance criteria - pending
 confirmation re description in prompt

---
 pkg/cmd/gist/delete/delete.go      |  19 +++-
 pkg/cmd/gist/delete/delete_test.go | 148 +++++++++++++++++++++--------
 2 files changed, 123 insertions(+), 44 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete.go b/pkg/cmd/gist/delete/delete.go
index 23e929d5b..a2b552a3a 100644
--- a/pkg/cmd/gist/delete/delete.go
+++ b/pkg/cmd/gist/delete/delete.go
@@ -35,7 +35,7 @@ func NewCmdDelete(f *cmdutil.Factory, runF func(*DeleteOptions) error) *cobra.Co
 	}
 
 	cmd := &cobra.Command{
-		Use:   "delete [<id> | <url>]",
+		Use:   "delete {<id> | <url>}",
 		Short: "Delete a gist",
 		Long: heredoc.Docf(`
 		Delete a GitHub gist.
@@ -53,9 +53,18 @@ func NewCmdDelete(f *cmdutil.Factory, runF func(*DeleteOptions) error) *cobra.Co
 	`),
 		Args: cobra.MaximumNArgs(1),
 		RunE: func(c *cobra.Command, args []string) error {
+			if !opts.IO.CanPrompt() && !opts.Confirmed {
+				return cmdutil.FlagErrorf("--yes required when not running interactively")
+			}
+
+			if !opts.IO.CanPrompt() && len(args) == 0 {
+				return cmdutil.FlagErrorf("id or url argument required in non-interactive mode")
+			}
+
 			if len(args) == 1 {
 				opts.Selector = args[0]
 			}
+
 			if runF != nil {
 				return runF(&opts)
 			}
@@ -97,9 +106,11 @@ func deleteRun(opts *DeleteOptions) error {
 	}
 
 	if !opts.Confirmed {
-		err = opts.Prompter.ConfirmDeletion("delete")
-
+		confirmed, err := opts.Prompter.Confirm(fmt.Sprintf("Delete \"%s\" gist?", gistID), false)
 		if err != nil {
+			return err
+		}
+		if !confirmed {
 			return cmdutil.CancelError
 		}
 	}
@@ -128,7 +139,7 @@ func deleteGist(apiClient *api.Client, hostname string, gistID string, opts *Del
 	if opts.IO.IsStdoutTTY() {
 		cs := opts.IO.ColorScheme()
 		fmt.Fprintf(opts.IO.Out,
-			"%s Deleted gist %s\n",
+			"%s Gist \"%s\" deleted\n",
 			cs.SuccessIcon(),
 			gistID)
 	}
diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index fec3b4ffd..237e3f768 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -19,36 +19,75 @@ import (
 
 func TestNewCmdDelete(t *testing.T) {
 	tests := []struct {
-		name  string
-		cli   string
-		wants DeleteOptions
+		name       string
+		cli        string
+		tty        bool
+		want       DeleteOptions
+		wantErr    bool
+		wantErrMsg string
 	}{
 		{
 			name: "valid selector",
 			cli:  "123",
-			wants: DeleteOptions{
+			tty:  true,
+			want: DeleteOptions{
 				Selector: "123",
 			},
 		},
 		{
-			name: "no ID supplied",
+			name: "valid selector, no ID supplied",
 			cli:  "",
-			wants: DeleteOptions{
+			tty:  true,
+			want: DeleteOptions{
 				Selector: "",
 			},
 		},
 		{
-			name: "yes flag",
+			name: "no ID supplied with --yes",
+			cli:  "--yes",
+			tty:  true,
+			want: DeleteOptions{
+				Selector: "",
+			},
+		},
+		{
+			name: "selector with --yes, no tty",
 			cli:  "123 --yes",
-			wants: DeleteOptions{
+			tty:  false,
+			want: DeleteOptions{
 				Selector: "123",
 			},
 		},
+		{
+			name: "ID arg without --yes, no tty",
+			cli:  "123",
+			tty:  false,
+			want: DeleteOptions{
+				Selector: "",
+			},
+			wantErr:    true,
+			wantErrMsg: "--yes required when not running interactively",
+		},
+		{
+			name: "no ID supplied with --yes, no tty",
+			cli:  "--yes",
+			tty:  false,
+			want: DeleteOptions{
+				Selector: "",
+			},
+			wantErr:    true,
+			wantErrMsg: "id or url argument required in non-interactive mode",
+		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			f := &cmdutil.Factory{}
+			io, _, _, _ := iostreams.Test()
+			f := &cmdutil.Factory{
+				IOStreams: io,
+			}
+			io.SetStdinTTY(tt.tty)
+			io.SetStdoutTTY(tt.tty)
 
 			argv, err := shlex.Split(tt.cli)
 			assert.NoError(t, err)
@@ -64,9 +103,13 @@ func TestNewCmdDelete(t *testing.T) {
 			cmd.SetErr(&bytes.Buffer{})
 
 			_, err = cmd.ExecuteC()
-			assert.NoError(t, err)
+			if tt.wantErr {
+				assert.EqualError(t, err, tt.wantErrMsg)
+				return
+			}
 
-			assert.Equal(t, tt.wants.Selector, gotOpts.Selector)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.want.Selector, gotOpts.Selector)
 		})
 	}
 }
@@ -75,6 +118,7 @@ func Test_deleteRun(t *testing.T) {
 	tests := []struct {
 		name         string
 		opts         *DeleteOptions
+		cancel       bool
 		httpStubs    func(*httpmock.Registry)
 		mockGistList bool
 		wantErr      bool
@@ -91,7 +135,7 @@ func Test_deleteRun(t *testing.T) {
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			wantErr:    false,
-			wantStdout: "✓ Deleted gist 1234\n",
+			wantStdout: "✓ Gist \"1234\" deleted\n",
 			wantStderr: "",
 		},
 		{
@@ -105,7 +149,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			mockGistList: true,
 			wantErr:      false,
-			wantStdout:   "✓ Deleted gist 1234\n",
+			wantStdout:   "✓ Gist \"1234\" deleted\n",
 			wantStderr:   "",
 		},
 		{
@@ -119,7 +163,7 @@ func Test_deleteRun(t *testing.T) {
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			wantErr:    false,
-			wantStdout: "✓ Deleted gist 1234\n",
+			wantStdout: "✓ Gist \"1234\" deleted\n",
 			wantStderr: "",
 		},
 		{
@@ -134,9 +178,29 @@ func Test_deleteRun(t *testing.T) {
 			},
 			mockGistList: true,
 			wantErr:      false,
-			wantStdout:   "✓ Deleted gist 1234\n",
+			wantStdout:   "✓ Gist \"1234\" deleted\n",
 			wantStderr:   "",
 		},
+		{
+			name: "cancel delete with id",
+			opts: &DeleteOptions{
+				Selector: "1234",
+			},
+			cancel:     true,
+			wantErr:    true,
+			wantStdout: "",
+			wantStderr: "",
+		},
+		{
+			name: "cancel delete with prompt",
+			opts: &DeleteOptions{
+				Selector: "",
+			},
+			cancel:     true,
+			wantErr:    true,
+			wantStdout: "",
+			wantStderr: "",
+		},
 		{
 			name: "not found",
 			opts: &DeleteOptions{
@@ -153,43 +217,47 @@ func Test_deleteRun(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		reg := &httpmock.Registry{}
-		tt.httpStubs(reg)
 		pm := prompter.NewMockPrompter(t)
 		if !tt.opts.Confirmed {
-			pm.RegisterConfirmDeletion("Type delete to confirm deletion:", func(_ string) error {
-				return nil
+			pm.RegisterConfirm("Delete \"1234\" gist?", func(_ string, _ bool) (bool, error) {
+				return !tt.cancel, nil
 			})
 		}
 
-		if tt.mockGistList {
-			sixHours, _ := time.ParseDuration("6h")
-			sixHoursAgo := time.Now().Add(-sixHours)
-			reg.Register(
-				httpmock.GraphQL(`query GistList\b`),
-				httpmock.StringResponse(fmt.Sprintf(
-					`{ "data": { "viewer": { "gists": { "nodes": [
-							{
-								"name": "1234",
-								"files": [{ "name": "cool.txt" }],
-								"description": "",
-								"updatedAt": "%s",
-								"isPublic": true
-							}
-						] } } } }`,
-					sixHoursAgo.Format(time.RFC3339),
-				)),
-			)
+		reg := &httpmock.Registry{}
+		if !tt.cancel {
+			tt.httpStubs(reg)
+			if tt.mockGistList {
+				sixHours, _ := time.ParseDuration("6h")
+				sixHoursAgo := time.Now().Add(-sixHours)
+				reg.Register(
+					httpmock.GraphQL(`query GistList\b`),
+					httpmock.StringResponse(fmt.Sprintf(
+						`{ "data": { "viewer": { "gists": { "nodes": [
+								{
+									"name": "1234",
+									"files": [{ "name": "cool.txt" }],
+									"description": "",
+									"updatedAt": "%s",
+									"isPublic": true
+								}
+							] } } } }`,
+						sixHoursAgo.Format(time.RFC3339),
+					)),
+				)
+
+				pm.RegisterSelect("Select a gist", []string{"cool.txt  about 6 hours ago"}, func(_, _ string, opts []string) (int, error) {
+					return 0, nil
+				})
+			}
 
-			pm.RegisterSelect("Select a gist", []string{"cool.txt  about 6 hours ago"}, func(_, _ string, opts []string) (int, error) {
-				return 0, nil
-			})
 		}
 		tt.opts.Prompter = pm
 
 		tt.opts.HttpClient = func() (*http.Client, error) {
 			return &http.Client{Transport: reg}, nil
 		}
+
 		tt.opts.Config = func() (gh.Config, error) {
 			return config.NewBlankConfig(), nil
 		}

From 8ad877b188762e7a613ddc68ce220f4e7144a856 Mon Sep 17 00:00:00 2001
From: Meredith Lancaster <malancas@github.com>
Date: Wed, 8 Jan 2025 08:38:43 -0700
Subject: [PATCH 41/68] add check for invalid attestation

Signed-off-by: Meredith Lancaster <malancas@github.com>
---
 pkg/cmd/attestation/api/client.go      |  5 +++++
 pkg/cmd/attestation/api/client_test.go | 14 ++++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/pkg/cmd/attestation/api/client.go b/pkg/cmd/attestation/api/client.go
index f8d0509ee..37579b7bc 100644
--- a/pkg/cmd/attestation/api/client.go
+++ b/pkg/cmd/attestation/api/client.go
@@ -172,6 +172,10 @@ func (c *LiveClient) fetchBundleFromAttestations(attestations []*Attestation) ([
 	g := errgroup.Group{}
 	for i, a := range attestations {
 		g.Go(func() error {
+			if a.Bundle == nil && a.BundleURL == "" {
+				return fmt.Errorf("attestation has no bundle or bundle URL")
+			}
+
 			// for now, we fallback to the bundle field if the bundle URL is empty
 			if a.BundleURL == "" {
 				c.logger.VerbosePrintf("Bundle URL is empty. Falling back to bundle field\n\n")
@@ -181,6 +185,7 @@ func (c *LiveClient) fetchBundleFromAttestations(attestations []*Attestation) ([
 				return nil
 			}
 
+			// otherwise fetch the bundle with the provided URL
 			b, err := c.GetBundle(a.BundleURL)
 			if err != nil {
 				return fmt.Errorf("failed to fetch bundle with URL: %w", err)
diff --git a/pkg/cmd/attestation/api/client_test.go b/pkg/cmd/attestation/api/client_test.go
index fcceb33d7..65f8d59ca 100644
--- a/pkg/cmd/attestation/api/client_test.go
+++ b/pkg/cmd/attestation/api/client_test.go
@@ -197,6 +197,20 @@ func TestFetchBundleFromAttestations(t *testing.T) {
 	httpClient.AssertNumberOfCalls(t, "OnGetSuccess", 2)
 }
 
+func TestFetchBundleFromAttestations_InvalidAttestation(t *testing.T) {
+	httpClient := &mockHttpClient{}
+	client := LiveClient{
+		httpClient: httpClient,
+		logger:     io.NewTestHandler(),
+	}
+
+	att1 := Attestation{}
+	attestations := []*Attestation{&att1}
+	fetched, err := client.fetchBundleFromAttestations(attestations)
+	require.Error(t, err)
+	require.Nil(t, fetched, 2)
+}
+
 func TestFetchBundleFromAttestations_Fail(t *testing.T) {
 	httpClient := &failAfterOneCallHttpClient{}
 

From 4575692ebfbde0bfb9827e0fffea7d0751d9744f Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Wed, 8 Jan 2025 10:36:45 -0800
Subject: [PATCH 42/68] Remove private readBranchConfig method and remove
 parseBranchConfig from Client

I think I went too far with my previous refactor and am backing out of it.
Adding a private readBranchConfig method on the client wasn't providing
any real additional value, so I've put it back into ReadBranchConfig.

However, I think there is still value in having parseBranchConfig
(formerly createBranchConfig) as a separate util function, as it both
improves readability of ReadBranchConfig and makes parsing its purpose
easier through the bespoke tests for it.
---
 git/client.go      | 21 ++++-------
 git/client_test.go | 86 ++++++++++++----------------------------------
 2 files changed, 28 insertions(+), 79 deletions(-)

diff --git a/git/client.go b/git/client.go
index 20a489a29..3cc53ca96 100644
--- a/git/client.go
+++ b/git/client.go
@@ -381,35 +381,26 @@ func (c *Client) lookupCommit(ctx context.Context, sha, format string) ([]byte,
 // Downstream consumers of ReadBranchConfig should consider the behavior they desire if this errors,
 // as an empty config is not necessarily breaking.
 func (c *Client) ReadBranchConfig(ctx context.Context, branch string) (BranchConfig, error) {
-	var cfg BranchConfig
 
-	branchConfigOutput, err := c.readGitBranchConfig(ctx, branch)
-	if err != nil {
-		return cfg, err
-	}
-
-	return c.createBranchConfig(branchConfigOutput), nil
-}
-
-func (c *Client) readGitBranchConfig(ctx context.Context, branch string) ([]string, error) {
 	prefix := regexp.QuoteMeta(fmt.Sprintf("branch.%s.", branch))
 	args := []string{"config", "--get-regexp", fmt.Sprintf("^%s(remote|merge|%s)$", prefix, MergeBaseConfig)}
 	cmd, err := c.Command(ctx, args...)
 	if err != nil {
-		return []string{}, err
+		return BranchConfig{}, err
 	}
 
 	out, err := cmd.Output()
 	if err != nil {
-		return []string{}, err
+		return BranchConfig{}, err
 	}
 
-	return outputLines(out), nil
+	return parseBranchConfig(outputLines(out)), nil
 }
 
-func (c *Client) createBranchConfig(gitBranchConfigOutput []string) BranchConfig {
+func parseBranchConfig(configLines []string) BranchConfig {
 	var cfg BranchConfig
-	for _, line := range gitBranchConfigOutput {
+
+	for _, line := range configLines {
 		parts := strings.SplitN(line, " ", 2)
 		if len(parts) < 2 {
 			continue
diff --git a/git/client_test.go b/git/client_test.go
index 0930a6f72..df9577946 100644
--- a/git/client_test.go
+++ b/git/client_test.go
@@ -730,14 +730,26 @@ func TestClientReadBranchConfig(t *testing.T) {
 		cmdExitStatus    int
 		cmdStdout        string
 		cmdStderr        string
-		wantCmdArgs      string
+		branch           string
 		wantBranchConfig BranchConfig
+		wantError        *GitError
 	}{
 		{
 			name:             "read branch config",
+			cmdExitStatus:    0,
 			cmdStdout:        "branch.trunk.remote origin\nbranch.trunk.merge refs/heads/trunk\nbranch.trunk.gh-merge-base trunk",
-			wantCmdArgs:      `path/to/git config --get-regexp ^branch\.trunk\.(remote|merge|gh-merge-base)$`,
+			branch:           "trunk",
 			wantBranchConfig: BranchConfig{RemoteName: "origin", MergeRef: "refs/heads/trunk", MergeBase: "trunk"},
+			wantError:        nil,
+		},
+		{
+			name:             "command error",
+			cmdExitStatus:    1,
+			cmdStdout:        "",
+			cmdStderr:        "git error message",
+			branch:           "trunk",
+			wantBranchConfig: BranchConfig{},
+			wantError:        &GitError{ExitCode: 1, Stderr: "git error message"},
 		},
 	}
 	for _, tt := range tests {
@@ -747,72 +759,19 @@ func TestClientReadBranchConfig(t *testing.T) {
 				GitPath:        "path/to/git",
 				commandContext: cmdCtx,
 			}
-			branchConfig, _ := client.ReadBranchConfig(context.Background(), "trunk")
-			assert.Equal(t, tt.wantCmdArgs, strings.Join(cmd.Args[3:], " "))
+			branchConfig, err := client.ReadBranchConfig(context.Background(), tt.branch)
+			wantCmdArgs := fmt.Sprintf("path/to/git config --get-regexp ^branch\\.%s\\.(remote|merge|gh-merge-base)$", tt.branch)
+			assert.Equal(t, wantCmdArgs, strings.Join(cmd.Args[3:], " "))
 			assert.Equal(t, tt.wantBranchConfig, branchConfig)
-		})
-	}
-}
-
-func Test_readGitBranchConfig(t *testing.T) {
-	tests := []struct {
-		name           string
-		branch         string
-		cmdExitStatus  int
-		cmdStdout      string
-		cmdStderr      string
-		expectedOutput []string
-		expectedError  *GitError
-	}{
-		{
-			name:          "read branch config",
-			branch:        "trunk",
-			cmdExitStatus: 0,
-			cmdStdout:     "branch.trunk.remote origin\nbranch.trunk.merge refs/heads/trunk\nbranch.trunk.gh-merge-base trunk",
-			expectedOutput: []string{
-				"branch.trunk.remote origin",
-				"branch.trunk.merge refs/heads/trunk",
-				"branch.trunk.gh-merge-base trunk"},
-			expectedError: nil,
-		},
-		{
-			name:           "command failure",
-			branch:         "trunk",
-			cmdExitStatus:  1,
-			cmdStderr:      "git error message",
-			expectedOutput: []string{},
-			expectedError: &GitError{
-				ExitCode: 1,
-				Stderr:   "git error message",
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			commandString := fmt.Sprintf("path/to/git config --get-regexp ^branch\\.%s\\.(remote|merge|gh-merge-base)$", tt.branch)
-			cmdCtx := createMockedCommandContext(t, map[args]commandResult{
-				args(commandString): {
-					ExitStatus: tt.cmdExitStatus,
-					Stdout:     tt.cmdStdout,
-					Stderr:     tt.cmdStderr,
-				},
-			})
-			client := Client{
-				GitPath:        "path/to/git",
-				commandContext: cmdCtx,
-			}
-
-			out, err := client.readGitBranchConfig(context.Background(), tt.branch)
-			assert.Equal(t, tt.expectedOutput, out)
-			if err != nil {
-				assert.Equal(t, tt.cmdStderr, err.(*GitError).Stderr)
-				assert.Equal(t, tt.cmdExitStatus, err.(*GitError).ExitCode)
+			if tt.wantError != nil {
+				assert.Equal(t, tt.wantError.ExitCode, err.(*GitError).ExitCode)
+				assert.Equal(t, tt.wantError.Stderr, err.(*GitError).Stderr)
 			}
 		})
 	}
 }
 
-func Test_createBranchConfig(t *testing.T) {
+func Test_parseBranchConfig(t *testing.T) {
 	tests := []struct {
 		name                  string
 		gitBranchConfigOutput []string
@@ -855,8 +814,7 @@ func Test_createBranchConfig(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			client := Client{}
-			branchConfig := client.createBranchConfig(tt.gitBranchConfigOutput)
+			branchConfig := parseBranchConfig(tt.gitBranchConfigOutput)
 			assert.Equal(t, tt.wantBranchConfig, branchConfig)
 		})
 	}

From fea46c00112cd39ddcc832c79d8c884fb5a045e5 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Wed, 8 Jan 2025 11:40:42 -0800
Subject: [PATCH 43/68] Change ReadBranchConfig error message in gh pr create

---
 pkg/cmd/pr/create/create.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pkg/cmd/pr/create/create.go b/pkg/cmd/pr/create/create.go
index 638d8eed4..b2229b976 100644
--- a/pkg/cmd/pr/create/create.go
+++ b/pkg/cmd/pr/create/create.go
@@ -683,7 +683,7 @@ func NewCreateContext(opts *CreateOptions) (*CreateContext, error) {
 	headBranchConfig, err := gitClient.ReadBranchConfig(context.Background(), headBranch)
 	if err != nil {
 		// We can still proceed without the branch config, so print to stderr but continue
-		fmt.Fprintf(opts.IO.ErrOut, "Error reading git branch config: %v\n", err)
+		fmt.Fprintf(opts.IO.ErrOut, "Unable to read git branch config: %v\n", err)
 	}
 	if isPushEnabled {
 		// determine whether the head branch is already pushed to a remote

From 527d1db29877fdf8665723cbe4c2668fb069dbe0 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Wed, 8 Jan 2025 14:24:20 -0800
Subject: [PATCH 44/68] Add missing test for RemoteURL in parseBranchConfig

---
 git/client_test.go | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/git/client_test.go b/git/client_test.go
index df9577946..5eb7f4585 100644
--- a/git/client_test.go
+++ b/git/client_test.go
@@ -6,6 +6,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"net/url"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -811,11 +812,32 @@ func Test_parseBranchConfig(t *testing.T) {
 				MergeBase:  "gh-merge-base",
 			},
 		},
+		{
+			name: "remote URL",
+			gitBranchConfigOutput: []string{
+				"branch.Frederick888/main.remote git@github.com:Frederick888/playground.git",
+				"branch.Frederick888/main.merge refs/heads/main",
+			},
+			wantBranchConfig: BranchConfig{
+				MergeRef: "refs/heads/main",
+				RemoteURL: &url.URL{
+					Scheme: "ssh",
+					User:   url.User("git"),
+					Host:   "github.com",
+					Path:   "/Frederick888/playground.git",
+				},
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			branchConfig := parseBranchConfig(tt.gitBranchConfigOutput)
-			assert.Equal(t, tt.wantBranchConfig, branchConfig)
+			assert.Equal(t, tt.wantBranchConfig.RemoteName, branchConfig.RemoteName)
+			assert.Equal(t, tt.wantBranchConfig.MergeRef, branchConfig.MergeRef)
+			assert.Equal(t, tt.wantBranchConfig.MergeBase, branchConfig.MergeBase)
+			if tt.wantBranchConfig.RemoteURL != nil {
+				assert.Equal(t, tt.wantBranchConfig.RemoteURL.String(), branchConfig.RemoteURL.String())
+			}
 		})
 	}
 }

From ec9eaef048362eec8d620f8416b4b256d0d4e9d2 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Wed, 8 Jan 2025 14:27:41 -0800
Subject: [PATCH 45/68] Refactor prSelectorForCurrentBranch and tests

Replace the git config argument in prSelectorForCurrentBranch with
the branchConfig it was used to fetch. The tests needed to be refactored
accordingly to support this change to the prSelectorForCurrentBranch API.
In addition, I've moved the test to a table test format so I can expand
the test coverage in the next commit.
---
 pkg/cmd/pr/status/status.go      | 13 +++---
 pkg/cmd/pr/status/status_test.go | 68 ++++++++++++++++++++------------
 2 files changed, 51 insertions(+), 30 deletions(-)

diff --git a/pkg/cmd/pr/status/status.go b/pkg/cmd/pr/status/status.go
index 9245b1cdc..499202b7e 100644
--- a/pkg/cmd/pr/status/status.go
+++ b/pkg/cmd/pr/status/status.go
@@ -72,6 +72,7 @@ func NewCmdStatus(f *cmdutil.Factory, runF func(*StatusOptions) error) *cobra.Co
 }
 
 func statusRun(opts *StatusOptions) error {
+	ctx := context.Background()
 	httpClient, err := opts.HttpClient()
 	if err != nil {
 		return err
@@ -93,7 +94,8 @@ func statusRun(opts *StatusOptions) error {
 		}
 
 		remotes, _ := opts.Remotes()
-		currentPRNumber, currentPRHeadRef, err = prSelectorForCurrentBranch(opts.GitClient, baseRepo, currentBranch, remotes)
+		branchConfig, _ := opts.GitClient.ReadBranchConfig(ctx, currentBranch)
+		currentPRNumber, currentPRHeadRef, err = prSelectorForCurrentBranch(branchConfig, baseRepo, currentBranch, remotes)
 		if err != nil {
 			return fmt.Errorf("could not query for pull request for current branch: %w", err)
 		}
@@ -184,14 +186,15 @@ func statusRun(opts *StatusOptions) error {
 	return nil
 }
 
-func prSelectorForCurrentBranch(gitClient *git.Client, baseRepo ghrepo.Interface, prHeadRef string, rem ghContext.Remotes) (int, string, error) {
-	branchConfig, _ := gitClient.ReadBranchConfig(context.Background(), prHeadRef)
-
+func prSelectorForCurrentBranch(branchConfig git.BranchConfig, baseRepo ghrepo.Interface, prHeadRef string, rem ghContext.Remotes) (int, string, error) {
 	// the branch is configured to merge a special PR head ref
 	prHeadRE := regexp.MustCompile(`^refs/pull/(\d+)/head$`)
 	if m := prHeadRE.FindStringSubmatch(branchConfig.MergeRef); m != nil {
 		prNumber, err := strconv.Atoi(m[1])
-		return prNumber, prHeadRef, err
+		if err != nil {
+			return 0, "", err
+		}
+		return prNumber, prHeadRef, nil
 	}
 
 	var err error
diff --git a/pkg/cmd/pr/status/status_test.go b/pkg/cmd/pr/status/status_test.go
index e8e487559..6e2cf71f9 100644
--- a/pkg/cmd/pr/status/status_test.go
+++ b/pkg/cmd/pr/status/status_test.go
@@ -4,23 +4,23 @@ import (
 	"bytes"
 	"io"
 	"net/http"
+	"net/url"
 	"regexp"
 	"strings"
 	"testing"
 
-	"github.com/MakeNowJust/heredoc"
 	"github.com/cli/cli/v2/context"
 	"github.com/cli/cli/v2/git"
 	"github.com/cli/cli/v2/internal/config"
 	fd "github.com/cli/cli/v2/internal/featuredetection"
 	"github.com/cli/cli/v2/internal/gh"
 	"github.com/cli/cli/v2/internal/ghrepo"
-	"github.com/cli/cli/v2/internal/run"
 	"github.com/cli/cli/v2/pkg/cmdutil"
 	"github.com/cli/cli/v2/pkg/httpmock"
 	"github.com/cli/cli/v2/pkg/iostreams"
 	"github.com/cli/cli/v2/test"
 	"github.com/google/shlex"
+	"github.com/stretchr/testify/assert"
 )
 
 func runCommand(rt http.RoundTripper, branch string, isTTY bool, cli string) (*test.CmdOut, error) {
@@ -376,30 +376,48 @@ Requesting a code review from you
 }
 
 func Test_prSelectorForCurrentBranch(t *testing.T) {
-	rs, cleanup := run.Stub()
-	defer cleanup(t)
-
-	rs.Register(`git config --get-regexp \^branch\\.`, 0, heredoc.Doc(`
-		branch.Frederick888/main.remote git@github.com:Frederick888/playground.git
-		branch.Frederick888/main.merge refs/heads/main
-	`))
-
-	repo := ghrepo.NewWithHost("octocat", "playground", "github.com")
-	rem := context.Remotes{
-		&context.Remote{
-			Remote: &git.Remote{Name: "origin"},
-			Repo:   repo,
+	tests := []struct {
+		name         string
+		branchConfig git.BranchConfig
+		baseRepo     ghrepo.Interface
+		prHeadRef    string
+		remotes      context.Remotes
+		wantPrNumber int
+		wantSelector string
+		wantError    error
+	}{
+		{
+			name: "Branch merges from a remote specified by URL",
+			branchConfig: git.BranchConfig{
+				RemoteURL: &url.URL{
+					Scheme: "ssh",
+					User:   url.User("git"),
+					Host:   "github.com",
+					Path:   "Frederick888/playground.git",
+				},
+				MergeRef: "refs/heads/main",
+			},
+			baseRepo:  ghrepo.NewWithHost("octocat", "playground", "github.com"),
+			prHeadRef: "Frederick888/main",
+			remotes: context.Remotes{
+				&context.Remote{
+					Remote: &git.Remote{Name: "origin"},
+					Repo:   ghrepo.NewWithHost("octocat", "playground", "github.com"),
+				},
+			},
+			wantPrNumber: 0,
+			wantSelector: "Frederick888:main",
+			wantError:    nil,
 		},
 	}
-	gitClient := &git.Client{GitPath: "some/path/git"}
-	prNum, headRef, err := prSelectorForCurrentBranch(gitClient, repo, "Frederick888/main", rem)
-	if err != nil {
-		t.Fatalf("prSelectorForCurrentBranch error: %v", err)
-	}
-	if prNum != 0 {
-		t.Errorf("expected prNum to be 0, got %q", prNum)
-	}
-	if headRef != "Frederick888:main" {
-		t.Errorf("expected headRef to be \"Frederick888:main\", got %q", headRef)
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+
+			prNum, headRef, err := prSelectorForCurrentBranch(tt.branchConfig, tt.baseRepo, tt.prHeadRef, tt.remotes)
+			assert.Equal(t, tt.wantPrNumber, prNum)
+			assert.Equal(t, tt.wantSelector, headRef)
+			assert.Equal(t, tt.wantError, err)
+		})
 	}
 }

From 94b2d4ec3b0076cf33d4ec5d1ddbe9563299e988 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Wed, 8 Jan 2025 15:00:38 -0800
Subject: [PATCH 46/68] Added tests to cover prSelectorForCurrentBranch for
 confidence in refactor

---
 pkg/cmd/pr/status/status_test.go | 126 ++++++++++++++++++++++++++++++-
 1 file changed, 122 insertions(+), 4 deletions(-)

diff --git a/pkg/cmd/pr/status/status_test.go b/pkg/cmd/pr/status/status_test.go
index 6e2cf71f9..9f3079957 100644
--- a/pkg/cmd/pr/status/status_test.go
+++ b/pkg/cmd/pr/status/status_test.go
@@ -386,6 +386,16 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 		wantSelector string
 		wantError    error
 	}{
+		{
+			name: "The branch is configured to merge a special PR head ref",
+			branchConfig: git.BranchConfig{
+				MergeRef: "refs/pull/666/head",
+			},
+			prHeadRef:    "Frederick888/main",
+			wantPrNumber: 666,
+			wantSelector: "Frederick888/main",
+			wantError:    nil,
+		},
 		{
 			name: "Branch merges from a remote specified by URL",
 			branchConfig: git.BranchConfig{
@@ -395,18 +405,126 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 					Host:   "github.com",
 					Path:   "Frederick888/playground.git",
 				},
-				MergeRef: "refs/heads/main",
 			},
-			baseRepo:  ghrepo.NewWithHost("octocat", "playground", "github.com"),
+			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
 			prHeadRef: "Frederick888/main",
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "origin"},
-					Repo:   ghrepo.NewWithHost("octocat", "playground", "github.com"),
+					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
 				},
 			},
 			wantPrNumber: 0,
-			wantSelector: "Frederick888:main",
+			wantSelector: "Frederick888/main",
+			wantError:    nil,
+		},
+		{
+			name: "Branch merges from a remote specified by name",
+			branchConfig: git.BranchConfig{
+				RemoteName: "upstream",
+			},
+			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+			prHeadRef: "Frederick888/main",
+			remotes: context.Remotes{
+				&context.Remote{
+					Remote: &git.Remote{Name: "origin"},
+					Repo:   ghrepo.NewWithHost("forkName", "playground", "github.com"),
+				},
+				&context.Remote{
+					Remote: &git.Remote{Name: "upstream"},
+					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+				},
+			},
+			wantPrNumber: 0,
+			wantSelector: "Frederick888/main",
+			wantError:    nil,
+		},
+		{
+			name: "Branch is a fork and merges from a remote specified by URL",
+			branchConfig: git.BranchConfig{
+				RemoteURL: &url.URL{
+					Scheme: "ssh",
+					User:   url.User("git"),
+					Host:   "github.com",
+					Path:   "forkName/playground.git",
+				},
+				MergeRef: "refs/heads/main",
+			},
+			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+			prHeadRef: "Frederick888/main",
+			remotes: context.Remotes{
+				&context.Remote{
+					Remote: &git.Remote{Name: "origin"},
+					Repo:   ghrepo.NewWithHost("forkName", "playground", "github.com"),
+				},
+			},
+			wantPrNumber: 0,
+			wantSelector: "forkName:main",
+			wantError:    nil,
+		},
+		{
+			name: "Branch is a fork and merges from a remote specified by name",
+			branchConfig: git.BranchConfig{
+				RemoteName: "origin",
+			},
+			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+			prHeadRef: "Frederick888/main",
+			remotes: context.Remotes{
+				&context.Remote{
+					Remote: &git.Remote{Name: "origin"},
+					Repo:   ghrepo.NewWithHost("forkName", "playground", "github.com"),
+				},
+				&context.Remote{
+					Remote: &git.Remote{Name: "upstream"},
+					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+				},
+			},
+			wantPrNumber: 0,
+			wantSelector: "forkName:Frederick888/main",
+			wantError:    nil,
+		},
+		{
+			name: "Branch specifies a mergeRef and merges from a remote specified by name",
+			branchConfig: git.BranchConfig{
+				RemoteName: "upstream",
+				MergeRef:   "refs/heads/main",
+			},
+			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+			prHeadRef: "Frederick888/main",
+			remotes: context.Remotes{
+				&context.Remote{
+					Remote: &git.Remote{Name: "origin"},
+					Repo:   ghrepo.NewWithHost("forkName", "playground", "github.com"),
+				},
+				&context.Remote{
+					Remote: &git.Remote{Name: "upstream"},
+					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+				},
+			},
+			wantPrNumber: 0,
+			wantSelector: "main",
+			wantError:    nil,
+		},
+		{
+			name: "Branch is a fork, specifies a mergeRef, and merges from a remote specified by name",
+			branchConfig: git.BranchConfig{
+				RemoteName: "origin",
+				MergeRef:   "refs/heads/main",
+			},
+			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+			prHeadRef: "Frederick888/main",
+			remotes: context.Remotes{
+				&context.Remote{
+					Remote: &git.Remote{Name: "origin"},
+					Repo:   ghrepo.NewWithHost("forkName", "playground", "github.com"),
+				},
+				&context.Remote{
+					Remote: &git.Remote{Name: "upstream"},
+					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+				},
+			},
+			wantPrNumber: 0,
+			wantSelector: "forkName:main",
 			wantError:    nil,
 		},
 	}

From 15ac56622212b5dac30d4b02dfbe9debf5d1e094 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Wed, 8 Jan 2025 15:20:17 -0800
Subject: [PATCH 47/68] Remove shadowed errors from prSelectorForCurrentBranch
 and cover with tests

---
 pkg/cmd/pr/status/status.go      | 15 +++++++------
 pkg/cmd/pr/status/status_test.go | 36 ++++++++++++++++++++++++++++++++
 2 files changed, 45 insertions(+), 6 deletions(-)

diff --git a/pkg/cmd/pr/status/status.go b/pkg/cmd/pr/status/status.go
index 499202b7e..e97770ce4 100644
--- a/pkg/cmd/pr/status/status.go
+++ b/pkg/cmd/pr/status/status.go
@@ -197,18 +197,21 @@ func prSelectorForCurrentBranch(branchConfig git.BranchConfig, baseRepo ghrepo.I
 		return prNumber, prHeadRef, nil
 	}
 
-	var err error
 	var branchOwner string
 	if branchConfig.RemoteURL != nil {
 		// the branch merges from a remote specified by URL
-		if r, err := ghrepo.FromURL(branchConfig.RemoteURL); err == nil {
-			branchOwner = r.RepoOwner()
+		r, err := ghrepo.FromURL(branchConfig.RemoteURL)
+		if err != nil {
+			return 0, prHeadRef, err
 		}
+		branchOwner = r.RepoOwner()
 	} else if branchConfig.RemoteName != "" {
 		// the branch merges from a remote specified by name
-		if r, err := rem.FindByName(branchConfig.RemoteName); err == nil {
-			branchOwner = r.RepoOwner()
+		r, err := rem.FindByName(branchConfig.RemoteName)
+		if err != nil {
+			return 0, prHeadRef, err
 		}
+		branchOwner = r.RepoOwner()
 	}
 
 	selector := prHeadRef
@@ -222,7 +225,7 @@ func prSelectorForCurrentBranch(branchConfig git.BranchConfig, baseRepo ghrepo.I
 		}
 	}
 
-	return 0, selector, err
+	return 0, selector, nil
 }
 
 func totalApprovals(pr *api.PullRequest) int {
diff --git a/pkg/cmd/pr/status/status_test.go b/pkg/cmd/pr/status/status_test.go
index 9f3079957..94505aaba 100644
--- a/pkg/cmd/pr/status/status_test.go
+++ b/pkg/cmd/pr/status/status_test.go
@@ -2,6 +2,7 @@ package status
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"net/http"
 	"net/url"
@@ -527,6 +528,41 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 			wantSelector: "forkName:main",
 			wantError:    nil,
 		},
+		{
+			name: "Remote URL error",
+			branchConfig: git.BranchConfig{
+				RemoteURL: &url.URL{
+					Scheme: "ssh",
+					User:   url.User("git"),
+					Host:   "github.com",
+					Path:   "/\\invalid?Path/",
+				},
+			},
+			prHeadRef:    "Frederick888/main",
+			wantPrNumber: 0,
+			wantSelector: "Frederick888/main",
+			wantError:    fmt.Errorf("invalid path: /\\invalid?Path/"),
+		},
+		{
+			name: "Remote Name error",
+			branchConfig: git.BranchConfig{
+				RemoteName: "nonexistentRemote",
+			},
+			prHeadRef: "Frederick888/main",
+			remotes: context.Remotes{
+				&context.Remote{
+					Remote: &git.Remote{Name: "origin"},
+					Repo:   ghrepo.NewWithHost("forkName", "playground", "github.com"),
+				},
+				&context.Remote{
+					Remote: &git.Remote{Name: "upstream"},
+					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+				},
+			},
+			wantPrNumber: 0,
+			wantSelector: "Frederick888/main",
+			wantError:    fmt.Errorf("no matching remote found"),
+		},
 	}
 
 	for _, tt := range tests {

From 9c65a32ef86343786ec1fa4ef81de0fce412ff1b Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Wed, 8 Jan 2025 17:56:02 -0600
Subject: [PATCH 48/68] gist delete prompt with gist description

---
 pkg/cmd/gist/delete/delete.go      | 39 ++++++++++++++++--------------
 pkg/cmd/gist/delete/delete_test.go | 29 ++++++++++++++++++++--
 pkg/cmd/gist/edit/edit.go          |  5 ++--
 pkg/cmd/gist/shared/shared.go      | 19 +++++++--------
 pkg/cmd/gist/shared/shared_test.go | 30 +++++++++++------------
 pkg/cmd/gist/view/view.go          |  5 ++--
 6 files changed, 78 insertions(+), 49 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete.go b/pkg/cmd/gist/delete/delete.go
index a2b552a3a..c39538d4a 100644
--- a/pkg/cmd/gist/delete/delete.go
+++ b/pkg/cmd/gist/delete/delete.go
@@ -76,15 +76,6 @@ func NewCmdDelete(f *cmdutil.Factory, runF func(*DeleteOptions) error) *cobra.Co
 }
 
 func deleteRun(opts *DeleteOptions) error {
-	gistID := opts.Selector
-
-	if strings.Contains(gistID, "/") {
-		id, err := shared.GistIDFromURL(gistID)
-		if err != nil {
-			return err
-		}
-		gistID = id
-	}
 	client, err := opts.HttpClient()
 	if err != nil {
 		return err
@@ -97,16 +88,28 @@ func deleteRun(opts *DeleteOptions) error {
 
 	host, _ := cfg.Authentication().DefaultHost()
 
-	cs := opts.IO.ColorScheme()
-	if gistID == "" {
-		gistID, err = shared.PromptGists(opts.Prompter, client, host, cs)
+	gistID := opts.Selector
+	if strings.Contains(gistID, "/") {
+		id, err := shared.GistIDFromURL(gistID)
 		if err != nil {
 			return err
 		}
+		gistID = id
+	}
+
+	cs := opts.IO.ColorScheme()
+	var gist *shared.Gist
+	if gistID == "" {
+		gist, err = shared.PromptGists(opts.Prompter, client, host, cs)
+	} else {
+		gist, err = shared.GetGist(client, host, gistID)
+	}
+	if err != nil {
+		return err
 	}
 
 	if !opts.Confirmed {
-		confirmed, err := opts.Prompter.Confirm(fmt.Sprintf("Delete \"%s\" gist?", gistID), false)
+		confirmed, err := opts.Prompter.Confirm(fmt.Sprintf("Delete \"%s\" gist?", gist.Description), false)
 		if err != nil {
 			return err
 		}
@@ -116,9 +119,9 @@ func deleteRun(opts *DeleteOptions) error {
 	}
 
 	apiClient := api.NewClientFromHTTP(client)
-	if err := deleteGist(apiClient, host, gistID, opts); err != nil {
+	if err := deleteGist(apiClient, host, gist, opts); err != nil {
 		if errors.Is(err, shared.NotFoundErr) {
-			return fmt.Errorf("unable to delete gist %s: either the gist is not found or it is not owned by you", gistID)
+			return fmt.Errorf("unable to delete gist %s: either the gist is not found or it is not owned by you", gist.Description)
 		}
 		return err
 	}
@@ -126,8 +129,8 @@ func deleteRun(opts *DeleteOptions) error {
 	return nil
 }
 
-func deleteGist(apiClient *api.Client, hostname string, gistID string, opts *DeleteOptions) error {
-	path := "gists/" + gistID
+func deleteGist(apiClient *api.Client, hostname string, gist *shared.Gist, opts *DeleteOptions) error {
+	path := "gists/" + gist.ID
 	err := apiClient.REST(hostname, "DELETE", path, nil, nil)
 	if err != nil {
 		var httpErr api.HTTPError
@@ -141,7 +144,7 @@ func deleteGist(apiClient *api.Client, hostname string, gistID string, opts *Del
 		fmt.Fprintf(opts.IO.Out,
 			"%s Gist \"%s\" deleted\n",
 			cs.SuccessIcon(),
-			gistID)
+			gist.Description)
 	}
 	return nil
 }
diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index 237e3f768..010f65d5e 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -10,6 +10,7 @@ import (
 	"github.com/cli/cli/v2/internal/config"
 	"github.com/cli/cli/v2/internal/gh"
 	"github.com/cli/cli/v2/internal/prompter"
+	"github.com/cli/cli/v2/pkg/cmd/gist/shared"
 	"github.com/cli/cli/v2/pkg/cmdutil"
 	"github.com/cli/cli/v2/pkg/httpmock"
 	"github.com/cli/cli/v2/pkg/iostreams"
@@ -131,6 +132,8 @@ func Test_deleteRun(t *testing.T) {
 				Selector: "1234",
 			},
 			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(httpmock.REST("GET", "gists/1234"),
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "1234"}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
@@ -159,6 +162,8 @@ func Test_deleteRun(t *testing.T) {
 				Confirmed: true,
 			},
 			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(httpmock.REST("GET", "gists/1234"),
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "1234"}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
@@ -186,6 +191,24 @@ func Test_deleteRun(t *testing.T) {
 			opts: &DeleteOptions{
 				Selector: "1234",
 			},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(httpmock.REST("GET", "gists/1234"),
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "1234"}))
+			},
+			cancel:     true,
+			wantErr:    true,
+			wantStdout: "",
+			wantStderr: "",
+		},
+		{
+			name: "cancel delete with url",
+			opts: &DeleteOptions{
+				Selector: "https://gist.github.com/myrepo/1234",
+			},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(httpmock.REST("GET", "gists/1234"),
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "1234"}))
+			},
 			cancel:     true,
 			wantErr:    true,
 			wantStdout: "",
@@ -207,6 +230,8 @@ func Test_deleteRun(t *testing.T) {
 				Selector: "1234",
 			},
 			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(httpmock.REST("GET", "gists/1234"),
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "1234"}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(404, "{}"))
 			},
@@ -237,7 +262,7 @@ func Test_deleteRun(t *testing.T) {
 								{
 									"name": "1234",
 									"files": [{ "name": "cool.txt" }],
-									"description": "",
+									"description": "1234",
 									"updatedAt": "%s",
 									"isPublic": true
 								}
@@ -246,7 +271,7 @@ func Test_deleteRun(t *testing.T) {
 					)),
 				)
 
-				pm.RegisterSelect("Select a gist", []string{"cool.txt  about 6 hours ago"}, func(_, _ string, opts []string) (int, error) {
+				pm.RegisterSelect("Select a gist", []string{"cool.txt 1234 about 6 hours ago"}, func(_, _ string, opts []string) (int, error) {
 					return 0, nil
 				})
 			}
diff --git a/pkg/cmd/gist/edit/edit.go b/pkg/cmd/gist/edit/edit.go
index d777e9581..1e9b61825 100644
--- a/pkg/cmd/gist/edit/edit.go
+++ b/pkg/cmd/gist/edit/edit.go
@@ -108,15 +108,16 @@ func editRun(opts *EditOptions) error {
 	if gistID == "" {
 		cs := opts.IO.ColorScheme()
 		if gistID == "" {
-			gistID, err = shared.PromptGists(opts.Prompter, client, host, cs)
+			gist, err := shared.PromptGists(opts.Prompter, client, host, cs)
 			if err != nil {
 				return err
 			}
 
-			if gistID == "" {
+			if gist.ID == "" {
 				fmt.Fprintln(opts.IO.Out, "No gists found.")
 				return nil
 			}
+			gistID = gist.ID
 		}
 	}
 
diff --git a/pkg/cmd/gist/shared/shared.go b/pkg/cmd/gist/shared/shared.go
index ee6dcf1e3..fa528698f 100644
--- a/pkg/cmd/gist/shared/shared.go
+++ b/pkg/cmd/gist/shared/shared.go
@@ -202,21 +202,20 @@ func IsBinaryContents(contents []byte) bool {
 	return isBinary
 }
 
-func PromptGists(prompter prompter.Prompter, client *http.Client, host string, cs *iostreams.ColorScheme) (gistID string, err error) {
+func PromptGists(prompter prompter.Prompter, client *http.Client, host string, cs *iostreams.ColorScheme) (gist *Gist, err error) {
 	gists, err := ListGists(client, host, 10, nil, false, "all")
 	if err != nil {
-		return "", err
+		return &Gist{}, err
 	}
 
 	if len(gists) == 0 {
-		return "", nil
+		return &Gist{}, nil
 	}
 
-	var opts []string
-	var gistIDs = make([]string, len(gists))
+	// var opts []string
+	var opts = make([]string, len(gists))
 
 	for i, gist := range gists {
-		gistIDs[i] = gist.ID
 		description := ""
 		gistName := ""
 
@@ -234,15 +233,15 @@ func PromptGists(prompter prompter.Prompter, client *http.Client, host string, c
 		gistTime := text.FuzzyAgo(time.Now(), gist.UpdatedAt)
 		// TODO: support dynamic maxWidth
 		description = text.Truncate(100, text.RemoveExcessiveWhitespace(description))
-		opt := fmt.Sprintf("%s %s %s", cs.Bold(gistName), description, cs.Gray(gistTime))
-		opts = append(opts, opt)
+		opts[i] = fmt.Sprintf("%s %s %s", cs.Bold(gistName), description, cs.Gray(gistTime))
+		// opts = append(opts, opt)
 	}
 
 	result, err := prompter.Select("Select a gist", "", opts)
 
 	if err != nil {
-		return "", err
+		return &Gist{}, err
 	}
 
-	return gistIDs[result], nil
+	return &gists[result], nil
 }
diff --git a/pkg/cmd/gist/shared/shared_test.go b/pkg/cmd/gist/shared/shared_test.go
index 4d185ff7d..15b14a939 100644
--- a/pkg/cmd/gist/shared/shared_test.go
+++ b/pkg/cmd/gist/shared/shared_test.go
@@ -93,12 +93,15 @@ func TestIsBinaryContents(t *testing.T) {
 }
 
 func TestPromptGists(t *testing.T) {
+	sixHours, _ := time.ParseDuration("6h")
+	sixHoursAgo := time.Now().Add(-sixHours)
+	sixHoursAgoFormatted := sixHoursAgo.Format(time.RFC3339Nano)
+
 	tests := []struct {
 		name          string
 		prompterStubs func(pm *prompter.MockPrompter)
 		response      string
-		wantOut       string
-		gist          *Gist
+		wantOut       Gist
 		wantErr       bool
 	}{
 		{
@@ -112,21 +115,21 @@ func TestPromptGists(t *testing.T) {
 			},
 			response: `{ "data": { "viewer": { "gists": { "nodes": [
 							{
-								"name": "gistid1",
+								"name": "1234",
 								"files": [{ "name": "cool.txt" }],
 								"description": "",
 								"updatedAt": "%[1]v",
 								"isPublic": true
 							},
 							{
-								"name": "gistid2",
+								"name": "5678",
 								"files": [{ "name": "gistfile0.txt" }],
 								"description": "",
 								"updatedAt": "%[1]v",
 								"isPublic": true
 							}
 						] } } } }`,
-			wantOut: "gistid1",
+			wantOut: Gist{ID: "1234", Files: map[string]*GistFile{"cool.txt": {Filename: "cool.txt"}}, UpdatedAt: sixHoursAgo, Public: true},
 		},
 		{
 			name: "multiple files, select second gist",
@@ -139,26 +142,26 @@ func TestPromptGists(t *testing.T) {
 			},
 			response: `{ "data": { "viewer": { "gists": { "nodes": [
 							{
-								"name": "gistid1",
+								"name": "1234",
 								"files": [{ "name": "cool.txt" }],
 								"description": "",
 								"updatedAt": "%[1]v",
 								"isPublic": true
 							},
 							{
-								"name": "gistid2",
+								"name": "5678",
 								"files": [{ "name": "gistfile0.txt" }],
 								"description": "",
 								"updatedAt": "%[1]v",
 								"isPublic": true
 							}
 						] } } } }`,
-			wantOut: "gistid2",
+			wantOut: Gist{ID: "5678", Files: map[string]*GistFile{"gistfile0.txt": {Filename: "gistfile0.txt"}}, UpdatedAt: sixHoursAgo, Public: true},
 		},
 		{
 			name:     "no files",
 			response: `{ "data": { "viewer": { "gists": { "nodes": [] } } } }`,
-			wantOut:  "",
+			wantOut:  Gist{},
 		},
 	}
 
@@ -166,15 +169,12 @@ func TestPromptGists(t *testing.T) {
 
 	for _, tt := range tests {
 		reg := &httpmock.Registry{}
-
 		const query = `query GistList\b`
-		sixHours, _ := time.ParseDuration("6h")
-		sixHoursAgo := time.Now().Add(-sixHours)
 		reg.Register(
 			httpmock.GraphQL(query),
 			httpmock.StringResponse(fmt.Sprintf(
 				tt.response,
-				sixHoursAgo.Format(time.RFC3339),
+				sixHoursAgoFormatted,
 			)),
 		)
 		client := &http.Client{Transport: reg}
@@ -185,9 +185,9 @@ func TestPromptGists(t *testing.T) {
 				tt.prompterStubs(mockPrompter)
 			}
 
-			gistID, err := PromptGists(mockPrompter, client, "github.com", ios.ColorScheme())
+			gist, err := PromptGists(mockPrompter, client, "github.com", ios.ColorScheme())
 			assert.NoError(t, err)
-			assert.Equal(t, tt.wantOut, gistID)
+			assert.Equal(t, tt.wantOut.ID, gist.ID)
 			reg.Verify(t)
 		})
 	}
diff --git a/pkg/cmd/gist/view/view.go b/pkg/cmd/gist/view/view.go
index 2a19f5958..adfe77f6f 100644
--- a/pkg/cmd/gist/view/view.go
+++ b/pkg/cmd/gist/view/view.go
@@ -89,15 +89,16 @@ func viewRun(opts *ViewOptions) error {
 
 	cs := opts.IO.ColorScheme()
 	if gistID == "" {
-		gistID, err = shared.PromptGists(opts.Prompter, client, hostname, cs)
+		gist, err := shared.PromptGists(opts.Prompter, client, hostname, cs)
 		if err != nil {
 			return err
 		}
 
-		if gistID == "" {
+		if gist.ID == "" {
 			fmt.Fprintln(opts.IO.Out, "No gists found.")
 			return nil
 		}
+		gistID = gist.ID
 	}
 
 	if opts.Web {

From dccbc99fdfd94b4e179e8367e7e2dc3f009f5b99 Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Wed, 8 Jan 2025 20:47:50 -0600
Subject: [PATCH 49/68] fix gist description in tests

---
 pkg/cmd/gist/delete/delete.go      |  2 +-
 pkg/cmd/gist/delete/delete_test.go | 26 +++++++++++++-------------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete.go b/pkg/cmd/gist/delete/delete.go
index c39538d4a..9a77fe1f2 100644
--- a/pkg/cmd/gist/delete/delete.go
+++ b/pkg/cmd/gist/delete/delete.go
@@ -121,7 +121,7 @@ func deleteRun(opts *DeleteOptions) error {
 	apiClient := api.NewClientFromHTTP(client)
 	if err := deleteGist(apiClient, host, gist, opts); err != nil {
 		if errors.Is(err, shared.NotFoundErr) {
-			return fmt.Errorf("unable to delete gist %s: either the gist is not found or it is not owned by you", gist.Description)
+			return fmt.Errorf("unable to delete gist \"%s\": either the gist is not found or it is not owned by you", gist.Description)
 		}
 		return err
 	}
diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index 010f65d5e..d4ec36a0c 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -133,12 +133,12 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "1234"}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text"}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			wantErr:    false,
-			wantStdout: "✓ Gist \"1234\" deleted\n",
+			wantStdout: "✓ Gist \"my cool text\" deleted\n",
 			wantStderr: "",
 		},
 		{
@@ -152,7 +152,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			mockGistList: true,
 			wantErr:      false,
-			wantStdout:   "✓ Gist \"1234\" deleted\n",
+			wantStdout:   "✓ Gist \"my cool text\" deleted\n",
 			wantStderr:   "",
 		},
 		{
@@ -163,12 +163,12 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "1234"}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text"}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			wantErr:    false,
-			wantStdout: "✓ Gist \"1234\" deleted\n",
+			wantStdout: "✓ Gist \"my cool text\" deleted\n",
 			wantStderr: "",
 		},
 		{
@@ -183,7 +183,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			mockGistList: true,
 			wantErr:      false,
-			wantStdout:   "✓ Gist \"1234\" deleted\n",
+			wantStdout:   "✓ Gist \"my cool text\" deleted\n",
 			wantStderr:   "",
 		},
 		{
@@ -193,7 +193,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "1234"}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text"}))
 			},
 			cancel:     true,
 			wantErr:    true,
@@ -207,7 +207,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "1234"}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text"}))
 			},
 			cancel:     true,
 			wantErr:    true,
@@ -231,20 +231,20 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "1234"}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text"}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(404, "{}"))
 			},
 			wantErr:    true,
 			wantStdout: "",
-			wantStderr: "unable to delete gist 1234: either the gist is not found or it is not owned by you",
+			wantStderr: "unable to delete gist \"my cool text\": either the gist is not found or it is not owned by you",
 		},
 	}
 
 	for _, tt := range tests {
 		pm := prompter.NewMockPrompter(t)
 		if !tt.opts.Confirmed {
-			pm.RegisterConfirm("Delete \"1234\" gist?", func(_ string, _ bool) (bool, error) {
+			pm.RegisterConfirm("Delete \"my cool text\" gist?", func(_ string, _ bool) (bool, error) {
 				return !tt.cancel, nil
 			})
 		}
@@ -262,7 +262,7 @@ func Test_deleteRun(t *testing.T) {
 								{
 									"name": "1234",
 									"files": [{ "name": "cool.txt" }],
-									"description": "1234",
+									"description": "my cool text",
 									"updatedAt": "%s",
 									"isPublic": true
 								}
@@ -271,7 +271,7 @@ func Test_deleteRun(t *testing.T) {
 					)),
 				)
 
-				pm.RegisterSelect("Select a gist", []string{"cool.txt 1234 about 6 hours ago"}, func(_, _ string, opts []string) (int, error) {
+				pm.RegisterSelect("Select a gist", []string{"cool.txt my cool text about 6 hours ago"}, func(_, _ string, opts []string) (int, error) {
 					return 0, nil
 				})
 			}

From d4f7576e8baaccfdd3f7e9c4418151294d67733c Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Thu, 9 Jan 2025 09:01:14 -0800
Subject: [PATCH 50/68] Add test for empty BranchConfig in
 prSelectorForCurrentBranch

---
 pkg/cmd/pr/status/status.go      | 5 +++--
 pkg/cmd/pr/status/status_test.go | 8 ++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/pkg/cmd/pr/status/status.go b/pkg/cmd/pr/status/status.go
index e97770ce4..c15c0f7fd 100644
--- a/pkg/cmd/pr/status/status.go
+++ b/pkg/cmd/pr/status/status.go
@@ -214,8 +214,8 @@ func prSelectorForCurrentBranch(branchConfig git.BranchConfig, baseRepo ghrepo.I
 		branchOwner = r.RepoOwner()
 	}
 
-	selector := prHeadRef
 	if branchOwner != "" {
+		selector := prHeadRef
 		if strings.HasPrefix(branchConfig.MergeRef, "refs/heads/") {
 			selector = strings.TrimPrefix(branchConfig.MergeRef, "refs/heads/")
 		}
@@ -223,9 +223,10 @@ func prSelectorForCurrentBranch(branchConfig git.BranchConfig, baseRepo ghrepo.I
 		if !strings.EqualFold(branchOwner, baseRepo.RepoOwner()) {
 			selector = fmt.Sprintf("%s:%s", branchOwner, selector)
 		}
+		return 0, selector, nil
 	}
 
-	return 0, selector, nil
+	return 0, prHeadRef, nil
 }
 
 func totalApprovals(pr *api.PullRequest) int {
diff --git a/pkg/cmd/pr/status/status_test.go b/pkg/cmd/pr/status/status_test.go
index 94505aaba..431312155 100644
--- a/pkg/cmd/pr/status/status_test.go
+++ b/pkg/cmd/pr/status/status_test.go
@@ -387,6 +387,14 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 		wantSelector string
 		wantError    error
 	}{
+		{
+			name:         "Empty branch config",
+			branchConfig: git.BranchConfig{},
+			prHeadRef:    "Frederick888/main",
+			wantPrNumber: 0,
+			wantSelector: "Frederick888/main",
+			wantError:    nil,
+		},
 		{
 			name: "The branch is configured to merge a special PR head ref",
 			branchConfig: git.BranchConfig{

From e1423cdbbf36a0a49385eea2312aaaf8dc70dae4 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Thu, 9 Jan 2025 10:08:47 -0800
Subject: [PATCH 51/68] Refine error handling of ReadBranchConfig

cmd.Output() will return an error when the git command ran successfully
but had no output. To handle this, we can check Stderr, as we expect it to
be populated for any ExitErrors or otherwise when there is a command
failure.

This allows for propagation of this error handling up the call chain, so
we are now returning errors if the call to git fails instead of just
handing off an empty BranchConfig and suppressing the errors.

Additionally, I've removed some more naked returns that I found in
pkg/cmd/pr/create.go createRun
---
 git/client.go               |  8 ++++++-
 git/client_test.go          | 40 ++++++++++++++++++++++------------
 pkg/cmd/pr/create/create.go | 43 ++++++++++++++++++-------------------
 pkg/cmd/pr/status/status.go |  5 ++++-
 4 files changed, 58 insertions(+), 38 deletions(-)

diff --git a/git/client.go b/git/client.go
index 3cc53ca96..16e8f32b5 100644
--- a/git/client.go
+++ b/git/client.go
@@ -391,7 +391,13 @@ func (c *Client) ReadBranchConfig(ctx context.Context, branch string) (BranchCon
 
 	out, err := cmd.Output()
 	if err != nil {
-		return BranchConfig{}, err
+		// This will error if no matches are found but the git command still ran successfully. We only
+		// want to return an error if the command failed to run, usually and ExitError, which will be
+		// indicated by output on Stderr.
+		if err.(*GitError).Stderr != "" {
+			return BranchConfig{}, err
+		}
+		return BranchConfig{}, nil
 	}
 
 	return parseBranchConfig(outputLines(out)), nil
diff --git a/git/client_test.go b/git/client_test.go
index 5eb7f4585..4b721656e 100644
--- a/git/client_test.go
+++ b/git/client_test.go
@@ -744,7 +744,7 @@ func TestClientReadBranchConfig(t *testing.T) {
 			wantError:        nil,
 		},
 		{
-			name:             "command error",
+			name:             "output error",
 			cmdExitStatus:    1,
 			cmdStdout:        "",
 			cmdStderr:        "git error message",
@@ -752,6 +752,15 @@ func TestClientReadBranchConfig(t *testing.T) {
 			wantBranchConfig: BranchConfig{},
 			wantError:        &GitError{ExitCode: 1, Stderr: "git error message"},
 		},
+		{
+			name:             "git config runs successfully but returns no output",
+			cmdExitStatus:    1,
+			cmdStdout:        "",
+			cmdStderr:        "",
+			branch:           "trunk",
+			wantBranchConfig: BranchConfig{},
+			wantError:        nil,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -764,7 +773,10 @@ func TestClientReadBranchConfig(t *testing.T) {
 			wantCmdArgs := fmt.Sprintf("path/to/git config --get-regexp ^branch\\.%s\\.(remote|merge|gh-merge-base)$", tt.branch)
 			assert.Equal(t, wantCmdArgs, strings.Join(cmd.Args[3:], " "))
 			assert.Equal(t, tt.wantBranchConfig, branchConfig)
-			if tt.wantError != nil {
+			if err != nil {
+				if tt.wantError == nil {
+					t.Fatalf("expected no error but got %v", err)
+				}
 				assert.Equal(t, tt.wantError.ExitCode, err.(*GitError).ExitCode)
 				assert.Equal(t, tt.wantError.Stderr, err.(*GitError).Stderr)
 			}
@@ -774,34 +786,34 @@ func TestClientReadBranchConfig(t *testing.T) {
 
 func Test_parseBranchConfig(t *testing.T) {
 	tests := []struct {
-		name                  string
-		gitBranchConfigOutput []string
-		wantBranchConfig      BranchConfig
+		name             string
+		configLines      []string
+		wantBranchConfig BranchConfig
 	}{
 		{
-			name:                  "remote branch",
-			gitBranchConfigOutput: []string{"branch.trunk.remote origin"},
+			name:        "remote branch",
+			configLines: []string{"branch.trunk.remote origin"},
 			wantBranchConfig: BranchConfig{
 				RemoteName: "origin",
 			},
 		},
 		{
-			name:                  "merge ref",
-			gitBranchConfigOutput: []string{"branch.trunk.merge refs/heads/trunk"},
+			name:        "merge ref",
+			configLines: []string{"branch.trunk.merge refs/heads/trunk"},
 			wantBranchConfig: BranchConfig{
 				MergeRef: "refs/heads/trunk",
 			},
 		},
 		{
-			name:                  "merge base",
-			gitBranchConfigOutput: []string{"branch.trunk.gh-merge-base gh-merge-base"},
+			name:        "merge base",
+			configLines: []string{"branch.trunk.gh-merge-base gh-merge-base"},
 			wantBranchConfig: BranchConfig{
 				MergeBase: "gh-merge-base",
 			},
 		},
 		{
 			name: "remote, merge ref, and merge base all specified",
-			gitBranchConfigOutput: []string{
+			configLines: []string{
 				"branch.trunk.remote origin",
 				"branch.trunk.merge refs/heads/trunk",
 				"branch.trunk.gh-merge-base gh-merge-base",
@@ -814,7 +826,7 @@ func Test_parseBranchConfig(t *testing.T) {
 		},
 		{
 			name: "remote URL",
-			gitBranchConfigOutput: []string{
+			configLines: []string{
 				"branch.Frederick888/main.remote git@github.com:Frederick888/playground.git",
 				"branch.Frederick888/main.merge refs/heads/main",
 			},
@@ -831,7 +843,7 @@ func Test_parseBranchConfig(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			branchConfig := parseBranchConfig(tt.gitBranchConfigOutput)
+			branchConfig := parseBranchConfig(tt.configLines)
 			assert.Equal(t, tt.wantBranchConfig.RemoteName, branchConfig.RemoteName)
 			assert.Equal(t, tt.wantBranchConfig.MergeRef, branchConfig.MergeRef)
 			assert.Equal(t, tt.wantBranchConfig.MergeBase, branchConfig.MergeBase)
diff --git a/pkg/cmd/pr/create/create.go b/pkg/cmd/pr/create/create.go
index b2229b976..124bd4b07 100644
--- a/pkg/cmd/pr/create/create.go
+++ b/pkg/cmd/pr/create/create.go
@@ -263,17 +263,17 @@ func NewCmdCreate(f *cmdutil.Factory, runF func(*CreateOptions) error) *cobra.Co
 	return cmd
 }
 
-func createRun(opts *CreateOptions) (err error) {
+func createRun(opts *CreateOptions) error {
 	ctx, err := NewCreateContext(opts)
 	if err != nil {
-		return
+		return err
 	}
 
 	client := ctx.Client
 
 	state, err := NewIssueState(*ctx, *opts)
 	if err != nil {
-		return
+		return err
 	}
 
 	var openURL string
@@ -288,15 +288,15 @@ func createRun(opts *CreateOptions) (err error) {
 		}
 		err = handlePush(*opts, *ctx)
 		if err != nil {
-			return
+			return err
 		}
 		openURL, err = generateCompareURL(*ctx, *state)
 		if err != nil {
-			return
+			return err
 		}
 		if !shared.ValidURL(openURL) {
 			err = fmt.Errorf("cannot open in browser: maximum URL length exceeded")
-			return
+			return err
 		}
 		return previewPR(*opts, openURL)
 	}
@@ -344,7 +344,7 @@ func createRun(opts *CreateOptions) (err error) {
 	if !opts.EditorMode && (opts.FillVerbose || opts.Autofill || opts.FillFirst || (opts.TitleProvided && opts.BodyProvided)) {
 		err = handlePush(*opts, *ctx)
 		if err != nil {
-			return
+			return err
 		}
 		return submitPR(*opts, *ctx, *state)
 	}
@@ -368,7 +368,7 @@ func createRun(opts *CreateOptions) (err error) {
 			var template shared.Template
 			template, err = tpl.Select(opts.Template)
 			if err != nil {
-				return
+				return err
 			}
 			if state.Title == "" {
 				state.Title = template.Title()
@@ -378,18 +378,18 @@ func createRun(opts *CreateOptions) (err error) {
 
 		state.Title, state.Body, err = opts.TitledEditSurvey(state.Title, state.Body)
 		if err != nil {
-			return
+			return err
 		}
 		if state.Title == "" {
 			err = fmt.Errorf("title can't be blank")
-			return
+			return err
 		}
 	} else {
 
 		if !opts.TitleProvided {
 			err = shared.TitleSurvey(opts.Prompter, opts.IO, state)
 			if err != nil {
-				return
+				return err
 			}
 		}
 
@@ -403,12 +403,12 @@ func createRun(opts *CreateOptions) (err error) {
 				if opts.Template != "" {
 					template, err = tpl.Select(opts.Template)
 					if err != nil {
-						return
+						return err
 					}
 				} else {
 					template, err = tpl.Choose()
 					if err != nil {
-						return
+						return err
 					}
 				}
 
@@ -419,13 +419,13 @@ func createRun(opts *CreateOptions) (err error) {
 
 			err = shared.BodySurvey(opts.Prompter, state, templateContent)
 			if err != nil {
-				return
+				return err
 			}
 		}
 
 		openURL, err = generateCompareURL(*ctx, *state)
 		if err != nil {
-			return
+			return err
 		}
 
 		allowPreview := !state.HasMetadata() && shared.ValidURL(openURL) && !opts.DryRun
@@ -444,12 +444,12 @@ func createRun(opts *CreateOptions) (err error) {
 			}
 			err = shared.MetadataSurvey(opts.Prompter, opts.IO, ctx.BaseRepo, fetcher, state)
 			if err != nil {
-				return
+				return err
 			}
 
 			action, err = shared.ConfirmPRSubmission(opts.Prompter, !state.HasMetadata() && !opts.DryRun, false, state.Draft)
 			if err != nil {
-				return
+				return err
 			}
 		}
 	}
@@ -457,12 +457,12 @@ func createRun(opts *CreateOptions) (err error) {
 	if action == shared.CancelAction {
 		fmt.Fprintln(opts.IO.ErrOut, "Discarding.")
 		err = cmdutil.CancelError
-		return
+		return err
 	}
 
 	err = handlePush(*opts, *ctx)
 	if err != nil {
-		return
+		return err
 	}
 
 	if action == shared.PreviewAction {
@@ -479,7 +479,7 @@ func createRun(opts *CreateOptions) (err error) {
 	}
 
 	err = errors.New("expected to cancel, preview, or submit")
-	return
+	return err
 }
 
 var regexPattern = regexp.MustCompile(`(?m)^`)
@@ -682,8 +682,7 @@ func NewCreateContext(opts *CreateOptions) (*CreateContext, error) {
 
 	headBranchConfig, err := gitClient.ReadBranchConfig(context.Background(), headBranch)
 	if err != nil {
-		// We can still proceed without the branch config, so print to stderr but continue
-		fmt.Fprintf(opts.IO.ErrOut, "Unable to read git branch config: %v\n", err)
+		return nil, err
 	}
 	if isPushEnabled {
 		// determine whether the head branch is already pushed to a remote
diff --git a/pkg/cmd/pr/status/status.go b/pkg/cmd/pr/status/status.go
index c15c0f7fd..d22ae4e2f 100644
--- a/pkg/cmd/pr/status/status.go
+++ b/pkg/cmd/pr/status/status.go
@@ -94,7 +94,10 @@ func statusRun(opts *StatusOptions) error {
 		}
 
 		remotes, _ := opts.Remotes()
-		branchConfig, _ := opts.GitClient.ReadBranchConfig(ctx, currentBranch)
+		branchConfig, err := opts.GitClient.ReadBranchConfig(ctx, currentBranch)
+		if err != nil {
+			return err
+		}
 		currentPRNumber, currentPRHeadRef, err = prSelectorForCurrentBranch(branchConfig, baseRepo, currentBranch, remotes)
 		if err != nil {
 			return fmt.Errorf("could not query for pull request for current branch: %w", err)

From 48d45d0b9db6e5be0ce8f7fe50a4cac9b01e04cc Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Thu, 9 Jan 2025 11:45:45 -0800
Subject: [PATCH 52/68] Refactor error handling in ReadBranchConfig to avoid
 panic

---
 git/client.go      | 12 +++++++-----
 git/client_test.go | 12 +++++-------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/git/client.go b/git/client.go
index 16e8f32b5..820a9cdc7 100644
--- a/git/client.go
+++ b/git/client.go
@@ -391,11 +391,13 @@ func (c *Client) ReadBranchConfig(ctx context.Context, branch string) (BranchCon
 
 	out, err := cmd.Output()
 	if err != nil {
-		// This will error if no matches are found but the git command still ran successfully. We only
-		// want to return an error if the command failed to run, usually and ExitError, which will be
-		// indicated by output on Stderr.
-		if err.(*GitError).Stderr != "" {
-			return BranchConfig{}, err
+		// This is the error we expect if the git command does not run successfully.
+		// Note: err is non-nil if the command is successful but has no output
+		var gitError *GitError
+		if errors.As(err, &gitError) {
+			if gitError.Stderr != "" {
+				return BranchConfig{}, err
+			}
 		}
 		return BranchConfig{}, nil
 	}
diff --git a/git/client_test.go b/git/client_test.go
index 4b721656e..94d1c3969 100644
--- a/git/client_test.go
+++ b/git/client_test.go
@@ -750,7 +750,7 @@ func TestClientReadBranchConfig(t *testing.T) {
 			cmdStderr:        "git error message",
 			branch:           "trunk",
 			wantBranchConfig: BranchConfig{},
-			wantError:        &GitError{ExitCode: 1, Stderr: "git error message"},
+			wantError:        &GitError{},
 		},
 		{
 			name:             "git config runs successfully but returns no output",
@@ -773,12 +773,10 @@ func TestClientReadBranchConfig(t *testing.T) {
 			wantCmdArgs := fmt.Sprintf("path/to/git config --get-regexp ^branch\\.%s\\.(remote|merge|gh-merge-base)$", tt.branch)
 			assert.Equal(t, wantCmdArgs, strings.Join(cmd.Args[3:], " "))
 			assert.Equal(t, tt.wantBranchConfig, branchConfig)
-			if err != nil {
-				if tt.wantError == nil {
-					t.Fatalf("expected no error but got %v", err)
-				}
-				assert.Equal(t, tt.wantError.ExitCode, err.(*GitError).ExitCode)
-				assert.Equal(t, tt.wantError.Stderr, err.(*GitError).Stderr)
+			if tt.wantError != nil {
+				assert.ErrorAs(t, err, &tt.wantError)
+			} else {
+				assert.NoError(t, err)
 			}
 		})
 	}

From e4320ccc4bf39dd3cf0e8eba2a6872b6d42eccca Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Thu, 9 Jan 2025 11:58:33 -0800
Subject: [PATCH 53/68] Directly stub headBranchConfig in
 Test_tryDetermineTrackingRef

---
 pkg/cmd/pr/create/create_test.go | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/pkg/cmd/pr/create/create_test.go b/pkg/cmd/pr/create/create_test.go
index 66fe1c39a..b8f5daf66 100644
--- a/pkg/cmd/pr/create/create_test.go
+++ b/pkg/cmd/pr/create/create_test.go
@@ -1,7 +1,6 @@
 package create
 
 import (
-	ctx "context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -1626,6 +1625,7 @@ func Test_tryDetermineTrackingRef(t *testing.T) {
 	tests := []struct {
 		name                string
 		cmdStubs            func(*run.CommandStubber)
+		headBranchConfig    git.BranchConfig
 		remotes             context.Remotes
 		expectedTrackingRef trackingRef
 		expectedFound       bool
@@ -1633,18 +1633,18 @@ func Test_tryDetermineTrackingRef(t *testing.T) {
 		{
 			name: "empty",
 			cmdStubs: func(cs *run.CommandStubber) {
-				cs.Register(`git config --get-regexp.+branch\\\.feature\\\.`, 0, "")
 				cs.Register(`git show-ref --verify -- HEAD`, 0, "abc HEAD")
 			},
+			headBranchConfig:    git.BranchConfig{},
 			expectedTrackingRef: trackingRef{},
 			expectedFound:       false,
 		},
 		{
 			name: "no match",
 			cmdStubs: func(cs *run.CommandStubber) {
-				cs.Register(`git config --get-regexp.+branch\\\.feature\\\.`, 0, "")
 				cs.Register("git show-ref --verify -- HEAD refs/remotes/upstream/feature refs/remotes/origin/feature", 0, "abc HEAD\nbca refs/remotes/upstream/feature")
 			},
+			headBranchConfig: git.BranchConfig{},
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "upstream"},
@@ -1661,13 +1661,13 @@ func Test_tryDetermineTrackingRef(t *testing.T) {
 		{
 			name: "match",
 			cmdStubs: func(cs *run.CommandStubber) {
-				cs.Register(`git config --get-regexp.+branch\\\.feature\\\.`, 0, "")
 				cs.Register(`git show-ref --verify -- HEAD refs/remotes/upstream/feature refs/remotes/origin/feature$`, 0, heredoc.Doc(`
 		deadbeef HEAD
 		deadb00f refs/remotes/upstream/feature
 		deadbeef refs/remotes/origin/feature
 	`))
 			},
+			headBranchConfig: git.BranchConfig{},
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "upstream"},
@@ -1687,15 +1687,15 @@ func Test_tryDetermineTrackingRef(t *testing.T) {
 		{
 			name: "respect tracking config",
 			cmdStubs: func(cs *run.CommandStubber) {
-				cs.Register(`git config --get-regexp.+branch\\\.feature\\\.`, 0, heredoc.Doc(`
-		branch.feature.remote origin
-		branch.feature.merge refs/heads/great-feat
-	`))
 				cs.Register(`git show-ref --verify -- HEAD refs/remotes/origin/great-feat refs/remotes/origin/feature$`, 0, heredoc.Doc(`
 		deadbeef HEAD
 		deadb00f refs/remotes/origin/feature
 	`))
 			},
+			headBranchConfig: git.BranchConfig{
+				RemoteName: "origin",
+				MergeRef:   "refs/heads/great-feat",
+			},
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "origin"},
@@ -1717,8 +1717,8 @@ func Test_tryDetermineTrackingRef(t *testing.T) {
 				GhPath:  "some/path/gh",
 				GitPath: "some/path/git",
 			}
-			headBranchConfig, _ := gitClient.ReadBranchConfig(ctx.Background(), "feature")
-			ref, found := tryDetermineTrackingRef(gitClient, tt.remotes, "feature", headBranchConfig)
+
+			ref, found := tryDetermineTrackingRef(gitClient, tt.remotes, "feature", tt.headBranchConfig)
 
 			assert.Equal(t, tt.expectedTrackingRef, ref)
 			assert.Equal(t, tt.expectedFound, found)

From e4f0b791731e3093cc998d773e083a22f17c223e Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Thu, 9 Jan 2025 12:46:48 -0800
Subject: [PATCH 54/68] Surface and handle error from ReadBranchConfig in
 parseCurrentBranch

I've only added the one test for parseCurrentBranch because the function
appears to be largely exercised by TestFind. There's definitely an
opportunity for a bigger refactor of the tests, here, but I want to avoid
scope creep as I propagate the ReadBranchConfig api changes throughout the
codebase
---
 pkg/cmd/pr/shared/finder.go      |  12 ++--
 pkg/cmd/pr/shared/finder_test.go | 113 +++++++++++++++++++++----------
 2 files changed, 84 insertions(+), 41 deletions(-)

diff --git a/pkg/cmd/pr/shared/finder.go b/pkg/cmd/pr/shared/finder.go
index 3bc197b75..3f036c0cd 100644
--- a/pkg/cmd/pr/shared/finder.go
+++ b/pkg/cmd/pr/shared/finder.go
@@ -37,7 +37,7 @@ type finder struct {
 	branchFn     func() (string, error)
 	remotesFn    func() (remotes.Remotes, error)
 	httpClient   func() (*http.Client, error)
-	branchConfig func(string) git.BranchConfig
+	branchConfig func(string) (git.BranchConfig, error)
 	progress     progressIndicator
 
 	repo       ghrepo.Interface
@@ -58,9 +58,8 @@ func NewFinder(factory *cmdutil.Factory) PRFinder {
 		remotesFn:  factory.Remotes,
 		httpClient: factory.HttpClient,
 		progress:   factory.IOStreams,
-		branchConfig: func(s string) git.BranchConfig {
-			branchConfig, _ := factory.GitClient.ReadBranchConfig(context.Background(), s)
-			return branchConfig
+		branchConfig: func(s string) (git.BranchConfig, error) {
+			return factory.GitClient.ReadBranchConfig(context.Background(), s)
 		},
 	}
 }
@@ -239,7 +238,10 @@ func (f *finder) parseCurrentBranch() (string, int, error) {
 		return "", 0, err
 	}
 
-	branchConfig := f.branchConfig(prHeadRef)
+	branchConfig, err := f.branchConfig(prHeadRef)
+	if err != nil {
+		return "", 0, err
+	}
 
 	// the branch is configured to merge a special PR head ref
 	if m := prHeadRE.FindStringSubmatch(branchConfig.MergeRef); m != nil {
diff --git a/pkg/cmd/pr/shared/finder_test.go b/pkg/cmd/pr/shared/finder_test.go
index 258ef01e8..dd96e684a 100644
--- a/pkg/cmd/pr/shared/finder_test.go
+++ b/pkg/cmd/pr/shared/finder_test.go
@@ -10,19 +10,21 @@ import (
 	"github.com/cli/cli/v2/git"
 	"github.com/cli/cli/v2/internal/ghrepo"
 	"github.com/cli/cli/v2/pkg/httpmock"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
+type args struct {
+	baseRepoFn   func() (ghrepo.Interface, error)
+	branchFn     func() (string, error)
+	branchConfig func(string) (git.BranchConfig, error)
+	remotesFn    func() (context.Remotes, error)
+	selector     string
+	fields       []string
+	baseBranch   string
+}
+
 func TestFind(t *testing.T) {
-	type args struct {
-		baseRepoFn   func() (ghrepo.Interface, error)
-		branchFn     func() (string, error)
-		branchConfig func(string) git.BranchConfig
-		remotesFn    func() (context.Remotes, error)
-		selector     string
-		fields       []string
-		baseBranch   string
-	}
 	tests := []struct {
 		name     string
 		args     args
@@ -231,9 +233,7 @@ func TestFind(t *testing.T) {
 				branchFn: func() (string, error) {
 					return "blueberries", nil
 				},
-				branchConfig: func(branch string) (c git.BranchConfig) {
-					return
-				},
+				branchConfig: stubBranchConfig(git.BranchConfig{}, nil),
 			},
 			httpStub: func(r *httpmock.Registry) {
 				r.Register(
@@ -265,9 +265,7 @@ func TestFind(t *testing.T) {
 				branchFn: func() (string, error) {
 					return "blueberries", nil
 				},
-				branchConfig: func(branch string) (c git.BranchConfig) {
-					return
-				},
+				branchConfig: stubBranchConfig(git.BranchConfig{}, nil),
 			},
 			httpStub: func(r *httpmock.Registry) {
 				r.Register(
@@ -315,11 +313,10 @@ func TestFind(t *testing.T) {
 				branchFn: func() (string, error) {
 					return "blueberries", nil
 				},
-				branchConfig: func(branch string) (c git.BranchConfig) {
-					c.MergeRef = "refs/heads/blue-upstream-berries"
-					c.RemoteName = "origin"
-					return
-				},
+				branchConfig: stubBranchConfig(git.BranchConfig{
+					MergeRef:   "refs/heads/blue-upstream-berries",
+					RemoteName: "origin",
+				}, nil),
 				remotesFn: func() (context.Remotes, error) {
 					return context.Remotes{{
 						Remote: &git.Remote{Name: "origin"},
@@ -357,11 +354,12 @@ func TestFind(t *testing.T) {
 				branchFn: func() (string, error) {
 					return "blueberries", nil
 				},
-				branchConfig: func(branch string) (c git.BranchConfig) {
+				branchConfig: func(branch string) (git.BranchConfig, error) {
 					u, _ := url.Parse("https://github.com/UPSTREAMOWNER/REPO")
-					c.MergeRef = "refs/heads/blue-upstream-berries"
-					c.RemoteURL = u
-					return
+					return stubBranchConfig(git.BranchConfig{
+						MergeRef:  "refs/heads/blue-upstream-berries",
+						RemoteURL: u,
+					}, nil)(branch)
 				},
 				remotesFn: nil,
 			},
@@ -395,10 +393,9 @@ func TestFind(t *testing.T) {
 				branchFn: func() (string, error) {
 					return "blueberries", nil
 				},
-				branchConfig: func(branch string) (c git.BranchConfig) {
-					c.RemoteName = "origin"
-					return
-				},
+				branchConfig: stubBranchConfig(git.BranchConfig{
+					RemoteName: "origin",
+				}, nil),
 				remotesFn: func() (context.Remotes, error) {
 					return context.Remotes{{
 						Remote: &git.Remote{Name: "origin"},
@@ -436,10 +433,9 @@ func TestFind(t *testing.T) {
 				branchFn: func() (string, error) {
 					return "blueberries", nil
 				},
-				branchConfig: func(branch string) (c git.BranchConfig) {
-					c.MergeRef = "refs/pull/13/head"
-					return
-				},
+				branchConfig: stubBranchConfig(git.BranchConfig{
+					MergeRef: "refs/pull/13/head",
+				}, nil),
 			},
 			httpStub: func(r *httpmock.Registry) {
 				r.Register(
@@ -462,10 +458,9 @@ func TestFind(t *testing.T) {
 				branchFn: func() (string, error) {
 					return "blueberries", nil
 				},
-				branchConfig: func(branch string) (c git.BranchConfig) {
-					c.MergeRef = "refs/pull/13/head"
-					return
-				},
+				branchConfig: stubBranchConfig(git.BranchConfig{
+					MergeRef: "refs/pull/13/head",
+				}, nil),
 			},
 			httpStub: func(r *httpmock.Registry) {
 				r.Register(
@@ -561,3 +556,49 @@ func TestFind(t *testing.T) {
 		})
 	}
 }
+
+func Test_parseCurrentBranch(t *testing.T) {
+	tests := []struct {
+		name         string
+		args         args
+		wantSelector string
+		wantPR       int
+		wantError    error
+	}{
+		{
+			name: "failed branch config",
+			args: args{
+				branchConfig: stubBranchConfig(git.BranchConfig{}, errors.New("branchConfigErr")),
+				branchFn: func() (string, error) {
+					return "blueberries", nil
+				},
+			},
+			wantSelector: "",
+			wantPR:       0,
+			wantError:    errors.New("branchConfigErr"),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f := finder{
+				httpClient: func() (*http.Client, error) {
+					return &http.Client{}, nil
+				},
+				baseRepoFn:   tt.args.baseRepoFn,
+				branchFn:     tt.args.branchFn,
+				branchConfig: tt.args.branchConfig,
+				remotesFn:    tt.args.remotesFn,
+			}
+			selector, pr, err := f.parseCurrentBranch()
+			assert.Equal(t, tt.wantSelector, selector)
+			assert.Equal(t, tt.wantPR, pr)
+			assert.Equal(t, tt.wantError, err)
+		})
+	}
+}
+
+func stubBranchConfig(branchConfig git.BranchConfig, err error) func(string) (git.BranchConfig, error) {
+	return func(branch string) (git.BranchConfig, error) {
+		return branchConfig, err
+	}
+}

From 100f9b473f8e7c53cb640c41fd00eb74b9e8926c Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Thu, 9 Jan 2025 12:57:23 -0800
Subject: [PATCH 55/68] Change pr number in test

---
 pkg/cmd/pr/status/status_test.go | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pkg/cmd/pr/status/status_test.go b/pkg/cmd/pr/status/status_test.go
index 431312155..5ccc80eab 100644
--- a/pkg/cmd/pr/status/status_test.go
+++ b/pkg/cmd/pr/status/status_test.go
@@ -398,10 +398,10 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 		{
 			name: "The branch is configured to merge a special PR head ref",
 			branchConfig: git.BranchConfig{
-				MergeRef: "refs/pull/666/head",
+				MergeRef: "refs/pull/42/head",
 			},
 			prHeadRef:    "Frederick888/main",
-			wantPrNumber: 666,
+			wantPrNumber: 42,
 			wantSelector: "Frederick888/main",
 			wantError:    nil,
 		},

From 3d2748789e18fbd0f910d73d2c4c78712efbb1f6 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Thu, 9 Jan 2025 12:58:31 -0800
Subject: [PATCH 56/68] Rename test user in tests

---
 pkg/cmd/pr/status/status_test.go | 60 ++++++++++++++++----------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/pkg/cmd/pr/status/status_test.go b/pkg/cmd/pr/status/status_test.go
index 5ccc80eab..eb40912b4 100644
--- a/pkg/cmd/pr/status/status_test.go
+++ b/pkg/cmd/pr/status/status_test.go
@@ -390,9 +390,9 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 		{
 			name:         "Empty branch config",
 			branchConfig: git.BranchConfig{},
-			prHeadRef:    "Frederick888/main",
+			prHeadRef:    "monalisa/main",
 			wantPrNumber: 0,
-			wantSelector: "Frederick888/main",
+			wantSelector: "monalisa/main",
 			wantError:    nil,
 		},
 		{
@@ -400,9 +400,9 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 			branchConfig: git.BranchConfig{
 				MergeRef: "refs/pull/42/head",
 			},
-			prHeadRef:    "Frederick888/main",
+			prHeadRef:    "monalisa/main",
 			wantPrNumber: 42,
-			wantSelector: "Frederick888/main",
+			wantSelector: "monalisa/main",
 			wantError:    nil,
 		},
 		{
@@ -412,19 +412,19 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 					Scheme: "ssh",
 					User:   url.User("git"),
 					Host:   "github.com",
-					Path:   "Frederick888/playground.git",
+					Path:   "monalisa/playground.git",
 				},
 			},
-			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
-			prHeadRef: "Frederick888/main",
+			baseRepo:  ghrepo.NewWithHost("monalisa", "playground", "github.com"),
+			prHeadRef: "monalisa/main",
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "origin"},
-					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+					Repo:   ghrepo.NewWithHost("monalisa", "playground", "github.com"),
 				},
 			},
 			wantPrNumber: 0,
-			wantSelector: "Frederick888/main",
+			wantSelector: "monalisa/main",
 			wantError:    nil,
 		},
 		{
@@ -432,8 +432,8 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 			branchConfig: git.BranchConfig{
 				RemoteName: "upstream",
 			},
-			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
-			prHeadRef: "Frederick888/main",
+			baseRepo:  ghrepo.NewWithHost("monalisa", "playground", "github.com"),
+			prHeadRef: "monalisa/main",
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "origin"},
@@ -441,11 +441,11 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 				},
 				&context.Remote{
 					Remote: &git.Remote{Name: "upstream"},
-					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+					Repo:   ghrepo.NewWithHost("monalisa", "playground", "github.com"),
 				},
 			},
 			wantPrNumber: 0,
-			wantSelector: "Frederick888/main",
+			wantSelector: "monalisa/main",
 			wantError:    nil,
 		},
 		{
@@ -459,8 +459,8 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 				},
 				MergeRef: "refs/heads/main",
 			},
-			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
-			prHeadRef: "Frederick888/main",
+			baseRepo:  ghrepo.NewWithHost("monalisa", "playground", "github.com"),
+			prHeadRef: "monalisa/main",
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "origin"},
@@ -476,8 +476,8 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 			branchConfig: git.BranchConfig{
 				RemoteName: "origin",
 			},
-			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
-			prHeadRef: "Frederick888/main",
+			baseRepo:  ghrepo.NewWithHost("monalisa", "playground", "github.com"),
+			prHeadRef: "monalisa/main",
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "origin"},
@@ -485,11 +485,11 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 				},
 				&context.Remote{
 					Remote: &git.Remote{Name: "upstream"},
-					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+					Repo:   ghrepo.NewWithHost("monalisa", "playground", "github.com"),
 				},
 			},
 			wantPrNumber: 0,
-			wantSelector: "forkName:Frederick888/main",
+			wantSelector: "forkName:monalisa/main",
 			wantError:    nil,
 		},
 		{
@@ -498,8 +498,8 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 				RemoteName: "upstream",
 				MergeRef:   "refs/heads/main",
 			},
-			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
-			prHeadRef: "Frederick888/main",
+			baseRepo:  ghrepo.NewWithHost("monalisa", "playground", "github.com"),
+			prHeadRef: "monalisa/main",
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "origin"},
@@ -507,7 +507,7 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 				},
 				&context.Remote{
 					Remote: &git.Remote{Name: "upstream"},
-					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+					Repo:   ghrepo.NewWithHost("monalisa", "playground", "github.com"),
 				},
 			},
 			wantPrNumber: 0,
@@ -520,8 +520,8 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 				RemoteName: "origin",
 				MergeRef:   "refs/heads/main",
 			},
-			baseRepo:  ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
-			prHeadRef: "Frederick888/main",
+			baseRepo:  ghrepo.NewWithHost("monalisa", "playground", "github.com"),
+			prHeadRef: "monalisa/main",
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "origin"},
@@ -529,7 +529,7 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 				},
 				&context.Remote{
 					Remote: &git.Remote{Name: "upstream"},
-					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+					Repo:   ghrepo.NewWithHost("monalisa", "playground", "github.com"),
 				},
 			},
 			wantPrNumber: 0,
@@ -546,9 +546,9 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 					Path:   "/\\invalid?Path/",
 				},
 			},
-			prHeadRef:    "Frederick888/main",
+			prHeadRef:    "monalisa/main",
 			wantPrNumber: 0,
-			wantSelector: "Frederick888/main",
+			wantSelector: "monalisa/main",
 			wantError:    fmt.Errorf("invalid path: /\\invalid?Path/"),
 		},
 		{
@@ -556,7 +556,7 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 			branchConfig: git.BranchConfig{
 				RemoteName: "nonexistentRemote",
 			},
-			prHeadRef: "Frederick888/main",
+			prHeadRef: "monalisa/main",
 			remotes: context.Remotes{
 				&context.Remote{
 					Remote: &git.Remote{Name: "origin"},
@@ -564,11 +564,11 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 				},
 				&context.Remote{
 					Remote: &git.Remote{Name: "upstream"},
-					Repo:   ghrepo.NewWithHost("Frederick888", "playground", "github.com"),
+					Repo:   ghrepo.NewWithHost("monalisa", "playground", "github.com"),
 				},
 			},
 			wantPrNumber: 0,
-			wantSelector: "Frederick888/main",
+			wantSelector: "monalisa/main",
 			wantError:    fmt.Errorf("no matching remote found"),
 		},
 	}

From 7f71681ace24411034ee18b44fc9288e4c14a06b Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Fri, 10 Jan 2025 01:07:11 -0600
Subject: [PATCH 57/68] gist delete - use  in confirmation and success info

---
 pkg/cmd/gist/delete/delete.go      |  8 +++----
 pkg/cmd/gist/delete/delete_test.go | 22 +++++++++---------
 pkg/cmd/gist/shared/shared.go      | 36 +++++++++++++++---------------
 3 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete.go b/pkg/cmd/gist/delete/delete.go
index 9a77fe1f2..af070b10e 100644
--- a/pkg/cmd/gist/delete/delete.go
+++ b/pkg/cmd/gist/delete/delete.go
@@ -109,7 +109,7 @@ func deleteRun(opts *DeleteOptions) error {
 	}
 
 	if !opts.Confirmed {
-		confirmed, err := opts.Prompter.Confirm(fmt.Sprintf("Delete \"%s\" gist?", gist.Description), false)
+		confirmed, err := opts.Prompter.Confirm(fmt.Sprintf("Delete %q gist?", gist.FilenameDescription()), false)
 		if err != nil {
 			return err
 		}
@@ -121,7 +121,7 @@ func deleteRun(opts *DeleteOptions) error {
 	apiClient := api.NewClientFromHTTP(client)
 	if err := deleteGist(apiClient, host, gist, opts); err != nil {
 		if errors.Is(err, shared.NotFoundErr) {
-			return fmt.Errorf("unable to delete gist \"%s\": either the gist is not found or it is not owned by you", gist.Description)
+			return fmt.Errorf("unable to delete gist %q: either the gist is not found or it is not owned by you", gist.FilenameDescription())
 		}
 		return err
 	}
@@ -142,9 +142,9 @@ func deleteGist(apiClient *api.Client, hostname string, gist *shared.Gist, opts
 	if opts.IO.IsStdoutTTY() {
 		cs := opts.IO.ColorScheme()
 		fmt.Fprintf(opts.IO.Out,
-			"%s Gist \"%s\" deleted\n",
+			"%s Gist %q deleted\n",
 			cs.SuccessIcon(),
-			gist.Description)
+			gist.FilenameDescription())
 	}
 	return nil
 }
diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index d4ec36a0c..729f81527 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -133,12 +133,12 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text"}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			wantErr:    false,
-			wantStdout: "✓ Gist \"my cool text\" deleted\n",
+			wantStdout: "✓ Gist \"cool.txt my cool text\" deleted\n",
 			wantStderr: "",
 		},
 		{
@@ -152,7 +152,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			mockGistList: true,
 			wantErr:      false,
-			wantStdout:   "✓ Gist \"my cool text\" deleted\n",
+			wantStdout:   "✓ Gist \"cool.txt my cool text\" deleted\n",
 			wantStderr:   "",
 		},
 		{
@@ -163,12 +163,12 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text"}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			wantErr:    false,
-			wantStdout: "✓ Gist \"my cool text\" deleted\n",
+			wantStdout: "✓ Gist \"cool.txt my cool text\" deleted\n",
 			wantStderr: "",
 		},
 		{
@@ -183,7 +183,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			mockGistList: true,
 			wantErr:      false,
-			wantStdout:   "✓ Gist \"my cool text\" deleted\n",
+			wantStdout:   "✓ Gist \"cool.txt my cool text\" deleted\n",
 			wantStderr:   "",
 		},
 		{
@@ -193,7 +193,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text"}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 			},
 			cancel:     true,
 			wantErr:    true,
@@ -207,7 +207,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text"}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 			},
 			cancel:     true,
 			wantErr:    true,
@@ -231,20 +231,20 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text"}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(404, "{}"))
 			},
 			wantErr:    true,
 			wantStdout: "",
-			wantStderr: "unable to delete gist \"my cool text\": either the gist is not found or it is not owned by you",
+			wantStderr: "unable to delete gist \"cool.txt my cool text\": either the gist is not found or it is not owned by you",
 		},
 	}
 
 	for _, tt := range tests {
 		pm := prompter.NewMockPrompter(t)
 		if !tt.opts.Confirmed {
-			pm.RegisterConfirm("Delete \"my cool text\" gist?", func(_ string, _ bool) (bool, error) {
+			pm.RegisterConfirm("Delete \"cool.txt my cool text\" gist?", func(_ string, _ bool) (bool, error) {
 				return !tt.cancel, nil
 			})
 		}
diff --git a/pkg/cmd/gist/shared/shared.go b/pkg/cmd/gist/shared/shared.go
index fa528698f..085eec0ab 100644
--- a/pkg/cmd/gist/shared/shared.go
+++ b/pkg/cmd/gist/shared/shared.go
@@ -39,6 +39,23 @@ type Gist struct {
 	Owner       *GistOwner           `json:"owner,omitempty"`
 }
 
+func (g Gist) Filename() string {
+	filenames := make([]string, 0, len(g.Files))
+	for fn := range g.Files {
+		filenames = append(filenames, fn)
+	}
+	sort.Strings(filenames)
+	return filenames[0]
+}
+
+func (g Gist) TruncDescription() string {
+	return text.Truncate(100, text.RemoveExcessiveWhitespace(g.Description))
+}
+
+func (g Gist) FilenameDescription() string {
+	return g.Filename() + " " + g.TruncDescription()
+}
+
 var NotFoundErr = errors.New("not found")
 
 func GetGist(client *http.Client, hostname, gistID string) (*Gist, error) {
@@ -212,29 +229,12 @@ func PromptGists(prompter prompter.Prompter, client *http.Client, host string, c
 		return &Gist{}, nil
 	}
 
-	// var opts []string
 	var opts = make([]string, len(gists))
 
 	for i, gist := range gists {
-		description := ""
-		gistName := ""
-
-		if gist.Description != "" {
-			description = gist.Description
-		}
-
-		filenames := make([]string, 0, len(gist.Files))
-		for fn := range gist.Files {
-			filenames = append(filenames, fn)
-		}
-		sort.Strings(filenames)
-		gistName = filenames[0]
-
 		gistTime := text.FuzzyAgo(time.Now(), gist.UpdatedAt)
 		// TODO: support dynamic maxWidth
-		description = text.Truncate(100, text.RemoveExcessiveWhitespace(description))
-		opts[i] = fmt.Sprintf("%s %s %s", cs.Bold(gistName), description, cs.Gray(gistTime))
-		// opts = append(opts, opt)
+		opts[i] = fmt.Sprintf("%s %s %s", cs.Bold(gist.Filename()), gist.TruncDescription(), cs.Gray(gistTime))
 	}
 
 	result, err := prompter.Select("Select a gist", "", opts)

From ae36160ea571e702cc1e8b65da2c1ecac1ebe204 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 10 Jan 2025 14:39:20 +0000
Subject: [PATCH 58/68] Bump github.com/sigstore/protobuf-specs from 0.3.2 to
 0.3.3

Bumps [github.com/sigstore/protobuf-specs](https://github.com/sigstore/protobuf-specs) from 0.3.2 to 0.3.3.
- [Release notes](https://github.com/sigstore/protobuf-specs/releases)
- [Changelog](https://github.com/sigstore/protobuf-specs/blob/main/CHANGELOG.md)
- [Commits](https://github.com/sigstore/protobuf-specs/compare/v0.3.2...v0.3.3)

---
updated-dependencies:
- dependency-name: github.com/sigstore/protobuf-specs
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 go.mod | 4 ++--
 go.sum | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/go.mod b/go.mod
index f2f1ce812..14277d49e 100644
--- a/go.mod
+++ b/go.mod
@@ -39,7 +39,7 @@ require (
 	github.com/opentracing/opentracing-go v1.2.0
 	github.com/rivo/tview v0.0.0-20221029100920-c4a7e501810d
 	github.com/shurcooL/githubv4 v0.0.0-20240120211514-18a1ae0e79dc
-	github.com/sigstore/protobuf-specs v0.3.2
+	github.com/sigstore/protobuf-specs v0.3.3
 	github.com/sigstore/sigstore-go v0.6.2
 	github.com/spf13/cobra v1.8.1
 	github.com/spf13/pflag v1.0.5
@@ -50,7 +50,7 @@ require (
 	golang.org/x/term v0.27.0
 	golang.org/x/text v0.21.0
 	google.golang.org/grpc v1.64.1
-	google.golang.org/protobuf v1.34.2
+	google.golang.org/protobuf v1.36.2
 	gopkg.in/h2non/gock.v1 v1.1.2
 	gopkg.in/yaml.v3 v3.0.1
 )
diff --git a/go.sum b/go.sum
index 1b48f0c27..af84c7e41 100644
--- a/go.sum
+++ b/go.sum
@@ -392,8 +392,8 @@ github.com/shurcooL/githubv4 v0.0.0-20240120211514-18a1ae0e79dc h1:vH0NQbIDk+mJL
 github.com/shurcooL/githubv4 v0.0.0-20240120211514-18a1ae0e79dc/go.mod h1:zqMwyHmnN/eDOZOdiTohqIUKUrTFX62PNlu7IJdu0q8=
 github.com/shurcooL/graphql v0.0.0-20230722043721-ed46e5a46466 h1:17JxqqJY66GmZVHkmAsGEkcIu0oCe3AM420QDgGwZx0=
 github.com/shurcooL/graphql v0.0.0-20230722043721-ed46e5a46466/go.mod h1:9dIRpgIY7hVhoqfe0/FcYp0bpInZaT7dc3BYOprrIUE=
-github.com/sigstore/protobuf-specs v0.3.2 h1:nCVARCN+fHjlNCk3ThNXwrZRqIommIeNKWwQvORuRQo=
-github.com/sigstore/protobuf-specs v0.3.2/go.mod h1:RZ0uOdJR4OB3tLQeAyWoJFbNCBFrPQdcokntde4zRBA=
+github.com/sigstore/protobuf-specs v0.3.3 h1:RMZQgXTD/pF7KW6b5NaRLYxFYZ/wzx44PQFXN2PEo5g=
+github.com/sigstore/protobuf-specs v0.3.3/go.mod h1:vIhZ6Uor1a38+wvRrKcqL2PtYNlgoIW9lhzYzkyy4EU=
 github.com/sigstore/rekor v1.3.6 h1:QvpMMJVWAp69a3CHzdrLelqEqpTM3ByQRt5B5Kspbi8=
 github.com/sigstore/rekor v1.3.6/go.mod h1:JDTSNNMdQ/PxdsS49DJkJ+pRJCO/83nbR5p3aZQteXc=
 github.com/sigstore/sigstore v1.8.9 h1:NiUZIVWywgYuVTxXmRoTT4O4QAGiTEKup4N1wdxFadk=
@@ -548,8 +548,8 @@ google.golang.org/genproto/googleapis/rpc v0.0.0-20240520151616-dc85e6b867a5 h1:
 google.golang.org/genproto/googleapis/rpc v0.0.0-20240520151616-dc85e6b867a5/go.mod h1:EfXuqaE1J41VCDicxHzUDm+8rk+7ZdXzHV0IhO/I6s0=
 google.golang.org/grpc v1.64.1 h1:LKtvyfbX3UGVPFcGqJ9ItpVWW6oN/2XqTxfAnwRRXiA=
 google.golang.org/grpc v1.64.1/go.mod h1:hiQF4LFZelK2WKaP6W0L92zGHtiQdZxk8CrSdvyjeP0=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+google.golang.org/protobuf v1.36.2 h1:R8FeyR1/eLmkutZOM5CWghmo5itiG9z0ktFlTVLuTmU=
+google.golang.org/protobuf v1.36.2/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=

From 322a43feff32c0071705c8b3fd75091ffb8ebc2f Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Fri, 10 Jan 2025 09:59:21 -0800
Subject: [PATCH 59/68] Change error handling on ReadBranchConfig to respect
 git Exit Codes

---
 git/client.go      |  8 +++-----
 git/client_test.go | 20 ++++++++++----------
 2 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/git/client.go b/git/client.go
index 820a9cdc7..19688ca51 100644
--- a/git/client.go
+++ b/git/client.go
@@ -392,12 +392,10 @@ func (c *Client) ReadBranchConfig(ctx context.Context, branch string) (BranchCon
 	out, err := cmd.Output()
 	if err != nil {
 		// This is the error we expect if the git command does not run successfully.
-		// Note: err is non-nil if the command is successful but has no output
+		// If the ExitCode is 1, then we just didn't find any config for the branch.
 		var gitError *GitError
-		if errors.As(err, &gitError) {
-			if gitError.Stderr != "" {
-				return BranchConfig{}, err
-			}
+		if ok := errors.As(err, &gitError); ok && gitError.ExitCode != 1 {
+			return BranchConfig{}, err
 		}
 		return BranchConfig{}, nil
 	}
diff --git a/git/client_test.go b/git/client_test.go
index 94d1c3969..fe3047db9 100644
--- a/git/client_test.go
+++ b/git/client_test.go
@@ -744,16 +744,7 @@ func TestClientReadBranchConfig(t *testing.T) {
 			wantError:        nil,
 		},
 		{
-			name:             "output error",
-			cmdExitStatus:    1,
-			cmdStdout:        "",
-			cmdStderr:        "git error message",
-			branch:           "trunk",
-			wantBranchConfig: BranchConfig{},
-			wantError:        &GitError{},
-		},
-		{
-			name:             "git config runs successfully but returns no output",
+			name:             "git config runs successfully but returns no output (Exit Code 1)",
 			cmdExitStatus:    1,
 			cmdStdout:        "",
 			cmdStderr:        "",
@@ -761,6 +752,15 @@ func TestClientReadBranchConfig(t *testing.T) {
 			wantBranchConfig: BranchConfig{},
 			wantError:        nil,
 		},
+		{
+			name:             "output error (Exit Code > 1)",
+			cmdExitStatus:    2,
+			cmdStdout:        "",
+			cmdStderr:        "git error message",
+			branch:           "trunk",
+			wantBranchConfig: BranchConfig{},
+			wantError:        &GitError{},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

From 74cbd50d3ff44cef698d8b77056122c257fb32b9 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Fri, 10 Jan 2025 10:51:55 -0800
Subject: [PATCH 60/68] Restore old error functionality of
 prSelectorForCurrentBranch

Before this refactor, the errors emitted by ghrepo.FromURL and
rem.FindName() were suppressed. It isn't clear whether this was
intentional or not, but we've made the decision here to maintain the
original error behavior while still refactoring the return values for more
clarity. I've left a comment at each error handling block to explain this
decision.

Additionally, I've added the necessary git command stubs to the other
tests in status_test.go so that the tests are now passing.
---
 pkg/cmd/pr/status/status.go      | 10 ++++-
 pkg/cmd/pr/status/status_test.go | 74 +++++++++++++++++++++++++++++---
 2 files changed, 77 insertions(+), 7 deletions(-)

diff --git a/pkg/cmd/pr/status/status.go b/pkg/cmd/pr/status/status.go
index d22ae4e2f..a97a59e44 100644
--- a/pkg/cmd/pr/status/status.go
+++ b/pkg/cmd/pr/status/status.go
@@ -205,14 +205,20 @@ func prSelectorForCurrentBranch(branchConfig git.BranchConfig, baseRepo ghrepo.I
 		// the branch merges from a remote specified by URL
 		r, err := ghrepo.FromURL(branchConfig.RemoteURL)
 		if err != nil {
-			return 0, prHeadRef, err
+			// TODO: We aren't returning the error because we discovered that it was shadowed
+			// before refactoring to its current return pattern. Thus, we aren't confident
+			// that returning the error won't break existing behavior.
+			return 0, prHeadRef, nil
 		}
 		branchOwner = r.RepoOwner()
 	} else if branchConfig.RemoteName != "" {
 		// the branch merges from a remote specified by name
 		r, err := rem.FindByName(branchConfig.RemoteName)
 		if err != nil {
-			return 0, prHeadRef, err
+			// TODO: We aren't returning the error because we discovered that it was shadowed
+			// before refactoring to its current return pattern. Thus, we aren't confident
+			// that returning the error won't break existing behavior.
+			return 0, prHeadRef, nil
 		}
 		branchOwner = r.RepoOwner()
 	}
diff --git a/pkg/cmd/pr/status/status_test.go b/pkg/cmd/pr/status/status_test.go
index eb40912b4..43cce5f4c 100644
--- a/pkg/cmd/pr/status/status_test.go
+++ b/pkg/cmd/pr/status/status_test.go
@@ -2,7 +2,6 @@ package status
 
 import (
 	"bytes"
-	"fmt"
 	"io"
 	"net/http"
 	"net/url"
@@ -16,6 +15,7 @@ import (
 	fd "github.com/cli/cli/v2/internal/featuredetection"
 	"github.com/cli/cli/v2/internal/gh"
 	"github.com/cli/cli/v2/internal/ghrepo"
+	"github.com/cli/cli/v2/internal/run"
 	"github.com/cli/cli/v2/pkg/cmdutil"
 	"github.com/cli/cli/v2/pkg/httpmock"
 	"github.com/cli/cli/v2/pkg/iostreams"
@@ -96,6 +96,11 @@ func TestPRStatus(t *testing.T) {
 	defer http.Verify(t)
 	http.Register(httpmock.GraphQL(`query PullRequestStatus\b`), httpmock.FileResponse("./fixtures/prStatus.json"))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommand(http, "blueberries", true, "")
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -121,6 +126,11 @@ func TestPRStatus_reviewsAndChecks(t *testing.T) {
 	// status,conclusion matches the old StatusContextRollup query
 	http.Register(httpmock.GraphQL(`status,conclusion`), httpmock.FileResponse("./fixtures/prStatusChecks.json"))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommand(http, "blueberries", true, "")
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -146,6 +156,11 @@ func TestPRStatus_reviewsAndChecksWithStatesByCount(t *testing.T) {
 	// checkRunCount,checkRunCountsByState matches the new StatusContextRollup query
 	http.Register(httpmock.GraphQL(`checkRunCount,checkRunCountsByState`), httpmock.FileResponse("./fixtures/prStatusChecksWithStatesByCount.json"))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommandWithDetector(http, "blueberries", true, "", &fd.EnabledDetectorMock{})
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -170,6 +185,11 @@ func TestPRStatus_currentBranch_showTheMostRecentPR(t *testing.T) {
 	defer http.Verify(t)
 	http.Register(httpmock.GraphQL(`query PullRequestStatus\b`), httpmock.FileResponse("./fixtures/prStatusCurrentBranch.json"))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommand(http, "blueberries", true, "")
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -198,6 +218,11 @@ func TestPRStatus_currentBranch_defaultBranch(t *testing.T) {
 	defer http.Verify(t)
 	http.Register(httpmock.GraphQL(`query PullRequestStatus\b`), httpmock.FileResponse("./fixtures/prStatusCurrentBranch.json"))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommand(http, "blueberries", true, "")
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -232,6 +257,11 @@ func TestPRStatus_currentBranch_Closed(t *testing.T) {
 	defer http.Verify(t)
 	http.Register(httpmock.GraphQL(`query PullRequestStatus\b`), httpmock.FileResponse("./fixtures/prStatusCurrentBranchClosed.json"))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommand(http, "blueberries", true, "")
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -249,6 +279,11 @@ func TestPRStatus_currentBranch_Closed_defaultBranch(t *testing.T) {
 	defer http.Verify(t)
 	http.Register(httpmock.GraphQL(`query PullRequestStatus\b`), httpmock.FileResponse("./fixtures/prStatusCurrentBranchClosedOnDefaultBranch.json"))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommand(http, "blueberries", true, "")
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -266,6 +301,11 @@ func TestPRStatus_currentBranch_Merged(t *testing.T) {
 	defer http.Verify(t)
 	http.Register(httpmock.GraphQL(`query PullRequestStatus\b`), httpmock.FileResponse("./fixtures/prStatusCurrentBranchMerged.json"))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommand(http, "blueberries", true, "")
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -283,6 +323,11 @@ func TestPRStatus_currentBranch_Merged_defaultBranch(t *testing.T) {
 	defer http.Verify(t)
 	http.Register(httpmock.GraphQL(`query PullRequestStatus\b`), httpmock.FileResponse("./fixtures/prStatusCurrentBranchMergedOnDefaultBranch.json"))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommand(http, "blueberries", true, "")
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -300,6 +345,11 @@ func TestPRStatus_blankSlate(t *testing.T) {
 	defer http.Verify(t)
 	http.Register(httpmock.GraphQL(`query PullRequestStatus\b`), httpmock.StringResponse(`{"data": {}}`))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommand(http, "blueberries", true, "")
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -353,6 +403,11 @@ func TestPRStatus_detachedHead(t *testing.T) {
 	defer http.Verify(t)
 	http.Register(httpmock.GraphQL(`query PullRequestStatus\b`), httpmock.StringResponse(`{"data": {}}`))
 
+	// stub successful git command
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 0, "")
+
 	output, err := runCommand(http, "", true, "")
 	if err != nil {
 		t.Errorf("error running command `pr status`: %v", err)
@@ -376,6 +431,15 @@ Requesting a code review from you
 	}
 }
 
+func TestPRStatus_error_ReadBranchConfig(t *testing.T) {
+	rs, cleanup := run.Stub()
+	defer cleanup(t)
+	rs.Register(`git config --get-regexp \^branch\\.`, 1, "")
+
+	_, err := runCommand(initFakeHTTP(), "blueberries", true, "")
+	assert.Error(t, err)
+}
+
 func Test_prSelectorForCurrentBranch(t *testing.T) {
 	tests := []struct {
 		name         string
@@ -537,7 +601,7 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 			wantError:    nil,
 		},
 		{
-			name: "Remote URL error",
+			name: "Remote URL errors",
 			branchConfig: git.BranchConfig{
 				RemoteURL: &url.URL{
 					Scheme: "ssh",
@@ -549,10 +613,10 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 			prHeadRef:    "monalisa/main",
 			wantPrNumber: 0,
 			wantSelector: "monalisa/main",
-			wantError:    fmt.Errorf("invalid path: /\\invalid?Path/"),
+			wantError:    nil,
 		},
 		{
-			name: "Remote Name error",
+			name: "Remote Name errors",
 			branchConfig: git.BranchConfig{
 				RemoteName: "nonexistentRemote",
 			},
@@ -569,7 +633,7 @@ func Test_prSelectorForCurrentBranch(t *testing.T) {
 			},
 			wantPrNumber: 0,
 			wantSelector: "monalisa/main",
-			wantError:    fmt.Errorf("no matching remote found"),
+			wantError:    nil,
 		},
 	}
 

From 5de282c9702ca98bac0e4282bdb3ca6b12b40e71 Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Sat, 11 Jan 2025 01:35:12 -0600
Subject: [PATCH 61/68] drop description from prompts, fix tests

---
 pkg/cmd/gist/delete/delete.go      |  25 +++----
 pkg/cmd/gist/delete/delete_test.go | 107 ++++++++++++++---------------
 pkg/cmd/gist/shared/shared.go      |   4 --
 3 files changed, 66 insertions(+), 70 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete.go b/pkg/cmd/gist/delete/delete.go
index af070b10e..ad1e0a48b 100644
--- a/pkg/cmd/gist/delete/delete.go
+++ b/pkg/cmd/gist/delete/delete.go
@@ -109,7 +109,7 @@ func deleteRun(opts *DeleteOptions) error {
 	}
 
 	if !opts.Confirmed {
-		confirmed, err := opts.Prompter.Confirm(fmt.Sprintf("Delete %q gist?", gist.FilenameDescription()), false)
+		confirmed, err := opts.Prompter.Confirm(fmt.Sprintf("Delete %q gist?", gist.Filename()), false)
 		if err != nil {
 			return err
 		}
@@ -119,18 +119,26 @@ func deleteRun(opts *DeleteOptions) error {
 	}
 
 	apiClient := api.NewClientFromHTTP(client)
-	if err := deleteGist(apiClient, host, gist, opts); err != nil {
+	if err := deleteGist(apiClient, host, gist.ID); err != nil {
 		if errors.Is(err, shared.NotFoundErr) {
-			return fmt.Errorf("unable to delete gist %q: either the gist is not found or it is not owned by you", gist.FilenameDescription())
+			return fmt.Errorf("unable to delete gist %q: either the gist is not found or it is not owned by you", gist.Filename())
 		}
 		return err
 	}
 
+	if opts.IO.IsStdoutTTY() {
+		cs := opts.IO.ColorScheme()
+		fmt.Fprintf(opts.IO.Out,
+			"%s Gist %q deleted\n",
+			cs.SuccessIcon(),
+			gist.Filename())
+	}
+
 	return nil
 }
 
-func deleteGist(apiClient *api.Client, hostname string, gist *shared.Gist, opts *DeleteOptions) error {
-	path := "gists/" + gist.ID
+func deleteGist(apiClient *api.Client, hostname string, gistID string) error {
+	path := "gists/" + gistID
 	err := apiClient.REST(hostname, "DELETE", path, nil, nil)
 	if err != nil {
 		var httpErr api.HTTPError
@@ -139,12 +147,5 @@ func deleteGist(apiClient *api.Client, hostname string, gist *shared.Gist, opts
 		}
 		return err
 	}
-	if opts.IO.IsStdoutTTY() {
-		cs := opts.IO.ColorScheme()
-		fmt.Fprintf(opts.IO.Out,
-			"%s Gist %q deleted\n",
-			cs.SuccessIcon(),
-			gist.FilenameDescription())
-	}
 	return nil
 }
diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index 729f81527..359e73a59 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -117,14 +117,14 @@ func TestNewCmdDelete(t *testing.T) {
 
 func Test_deleteRun(t *testing.T) {
 	tests := []struct {
-		name         string
-		opts         *DeleteOptions
-		cancel       bool
-		httpStubs    func(*httpmock.Registry)
-		mockGistList bool
-		wantErr      bool
-		wantStdout   string
-		wantStderr   string
+		name            string
+		opts            *DeleteOptions
+		cancel          bool
+		httpStubs       func(*httpmock.Registry)
+		mockPromptGists bool
+		wantErr         bool
+		wantStdout      string
+		wantStderr      string
 	}{
 		{
 			name: "successfully delete",
@@ -133,12 +133,12 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			wantErr:    false,
-			wantStdout: "✓ Gist \"cool.txt my cool text\" deleted\n",
+			wantStdout: "✓ Gist \"cool.txt\" deleted\n",
 			wantStderr: "",
 		},
 		{
@@ -150,10 +150,10 @@ func Test_deleteRun(t *testing.T) {
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
-			mockGistList: true,
-			wantErr:      false,
-			wantStdout:   "✓ Gist \"cool.txt my cool text\" deleted\n",
-			wantStderr:   "",
+			mockPromptGists: true,
+			wantErr:         false,
+			wantStdout:      "✓ Gist \"cool.txt\" deleted\n",
+			wantStderr:      "",
 		},
 		{
 			name: "successfully delete with --yes",
@@ -163,12 +163,12 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			wantErr:    false,
-			wantStdout: "✓ Gist \"cool.txt my cool text\" deleted\n",
+			wantStdout: "✓ Gist \"cool.txt\" deleted\n",
 			wantStderr: "",
 		},
 		{
@@ -181,10 +181,10 @@ func Test_deleteRun(t *testing.T) {
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
-			mockGistList: true,
-			wantErr:      false,
-			wantStdout:   "✓ Gist \"cool.txt my cool text\" deleted\n",
-			wantStderr:   "",
+			mockPromptGists: true,
+			wantErr:         false,
+			wantStdout:      "✓ Gist \"cool.txt\" deleted\n",
+			wantStderr:      "",
 		},
 		{
 			name: "cancel delete with id",
@@ -193,7 +193,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 			},
 			cancel:     true,
 			wantErr:    true,
@@ -207,7 +207,7 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 			},
 			cancel:     true,
 			wantErr:    true,
@@ -219,10 +219,12 @@ func Test_deleteRun(t *testing.T) {
 			opts: &DeleteOptions{
 				Selector: "",
 			},
-			cancel:     true,
-			wantErr:    true,
-			wantStdout: "",
-			wantStderr: "",
+			httpStubs:       func(reg *httpmock.Registry) {},
+			mockPromptGists: true,
+			cancel:          true,
+			wantErr:         true,
+			wantStdout:      "",
+			wantStderr:      "",
 		},
 		{
 			name: "not found",
@@ -231,52 +233,49 @@ func Test_deleteRun(t *testing.T) {
 			},
 			httpStubs: func(reg *httpmock.Registry) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
-					httpmock.JSONResponse(shared.Gist{ID: "1234", Description: "my cool text", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
+					httpmock.JSONResponse(shared.Gist{ID: "1234", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(404, "{}"))
 			},
 			wantErr:    true,
 			wantStdout: "",
-			wantStderr: "unable to delete gist \"cool.txt my cool text\": either the gist is not found or it is not owned by you",
+			wantStderr: "unable to delete gist \"cool.txt\": either the gist is not found or it is not owned by you",
 		},
 	}
 
 	for _, tt := range tests {
 		pm := prompter.NewMockPrompter(t)
 		if !tt.opts.Confirmed {
-			pm.RegisterConfirm("Delete \"cool.txt my cool text\" gist?", func(_ string, _ bool) (bool, error) {
+			pm.RegisterConfirm("Delete \"cool.txt\" gist?", func(_ string, _ bool) (bool, error) {
 				return !tt.cancel, nil
 			})
 		}
 
 		reg := &httpmock.Registry{}
-		if !tt.cancel {
-			tt.httpStubs(reg)
-			if tt.mockGistList {
-				sixHours, _ := time.ParseDuration("6h")
-				sixHoursAgo := time.Now().Add(-sixHours)
-				reg.Register(
-					httpmock.GraphQL(`query GistList\b`),
-					httpmock.StringResponse(fmt.Sprintf(
-						`{ "data": { "viewer": { "gists": { "nodes": [
-								{
-									"name": "1234",
-									"files": [{ "name": "cool.txt" }],
-									"description": "my cool text",
-									"updatedAt": "%s",
-									"isPublic": true
-								}
-							] } } } }`,
-						sixHoursAgo.Format(time.RFC3339),
-					)),
-				)
-
-				pm.RegisterSelect("Select a gist", []string{"cool.txt my cool text about 6 hours ago"}, func(_, _ string, opts []string) (int, error) {
-					return 0, nil
-				})
-			}
+		tt.httpStubs(reg)
+		if tt.mockPromptGists {
+			sixHours, _ := time.ParseDuration("6h")
+			sixHoursAgo := time.Now().Add(-sixHours)
+			reg.Register(
+				httpmock.GraphQL(`query GistList\b`),
+				httpmock.StringResponse(fmt.Sprintf(
+					`{ "data": { "viewer": { "gists": { "nodes": [
+							{
+								"name": "1234",
+								"files": [{ "name": "cool.txt" }],
+								"updatedAt": "%s",
+								"isPublic": true
+							}
+						] } } } }`,
+					sixHoursAgo.Format(time.RFC3339),
+				)),
+			)
 
+			pm.RegisterSelect("Select a gist", []string{"cool.txt  about 6 hours ago"}, func(_, _ string, _ []string) (int, error) {
+				return 0, nil
+			})
 		}
+
 		tt.opts.Prompter = pm
 
 		tt.opts.HttpClient = func() (*http.Client, error) {
diff --git a/pkg/cmd/gist/shared/shared.go b/pkg/cmd/gist/shared/shared.go
index 085eec0ab..53b577e4c 100644
--- a/pkg/cmd/gist/shared/shared.go
+++ b/pkg/cmd/gist/shared/shared.go
@@ -52,10 +52,6 @@ func (g Gist) TruncDescription() string {
 	return text.Truncate(100, text.RemoveExcessiveWhitespace(g.Description))
 }
 
-func (g Gist) FilenameDescription() string {
-	return g.Filename() + " " + g.TruncDescription()
-}
-
 var NotFoundErr = errors.New("not found")
 
 func GetGist(client *http.Client, hostname, gistID string) (*Gist, error) {

From 7885167c70eab766f9b887e2aa36bf166de10a09 Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Sun, 12 Jan 2025 17:01:45 -0600
Subject: [PATCH 62/68] gist delete - check no gists

---
 pkg/cmd/gist/delete/delete.go      |  4 ++
 pkg/cmd/gist/delete/delete_test.go | 80 ++++++++++++++++--------------
 2 files changed, 46 insertions(+), 38 deletions(-)

diff --git a/pkg/cmd/gist/delete/delete.go b/pkg/cmd/gist/delete/delete.go
index ad1e0a48b..8b8a47540 100644
--- a/pkg/cmd/gist/delete/delete.go
+++ b/pkg/cmd/gist/delete/delete.go
@@ -107,6 +107,10 @@ func deleteRun(opts *DeleteOptions) error {
 	if err != nil {
 		return err
 	}
+	if gist.ID == "" {
+		fmt.Fprintln(opts.IO.Out, "No gists found.")
+		return nil
+	}
 
 	if !opts.Confirmed {
 		confirmed, err := opts.Prompter.Confirm(fmt.Sprintf("Delete %q gist?", gist.Filename()), false)
diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index 359e73a59..97a7e11d3 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -122,6 +122,7 @@ func Test_deleteRun(t *testing.T) {
 		cancel          bool
 		httpStubs       func(*httpmock.Registry)
 		mockPromptGists bool
+		noGists         bool
 		wantErr         bool
 		wantStdout      string
 		wantStderr      string
@@ -137,9 +138,7 @@ func Test_deleteRun(t *testing.T) {
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
-			wantErr:    false,
 			wantStdout: "✓ Gist \"cool.txt\" deleted\n",
-			wantStderr: "",
 		},
 		{
 			name: "successfully delete with prompt",
@@ -151,9 +150,7 @@ func Test_deleteRun(t *testing.T) {
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			mockPromptGists: true,
-			wantErr:         false,
 			wantStdout:      "✓ Gist \"cool.txt\" deleted\n",
-			wantStderr:      "",
 		},
 		{
 			name: "successfully delete with --yes",
@@ -167,9 +164,7 @@ func Test_deleteRun(t *testing.T) {
 				reg.Register(httpmock.REST("DELETE", "gists/1234"),
 					httpmock.StatusStringResponse(200, "{}"))
 			},
-			wantErr:    false,
 			wantStdout: "✓ Gist \"cool.txt\" deleted\n",
-			wantStderr: "",
 		},
 		{
 			name: "successfully delete with prompt and --yes",
@@ -182,9 +177,7 @@ func Test_deleteRun(t *testing.T) {
 					httpmock.StatusStringResponse(200, "{}"))
 			},
 			mockPromptGists: true,
-			wantErr:         false,
 			wantStdout:      "✓ Gist \"cool.txt\" deleted\n",
-			wantStderr:      "",
 		},
 		{
 			name: "cancel delete with id",
@@ -195,10 +188,8 @@ func Test_deleteRun(t *testing.T) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
 					httpmock.JSONResponse(shared.Gist{ID: "1234", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 			},
-			cancel:     true,
-			wantErr:    true,
-			wantStdout: "",
-			wantStderr: "",
+			cancel:  true,
+			wantErr: true,
 		},
 		{
 			name: "cancel delete with url",
@@ -209,10 +200,8 @@ func Test_deleteRun(t *testing.T) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
 					httpmock.JSONResponse(shared.Gist{ID: "1234", Files: map[string]*shared.GistFile{"cool.txt": {Filename: "cool.txt"}}}))
 			},
-			cancel:     true,
-			wantErr:    true,
-			wantStdout: "",
-			wantStderr: "",
+			cancel:  true,
+			wantErr: true,
 		},
 		{
 			name: "cancel delete with prompt",
@@ -223,8 +212,6 @@ func Test_deleteRun(t *testing.T) {
 			mockPromptGists: true,
 			cancel:          true,
 			wantErr:         true,
-			wantStdout:      "",
-			wantStderr:      "",
 		},
 		{
 			name: "not found",
@@ -238,9 +225,18 @@ func Test_deleteRun(t *testing.T) {
 					httpmock.StatusStringResponse(404, "{}"))
 			},
 			wantErr:    true,
-			wantStdout: "",
 			wantStderr: "unable to delete gist \"cool.txt\": either the gist is not found or it is not owned by you",
 		},
+		{
+			name: "no gists",
+			opts: &DeleteOptions{
+				Selector: "",
+			},
+			httpStubs:       func(reg *httpmock.Registry) {},
+			mockPromptGists: true,
+			noGists:         true,
+			wantStdout:      "No gists found.\n",
+		},
 	}
 
 	for _, tt := range tests {
@@ -254,26 +250,34 @@ func Test_deleteRun(t *testing.T) {
 		reg := &httpmock.Registry{}
 		tt.httpStubs(reg)
 		if tt.mockPromptGists {
-			sixHours, _ := time.ParseDuration("6h")
-			sixHoursAgo := time.Now().Add(-sixHours)
-			reg.Register(
-				httpmock.GraphQL(`query GistList\b`),
-				httpmock.StringResponse(fmt.Sprintf(
-					`{ "data": { "viewer": { "gists": { "nodes": [
-							{
-								"name": "1234",
-								"files": [{ "name": "cool.txt" }],
-								"updatedAt": "%s",
-								"isPublic": true
-							}
-						] } } } }`,
-					sixHoursAgo.Format(time.RFC3339),
-				)),
-			)
+			if tt.noGists {
+				reg.Register(
+					httpmock.GraphQL(`query GistList\b`),
+					httpmock.StringResponse(
+						`{ "data": { "viewer": { "gists": { "nodes": [] }} } }`),
+				)
+			} else {
+				sixHours, _ := time.ParseDuration("6h")
+				sixHoursAgo := time.Now().Add(-sixHours)
+				reg.Register(
+					httpmock.GraphQL(`query GistList\b`),
+					httpmock.StringResponse(fmt.Sprintf(
+						`{ "data": { "viewer": { "gists": { "nodes": [
+								{
+									"name": "1234",
+									"files": [{ "name": "cool.txt" }],
+									"updatedAt": "%s",
+									"isPublic": true
+								}
+							] } } } }`,
+						sixHoursAgo.Format(time.RFC3339),
+					)),
+				)
+				pm.RegisterSelect("Select a gist", []string{"cool.txt  about 6 hours ago"}, func(_, _ string, _ []string) (int, error) {
+					return 0, nil
+				})
+			}
 
-			pm.RegisterSelect("Select a gist", []string{"cool.txt  about 6 hours ago"}, func(_, _ string, _ []string) (int, error) {
-				return 0, nil
-			})
 		}
 
 		tt.opts.Prompter = pm

From 08f7706c4287b0bae04b5d8b2efb05ab01da23c0 Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Sun, 12 Jan 2025 19:18:24 -0600
Subject: [PATCH 63/68] fix tests

---
 pkg/cmd/gist/delete/delete_test.go | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index 97a7e11d3..fa311b07e 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -214,7 +214,7 @@ func Test_deleteRun(t *testing.T) {
 			wantErr:         true,
 		},
 		{
-			name: "not found",
+			name: "not owned by you",
 			opts: &DeleteOptions{
 				Selector: "1234",
 			},
@@ -227,6 +227,19 @@ func Test_deleteRun(t *testing.T) {
 			wantErr:    true,
 			wantStderr: "unable to delete gist \"cool.txt\": either the gist is not found or it is not owned by you",
 		},
+		{
+			name: "not found",
+			opts: &DeleteOptions{
+				Selector: "1234",
+			},
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(httpmock.REST("GET", "gists/1234"),
+					httpmock.StatusStringResponse(404, "{}"))
+			},
+			noGists:    true,
+			wantErr:    true,
+			wantStderr: "not found",
+		},
 		{
 			name: "no gists",
 			opts: &DeleteOptions{

From 1d9b4e44640280ece40e6c97d136e5bfd6386a24 Mon Sep 17 00:00:00 2001
From: danochoa <dochoa3@gmail.com>
Date: Sun, 12 Jan 2025 19:36:44 -0600
Subject: [PATCH 64/68] fix tests

---
 pkg/cmd/gist/delete/delete_test.go | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index fa311b07e..74c511237 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -236,7 +236,6 @@ func Test_deleteRun(t *testing.T) {
 				reg.Register(httpmock.REST("GET", "gists/1234"),
 					httpmock.StatusStringResponse(404, "{}"))
 			},
-			noGists:    true,
 			wantErr:    true,
 			wantStderr: "not found",
 		},

From bc8c46b0b1c1fd411e286990b950aad254cfb78f Mon Sep 17 00:00:00 2001
From: Andy Feller <andyfeller@github.com>
Date: Mon, 13 Jan 2025 20:38:03 -0500
Subject: [PATCH 65/68] Make extension update check non-blocking

Fixes #10235

This commit updates the Cobra command logic around extension upgrade checks to be non-blocking.

Previously, we were waiting for 1 second after the extension completed to allow the update checking logic complete, however users want the GitHub CLI to run as far as possible.
---
 pkg/cmd/root/extension.go      | 31 ++++++++++++---------
 pkg/cmd/root/extension_test.go | 51 ++++++++++++++++++++++++++++++++++
 2 files changed, 69 insertions(+), 13 deletions(-)

diff --git a/pkg/cmd/root/extension.go b/pkg/cmd/root/extension.go
index 7f2325e18..7e2d7aca7 100644
--- a/pkg/cmd/root/extension.go
+++ b/pkg/cmd/root/extension.go
@@ -52,20 +52,25 @@ func NewCmdExtension(io *iostreams.IOStreams, em extensions.ExtensionManager, ex
 		},
 		// PostRun handles communicating extension release information if found
 		PostRun: func(c *cobra.Command, args []string) {
-			releaseInfo := <-updateMessageChan
-			if releaseInfo != nil {
-				stderr := io.ErrOut
-				fmt.Fprintf(stderr, "\n\n%s %s → %s\n",
-					cs.Yellowf("A new release of %s is available:", ext.Name()),
-					cs.Cyan(strings.TrimPrefix(ext.CurrentVersion(), "v")),
-					cs.Cyan(strings.TrimPrefix(releaseInfo.Version, "v")))
-				if ext.IsPinned() {
-					fmt.Fprintf(stderr, "To upgrade, run: gh extension upgrade %s --force\n", ext.Name())
-				} else {
-					fmt.Fprintf(stderr, "To upgrade, run: gh extension upgrade %s\n", ext.Name())
+			select {
+			case releaseInfo := <-updateMessageChan:
+				if releaseInfo != nil {
+					stderr := io.ErrOut
+					fmt.Fprintf(stderr, "\n\n%s %s → %s\n",
+						cs.Yellowf("A new release of %s is available:", ext.Name()),
+						cs.Cyan(strings.TrimPrefix(ext.CurrentVersion(), "v")),
+						cs.Cyan(strings.TrimPrefix(releaseInfo.Version, "v")))
+					if ext.IsPinned() {
+						fmt.Fprintf(stderr, "To upgrade, run: gh extension upgrade %s --force\n", ext.Name())
+					} else {
+						fmt.Fprintf(stderr, "To upgrade, run: gh extension upgrade %s\n", ext.Name())
+					}
+					fmt.Fprintf(stderr, "%s\n\n",
+						cs.Yellow(releaseInfo.URL))
 				}
-				fmt.Fprintf(stderr, "%s\n\n",
-					cs.Yellow(releaseInfo.URL))
+			default:
+				// Do not make the user wait for extension update check if incomplete by this time.
+				// This is being handled in non-blocking default as there is no context to cancel like in gh update checks.
 			}
 		},
 		GroupID: "extension",
diff --git a/pkg/cmd/root/extension_test.go b/pkg/cmd/root/extension_test.go
index 32b250de5..7dd66df31 100644
--- a/pkg/cmd/root/extension_test.go
+++ b/pkg/cmd/root/extension_test.go
@@ -3,6 +3,7 @@ package root_test
 import (
 	"io"
 	"testing"
+	"time"
 
 	"github.com/MakeNowJust/heredoc"
 	"github.com/cli/cli/v2/internal/update"
@@ -121,6 +122,8 @@ func TestNewCmdExtension_Updates(t *testing.T) {
 		em := &extensions.ExtensionManagerMock{
 			DispatchFunc: func(args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) (bool, error) {
 				// Assume extension executed / dispatched without problems as test is focused on upgrade checking.
+				// Sleep for 1 second to allow update checking logic to complete.
+				time.Sleep(1 * time.Second)
 				return true, nil
 			},
 		}
@@ -169,3 +172,51 @@ func TestNewCmdExtension_Updates(t *testing.T) {
 		}
 	}
 }
+
+func TestNewCmdExtension_UpdateCheckIsNonblocking(t *testing.T) {
+	ios, _, _, stderr := iostreams.Test()
+
+	em := &extensions.ExtensionManagerMock{
+		DispatchFunc: func(args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) (bool, error) {
+			// Assume extension executed / dispatched without problems as test is focused on upgrade checking.
+			return true, nil
+		},
+	}
+
+	ext := &extensions.ExtensionMock{
+		CurrentVersionFunc: func() string {
+			return "1.0.0"
+		},
+		IsPinnedFunc: func() bool {
+			return false
+		},
+		LatestVersionFunc: func() string {
+			return "2.0.0"
+		},
+		NameFunc: func() string {
+			return "major-update"
+		},
+		UpdateAvailableFunc: func() bool {
+			return true
+		},
+		URLFunc: func() string {
+			return "https//github.com/dne/major-update"
+		},
+	}
+
+	checkFunc := func(em extensions.ExtensionManager, ext extensions.Extension) (*update.ReleaseInfo, error) {
+		// This function runs in the background as a goroutine while the extension is dispatched.
+		// Testing whether the extension cobra command is non-blocking for extension update check,
+		// this function will cause goroutine to sleep for a sufficiently long time before panicking.
+		// The idea is that the test will conclude because the dispatch function completes immediately
+		// and exits before the check update function completes.
+		time.Sleep(30 * time.Second)
+		panic("It seems like the extension cobra command might be blocking on update checking when it should not block on long update checks")
+	}
+
+	cmd := root.NewCmdExtension(ios, em, ext, checkFunc)
+
+	_, err := cmd.ExecuteC()
+	require.NoError(t, err)
+	require.Emptyf(t, stderr.String(), "long running, non-blocking extension update check should not have displayed anything on stderr")
+}

From 3feeb9a826e31cd6afbb884a4deeade37c802364 Mon Sep 17 00:00:00 2001
From: Tyler McGoffin <jtmcg@github.com>
Date: Tue, 14 Jan 2025 11:41:20 -0800
Subject: [PATCH 66/68] Add tests for deleteGist

---
 pkg/cmd/gist/delete/delete_test.go | 70 ++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/pkg/cmd/gist/delete/delete_test.go b/pkg/cmd/gist/delete/delete_test.go
index 74c511237..24ca2bb33 100644
--- a/pkg/cmd/gist/delete/delete_test.go
+++ b/pkg/cmd/gist/delete/delete_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/cli/cli/v2/api"
 	"github.com/cli/cli/v2/internal/config"
 	"github.com/cli/cli/v2/internal/gh"
 	"github.com/cli/cli/v2/internal/prompter"
@@ -14,6 +15,7 @@ import (
 	"github.com/cli/cli/v2/pkg/cmdutil"
 	"github.com/cli/cli/v2/pkg/httpmock"
 	"github.com/cli/cli/v2/pkg/iostreams"
+	ghAPI "github.com/cli/go-gh/v2/pkg/api"
 	"github.com/google/shlex"
 	"github.com/stretchr/testify/assert"
 )
@@ -322,3 +324,71 @@ func Test_deleteRun(t *testing.T) {
 		})
 	}
 }
+
+func Test_gistDelete(t *testing.T) {
+	tests := []struct {
+		name      string
+		httpStubs func(*httpmock.Registry)
+		hostname  string
+		gistID    string
+		wantErr   error
+	}{
+		{
+			name: "successful delete",
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.REST("DELETE", "gists/1234"),
+					httpmock.StatusStringResponse(204, "{}"),
+				)
+			},
+			hostname: "github.com",
+			gistID:   "1234",
+			wantErr:  nil,
+		},
+		{
+			name: "when an gist is not found, it returns a NotFoundError",
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.REST("DELETE", "gists/1234"),
+					httpmock.StatusStringResponse(404, "{}"),
+				)
+			},
+			hostname: "github.com",
+			gistID:   "1234",
+			wantErr:  shared.NotFoundErr,
+		},
+		{
+			name: "when there is a non-404 error deleting the gist, that error is returned",
+			httpStubs: func(reg *httpmock.Registry) {
+				reg.Register(
+					httpmock.REST("DELETE", "gists/1234"),
+					httpmock.StatusJSONResponse(500, `{"message": "arbitrary error"}`),
+				)
+			},
+			hostname: "github.com",
+			gistID:   "1234",
+			wantErr: api.HTTPError{
+				HTTPError: &ghAPI.HTTPError{
+					StatusCode: 500,
+					Message:    "arbitrary error",
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			reg := &httpmock.Registry{}
+			tt.httpStubs(reg)
+			client := api.NewClientFromHTTP(&http.Client{Transport: reg})
+
+			err := deleteGist(client, tt.hostname, tt.gistID)
+			if tt.wantErr != nil {
+				assert.ErrorAs(t, err, &tt.wantErr)
+			} else {
+				assert.NoError(t, err)
+			}
+
+		})
+	}
+}

From 243acaf5792d62234f769c2a9125f81616cd6328 Mon Sep 17 00:00:00 2001
From: Andy Feller <andyfeller@github.com>
Date: Thu, 16 Jan 2025 00:08:45 -0500
Subject: [PATCH 67/68] Refactor test based on PR feedback

---
 pkg/cmd/root/extension_test.go | 34 ++++++++++++++++++++++------------
 1 file changed, 22 insertions(+), 12 deletions(-)

diff --git a/pkg/cmd/root/extension_test.go b/pkg/cmd/root/extension_test.go
index 7dd66df31..8246c0e2a 100644
--- a/pkg/cmd/root/extension_test.go
+++ b/pkg/cmd/root/extension_test.go
@@ -1,6 +1,7 @@
 package root_test
 
 import (
+	"fmt"
 	"io"
 	"testing"
 	"time"
@@ -122,8 +123,6 @@ func TestNewCmdExtension_Updates(t *testing.T) {
 		em := &extensions.ExtensionManagerMock{
 			DispatchFunc: func(args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) (bool, error) {
 				// Assume extension executed / dispatched without problems as test is focused on upgrade checking.
-				// Sleep for 1 second to allow update checking logic to complete.
-				time.Sleep(1 * time.Second)
 				return true, nil
 			},
 		}
@@ -174,7 +173,7 @@ func TestNewCmdExtension_Updates(t *testing.T) {
 }
 
 func TestNewCmdExtension_UpdateCheckIsNonblocking(t *testing.T) {
-	ios, _, _, stderr := iostreams.Test()
+	ios, _, _, _ := iostreams.Test()
 
 	em := &extensions.ExtensionManagerMock{
 		DispatchFunc: func(args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) (bool, error) {
@@ -204,19 +203,30 @@ func TestNewCmdExtension_UpdateCheckIsNonblocking(t *testing.T) {
 		},
 	}
 
+	// When the extension command is executed, the checkFunc will run in the background longer than the extension dispatch.
+	// If the update check is non-blocking, then the extension command will complete immediately while checkFunc is still running.
 	checkFunc := func(em extensions.ExtensionManager, ext extensions.Extension) (*update.ReleaseInfo, error) {
-		// This function runs in the background as a goroutine while the extension is dispatched.
-		// Testing whether the extension cobra command is non-blocking for extension update check,
-		// this function will cause goroutine to sleep for a sufficiently long time before panicking.
-		// The idea is that the test will conclude because the dispatch function completes immediately
-		// and exits before the check update function completes.
 		time.Sleep(30 * time.Second)
-		panic("It seems like the extension cobra command might be blocking on update checking when it should not block on long update checks")
+		return nil, fmt.Errorf("update check should not have completed")
 	}
 
 	cmd := root.NewCmdExtension(ios, em, ext, checkFunc)
 
-	_, err := cmd.ExecuteC()
-	require.NoError(t, err)
-	require.Emptyf(t, stderr.String(), "long running, non-blocking extension update check should not have displayed anything on stderr")
+	// The test whether update check is non-blocking is based on how long it takes for the extension command execution.
+	// If there is no wait time as checkFunc is sleeping sufficiently long, we can trust update check is non-blocking.
+	// Otherwise, if any amount of wait is encountered, it is a decent indicator that update checking is blocking.
+	// This is not an ideal test and indicates the update design should be revisited to be easier to understand and manage.
+	completed := make(chan struct{})
+	go func() {
+		_, err := cmd.ExecuteC()
+		require.NoError(t, err)
+		close(completed)
+	}()
+
+	select {
+	case <-completed:
+		// Expected behavior assuming extension dispatch exits immediately while checkFunc is still running.
+	case <-time.After(1 * time.Second):
+		t.Fatal("extension update check should have exited")
+	}
 }

From cc4bf0fc9fc58da7f4eb522aad3fa41f0f0068f5 Mon Sep 17 00:00:00 2001
From: William Martin <williammartin@github.com>
Date: Thu, 16 Jan 2025 14:10:42 +0100
Subject: [PATCH 68/68] Add small wait to extension update tests

---
 pkg/cmd/root/extension_test.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/pkg/cmd/root/extension_test.go b/pkg/cmd/root/extension_test.go
index 8246c0e2a..5e9e9b9bc 100644
--- a/pkg/cmd/root/extension_test.go
+++ b/pkg/cmd/root/extension_test.go
@@ -123,6 +123,10 @@ func TestNewCmdExtension_Updates(t *testing.T) {
 		em := &extensions.ExtensionManagerMock{
 			DispatchFunc: func(args []string, stdin io.Reader, stdout io.Writer, stderr io.Writer) (bool, error) {
 				// Assume extension executed / dispatched without problems as test is focused on upgrade checking.
+				// Sleep for 100 milliseconds to allow update checking logic to complete. This would be better
+				// served by making the behaviour controllable by channels, but it's a larger change than desired
+				// just to improve the test.
+				time.Sleep(100 * time.Millisecond)
 				return true, nil
 			},
 		}