Add collection filtering assertions analagous to filterIsInstance

CHANGELOG.md

@@ -14,6 +14,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - signature of `isIn` and `isNotIn` has been changed to ensure at least two items are supplied.
 - added assertions `isIn(Iterable<T>)` and `isNotIn(Iterable<T>)`
 
+### Added
+- Added `doesNotExist` assertions to `Path`
+- Added `havingInstancesOf` and `notHavingInstancesOf` for `Iterable` and `Array`
+
 ## [0.28.1] 2024-04-17
 
 ### Added

assertk/src/commonMain/kotlin/assertk/assertions/array.kt

@@ -178,6 +178,34 @@ fun Assert<Array<*>>.containsExactly(vararg elements: Any?) = given { actual ->
     expectedListDiff(elements.asList(), actual.asList())
 }
 
+/**
+ * Asserts the collection contains at least one instance of a given type.
+ *
+ * ```
+ * assertThat(arrayOf<Any>("one", "two", 1)).havingInstanceOf<String>().each {
+ *   it.hasLength(3)
+ * }
+ * ```
+ */
+inline fun <reified T> Assert<Array<*>>.havingInstancesOf(): Assert<List<T>> {
+    return transform("contains instances of ${T::class}") { actual ->
+        actual.filterIsInstance<T>().also {
+            if (it.isEmpty()) expected("to contain at least one instance of ${T::class} but was ${actual.asList()}")
+        }
+    }
+}
+
+/**
+ * Asserts the collection does not contain an instance of a given type.
+ *
+ * ```
+ * assertThat(arrayOf<Any>("one", "two", 1)).havingInstancesOf<Double>()
+ * ```
+ */
+inline fun <reified T> Assert<Array<*>>.notHavingInstancesOf() = given { actual ->
+    if (actual.any { it is T }) expected("to not contain instances of ${T::class} but was ${actual.asList()}")
+}
+
 /**
  * Asserts on each item in the array. The given lambda will be run for each item.
  *

assertk/src/commonMain/kotlin/assertk/assertions/iterable.kt

@@ -131,6 +131,34 @@ internal fun MutableList<*>.removeFirst(value: Any?) {
     if (index > -1) removeAt(index)
 }
 
+/**
+ * Asserts the collection contains at least one instance of a given type.
+ *
+ * ```
+ * assertThat(listOf<Any>("one", "two", 1)).havingInstanceOf<String>().each {
+ *   it.hasLength(3)
+ * }
+ * ```
+ */
+inline fun <reified T> Assert<Iterable<*>>.havingInstancesOf(): Assert<List<T>> {
+    return transform("contains instance of ${T::class}") { actual ->
+        actual.filterIsInstance<T>().also {
+            if (it.isEmpty()) expected("to contain at least one instance of ${T::class} but was $actual")
+        }
+    }
+}
+
+/**
+ * Asserts the collection does not contain an instance of a given type.
+ *
+ * ```
+ * assertThat(listOf<Any>("one", "two", 1)).doesNotContainInstanceOf<Double>()
+ * ```
+ */
+inline fun <reified T> Assert<Iterable<*>>.notHavingInstancesOf() = given { actual ->
+    if (actual.any { it is T }) expected("to not contain instances of ${T::class} but was $actual")
+}
+
 /**
  * Asserts on each item in the iterable. The given lambda will be run for each item.
  *

assertk/src/commonTest/kotlin/test/assertk/assertions/ArrayTest.kt

@@ -322,6 +322,32 @@ class ArrayTest {
     }
     //endregion
 
+    //region containsInstanceOf
+    @Test fun containsInstanceOf_element_present_passes() {
+        assertThat(arrayOf<Any>(1, "two")).havingInstancesOf<String>().single().isEqualTo("two")
+    }
+
+    @Test fun containsInstanceOf_element_missing_fails() {
+        val error = assertFailsWith<AssertionError> {
+            assertThat(arrayOf<Any>(1, "two")).havingInstancesOf<Double>()
+        }
+        assertEquals("expected to contain at least one instance of class kotlin.Double but was [1, two]", error.message)
+    }
+    //endregion
+
+    //region doesNotContainInstanceOf
+    @Test fun doesNotContainInstanceOf_element_present_fails() {
+        val error = assertFailsWith<AssertionError>() {
+            assertThat(arrayOf<Any>(1, "two")).notHavingInstancesOf<String>()
+        }
+        assertEquals("expected to not contain instances of class kotlin.String but was [1, two]", error.message)
+    }
+
+    @Test fun doesNotContainInstanceOf_element_missing_passes() {
+        assertThat(arrayOf<Any>(1, "two")).notHavingInstancesOf<Double>()
+    }
+    //endregion
+
     //region each
     @Test
     fun each_empty_list_passes() {

assertk/src/commonTest/kotlin/test/assertk/assertions/IterableTest.kt

@@ -9,9 +9,11 @@ import assertk.assertions.contains
 import assertk.assertions.containsAtLeast
 import assertk.assertions.containsExactly
 import assertk.assertions.containsExactlyInAnyOrder
+import assertk.assertions.havingInstancesOf
 import assertk.assertions.containsNone
 import assertk.assertions.containsOnly
 import assertk.assertions.doesNotContain
+import assertk.assertions.notHavingInstancesOf
 import assertk.assertions.each
 import assertk.assertions.exactly
 import assertk.assertions.extracting
@@ -229,6 +231,32 @@ class IterableTest {
     }
     //endregion
 
+    //region containsInstanceOf
+    @Test fun containsInstanceOf_element_present_passes() {
+        assertThat(iterableOf(1, "two")).havingInstancesOf<String>().single().isEqualTo("two")
+    }
+
+    @Test fun containsInstanceOf_element_missing_fails() {
+        val error = assertFailsWith<AssertionError> {
+            assertThat(iterableOf(1, "two")).havingInstancesOf<Double>()
+        }
+        assertEquals("expected to contain at least one instance of class kotlin.Double but was [1, two]", error.message)
+    }
+    //endregion
+
+    //region doesNotContainInstanceOf
+    @Test fun doesNotContainInstanceOf_element_present_fails() {
+        val error = assertFailsWith<AssertionError>() {
+            assertThat(iterableOf(1, "two")).notHavingInstancesOf<String>()
+        }
+        assertEquals("expected to not contain instances of class kotlin.String but was [1, two]", error.message)
+    }
+
+    @Test fun doesNotContainInstanceOf_element_missing_passes() {
+        assertThat(iterableOf(1, "two")).notHavingInstancesOf<Double>()
+    }
+    //endregion
+
     //region each
     @Test
     fun each_empty_list_passes() {