AssertableError + ThenPrettyPrintOnFail + misc. changes

Author: Geish

.travis.yml

@@ -7,6 +7,7 @@ go:
   - 1.8
   - 1.9
   - "1.10"
+  - 1.11
   - tip
 
 env: GO15VENDOREXPERIMENT=1

Makefile

@@ -1,5 +1,4 @@
 GO ?= go
-GOFMT ?= gofmt
 GOIMPORTS ?= goimports
 ALL_PACKAGES := ./...
 LOCAL_PACKAGES := `$(GO) list $(ALL_PACKAGES) | grep -v /vendor/`
@@ -8,7 +7,6 @@ LOCAL_PACKAGES_FOLDERS := $(shell find * -maxdepth 0 -type d | grep -v vendor)
 all: clean check
 
 check:
-	$(GOFMT) -s -w $(LOCAL_PACKAGES_FOLDERS)
 	$(GOIMPORTS) -w $(LOCAL_PACKAGES_FOLDERS)
 	$(GO) vet $(LOCAL_PACKAGES)
 	$(GO) test $(LOCAL_PACKAGES)

README.md

@@ -40,7 +40,7 @@ import (
 func TestDeepThought(t *testing.T) {
     computer := NewDeepThoughtComputer()
     answer, err := computer.AnswerTheUltimateQuestion()
-    if assert.For(t).ThatActual(err).IsNil().Passed() {
+    if assert.For(t).ThatActualError(err).IsNil().Passed() {
         assert.For(t).ThatActual(answer).Equals(42)
     }
 }

assert/assert.go

@@ -22,9 +22,12 @@ type TestContext interface {
 	// expected to meet certain criteria.
 	ThatActual(value interface{}) AssertableValue
 
+	// ThatActualError adapts the specified error to an assertable one that's
+	// expected to meet certain criteria.
+	ThatActualError(value error) AssertableError
+
 	// ThatActualString adapts the specified string to an assertable one that's
 	// expected to meet certain criteria.
-	// TODO rename to ThatActualString
 	ThatActualString(value string) AssertableString
 
 	// ThatType adapts the specified type to an assertable one that's
@@ -64,6 +67,10 @@ func (testContext *testContext) ThatActual(value interface{}) AssertableValue {
 	return &assertableValue{testContext: testContext, value: value}
 }
 
+func (testContext *testContext) ThatActualError(value error) AssertableError {
+	return &assertableError{testContext: testContext, value: value}
+}
+
 func (testContext *testContext) ThatActualString(value string) AssertableString {
 	return &assertableString{testContext: testContext, value: value}
 }
@@ -82,6 +89,14 @@ func PrintDiff(actual interface{}, expected interface{}) {
 	pretty.Fdiff(os.Stdout, actual, expected)
 }
 
+// PrettyPrint pretty-prints the specified actual and expected values,
+// in that order.
+func PrettyPrint(actual interface{}, expected interface{}) {
+	printLock.Lock()
+	defer printLock.Unlock()
+	pretty.Printf("Pretty:\nActual: %s\nExpected: %s\n", actual, expected)
+}
+
 func (testContext *testContext) decoratedErrorf(format string, args ...interface{}) {
 	file, line := testContext.caller()
 	testContext.errorf(file, line, format, args...)

assert/assert_test.go

@@ -6,6 +6,10 @@ import (
 	"testing"
 )
 
+var (
+	t = &testing.T{}
+)
+
 func TestHooksAreHidden(t *testing.T) {
 	For(t).ThatType(reflect.TypeOf(testContext{})).HidesTestHooks()
 }
@@ -22,8 +26,6 @@ func pack(elements ...interface{}) []interface{} {
 	return elements
 }
 
-var t = &testing.T{}
-
 // mockTestContextToAssert mocks a test context to use for assertions.
 // The optional parameter(s) can be used to identify a specific test case
 // in a data-driven test.

assert/call_test.go

@@ -1,18 +1,18 @@
 package assert
 
-func ExampleAssertableCall_panicsReportingPass() {
+func ExampleAssertableCall_PanicsReporting_pass() {
 	For(t).ThatCalling(func() { panic("error") }).PanicsReporting("error")
 	// Output:
 }
 
-func ExampleAssertableCall_panicsReportingFailPanicDidNotOccur() {
+func ExampleAssertableCall_PanicsReporting_panicDidNotOccur() {
 	mockTestContextToAssert().ThatCalling(func() {}).PanicsReporting("expected")
 	// Output:
 	// file:3: Function call did not panic as expected.
 	// Expected: expected
 }
 
-func ExampleAssertableCall_panicsReportingFailMessageMismatch() {
+func ExampleAssertableCall_PanicsReporting_messageMismatch() {
 	mockTestContextToAssert().ThatCalling(func() { panic("actual") }).PanicsReporting("expected")
 	// Output:
 	// file:3: Panic message mismatch.

assert/error.go

@@ -0,0 +1,64 @@
+package assert
+
+// AssertableError represents an under-test error that's expected to meet
+// certain criteria.
+type AssertableError interface {
+	// Equals asserts that the specified actual error equals the expected one.
+	// Returns a ValueAssertionResult that provides post-assert actions.
+	Equals(expected error) ValueAssertionResult
+
+	// IsNil asserts that the specified actual error is nil.
+	// Returns a ValueAssertionResult that provides post-assert actions.
+	IsNil() ValueAssertionResult
+
+	// IsNotNil asserts that the specified actual error is not nil.
+	// Returns a ValueAssertionResult that provides post-assert actions.
+	IsNotNil() ValueAssertionResult
+}
+
+type assertableError struct {
+	testContext *testContext
+	value       error
+}
+
+// ErrorString is a trivial implementation of error. It's useful for asserting
+// error messages. For example:
+//
+//     assert.For(t).ThatActualError(err).Equals(assert.ErrorString("foo"))
+//
+// The assert library compares errors by comapring the output of Error().
+type ErrorString string
+
+func (err ErrorString) Error() string {
+	return string(err)
+}
+
+func (actual *assertableError) Equals(expected error) ValueAssertionResult {
+	if expected == nil {
+		return actual.IsNil()
+	}
+	if actual.value == nil {
+		actual.testContext.decoratedErrorf("Error mismatch.\nActual was <nil>.\nExpected: %v\n", expected)
+		return &valueAssertionResult{bool: false, actual: actual.value, expected: expected}
+	}
+	// We're comparing interfaces — we only care about what Error() returns for both objects
+	areEqual := actual.value.Error() == expected.Error()
+	if !areEqual {
+		actual.testContext.decoratedErrorf("Error mismatch.\nActual: %s\nExpected: %s\n", actual.value, expected)
+	}
+	return &valueAssertionResult{bool: areEqual, actual: actual.value, expected: expected}
+}
+
+func (actual *assertableError) IsNil() ValueAssertionResult {
+	if actual.value != nil {
+		actual.testContext.decoratedErrorf("Actual error was not <nil>.\nActual: %v\n", actual.value)
+	}
+	return &valueAssertionResult{bool: actual.value == nil, actual: actual.value, expected: nil}
+}
+
+func (actual *assertableError) IsNotNil() ValueAssertionResult {
+	if actual.value == nil {
+		actual.testContext.decoratedErrorf("Actual error was <nil>.\n")
+	}
+	return &valueAssertionResult{bool: actual.value != nil, actual: actual.value, expected: &anyOtherValue{}}
+}

assert/error_test.go

@@ -0,0 +1,93 @@
+package assert
+
+import (
+	"errors"
+	"fmt"
+)
+
+func ExampleAssertableError_Equals_pass() {
+	cases := []struct {
+		id       string
+		actual   error
+		expected error
+	}{
+		{"both are nil", nil, nil},
+		{"same type and message", errors.New("foo"), errors.New("foo")},
+		{"different struct types, same message", ErrorString("foo"), errors.New("foo")},
+	}
+
+	for _, c := range cases {
+		if For(t, c.id).ThatActualError(c.actual).Equals(c.expected).Passed() {
+			fmt.Println("Passed: " + c.id)
+		}
+	}
+	// Output:
+	// Passed: both are nil
+	// Passed: same type and message
+	// Passed: different struct types, same message
+}
+
+func ExampleAssertableError_Equals_fail() {
+	cases := []struct {
+		id       string
+		actual   error
+		expected error
+	}{
+		{"expected is nil while actual isn't", ErrorString("foo"), nil},
+		{"actual is nil while expected isn't", nil, ErrorString("foo")},
+		{"different messages", ErrorString("foo"), ErrorString("bar")},
+	}
+
+	for _, c := range cases {
+		if !mockTestContextToAssert(c.id).ThatActualError(c.actual).Equals(c.expected).Passed() {
+			fmt.Println("Assertion failed successfully!")
+		}
+	}
+	// Output:
+	// file:3: [expected is nil while actual isn't] Actual error was not <nil>.
+	// Actual: foo
+	// Assertion failed successfully!
+	// file:3: [actual is nil while expected isn't] Error mismatch.
+	// Actual was <nil>.
+	// Expected: foo
+	// Assertion failed successfully!
+	// file:3: [different messages] Error mismatch.
+	// Actual: foo
+	// Expected: bar
+	// Assertion failed successfully!
+}
+
+func ExampleAssertableError_IsNil_pass() {
+	if For(t).ThatActualError(nil).IsNil().Passed() {
+		fmt.Println("Passed!")
+	}
+	// Output: Passed!
+}
+
+func ExampleAssertableError_IsNil_fail() {
+	if !mockTestContextToAssert().ThatActualError(errors.New("foo")).IsNil().Passed() {
+		fmt.Println("Assertion failed successfully!")
+	}
+	// Output:
+	// file:3: Actual error was not <nil>.
+	// Actual: foo
+	// Assertion failed successfully!
+}
+
+func ExampleAssertableError_IsNotNil_pass() {
+	if For(t).ThatActualError(errors.New("foo")).IsNotNil().Passed() {
+		fmt.Println("Passed!")
+	}
+	// Output: Passed!
+}
+
+func ExampleAssertableError_IsNotNil_fail() {
+	if !mockTestContextToAssert().ThatActualError(nil).IsNotNil().ThenDiffOnFail().Passed() {
+		fmt.Println("Assertion failed successfully!")
+	}
+	// Output:
+	// file:3: Actual error was <nil>.
+	// Diff:
+	// nil != &assert.anyOtherValue{}
+	// Assertion failed successfully!
+}

assert/result.go

@@ -33,6 +33,10 @@ type ValueAssertionResult interface {
 	// Returns the current ValueAssertionResult to allow for call-chaining.
 	ThenDiffOnFail() ValueAssertionResult
 
+	// ThenPrettyPrintOnFail pretty-prints asserted values on assertion failure;
+	// Returns the current ValueAssertionResult to allow for call-chaining.
+	ThenPrettyPrintOnFail() ValueAssertionResult
+
 	// ThenRunOnFail performed the specified action on assertion failure;
 	// in which case, it passes the actual and expected values used in
 	// the failed assertion as parameters to the specified function.
@@ -54,6 +58,10 @@ func (result *valueAssertionResult) ThenDiffOnFail() ValueAssertionResult {
 	return result.ThenRunOnFail(PrintDiff)
 }
 
+func (result *valueAssertionResult) ThenPrettyPrintOnFail() ValueAssertionResult {
+	return result.ThenRunOnFail(PrettyPrint)
+}
+
 func (result *valueAssertionResult) ThenRunOnFail(action func(actual, expected interface{})) ValueAssertionResult {
 	if !result.Passed() {
 		action(result.actual, result.expected)

assert/result_test.go

@@ -5,7 +5,7 @@ import (
 	"net/mail"
 )
 
-func ExampleValueAssertionResult_ThenDiffOnFail_whenAssertionFails() {
+func ExampleValueAssertionResult_ThenDiffOnFail_assertionFailed() {
 	address := &mail.Address{Name: "Richard Hendricks", Address: "[email protected]"}
 	expected := &mail.Address{Name: "Erlich Bachman", Address: "[email protected]"}
 	mockTestContextToAssert().ThatActual(address).Equals(expected).ThenDiffOnFail()
@@ -18,14 +18,27 @@ func ExampleValueAssertionResult_ThenDiffOnFail_whenAssertionFails() {
 	// Address: "[email protected]" != "[email protected]"
 }
 
-func ExampleValueAssertionResult_ThenDiffOnFail_whenAssertionPasses() {
+func ExampleValueAssertionResult_ThenDiffOnFail_assertionPassed() {
 	if mockTestContextToAssert().ThatActual(42).Equals(42).ThenDiffOnFail().Passed() {
 		fmt.Println("Passed!")
 	}
 	// Output: Passed!
 }
 
-func ExampleValueAssertionResult_ThenRunOnFail_whenAssertionFails() {
+func ExampleValueAssertionResult_ThenPrettyPrintOnFail_assertionFailed() {
+	address := &mail.Address{Name: "Richard Hendricks", Address: "[email protected]"}
+	expected := &mail.Address{Name: "Erlich Bachman", Address: "[email protected]"}
+	mockTestContextToAssert().ThatActual(address).Equals(expected).ThenPrettyPrintOnFail()
+	// Output:
+	// file:3: Value mismatch.
+	// Actual: &mail.Address{Name:"Richard Hendricks", Address:"[email protected]"}
+	// Expected: &mail.Address{Name:"Erlich Bachman", Address:"[email protected]"}
+	// Pretty:
+	// Actual: "Richard Hendricks" <[email protected]>
+	// Expected: "Erlich Bachman" <[email protected]>
+}
+
+func ExampleValueAssertionResult_ThenRunOnFail_assertionFailed() {
 	mockTestContextToAssert().ThatActualString("foo").Equals("bar").ThenRunOnFail(func(actual, expected interface{}) {
 		fmt.Printf("Custom Message: %q != %q", actual, expected)
 	})
@@ -36,7 +49,7 @@ func ExampleValueAssertionResult_ThenRunOnFail_whenAssertionFails() {
 	// Custom Message: "foo" != "bar"
 }
 
-func ExampleValueAssertionResult_ThenRunOnFail_whenAssertionPasses() {
+func ExampleValueAssertionResult_ThenRunOnFail_assertionPassed() {
 	panicker := func(actual, expected interface{}) { panic("This should have never run!") }
 	if mockTestContextToAssert().ThatActual(42).Equals(42).ThenRunOnFail(panicker).Passed() {
 		fmt.Println("Passed!")

assert/string_test.go

@@ -2,14 +2,14 @@ package assert
 
 import "fmt"
 
-func ExampleAssertableString_equalsPass() {
+func ExampleAssertableString_Equals_pass() {
 	if For(t).ThatActualString("foo").Equals("foo").Passed() {
 		fmt.Println("Passed!")
 	}
 	// Output: Passed!
 }
 
-func ExampleAssertableString_equalsFail() {
+func ExampleAssertableString_Equals_fail() {
 	cases := []struct {
 		id       string
 		actual   string
@@ -40,14 +40,14 @@ func ExampleAssertableString_equalsFail() {
 	// Assertion failed successfully!
 }
 
-func ExampleAssertableValue_isEmptyPass() {
+func ExampleAssertableString_IsEmpty_pass() {
 	if For(t).ThatActualString("").IsEmpty().Passed() {
 		fmt.Println("Passed!")
 	}
 	// Output: Passed!
 }
 
-func ExampleAssertableValue_isEmptyFail() {
+func ExampleAssertableString_IsEmpty_fail() {
 	if !mockTestContextToAssert().ThatActualString("foo").IsEmpty().ThenDiffOnFail().Passed() {
 		fmt.Println("Assertion failed successfully!")
 	}
@@ -59,14 +59,14 @@ func ExampleAssertableValue_isEmptyFail() {
 	// Assertion failed successfully!
 }
 
-func ExampleAssertableValue_isNotEmptyPass() {
+func ExampleAssertableString_IsNotEmpty_pass() {
 	if For(t).ThatActualString(" ").IsNotEmpty().Passed() {
 		fmt.Println("Passed!")
 	}
 	// Output: Passed!
 }
 
-func ExampleAssertableValue_isNotEmptyFail() {
+func ExampleAssertableString_IsNotEmpty_fail() {
 	if !mockTestContextToAssert().ThatActualString("").IsNotEmpty().ThenDiffOnFail().Passed() {
 		fmt.Println("Assertion failed successfully!")
 	}