simplify funcs

Eun · Jan 24, 2024 · 730dd3e · 730dd3e
1 parent ef580c3
commit 730dd3e
Show file tree

Hide file tree

Showing 7 changed files with 60 additions and 163 deletions.
diff --git a/builder_test.go b/builder_test.go
@@ -1,7 +1,6 @@
 package serrors_test
 
 import (
-	"reflect"
 	"runtime"
 	"testing"
 
@@ -16,9 +15,7 @@ func testBuilderErrorFunc() error {
 
 func TestBuilder(t *testing.T) {
 	_, filename, _, ok := runtime.Caller(0)
-	if expect, actual := true, ok; expect != actual {
-		t.Fatalf(`expected %v, but was %v`, expect, actual)
-	}
+	Equal(t, true, ok)
 
 	t.Run("Errorf", func(t *testing.T) {
 		errorBuilder := serrors.NewBuilder().
@@ -27,12 +24,8 @@ func TestBuilder(t *testing.T) {
 		err := errorBuilder.Errorf("some error"). // [TestBuilderErrorf00]
 								With("key2", "value2").
 								With("key3", "value3")
-		if err == nil {
-			t.Fatal(`expected not nil`)
-		}
-		if expect, actual := "some error", err.Error(); expect != actual {
-			t.Fatalf(`expected %q, but was %q`, expect, actual)
-		}
+		NotEqual(t, nil, err)
+		Equal(t, "some error", err.Error())
 
 		expectedFields := map[string]any{
 			"key1": "value1",
@@ -48,9 +41,7 @@ func TestBuilder(t *testing.T) {
 				},
 			},
 		}
-		if expect, actual := expectedFields, serrors.GetFields(err); !reflect.DeepEqual(expect, actual) {
-			t.Fatalf(`expected %+v, but was %+v`, expect, actual)
-		}
+		Equal(t, expectedFields, serrors.GetFields(err))
 		CompareErrorStack(t, expectedStack, serrors.GetStack(err))
 	})
 
@@ -64,12 +55,8 @@ func TestBuilder(t *testing.T) {
 								With("deep.key2", "value2").
 								With("key2", "value2").
 								With("key3", "value3")
-		if err == nil {
-			t.Fatal(`expected not nil`)
-		}
-		if expect, actual := "some error: deep error", err.Error(); expect != actual {
-			t.Fatalf(`expected %q, but was %q`, expect, actual)
-		}
+		NotEqual(t, nil, err)
+		Equal(t, "some error: deep error", err.Error())
 
 		expectedFields := map[string]any{
 			"deep.key1": "value1",
@@ -103,9 +90,7 @@ func TestBuilder(t *testing.T) {
 				},
 			},
 		}
-		if expect, actual := expectedFields, serrors.GetFields(err); !reflect.DeepEqual(expect, actual) {
-			t.Fatalf(`expected %+v, but was %+v`, expect, actual)
-		}
+		Equal(t, expectedFields, serrors.GetFields(err))
 		CompareErrorStack(t, expectedStack, serrors.GetStack(err))
 	})
 }
diff --git a/error_example_test.go b/error_example_test.go
@@ -61,9 +61,8 @@ func addUserToRole(userName, roleName string) error {
 }
 
 func ExampleError() {
-	logger := NewSLogLogger()
 	if err := addUserToRole("joe", "guest"); err != nil {
-		logger.Error("name validation failed",
+		slog.Error("name validation failed",
 			"error", err.Error(),
 			slog.Group("details", serrors.GetFieldsAsCombinedSlice(err)...),
 			"stack", serrors.GetStack(err),

diff --git a/error_test.go b/error_test.go
@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 	"net"
-	"reflect"
 	"runtime"
 	"testing"
 
@@ -21,20 +20,14 @@ func testErrorFunc() error {
 
 func TestError(t *testing.T) {
 	_, filename, _, ok := runtime.Caller(0)
-	if expect, actual := true, ok; expect != actual {
-		t.Fatalf(`expected %v, but was %v`, expect, actual)
-	}
+	Equal(t, true, ok)
 
 	t.Run("Errorf", func(t *testing.T) {
 		err := serrors.Errorf("some error"). // [TestErrorErrorf00]
 							With("key1", "value1").
 							With("key2", "value2")
-		if err == nil {
-			t.Fatal(`expected not nil`)
-		}
-		if expect, actual := "some error", err.Error(); expect != actual {
-			t.Fatalf(`expected %q, but was %q`, expect, actual)
-		}
+		NotEqual(t, nil, err)
+		Equal(t, "some error", err.Error())
 
 		expectedFields := map[string]any{
 			"key1": "value1",
@@ -49,9 +42,7 @@ func TestError(t *testing.T) {
 				},
 			},
 		}
-		if expect, actual := expectedFields, serrors.GetFields(err); !reflect.DeepEqual(expect, actual) {
-			t.Fatalf(`expected %+v, but was %+v`, expect, actual)
-		}
+		Equal(t, expectedFields, serrors.GetFields(err))
 		CompareErrorStack(t, expectedStack, serrors.GetStack(err))
 	})
 
@@ -61,12 +52,8 @@ func TestError(t *testing.T) {
 							With("deep.key2", "value2").
 							With("key1", "value1").
 							With("key2", "value2")
-		if err == nil {
-			t.Fatal(`expected not nil`)
-		}
-		if expect, actual := "some error: deep error", err.Error(); expect != actual {
-			t.Fatalf(`expected %q, but was %q`, expect, actual)
-		}
+		NotEqual(t, nil, err)
+		Equal(t, "some error: deep error", err.Error())
 
 		expectedFields := map[string]any{
 			"deep.key1": "value1",
@@ -98,9 +85,7 @@ func TestError(t *testing.T) {
 				},
 			},
 		}
-		if expect, actual := expectedFields, serrors.GetFields(err); !reflect.DeepEqual(expect, actual) {
-			t.Fatalf(`expected %+v, but was %+v`, expect, actual)
-		}
+		Equal(t, expectedFields, serrors.GetFields(err))
 		CompareErrorStack(t, expectedStack, serrors.GetStack(err))
 	})
 }
@@ -141,9 +126,7 @@ func TestGetFields(t *testing.T) {
 	for _, tc := range testCases {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
-			if expect, actual := tc.expectedFields, serrors.GetFields(tc.error); !reflect.DeepEqual(expect, actual) {
-				t.Fatalf(`expected %+v, but was %+v`, expect, actual)
-			}
+			Equal(t, tc.expectedFields, serrors.GetFields(tc.error))
 		})
 	}
 }
@@ -184,9 +167,7 @@ func TestGetFieldsAsArguments(t *testing.T) {
 	for _, tc := range testCases {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
-			if expect, actual := tc.expectedArguments, serrors.GetFieldsAsCombinedSlice(tc.error); !reflect.DeepEqual(expect, actual) {
-				t.Fatalf(`expected %+v, but was %+v`, expect, actual)
-			}
+			Equal(t, tc.expectedArguments, serrors.GetFieldsAsCombinedSlice(tc.error))
 		})
 	}
 }
@@ -195,36 +176,24 @@ func TestUnwrap(t *testing.T) {
 	t.Run("wrapped error", func(t *testing.T) {
 		err1 := errors.New("error1")
 		err := serrors.Wrap(err1, "error2")
-		if expect, actual := err1, errors.Unwrap(err); !reflect.DeepEqual(expect, actual) {
-			t.Fatalf(`expected %+v, but was %+v`, expect, actual)
-		}
+		Equal(t, err1, errors.Unwrap(err))
 	})
 	t.Run("wrapped no error", func(t *testing.T) {
 		err := serrors.Wrap(nil, "error2")
-		if errors.Unwrap(err) != nil {
-			t.Fatal("expected not nil")
-		}
+		NotEqual(t, nil, errors.Unwrap(err))
 	})
 }
 
 func TestIs(t *testing.T) {
 	t.Run("wrapped error", func(t *testing.T) {
 		err := serrors.Wrap(net.ErrClosed, "error")
-		if expect, actual := true, errors.Is(err, net.ErrClosed); expect != actual {
-			t.Fatalf(`expected %v, but was %v`, expect, actual)
-		}
-		if expect, actual := false, errors.Is(err, net.ErrWriteToConnected); expect != actual {
-			t.Fatalf(`expected %v, but was %v`, expect, actual)
-		}
+		Equal(t, true, errors.Is(err, net.ErrClosed))
+		Equal(t, false, errors.Is(err, net.ErrWriteToConnected))
 	})
 	t.Run("wrapped no error", func(t *testing.T) {
 		err := serrors.Wrap(nil, "error")
-		if expect, actual := false, errors.Is(err, net.ErrClosed); expect != actual {
-			t.Fatalf(`expected %v, but was %v`, expect, actual)
-		}
-		if expect, actual := false, errors.Is(err, net.ErrWriteToConnected); expect != actual {
-			t.Fatalf(`expected %v, but was %v`, expect, actual)
-		}
+		Equal(t, false, errors.Is(err, net.ErrClosed))
+		Equal(t, false, errors.Is(err, net.ErrWriteToConnected))
 	})
 }
 
@@ -233,38 +202,24 @@ func TestAs(t *testing.T) {
 		err := serrors.Wrap(&net.AddrError{Addr: "127.0.0.1"}, "error")
 
 		var cause1 *net.AddrError
-		if expect, actual := true, errors.As(err, &cause1); expect != actual {
-			t.Fatalf(`expected %v, but was %v`, expect, actual)
-		}
-		if expect, actual := "127.0.0.1", cause1.Addr; expect != actual {
-			t.Fatalf(`expected %q, but was %q`, expect, actual)
-		}
+		Equal(t, true, errors.As(err, &cause1))
+		Equal(t, "127.0.0.1", cause1.Addr)
 
 		var cause2 *net.OpError
-		if expect, actual := false, errors.As(err, &cause2); expect != actual {
-			t.Fatalf(`expected %v, but was %v`, expect, actual)
-		}
+		Equal(t, false, errors.As(err, &cause2))
 		if cause2 != nil {
 			t.Fatal("expected not nil")
 		}
 	})
 	t.Run("wrapped no error", func(t *testing.T) {
 		err := serrors.Wrap(nil, "error")
 		var cause1 *net.AddrError
-		if expect, actual := false, errors.As(err, &cause1); expect != actual {
-			t.Fatalf(`expected %v, but was %v`, expect, actual)
-		}
-		if cause1 != nil {
-			t.Fatal("expected nil")
-		}
+		Equal(t, false, errors.As(err, &cause1))
+		NotEqual(t, nil, cause1)
 
 		var cause2 *net.OpError
 
-		if expect, actual := false, errors.As(err, &cause2); expect != actual {
-			t.Fatalf(`expected %v, but was %v`, expect, actual)
-		}
-		if cause2 != nil {
-			t.Fatal("expected nil")
-		}
+		Equal(t, false, errors.As(err, &cause2))
+		NotEqual(t, nil, cause2)
 	})
 }
diff --git a/format_test.go b/format_test.go
@@ -51,45 +51,33 @@ func TestError_Error(t *testing.T) {
 	for _, tc := range testCases {
 		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
-			if expect, actual := tc.expectedErrorText, tc.error.Error(); expect != actual {
-				t.Fatalf(`expected %q, but was %q`, expect, actual)
-			}
+			Equal(t, tc.expectedErrorText, tc.error.Error())
 		})
 	}
 }
 
 func TestError_Format(t *testing.T) {
 	_, filename, _, ok := runtime.Caller(0)
-	if expect, actual := true, ok; expect != actual {
-		t.Fatalf(`expected %v, but was %v`, expect, actual)
-	}
+	Equal(t, true, ok)
 
 	cause := serrors.New("error 1").With("k1", "v1")       // [TestError_Format01]
 	err := serrors.Wrap(cause, "error 2").With("k2", "v2") // [TestError_Format00]
 
 	t.Run("normal string", func(t *testing.T) {
-		if expect, actual := "error 2: error 1", fmt.Sprintf("%s", err); expect != actual {
-			t.Fatalf(`expected %q, but was %q`, expect, actual)
-		}
+		Equal(t, "error 2: error 1", fmt.Sprintf("%s", err))
 	})
 	t.Run("quoted string", func(t *testing.T) {
-		if expect, actual := `"error 2: error 1"`, fmt.Sprintf("%q", err); expect != actual {
-			t.Fatalf(`expected %q, but was %q`, expect, actual)
-		}
+		Equal(t, `"error 2: error 1"`, fmt.Sprintf("%q", err))
 	})
 	t.Run("verbose", func(t *testing.T) {
-		if expect, actual := "error 2: error 1[k1=v1 k2=v2]", fmt.Sprintf("%v", err); expect != actual {
-			t.Fatalf(`expected %q, but was %q`, expect, actual)
-		}
+		Equal(t, "error 2: error 1[k1=v1 k2=v2]", fmt.Sprintf("%v", err))
 	})
 	t.Run("extra verbose", func(t *testing.T) {
 		expected := fmt.Sprintf("error 2\n[k2=v2]\n%s\nerror 1\n[k1=v1]\n%s\n",
 			generateExpectedStack(t, filename, "TestError_Format00"),
 			generateExpectedStack(t, filename, "TestError_Format01"),
 		)
-		if expect, actual := expected, fmt.Sprintf("%+v", err); expect != actual {
-			t.Fatalf(`expected %q, but was %q`, expect, actual)
-		}
+		Equal(t, expected, fmt.Sprintf("%+v", err))
 	})
 }
 

diff --git a/stack_test.go b/stack_test.go
@@ -4,7 +4,6 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
-	"reflect"
 	"strconv"
 	"strings"
 	"testing"
@@ -16,23 +15,15 @@ func TestGetStack(t *testing.T) {
 	// just generic testing
 	// the real test are happening in TestError & TestBuilder.
 	t.Run("get stack from nil value", func(t *testing.T) {
-		if serrors.GetStack(nil) != nil {
-			t.Fatal("expected nil")
-		}
+		Equal(t, nil, serrors.GetStack(nil))
 	})
 	t.Run("get original error from stack", func(t *testing.T) {
 		err := serrors.New("some error")
 
 		stack := serrors.GetStack(err)
-		if expect, actual := 1, len(stack); expect != actual {
-			t.Fatalf(`expected %v, but was %v`, expect, actual)
-		}
-		if expect, actual := err, stack[0].Error(); !reflect.DeepEqual(expect, actual) {
-			t.Fatalf(`expected %+v, but was %+v`, expect, actual)
-		}
-		if expect, actual := err.Error(), stack[0].ErrorMessage; expect != actual {
-			t.Fatalf(`expected %q, but was %q`, expect, actual)
-		}
+		Equal(t, 1, len(stack))
+		Equal(t, err, stack[0].Error())
+		Equal(t, err.Error(), stack[0].ErrorMessage)
 	})
 }
 
@@ -43,9 +34,7 @@ func buildStackFrameFromMarker(t *testing.T, fileName, marker string) serrors.St
 
 	// Parse the Go file
 	file, err := parser.ParseFile(fileSet, fileName, nil, parser.AllErrors|parser.ParseComments)
-	if err != nil {
-		t.Fatal(`expected no error`)
-	}
+	NotEqual(t, nil, err)
 	packageName := "github.com/Eun/" + file.Name.Name
 
 	var inspectNode func(n ast.Node) bool
@@ -65,9 +54,7 @@ func buildStackFrameFromMarker(t *testing.T, fileName, marker string) serrors.St
 				// Get the function name and line number
 				pos := fileSet.Position(v.Slash)
 				funcName := findEnclosingFunc(fileSet, file, pos.Offset)
-				if result != nil {
-					t.Fatalf(`found a marker %q already`, marker)
-				}
+				NotEqual(t, nil, result)
 				result = &serrors.StackFrame{
 					File: fileName,
 					Func: packageName + "." + funcName,
@@ -81,9 +68,7 @@ func buildStackFrameFromMarker(t *testing.T, fileName, marker string) serrors.St
 
 	// Traverse the AST
 	ast.Inspect(file, inspectNode)
-	if result == nil {
-		t.Fatalf(`no marker found %q`, marker)
-	}
+	NotEqual(t, nil, result)
 	return *result
 }