From a74e84419015c14631913e854df6acd0c60a6f08 Mon Sep 17 00:00:00 2001 From: Eugene Triguba Date: Sun, 28 Jan 2024 16:24:54 -0500 Subject: Move assert functions to assert package --- CHANGELOG.md | 7 + assert.go | 227 ----------------------------- assert/assert.go | 227 +++++++++++++++++++++++++++++ assert/assert_test.go | 393 ++++++++++++++++++++++++++++++++++++++++++++++++++ assert_test.go | 393 -------------------------------------------------- 5 files changed, 627 insertions(+), 620 deletions(-) delete mode 100644 assert.go create mode 100644 assert/assert.go create mode 100644 assert/assert_test.go delete mode 100644 assert_test.go diff --git a/CHANGELOG.md b/CHANGELOG.md index 91501e7..c45ee7a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [Unreleased] - 2024-01-28 + +### Changed + +- Moved assertion functions to a `assert` module and removed `Assert` suffix + from many of the functions. + ## [0.1.0] - 2024-01-28 - Initial Release diff --git a/assert.go b/assert.go deleted file mode 100644 index eb2544a..0000000 --- a/assert.go +++ /dev/null @@ -1,227 +0,0 @@ -// Checkmate is a library designed to enhance the testing experience by providing a -// set of assertion functions. With Go, there is no built-in assertion library which -// can make writing tests feel more verbose than it needs to be, so Checkmate aims to -// fill that gap. -// -// This is a simple and small library. If you need something more advanced and full-featured, -// [Testify](https://github.com/stretchr/testify), [Gomega](https://github.com/onsi/gomega), or -// [gotest.tools](https://github.com/gotestyourself/gotest.tools) are all great options. -package checkmate - -import ( - "errors" - "fmt" - "strings" - - "github.com/google/go-cmp/cmp" -) - -// AssertNil checks whether the value equals nil. An optional -// message and arguments for any format placeholders in that -// message can be provided for if a failure occurs. -func AssertNil(t TestingT, value any, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"expected value to be nil, got %v", value} - } - - Assert(t, value == nil, msgAndArgs...) -} - -// AssertNil checks whether the value does not equal nil. -// An optional message and arguments for any format placeholders -// in that message can be provided for if a failure occurs. -func AssertNotNil(t TestingT, value any, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"expected value to not be nil, got nil", value} - } - - Assert(t, value != nil, msgAndArgs...) -} - -// AssertTrue checks whether the condition is true. -// An optional message and arguments for any format placeholders -// in that message can be provided for if a failure occurs. -func AssertTrue(t TestingT, condition bool, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"expected condition to be true, got false"} - } - - Assert(t, condition, msgAndArgs...) -} - -// AssertFalse checks whether the condition is false. -// An optional message and arguments for any format placeholders -// in that message can be provided for if a failure occurs. -func AssertFalse(t TestingT, condition bool, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"expected condition to be false, got true"} - } - - Assert(t, !condition, msgAndArgs...) -} - -// AssertErrorIs checks whether any error in the actual error's tree -// matches the expected error. An optional message and arguments for -// any format placeholders in that message can be provided for if a -// failure occurs. -func AssertErrorIs(t TestingT, actual error, expected error, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"expected error %v to have error %v in its tree", actual, expected} - } - - Assert(t, errors.Is(actual, expected), msgAndArgs...) -} - -// AssertErrorContains checks whether the given err contains the expectedErrText -// in the err.Error() output. An optional message and arguments for any format -// placeholders in that message can be provided for if a failure occurs. -func AssertErrorContains(t TestingT, err error, expectedErrText string, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"expected err to contain %s, got %s", expectedErrText, err.Error()} - } - - Assert(t, strings.Contains(err.Error(), expectedErrText), msgAndArgs...) -} - -// AssertDeepEqual checks if two values are deeply equal using Google's -// go-cmp cmp.Equal. If they are not equal, it logs the differences -// using cmp.Diff. An optional message and arguments for any format -// placeholders in that message can be provided for if a failure occurs. -func AssertDeepEqual(t TestingT, actual, expected any, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - - if diff := cmp.Diff(expected, actual); diff != "" { - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"mismatch (-expected +actual):\n%s", diff} - } - Assert(t, false, msgAndArgs...) - } -} - -// AssertEqual checks if two primitive values are equal. An optional -// message and arguments for any format placeholders in that message -// can be provided for if a failure occurs. -func AssertEqual(t TestingT, actual, expected any, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - - if actual != expected { - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"expected %v to equal %v", expected, actual} - } - Assert(t, false, msgAndArgs...) - } -} - -// AssertNotEqual checks if two values are not equal. It fails the test if -// the values are equal. An optional message and arguments for any format -// placeholders in that message can be provided if a failure occurs. -func AssertNotEqual(t TestingT, actual, expected any, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - - if actual == expected { - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"expected %v to not equal %v", expected, actual} - } - Assert(t, false, msgAndArgs...) - } -} - -// AssertLenEqual checks if the length of a given slice or array equals the -// expected length. It fails the test if the lengths are not equal. An optional -// message and arguments for any format placeholders in that message can be provided -// if a failure occurs. -func AssertLenEqual[T any](t TestingT, l []T, expectedLen int, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"expected %v to have len %d, got len %d", l, len(l), expectedLen} - } - Assert(t, len(l) == expectedLen, msgAndArgs...) -} - -// Assert checks a boolean condition and fails the test if the condition is false. -// This is a general-purpose assertion function used to validate if a condition holds true. -// An optional message and arguments for any format placeholders in that message -// can be provided if a failure occurs. -func Assert(t TestingT, condition bool, msgAndArgs ...any) { - if ht, ok := t.(helperT); ok { - ht.Helper() - } - if len(msgAndArgs) == 0 { - msgAndArgs = []any{"assertion failed"} - } - passed := Check(t, condition, msgAndArgs...) - if !passed { - t.FailNow() - } -} - -// Check evaluates a boolean condition and logs a message if the condition is false. -// Unlike Assert, it does not stop the test when the condition is false but returns -// a boolean indicating the result. This function is useful for cases where you want -// to perform multiple checks in a single test function without stopping the test -// execution after the first failure. An optional message and arguments for any format -// placeholders in that message can be provided if the check fails. -func Check(t 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: assertion called with a non-string message, using default message") - } - } - t.Log(message) - return false - } - return true -} - -// The subset of testing.T which is used by the -// checkmate package. -type TestingT interface { - Log(args ...any) - FailNow() -} - -type helperT interface { - Helper() -} diff --git a/assert/assert.go b/assert/assert.go new file mode 100644 index 0000000..b120ec5 --- /dev/null +++ b/assert/assert.go @@ -0,0 +1,227 @@ +// Checkmate is a library designed to enhance the testing experience by providing a +// set of assertion functions. With Go, there is no built-in assertion library which +// can make writing tests feel more verbose than it needs to be, so Checkmate aims to +// fill that gap. +// +// This is a simple and small library. If you need something more advanced and full-featured, +// [Testify](https://github.com/stretchr/testify), [Gomega](https://github.com/onsi/gomega), or +// [gotest.tools](https://github.com/gotestyourself/gotest.tools) are all great options. +package assert + +import ( + "errors" + "fmt" + "strings" + + "github.com/google/go-cmp/cmp" +) + +// Nil checks whether the value equals nil. An optional +// message and arguments for any format placeholders in that +// message can be provided for if a failure occurs. +func Nil(t TestingT, value any, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected value to be nil, got %v", value} + } + + Assert(t, value == nil, msgAndArgs...) +} + +// NotNil checks whether the value does not equal nil. +// An optional message and arguments for any format placeholders +// in that message can be provided for if a failure occurs. +func NotNil(t TestingT, value any, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected value to not be nil, got nil", value} + } + + Assert(t, value != nil, msgAndArgs...) +} + +// True checks whether the condition is true. +// An optional message and arguments for any format placeholders +// in that message can be provided for if a failure occurs. +func True(t TestingT, condition bool, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected condition to be true, got false"} + } + + Assert(t, condition, msgAndArgs...) +} + +// False checks whether the condition is false. +// An optional message and arguments for any format placeholders +// in that message can be provided for if a failure occurs. +func False(t TestingT, condition bool, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected condition to be false, got true"} + } + + Assert(t, !condition, msgAndArgs...) +} + +// ErrorIs checks whether any error in the actual error's tree +// matches the expected error. An optional message and arguments for +// any format placeholders in that message can be provided for if a +// failure occurs. +func ErrorIs(t TestingT, actual error, expected error, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected error %v to have error %v in its tree", actual, expected} + } + + Assert(t, errors.Is(actual, expected), msgAndArgs...) +} + +// ErrorContains checks whether the given err contains the expectedErrText +// in the err.Error() output. An optional message and arguments for any format +// placeholders in that message can be provided for if a failure occurs. +func ErrorContains(t TestingT, err error, expectedErrText string, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected err to contain %s, got %s", expectedErrText, err.Error()} + } + + Assert(t, strings.Contains(err.Error(), expectedErrText), msgAndArgs...) +} + +// DeepEqual checks if two values are deeply equal using Google's +// go-cmp cmp.Equal. If they are not equal, it logs the differences +// using cmp.Diff. An optional message and arguments for any format +// placeholders in that message can be provided for if a failure occurs. +func DeepEqual(t TestingT, actual, expected any, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if diff := cmp.Diff(expected, actual); diff != "" { + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"mismatch (-expected +actual):\n%s", diff} + } + Assert(t, false, msgAndArgs...) + } +} + +// Equal checks if two primitive values are equal. An optional +// message and arguments for any format placeholders in that message +// can be provided for if a failure occurs. +func Equal(t TestingT, actual, expected any, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if actual != expected { + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected %v to equal %v", expected, actual} + } + Assert(t, false, msgAndArgs...) + } +} + +// NotEqual checks if two values are not equal. It fails the test if +// the values are equal. An optional message and arguments for any format +// placeholders in that message can be provided if a failure occurs. +func NotEqual(t TestingT, actual, expected any, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if actual == expected { + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected %v to not equal %v", expected, actual} + } + Assert(t, false, msgAndArgs...) + } +} + +// LenEqual checks if the length of a given slice or array equals the +// expected length. It fails the test if the lengths are not equal. An optional +// message and arguments for any format placeholders in that message can be provided +// if a failure occurs. +func LenEqual[T any](t TestingT, l []T, expectedLen int, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"expected %v to have len %d, got len %d", l, len(l), expectedLen} + } + Assert(t, len(l) == expectedLen, msgAndArgs...) +} + +// Assert checks a boolean condition and fails the test if the condition is false. +// This is a general-purpose assertion function used to validate if a condition holds true. +// An optional message and arguments for any format placeholders in that message +// can be provided if a failure occurs. +func Assert(t TestingT, condition bool, msgAndArgs ...any) { + if ht, ok := t.(helperT); ok { + ht.Helper() + } + if len(msgAndArgs) == 0 { + msgAndArgs = []any{"assertion failed"} + } + passed := Check(t, condition, msgAndArgs...) + if !passed { + t.FailNow() + } +} + +// Check evaluates a boolean condition and logs a message if the condition is false. +// Unlike Assert, it does not stop the test when the condition is false but returns +// a boolean indicating the result. This function is useful for cases where you want +// to perform multiple checks in a single test function without stopping the test +// execution after the first failure. An optional message and arguments for any format +// placeholders in that message can be provided if the check fails. +func Check(t 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: assertion called with a non-string message, using default message") + } + } + t.Log(message) + return false + } + return true +} + +// The subset of testing.T which is used by the +// checkmate package. +type TestingT interface { + Log(args ...any) + FailNow() +} + +type helperT interface { + Helper() +} diff --git a/assert/assert_test.go b/assert/assert_test.go new file mode 100644 index 0000000..a21f00c --- /dev/null +++ b/assert/assert_test.go @@ -0,0 +1,393 @@ +package assert + +import ( + "errors" + "fmt" + "os" + "strings" + "testing" +) + +// MockT is a mock structure for capturing test outputs. +type MockT struct { + TestingT + + FailNowCalled bool + Logs []string +} + +func (m *MockT) FailNow() { + m.FailNowCalled = true +} + +func (m *MockT) Log(args ...any) { + m.Logs = append(m.Logs, fmt.Sprint(args...)) +} + +// MockHelperT has a MockT and is also a helperT. +type MockHelperT struct { + MockT + + HelperCalled bool +} + +func (m *MockHelperT) Helper() { + m.HelperCalled = true +} + +// assertFn defines a common interface to be able to +// wrap all the assertion functions in the library to +// a common interface to make testing their common behavior +// with testing tables easier. +type assertFn func(t TestingT, args []any) + +func wrapCheck(t TestingT, args []any) { + if len(args) > 1 { + Check(t, args[0].(bool), args[1:]...) + } else { + Check(t, args[0].(bool)) + } +} + +func wrapAssert(t TestingT, args []any) { + if len(args) > 1 { + Assert(t, args[0].(bool), args[1:]...) + } else { + Assert(t, args[0].(bool)) + } +} + +func wrapAssertEqual(t TestingT, args []any) { + if len(args) > 2 { + Equal(t, args[0], args[1], args[2:]...) + + } else { + Equal(t, args[0], args[1]) + } +} + +func wrapAssertDeepEqual(t TestingT, args []any) { + if len(args) > 2 { + DeepEqual(t, args[0], args[1], args[2:]...) + + } else { + DeepEqual(t, args[0], args[1]) + } +} + +func wrapAssertNotEqual(t TestingT, args []any) { + if len(args) > 2 { + NotEqual(t, args[0], args[1], args[2:]...) + + } else { + NotEqual(t, args[0], args[1]) + } +} + +func wrapAssertLenEqualInt(t TestingT, args []any) { + slice, ok := args[0].([]int) + if !ok { + t.Log("Invalid argument type for AssertLenEqualInt") + } + + expectedLen, ok := args[1].(int) + if !ok { + t.Log("Invalid length argument for AssertLenEqualInt") + } + + if len(args) > 2 { + LenEqual(t, slice, expectedLen, args[2:]...) + + } else { + LenEqual(t, slice, expectedLen) + } +} + +func wrapAssertErrorIs(t TestingT, args []any) { + if len(args) > 2 { + ErrorIs(t, args[0].(error), args[1].(error), args[2:]...) + + } else { + ErrorIs(t, args[0].(error), args[1].(error)) + } +} + +func wrapAssertErrorContains(t TestingT, args []any) { + if len(args) > 2 { + ErrorContains(t, args[0].(error), args[1].(string), args[2:]...) + + } else { + ErrorContains(t, args[0].(error), args[1].(string)) + } +} + +func wrapAssertTrue(t TestingT, args []any) { + if len(args) > 1 { + True(t, args[0].(bool), args[1:]...) + + } else { + True(t, args[0].(bool)) + } +} + +func wrapAssertFalse(t TestingT, args []any) { + if len(args) > 1 { + False(t, args[0].(bool), args[1:]...) + + } else { + False(t, args[0].(bool)) + } +} + +func wrapAssertNil(t TestingT, args []any) { + if len(args) > 1 { + Nil(t, args[0], args[1:]...) + + } else { + Nil(t, args[0]) + } +} + +func wrapAssertNotNil(t TestingT, args []any) { + if len(args) > 1 { + NotNil(t, args[0], args[1:]...) + + } else { + NotNil(t, args[0]) + } +} + +var passingTestFns = []struct { + name string + assertionFn assertFn + args []any +}{ + {"Check", wrapCheck, []any{true}}, + {"Assert", wrapAssert, []any{true}}, + {"AssertEqual", wrapAssertEqual, []any{5, 5}}, + {"AssertDeepEqual", wrapAssertDeepEqual, []any{5, 5}}, + {"AssertNotEqual", wrapAssertNotEqual, []any{5, 10}}, + {"AssertLenEqual", wrapAssertLenEqualInt, []any{[]int{1, 2}, 2}}, + {"AssertErrorIs", wrapAssertErrorIs, []any{os.ErrExist, os.ErrExist}}, + {"AssertErrorContains", wrapAssertErrorContains, []any{errors.New("error 1"), "error 1"}}, + {"AssertTrue", wrapAssertTrue, []any{true}}, + {"AssertFalse", wrapAssertFalse, []any{false}}, + {"AssertNil", wrapAssertNil, []any{nil}}, + {"AssertNotNil", wrapAssertNotNil, []any{1}}, +} + +var failingTestFns = []struct { + name string + assertionFn assertFn + args []any +}{ + {"Check", wrapCheck, []any{false}}, + {"Assert", wrapAssert, []any{false}}, + {"AssertEqual", wrapAssertEqual, []any{5, 10}}, + {"AssertDeepEqual", wrapAssertDeepEqual, []any{5, 10}}, + {"AssertNotEqual", wrapAssertNotEqual, []any{5, 5}}, + {"AssertLenEqual", wrapAssertLenEqualInt, []any{[]int{1, 2}, 0}}, + {"AssertErrorIs", wrapAssertErrorIs, []any{errors.New("error 1"), errors.New("error 2")}}, + {"AssertErrorContains", wrapAssertErrorContains, []any{errors.New("error 1"), "error 2"}}, + {"AssertTrue", wrapAssertTrue, []any{false}}, + {"AssertFalse", wrapAssertFalse, []any{true}}, + {"AssertNil", wrapAssertNil, []any{1}}, + {"AssertNotNil", wrapAssertNotNil, []any{nil}}, +} + +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: assertion 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 := &MockT{} + + testFn.assertionFn(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(mockT.Logs), mockT.Logs, len(testCase.expectedLogs), + testCase.expectedLogs, + ) + } + 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 TestAssertFnsCallHelper(t *testing.T) { + for _, testFn := range failingTestFns { + t.Run(testFn.name, func(t *testing.T) { + mockHelperT := &MockHelperT{} + + testFn.assertionFn(mockHelperT, testFn.args) + + if !mockHelperT.HelperCalled { + t.Errorf("%s: expected HelperT to be called", testFn.name) + } + }) + } +} + +func TestAssertFnsShouldNotFailOrEmitLogsOnSuccess(t *testing.T) { + for _, testFn := range passingTestFns { + t.Run(testFn.name, func(t *testing.T) { + mockT := &MockT{} + testFn.assertionFn(mockT, testFn.args) + + if mockT.FailNowCalled { + t.Fatalf( + "%s: fail now 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 TestCheckReturnValues(t *testing.T) { + t.Run("should return true on true condition", func(t *testing.T) { + mockT := &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 := &MockT{} + + passed := Check(mockT, false) + + if passed { + t.Fatal("Check should have returned false on false condition") + } + }) +} + +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 := &MockT{} + Equal(mockT, tc.actual, tc.expected) + + if mockT.FailNowCalled != tc.shouldFail { + t.Errorf( + "%s: FailNowCalled = %v, want %v", + tc.name, mockT.FailNowCalled, 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 := &MockT{} + DeepEqual(mockT, TestStruct{"Alice", 30}, TestStruct{"Alice", 30}) + if mockT.FailNowCalled { + t.Error("AssertDeepEqual failed when it should have passed") + } + }) + + t.Run("Not equal structs", func(t *testing.T) { + mockT := &MockT{} + DeepEqual(mockT, TestStruct{"Alice", 30}, TestStruct{"Bob", 30}) + if !mockT.FailNowCalled { + 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 := &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") + } +} diff --git a/assert_test.go b/assert_test.go deleted file mode 100644 index 88e9e0b..0000000 --- a/assert_test.go +++ /dev/null @@ -1,393 +0,0 @@ -package checkmate - -import ( - "errors" - "fmt" - "os" - "strings" - "testing" -) - -// MockT is a mock structure for capturing test outputs. -type MockT struct { - TestingT - - FailNowCalled bool - Logs []string -} - -func (m *MockT) FailNow() { - m.FailNowCalled = true -} - -func (m *MockT) Log(args ...any) { - m.Logs = append(m.Logs, fmt.Sprint(args...)) -} - -// MockHelperT has a MockT and is also a helperT. -type MockHelperT struct { - MockT - - HelperCalled bool -} - -func (m *MockHelperT) Helper() { - m.HelperCalled = true -} - -// assertFn defines a common interface to be able to -// wrap all the assertion functions in the library to -// a common interface to make testing their common behavior -// with testing tables easier. -type assertFn func(t TestingT, args []any) - -func wrapCheck(t TestingT, args []any) { - if len(args) > 1 { - Check(t, args[0].(bool), args[1:]...) - } else { - Check(t, args[0].(bool)) - } -} - -func wrapAssert(t TestingT, args []any) { - if len(args) > 1 { - Assert(t, args[0].(bool), args[1:]...) - } else { - Assert(t, args[0].(bool)) - } -} - -func wrapAssertEqual(t TestingT, args []any) { - if len(args) > 2 { - AssertEqual(t, args[0], args[1], args[2:]...) - - } else { - AssertEqual(t, args[0], args[1]) - } -} - -func wrapAssertDeepEqual(t TestingT, args []any) { - if len(args) > 2 { - AssertDeepEqual(t, args[0], args[1], args[2:]...) - - } else { - AssertDeepEqual(t, args[0], args[1]) - } -} - -func wrapAssertNotEqual(t TestingT, args []any) { - if len(args) > 2 { - AssertNotEqual(t, args[0], args[1], args[2:]...) - - } else { - AssertNotEqual(t, args[0], args[1]) - } -} - -func wrapAssertLenEqualInt(t TestingT, args []any) { - slice, ok := args[0].([]int) - if !ok { - t.Log("Invalid argument type for AssertLenEqualInt") - } - - expectedLen, ok := args[1].(int) - if !ok { - t.Log("Invalid length argument for AssertLenEqualInt") - } - - if len(args) > 2 { - AssertLenEqual(t, slice, expectedLen, args[2:]...) - - } else { - AssertLenEqual(t, slice, expectedLen) - } -} - -func wrapAssertErrorIs(t TestingT, args []any) { - if len(args) > 2 { - AssertErrorIs(t, args[0].(error), args[1].(error), args[2:]...) - - } else { - AssertErrorIs(t, args[0].(error), args[1].(error)) - } -} - -func wrapAssertErrorContains(t TestingT, args []any) { - if len(args) > 2 { - AssertErrorContains(t, args[0].(error), args[1].(string), args[2:]...) - - } else { - AssertErrorContains(t, args[0].(error), args[1].(string)) - } -} - -func wrapAssertTrue(t TestingT, args []any) { - if len(args) > 1 { - AssertTrue(t, args[0].(bool), args[1:]...) - - } else { - AssertTrue(t, args[0].(bool)) - } -} - -func wrapAssertFalse(t TestingT, args []any) { - if len(args) > 1 { - AssertFalse(t, args[0].(bool), args[1:]...) - - } else { - AssertFalse(t, args[0].(bool)) - } -} - -func wrapAssertNil(t TestingT, args []any) { - if len(args) > 1 { - AssertNil(t, args[0], args[1:]...) - - } else { - AssertNil(t, args[0]) - } -} - -func wrapAssertNotNil(t TestingT, args []any) { - if len(args) > 1 { - AssertNotNil(t, args[0], args[1:]...) - - } else { - AssertNotNil(t, args[0]) - } -} - -var passingTestFns = []struct { - name string - assertionFn assertFn - args []any -}{ - {"Check", wrapCheck, []any{true}}, - {"Assert", wrapAssert, []any{true}}, - {"AssertEqual", wrapAssertEqual, []any{5, 5}}, - {"AssertDeepEqual", wrapAssertDeepEqual, []any{5, 5}}, - {"AssertNotEqual", wrapAssertNotEqual, []any{5, 10}}, - {"AssertLenEqual", wrapAssertLenEqualInt, []any{[]int{1, 2}, 2}}, - {"AssertErrorIs", wrapAssertErrorIs, []any{os.ErrExist, os.ErrExist}}, - {"AssertErrorContains", wrapAssertErrorContains, []any{errors.New("error 1"), "error 1"}}, - {"AssertTrue", wrapAssertTrue, []any{true}}, - {"AssertFalse", wrapAssertFalse, []any{false}}, - {"AssertNil", wrapAssertNil, []any{nil}}, - {"AssertNotNil", wrapAssertNotNil, []any{1}}, -} - -var failingTestFns = []struct { - name string - assertionFn assertFn - args []any -}{ - {"Check", wrapCheck, []any{false}}, - {"Assert", wrapAssert, []any{false}}, - {"AssertEqual", wrapAssertEqual, []any{5, 10}}, - {"AssertDeepEqual", wrapAssertDeepEqual, []any{5, 10}}, - {"AssertNotEqual", wrapAssertNotEqual, []any{5, 5}}, - {"AssertLenEqual", wrapAssertLenEqualInt, []any{[]int{1, 2}, 0}}, - {"AssertErrorIs", wrapAssertErrorIs, []any{errors.New("error 1"), errors.New("error 2")}}, - {"AssertErrorContains", wrapAssertErrorContains, []any{errors.New("error 1"), "error 2"}}, - {"AssertTrue", wrapAssertTrue, []any{false}}, - {"AssertFalse", wrapAssertFalse, []any{true}}, - {"AssertNil", wrapAssertNil, []any{1}}, - {"AssertNotNil", wrapAssertNotNil, []any{nil}}, -} - -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: assertion 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 := &MockT{} - - testFn.assertionFn(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(mockT.Logs), mockT.Logs, len(testCase.expectedLogs), - testCase.expectedLogs, - ) - } - 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 TestAssertFnsCallHelper(t *testing.T) { - for _, testFn := range failingTestFns { - t.Run(testFn.name, func(t *testing.T) { - mockHelperT := &MockHelperT{} - - testFn.assertionFn(mockHelperT, testFn.args) - - if !mockHelperT.HelperCalled { - t.Errorf("%s: expected HelperT to be called", testFn.name) - } - }) - } -} - -func TestAssertFnsShouldNotFailOrEmitLogsOnSuccess(t *testing.T) { - for _, testFn := range passingTestFns { - t.Run(testFn.name, func(t *testing.T) { - mockT := &MockT{} - testFn.assertionFn(mockT, testFn.args) - - if mockT.FailNowCalled { - t.Fatalf( - "%s: fail now 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 TestCheckReturnValues(t *testing.T) { - t.Run("should return true on true condition", func(t *testing.T) { - mockT := &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 := &MockT{} - - passed := Check(mockT, false) - - if passed { - t.Fatal("Check should have returned false on false condition") - } - }) -} - -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 := &MockT{} - AssertEqual(mockT, tc.actual, tc.expected) - - if mockT.FailNowCalled != tc.shouldFail { - t.Errorf( - "%s: FailNowCalled = %v, want %v", - tc.name, mockT.FailNowCalled, 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 := &MockT{} - AssertDeepEqual(mockT, TestStruct{"Alice", 30}, TestStruct{"Alice", 30}) - if mockT.FailNowCalled { - t.Error("AssertDeepEqual failed when it should have passed") - } - }) - - t.Run("Not equal structs", func(t *testing.T) { - mockT := &MockT{} - AssertDeepEqual(mockT, TestStruct{"Alice", 30}, TestStruct{"Bob", 30}) - if !mockT.FailNowCalled { - 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 := &MockT{} - actual := fmt.Errorf("wrapped: %w", os.ErrInvalid) - expected := os.ErrInvalid - - AssertErrorIs(mockT, actual, expected) - - if mockT.FailNowCalled { - t.Fatal("AssertErrorIs failed when it should have passed") - } -} -- cgit v1.2.3