Change Merge to Prefix, And, Or

Author: pellared

CHANGELOG.md

@@ -62,7 +62,8 @@ The main additions are the new assertions for
   via `FluentAsync` and `FluentPeriodic` types:
   - `Eventually`
   - `EventuallyContext`
-- Add `FailureMessage.Merge` method to to facilitate accumulating failure messages.
+- Add `FailureMessage.Prefix` method together with `And` and `Or` functions
+  to facilitate creating complex assertions.
 
 ### Changed
 

README.md

@@ -160,18 +160,44 @@ $ go test
 
 ## Extensibility
 
-### Custom fluent assertions
+### Custom predicates
 
-You can take advantage of the `verify.FailureMessage` and `verify.Fluent*` types
-to create your own fluent assertions for a given type.
+For the most basic scenarios, you can use one of the
+`Check`, `Should`, `ShouldNot` assertions.
 
-For reference, take a look at the implementation
-of existing fluent assertions in this repository
-(for example [comparable.go](verify/comparable.go)).
+```go
+package test
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/fluentassert/verify"
+)
+
+func TestShould(t *testing.T) {
+	got := "wrong"
+
+	chars := "abc"
+	verify.Obj(got).Should(func(got string) bool {
+		return strings.ContainsAny(got, chars)
+	}).Assertf(t, "does not contain any of: %s", chars)
+}
+```
+
+```sh
+$ go test
+--- FAIL: TestShould (0.00s)
+    should_test.go:16: does not contain any of: abc
+        object does not meet the predicate criteria
+        got: "wrong"
+```
 
 ### Custom assertion function
 
-For simple cases, you can simply prepare a function that returns `FailureMessage`.
+You can create a function that returns `FailureMessage`.
+Use `And` and `Or` functions together with `FailureMessage.Prefix` method
+to create complex assertions.
 
 ```go
 package test
@@ -194,62 +220,32 @@ func TestCustom(t *testing.T) {
 }
 
 func verifyA(got A) verify.FailureMessage {
-	var msg verify.FailureMessage
-	msg.Merge("got.String assertion:",
-		verify.String(got.Str).Contain("ok"),
-	)
-	msg.Merge("got.Ok assertion:",
-		verify.True(got.Ok),
+	return verify.And(
+		verify.String(got.Str).Contain("ok").Prefix("got.String: "),
+		verify.True(got.Ok).Prefix("got.Ok: "),
 	)
-	return msg
 }
 ```
 
 ```sh
 $ go test
 --- FAIL: TestCustom (0.00s)
     custom_test.go:17:
-        got.String assertion:
-        the value does not contain the substring
+        got.String: the value does not contain the substring
         got: "something was wrong"
         substr: "ok"
 
-        got.Ok assertion:
-        the value is false
+        got.Ok: the value is false
 ```
 
-### Custom predicates
-
-For the most basic scenarios, you can also use one of the
-`Check`, `Should`, `ShouldNot` assertions.
-
-```go
-package test
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/fluentassert/verify"
-)
-
-func TestShould(t *testing.T) {
-	got := "wrong"
+### Custom fluent assertions
 
-	chars := "abc"
-	verify.Obj(got).Should(func(got string) bool {
-		return strings.ContainsAny(got, chars)
-	}).Assertf(t, "does not contain any of: %s", chars)
-}
-```
+You can take advantage of the `FailureMessage` and `Fluent*` types
+to create your own fluent assertions for a given type.
 
-```sh
-$ go test
---- FAIL: TestShould (0.00s)
-    should_test.go:16: does not contain any of: abc
-        object does not meet the predicate criteria
-        got: "wrong"
-```
+For reference, take a look at the implementation
+of existing fluent assertions in this repository
+(for example [comparable.go](comparable.go)).
 
 ## Supported Go versions
 

and.go

@@ -0,0 +1,17 @@
+package verify
+
+// And accumalates non-empty failure messages.
+func And(assertions ...FailureMessage) FailureMessage {
+	var msg FailureMessage
+	for _, assertion := range assertions {
+		if assertion == "" {
+			continue
+		}
+		if msg == "" {
+			msg = assertion
+			continue
+		}
+		msg = msg + "\n\n" + assertion
+	}
+	return msg
+}

and_test.go

@@ -0,0 +1,26 @@
+package verify_test
+
+import (
+	"testing"
+
+	"github.com/fluentassert/verify"
+)
+
+func TestAnd(t *testing.T) {
+	t.Run("Empty", func(t *testing.T) {
+		msg := verify.And()
+		assertPassed(t, msg)
+	})
+	t.Run("NoneFailed", func(t *testing.T) {
+		msg := verify.And("", "")
+		assertPassed(t, msg)
+	})
+	t.Run("OneFailed", func(t *testing.T) {
+		msg := verify.And("", "failure")
+		assertFailed(t, msg, "failure")
+	})
+	t.Run("TwoFailed", func(t *testing.T) {
+		msg := verify.And("one", "two")
+		assertFailed(t, msg, "one\n\ntwo")
+	})
+}

failmsg.go

@@ -75,16 +75,10 @@ func (msg FailureMessage) Requiref(t interface {
 	return false
 }
 
-// Merge accumalates a non-empty failure message.
-//
-// Merge can be used for creating custom assertions.
-func (msg *FailureMessage) Merge(header string, failureMessage FailureMessage) {
-	if failureMessage == "" {
-		return
-	}
-	if *msg == "" {
-		*msg = FailureMessage(header) + "\n" + failureMessage
-		return
+// Prefix adds prefix if the failure message is not empty.
+func (msg FailureMessage) Prefix(s string) FailureMessage {
+	if msg == "" {
+		return ""
 	}
-	*msg = *msg + "\n\n" + FailureMessage(header) + "\n" + failureMessage
+	return FailureMessage(s) + msg
 }

failmsg_test.go

@@ -127,22 +127,14 @@ func TestFailureMessage(t *testing.T) {
 		})
 	})
 
-	t.Run("Merge", func(t *testing.T) {
-		t.Run("BothEmpty", func(t *testing.T) {
-			var first, second verify.FailureMessage
-			first.Merge("assertion", second)
-			assertPassed(t, first)
-		})
-		t.Run("ArgIsNotEmpty", func(t *testing.T) {
-			var msg verify.FailureMessage
-			msg.Merge("assertion", verify.FailureMessage("failure"))
-			assertFailed(t, msg, "assertion\nfailure")
+	t.Run("Prefix", func(t *testing.T) {
+		t.Run("Empty", func(t *testing.T) {
+			got := verify.FailureMessage("").Prefix("[fail]")
+			assertEqual(t, got, "")
 		})
-		t.Run("NoneIsEmpty", func(t *testing.T) {
-			var msg verify.FailureMessage
-			msg.Merge("first", verify.FailureMessage("error"))
-			msg.Merge("second", verify.FailureMessage("failure"))
-			assertFailed(t, msg, "first\nerror\n\nsecond\nfailure")
+		t.Run("Empty", func(t *testing.T) {
+			got := verify.FailureMessage("errored").Prefix("[fail] ")
+			assertEqual(t, got, "[fail] errored")
 		})
 	})
 }

or.go

@@ -0,0 +1,17 @@
+package verify
+
+// Or accumalates failure messages if all are not empty.
+func Or(assertions ...FailureMessage) FailureMessage {
+	var msg FailureMessage
+	for _, assertion := range assertions {
+		if assertion == "" {
+			return ""
+		}
+		if msg == "" {
+			msg = assertion
+			continue
+		}
+		msg = msg + "\n\n" + assertion
+	}
+	return msg
+}

or_test.go

@@ -0,0 +1,26 @@
+package verify_test
+
+import (
+	"testing"
+
+	"github.com/fluentassert/verify"
+)
+
+func TestOr(t *testing.T) {
+	t.Run("Empty", func(t *testing.T) {
+		msg := verify.Or()
+		assertPassed(t, msg)
+	})
+	t.Run("NoneFailed", func(t *testing.T) {
+		msg := verify.Or("", "")
+		assertPassed(t, msg)
+	})
+	t.Run("OneFailed", func(t *testing.T) {
+		msg := verify.Or("", "failure")
+		assertPassed(t, msg)
+	})
+	t.Run("TwoFailed", func(t *testing.T) {
+		msg := verify.Or("one", "two")
+		assertFailed(t, msg, "one\n\ntwo")
+	})
+}