Add map Contains and NotContains

Author: pellared

map.go

@@ -1,6 +1,10 @@
 package verify
 
-import "fmt"
+import (
+	"fmt"
+
+	"github.com/google/go-cmp/cmp"
+)
 
 // FluentMap encapsulates assertions for a map.
 type FluentMap[K comparable, V any] struct {
@@ -28,6 +32,40 @@ func (x FluentMap[K, V]) NotEmpty() FailureMessage {
 	return FailureMessage(fmt.Sprintf("an empty map\ngot: %+v", x.Got))
 }
 
+// Contain tests if the map contains all pairs from want.
+func (x FluentMap[K, V]) Contain(want map[K]V, opts ...cmp.Option) FailureMessage {
+	missing := x.miss(want, opts)
+	if len(missing) == 0 {
+		return ""
+	}
+	return FailureMessage(fmt.Sprintf("not contains all pairs\ngot: %+v\nwant: %+v\nmissing: %+v", x.Got, want, missing))
+}
+
+// NotContain tests if the slice does not have the same element as want in any order.
+func (x FluentMap[K, V]) NotContain(want map[K]V, opts ...cmp.Option) FailureMessage {
+	missing := x.miss(want, opts)
+	if len(missing) > 0 {
+		return ""
+	}
+	return FailureMessage(fmt.Sprintf("contains all pairs\ngot: %+v\nwant: %+v", x.Got, want))
+}
+
+func (x FluentMap[K, V]) miss(want map[K]V, opts []cmp.Option) map[K]V {
+	missing := map[K]V{}
+	for k, v := range want {
+		got, ok := x.Got[k]
+		if !ok {
+			missing[k] = v
+			continue
+		}
+		if !cmp.Equal(v, got, opts...) {
+			missing[k] = v
+			continue
+		}
+	}
+	return missing
+}
+
 // TODO: Contain(elements map[K]V) FailureMessage
 
 // TODO: NotContain(elements map[K]V) FailureMessage

map_test.go

@@ -25,6 +25,14 @@ func TestMap(t *testing.T) {
 		"a": {Str: "text", Bool: true, Slice: []int{1, 2, 3}},
 		"b": {Slice: []int{9, 8, 7}},
 	}
+	has := map[string]A{
+		"a": {Str: "text", Bool: true, Slice: []int{1, 2, 3}},
+	}
+	notHas := map[string]A{
+		"a": {Str: "text", Bool: true, Slice: []int{1, 2, 3}},
+		"b": {Slice: []int{1, 4, 7}},
+		"c": {Slice: []int{9, 8, 7}},
+	}
 	t.Run("Empty", func(t *testing.T) {
 		t.Run("Passed", func(t *testing.T) {
 			got := verify.Map(map[string]A{}).Empty()
@@ -45,4 +53,25 @@ func TestMap(t *testing.T) {
 			assertFailed(t, got, "an empty map")
 		})
 	})
+
+	t.Run("Contain", func(t *testing.T) {
+		t.Run("Passed", func(t *testing.T) {
+			got := verify.Map(dict).Contain(has)
+			assertPassed(t, got)
+		})
+		t.Run("Failed", func(t *testing.T) {
+			got := verify.Map(dict).Contain(notHas)
+			assertFailed(t, got, "not contains all pairs")
+		})
+	})
+	t.Run("NotContain", func(t *testing.T) {
+		t.Run("Passed", func(t *testing.T) {
+			got := verify.Map(dict).NotContain(notHas)
+			assertPassed(t, got)
+		})
+		t.Run("Failed", func(t *testing.T) {
+			got := verify.Map(dict).NotContain(has)
+			assertFailed(t, got, "contains all pairs")
+		})
+	})
 }

slice.go

@@ -32,7 +32,7 @@ func (x FluentSlice[T]) NotEmpty() FailureMessage {
 	return FailureMessage(fmt.Sprintf("an empty slice\ngot: %+v", x.Got))
 }
 
-// Equivalent tests if the slice has the same element as want in any order.
+// Equivalent tests if the slice has the same items as want in any order.
 func (x FluentSlice[T]) Equivalent(want []T, opts ...cmp.Option) FailureMessage {
 	extraGot, extraWant := x.diff(want, opts)
 	if len(extraGot) == 0 && len(extraWant) == 0 {
@@ -41,7 +41,7 @@ func (x FluentSlice[T]) Equivalent(want []T, opts ...cmp.Option) FailureMessage
 	return FailureMessage(fmt.Sprintf("not equivalent\nextra got: %+v\nextra want: %+v", extraGot, extraWant))
 }
 
-// NotEquivalent tests if the slice does not have the same element as want in any order.
+// NotEquivalent tests if the slice does not have the same items as want in any order.
 func (x FluentSlice[T]) NotEquivalent(want []T, opts ...cmp.Option) FailureMessage {
 	extraGot, extraWant := x.diff(want, opts)
 	if len(extraGot) != 0 || len(extraWant) != 0 {
@@ -83,6 +83,7 @@ func (x FluentSlice[T]) diff(want []T, opts []cmp.Option) (extraGot, extraWant [
 	return
 }
 
+// TODO: Rename to ContainItem and add Contain
 // Contain tests if the slice contains the item.
 func (x FluentSlice[T]) Contain(item T, opts ...cmp.Option) FailureMessage {
 	for _, v := range x.Got {
@@ -93,6 +94,7 @@ func (x FluentSlice[T]) Contain(item T, opts ...cmp.Option) FailureMessage {
 	return FailureMessage(fmt.Sprintf("slice does not contain the item\ngot: %+v\nitem: %+v", x.Got, item))
 }
 
+// TODO: Rename to NotContainItem and add NotContain
 // NotContain tests if the slice does not contain the item.
 func (x FluentSlice[T]) NotContain(item T, opts ...cmp.Option) FailureMessage {
 	for _, v := range x.Got {