github.com/rish1988/moby@v25.0.2+incompatible/errdefs/helpers_test.go (about)

     1  package errdefs
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"testing"
     7  )
     8  
     9  var errTest = errors.New("this is a test")
    10  
    11  type causal interface {
    12  	Cause() error
    13  }
    14  
    15  func TestNotFound(t *testing.T) {
    16  	if IsNotFound(errTest) {
    17  		t.Fatalf("did not expect not found error, got %T", errTest)
    18  	}
    19  	e := NotFound(errTest)
    20  	if !IsNotFound(e) {
    21  		t.Fatalf("expected not found error, got: %T", e)
    22  	}
    23  	if cause := e.(causal).Cause(); cause != errTest {
    24  		t.Fatalf("causual should be errTest, got: %v", cause)
    25  	}
    26  	if !errors.Is(e, errTest) {
    27  		t.Fatalf("expected not found error to match errTest")
    28  	}
    29  
    30  	wrapped := fmt.Errorf("foo: %w", e)
    31  	if !IsNotFound(wrapped) {
    32  		t.Fatalf("expected not found error, got: %T", wrapped)
    33  	}
    34  }
    35  
    36  func TestConflict(t *testing.T) {
    37  	if IsConflict(errTest) {
    38  		t.Fatalf("did not expect conflict error, got %T", errTest)
    39  	}
    40  	e := Conflict(errTest)
    41  	if !IsConflict(e) {
    42  		t.Fatalf("expected conflict error, got: %T", e)
    43  	}
    44  	if cause := e.(causal).Cause(); cause != errTest {
    45  		t.Fatalf("causual should be errTest, got: %v", cause)
    46  	}
    47  	if !errors.Is(e, errTest) {
    48  		t.Fatalf("expected conflict error to match errTest")
    49  	}
    50  
    51  	wrapped := fmt.Errorf("foo: %w", e)
    52  	if !IsConflict(wrapped) {
    53  		t.Fatalf("expected conflict error, got: %T", wrapped)
    54  	}
    55  }
    56  
    57  func TestForbidden(t *testing.T) {
    58  	if IsForbidden(errTest) {
    59  		t.Fatalf("did not expect forbidden error, got %T", errTest)
    60  	}
    61  	e := Forbidden(errTest)
    62  	if !IsForbidden(e) {
    63  		t.Fatalf("expected forbidden error, got: %T", e)
    64  	}
    65  	if cause := e.(causal).Cause(); cause != errTest {
    66  		t.Fatalf("causual should be errTest, got: %v", cause)
    67  	}
    68  	if !errors.Is(e, errTest) {
    69  		t.Fatalf("expected forbidden error to match errTest")
    70  	}
    71  
    72  	wrapped := fmt.Errorf("foo: %w", e)
    73  	if !IsForbidden(wrapped) {
    74  		t.Fatalf("expected forbidden error, got: %T", wrapped)
    75  	}
    76  }
    77  
    78  func TestInvalidParameter(t *testing.T) {
    79  	if IsInvalidParameter(errTest) {
    80  		t.Fatalf("did not expect invalid argument error, got %T", errTest)
    81  	}
    82  	e := InvalidParameter(errTest)
    83  	if !IsInvalidParameter(e) {
    84  		t.Fatalf("expected invalid argument error, got %T", e)
    85  	}
    86  	if cause := e.(causal).Cause(); cause != errTest {
    87  		t.Fatalf("causual should be errTest, got: %v", cause)
    88  	}
    89  	if !errors.Is(e, errTest) {
    90  		t.Fatalf("expected invalid argument error to match errTest")
    91  	}
    92  
    93  	wrapped := fmt.Errorf("foo: %w", e)
    94  	if !IsInvalidParameter(wrapped) {
    95  		t.Fatalf("expected invalid argument error, got: %T", wrapped)
    96  	}
    97  }
    98  
    99  func TestNotImplemented(t *testing.T) {
   100  	if IsNotImplemented(errTest) {
   101  		t.Fatalf("did not expect not implemented error, got %T", errTest)
   102  	}
   103  	e := NotImplemented(errTest)
   104  	if !IsNotImplemented(e) {
   105  		t.Fatalf("expected not implemented error, got %T", e)
   106  	}
   107  	if cause := e.(causal).Cause(); cause != errTest {
   108  		t.Fatalf("causual should be errTest, got: %v", cause)
   109  	}
   110  	if !errors.Is(e, errTest) {
   111  		t.Fatalf("expected not implemented error to match errTest")
   112  	}
   113  
   114  	wrapped := fmt.Errorf("foo: %w", e)
   115  	if !IsNotImplemented(wrapped) {
   116  		t.Fatalf("expected not implemented error, got: %T", wrapped)
   117  	}
   118  }
   119  
   120  func TestNotModified(t *testing.T) {
   121  	if IsNotModified(errTest) {
   122  		t.Fatalf("did not expect not modified error, got %T", errTest)
   123  	}
   124  	e := NotModified(errTest)
   125  	if !IsNotModified(e) {
   126  		t.Fatalf("expected not modified error, got %T", e)
   127  	}
   128  	if cause := e.(causal).Cause(); cause != errTest {
   129  		t.Fatalf("causual should be errTest, got: %v", cause)
   130  	}
   131  	if !errors.Is(e, errTest) {
   132  		t.Fatalf("expected not modified error to match errTest")
   133  	}
   134  
   135  	wrapped := fmt.Errorf("foo: %w", e)
   136  	if !IsNotModified(wrapped) {
   137  		t.Fatalf("expected not modified error, got: %T", wrapped)
   138  	}
   139  }
   140  
   141  func TestUnauthorized(t *testing.T) {
   142  	if IsUnauthorized(errTest) {
   143  		t.Fatalf("did not expect unauthorized error, got %T", errTest)
   144  	}
   145  	e := Unauthorized(errTest)
   146  	if !IsUnauthorized(e) {
   147  		t.Fatalf("expected unauthorized error, got %T", e)
   148  	}
   149  	if cause := e.(causal).Cause(); cause != errTest {
   150  		t.Fatalf("causual should be errTest, got: %v", cause)
   151  	}
   152  	if !errors.Is(e, errTest) {
   153  		t.Fatalf("expected unauthorized error to match errTest")
   154  	}
   155  
   156  	wrapped := fmt.Errorf("foo: %w", e)
   157  	if !IsUnauthorized(wrapped) {
   158  		t.Fatalf("expected unauthorized error, got: %T", wrapped)
   159  	}
   160  }
   161  
   162  func TestUnknown(t *testing.T) {
   163  	if IsUnknown(errTest) {
   164  		t.Fatalf("did not expect unknown error, got %T", errTest)
   165  	}
   166  	e := Unknown(errTest)
   167  	if !IsUnknown(e) {
   168  		t.Fatalf("expected unknown error, got %T", e)
   169  	}
   170  	if cause := e.(causal).Cause(); cause != errTest {
   171  		t.Fatalf("causual should be errTest, got: %v", cause)
   172  	}
   173  	if !errors.Is(e, errTest) {
   174  		t.Fatalf("expected unknown error to match errTest")
   175  	}
   176  
   177  	wrapped := fmt.Errorf("foo: %w", e)
   178  	if !IsUnknown(wrapped) {
   179  		t.Fatalf("expected unknown error, got: %T", wrapped)
   180  	}
   181  }
   182  
   183  func TestCancelled(t *testing.T) {
   184  	if IsCancelled(errTest) {
   185  		t.Fatalf("did not expect cancelled error, got %T", errTest)
   186  	}
   187  	e := Cancelled(errTest)
   188  	if !IsCancelled(e) {
   189  		t.Fatalf("expected cancelled error, got %T", e)
   190  	}
   191  	if cause := e.(causal).Cause(); cause != errTest {
   192  		t.Fatalf("causual should be errTest, got: %v", cause)
   193  	}
   194  	if !errors.Is(e, errTest) {
   195  		t.Fatalf("expected cancelled error to match errTest")
   196  	}
   197  
   198  	wrapped := fmt.Errorf("foo: %w", e)
   199  	if !IsCancelled(wrapped) {
   200  		t.Fatalf("expected cancelled error, got: %T", wrapped)
   201  	}
   202  }
   203  
   204  func TestDeadline(t *testing.T) {
   205  	if IsDeadline(errTest) {
   206  		t.Fatalf("did not expect deadline error, got %T", errTest)
   207  	}
   208  	e := Deadline(errTest)
   209  	if !IsDeadline(e) {
   210  		t.Fatalf("expected deadline error, got %T", e)
   211  	}
   212  	if cause := e.(causal).Cause(); cause != errTest {
   213  		t.Fatalf("causual should be errTest, got: %v", cause)
   214  	}
   215  	if !errors.Is(e, errTest) {
   216  		t.Fatalf("expected deadline error to match errTest")
   217  	}
   218  
   219  	wrapped := fmt.Errorf("foo: %w", e)
   220  	if !IsDeadline(wrapped) {
   221  		t.Fatalf("expected deadline error, got: %T", wrapped)
   222  	}
   223  }
   224  
   225  func TestDataLoss(t *testing.T) {
   226  	if IsDataLoss(errTest) {
   227  		t.Fatalf("did not expect data loss error, got %T", errTest)
   228  	}
   229  	e := DataLoss(errTest)
   230  	if !IsDataLoss(e) {
   231  		t.Fatalf("expected data loss error, got %T", e)
   232  	}
   233  	if cause := e.(causal).Cause(); cause != errTest {
   234  		t.Fatalf("causual should be errTest, got: %v", cause)
   235  	}
   236  	if !errors.Is(e, errTest) {
   237  		t.Fatalf("expected data loss error to match errTest")
   238  	}
   239  
   240  	wrapped := fmt.Errorf("foo: %w", e)
   241  	if !IsDataLoss(wrapped) {
   242  		t.Fatalf("expected data loss error, got: %T", wrapped)
   243  	}
   244  }
   245  
   246  func TestUnavailable(t *testing.T) {
   247  	if IsUnavailable(errTest) {
   248  		t.Fatalf("did not expect unavaillable error, got %T", errTest)
   249  	}
   250  	e := Unavailable(errTest)
   251  	if !IsUnavailable(e) {
   252  		t.Fatalf("expected unavaillable error, got %T", e)
   253  	}
   254  	if cause := e.(causal).Cause(); cause != errTest {
   255  		t.Fatalf("causual should be errTest, got: %v", cause)
   256  	}
   257  	if !errors.Is(e, errTest) {
   258  		t.Fatalf("expected unavaillable error to match errTest")
   259  	}
   260  
   261  	wrapped := fmt.Errorf("foo: %w", e)
   262  	if !IsUnavailable(wrapped) {
   263  		t.Fatalf("expected unavaillable error, got: %T", wrapped)
   264  	}
   265  }
   266  
   267  func TestSystem(t *testing.T) {
   268  	if IsSystem(errTest) {
   269  		t.Fatalf("did not expect system error, got %T", errTest)
   270  	}
   271  	e := System(errTest)
   272  	if !IsSystem(e) {
   273  		t.Fatalf("expected system error, got %T", e)
   274  	}
   275  	if cause := e.(causal).Cause(); cause != errTest {
   276  		t.Fatalf("causual should be errTest, got: %v", cause)
   277  	}
   278  	if !errors.Is(e, errTest) {
   279  		t.Fatalf("expected system error to match errTest")
   280  	}
   281  
   282  	wrapped := fmt.Errorf("foo: %w", e)
   283  	if !IsSystem(wrapped) {
   284  		t.Fatalf("expected system error, got: %T", wrapped)
   285  	}
   286  }