Carteni / crypto-bundle

Tests/Command/KeyGeneratorCommandTest.php

Doc Comments +1 added lines, -1 removed lines

@@ -136,7 +136,7 @@
     }
 
     /**
-     * @param $input
+     * @param string[] $input
      *
      * @return resource
      */

DependencyInjection/MesCryptoExtension.php

Indentation +15 added lines, -15 removed lines

@@ -129,23 +129,23 @@ 
 
             // Reads encoded key from configuration file if key is not external.
             $rawKeyDefinition->setClass($defuseKey)
-                             ->setFactory(array(
-                                 $defuseKey,
-                                 'loadFromAsciiSafeString',
-                             ));
+                                ->setFactory(array(
+                                    $defuseKey,
+                                    'loadFromAsciiSafeString',
+                                ));
             $rawKeyDefinition->setArguments(array(
                 $keyIsExternal ? $loadKey : $key,
             ));
         } else {
             $rawKeyDefinition->setClass($defuseKey)
-                             ->setArguments($secretExists ? array($secretIsExternal ? $loadSecret : $secret) : array())
-                             ->setFactory($secretExists ? array(
-                                 'Defuse\Crypto\KeyProtectedByPassword',
-                                 'createRandomPasswordProtectedKey',
-                             ) : array(
-                                 'Defuse\Crypto\Key',
-                                 'createNewRandomKey',
-                             ));
+                                ->setArguments($secretExists ? array($secretIsExternal ? $loadSecret : $secret) : array())
+                                ->setFactory($secretExists ? array(
+                                    'Defuse\Crypto\KeyProtectedByPassword',
+                                    'createRandomPasswordProtectedKey',
+                                ) : array(
+                                    'Defuse\Crypto\Key',
+                                    'createNewRandomKey',
+                                ));
         }
 
         if ($createRandomKey || (!$createRandomKey && !$keyIsExternal)) {
@@ -153,7 +153,7 @@ 
         }
 
         $container->setDefinition('mes_crypto.raw_key', $rawKeyDefinition)
-                  ->setPublic(false);
+                    ->setPublic(false);
 
         // Key
         $keyDefinition = new Definition('Mes\Security\CryptoBundle\Model\Key', array(
@@ -165,7 +165,7 @@ 
             'create',
         ));
         $container->setDefinition('mes_crypto.key', $keyDefinition)
-                  ->setPublic(false);
+                    ->setPublic(false);
 
         $keyManagerDefinition = $container->getDefinition('mes_crypto.key_manager_wrapper');
 
@@ -200,7 +200,7 @@ 
     private function setCryptoLoaderResource(ContainerBuilder $container, $resource)
     {
         $container->getDefinition('mes_crypto.crypto_loader')
-                  ->replaceArgument(0, $resource);
+                    ->replaceArgument(0, $resource);
     }
 
     /**

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->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
+                            ->method('generate')
+                            ->with(null)
+                            ->will($this->returnValue($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
 
         $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->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
+                            ->method('generateFromAscii')
+                            ->with($key_encoded, $secret)
+                            ->will($this->returnValue($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
 
         $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->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
+                            ->method('getKey')
+                            ->will($this->returnValue($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
 
         $key = $this->wrapper->getKey();
 
@@ -123,8 +123,8 @@ 
     public function testSetKeyStoresKey()
     {
         $this->keyManager->expects($this->once())
-                         ->method('setKey')
-                         ->with($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'));
+                            ->method('setKey')
+                            ->with($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'));
 
         $this->wrapper->setKey($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'));
     }
@@ -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();
 

Tests/KeyManagerTest.php

Indentation +20 added lines, -20 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->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
+                            ->method('generate')
+                            ->with(null)
+                            ->will($this->returnValue($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
 
         $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->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
+                            ->method('generateFromAscii')
+                            ->with($key_encoded, $secret)
+                            ->will($this->returnValue($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
 
         $key = $this->keyManager->generateFromAscii($key_encoded, $secret);
 
@@ -81,16 +81,16 @@ 
     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->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
+                            ->method('generate')
+                            ->with(null)
+                            ->will($this->returnValue($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
 
         $this->keyStorage->expects($this->once())
-                         ->method('setKey');
+                            ->method('setKey');
 
         $key = $this->keyManager->getKey();
 
@@ -100,14 +100,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->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
+                            ->method('getKey')
+                            ->will($this->returnValue($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface')));
 
         $key = $this->keyManager->getKey();
 
@@ -117,8 +117,8 @@ 
     public function testSetKeyStoresKey()
     {
         $this->keyStorage->expects($this->once())
-                         ->method('setKey')
-                         ->with($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'));
+                            ->method('setKey')
+                            ->with($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'));
 
         $this->keyManager->setKey($this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'));
     }

Tests/EncryptionWrapperTest.php

Indentation +27 added lines, -27 removed lines

@@ -35,9 +35,9 @@ 
     public function testEncryptEncryptsPlaintext()
     {
         $this->encryption->expects($this->once())
-                         ->method('encrypt')
-                         ->with('The quick brown fox jumps over the lazy dog', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'))
-                         ->will($this->returnValue('ThisIsACipherText'));
+                            ->method('encrypt')
+                            ->with('The quick brown fox jumps over the lazy dog', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'))
+                            ->will($this->returnValue('ThisIsACipherText'));
 
         $ciphertext = $this->wrapper->encrypt('The quick brown fox jumps over the lazy dog', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'));
 
@@ -51,9 +51,9 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encrypt')
-                             ->with('The quick brown fox jumps over the lazy dog', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'))
-                             ->will($this->throwException(new EnvironmentIsBrokenException()));
+                                ->method('encrypt')
+                                ->with('The quick brown fox jumps over the lazy dog', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'))
+                                ->will($this->throwException(new EnvironmentIsBrokenException()));
         } catch (EnvironmentIsBrokenException $e) {
             $this->throwException(new CryptoException());
         }
@@ -64,9 +64,9 @@ 
     public function testDecryptDecryptsCiphertext()
     {
         $this->encryption->expects($this->once())
-                         ->method('decrypt')
-                         ->with('ThisIsACipherText', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'))
-                         ->will($this->returnValue('The quick brown fox jumps over the lazy dog'));
+                            ->method('decrypt')
+                            ->with('ThisIsACipherText', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'))
+                            ->will($this->returnValue('The quick brown fox jumps over the lazy dog'));
 
         $decryptedText = $this->wrapper->decrypt('ThisIsACipherText', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'));
 
@@ -80,9 +80,9 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decrypt')
-                             ->with('ThisIsACipherText', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'))
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('decrypt')
+                                ->with('ThisIsACipherText', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'))
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
@@ -93,11 +93,11 @@ 
     public function testEncryptFileEncryptsFile()
     {
         $this->encryption->expects($this->once())
-                         ->method('encryptFile')
-                         ->will($this->returnCallback(function ($input, $output) {
-                             $fs = new Filesystem();
-                             $fs->dumpFile($output, '');
-                         }));
+                            ->method('encryptFile')
+                            ->will($this->returnCallback(function ($input, $output) {
+                                $fs = new Filesystem();
+                                $fs->dumpFile($output, '');
+                            }));
 
         $this->wrapper->encryptFile(__DIR__.'/file.txt', __DIR__.'/file.crypto', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'));
 
@@ -109,11 +109,11 @@ 
     public function testDecryptFileDecryptsEncryptedFile()
     {
         $this->encryption->expects($this->once())
-                         ->method('decryptFile')
-                         ->will($this->returnCallback(function ($input, $output) {
-                             $fs = new Filesystem();
-                             $fs->dumpFile($output, 'Plain text');
-                         }));
+                            ->method('decryptFile')
+                            ->will($this->returnCallback(function ($input, $output) {
+                                $fs = new Filesystem();
+                                $fs->dumpFile($output, 'Plain text');
+                            }));
 
         $this->wrapper->decryptFile(__DIR__.'/file.crypto', __DIR__.'/file.txt', $this->getMock('Mes\Security\CryptoBundle\Model\KeyInterface'));
 
@@ -130,8 +130,8 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('encryptFile')
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('encryptFile')
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
@@ -146,8 +146,8 @@ 
     {
         try {
             $this->encryption->expects($this->once())
-                             ->method('decryptFile')
-                             ->will($this->throwException(new BaseCryptoException()));
+                                ->method('decryptFile')
+                                ->will($this->throwException(new BaseCryptoException()));
         } catch (BaseCryptoException $e) {
             $this->throwException(new CryptoException());
         }
@@ -158,7 +158,7 @@ 
     protected function setUp()
     {
         $this->encryption = $this->getMockBuilder('Mes\Security\CryptoBundle\EncryptionInterface')
-                                 ->getMock();
+                                    ->getMock();
         $this->wrapper = new EncryptionWrapper($this->encryption);
     }
 

Spacing +2 added lines, -2 removed lines

@@ -94,7 +94,7 @@ 
     {
         $this->encryption->expects($this->once())
                          ->method('encryptFile')
-                         ->will($this->returnCallback(function ($input, $output) {
+                         ->will($this->returnCallback(function($input, $output) {
                              $fs = new Filesystem();
                              $fs->dumpFile($output, '');
                          }));
@@ -110,7 +110,7 @@ 
     {
         $this->encryption->expects($this->once())
                          ->method('decryptFile')
-                         ->will($this->returnCallback(function ($input, $output) {
+                         ->will($this->returnCallback(function($input, $output) {
                              $fs = new Filesystem();
                              $fs->dumpFile($output, 'Plain text');
                          }));

Tests/DependencyInjection/MesCryptoExtensionTest.php

Indentation +7 added lines, -7 removed lines

@@ -31,7 +31,7 @@ 
 
         $this->assertHasDefinition('mes_crypto.raw_key');
         $this->assertSame('Defuse\Crypto\Key', $this->configuration->findDefinition('mes_crypto.raw_key')
-                                                                   ->getClass(), 'Defuse\Crypto\Key class is correct');
+                                                                    ->getClass(), 'Defuse\Crypto\Key class is correct');
 
         $this->assertNotHasDefinition('mes_crypto.crypto_loader');
     }
@@ -44,7 +44,7 @@ 
 
         $this->assertHasDefinition('mes_crypto.raw_key');
         $this->assertSame('Defuse\Crypto\KeyProtectedByPassword', $this->configuration->findDefinition('mes_crypto.raw_key')
-                                                                                      ->getClass(), 'KeyProtectedByPassword class is correct');
+                                                                                        ->getClass(), 'KeyProtectedByPassword class is correct');
 
         $this->assertNotHasDefinition('mes_crypto.crypto_loader');
     }
@@ -57,7 +57,7 @@ 
 
         $this->assertHasDefinition('mes_crypto.raw_key');
         $this->assertSame('Defuse\Crypto\KeyProtectedByPassword', $this->configuration->findDefinition('mes_crypto.raw_key')
-                                                                                      ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
+                                                                                        ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
         $this->assertNotHasDefinition('mes_crypto.crypto_loader');
     }
 
@@ -69,11 +69,11 @@ 
 
         $this->assertHasDefinition('mes_crypto.raw_key');
         $this->assertSame('Defuse\Crypto\KeyProtectedByPassword', $this->configuration->findDefinition('mes_crypto.raw_key')
-                                                                                      ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
+                                                                                        ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
         $this->assertHasDefinition('mes_crypto.crypto_loader');
 
         $keyResource = $this->configuration->findDefinition('mes_crypto.crypto_loader')
-                                           ->getArgument(0);
+                                            ->getArgument(0);
 
         $this->assertContains('key.crypto', $keyResource, sprintf('crypto file is %s', 'key.crypto'));
     }
@@ -86,11 +86,11 @@ 
 
         $this->assertHasDefinition('mes_crypto.raw_key');
         $this->assertSame('Defuse\Crypto\KeyProtectedByPassword', $this->configuration->findDefinition('mes_crypto.raw_key')
-                                                                                      ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
+                                                                                        ->getClass(), 'Defuse\Crypto\KeyProtectedByPassword class is correct');
         $this->assertHasDefinition('mes_crypto.crypto_loader');
 
         $keyResource = $this->configuration->findDefinition('mes_crypto.crypto_loader')
-                                           ->getArgument(0);
+                                            ->getArgument(0);
 
         $this->assertContains('key.crypto', $keyResource, sprintf('crypto file is %s', 'key.crypto'));