Add comparable assertions

Author: pellared

build/build.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"os/exec"
 
 	"github.com/goyek/goyek"
 	"github.com/mattn/go-shellwords"
@@ -19,10 +20,10 @@ func flow() *goyek.Flow {
 
 	test := flow.Register(taskTest())
 	lint := flow.Register(taskLint())
-	markdownlint := flow.Register(taskMarkdownLint())
 	misspell := flow.Register(taskMisspell())
+	markdownlint := flow.Register(taskMarkdownLint())
 	all := flow.Register(taskAll(goyek.Deps{
-		test, lint, markdownlint, misspell,
+		test, lint, misspell, markdownlint,
 	}))
 
 	flow.DefaultTask = all
@@ -50,11 +51,26 @@ func taskLint() goyek.Task {
 	}
 }
 
+func taskMisspell() goyek.Task {
+	return goyek.Task{
+		Name:  "misspell",
+		Usage: "misspell",
+		Action: func(tf *goyek.TF) {
+			Exec(tf, buildDir, "go install github.com/client9/misspell/cmd/misspell")
+			Exec(tf, "", "misspell -error -locale=US *.md")
+		},
+	}
+}
+
 func taskMarkdownLint() goyek.Task {
 	return goyek.Task{
 		Name:  "markdownlint",
-		Usage: "markdownlint-cli (requires docker)",
+		Usage: "markdownlint-cli (uses docker)",
 		Action: func(tf *goyek.TF) {
+			if _, err := exec.LookPath("docker"); err != nil {
+				tf.Skip(err)
+			}
+
 			curDir, err := os.Getwd()
 			if err != nil {
 				tf.Fatal(err)
@@ -68,17 +84,6 @@ func taskMarkdownLint() goyek.Task {
 	}
 }
 
-func taskMisspell() goyek.Task {
-	return goyek.Task{
-		Name:  "misspell",
-		Usage: "misspell",
-		Action: func(tf *goyek.TF) {
-			Exec(tf, buildDir, "go install github.com/client9/misspell/cmd/misspell")
-			Exec(tf, "", "misspell -error -locale=US *.md")
-		},
-	}
-}
-
 func taskAll(deps goyek.Deps) goyek.Task {
 	return goyek.Task{
 		Name:  "all",

f/comparable.go

@@ -0,0 +1,27 @@
+package f
+
+// FluentComparable encapsulates assertions for comparable object.
+type FluentComparable[T comparable] struct {
+	FluentObj[T]
+}
+
+// Comparable is used for testing a comparable object.
+func Comparable[T comparable](got T) FluentComparable[T] {
+	return FluentComparable[T]{FluentObj[T]{got}}
+}
+
+// Equal tests if the objects are equal using == operator.
+func (x FluentComparable[T]) Equal(want T) FailureMessage {
+	if x.Got == want {
+		return ""
+	}
+	return "the objects are not equal"
+}
+
+// NotEqual tests if the objects are equal using == operator.
+func (x FluentComparable[T]) NotEqual(want T) FailureMessage {
+	if x.Got != want {
+		return ""
+	}
+	return "the objects are equal"
+}

f/comparable_test.go

@@ -0,0 +1,60 @@
+package f_test
+
+import (
+	"testing"
+
+	"github.com/pellared/fluentassert/f"
+)
+
+func TestComparable(t *testing.T) {
+	type A struct {
+		Str  string
+		Bool bool
+	}
+
+	t.Run("Equal", func(t *testing.T) {
+		t.Run("Passed", func(t *testing.T) {
+			want := A{Str: "string", Bool: true}
+			got := A{Str: "string", Bool: true}
+			msg := f.Comparable(got).Equal(want)
+			assertPassed(t, msg)
+		})
+		t.Run("Failed", func(t *testing.T) {
+			want := A{Str: "string", Bool: true}
+			got := A{Str: "wrong", Bool: true}
+			msg := f.Comparable(got).Equal(want)
+			assertFailed(t, msg, "the objects are not equal")
+		})
+		t.Run("nil", func(t *testing.T) {
+			var got *A
+			msg := f.Comparable(got).Equal(nil)
+			assertPassed(t, msg)
+		})
+	})
+
+	t.Run("NotEqual", func(t *testing.T) {
+		t.Run("Passed", func(t *testing.T) {
+			want := A{Str: "string", Bool: true}
+			got := A{Str: "wrong", Bool: true}
+			msg := f.Comparable(got).NotEqual(want)
+			assertPassed(t, msg)
+		})
+		t.Run("Failed", func(t *testing.T) {
+			want := A{Str: "string", Bool: true}
+			got := A{Str: "string", Bool: true}
+			msg := f.Comparable(got).NotEqual(want)
+			assertFailed(t, msg, "the objects are equal")
+		})
+		t.Run("nil", func(t *testing.T) {
+			var got *A
+			msg := f.Comparable(got).NotEqual(nil)
+			assertFailed(t, msg, "the objects are equal")
+		})
+	})
+
+	t.Run("has assertions from Obj", func(t *testing.T) {
+		want := A{}
+		got := f.Comparable(want).FluentObj.Got // type embedding done properly
+		assertEqual(t, got, want)
+	})
+}

f/obj.go

@@ -2,7 +2,7 @@ package f
 
 import "github.com/google/go-cmp/cmp"
 
-// FluentObj encapsulates assertions for any objet.
+// FluentObj encapsulates assertions for any object.
 type FluentObj[T any] struct {
 	Got T
 }