diff options
| author | Eugene Triguba <eugenetriguba@gmail.com> | 2024-02-01 22:34:52 -0500 |
|---|---|---|
| committer | Eugene Triguba <eugenetriguba@gmail.com> | 2024-02-01 22:34:52 -0500 |
| commit | c4f88b3173e34387147499f6f3a66b5595c7bf47 (patch) | |
| tree | b12eea8e762b9ca62a52c25fdb928e2f821ac504 /check | |
| parent | Fix typo (diff) | |
| download | checkmate-c4f88b3173e34387147499f6f3a66b5595c7bf47.zip | |
Add check module, add some not functions, and remove a few test fns
Diffstat (limited to 'check')
| -rw-r--r-- | check/check.go | 201 | ||||
| -rw-r--r-- | check/check_test.go | 345 |
2 files changed, 546 insertions, 0 deletions
diff --git a/check/check.go b/check/check.go new file mode 100644 index 0000000..ddb9d5a --- /dev/null +++ b/check/check.go @@ -0,0 +1,201 @@ +package check + +import ( + "errors" + "fmt" + "strings" + + "github.com/eugenetriguba/checkmate" + "github.com/google/go-cmp/cmp" +) + +type helperT interface { + Helper() +} + +// Nil checks whether the value equals nil. +func Nil(t checkmate.TestingT, value any, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected value to be nil, got %v", value} + } + + return check(t, value == nil, msgAndArgs...) +} + +// NotNil checks whether the value does not equal nil. +func NotNil(t checkmate.TestingT, value any, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected value to not be nil, got nil", value} + } + + return check(t, value != nil, msgAndArgs...) +} + +// True checks whether the condition is true. +func True(t checkmate.TestingT, condition bool, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected condition to be true, got false"} + } + + return check(t, condition, msgAndArgs...) +} + +// False checks whether the condition is false. +func False(t checkmate.TestingT, condition bool, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected condition to be false, got true"} + } + + return check(t, !condition, msgAndArgs...) +} + +// ErrorIs checks whether the target error occurs within err's error tree. +func ErrorIs(t checkmate.TestingT, err error, target error, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected error %v to have error %v in its tree", err, target} + } + + return check(t, errors.Is(err, target), msgAndArgs...) +} + +// NotErrorIs checks whether the target error does not occur within +// the err's error tree. +func NotErrorIs(t checkmate.TestingT, err error, target error, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected error %v to not have error %v in its tree", err, target} + } + + return check(t, !errors.Is(err, target), msgAndArgs...) +} + +// ErrorContains checks whether the given err contains the errText +// in the err.Error() output. +func ErrorContains(t checkmate.TestingT, err error, errText string, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected err to contain %s, got %s", errText, err.Error()} + } + + return check(t, strings.Contains(err.Error(), errText), msgAndArgs...) +} + +// NotErrorContains checks whether the given err does not contain the errText +// in the err.Error() output. +func NotErrorContains(t checkmate.TestingT, err error, errText string, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected err to contain not %s, got that it does", errText} + } + + return check(t, !strings.Contains(err.Error(), errText), msgAndArgs...) +} + +// DeepEqual checks if two values are deeply equal. If they are not equal, +// it logs the differences. +func DeepEqual(t checkmate.TestingT, actual, expected any, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + diff := cmp.Diff(expected, actual) + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"mismatch (-expected +actual):\n%s", diff} + } + + return check(t, diff == "", msgAndArgs...) +} + +// NotDeepEqual checks if two values are not deeply equal. +func NotDeepEqual(t checkmate.TestingT, actual, expected any, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + diff := cmp.Diff(expected, actual) + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected %v to not equal %v, got that they're equal", actual, expected} + } + return check(t, diff != "", msgAndArgs...) +} + +// Equal checks if two primitive values are equal. +func Equal(t checkmate.TestingT, actual, expected any, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected %v to equal %v", expected, actual} + } + + return check(t, actual == expected, msgAndArgs...) +} + +// NotEqual checks if two values are not equal. It fails the test if +// the values are equal. +func NotEqual(t checkmate.TestingT, actual, expected any, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected %v to not equal %v", actual, expected} + } + + return check(t, actual != expected, msgAndArgs...) +} + +// Check evaluates a boolean condition and if the condition is false, +// it will log out a message and mark the test as failed. However, it does +// not immediately stop execution, unlike the assert functions. +func check(t checkmate.TestingT, condition bool, msgAndArgs ...any) bool { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if !condition { + message := "check failed" + if len(msgAndArgs) > 0 { + switch msgAndArgs[0].(type) { + case string: + message = fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...) + default: + t.Log("checkmate: check called with a non-string message, using default message") + } + } + t.Log(message) + t.Fail() + } + + return condition +} diff --git a/check/check_test.go b/check/check_test.go new file mode 100644 index 0000000..9c73d52 --- /dev/null +++ b/check/check_test.go @@ -0,0 +1,345 @@ +package check + +import ( + "errors" + "fmt" + "os" + "strings" + "testing" + + "github.com/eugenetriguba/checkmate" + "github.com/eugenetriguba/checkmate/internal/cmtest" +) + +type checkFn func(t checkmate.TestingT, args []any) bool + +func wrappedCheckNil(t checkmate.TestingT, args []any) bool { + if len(args) > 1 { + return Nil(t, args[0], args[1:]...) + } else { + return Nil(t, args[0]) + } +} + +func wrappedCheckNotNil(t checkmate.TestingT, args []any) bool { + if len(args) > 1 { + return NotNil(t, args[0], args[1:]...) + } else { + return NotNil(t, args[0]) + } +} + +func wrappedCheckTrue(t checkmate.TestingT, args []any) bool { + if len(args) > 1 { + return True(t, args[0].(bool), args[1:]...) + } else { + return True(t, args[0].(bool)) + } +} + +func wrappedCheckFalse(t checkmate.TestingT, args []any) bool { + if len(args) > 1 { + return False(t, args[0].(bool), args[1:]...) + } else { + return False(t, args[0].(bool)) + } +} + +func wrappedCheckDeepEqual(t checkmate.TestingT, args []any) bool { + if len(args) > 2 { + return DeepEqual(t, args[0], args[1], args[2:]...) + } else { + return DeepEqual(t, args[0], args[1]) + } +} + +func wrappedCheckNotDeepEqual(t checkmate.TestingT, args []any) bool { + if len(args) > 2 { + return NotDeepEqual(t, args[0], args[1], args[2:]...) + } else { + return NotDeepEqual(t, args[0], args[1]) + } +} + +func wrappedCheckErrorIs(t checkmate.TestingT, args []any) bool { + if len(args) > 2 { + return ErrorIs(t, args[0].(error), args[1].(error), args[2:]...) + } else { + return ErrorIs(t, args[0].(error), args[1].(error)) + } +} + +func wrappedCheckNotErrorIs(t checkmate.TestingT, args []any) bool { + if len(args) > 2 { + return NotErrorIs(t, args[0].(error), args[1].(error), args[2:]...) + } else { + return NotErrorIs(t, args[0].(error), args[1].(error)) + } +} + +func wrappedCheckErrorContains(t checkmate.TestingT, args []any) bool { + if len(args) > 2 { + return ErrorContains(t, args[0].(error), args[1].(string), args[2:]...) + } else { + return ErrorContains(t, args[0].(error), args[1].(string)) + } +} + +func wrappedCheckNotErrorContains(t checkmate.TestingT, args []any) bool { + if len(args) > 2 { + return NotErrorContains(t, args[0].(error), args[1].(string), args[2:]...) + } else { + return NotErrorContains(t, args[0].(error), args[1].(string)) + } +} + +func wrappedCheckEqual(t checkmate.TestingT, args []any) bool { + if len(args) > 2 { + return Equal(t, args[0], args[1], args[2:]...) + } else { + return Equal(t, args[0], args[1]) + } +} + +func wrappedCheckNotEqual(t checkmate.TestingT, args []any) bool { + if len(args) > 2 { + return NotEqual(t, args[0], args[1], args[2:]...) + } else { + return NotEqual(t, args[0], args[1]) + } +} + +var passingTestFns = []struct { + name string + fn checkFn + args []any +}{ + {"CheckNil", wrappedCheckNil, []any{nil}}, + {"CheckNotNil", wrappedCheckNotNil, []any{1}}, + {"CheckTrue", wrappedCheckTrue, []any{true}}, + {"CheckFalse", wrappedCheckFalse, []any{false}}, + {"CheckErrorIs", wrappedCheckErrorIs, []any{os.ErrExist, os.ErrExist}}, + {"CheckNotErrorIs", wrappedCheckNotErrorIs, []any{os.ErrExist, os.ErrClosed}}, + {"CheckErrorContains", wrappedCheckErrorContains, []any{errors.New("error 1"), "error 1"}}, + {"CheckNotErrorContains", wrappedCheckNotErrorContains, []any{errors.New("error 1"), "error 2"}}, + {"CheckDeepEqual", wrappedCheckDeepEqual, []any{5, 5}}, + {"CheckNotDeepEqual", wrappedCheckNotDeepEqual, []any{5, 6}}, + {"CheckEqual", wrappedCheckEqual, []any{5, 5}}, + {"CheckNotEqual", wrappedCheckNotEqual, []any{5, 10}}, +} + +var failingTestFns = []struct { + name string + fn checkFn + args []any +}{ + {"CheckNil", wrappedCheckNil, []any{1}}, + {"CheckNotNil", wrappedCheckNotNil, []any{nil}}, + {"CheckTrue", wrappedCheckTrue, []any{false}}, + {"CheckFalse", wrappedCheckFalse, []any{true}}, + {"CheckErrorIs", wrappedCheckErrorIs, []any{errors.New("error 1"), errors.New("error 2")}}, + {"CheckNotErrorIs", wrappedCheckNotErrorIs, []any{os.ErrClosed, os.ErrClosed}}, + {"CheckErrorContains", wrappedCheckErrorContains, []any{errors.New("error 1"), "error 2"}}, + {"CheckNotErrorContains", wrappedCheckNotErrorContains, []any{errors.New("error 1"), "error 1"}}, + {"CheckDeepEqual", wrappedCheckDeepEqual, []any{5, 10}}, + {"CheckNotDeepEqual", wrappedCheckNotDeepEqual, []any{5, 5}}, + {"CheckEqual", wrappedCheckEqual, []any{5, 10}}, + {"CheckNotEqual", wrappedCheckNotEqual, []any{5, 5}}, +} + +func TestOptionalMessageAndArgs(t *testing.T) { + testCases := []struct { + name string + args []any + expectedLogs []string + }{ + {"Plain message", []any{"my message"}, []string{"my message"}}, + {"Message with format placeholders", []any{"my message: %d", 5}, []string{"my message: 5"}}, + { + "Invalid message type", + []any{5}, + []string{ + "checkmate: check called with a non-string message, using default message", + "check failed", + }, + }, + } + + for _, testFn := range failingTestFns { + for _, testCase := range testCases { + testName := fmt.Sprintf("%s: %s", testFn.name, testCase.name) + t.Run(testName, func(t *testing.T) { + mockT := &cmtest.MockT{} + + testFn.fn(mockT, append(testFn.args, testCase.args...)) + + if len(mockT.Logs) != len(testCase.expectedLogs) { + t.Errorf( + "%s: expected %d (%v) log messages but got %d (%v)", + testName, len(testCase.expectedLogs), + testCase.expectedLogs, len(mockT.Logs), mockT.Logs, + ) + } + if len(mockT.Logs) == len(testCase.expectedLogs) { + for i, expectedLogMsg := range testCase.expectedLogs { + if mockT.Logs[i] != expectedLogMsg { + t.Errorf( + "%s: expected log message '%s', got '%s'", + testName, expectedLogMsg, mockT.Logs[i], + ) + } + } + } + }) + } + } +} + +func TestCheckFnsCallHelper(t *testing.T) { + for _, testFn := range passingTestFns { + t.Run(testFn.name, func(t *testing.T) { + mockHelperT := &cmtest.MockHelperT{} + + testFn.fn(mockHelperT, testFn.args) + + if !mockHelperT.HelperCalled { + t.Errorf("%s: expected HelperT to be called", testFn.name) + } + }) + } +} + +func TestCheckFnsShouldNotFailOrEmitLogsOnSuccess(t *testing.T) { + for _, testFn := range passingTestFns { + t.Run(testFn.name, func(t *testing.T) { + mockT := &cmtest.MockT{} + testFn.fn(mockT, testFn.args) + + if mockT.FailNowCalled || mockT.FailCalled { + t.Fatalf( + "%s: fail called, expected the test to not be failed on true condition", + testFn.name, + ) + } + if len(mockT.Logs) > 0 { + t.Fatalf( + "%s: %v logs emitted, expected the test to not emit any logs on true condition", + testFn.name, mockT.Logs, + ) + } + }) + } +} + +func TestAssertEqual(t *testing.T) { + testCases := []struct { + name string + actual any + expected any + shouldFail bool + logMessages []string + }{ + {"EqualIntegers", 5, 5, false, []string{}}, + {"UnequalIntegers", 5, 10, true, []string{"expected 10 to equal 5"}}, + {"EqualFloats", 5.123, 5.123, false, []string{}}, + {"UnequalFloats", 5.123, 5.1234, true, []string{"expected 5.1234 to equal 5.123"}}, + {"EqualStrings", "test", "test", false, []string{}}, + {"UnequalStrings", "test", "fail", true, []string{"expected fail to equal test"}}, + {"EqualBooleans", true, true, false, []string{}}, + {"UnequalBooleans", false, true, true, []string{"expected true to equal false"}}, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + mockT := &cmtest.MockT{} + Equal(mockT, tc.actual, tc.expected) + + if mockT.FailCalled != tc.shouldFail { + t.Errorf( + "%s: FailCalled = %v, want %v", + tc.name, mockT.FailCalled, tc.shouldFail, + ) + } + if len(mockT.Logs) != len(tc.logMessages) { + t.Errorf( + "%s: expected %d (%v) log messages but got %d (%v)", + tc.name, len(mockT.Logs), mockT.Logs, len(tc.logMessages), tc.logMessages, + ) + } + if len(mockT.Logs) == len(tc.logMessages) { + for i, expectedLogMsg := range tc.logMessages { + if mockT.Logs[i] != expectedLogMsg { + t.Errorf( + "%s: expected log message '%s', got '%s'", + tc.name, expectedLogMsg, mockT.Logs[0], + ) + } + } + } + }) + } +} + +func TestAssertDeepEqual(t *testing.T) { + type TestStruct struct { + Name string + Age int + } + + t.Run("Equal structs", func(t *testing.T) { + mockT := &cmtest.MockT{} + DeepEqual(mockT, TestStruct{"Alice", 30}, TestStruct{"Alice", 30}) + if mockT.FailCalled { + t.Error("AssertDeepEqual failed when it should have passed") + } + }) + + t.Run("Not equal structs", func(t *testing.T) { + mockT := &cmtest.MockT{} + DeepEqual(mockT, TestStruct{"Alice", 30}, TestStruct{"Bob", 30}) + if !mockT.FailCalled { + t.Error("AssertDeepEqual passed when it should have failed") + } + if len(mockT.Logs) == 0 || !containsDiffMessage(mockT.Logs[0]) { + t.Error("AssertDeepEqual did not log the correct diff message") + } + }) +} + +func containsDiffMessage(log string) bool { + return strings.Contains(log, "(-expected +actual)") +} + +func TestAssertErrorIsChecksErrTree(t *testing.T) { + mockT := &cmtest.MockT{} + actual := fmt.Errorf("wrapped: %w", os.ErrInvalid) + expected := os.ErrInvalid + + ErrorIs(mockT, actual, expected) + + if mockT.FailNowCalled { + t.Fatal("AssertErrorIs failed when it should have passed") + } +} + +func TestCheckReturnValues(t *testing.T) { + t.Run("should return true on true condition", func(t *testing.T) { + mockT := &cmtest.MockT{} + + passed := check(mockT, true) + + if !passed { + t.Fatal("Check should have returned true on true condition") + } + }) + + t.Run("should return false on false condition", func(t *testing.T) { + mockT := &cmtest.MockT{} + + passed := check(mockT, false) + + if passed { + t.Fatal("Check should have returned false on false condition") + } + }) +} |