New package 'must' to signal immediate/fatal termination of failed test cases

doc.go

@@ -16,6 +16,7 @@ package assertions
 import (
 	"fmt"
 	"runtime"
+	"strings"
 )
 
 // By default, we use a no-op serializer. The actual Serializer provides a JSON
@@ -39,6 +40,7 @@ func GoConveyMode(yes bool) {
 
 type testingT interface {
 	Error(args ...any)
+	Fatal(args ...any)
 }
 
 type Assertion struct {
@@ -61,9 +63,15 @@ func (this *Assertion) Failed() bool {
 func (this *Assertion) So(actual any, assert SoFunc, expected ...any) bool {
 	ok, result := So(actual, assert, expected...)
 	if !ok {
+		const fatalPrefix = "<<FATAL>>"
 		this.failed = true
 		_, file, line, _ := runtime.Caller(1)
-		this.t.Error(fmt.Sprintf("\n%s:%d\n%s", file, line, result))
+		report := fmt.Sprintf("\n%s:%d\n%s", file, line, result)
+		if strings.HasPrefix(result, fatalPrefix) {
+			this.t.Fatal(report)
+		} else {
+			this.t.Error(report)
+		}
 	}
 	return ok
 }

doc_test.go

@@ -49,6 +49,23 @@ func TestFailingAssertion(t *testing.T) {
 	}
 }
 
+func TestFatalAssertion(t *testing.T) {
+	fake := &FakeT{buffer: new(bytes.Buffer)}
+	assertion := New(fake)
+	passed := assertion.So(1, MustEqual, 2)
+
+	if passed {
+		t.Error("Assertion passed when it should have failed.")
+	}
+	if !fake.fatal {
+		t.Error("Expected assertion to fail fatally.")
+	}
+}
+
+func MustEqual(actual any, expected ...any) string {
+	return "<<FATAL>>"
+}
+
 func TestFailingGroupsOfAssertions(t *testing.T) {
 	fake := &FakeT{buffer: new(bytes.Buffer)}
 	assertion1 := New(fake)
@@ -67,8 +84,14 @@ func TestFailingGroupsOfAssertions(t *testing.T) {
 
 type FakeT struct {
 	buffer *bytes.Buffer
+	fatal  bool
 }
 
 func (this *FakeT) Error(args ...any) {
-	fmt.Fprint(this.buffer, args...)
+	_, _ = fmt.Fprint(this.buffer, args...)
+}
+
+func (this *FakeT) Fatal(args ...any) {
+	_, _ = fmt.Fprint(this.buffer, args...)
+	this.fatal = true
 }

must/must.go

@@ -0,0 +1,79 @@
+package must
+
+import "github.com/smarty/assertions"
+
+func fatal(so assertions.SoFunc) assertions.SoFunc {
+	return func(actual any, expected ...any) string {
+		result := so(actual, expected...)
+		if len(result) > 0 {
+			return "<<FATAL>>" + result
+		}
+		return result
+	}
+}
+
+var (
+	AlmostEqual            = fatal(assertions.ShouldAlmostEqual)
+	BeBetween              = fatal(assertions.ShouldBeBetween)
+	BeBetweenOrEqual       = fatal(assertions.ShouldBeBetweenOrEqual)
+	BeBlank                = fatal(assertions.ShouldBeBlank)
+	BeChronological        = fatal(assertions.ShouldBeChronological)
+	BeEmpty                = fatal(assertions.ShouldBeEmpty)
+	BeError                = fatal(assertions.ShouldBeError)
+	BeFalse                = fatal(assertions.ShouldBeFalse)
+	BeGreaterThan          = fatal(assertions.ShouldBeGreaterThan)
+	BeGreaterThanOrEqualTo = fatal(assertions.ShouldBeGreaterThanOrEqualTo)
+	BeIn                   = fatal(assertions.ShouldBeIn)
+	BeLessThan             = fatal(assertions.ShouldBeLessThan)
+	BeLessThanOrEqualTo    = fatal(assertions.ShouldBeLessThanOrEqualTo)
+	BeNil                  = fatal(assertions.ShouldBeNil)
+	BeTrue                 = fatal(assertions.ShouldBeTrue)
+	BeZeroValue            = fatal(assertions.ShouldBeZeroValue)
+	Contain                = fatal(assertions.ShouldContain)
+	ContainKey             = fatal(assertions.ShouldContainKey)
+	ContainSubstring       = fatal(assertions.ShouldContainSubstring)
+	EndWith                = fatal(assertions.ShouldEndWith)
+	Equal                  = fatal(assertions.ShouldEqual)
+	EqualJSON              = fatal(assertions.ShouldEqualJSON)
+	EqualTrimSpace         = fatal(assertions.ShouldEqualTrimSpace)
+	EqualWithout           = fatal(assertions.ShouldEqualWithout)
+	HappenAfter            = fatal(assertions.ShouldHappenAfter)
+	HappenBefore           = fatal(assertions.ShouldHappenBefore)
+	HappenBetween          = fatal(assertions.ShouldHappenBetween)
+	HappenOnOrAfter        = fatal(assertions.ShouldHappenOnOrAfter)
+	HappenOnOrBefore       = fatal(assertions.ShouldHappenOnOrBefore)
+	HappenOnOrBetween      = fatal(assertions.ShouldHappenOnOrBetween)
+	HappenWithin           = fatal(assertions.ShouldHappenWithin)
+	HaveLength             = fatal(assertions.ShouldHaveLength)
+	HaveSameTypeAs         = fatal(assertions.ShouldHaveSameTypeAs)
+	Implement              = fatal(assertions.ShouldImplement)
+	NotAlmostEqual         = fatal(assertions.ShouldNotAlmostEqual)
+	NotBeBetween           = fatal(assertions.ShouldNotBeBetween)
+	NotBeBetweenOrEqual    = fatal(assertions.ShouldNotBeBetweenOrEqual)
+	NotBeBlank             = fatal(assertions.ShouldNotBeBlank)
+	NotBeChronological     = fatal(assertions.ShouldNotBeChronological)
+	NotBeEmpty             = fatal(assertions.ShouldNotBeEmpty)
+	NotBeIn                = fatal(assertions.ShouldNotBeIn)
+	NotBeNil               = fatal(assertions.ShouldNotBeNil)
+	NotBeZeroValue         = fatal(assertions.ShouldNotBeZeroValue)
+	NotContain             = fatal(assertions.ShouldNotContain)
+	NotContainKey          = fatal(assertions.ShouldNotContainKey)
+	NotContainSubstring    = fatal(assertions.ShouldNotContainSubstring)
+	NotEndWith             = fatal(assertions.ShouldNotEndWith)
+	NotEqual               = fatal(assertions.ShouldNotEqual)
+	NotHappenOnOrBetween   = fatal(assertions.ShouldNotHappenOnOrBetween)
+	NotHappenWithin        = fatal(assertions.ShouldNotHappenWithin)
+	NotHaveSameTypeAs      = fatal(assertions.ShouldNotHaveSameTypeAs)
+	NotImplement           = fatal(assertions.ShouldNotImplement)
+	NotPanic               = fatal(assertions.ShouldNotPanic)
+	NotPanicWith           = fatal(assertions.ShouldNotPanicWith)
+	NotPointTo             = fatal(assertions.ShouldNotPointTo)
+	NotResemble            = fatal(assertions.ShouldNotResemble)
+	NotStartWith           = fatal(assertions.ShouldNotStartWith)
+	Panic                  = fatal(assertions.ShouldPanic)
+	PanicWith              = fatal(assertions.ShouldPanicWith)
+	PointTo                = fatal(assertions.ShouldPointTo)
+	Resemble               = fatal(assertions.ShouldResemble)
+	StartWith              = fatal(assertions.ShouldStartWith)
+	Wrap                   = fatal(assertions.ShouldWrap)
+)

must/must_test.go

@@ -0,0 +1,17 @@
+package must
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestFatal(t *testing.T) {
+	output := Equal(1, 1)
+	if strings.HasPrefix(output, "<<FATAL>>") {
+		t.Error("Unexpected 'fatal' prefix")
+	}
+	output = Equal(1, 2)
+	if !strings.HasPrefix(output, "<<FATAL>>") {
+		t.Error("Missing expected 'fatal' prefix from output:", output)
+	}
+}