Carteni / crypto-bundle

Tests/KeyManagerTest.php

Indentation +25 added lines, -25 removed lines

@@ -37,10 +37,10 @@ 
     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();
 
@@ -53,10 +53,10 @@ 
         $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);
 
@@ -66,17 +66,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();
 
@@ -86,14 +86,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();
@@ -104,12 +104,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()
@@ -122,10 +122,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);
     }

Tests/EncryptionWrapperTest.php

Indentation +53 added lines, -53 removed lines

@@ -37,7 +37,7 @@ 
     protected function setUp()
     {
         $this->encryption = $this->getMockBuilder('Mes\Security\CryptoBundle\EncryptionInterface')
-                                 ->getMock();
+                                    ->getMock();
         $this->wrapper = new EncryptionWrapper($this->encryption);
     }
 
@@ -53,9 +53,9 @@ 
     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')->getMock())
-                         ->will($this->returnValue('ThisIsACipherText'));
+                            ->method('encryptWithKey')
+                            ->with('The quick brown fox jumps over the lazy dog', $this->getMockBuilder('Mes\Security\CryptoBundle\Model\KeyInterface')->getMock())
+                            ->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());
 
@@ -69,9 +69,9 @@ 
     {
         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')->getMock())
-                             ->will($this->throwException(new EnvironmentIsBrokenException()));
+                                ->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()));
         } catch (EnvironmentIsBrokenException $e) {
             $this->throwException(new CryptoException());
         }
@@ -85,9 +85,9 @@ 
     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());
 
@@ -101,9 +101,9 @@ 
     {
         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());
         }
@@ -117,11 +117,11 @@ 
     public function testEncryptWithKeyFileEncryptsFile()
     {
         $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());
 
@@ -136,11 +136,11 @@ 
     public function testDecryptWithKeyFileDecryptsEncryptedFile()
     {
         $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());
 
@@ -157,8 +157,8 @@ 
     {
         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());
         }
@@ -173,8 +173,8 @@ 
     {
         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());
         }
@@ -185,9 +185,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');
 
@@ -201,9 +201,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());
         }
@@ -214,9 +214,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');
 
@@ -230,9 +230,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());
         }
@@ -243,11 +243,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');
 
@@ -263,8 +263,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());
         }
@@ -275,11 +275,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');
 
@@ -296,8 +296,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());
         }

Spacing +4 added lines, -4 removed lines

@@ -118,7 +118,7 @@ 
     {
         $this->encryption->expects($this->once())
                          ->method('encryptFileWithKey')
-                         ->will($this->returnCallback(function ($input, $output) {
+                         ->will($this->returnCallback(function($input, $output) {
                              $fs = new Filesystem();
                              $fs->dumpFile($output, '');
                          }));
@@ -137,7 +137,7 @@ 
     {
         $this->encryption->expects($this->once())
                          ->method('decryptFileWithKey')
-                         ->will($this->returnCallback(function ($input, $output) {
+                         ->will($this->returnCallback(function($input, $output) {
                              $fs = new Filesystem();
                              $fs->dumpFile($output, 'Plain text');
                          }));
@@ -244,7 +244,7 @@ 
     {
         $this->encryption->expects($this->once())
                          ->method('encryptFileWithPassword')
-                         ->will($this->returnCallback(function ($input, $output, $password) {
+                         ->will($this->returnCallback(function($input, $output, $password) {
                              $fs = new Filesystem();
                              $fs->dumpFile($output, '');
                          }));
@@ -276,7 +276,7 @@ 
     {
         $this->encryption->expects($this->once())
                          ->method('decryptFileWithPassword')
-                         ->will($this->returnCallback(function ($input, $output, $password) {
+                         ->will($this->returnCallback(function($input, $output, $password) {
                              $fs = new Filesystem();
                              $fs->dumpFile($output, 'Plain text');
                          }));

Tests/bootstrap.php

Spacing +1 added lines, -1 removed lines

@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-register_shutdown_function(function () {
+register_shutdown_function(function() {
     if (file_exists(__DIR__.'/key.crypto')) {
         unlink(__DIR__.'/key.crypto');
     }