Carteni / crypto-bundle

Tests/EncryptionWrapperTest.php

Indentation +63 added lines, -63 removed lines

@@ -36,7 +36,7 @@ 
     protected function setUp()
     {
         $this->encryption = $this->getMockBuilder('Mes\Security\CryptoBundle\EncryptionInterface')
-                                 ->getMock();
+                                    ->getMock();
         $this->wrapper = new EncryptionWrapper($this->encryption);
     }
 
@@ -59,13 +59,13 @@ 
     public function testEncryptWithKeyEncryptsPlaintext()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptWithKey')
-                         ->with('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                            ->method('encryptWithKey')
+                            ->with('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
                                                                                     ->getMock())
-                         ->will($this->returnValue('ThisIsACipherText'));
+                            ->will($this->returnValue('ThisIsACipherText'));
 
         $ciphertext = $this->wrapper->encryptWithKey('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                                         ->getMock());
+                                                                                                            ->getMock());
 
         $this->assertTrue(ctype_print($ciphertext), 'is printable');
     }
@@ -77,16 +77,16 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptWithKey')
-                             ->with('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                                ->method('encryptWithKey')
+                                ->with('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
                                                                                         ->getMock())
-                             ->will($this->throwException(new EnvironmentIsBrokenException()));
+                                ->will($this->throwException(new EnvironmentIsBrokenException()));
         } catch (EnvironmentIsBrokenException $e) {
             $this->throwException(new CryptoException());
         }
 
         $this->wrapper->encryptWithKey('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                           ->getMock());
+                                                                                            ->getMock());
     }
 
     /**
@@ -95,13 +95,13 @@ 
     public function testDecryptWithKeyDecryptsCiphertext()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptWithKey')
-                         ->with('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                          ->getMock())
-                         ->will($this->returnValue('The quick brown fox jumps over the lazy dog'));
+                            ->method('decryptWithKey')
+                            ->with('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                                                            ->getMock())
+                            ->will($this->returnValue('The quick brown fox jumps over the lazy dog'));
 
         $decryptedText = $this->wrapper->decryptWithKey('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                  ->getMock());
+                                                                                    ->getMock());
 
         $this->assertSame('The quick brown fox jumps over the lazy dog', $decryptedText);
     }
@@ -113,16 +113,16 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptWithKey')
-                             ->with('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                              ->getMock())
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('decryptWithKey')
+                                ->with('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                                                                ->getMock())
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
 
         $this->wrapper->decryptWithKey('ThisIsACipherText', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                 ->getMock());
+                                                                    ->getMock());
     }
 
     /* =======================================
@@ -138,14 +138,14 @@ 
     public function testEncryptFileWithKeyEncryptsFile()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptFileWithKey')
-                         ->will($this->returnCallback(function ($input, $output) {
-                             $fs = new Filesystem();
-                             $fs->dumpFile($output, '');
-                         }));
+                            ->method('encryptFileWithKey')
+                            ->will($this->returnCallback(function ($input, $output) {
+                                $fs = new Filesystem();
+                                $fs->dumpFile($output, '');
+                            }));
 
         $this->wrapper->encryptFileWithKey(__DIR__.'/file.txt', __DIR__.'/file.crypto', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                                 ->getMock());
+                                                                                                    ->getMock());
 
         $this->assertFileExists(__DIR__.'/file.crypto');
 
@@ -158,14 +158,14 @@ 
     public function testDecryptFileWithKeyDecryptsEncryptedFile()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptFileWithKey')
-                         ->will($this->returnCallback(function ($input, $output) {
-                             $fs = new Filesystem();
-                             $fs->dumpFile($output, 'Plain text');
-                         }));
+                            ->method('decryptFileWithKey')
+                            ->will($this->returnCallback(function ($input, $output) {
+                                $fs = new Filesystem();
+                                $fs->dumpFile($output, 'Plain text');
+                            }));
 
         $this->wrapper->decryptFileWithKey(__DIR__.'/file.crypto', __DIR__.'/file.txt', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                                 ->getMock());
+                                                                                                    ->getMock());
 
         $this->assertFileExists(__DIR__.'/file.txt');
         $this->assertContains('Plain text', file_get_contents(__DIR__.'/file.txt'));
@@ -180,14 +180,14 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptFileWithKey')
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('encryptFileWithKey')
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
 
         $this->wrapper->encryptFileWithKey(__DIR__.'/file.txt', __DIR__.'/file.crypto', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                                 ->getMock());
+                                                                                                    ->getMock());
     }
 
     /**
@@ -197,14 +197,14 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptFileWithKey')
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('decryptFileWithKey')
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
 
         $this->wrapper->decryptFileWithKey(__DIR__.'/file.crypto', __DIR__.'/file.txt', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                                                                 ->getMock());
+                                                                                                    ->getMock());
     }
 
     /* ========================================
@@ -217,9 +217,9 @@ 
     public function testEncryptWithPasswordEncryptsPlaintext()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptWithPassword')
-                         ->with('The quick brown fox jumps over the lazy dog', 'SuperSecretPa$$word')
-                         ->will($this->returnValue('ThisIsACipherText'));
+                            ->method('encryptWithPassword')
+                            ->with('The quick brown fox jumps over the lazy dog', 'SuperSecretPa$$word')
+                            ->will($this->returnValue('ThisIsACipherText'));
 
         $ciphertext = $this->wrapper->encryptWithPassword('The quick brown fox jumps over the lazy dog', 'SuperSecretPa$$word');
 
@@ -233,9 +233,9 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptWithPassword')
-                             ->with('The quick brown fox jumps over the lazy dog', 'SuperSecretPa$$word')
-                             ->will($this->throwException(new EnvironmentIsBrokenException()));
+                                ->method('encryptWithPassword')
+                                ->with('The quick brown fox jumps over the lazy dog', 'SuperSecretPa$$word')
+                                ->will($this->throwException(new EnvironmentIsBrokenException()));
         } catch (EnvironmentIsBrokenException $e) {
             $this->throwException(new CryptoException());
         }
@@ -246,9 +246,9 @@ 
     public function testDecryptWithPasswordDecryptsCiphertext()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptWithPassword')
-                         ->with('ThisIsACipherText', 'SuperSecretPa$$word')
-                         ->will($this->returnValue('The quick brown fox jumps over the lazy dog'));
+                            ->method('decryptWithPassword')
+                            ->with('ThisIsACipherText', 'SuperSecretPa$$word')
+                            ->will($this->returnValue('The quick brown fox jumps over the lazy dog'));
 
         $decryptedText = $this->wrapper->decryptWithPassword('ThisIsACipherText', 'SuperSecretPa$$word');
 
@@ -262,9 +262,9 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptWithPassword')
-                             ->with('ThisIsACipherText', 'SuperSecretPa$$word')
-                             ->will($this->throwException(new WrongKeyOrModifiedCiphertextException()));
+                                ->method('decryptWithPassword')
+                                ->with('ThisIsACipherText', 'SuperSecretPa$$word')
+                                ->will($this->throwException(new WrongKeyOrModifiedCiphertextException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
@@ -282,11 +282,11 @@ 
     public function testEncryptFileWithPasswordEncryptsFile()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptFileWithPassword')
-                         ->will($this->returnCallback(function ($input, $output, $password) {
-                             $fs = new Filesystem();
-                             $fs->dumpFile($output, '');
-                         }));
+                            ->method('encryptFileWithPassword')
+                            ->will($this->returnCallback(function ($input, $output, $password) {
+                                $fs = new Filesystem();
+                                $fs->dumpFile($output, '');
+                            }));
 
         $this->wrapper->encryptFileWithPassword(__DIR__.'/file.txt', __DIR__.'/file.crypto', 'SuperSecretPa$$word');
 
@@ -302,8 +302,8 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptFileWithPassword')
-                             ->will($this->throwException(new EnvironmentIsBrokenException()));
+                                ->method('encryptFileWithPassword')
+                                ->will($this->throwException(new EnvironmentIsBrokenException()));
         } catch (EnvironmentIsBrokenException $e) {
             $this->throwException(new CryptoException());
         }
@@ -314,11 +314,11 @@ 
     public function testDecryptFileWithPasswordDecryptsEncryptedFile()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptFileWithPassword')
-                         ->will($this->returnCallback(function ($input, $output, $password) {
-                             $fs = new Filesystem();
-                             $fs->dumpFile($output, 'Plain text');
-                         }));
+                            ->method('decryptFileWithPassword')
+                            ->will($this->returnCallback(function ($input, $output, $password) {
+                                $fs = new Filesystem();
+                                $fs->dumpFile($output, 'Plain text');
+                            }));
 
         $this->wrapper->decryptFileWithPassword(__DIR__.'/file.crypto', __DIR__.'/file.txt', 'SuperSecretPa$$word');
 
@@ -335,8 +335,8 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptFileWithPassword')
-                             ->will($this->throwException(new WrongKeyOrModifiedCiphertextException()));
+                                ->method('decryptFileWithPassword')
+                                ->will($this->throwException(new WrongKeyOrModifiedCiphertextException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }

Tests/KeyManagerTest.php

Indentation +23 added lines, -23 removed lines

@@ -36,10 +36,10 @@ 
     protected function setUp()
     {
         $this->keyStorage = $this->getMockBuilder('Mes\Security\CryptoBundle\KeyStorage\KeyStorageInterface')
-                                 ->getMock();
+                                    ->getMock();
 
         $this->keyGenerator = $this->getMockBuilder('Mes\Security\CryptoBundle\KeyGenerator\KeyGeneratorInterface')
-                                   ->getMock();
+                                    ->getMock();
 
         $this->keyManager = new KeyManager($this->keyStorage, $this->keyGenerator);
     }
@@ -54,9 +54,9 @@ 
     public function testGenerateCreatesKey()
     {
         $this->keyGenerator->expects($this->once())
-                           ->method('generate')
-                           ->with(null)
-                           ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
+                            ->method('generate')
+                            ->with(null)
+                            ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
 
         $key = $this->keyManager->generate();
 
@@ -69,9 +69,9 @@ 
         $secret = 'ThisIsASecretPassword';
 
         $this->keyGenerator->expects($this->once())
-                           ->method('generateFromAscii')
-                           ->with($key_encoded, $secret)
-                           ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
+                            ->method('generateFromAscii')
+                            ->with($key_encoded, $secret)
+                            ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
 
         $key = $this->keyManager->generateFromAscii($key_encoded, $secret);
 
@@ -81,17 +81,17 @@ 
     public function testGetKeyReadsNotExistingKey()
     {
         $this->keyStorage->expects($this->once())
-                         ->method('getKey')
-                         ->will($this->returnValue(null));
+                            ->method('getKey')
+                            ->will($this->returnValue(null));
 
         $this->keyGenerator->expects($this->once())
-                           ->method('generate')
-                           ->with(null)
-                           ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                                          ->getMock()));
+                            ->method('generate')
+                            ->with(null)
+                            ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                                                            ->getMock()));
 
         $this->keyStorage->expects($this->once())
-                         ->method('setKey');
+                            ->method('setKey');
 
         $key = $this->keyManager->getKey();
 
@@ -101,14 +101,14 @@ 
     public function testGetKeyReadsExistingKey()
     {
         $this->keyStorage->expects($this->never())
-                         ->method('setKey');
+                            ->method('setKey');
 
         $this->keyGenerator->expects($this->never())
-                           ->method('generate');
+                            ->method('generate');
 
         $this->keyStorage->expects($this->once())
-                         ->method('getKey')
-                         ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                            ->method('getKey')
+                            ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
                                                         ->getMock()));
 
         $key = $this->keyManager->getKey();
@@ -119,12 +119,12 @@ 
     public function testSetKeyStoresKey()
     {
         $this->keyStorage->expects($this->once())
-                         ->method('setKey')
-                         ->with($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                     ->getMock());
+                            ->method('setKey')
+                            ->with($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
+                                        ->getMock());
 
         $this->keyManager->setKey($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')
-                                       ->getMock());
+                                        ->getMock());
     }
 
     public function testSetSecretStoreSecret()

Tests/KeyManagerWrapperTest.php

Indentation +21 added lines, -21 removed lines

@@ -36,7 +36,7 @@ 
     protected function setUp()
     {
         $this->keyManager = $this->getMockBuilder('\Mes\Security\CryptoBundle\KeyManagerInterface')
-                                 ->getMock();
+                                    ->getMock();
         $this->wrapper = new KeyManagerWrapper($this->keyManager);
     }
 
@@ -48,9 +48,9 @@ 
     public function testGenerateCreatesKey()
     {
         $this->keyManager->expects($this->once())
-                         ->method('generate')
-                         ->with(null)
-                         ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
+                            ->method('generate')
+                            ->with(null)
+                            ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
 
         $key = $this->wrapper->generate();
 
@@ -64,9 +64,9 @@ 
     {
         try {
             $this->keyManager->expects($this->once())
-                             ->method('generate')
-                             ->with(null)
-                             ->will($this->throwException(new EnvironmentIsBrokenException()));
+                                ->method('generate')
+                                ->with(null)
+                                ->will($this->throwException(new EnvironmentIsBrokenException()));
         } catch (EnvironmentIsBrokenException $ex) {
             $this->throwException(new CryptoException());
         }
@@ -80,9 +80,9 @@ 
         $secret = 'ThisIsASecretPassword';
 
         $this->keyManager->expects($this->once())
-                         ->method('generateFromAscii')
-                         ->with($key_encoded, $secret)
-                         ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
+                            ->method('generateFromAscii')
+                            ->with($key_encoded, $secret)
+                            ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
 
         $key = $this->wrapper->generateFromAscii($key_encoded, $secret);
 
@@ -99,9 +99,9 @@ 
 
         try {
             $this->keyManager->expects($this->once())
-                             ->method('generateFromAscii')
-                             ->with($key_encoded, $secret)
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('generateFromAscii')
+                                ->with($key_encoded, $secret)
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (CryptoException $ex) {
             $this->throwException(new CryptoException());
         }
@@ -112,8 +112,8 @@ 
     public function testGetKeyReadsKey()
     {
         $this->keyManager->expects($this->once())
-                         ->method('getKey')
-                         ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
+                            ->method('getKey')
+                            ->will($this->returnValue($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock()));
 
         $key = $this->wrapper->getKey();
 
@@ -123,8 +123,8 @@ 
     public function testSetKeyStoresKey()
     {
         $this->keyManager->expects($this->once())
-                         ->method('setKey')
-                         ->with($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock());
+                            ->method('setKey')
+                            ->with($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock());
 
         $this->wrapper->setKey($this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock());
     }
@@ -132,8 +132,8 @@ 
     public function testSetSecretStoresSecret()
     {
         $this->keyManager->expects($this->once())
-                         ->method('setSecret')
-                         ->with('ThisIsASecret');
+                            ->method('setSecret')
+                            ->with('ThisIsASecret');
 
         $this->wrapper->setSecret('ThisIsASecret');
     }
@@ -141,8 +141,8 @@ 
     public function testGetSecretReadsSecret()
     {
         $this->keyManager->expects($this->once())
-                         ->method('getSecret')
-                         ->will($this->returnValue('ThisIsYourSecret'));
+                            ->method('getSecret')
+                            ->will($this->returnValue('ThisIsYourSecret'));
 
         $secret = $this->wrapper->getSecret();