feat(assert): implement AssertIterable methods

- add `AssertIterable::contains()` method.
- add `AssertIterable::sameSizeAs()` method
- add `AssertIterable::allOf()` method

Author: petrdobr

src/Assert.php

@@ -21,6 +21,7 @@
 use Testo\Assert\State\AssertTypeFailure;
 use Testo\Assert\StaticState;
 use Testo\Assert\Support;
+use Testo\Assert\Internal\Assertion\AssertIterable;
 
 /**
  * Assertion utilities.
@@ -294,12 +295,10 @@ public static function json(string $actual): JsonAbstract
      * Does not work with Generators.
      *
      * @throws AssertTypeFailure
-     *
-     * @deprecated To be implemented
      */
     public static function iterable(mixed $actual): IterableType
     {
-        throw new \LogicException('Not implemented yet');
+        return AssertIterable::validateAndCreate($actual);
     }
 
     /**

src/Assert/Internal/Assertion/AssertIterable.php

@@ -24,11 +24,11 @@ public function __construct(
     ) {}
 
     /**
-     * Validate that the given value is a float and return an AssertFloat instance.
+     * Validate that the given value is an iterable and return an AssertIterable instance.
      *
-     * @param mixed $value The value to be asserted as float.
-     * @return self An instance of AssertFloat.
-     * @throws AssertTypeFailure when the value is not a float.
+     * @param mixed $value The value to be asserted as an iterable.
+     * @return self An instance of AssertIterable.
+     * @throws AssertTypeFailure when the value is not an iterable.
      */
     public static function validateAndCreate(mixed $value): self
     {

src/Assert/Internal/Assertion/Traits/IterableTrait.php

@@ -5,36 +5,89 @@
 namespace Testo\Assert\Internal\Assertion\Traits;
 
 use Testo\Assert\State\AssertException;
+use Testo\Assert\StaticState;
+use Testo\Assert\Support;
 
 /**
- * Contains methods for comparing numeric values
+ * Contains assertion methods for iterable values.
+ * @property iterable $value
  */
 trait IterableTrait
 {
     /**
-     * Asserts that the iterable contains the given needle.
+     * Asserts that the iterable contains the given needle (strict comparison).
      * @param mixed $needle The value to look for within the iterable.
      * @param string $message Optional message for the assertion.
+     *
      * @throws AssertException when the assertion fails.
      */
     public function contains(mixed $needle, string $message = ''): self
     {
-        throw new \LogicException('Not implemented yet');
+        foreach ($this->value as $item) {
+            if ($item === $needle) {
+                StaticState::log(
+                    'Assert that iterable: ' . Support::stringify($this->value) . ' contains ' . Support::stringify($needle),
+                );
+                return new self($this->value);
+            }
+        }
+        StaticState::fail(
+            AssertException::fail(
+                'Failed to assert that iterable ' . Support::stringify($this->value) . ' contains ' . Support::stringify($needle),
+            ),
+        );
     }
 
     /**
      * Asserts that the iterable has the same number of elements as the expected iterable.
+     *
      * @param iterable $expected The iterable to compare size against.
      * @param string $message Optional message for the assertion.
-     * @throws AssertException when the assertion fails.
+     *
+     * @throws AssertException When the iterables do not have the same size.
      */
     public function sameSizeAs(iterable $expected, string $message = ''): self
     {
-        throw new \LogicException('Not implemented yet');
+        if (Support::countIterable($this->value) === Support::countIterable($expected)) {
+            StaticState::log(
+                'Assert that iterable: ' . Support::stringify($this->value) . ' has the same number of elements as ' . Support::stringify($expected),
+            );
+            return new self($this->value);
+        }
+        StaticState::fail(
+            AssertException::fail(
+                'Failed to assert that iterable ' . Support::stringify($this->value) . ' has the same number of elements as ' . Support::stringify($expected),
+            ),
+        );
     }
 
-    public function allOf(string $type, string $message = ''): \Testo\Assert\Api\Builtin\IterableType
+    /**
+     * Asserts that all elements of the iterable have the given PHP type.
+     *
+     * The $type parameter uses PHP internal type names (compatible with gettype()),
+     * e.g.: "integer", "double", "boolean", "string", "array", "object", "resource", "null".
+     *
+     * @param non-empty-string $type Expected PHP type name for all elements.
+     * @param string $message Optional message for the assertion.
+     *
+     * @throws AssertException When at least one element has a different type.
+     */
+    public function allOf(string $type, string $message = ''): self
     {
-        throw new \LogicException('Not implemented yet');
+        foreach ($this->value as $element) {
+            $actualType = \gettype($element);
+            if ($actualType !== $type) {
+                StaticState::fail(
+                    AssertException::fail(
+                        'Failed to assert that all elements of iterable ' . Support::stringify($this->value) . ' have type ' . Support::stringify($type) .
+                        ' (found ' . Support::stringify($actualType) . ' instead)',
+                    ),
+                );
+            }
+        }
+        StaticState::log(
+            'Assert that all elements of iterable ' . Support::stringify($this->value) . ' have type ' . Support::stringify($type),
+        );
+        return new self($this->value);
     }
 }

src/Assert/Support.php

@@ -24,4 +24,23 @@ public static function stringify(mixed $value): string
             default => (string) $value,
         };
     }
+
+    /**
+     * Counts the number of elements in the given iterable.
+     */
+    public static function countIterable(iterable $value): int
+    {
+        // if Countable
+        if (\is_array($value) || $value instanceof \Countable) {
+            return \count($value);
+        }
+
+        // if Traversable
+        $count = 0;
+        foreach ($value as $_) {
+            $count++;
+        }
+
+        return $count;
+    }
 }

tests/Assert/Self/AssertIterable.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tests\Assert\Self;
+
+use Testo\Assert;
+use Testo\Attribute\ExpectException;
+use Testo\Attribute\Test;
+use Testo\Expect;
+
+/**
+ * @see Assert::iterable()
+ */
+final class AssertIterable
+{
+    #[Test]
+    public function checkIterableType(): void
+    {
+        // This assertion checks incoming data type
+        Assert::iterable(new \ArrayIterator([1, 2, 3]));
+        Assert::iterable([]);
+    }
+
+    #[Test]
+    public function checkContains(): void
+    {
+        Assert::iterable(new \ArrayIterator([1, 2, 3]))->contains(3);
+        Assert::iterable([1, 2, 3])->contains(3);
+    }
+
+    #[Test]
+    public function checkSameSizeAs(): void
+    {
+        Assert::iterable(new \ArrayIterator([1, 2, 3]))->sameSizeAs(new \ArrayIterator(['a', 'b', 'c']));
+        Assert::iterable(new \ArrayIterator([1, 2, 3]))->sameSizeAs(['a', 'b', 'c']);
+    }
+
+    #[Test]
+    public function checkAllOf(): void
+    {
+        Assert::iterable(new \ArrayIterator([1, 2, 3]))->allOf('integer');
+        Assert::iterable(['a', 'b', 'c'])->allOf('string');
+
+        Expect::exception(Assert\State\AssertException::class);
+        Assert::iterable([true, false, 'true'])->allOf('bool');
+    }
+}