Method TestFromError_Wrapped

status/status_ext_test.go:264–317

(t *testing.T)

}

func (s) TestFromError_Wrapped(t *testing.T) {
	base := status.New(codes.Canceled, "inner canceled")
	sWithDetails, err := base.WithDetails(&testpb.Empty{})
	if err != nil {
		t.Fatalf("WithDetails failed: %v", err)
	}
	innerErr := sWithDetails.Err()
	mustStatus := func(message string) *status.Status {
		st, err := status.New(codes.Canceled, message).WithDetails(&testpb.Empty{})
		if err != nil {
			t.Fatal(err)
		}
		return st
	}

	testCases := []struct {
		name       string
		err        error
		wantStatus *status.Status
	}{
		{
			name:       "direct_error",
			err:        innerErr,
			wantStatus: mustStatus("inner canceled"),
		},
		{
			name:       "wrapped_error",
			err:        fmt.Errorf("wrapped: %w", innerErr),
			wantStatus: mustStatus("wrapped: rpc error: code = Canceled desc = inner canceled"),
		},
		{
			name:       "double_wrapped_error",
			err:        fmt.Errorf("outer: %w", fmt.Errorf("inner: %w", innerErr)),
			wantStatus: mustStatus("outer: inner: rpc error: code = Canceled desc = inner canceled"),
		},
		{
			name:       "double_wrapped_single_errorf",
			err:        fmt.Errorf("error: %w: %w", errors.New("test error"), innerErr),
			wantStatus: mustStatus("error: test error: rpc error: code = Canceled desc = inner canceled"),
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			got, ok := status.FromError(tc.err)
			if !ok {
				t.Fatalf("status.FromError(%v) returned false; want true", tc.err)
			}
			if diff := cmp.Diff(tc.wantStatus, got, protocmp.Transform(), cmp.AllowUnexported(status.Status{})); diff != "" {
				t.Fatalf("status.FromError(%v) got unexpected output, diff (-want +got):\n%s", tc.err, diff)
			}
		})
	}
}