Map assertions

Author: pellared

CHANGELOG.md

@@ -77,8 +77,6 @@ The main additions are the new assertions for
   - `NotEmpty`
   - `Contain`
   - `NotContain`
-  - `ContainKey`
-  - `NotContainKey`
   - `ContainPair`
   - `NotContainPair`
   - `Any`

README.md

@@ -124,7 +124,13 @@ func TestSlice(t *testing.T) {
 
 ```sh
 $ go test
-TODO
+--- FAIL: TestSlice (0.00s)
+    slice_test.go:12:
+        not equivalent
+        got: [3 1 2]
+        want: [2 3 4]
+        extra got: [1]
+        extra want: [4]
 ```
 
 ### Periodic polling

map.go

@@ -41,7 +41,7 @@ func (x FluentMap[K, V]) Contain(want map[K]V, opts ...cmp.Option) FailureMessag
 	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.
+// NotContain tests if the map does not contains all pairs from want.
 func (x FluentMap[K, V]) NotContain(want map[K]V, opts ...cmp.Option) FailureMessage {
 	missing := x.miss(want, opts)
 	if len(missing) > 0 {
@@ -66,20 +66,56 @@ func (x FluentMap[K, V]) miss(want map[K]V, opts []cmp.Option) map[K]V {
 	return missing
 }
 
-// TODO: Contain(elements map[K]V) FailureMessage
-
-// TODO: NotContain(elements map[K]V) FailureMessage
-
-// TODO: ContainKey(keys ...K) FailureMessage
-
-// TODO: NotContainKey(keys ...K) FailureMessage
-
-// TODO: ContainPair(K,V) FailureMessage
+// ContainPair tests if the map contains the pair.
+func (x FluentMap[K, V]) ContainPair(k K, v V, opts ...cmp.Option) FailureMessage {
+	got, ok := x.Got[k]
+	if !ok {
+		return FailureMessage(fmt.Sprintf("has no value under key\ngot: %+v\nkey: %+v\nvalue: %+v", x.Got, k, v))
+	}
+	if !cmp.Equal(v, got, opts...) {
+		return FailureMessage(fmt.Sprintf("has different value under key\nkey: %+v\ngot: %+v\nwant: %+v", k, got, v))
+	}
+	return ""
+}
 
-// TODO: NotContainPair(K,V) FailureMessage
+// NotContainPair tests if the map does not contain the pair.
+func (x FluentMap[K, V]) NotContainPair(k K, v V, opts ...cmp.Option) FailureMessage {
+	got, ok := x.Got[k]
+	if !ok {
+		return ""
+	}
+	if !cmp.Equal(v, got, opts...) {
+		return ""
+	}
+	return FailureMessage(fmt.Sprintf("contains the pair\ngot: %+v\nkey: %+v\nvalue: %+v", x.Got, k, v))
+}
 
-// TODO: Any(func(K,V) bool) FailureMessage
+// Any tests if any of the slice's item meets the predicate criteria.
+func (x FluentMap[K, V]) Any(predicate func(K, V) bool) FailureMessage {
+	for k, v := range x.Got {
+		if predicate(k, v) {
+			return ""
+		}
+	}
+	return FailureMessage(fmt.Sprintf("none pair does meet the predicate criteria\ngot: %+v", x.Got))
+}
 
-// TODO: All(func(K,V) bool) FailureMessage
+// All tests if all of the slice's items meets the predicate criteria.
+func (x FluentMap[K, V]) All(predicate func(K, V) bool) FailureMessage {
+	for k, v := range x.Got {
+		if !predicate(k, v) {
+			return FailureMessage(fmt.Sprintf("a pair does not meet the predicate criteria\ngot: %+v\npair: %+v", x.Got, v))
+		}
+	}
+	return ""
+}
 
-// TODO: None(func(K,V) bool) FailureMessage
+// None tests if all of the slice's item does not meet the predicate criteria.
+func (x FluentMap[K, V]) None(predicate func(K, V) bool) FailureMessage {
+	for k, v := range x.Got {
+		if predicate(k, v) {
+			return FailureMessage(fmt.Sprintf("a pair meets the predicate criteria\ngot: %+v\npair: %+v", x.Got, v))
+		}
+	}
+	return ""
+}

map_test.go

@@ -74,4 +74,64 @@ func TestMap(t *testing.T) {
 			assertFailed(t, got, "contains all pairs")
 		})
 	})
+
+	t.Run("ContainPair", func(t *testing.T) {
+		t.Run("Has", func(t *testing.T) {
+			got := verify.Map(dict).ContainPair("b", A{Slice: []int{9, 8, 7}})
+			assertPassed(t, got)
+		})
+		t.Run("DiffKey", func(t *testing.T) {
+			got := verify.Map(dict).ContainPair("z", A{Slice: []int{9, 8, 7}})
+			assertFailed(t, got, "has no value under key")
+		})
+		t.Run("DiffValue", func(t *testing.T) {
+			got := verify.Map(dict).ContainPair("b", A{Slice: []int{1, 1, 1}})
+			assertFailed(t, got, "has different value under key")
+		})
+	})
+	t.Run("NotContainPair", func(t *testing.T) {
+		t.Run("Has", func(t *testing.T) {
+			got := verify.Map(dict).NotContainPair("b", A{Slice: []int{9, 8, 7}})
+			assertFailed(t, got, "contains the pair")
+		})
+		t.Run("DiffKey", func(t *testing.T) {
+			got := verify.Map(dict).NotContainPair("z", A{Slice: []int{9, 8, 7}})
+			assertPassed(t, got)
+		})
+		t.Run("DiffValue", func(t *testing.T) {
+			got := verify.Map(dict).NotContainPair("b", A{Slice: []int{1, 1, 1}})
+			assertPassed(t, got)
+		})
+	})
+
+	t.Run("Any", func(t *testing.T) {
+		t.Run("Passed", func(t *testing.T) {
+			got := verify.Map(dict).Any(func(string, A) bool { return true })
+			assertPassed(t, got)
+		})
+		t.Run("Failed", func(t *testing.T) {
+			got := verify.Map(dict).Any(func(string, A) bool { return false })
+			assertFailed(t, got, "none pair does meet the predicate criteria")
+		})
+	})
+	t.Run("All", func(t *testing.T) {
+		t.Run("Passed", func(t *testing.T) {
+			got := verify.Map(dict).All(func(string, A) bool { return true })
+			assertPassed(t, got)
+		})
+		t.Run("Failed", func(t *testing.T) {
+			got := verify.Map(dict).All(func(string, A) bool { return false })
+			assertFailed(t, got, "a pair does not meet the predicate criteria")
+		})
+	})
+	t.Run("None", func(t *testing.T) {
+		t.Run("Passed", func(t *testing.T) {
+			got := verify.Map(dict).None(func(string, A) bool { return false })
+			assertPassed(t, got)
+		})
+		t.Run("Failed", func(t *testing.T) {
+			got := verify.Map(dict).None(func(string, A) bool { return true })
+			assertFailed(t, got, "a pair meets the predicate criteria")
+		})
+	})
 }

slice.go

@@ -38,7 +38,7 @@ func (x FluentSlice[T]) Equivalent(want []T, opts ...cmp.Option) FailureMessage
 	if len(extraGot) == 0 && len(extraWant) == 0 {
 		return ""
 	}
-	return FailureMessage(fmt.Sprintf("not equivalent\nextra got: %+v\nextra want: %+v", extraGot, extraWant))
+	return FailureMessage(fmt.Sprintf("not equivalent\ngot: %+v\nwant: %+v\nextra got: %+v\nextra want: %+v", x.Got, want, extraGot, extraWant))
 }
 
 // NotEquivalent tests if the slice does not have the same items as want in any order.
@@ -83,7 +83,6 @@ 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 {
@@ -94,7 +93,6 @@ 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 {