├── .github
    └── workflows
    │   └── main.yml
├── LICENSE
├── composer.json
└── src
    └── Codeception
        └── Module
            ├── AbstractAsserts.php
            └── Asserts.php


/.github/workflows/main.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | jobs:
 6 |   tests:
 7 |     runs-on: ubuntu-latest
 8 | 
 9 |     strategy:
10 |       matrix:
11 |         php: [8.2, 8.3, 8.4]
12 | 
13 |     steps:
14 |       - name: Checkout code
15 |         uses: actions/checkout@v4
16 | 
17 |       - name: Setup PHP
18 |         uses: shivammathur/setup-php@v2
19 |         with:
20 |           php-version: ${{ matrix.php }}
21 |           coverage: none
22 |           tools: phpstan, phpcs
23 | 
24 |       - name: Validate composer.json and composer.lock
25 |         run: composer validate
26 | 
27 |       - name: Install dependencies
28 |         run: composer install --prefer-dist --no-progress --no-interaction --no-suggest
29 | 
30 |       - name: Run PHPStan
31 |         run: phpstan analyse src
32 | 
33 |       - name: Run PHPCS
34 |         run: phpcs --standard=PSR12 src
35 | 
36 |       - name: Run test suite
37 |         run: php vendor/bin/codecept run
38 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2011 Michael Bodnarchuk and contributors
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "codeception/module-asserts",
 3 |     "description": "Codeception module containing various assertions",
 4 |     "license": "MIT",
 5 |     "type": "library",
 6 |     "keywords": [
 7 |         "codeception",
 8 |         "asserts",
 9 |         "assertions"
10 |     ],
11 |     "authors": [
12 |         {
13 |             "name": "Michael Bodnarchuk"
14 |         },
15 |         {
16 |             "name": "Gintautas Miselis"
17 |         },
18 |         {
19 |             "name": "Gustavo Nieves",
20 |             "homepage": "https://medium.com/@ganieves"
21 |         }
22 |     ],
23 |     "homepage": "https://codeception.com/",
24 |     "require": {
25 |         "php": "^8.2",
26 |         "codeception/codeception": "*@dev",
27 |         "codeception/lib-asserts": "^2.2"
28 |     },
29 |     "conflict": {
30 |         "codeception/codeception": "<5.0"
31 |     },
32 |     "minimum-stability": "dev",
33 |     "autoload": {
34 |         "classmap": [
35 |             "src/"
36 |         ]
37 |     },
38 |     "config": {
39 |         "classmap-authoritative": true
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/Codeception/Module/AbstractAsserts.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Codeception\Module;
  6 | 
  7 | use Codeception\Module;
  8 | use Codeception\Util\Shared\Asserts;
  9 | 
 10 | abstract class AbstractAsserts extends Module
 11 | {
 12 |     use Asserts {
 13 |         assertArrayHasKey as public;
 14 |         assertArrayNotHasKey as public;
 15 |         assertClassHasAttribute as public;
 16 |         assertClassHasStaticAttribute as public;
 17 |         assertClassNotHasAttribute as public;
 18 |         assertClassNotHasStaticAttribute as public;
 19 |         assertContains as public;
 20 |         assertContainsEquals as public;
 21 |         assertContainsOnly as public;
 22 |         assertContainsOnlyInstancesOf as public;
 23 |         assertCount as public;
 24 |         assertDirectoryDoesNotExist as public;
 25 |         assertDirectoryExists as public;
 26 |         assertDirectoryIsNotReadable as public;
 27 |         assertDirectoryIsNotWritable as public;
 28 |         assertDirectoryIsReadable as public;
 29 |         assertDirectoryIsWritable as public;
 30 |         assertDoesNotMatchRegularExpression as public;
 31 |         assertEmpty as public;
 32 |         assertEquals as public;
 33 |         assertEqualsCanonicalizing as public;
 34 |         assertEqualsIgnoringCase as public;
 35 |         assertEqualsWithDelta as public;
 36 |         assertFalse as public;
 37 |         assertFileDoesNotExist as public;
 38 |         assertFileEquals as public;
 39 |         assertFileEqualsCanonicalizing as public;
 40 |         assertFileEqualsIgnoringCase as public;
 41 |         assertFileExists as public;
 42 |         assertFileIsNotReadable as public;
 43 |         assertFileIsNotWritable as public;
 44 |         assertFileIsReadable as public;
 45 |         assertFileIsWritable as public;
 46 |         assertFileNotEquals as public;
 47 |         assertFileNotEqualsCanonicalizing as public;
 48 |         assertFileNotEqualsIgnoringCase as public;
 49 |         assertFileNotExists as public;
 50 |         assertFinite as public;
 51 |         assertGreaterOrEquals as public;
 52 |         assertGreaterThan as public;
 53 |         assertGreaterThanOrEqual as public;
 54 |         assertInfinite as public;
 55 |         assertInstanceOf as public;
 56 |         assertIsArray as public;
 57 |         assertIsBool as public;
 58 |         assertIsCallable as public;
 59 |         assertIsClosedResource as public;
 60 |         assertIsEmpty as public;
 61 |         assertIsFloat as public;
 62 |         assertIsInt as public;
 63 |         assertIsIterable as public;
 64 |         assertIsNotArray as public;
 65 |         assertIsNotBool as public;
 66 |         assertIsNotCallable as public;
 67 |         assertIsNotClosedResource as public;
 68 |         assertIsNotFloat as public;
 69 |         assertIsNotInt as public;
 70 |         assertIsNotIterable as public;
 71 |         assertIsNotNumeric as public;
 72 |         assertIsNotObject as public;
 73 |         assertIsNotReadable as public;
 74 |         assertIsNotResource as public;
 75 |         assertIsNotScalar as public;
 76 |         assertIsNotString as public;
 77 |         assertIsNotWritable as public;
 78 |         assertIsNumeric as public;
 79 |         assertIsObject as public;
 80 |         assertIsReadable as public;
 81 |         assertIsResource as public;
 82 |         assertIsScalar as public;
 83 |         assertIsString as public;
 84 |         assertIsWritable as public;
 85 |         assertJson as public;
 86 |         assertJsonFileEqualsJsonFile as public;
 87 |         assertJsonFileNotEqualsJsonFile as public;
 88 |         assertJsonStringEqualsJsonFile as public;
 89 |         assertJsonStringEqualsJsonString as public;
 90 |         assertJsonStringNotEqualsJsonFile as public;
 91 |         assertJsonStringNotEqualsJsonString as public;
 92 |         assertLessOrEquals as public;
 93 |         assertLessThan as public;
 94 |         assertLessThanOrEqual as public;
 95 |         assertMatchesRegularExpression as public;
 96 |         assertNan as public;
 97 |         assertNotContains as public;
 98 |         assertNotContainsEquals as public;
 99 |         assertNotContainsOnly as public;
100 |         assertNotCount as public;
101 |         assertNotEmpty as public;
102 |         assertNotEquals as public;
103 |         assertNotEqualsCanonicalizing as public;
104 |         assertNotEqualsIgnoringCase as public;
105 |         assertNotEqualsWithDelta as public;
106 |         assertNotFalse as public;
107 |         assertNotInstanceOf as public;
108 |         assertNotNull as public;
109 |         assertNotRegExp as public;
110 |         assertNotSame as public;
111 |         assertNotSameSize as public;
112 |         assertNotTrue as public;
113 |         assertNull as public;
114 |         assertObjectHasAttribute as public;
115 |         assertObjectNotHasAttribute as public;
116 |         assertRegExp as public;
117 |         assertSame as public;
118 |         assertSameSize as public;
119 |         assertStringContainsString as public;
120 |         assertStringContainsStringIgnoringCase as public;
121 |         assertStringEndsNotWith as public;
122 |         assertStringEndsWith as public;
123 |         assertStringEqualsFile as public;
124 |         assertStringEqualsFileCanonicalizing as public;
125 |         assertStringEqualsFileIgnoringCase as public;
126 |         assertStringMatchesFormat as public;
127 |         assertStringMatchesFormatFile as public;
128 |         assertStringNotContainsString as public;
129 |         assertStringNotContainsStringIgnoringCase as public;
130 |         assertStringNotEqualsFile as public;
131 |         assertStringNotEqualsFileCanonicalizing as public;
132 |         assertStringNotEqualsFileIgnoringCase as public;
133 |         assertStringNotMatchesFormat as public;
134 |         assertStringNotMatchesFormatFile as public;
135 |         assertStringStartsNotWith as public;
136 |         assertStringStartsWith as public;
137 |         assertThat as public;
138 |         assertThatItsNot as public;
139 |         assertTrue as public;
140 |         assertXmlFileEqualsXmlFile as public;
141 |         assertXmlFileNotEqualsXmlFile as public;
142 |         assertXmlStringEqualsXmlFile as public;
143 |         assertXmlStringEqualsXmlString as public;
144 |         assertXmlStringNotEqualsXmlFile as public;
145 |         assertXmlStringNotEqualsXmlString as public;
146 |         fail as public;
147 |         markTestIncomplete as public;
148 |         markTestSkipped as public;
149 |     }
150 | }
151 | 


--------------------------------------------------------------------------------
/src/Codeception/Module/Asserts.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | declare(strict_types=1);
  4 | 
  5 | namespace Codeception\Module;
  6 | 
  7 | use Throwable;
  8 | 
  9 | use function get_debug_type;
 10 | 
 11 | /**
 12 |  * Special module for using asserts in your tests.
 13 |  */
 14 | class Asserts extends AbstractAsserts
 15 | {
 16 |     /**
 17 |      * Handles and checks throwables (Exceptions/Errors) called inside the callback function.
 18 |      * Either throwable class name or throwable instance should be provided.
 19 |      *
 20 |      * ```php
 21 |      * <?php
 22 |      * $I->expectThrowable(MyThrowable::class, function() {
 23 |      *     $this->doSomethingBad();
 24 |      * });
 25 |      *
 26 |      * $I->expectThrowable(new MyException(), function() {
 27 |      *     $this->doSomethingBad();
 28 |      * });
 29 |      * ```
 30 |      *
 31 |      * If you want to check message or throwable code, you can pass them with throwable instance:
 32 |      * ```php
 33 |      * <?php
 34 |      * // will check that throwable MyError is thrown with "Don't do bad things" message
 35 |      * $I->expectThrowable(new MyError("Don't do bad things"), function() {
 36 |      *     $this->doSomethingBad();
 37 |      * });
 38 |      * ```
 39 |      */
 40 |     public function expectThrowable(string|Throwable $throwable, callable $callback): void
 41 |     {
 42 |         if (is_object($throwable)) {
 43 |             $class = get_class($throwable);
 44 |             $msg = $throwable->getMessage();
 45 |             $code = (int) $throwable->getCode();
 46 |         } else {
 47 |             $class = $throwable;
 48 |             $msg = null;
 49 |             $code = null;
 50 |         }
 51 | 
 52 |         try {
 53 |             $callback();
 54 |         } catch (Throwable $t) {
 55 |             $this->checkThrowable($t, $class, $msg, $code);
 56 |             return;
 57 |         }
 58 | 
 59 |         $this->fail("Expected throwable of class '{$class}' to be thrown, but nothing was caught");
 60 |     }
 61 | 
 62 |     /**
 63 |      * Check if the given throwable matches the expected data,
 64 |      * fail (throws an exception) if it does not.
 65 |      */
 66 |     protected function checkThrowable(
 67 |         Throwable $throwable,
 68 |         string $expectedClass,
 69 |         ?string $expectedMsg,
 70 |         int|null $expectedCode = null
 71 |     ): void {
 72 |         if (!($throwable instanceof $expectedClass)) {
 73 |             $this->fail(sprintf(
 74 |                 "Exception of class '%s' expected to be thrown, but class '%s' was caught",
 75 |                 $expectedClass,
 76 |                 get_debug_type($throwable)
 77 |             ));
 78 |         }
 79 | 
 80 |         if (null !== $expectedMsg && $throwable->getMessage() !== $expectedMsg) {
 81 |             $this->fail(sprintf(
 82 |                 "Exception of class '%s' expected to have message '%s', but actual message was '%s'",
 83 |                 $expectedClass,
 84 |                 $expectedMsg,
 85 |                 $throwable->getMessage()
 86 |             ));
 87 |         }
 88 | 
 89 |         if (null !== $expectedCode && $throwable->getCode() !== $expectedCode) {
 90 |             $this->fail(sprintf(
 91 |                 "Exception of class '%s' expected to have code '%s', but actual code was '%s'",
 92 |                 $expectedClass,
 93 |                 $expectedCode,
 94 |                 $throwable->getCode()
 95 |             ));
 96 |         }
 97 | 
 98 |         $this->assertTrue(true); // increment assertion counter
 99 |     }
100 | }
101 | 


--------------------------------------------------------------------------------