InTheForest/moby
1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2026-01-11 18:51:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

errdefs: replace uses of errdefs package

Browse Source 
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>
This commit is contained in:
Matthieu MOREL
2025-05-28 05:39:19 +00:00
parent 083ccfa486
commit 6ee53a6831
2 changed files with 59 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
errdefs/helpers.go
View File

@@ -1,6 +1,10 @@
package errdefs package errdefs
import "context" import (
"context"
cerrdefs "github.com/containerd/errdefs"
)
type errNotFound struct{ error } type errNotFound struct{ error }
@@ -18,7 +22,7 @@ func (e errNotFound) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrNotFound], // [ErrNotFound],
func NotFound(err error) error { func NotFound(err error) error {
if err == nil || IsNotFound(err) { if err == nil || cerrdefs.IsNotFound(err) {
return err return err
} }
return errNotFound{err} return errNotFound{err}
@@ -40,7 +44,7 @@ func (e errInvalidParameter) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrInvalidParameter], // [ErrInvalidParameter],
func InvalidParameter(err error) error { func InvalidParameter(err error) error {
if err == nil || IsInvalidParameter(err) { if err == nil || cerrdefs.IsInvalidArgument(err) {
return err return err
} }
return errInvalidParameter{err} return errInvalidParameter{err}
@@ -62,7 +66,7 @@ func (e errConflict) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrConflict], // [ErrConflict],
func Conflict(err error) error { func Conflict(err error) error {
if err == nil || IsConflict(err) { if err == nil || cerrdefs.IsConflict(err) {
return err return err
} }
return errConflict{err} return errConflict{err}
@@ -84,7 +88,7 @@ func (e errUnauthorized) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrUnauthorized], // [ErrUnauthorized],
func Unauthorized(err error) error { func Unauthorized(err error) error {
if err == nil || IsUnauthorized(err) { if err == nil || cerrdefs.IsUnauthorized(err) {
return err return err
} }
return errUnauthorized{err} return errUnauthorized{err}
@@ -106,7 +110,7 @@ func (e errUnavailable) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrUnavailable], // [ErrUnavailable],
func Unavailable(err error) error { func Unavailable(err error) error {
if err == nil || IsUnavailable(err) { if err == nil || cerrdefs.IsUnavailable(err) {
return err return err
} }
return errUnavailable{err} return errUnavailable{err}
@@ -128,7 +132,7 @@ func (e errForbidden) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrForbidden], // [ErrForbidden],
func Forbidden(err error) error { func Forbidden(err error) error {
if err == nil || IsForbidden(err) { if err == nil || cerrdefs.IsPermissionDenied(err) {
return err return err
} }
return errForbidden{err} return errForbidden{err}
@@ -150,7 +154,7 @@ func (e errSystem) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrSystem], // [ErrSystem],
func System(err error) error { func System(err error) error {
if err == nil || IsSystem(err) { if err == nil || cerrdefs.IsInternal(err) {
return err return err
} }
return errSystem{err} return errSystem{err}
@@ -172,7 +176,7 @@ func (e errNotModified) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [NotModified], // [NotModified],
func NotModified(err error) error { func NotModified(err error) error {
if err == nil || IsNotModified(err) { if err == nil || cerrdefs.IsNotModified(err) {
return err return err
} }
return errNotModified{err} return errNotModified{err}
@@ -194,7 +198,7 @@ func (e errNotImplemented) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrNotImplemented], // [ErrNotImplemented],
func NotImplemented(err error) error { func NotImplemented(err error) error {
if err == nil || IsNotImplemented(err) { if err == nil || cerrdefs.IsNotImplemented(err) {
return err return err
} }
return errNotImplemented{err} return errNotImplemented{err}
@@ -216,7 +220,7 @@ func (e errUnknown) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrUnknown], // [ErrUnknown],
func Unknown(err error) error { func Unknown(err error) error {
if err == nil || IsUnknown(err) { if err == nil || cerrdefs.IsUnknown(err) {
return err return err
} }
return errUnknown{err} return errUnknown{err}
@@ -238,7 +242,7 @@ func (e errCancelled) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrCancelled], // [ErrCancelled],
func Cancelled(err error) error { func Cancelled(err error) error {
if err == nil || IsCancelled(err) { if err == nil || cerrdefs.IsCanceled(err) {
return err return err
} }
return errCancelled{err} return errCancelled{err}
@@ -260,7 +264,7 @@ func (e errDeadline) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrDeadline], // [ErrDeadline],
func Deadline(err error) error { func Deadline(err error) error {
if err == nil || IsDeadline(err) { if err == nil || cerrdefs.IsDeadlineExceeded(err) {
return err return err
} }
return errDeadline{err} return errDeadline{err}
@@ -282,7 +286,7 @@ func (e errDataLoss) Unwrap() error {
// It returns the error as-is if it is either nil (no error) or already implements // It returns the error as-is if it is either nil (no error) or already implements
// [ErrDataLoss], // [ErrDataLoss],
func DataLoss(err error) error { func DataLoss(err error) error {
if err == nil || IsDataLoss(err) { if err == nil || cerrdefs.IsDataLoss(err) {
return err return err
} }
return errDataLoss{err} return errDataLoss{err}

80
errdefs/helpers_test.go
View File

@@ -4,6 +4,8 @@ import (
"errors" "errors"
"fmt" "fmt"
"testing" "testing"
cerrdefs "github.com/containerd/errdefs"
) )
var errTest = errors.New("this is a test") var errTest = errors.New("this is a test")
@@ -13,11 +15,11 @@ type wrapped interface {
} }
func TestNotFound(t *testing.T) { func TestNotFound(t *testing.T) {
if IsNotFound(errTest) { if cerrdefs.IsNotFound(errTest) {
t.Fatalf("did not expect not found error, got %T", errTest) t.Fatalf("did not expect not found error, got %T", errTest)
} }
e := NotFound(errTest) e := NotFound(errTest)
if !IsNotFound(e) { if !cerrdefs.IsNotFound(e) {
t.Fatalf("expected not found error, got: %T", e) t.Fatalf("expected not found error, got: %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -28,17 +30,17 @@ func TestNotFound(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsNotFound(wrapped) { if !cerrdefs.IsNotFound(wrapped) {
t.Fatalf("expected not found error, got: %T", wrapped) t.Fatalf("expected not found error, got: %T", wrapped)
} }
} }
func TestConflict(t *testing.T) { func TestConflict(t *testing.T) {
if IsConflict(errTest) { if cerrdefs.IsConflict(errTest) {
t.Fatalf("did not expect conflict error, got %T", errTest) t.Fatalf("did not expect conflict error, got %T", errTest)
} }
e := Conflict(errTest) e := Conflict(errTest)
if !IsConflict(e) { if !cerrdefs.IsConflict(e) {
t.Fatalf("expected conflict error, got: %T", e) t.Fatalf("expected conflict error, got: %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -49,17 +51,17 @@ func TestConflict(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsConflict(wrapped) { if !cerrdefs.IsConflict(wrapped) {
t.Fatalf("expected conflict error, got: %T", wrapped) t.Fatalf("expected conflict error, got: %T", wrapped)
} }
} }
func TestForbidden(t *testing.T) { func TestForbidden(t *testing.T) {
if IsForbidden(errTest) { if cerrdefs.IsPermissionDenied(errTest) {
t.Fatalf("did not expect forbidden error, got %T", errTest) t.Fatalf("did not expect forbidden error, got %T", errTest)
} }
e := Forbidden(errTest) e := Forbidden(errTest)
if !IsForbidden(e) { if !cerrdefs.IsPermissionDenied(e) {
t.Fatalf("expected forbidden error, got: %T", e) t.Fatalf("expected forbidden error, got: %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -70,17 +72,17 @@ func TestForbidden(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsForbidden(wrapped) { if !cerrdefs.IsPermissionDenied(wrapped) {
t.Fatalf("expected forbidden error, got: %T", wrapped) t.Fatalf("expected forbidden error, got: %T", wrapped)
} }
} }
func TestInvalidParameter(t *testing.T) { func TestInvalidParameter(t *testing.T) {
if IsInvalidParameter(errTest) { if cerrdefs.IsInvalidArgument(errTest) {
t.Fatalf("did not expect invalid argument error, got %T", errTest) t.Fatalf("did not expect invalid argument error, got %T", errTest)
} }
e := InvalidParameter(errTest) e := InvalidParameter(errTest)
if !IsInvalidParameter(e) { if !cerrdefs.IsInvalidArgument(e) {
t.Fatalf("expected invalid argument error, got %T", e) t.Fatalf("expected invalid argument error, got %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -91,17 +93,17 @@ func TestInvalidParameter(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsInvalidParameter(wrapped) { if !cerrdefs.IsInvalidArgument(wrapped) {
t.Fatalf("expected invalid argument error, got: %T", wrapped) t.Fatalf("expected invalid argument error, got: %T", wrapped)
} }
} }
func TestNotImplemented(t *testing.T) { func TestNotImplemented(t *testing.T) {
if IsNotImplemented(errTest) { if cerrdefs.IsNotImplemented(errTest) {
t.Fatalf("did not expect not implemented error, got %T", errTest) t.Fatalf("did not expect not implemented error, got %T", errTest)
} }
e := NotImplemented(errTest) e := NotImplemented(errTest)
if !IsNotImplemented(e) { if !cerrdefs.IsNotImplemented(e) {
t.Fatalf("expected not implemented error, got %T", e) t.Fatalf("expected not implemented error, got %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -112,17 +114,17 @@ func TestNotImplemented(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsNotImplemented(wrapped) { if !cerrdefs.IsNotImplemented(wrapped) {
t.Fatalf("expected not implemented error, got: %T", wrapped) t.Fatalf("expected not implemented error, got: %T", wrapped)
} }
} }
func TestNotModified(t *testing.T) { func TestNotModified(t *testing.T) {
if IsNotModified(errTest) { if cerrdefs.IsNotModified(errTest) {
t.Fatalf("did not expect not modified error, got %T", errTest) t.Fatalf("did not expect not modified error, got %T", errTest)
} }
e := NotModified(errTest) e := NotModified(errTest)
if !IsNotModified(e) { if !cerrdefs.IsNotModified(e) {
t.Fatalf("expected not modified error, got %T", e) t.Fatalf("expected not modified error, got %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -133,17 +135,17 @@ func TestNotModified(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsNotModified(wrapped) { if !cerrdefs.IsNotModified(wrapped) {
t.Fatalf("expected not modified error, got: %T", wrapped) t.Fatalf("expected not modified error, got: %T", wrapped)
} }
} }
func TestUnauthorized(t *testing.T) { func TestUnauthorized(t *testing.T) {
if IsUnauthorized(errTest) { if cerrdefs.IsUnauthorized(errTest) {
t.Fatalf("did not expect unauthorized error, got %T", errTest) t.Fatalf("did not expect unauthorized error, got %T", errTest)
} }
e := Unauthorized(errTest) e := Unauthorized(errTest)
if !IsUnauthorized(e) { if !cerrdefs.IsUnauthorized(e) {
t.Fatalf("expected unauthorized error, got %T", e) t.Fatalf("expected unauthorized error, got %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -154,17 +156,17 @@ func TestUnauthorized(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsUnauthorized(wrapped) { if !cerrdefs.IsUnauthorized(wrapped) {
t.Fatalf("expected unauthorized error, got: %T", wrapped) t.Fatalf("expected unauthorized error, got: %T", wrapped)
} }
} }
func TestUnknown(t *testing.T) { func TestUnknown(t *testing.T) {
if IsUnknown(errTest) { if cerrdefs.IsUnknown(errTest) {
t.Fatalf("did not expect unknown error, got %T", errTest) t.Fatalf("did not expect unknown error, got %T", errTest)
} }
e := Unknown(errTest) e := Unknown(errTest)
if !IsUnknown(e) { if !cerrdefs.IsUnknown(e) {
t.Fatalf("expected unknown error, got %T", e) t.Fatalf("expected unknown error, got %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -175,17 +177,17 @@ func TestUnknown(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsUnknown(wrapped) { if !cerrdefs.IsUnknown(wrapped) {
t.Fatalf("expected unknown error, got: %T", wrapped) t.Fatalf("expected unknown error, got: %T", wrapped)
} }
} }
func TestCancelled(t *testing.T) { func TestCancelled(t *testing.T) {
if IsCancelled(errTest) { if cerrdefs.IsCanceled(errTest) {
t.Fatalf("did not expect cancelled error, got %T", errTest) t.Fatalf("did not expect cancelled error, got %T", errTest)
} }
e := Cancelled(errTest) e := Cancelled(errTest)
if !IsCancelled(e) { if !cerrdefs.IsCanceled(e) {
t.Fatalf("expected cancelled error, got %T", e) t.Fatalf("expected cancelled error, got %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -196,17 +198,17 @@ func TestCancelled(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsCancelled(wrapped) { if !cerrdefs.IsCanceled(wrapped) {
t.Fatalf("expected cancelled error, got: %T", wrapped) t.Fatalf("expected cancelled error, got: %T", wrapped)
} }
} }
func TestDeadline(t *testing.T) { func TestDeadline(t *testing.T) {
if IsDeadline(errTest) { if cerrdefs.IsDeadlineExceeded(errTest) {
t.Fatalf("did not expect deadline error, got %T", errTest) t.Fatalf("did not expect deadline error, got %T", errTest)
} }
e := Deadline(errTest) e := Deadline(errTest)
if !IsDeadline(e) { if !cerrdefs.IsDeadlineExceeded(e) {
t.Fatalf("expected deadline error, got %T", e) t.Fatalf("expected deadline error, got %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -217,17 +219,17 @@ func TestDeadline(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsDeadline(wrapped) { if !cerrdefs.IsDeadlineExceeded(wrapped) {
t.Fatalf("expected deadline error, got: %T", wrapped) t.Fatalf("expected deadline error, got: %T", wrapped)
} }
} }
func TestDataLoss(t *testing.T) { func TestDataLoss(t *testing.T) {
if IsDataLoss(errTest) { if cerrdefs.IsDataLoss(errTest) {
t.Fatalf("did not expect data loss error, got %T", errTest) t.Fatalf("did not expect data loss error, got %T", errTest)
} }
e := DataLoss(errTest) e := DataLoss(errTest)
if !IsDataLoss(e) { if !cerrdefs.IsDataLoss(e) {
t.Fatalf("expected data loss error, got %T", e) t.Fatalf("expected data loss error, got %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -238,17 +240,17 @@ func TestDataLoss(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsDataLoss(wrapped) { if !cerrdefs.IsDataLoss(wrapped) {
t.Fatalf("expected data loss error, got: %T", wrapped) t.Fatalf("expected data loss error, got: %T", wrapped)
} }
} }
func TestUnavailable(t *testing.T) { func TestUnavailable(t *testing.T) {
if IsUnavailable(errTest) { if cerrdefs.IsUnavailable(errTest) {
t.Fatalf("did not expect unavaillable error, got %T", errTest) t.Fatalf("did not expect unavaillable error, got %T", errTest)
} }
e := Unavailable(errTest) e := Unavailable(errTest)
if !IsUnavailable(e) { if !cerrdefs.IsUnavailable(e) {
t.Fatalf("expected unavaillable error, got %T", e) t.Fatalf("expected unavaillable error, got %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -259,17 +261,17 @@ func TestUnavailable(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsUnavailable(wrapped) { if !cerrdefs.IsUnavailable(wrapped) {
t.Fatalf("expected unavaillable error, got: %T", wrapped) t.Fatalf("expected unavaillable error, got: %T", wrapped)
} }
} }
func TestSystem(t *testing.T) { func TestSystem(t *testing.T) {
if IsSystem(errTest) { if cerrdefs.IsInternal(errTest) {
t.Fatalf("did not expect system error, got %T", errTest) t.Fatalf("did not expect system error, got %T", errTest)
} }
e := System(errTest) e := System(errTest)
if !IsSystem(e) { if !cerrdefs.IsInternal(e) {
t.Fatalf("expected system error, got %T", e) t.Fatalf("expected system error, got %T", e)
} }
if cause := e.(wrapped).Unwrap(); cause != errTest { if cause := e.(wrapped).Unwrap(); cause != errTest {
@@ -280,7 +282,7 @@ func TestSystem(t *testing.T) {
} }
wrapped := fmt.Errorf("foo: %w", e) wrapped := fmt.Errorf("foo: %w", e)
if !IsSystem(wrapped) { if !cerrdefs.IsInternal(wrapped) {
t.Fatalf("expected system error, got: %T", wrapped) t.Fatalf("expected system error, got: %T", wrapped)
} }
} }