Carteni / crypto-bundle

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'));