Add assertContainsExactly assertion

Author: JavierSegoviaCordoba

CHANGELOG.md

@@ -8,6 +8,7 @@
 - `assertNotContains` assertion
 - `assertStartWith` and `assertEndWith` assertions
 - `assertGreaterThan` and `assertLessThan` assertions for `Duration`
+- `assertContainsExactly` assertion
 
 ### Changed
 

kotlin-test/common/main/kotlin/com/javiersc/kotlin/test/iterableMatchers.kt

@@ -10,6 +10,14 @@ public inline fun <reified I : Iterable<T>, reified T : Any> I.assertContains(
     return this
 }
 
+public inline fun <reified I : Iterable<T>, reified T : Any> I.assertContainsExactly(
+    elements: I,
+    message: String? = null,
+): I {
+    this.toList().assertEquals(elements.toList(), message)
+    return this
+}
+
 public inline fun <reified I : Iterable<T>, reified T : Any> I.assertCount(
     expectSize: Int,
     message: String? = null,

kotlin-test/common/test/kotlin/com/javiersc/kotlin/test/IterableMatchersTest.kt

@@ -19,6 +19,18 @@ class IterableMatchersTest {
         )
     }
 
+    @Test
+    fun `assertContains should fail`() {
+        val list: List<Int> = listOf(1, 2, 3)
+        val element = 4
+        val exception: AssertionError = assertFailsWith { list.assertContains(element) }
+        assertTrue(
+            exception.message ==
+                "Expected the collection to contain the element.\n" +
+                    "Collection <[1, 2, 3]>, element <4>."
+        )
+    }
+
     @Test
     fun `assertContains should work with different types`() {
         val list: List<Double> = listOf(1.0, 2.0, 3.0)
@@ -27,6 +39,57 @@ class IterableMatchersTest {
         assertTrue(result === list)
     }
 
+    @Test
+    fun `assertContains should work`() {
+        val list: List<String> = listOf("AA", "BB", "CC")
+        val element = "BB"
+        val result: List<String> = list.assertContains(element)
+        assertTrue(result === list)
+    }
+
+    @Test
+    fun `assertContainsExactly should fail with custom message`() {
+        val list: List<Int> = listOf(1, 2, 3)
+        val elements = listOf(1, 2, 3, 4)
+        val message = "Custom error"
+        val exception: AssertionError = assertFailsWith {
+            list.assertContainsExactly(elements, message)
+        }
+        assertTrue(exception.message == "Custom error expected:<[1, 2, 3]> but was:<[1, 2, 3, 4]>")
+    }
+
+    @Test
+    fun `assertContainsExactly should fail`() {
+        val list: List<Int> = listOf(1, 2, 3)
+        val elements: List<Int> = listOf(1, 2, 3, 4)
+        val exception: AssertionError = assertFailsWith { list.assertContainsExactly(elements) }
+        assertTrue(exception.message == "expected:<[1, 2, 3]> but was:<[1, 2, 3, 4]>")
+    }
+
+    @Test
+    fun `assertContainsExactly should fail with more items`() {
+        val list: List<Int> = listOf(1, 2, 3, 4, 5)
+        val elements: List<Int> = listOf(1, 2, 3, 4)
+        val exception: AssertionError = assertFailsWith { list.assertContainsExactly(elements) }
+        assertTrue(exception.message == "expected:<[1, 2, 3, 4, 5]> but was:<[1, 2, 3, 4]>")
+    }
+
+    @Test
+    fun `assertContainsExactly should work with different types`() {
+        val list: List<Double> = listOf(1.0, 2.0, 3.0)
+        val elements: List<Double> = listOf(1.0, 2.0, 3.0)
+        val result: List<Double> = list.assertContainsExactly(elements)
+        assertTrue(result === list)
+    }
+
+    @Test
+    fun `assertContainsExactly should work`() {
+        val list: List<String> = listOf("AA", "BB", "CC")
+        val elements: List<String> = listOf("AA", "BB", "CC")
+        val result: List<String> = list.assertContainsExactly(elements)
+        assertTrue(result === list)
+    }
+
     @Test
     fun `assertCount should pass when count matches`() {
         val list: List<Int> = listOf(1, 2, 3)