Reorganize errors

errors/errors_test.go

@@ -0,0 +1,184 @@
+package errors
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+)
+
+type CustomError struct {
+	Err error
+}
+
+func (e *CustomError) Error() string { return e.Err.Error() }
+
+func IsCustomError(err error) bool {
+	var asError *CustomError
+	return errors.As(err, &asError)
+}
+
+func TestWrapping(t *testing.T) {
+	t.Parallel()
+	originalErr := errors.New("original error")
+	err1 := NewError(originalErr)
+	if !errors.Is(err1, originalErr) {
+		t.Errorf("original error is not wrapped")
+	}
+	if !Is(err1, originalErr) {
+		t.Errorf("original error is not wrapped")
+	}
+	unwrappedErr := errors.Unwrap(err1)
+	if !errors.Is(unwrappedErr, originalErr) {
+		t.Errorf("original error is not wrapped")
+	}
+	if !Is(unwrappedErr, originalErr) {
+		t.Errorf("original error is not wrapped")
+	}
+	unwrappedErr = Unwrap(err1)
+	if !errors.Is(unwrappedErr, originalErr) {
+		t.Errorf("original error is not wrapped")
+	}
+	if !Is(unwrappedErr, originalErr) {
+		t.Errorf("original error is not wrapped")
+	}
+	wrappedErr := fmt.Errorf("wrapped: %w", originalErr)
+	if !errors.Is(wrappedErr, originalErr) {
+		t.Errorf("original error is not wrapped")
+	}
+	if !Is(wrappedErr, originalErr) {
+		t.Errorf("original error is not wrapped")
+	}
+}
+
+func TestNewError(t *testing.T) {
+	t.Parallel()
+	originalErr := &CustomError{errors.New("err1")}
+	if !IsCustomError(originalErr) {
+		t.Errorf("TestNewError fail #1")
+	}
+	err1 := NewError(originalErr)
+	if !IsCustomError(err1) {
+		t.Errorf("TestNewError fail #2")
+	}
+	wrappedErr1 := fmt.Errorf("wrapped %w", err1)
+	if !IsCustomError(wrappedErr1) {
+		t.Errorf("TestNewError fail #3")
+	}
+	unwrappedErr1 := Unwrap(wrappedErr1)
+	if !IsCustomError(unwrappedErr1) {
+		t.Errorf("TestNewError fail #4")
+	}
+}
+
+func TestIsFatal(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		err  error
+		want bool
+	}{
+		{
+			name: "nil error",
+			err:  nil,
+			want: false,
+		},
+		{
+			name: "simple non-fatal error",
+			err:  fmt.Errorf("regular error"),
+			want: false,
+		},
+		{
+			name: "direct fatal error",
+			err:  NewFatalError(fmt.Errorf("fatal error")),
+			want: true,
+		},
+		{
+			name: "non-fatal Error type",
+			err:  NewError(fmt.Errorf("non-fatal error")),
+			want: false,
+		},
+		{
+			name: "wrapped fatal error - one level",
+			err:  fmt.Errorf("outer: %w", NewFatalError(fmt.Errorf("inner fatal"))),
+			want: true,
+		},
+		{
+			name: "wrapped fatal error - two levels",
+			err: fmt.Errorf("outer: %w",
+				fmt.Errorf("middle: %w",
+					NewFatalError(fmt.Errorf("inner fatal")))),
+			want: true,
+		},
+		{
+			name: "wrapped fatal error - three levels",
+			err: fmt.Errorf("outer: %w",
+				fmt.Errorf("middle1: %w",
+					fmt.Errorf("middle2: %w",
+						NewFatalError(fmt.Errorf("inner fatal"))))),
+			want: true,
+		},
+		{
+			name: "multiple wrapped errors - non-fatal",
+			err: fmt.Errorf("outer: %w",
+				fmt.Errorf("middle: %w",
+					fmt.Errorf("inner: %w",
+						NewError(fmt.Errorf("base error"))))),
+			want: false,
+		},
+		{
+			name: "wrapped non-fatal Error type",
+			err:  fmt.Errorf("outer: %w", NewError(fmt.Errorf("inner"))),
+			want: false,
+		},
+		{
+			name: "wrapped basic error",
+			err:  fmt.Errorf("outer: %w", fmt.Errorf("inner")),
+			want: false,
+		},
+		{
+			name: "fatal error wrapping fatal error",
+			err:  NewFatalError(NewFatalError(fmt.Errorf("double fatal"))),
+			want: true,
+		},
+		{
+			name: "fatal error wrapping non-fatal Error",
+			err:  NewFatalError(NewError(fmt.Errorf("mixed"))),
+			want: true,
+		},
+		{
+			name: "non-fatal Error wrapping fatal error",
+			err:  NewError(NewFatalError(fmt.Errorf("mixed"))),
+			want: true,
+		},
+		{
+			name: "Error wrapping Error",
+			err:  NewError(NewError(fmt.Errorf("double wrapped"))),
+			want: false,
+		},
+		{
+			name: "wrapped nil error",
+			err:  fmt.Errorf("outer: %w", nil),
+			want: false,
+		},
+		{
+			name: "fatal wrapping nil",
+			err:  NewFatalError(nil),
+			want: false,
+		},
+	}
+
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got := IsFatal(tt.err)
+			if got != tt.want {
+				t.Errorf("IsFatal() = %v, want %v", got, tt.want)
+				if tt.err != nil {
+					t.Errorf("Error was: %v", tt.err)
+				}
+			}
+		})
+	}
+}