add tests and update readme

devlop · Feb 23, 2021 · f1da0d7 · f1da0d7
1 parent f638247
commit f1da0d7
Show file tree

Hide file tree

Showing 8 changed files with 358 additions and 19 deletions.
diff --git a/README.md b/README.md
@@ -41,27 +41,28 @@ $this->assertExceptionThrown(\InvalidArgumentException::class, function () : voi
 });
 ```
 
-## assertNoExceptionsThrown
-
-Asserts that no exceptions was thrown during the execution of the callback,
-if any exceptions was thrown during the execution the assertion fails.
-
-```php
-$this->assertNoExceptionsThrown(function () : void {
-    // code that should not throw any exceptions
-});
-```
-
 ## assertExceptionNotThrown
 
 Asserts that a specific exception was not thrown during the execution of the callback,
 if the specified exception was thrown during execution the assertion fails.
 
 **use with caution** - this will only assert that a specific exception was not thrown and
 the assertion will pass for any other exceptions thrown, intentional or accidental.
+In most cases it is probably better to `assertNoExceptionsThrown` instead.
 
 ```php
 $this->assertExceptionNotThrown(\InvalidArgumentException::class, function () : void {
     // code that should not throw the exception
 });
 ```
+
+## assertNoExceptionsThrown
+
+Asserts that no exceptions was thrown during the execution of the callback,
+if any exceptions was thrown during the execution the assertion fails.
+
+```php
+$this->assertNoExceptionsThrown(function () : void {
+    // code that should not throw any exceptions
+});
+```
diff --git a/composer.json b/composer.json
@@ -13,11 +13,19 @@
         "php": "^7.4|^8.0",
         "phpunit/phpunit": "^9.5"
     },
+    "require-dev": {
+        "symfony/var-dumper": "^5.2"
+    },
     "autoload": {
         "psr-4": {
             "Devlop\\PHPUnit\\": "src/"
         }
     },
+    "autoload-dev": {
+        "psr-4": {
+            "Devlop\\Buffer\\Tests\\": "tests/"
+        }
+    },
     "minimum-stability": "dev",
     "prefer-stable": true,
     "extra": {

diff --git a/phpunit.xml.dist b/phpunit.xml.dist
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="./vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+         verbose="true">
+    <testsuites>
+        <testsuite name="devlop/phpunit-exception-assertions Test Suite">
+            <directory suffix="Test.php">./tests</directory>
+        </testsuite>
+    </testsuites>
+    <coverage processUncoveredFiles="true">
+        <include>
+            <directory suffix=".php">./src</directory>
+        </include>
+    </coverage>
+</phpunit>
diff --git a/src/ExceptionAssertions.php b/src/ExceptionAssertions.php
@@ -4,6 +4,7 @@
 
 namespace Devlop\PHPUnit;
 
+use PHPUnit\Framework\Assert;
 use Throwable;
 
 trait ExceptionAssertions
@@ -16,7 +17,7 @@ trait ExceptionAssertions
      * @param  callable  $callback
      * @return void
      */
-    public function assertExceptionThrown(string $expectedException, callable $callback, ?callable $validator = null) : Throwable
+    public static function assertExceptionThrown(string $expectedException, callable $callback, ?callable $validator = null) : void
     {
         $thrownException = null;
 
@@ -26,7 +27,7 @@ public function assertExceptionThrown(string $expectedException, callable $callb
             $thrownException = $e;
         }
 
-        $this->assertInstanceOf(
+        Assert::assertInstanceOf(
             $expectedException,
             $thrownException,
             $thrownException === null
@@ -41,8 +42,6 @@ public function assertExceptionThrown(string $expectedException, callable $callb
         if ($validator !== null) {
             $validator($thrownException);
         }
-
-        return $thrownException;
     }
 
     /**
@@ -54,7 +53,7 @@ public function assertExceptionThrown(string $expectedException, callable $callb
      * @param  callable  $callback
      * @return void
      */
-    public function assertExceptionNotThrown(string $expectedException, callable $callback) : void
+    public static function assertExceptionNotThrown(string $expectedException, callable $callback) : void
     {
         $thrownException = null;
 
@@ -64,7 +63,7 @@ public function assertExceptionNotThrown(string $expectedException, callable $ca
             $thrownException = $e;
         }
 
-        $this->assertNotInstanceOf(
+        Assert::assertNotInstanceOf(
             $expectedException,
             $thrownException,
             \sprintf(
@@ -80,7 +79,7 @@ public function assertExceptionNotThrown(string $expectedException, callable $ca
      * @param  callable  $callback
      * @return void
      */
-    public function assertNoExceptionsThrown(callable $callback) : void
+    public static function assertNoExceptionsThrown(callable $callback) : void
     {
         $thrownException = null;
 
@@ -90,7 +89,7 @@ public function assertNoExceptionsThrown(callable $callback) : void
             $thrownException = $e;
         }
 
-        $this->assertNull(
+        Assert::assertNull(
             $thrownException,
             \sprintf(
                 'Failed asserting that no exceptions was thrown, exception of type "%1$s was thrown.',

diff --git a/tests/AssertExceptionNotThrownTest.php b/tests/AssertExceptionNotThrownTest.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devlop\PHPUnit\Tests;
+
+use Devlop\PHPUnit\ExceptionAssertions;
+use PHPUnit\Framework\TestCase;
+
+final class AssertExceptionNotThrownTest extends TestCase
+{
+    use ExceptionAssertions;
+
+    function test_assert_exception_not_thrown_does_not_pass_if_the_exception_was_thrown() : void
+    {
+        $assertionPasses = true;
+
+        try {
+            $this->assertExceptionNotThrown(\RuntimeException::class, function () : void {
+                throw new \RuntimeException('Oh?');
+            });
+        } catch (\PHPUnit\Framework\Exception $exception) {
+            $assertionPasses = false;
+        }
+
+        $this->assertFalse($assertionPasses);
+    }
+
+    function test_assert_exception_not_thrown_does_not_pass_if_parent_exception_was_thrown() : void
+    {
+        $assertionPasses = true;
+
+        try {
+            $this->assertExceptionNotThrown(\Throwable::class, function () : void {
+                throw \RuntimeException('Oh?');
+            });
+        } catch (\PHPUnit\Framework\Exception $exception) {
+            $assertionPasses = false;
+        }
+
+        $this->assertFalse($assertionPasses);
+    }
+
+    function test_assert_exception_not_thrown_passes_if_no_exception_was_thrown() : void
+    {
+        $assertionPasses = true;
+
+        try {
+            $this->assertExceptionNotThrown(\RuntimeException::class, function () : void {
+                // do nothing
+            });
+        } catch (\PHPUnit\Framework\Exception $exception) {
+            $assertionPasses = false;
+        }
+
+        $this->assertTrue($assertionPasses);
+    }
+
+    function test_assert_exception_not_thrown_passes_if_another_exception_was_thrown() : void
+    {
+        $assertionPasses = true;
+
+        try {
+            $this->assertExceptionNotThrown(\InvalidArgumentException::class, function () : void {
+                throw new \RuntimeException('Oh?');
+            });
+        } catch (\PHPUnit\Framework\Exception $exception) {
+            $assertionPasses = false;
+        }
+
+        $this->assertTrue($assertionPasses);
+    }
+}
diff --git a/tests/AssertExceptionThrownTest.php b/tests/AssertExceptionThrownTest.php
@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devlop\PHPUnit\Tests;
+
+use Devlop\PHPUnit\ExceptionAssertions;
+use PHPUnit\Framework\TestCase;
+
+final class AssertExceptionThrownTest extends TestCase
+{
+    use ExceptionAssertions;
+
+    function test_assert_exception_thrown_does_not_pass_if_no_exception_was_thrown() : void
+    {
+        $assertionPasses = true;
+
+        try {
+            $this->assertExceptionThrown(\Throwable::class, function () : void {
+                // do nothing
+            });
+        } catch (\PHPUnit\Framework\Exception $exception) {
+            $assertionPasses = false;
+        }
+
+        $this->assertFalse($assertionPasses);
+    }
+
+    function test_assert_exception_thrown_does_not_pass_if_another_exception_was_thrown() : void
+    {
+        $assertionPasses = true;
+
+        try {
+            $this->assertExceptionThrown(\InvalidArgumentException::class, function () : void {
+                throw new \RuntimeException('Oh?');
+            });
+        } catch (\PHPUnit\Framework\Exception $exception) {
+            $assertionPasses = false;
+        }
+
+        $this->assertFalse($assertionPasses);
+    }
+
+    function test_assert_exception_thrown_passes_if_the_correct_exception_was_thrown() : void
+    {
+        $assertionPasses = true;
+
+        try {
+            $this->assertExceptionThrown(\RuntimeException::class, function () : void {
+                throw new \RuntimeException('Oh?');
+            });
+        } catch (\PHPUnit\Framework\Exception $exception) {
+            $assertionPasses = false;
+        }
+
+        $this->assertTrue($assertionPasses);
+    }
+
+    function test_assert_exception_thrown_passes_if_parent_exception_was_thrown() : void
+    {
+        $assertionPasses = true;
+
+        try {
+            $this->assertExceptionThrown(\Throwable::class, function () : void {
+                throw new \RuntimeException('Oh?');
+            });
+        } catch (\PHPUnit\Framework\Exception $exception) {
+            $assertionPasses = false;
+        }
+
+        $this->assertTrue($assertionPasses);
+    }
+}
diff --git a/tests/AssertNoExceptionsThrownTest.php b/tests/AssertNoExceptionsThrownTest.php
@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Devlop\PHPUnit\Tests;
+
+use Devlop\PHPUnit\ExceptionAssertions;
+use PHPUnit\Framework\TestCase;
+
+final class AssertNoExceptionsThrownTest extends TestCase
+{
+    use ExceptionAssertions;
+
+    function test_assert_no_exceptions_thrown_does_not_pass_if_any_exception_was_thrown() : void
+    {
+        $assertionPasses = true;
+
+        try {
+            $this->assertNoExceptionsThrown(function () : void {
+                throw new \RuntimeException('Oh?');
+            });
+        } catch (\PHPUnit\Framework\Exception $exception) {
+            $assertionPasses = false;
+        }
+
+        $this->assertFalse($assertionPasses);
+    }
+
+    function test_assert_no_exceptions_thrown_passes_if_no_exceptions_was_thrown() : void
+    {
+        $assertionPasses = true;
+
+        try {
+            $this->assertNoExceptionsThrown(function () : void {
+                // do nothing
+            });
+        } catch (\PHPUnit\Framework\Exception $exception) {
+            $assertionPasses = false;
+        }
+
+        $this->assertTrue($assertionPasses);
+    }
+}