fix(forge): a close refused for open dependencies is a typed error across the boundary (#1922)
This commit is contained in:
8 files changed
+156
-39
No files matched your search
@@ -63,7 +63,6 @@ require (
|
||||
golang.org/x/text v0.44.0 // indirect
|
||||
golang.org/x/time v0.16.0 // indirect
|
||||
google.golang.org/genproto/googleapis/api v0.0.0-20261110000943-09e21b237f2c // indirect
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20261110000943-09e21b237f2c // indirect
|
||||
)
|
||||
|
||||
require (
|
||||
@@ -106,6 +105,7 @@ require (
|
||||
golang.org/x/oauth2 v0.38.0
|
||||
golang.org/x/sys v0.50.0
|
||||
golang.org/x/term v0.48.0
|
||||
google.golang.org/genproto/googleapis/rpc v0.0.0-20261110000943-09e21b237f2c
|
||||
google.golang.org/grpc v1.86.0-dev
|
||||
google.golang.org/protobuf v1.36.12
|
||||
gopkg.in/yaml.v3 v3.0.1
|
||||
|
||||
@@ -3,10 +3,12 @@ package workflow
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"testing"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
||||
"github.com/samcharles93/archie-core/internal/forge"
|
||||
)
|
||||
|
||||
type closeForge struct {
|
||||
@@ -39,7 +41,7 @@ func TestCloseIssueRefusedForDependenciesRecordsTheDecision(t *testing.T) {
|
||||
wantLabels int
|
||||
}{
|
||||
{name: "closes"},
|
||||
{name: "open dependencies are commented and labelled", closeErr: errors.New("close issue: it still has open dependencies"), wantComments: 1, wantLabels: 1},
|
||||
{name: "open dependencies are commented and labelled", closeErr: fmt.Errorf("close issue: %w", forge.ErrBlockedByDependencies), wantComments: 1, wantLabels: 1},
|
||||
{name: "other failures still park", closeErr: errors.New("forge unreachable"), wantErr: true},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
|
||||
@@ -3,6 +3,7 @@ package workflow
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"maps"
|
||||
"slices"
|
||||
@@ -11,6 +12,7 @@ import (
|
||||
"gopkg.in/yaml.v3"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
|
||||
"github.com/samcharles93/archie-core/internal/forge"
|
||||
)
|
||||
|
||||
// Control step types: they decide where the task goes next.
|
||||
@@ -117,7 +119,7 @@ const blockedLabel = "blocked"
|
||||
func closeIssueOrRecordBlock(ctx context.Context, tc *TaskContext) error {
|
||||
t := tc.Task
|
||||
err := tc.Forge.CloseIssue(ctx, t.Owner, t.Repo, t.IssueNumber, "")
|
||||
if err == nil || !strings.Contains(strings.ToLower(err.Error()), "dependenc") {
|
||||
if !errors.Is(err, forge.ErrBlockedByDependencies) {
|
||||
return err
|
||||
}
|
||||
note := fmt.Sprintf("Ready to close, but the forge refused because the issue has open dependencies: %s\n\nClose it once they are resolved.", err)
|
||||
|
||||
@@ -5,10 +5,16 @@ package forge
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"io"
|
||||
"time"
|
||||
)
|
||||
|
||||
// ErrBlockedByDependencies is returned by CloseIssue when the forge refuses to
|
||||
// close an issue that still has open dependencies. Callers match it with
|
||||
// errors.Is; the forge's own message stays in the error text.
|
||||
var ErrBlockedByDependencies = errors.New("forge refused: open dependencies")
|
||||
|
||||
// Issue is a forge-neutral representation of an issue (not a PR).
|
||||
type Issue struct {
|
||||
Number int
|
||||
|
||||
@@ -32,6 +32,12 @@ const (
|
||||
SubjectReplyToReview = "archie.forge.reply_to_review"
|
||||
)
|
||||
|
||||
// errorCodes is the wire table for forge sentinels; server and client must
|
||||
// share it so a refusal reaches the caller as the same sentinel.
|
||||
var errorCodes = map[string]error{"blocked_by_dependencies": forge.ErrBlockedByDependencies}
|
||||
|
||||
func envelope(err error) natsrpc.Envelope { return natsrpc.NewEnvelopeWith(err, errorCodes) }
|
||||
|
||||
// Subjects returns every forge RPC subject identity's server answers: the
|
||||
// set a task of that identity may publish to.
|
||||
func Subjects(identity string) []string {
|
||||
@@ -247,92 +253,92 @@ func (s *Server) authorizedForge(ctx context.Context, identity string, target Ta
|
||||
func (s *Server) handleComment(ctx context.Context, identity string, msg *nats.Msg) {
|
||||
var req CommentRequest
|
||||
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
||||
s.respond(msg, CommentResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode comment request: %w", err))})
|
||||
s.respond(msg, CommentResponse{Envelope: envelope(fmt.Errorf("decode comment request: %w", err))})
|
||||
return
|
||||
}
|
||||
client, err := s.authorizedForge(ctx, identity, req.Target, "comment")
|
||||
if err != nil {
|
||||
s.respond(msg, CommentResponse{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, CommentResponse{Envelope: envelope(err)})
|
||||
return
|
||||
}
|
||||
id, err := client.Comment(ctx, req.Owner, req.Repo, req.Number, req.Body)
|
||||
s.respond(msg, CommentResponse{ID: id, Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, CommentResponse{ID: id, Envelope: envelope(err)})
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateIssue(ctx context.Context, identity string, msg *nats.Msg) {
|
||||
var req CreateIssueRequest
|
||||
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
||||
s.respond(msg, CreateIssueResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode create_issue request: %w", err))})
|
||||
s.respond(msg, CreateIssueResponse{Envelope: envelope(fmt.Errorf("decode create_issue request: %w", err))})
|
||||
return
|
||||
}
|
||||
client, err := s.authorizedForge(ctx, identity, req.Target, "comment")
|
||||
if err != nil {
|
||||
s.respond(msg, CreateIssueResponse{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, CreateIssueResponse{Envelope: envelope(err)})
|
||||
return
|
||||
}
|
||||
number, err := client.CreateIssue(ctx, req.Owner, req.Repo, req.Title, req.Body, req.Labels)
|
||||
s.respond(msg, CreateIssueResponse{Number: number, Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, CreateIssueResponse{Number: number, Envelope: envelope(err)})
|
||||
}
|
||||
|
||||
func (s *Server) handleCloseIssue(ctx context.Context, identity string, msg *nats.Msg) {
|
||||
var req CloseIssueRequest
|
||||
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode close_issue request: %w", err))})
|
||||
s.respond(msg, Response{Envelope: envelope(fmt.Errorf("decode close_issue request: %w", err))})
|
||||
return
|
||||
}
|
||||
client, err := s.authorizedForge(ctx, identity, req.Target, "comment")
|
||||
if err != nil {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, Response{Envelope: envelope(err)})
|
||||
return
|
||||
}
|
||||
err = client.CloseIssue(ctx, req.Owner, req.Repo, req.Number, req.Comment)
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, Response{Envelope: envelope(err)})
|
||||
}
|
||||
|
||||
func (s *Server) handleCreatePR(ctx context.Context, identity string, msg *nats.Msg) {
|
||||
var req CreatePRRequest
|
||||
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
||||
s.respond(msg, CreatePRResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode create_pr request: %w", err))})
|
||||
s.respond(msg, CreatePRResponse{Envelope: envelope(fmt.Errorf("decode create_pr request: %w", err))})
|
||||
return
|
||||
}
|
||||
client, err := s.authorizedForge(ctx, identity, req.Target, "open_pr")
|
||||
if err != nil {
|
||||
s.respond(msg, CreatePRResponse{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, CreatePRResponse{Envelope: envelope(err)})
|
||||
return
|
||||
}
|
||||
num, err := client.CreatePR(ctx, req.Owner, req.Repo, req.Title, req.Head, req.Base, req.Body)
|
||||
s.respond(msg, CreatePRResponse{Number: num, Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, CreatePRResponse{Number: num, Envelope: envelope(err)})
|
||||
}
|
||||
|
||||
func (s *Server) handleLinkBranch(ctx context.Context, identity string, msg *nats.Msg) {
|
||||
var req LinkBranchRequest
|
||||
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode link_branch request: %w", err))})
|
||||
s.respond(msg, Response{Envelope: envelope(fmt.Errorf("decode link_branch request: %w", err))})
|
||||
return
|
||||
}
|
||||
client, err := s.authorizedForge(ctx, identity, req.Target, "open_pr")
|
||||
if err != nil {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, Response{Envelope: envelope(err)})
|
||||
return
|
||||
}
|
||||
err = client.LinkBranch(ctx, req.Owner, req.Repo, req.IssueNumber, req.Branch)
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, Response{Envelope: envelope(err)})
|
||||
}
|
||||
|
||||
func (s *Server) handleCreateReviewComments(ctx context.Context, identity string, msg *nats.Msg) {
|
||||
var req CreateReviewCommentsRequest
|
||||
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode create_review_comments request: %w", err))})
|
||||
s.respond(msg, Response{Envelope: envelope(fmt.Errorf("decode create_review_comments request: %w", err))})
|
||||
return
|
||||
}
|
||||
client, err := s.authorizedForge(ctx, identity, req.Target, "review")
|
||||
if err != nil {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, Response{Envelope: envelope(err)})
|
||||
return
|
||||
}
|
||||
writer, ok := client.(forge.ReviewCommentWriter)
|
||||
if !ok {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(errors.New("this forge cannot post review comments"))})
|
||||
s.respond(msg, Response{Envelope: envelope(errors.New("this forge cannot post review comments"))})
|
||||
return
|
||||
}
|
||||
comments := make([]forge.InlineReviewComment, 0, len(req.Comments))
|
||||
@@ -341,42 +347,42 @@ func (s *Server) handleCreateReviewComments(ctx context.Context, identity string
|
||||
}
|
||||
review := forge.ReviewSubmission{Event: req.Event, Body: req.Body, Comments: comments}
|
||||
err = writer.CreateReviewComments(ctx, req.Owner, req.Repo, req.Number, req.ReviewedHeadSHA, review)
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, Response{Envelope: envelope(err)})
|
||||
}
|
||||
|
||||
func (s *Server) handleReplyToReview(ctx context.Context, identity string, msg *nats.Msg) {
|
||||
var req ReplyToReviewRequest
|
||||
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode reply_to_review request: %w", err))})
|
||||
s.respond(msg, Response{Envelope: envelope(fmt.Errorf("decode reply_to_review request: %w", err))})
|
||||
return
|
||||
}
|
||||
client, err := s.authorizedForge(ctx, identity, req.Target, "review")
|
||||
if err != nil {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, Response{Envelope: envelope(err)})
|
||||
return
|
||||
}
|
||||
reader, ok := client.(forge.PullRequestReviewReader)
|
||||
if !ok {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(errors.New("this forge cannot reply to reviews"))})
|
||||
s.respond(msg, Response{Envelope: envelope(errors.New("this forge cannot reply to reviews"))})
|
||||
return
|
||||
}
|
||||
err = reader.ReplyToReview(ctx, req.Owner, req.Repo, req.Number, req.CommentID, req.Body)
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, Response{Envelope: envelope(err)})
|
||||
}
|
||||
|
||||
func (s *Server) handleSetStateLabel(ctx context.Context, identity string, msg *nats.Msg) {
|
||||
var req SetStateLabelRequest
|
||||
if err := json.Unmarshal(msg.Data, &req); err != nil {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode set_state_label request: %w", err))})
|
||||
s.respond(msg, Response{Envelope: envelope(fmt.Errorf("decode set_state_label request: %w", err))})
|
||||
return
|
||||
}
|
||||
client, err := s.authorizedForge(ctx, identity, req.Target, "comment")
|
||||
if err != nil {
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, Response{Envelope: envelope(err)})
|
||||
return
|
||||
}
|
||||
err = client.SetStateLabel(ctx, req.Owner, req.Repo, req.Number, req.Label, req.KnownLabels)
|
||||
s.respond(msg, Response{Envelope: natsrpc.NewEnvelope(err)})
|
||||
s.respond(msg, Response{Envelope: envelope(err)})
|
||||
}
|
||||
|
||||
func (s *Server) respond(msg *nats.Msg, v any) {
|
||||
@@ -410,7 +416,7 @@ func (c *Client) Comment(ctx context.Context, owner, repo string, number int, bo
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if err := resp.Err(); err != nil {
|
||||
if err := resp.ErrWith(errorCodes); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return resp.ID, nil
|
||||
@@ -422,7 +428,7 @@ func (c *Client) CreateIssue(ctx context.Context, owner, repo, title, body strin
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if err := resp.Err(); err != nil {
|
||||
if err := resp.ErrWith(errorCodes); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return resp.Number, nil
|
||||
@@ -434,7 +440,7 @@ func (c *Client) CloseIssue(ctx context.Context, owner, repo string, number int,
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return resp.Err()
|
||||
return resp.ErrWith(errorCodes)
|
||||
}
|
||||
|
||||
func (c *Client) CreatePR(ctx context.Context, owner, repo, title, head, base, body string) (int, error) {
|
||||
@@ -443,7 +449,7 @@ func (c *Client) CreatePR(ctx context.Context, owner, repo, title, head, base, b
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if err := resp.Err(); err != nil {
|
||||
if err := resp.ErrWith(errorCodes); err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return resp.Number, nil
|
||||
@@ -455,7 +461,7 @@ func (c *Client) LinkBranch(ctx context.Context, owner, repo string, issueNumber
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return resp.Err()
|
||||
return resp.ErrWith(errorCodes)
|
||||
}
|
||||
|
||||
// SetStateLabel remains available for RPC compatibility with older workers;
|
||||
@@ -466,7 +472,7 @@ func (c *Client) SetStateLabel(ctx context.Context, owner, repo string, number i
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return resp.Err()
|
||||
return resp.ErrWith(errorCodes)
|
||||
}
|
||||
|
||||
// CreateReviewComments submits one review on the PR through the daemon.
|
||||
@@ -483,7 +489,7 @@ func (c *Client) CreateReviewComments(ctx context.Context, owner, repo string, n
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return resp.Err()
|
||||
return resp.ErrWith(errorCodes)
|
||||
}
|
||||
|
||||
// ReplyToReview posts a threaded reply to one review comment, on behalf of
|
||||
@@ -494,5 +500,5 @@ func (c *Client) ReplyToReview(ctx context.Context, owner, repo string, number i
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return resp.Err()
|
||||
return resp.ErrWith(errorCodes)
|
||||
}
|
||||
@@ -12,6 +12,7 @@ import (
|
||||
"sync"
|
||||
|
||||
goplugin "github.com/hashicorp/go-plugin"
|
||||
"google.golang.org/genproto/googleapis/rpc/errdetails"
|
||||
"google.golang.org/grpc"
|
||||
"google.golang.org/grpc/codes"
|
||||
"google.golang.org/grpc/status"
|
||||
@@ -136,12 +137,32 @@ func call[T any](ctx context.Context, f *Forge, op string, fn func(forgev1.Forge
|
||||
if status.Code(err) == codes.Unimplemented {
|
||||
return zero, fmt.Errorf("this forge does not support %s", op)
|
||||
}
|
||||
if blockedByDependencies(err) {
|
||||
return zero, fmt.Errorf("forge %s: %w: %s", op, forge.ErrBlockedByDependencies, status.Convert(err).Message())
|
||||
}
|
||||
if err != nil {
|
||||
return zero, extensionError{op: op, err: err}
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// blockedReason is the ErrorInfo reason a forge extension attaches to a
|
||||
// FailedPrecondition close refused for open dependencies.
|
||||
const blockedReason = "BLOCKED_BY_DEPENDENCIES"
|
||||
|
||||
func blockedByDependencies(err error) bool {
|
||||
st, ok := status.FromError(err)
|
||||
if !ok || st.Code() != codes.FailedPrecondition {
|
||||
return false
|
||||
}
|
||||
for _, d := range st.Details() {
|
||||
if info, ok := d.(*errdetails.ErrorInfo); ok && info.GetReason() == blockedReason {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// extensionError prints the extension's own message without the gRPC framing
|
||||
// around it, and still unwraps to the status for callers that branch on it.
|
||||
type extensionError struct {
|
||||
|
||||
@@ -20,24 +20,60 @@ import (
|
||||
// free instead of hand-rolling an `Error string` field and its checks.
|
||||
type Envelope struct {
|
||||
Error string `json:"error,omitempty"`
|
||||
// Code names a sentinel from the table both ends pass to NewEnvelopeWith
|
||||
// and ErrWith, so the receiver can match it with errors.Is.
|
||||
Code string `json:"code,omitempty"`
|
||||
}
|
||||
|
||||
// NewEnvelope builds an Envelope from err, leaving Error empty on nil.
|
||||
func NewEnvelope(err error) Envelope {
|
||||
return NewEnvelopeWith(err, nil)
|
||||
}
|
||||
|
||||
// NewEnvelopeWith is NewEnvelope that also sets Code when err wraps one of the
|
||||
// sentinels in codes (code name to sentinel).
|
||||
func NewEnvelopeWith(err error, codes map[string]error) Envelope {
|
||||
if err == nil {
|
||||
return Envelope{}
|
||||
}
|
||||
return Envelope{Error: err.Error()}
|
||||
env := Envelope{Error: err.Error()}
|
||||
for code, sentinel := range codes {
|
||||
if errors.Is(err, sentinel) {
|
||||
env.Code = code
|
||||
break
|
||||
}
|
||||
}
|
||||
return env
|
||||
}
|
||||
|
||||
// Err converts a populated Error string back into an error, or nil.
|
||||
func (e Envelope) Err() error {
|
||||
return e.ErrWith(nil)
|
||||
}
|
||||
|
||||
// ErrWith is Err that rebuilds the sentinel named by Code from codes, so
|
||||
// errors.Is matches it. The text is the sender's, unchanged.
|
||||
func (e Envelope) ErrWith(codes map[string]error) error {
|
||||
if e.Error == "" {
|
||||
return nil
|
||||
}
|
||||
return errors.New(e.Error)
|
||||
sentinel, ok := codes[e.Code]
|
||||
if e.Code == "" || !ok {
|
||||
return errors.New(e.Error)
|
||||
}
|
||||
return codedError{msg: e.Error, sentinel: sentinel}
|
||||
}
|
||||
|
||||
// codedError keeps the sender's message and unwraps to the sentinel. It is not
|
||||
// fmt.Errorf("%s: %w"), which would repeat the sentinel's text in the message.
|
||||
type codedError struct {
|
||||
msg string
|
||||
sentinel error
|
||||
}
|
||||
|
||||
func (e codedError) Error() string { return e.msg }
|
||||
func (e codedError) Unwrap() error { return e.sentinel }
|
||||
|
||||
// Client sends timeout-bounded NATS request/reply calls.
|
||||
type Client struct {
|
||||
Conn *nats.Conn
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
package natsrpc
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/samcharles93/archie-core/internal/forge"
|
||||
)
|
||||
|
||||
// TestEnvelopeKeepsSentinel guards that a forge sentinel survives the NATS
|
||||
// envelope: a caller that matches it with errors.Is on the receiving side must
|
||||
// get the same answer as on the sending side, with the sender's text kept.
|
||||
func TestEnvelopeKeepsSentinel(t *testing.T) {
|
||||
codes := map[string]error{"blocked_by_dependencies": forge.ErrBlockedByDependencies}
|
||||
tests := []struct {
|
||||
name string
|
||||
err error
|
||||
want bool
|
||||
}{
|
||||
{name: "sentinel wrapped", err: fmt.Errorf("close issue: %w", forge.ErrBlockedByDependencies), want: true},
|
||||
{name: "plain error", err: errors.New("forge unreachable"), want: false},
|
||||
}
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
data, err := json.Marshal(NewEnvelopeWith(tt.err, codes))
|
||||
if err != nil {
|
||||
t.Fatalf("marshal envelope: %v", err)
|
||||
}
|
||||
var env Envelope
|
||||
if err := json.Unmarshal(data, &env); err != nil {
|
||||
t.Fatalf("unmarshal envelope: %v", err)
|
||||
}
|
||||
got := env.ErrWith(codes)
|
||||
if errors.Is(got, forge.ErrBlockedByDependencies) != tt.want {
|
||||
t.Errorf("errors.Is(%v, sentinel) = %t, want %t", got, !tt.want, tt.want)
|
||||
}
|
||||
if got.Error() != tt.err.Error() {
|
||||
t.Errorf("text = %q, want %q", got.Error(), tt.err.Error())
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user