Merge pull request #8 from IlicMiljan/improve-exception-handling

[Breaking Change] Services - Improve Exception Handling
IlicMiljan · Mar 10, 2024 · 70ead66 · 70ead66
2 parents b210580 + 61a7882
commit 70ead66
Show file tree

Hide file tree

Showing 13 changed files with 269 additions and 27 deletions.
diff --git a/src/Cipher/AdvancedEncryptionStandardCipher.php b/src/Cipher/AdvancedEncryptionStandardCipher.php
@@ -6,21 +6,20 @@
 use IlicMiljan\SecureProps\Cipher\Exception\FailedDecryptingValue;
 use IlicMiljan\SecureProps\Cipher\Exception\FailedEncryptingValue;
 use IlicMiljan\SecureProps\Cipher\Exception\FailedGeneratingInitializationVector;
-use InvalidArgumentException;
+use IlicMiljan\SecureProps\Cipher\Exception\InvalidKeyLength;
 use SensitiveParameter;
 
 class AdvancedEncryptionStandardCipher implements Cipher
 {
     private const CIPHER = 'AES-256-GCM';
     private const TAG_LENGTH = 16;
+    private const KEY_LENGTH = 32;
 
     public function __construct(
         #[SensitiveParameter]
         private string $key
     ) {
-        if (strlen($key) !== 32) {
-            throw new InvalidArgumentException('Key must be 32 bytes (256 bits) long.');
-        }
+        $this->validateKey($key);
     }
 
     /**
@@ -101,4 +100,11 @@ public function calculateInitializationVectorLength(string $cipher): int
 
         return $ivLength;
     }
+
+    public function validateKey(string $key): void
+    {
+        if (strlen($key) !== self::KEY_LENGTH) {
+            throw new InvalidKeyLength(self::KEY_LENGTH);
+        }
+    }
 }
diff --git a/src/Cipher/Exception/InvalidKeyLength.php b/src/Cipher/Exception/InvalidKeyLength.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace IlicMiljan\SecureProps\Cipher\Exception;
+
+use RuntimeException;
+use Throwable;
+
+class InvalidKeyLength extends RuntimeException implements CipherException
+{
+    public function __construct(
+        private int $expectedLength,
+        ?Throwable $previous = null
+    ) {
+        parent::__construct(
+            'The provided key is too short.',
+            0,
+            $previous
+        );
+    }
+
+    public function getExpectedLength(): int
+    {
+        return $this->expectedLength;
+    }
+}
diff --git a/src/Exception/EncryptionServiceException.php b/src/Exception/EncryptionServiceException.php
@@ -0,0 +1,9 @@
+<?php
+
+namespace IlicMiljan\SecureProps\Exception;
+
+use Throwable;
+
+interface EncryptionServiceException extends Throwable
+{
+}
diff --git a/src/Exception/ValueMustBeObject.php b/src/Exception/ValueMustBeObject.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace IlicMiljan\SecureProps\Exception;
+
+use RuntimeException;
+use Throwable;
+
+class ValueMustBeObject extends RuntimeException implements EncryptionServiceException
+{
+    public function __construct(
+        private string $type,
+        ?Throwable $previous = null
+    ) {
+        parent::__construct(
+            'The value must be an object.',
+            0,
+            $previous
+        );
+    }
+
+    public function getType(): string
+    {
+        return $this->type;
+    }
+}
diff --git a/src/Exception/ValueMustBeString.php b/src/Exception/ValueMustBeString.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace IlicMiljan\SecureProps\Exception;
+
+use RuntimeException;
+use Throwable;
+
+class ValueMustBeString extends RuntimeException implements EncryptionServiceException
+{
+    public function __construct(
+        private string $type,
+        ?Throwable $previous = null
+    ) {
+        parent::__construct(
+            'The value must be a string.',
+            0,
+            $previous
+        );
+    }
+
+    public function getType(): string
+    {
+        return $this->type;
+    }
+}
diff --git a/src/ObjectEncryptionService.php b/src/ObjectEncryptionService.php
@@ -5,9 +5,11 @@
 use IlicMiljan\SecureProps\Attribute\Encrypted;
 use IlicMiljan\SecureProps\Cipher\Cipher;
 use IlicMiljan\SecureProps\Cipher\Exception\CipherException;
+use IlicMiljan\SecureProps\Exception\EncryptionServiceException;
+use IlicMiljan\SecureProps\Exception\ValueMustBeObject;
+use IlicMiljan\SecureProps\Exception\ValueMustBeString;
 use IlicMiljan\SecureProps\Reader\Exception\ReaderException;
 use IlicMiljan\SecureProps\Reader\ObjectPropertiesReader;
-use InvalidArgumentException;
 use ReflectionProperty;
 use SensitiveParameter;
 
@@ -23,13 +25,14 @@ public function __construct(
      * @param mixed $value
      * @return object
      *
+     * @throws EncryptionServiceException
      * @throws CipherException
      * @throws ReaderException
      */
     public function encrypt(#[SensitiveParameter] mixed $value): object
     {
         if (!is_object($value)) {
-            throw new InvalidArgumentException('Value must be object.');
+            throw new ValueMustBeObject(gettype($value));
         }
 
         $encryptedProperties = $this->objectPropertiesReader->getPropertiesWithAttribute($value, Encrypted::class);
@@ -50,13 +53,14 @@ public function encrypt(#[SensitiveParameter] mixed $value): object
      *
      * @return object
      *
+     * @throws EncryptionServiceException
      * @throws CipherException
      * @throws ReaderException
      */
     public function decrypt(#[SensitiveParameter] mixed $value): object
     {
         if (!is_object($value)) {
-            throw new InvalidArgumentException('Value must be object.');
+            throw new ValueMustBeObject(gettype($value));
         }
 
         $encryptedProperties = $this->objectPropertiesReader->getPropertiesWithAttribute($value, Encrypted::class);
@@ -83,7 +87,7 @@ private function updatePropertyValue(ReflectionProperty $property, object $objec
         }
 
         if (!is_string($currentValue)) {
-            throw new InvalidArgumentException('Value must be string.');
+            throw new ValueMustBeString(gettype($currentValue));
         }
 
         $property->setValue($object, $callback($currentValue));

diff --git a/src/StringEncryptionService.php b/src/StringEncryptionService.php
@@ -4,7 +4,8 @@
 
 use IlicMiljan\SecureProps\Cipher\Cipher;
 use IlicMiljan\SecureProps\Cipher\Exception\CipherException;
-use InvalidArgumentException;
+use IlicMiljan\SecureProps\Exception\EncryptionServiceException;
+use IlicMiljan\SecureProps\Exception\ValueMustBeString;
 use SensitiveParameter;
 
 class StringEncryptionService implements EncryptionService
@@ -16,13 +17,16 @@ public function __construct(
 
     /**
      * @param mixed $value
+     *
      * @return string
+     *
+     * @throws EncryptionServiceException
      * @throws CipherException
      */
     public function encrypt(#[SensitiveParameter] mixed $value): string
     {
         if (!is_string($value)) {
-            throw new InvalidArgumentException('Value must be string.');
+            throw new ValueMustBeString(gettype($value));
         }
 
         return $this->cipher->encrypt($value);
@@ -31,12 +35,14 @@ public function encrypt(#[SensitiveParameter] mixed $value): string
     /**
      * @param mixed $value
      * @return string
+     *
+     * @throws EncryptionServiceException
      * @throws CipherException
      */
     public function decrypt(#[SensitiveParameter] mixed $value): string
     {
         if (!is_string($value)) {
-            throw new InvalidArgumentException('Value must be string.');
+            throw new ValueMustBeString(gettype($value));
         }
 
         return $this->cipher->decrypt($value);

diff --git a/tests/Cipher/AdvancedEncryptionStandardCipherTest.php b/tests/Cipher/AdvancedEncryptionStandardCipherTest.php
@@ -3,7 +3,7 @@
 namespace IlicMiljan\SecureProps\Tests\Cipher;
 
 use IlicMiljan\SecureProps\Cipher\AdvancedEncryptionStandardCipher;
-use InvalidArgumentException;
+use IlicMiljan\SecureProps\Cipher\Exception\InvalidKeyLength;
 use PHPUnit\Framework\TestCase;
 
 class AdvancedEncryptionStandardCipherTest extends TestCase
@@ -17,7 +17,7 @@ protected function setUp(): void
 
     public function testConstructWithInvalidKeyLengthThrowsException(): void
     {
-        $this->expectException(InvalidArgumentException::class);
+        $this->expectException(InvalidKeyLength::class);
 
         new AdvancedEncryptionStandardCipher(openssl_random_pseudo_bytes(16));
     }

diff --git a/tests/Cipher/Exception/InvalidKeyLengthTest.php b/tests/Cipher/Exception/InvalidKeyLengthTest.php
@@ -0,0 +1,47 @@
+<?php
+
+namespace IlicMiljan\SecureProps\Tests\Cipher\Exception;
+
+use IlicMiljan\SecureProps\Cipher\Exception\CipherException;
+use IlicMiljan\SecureProps\Cipher\Exception\InvalidKeyLength;
+use PHPUnit\Framework\TestCase;
+use RuntimeException;
+
+class InvalidKeyLengthTest extends TestCase
+{
+    private int $expectedLength;
+
+    protected function setUp(): void
+    {
+        $this->expectedLength = 32;
+    }
+
+    public function testCanBeCreated(): void
+    {
+        $exception = new InvalidKeyLength($this->expectedLength);
+
+        $this->assertInstanceOf(InvalidKeyLength::class, $exception);
+    }
+
+    public function testReturnsExpectedLength(): void
+    {
+        $exception = new InvalidKeyLength($this->expectedLength);
+
+        $this->assertEquals($this->expectedLength, $exception->getExpectedLength());
+    }
+
+    public function testPreviousExceptionIsStored(): void
+    {
+        $previous = new RuntimeException('Previous exception');
+        $exception = new InvalidKeyLength($this->expectedLength, $previous);
+
+        $this->assertSame($previous, $exception->getPrevious());
+    }
+
+    public function testImplementsCipherExceptionInterface(): void
+    {
+        $exception = new InvalidKeyLength($this->expectedLength);
+
+        $this->assertInstanceOf(CipherException::class, $exception);
+    }
+}
diff --git a/tests/Exception/ValueMustBeObjectTest.php b/tests/Exception/ValueMustBeObjectTest.php
@@ -0,0 +1,47 @@
+<?php
+
+namespace IlicMiljan\SecureProps\Tests\Exception;
+
+use IlicMiljan\SecureProps\Exception\EncryptionServiceException;
+use IlicMiljan\SecureProps\Exception\ValueMustBeObject;
+use PHPUnit\Framework\TestCase;
+use RuntimeException;
+
+class ValueMustBeObjectTest extends TestCase
+{
+    private string $type;
+
+    protected function setUp(): void
+    {
+        $this->type = 'string';
+    }
+
+    public function testCanBeCreated(): void
+    {
+        $exception = new ValueMustBeObject($this->type);
+
+        $this->assertInstanceOf(ValueMustBeObject::class, $exception);
+    }
+
+    public function testReturnsType(): void
+    {
+        $exception = new ValueMustBeObject($this->type);
+
+        $this->assertEquals($this->type, $exception->getType());
+    }
+
+    public function testPreviousExceptionIsStored(): void
+    {
+        $previous = new RuntimeException('Previous exception');
+        $exception = new ValueMustBeObject($this->type, $previous);
+
+        $this->assertSame($previous, $exception->getPrevious());
+    }
+
+    public function testImplementsEncryptionServiceExceptionInterface(): void
+    {
+        $exception = new ValueMustBeObject($this->type);
+
+        $this->assertInstanceOf(EncryptionServiceException::class, $exception);
+    }
+}
diff --git a/tests/Exception/ValueMustBeStringTest.php b/tests/Exception/ValueMustBeStringTest.php
@@ -0,0 +1,47 @@
+<?php
+
+namespace IlicMiljan\SecureProps\Tests\Exception;
+
+use IlicMiljan\SecureProps\Exception\EncryptionServiceException;
+use IlicMiljan\SecureProps\Exception\ValueMustBeString;
+use PHPUnit\Framework\TestCase;
+use RuntimeException;
+
+class ValueMustBeStringTest extends TestCase
+{
+    private string $type;
+
+    protected function setUp(): void
+    {
+        $this->type = 'object';
+    }
+
+    public function testCanBeCreated(): void
+    {
+        $exception = new ValueMustBeString($this->type);
+
+        $this->assertInstanceOf(ValueMustBeString::class, $exception);
+    }
+
+    public function testReturnsType(): void
+    {
+        $exception = new ValueMustBeString($this->type);
+
+        $this->assertEquals($this->type, $exception->getType());
+    }
+
+    public function testPreviousExceptionIsStored(): void
+    {
+        $previous = new RuntimeException('Previous exception');
+        $exception = new ValueMustBeString($this->type, $previous);
+
+        $this->assertSame($previous, $exception->getPrevious());
+    }
+
+    public function testImplementsEncryptionServiceExceptionInterface(): void
+    {
+        $exception = new ValueMustBeString($this->type);
+
+        $this->assertInstanceOf(EncryptionServiceException::class, $exception);
+    }
+}