| Current File : //home/strato/chroot/opt/RZphp72/includes/test/Crypt_GPG/tests/KeyTest.php |
<?php
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
/**
* Key class test cases for the Crypt_GPG package.
*
* These tests require the PHPUnit 3.6 or greater package to be installed.
* PHPUnit is installable using PEAR. See the
* {@link http://www.phpunit.de/manual/3.6/en/installation.html manual}
* for detailed installation instructions.
*
* To run these tests, use:
* <code>
* $ phpunit KeyTestCase
* </code>
*
* LICENSE:
*
* This library is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of the
* License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see
* <http://www.gnu.org/licenses/>
*
* @category Encryption
* @package Crypt_GPG
* @author Michael Gauthier <mike@silverorange.com>
* @copyright 2008-2010 silverorange
* @license http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
* @version CVS: $Id$
* @link http://pear.php.net/package/Crypt_GPG
*/
/**
* Base test case.
*/
require_once 'TestCase.php';
/**
* Key class.
*/
require_once 'Crypt/GPG/Key.php';
/**
* User id class.
*/
require_once 'Crypt/GPG/UserId.php';
/**
* Sub-key class.
*/
require_once 'Crypt/GPG/SubKey.php';
/**
* Key class tests for Crypt_GPG.
*
* @category Encryption
* @package Crypt_GPG
* @author Michael Gauthier <mike@silverorange.com>
* @copyright 2008-2010 silverorange
* @license http://www.gnu.org/copyleft/lesser.html LGPL License 2.1
* @link http://pear.php.net/package/Crypt_GPG
*/
class KeyTestCase extends Crypt_GPG_TestCase
{
// accessors
// {{{ testGetSubKeys()
/**
* @group accessors
*/
public function testGetSubKeys()
{
$key = new Crypt_GPG_Key();
$firstSubKey = new Crypt_GPG_SubKey(array(
'id' => 'C097D9EC94C06363',
'algorithm' => Crypt_GPG_SubKey::ALGORITHM_DSA,
'fingerprint' => '8D2299D9C5C211128B32BBB0C097D9EC94C06363',
'length' => 1024,
'creation' => 1221785805,
'expiration' => 0,
'canSign' => true,
'canEncrypt' => false,
'hasPrivate' => true
));
$key->addSubKey($firstSubKey);
$secondSubKey = new Crypt_GPG_SubKey(array(
'id' => '9F93F9116728EF12',
'algorithm' => Crypt_GPG_SubKey::ALGORITHM_ELGAMAL_ENC,
'fingerprint' => 'C9C65B3BBF040E40D0EA27B79F93F9116728EF12',
'length' => 2048,
'creation' => 1221785821,
'expiration' => 0,
'canSign' => false,
'canEncrypt' => true,
'hasPrivate' => true
));
$key->addSubKey($secondSubKey);
$subKeys = $key->getSubKeys();
$this->assertTrue(is_array($subKeys),
'Failed to assert returned sub-keys is an array.');
$this->assertEquals(2, count($subKeys),
'Failed to assert number of returned sub-keys is the same as ' .
'the number of sub-keys added.');
$this->assertContainsOnly('Crypt_GPG_SubKey', $subKeys, false,
'Failed to assert all returned sub-keys are Crypt_GPG_SubKey ' .
'objects.');
$this->assertArrayHasKey(0, $subKeys);
$this->assertEquals($subKeys[0], $firstSubKey,
'Failed to assert the first sub-key is the same as the first ' .
'added sub-key.');
$this->assertArrayHasKey(1, $subKeys);
$this->assertEquals($subKeys[1], $secondSubKey,
'Failed to assert the second sub-key is the same as the second ' .
'added sub-key.');
}
// }}}
// {{{ testGetUserIds()
/**
* @group accessors
*/
public function testGetUserIds()
{
$key = new Crypt_GPG_Key();
$firstUserId = new Crypt_GPG_UserId(array(
'name' => 'Alice',
'comment' => 'shipping',
'email' => 'alice@example.com'
));
$key->addUserId($firstUserId);
$secondUserId = new Crypt_GPG_UserId(array(
'name' => 'Bob',
'comment' => 'receiving',
'email' => 'bob@example.com'
));
$key->addUserId($secondUserId);
$userIds = $key->getUserIds();
$this->assertTrue(is_array($userIds),
'Failed to assert returned user ids is an array.');
$this->assertEquals(2, count($userIds),
'Failed to assert number of returned user ids is the same as ' .
'the number of user ids added.');
$this->assertContainsOnly('Crypt_GPG_UserId', $userIds, false,
'Failed to assert all returned user ids are Crypt_GPG_UserId ' .
'objects.');
$this->assertArrayHasKey(0, $userIds);
$this->assertEquals($userIds[0], $firstUserId,
'Failed to assert the first user id is the same as the first ' .
'added user id.');
$this->assertArrayHasKey(1, $userIds);
$this->assertEquals($userIds[1], $secondUserId,
'Failed to assert the second user id is the same as the second ' .
'added user id.');
}
// }}}
// {{{ testGetPrimaryKey()
/**
* @group accessors
*/
public function testGetPrimaryKey()
{
$key = new Crypt_GPG_Key();
$firstSubKey = new Crypt_GPG_SubKey(array(
'id' => 'C097D9EC94C06363',
'algorithm' => Crypt_GPG_SubKey::ALGORITHM_DSA,
'fingerprint' => '8D2299D9C5C211128B32BBB0C097D9EC94C06363',
'length' => 1024,
'creation' => 1221785805,
'expiration' => 0,
'canSign' => true,
'canEncrypt' => false,
'hasPrivate' => true
));
$key->addSubKey($firstSubKey);
$secondSubKey = new Crypt_GPG_SubKey(array(
'id' => '9F93F9116728EF12',
'algorithm' => Crypt_GPG_SubKey::ALGORITHM_ELGAMAL_ENC,
'fingerprint' => 'C9C65B3BBF040E40D0EA27B79F93F9116728EF12',
'length' => 2048,
'creation' => 1221785821,
'expiration' => 0,
'canSign' => false,
'canEncrypt' => true,
'hasPrivate' => true
));
$key->addSubKey($secondSubKey);
$primaryKey = $key->getPrimaryKey();
$this->assertEquals($firstSubKey, $primaryKey,
'Failed to assert the primary key is the same as the first added ' .
'sub-key.');
}
// }}}
// {{{ testCanSign_none()
/**
* @group accessors
*/
public function testCanSign_none()
{
$key = new Crypt_GPG_Key();
$subKey = new Crypt_GPG_SubKey(array('canSign' => false));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canSign' => false));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canSign' => false));
$key->addSubKey($subKey);
$this->assertFalse($key->canSign());
}
// }}}
// {{{ testCanSign_one()
/**
* @group accessors
*/
public function testCanSign_one()
{
$key = new Crypt_GPG_Key();
$subKey = new Crypt_GPG_SubKey(array('canSign' => false));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canSign' => false));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canSign' => true));
$key->addSubKey($subKey);
$this->assertTrue($key->canSign());
}
// }}}
// {{{ testCanSign_all()
/**
* @group accessors
*/
public function testCanSign_all()
{
$key = new Crypt_GPG_Key();
$subKey = new Crypt_GPG_SubKey(array('canSign' => true));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canSign' => true));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canSign' => true));
$key->addSubKey($subKey);
$this->assertTrue($key->canSign());
}
// }}}
// {{{ testCanEncrypt_none()
/**
* @group accessors
*/
public function testCanEncrypt_none()
{
$key = new Crypt_GPG_Key();
$subKey = new Crypt_GPG_SubKey(array('canEncrypt' => false));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canEncrypt' => false));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canEncrypt' => false));
$key->addSubKey($subKey);
$this->assertFalse($key->canEncrypt());
}
// }}}
// {{{ testCanEncrypt_one()
/**
* @group accessors
*/
public function testCanEncrypt_one()
{
$key = new Crypt_GPG_Key();
$subKey = new Crypt_GPG_SubKey(array('canEncrypt' => false));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canEncrypt' => false));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canEncrypt' => true));
$key->addSubKey($subKey);
$this->assertTrue($key->canEncrypt());
}
// }}}
// {{{ testCanEncrypt_all()
/**
* @group accessors
*/
public function testCanEncrypt_all()
{
$key = new Crypt_GPG_Key();
$subKey = new Crypt_GPG_SubKey(array('canEncrypt' => true));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canEncrypt' => true));
$key->addSubKey($subKey);
$subKey = new Crypt_GPG_SubKey(array('canEncrypt' => true));
$key->addSubKey($subKey);
$this->assertTrue($key->canEncrypt());
}
// }}}
// {{{ test__toString()
/**
* @group accessors
*/
public function test__toString()
{
$key = new Crypt_GPG_Key();
$firstSubKey = new Crypt_GPG_SubKey(array(
'id' => 'C097D9EC94C06363',
'algorithm' => Crypt_GPG_SubKey::ALGORITHM_DSA,
'fingerprint' => '8D2299D9C5C211128B32BBB0C097D9EC94C06363',
'length' => 1024,
'creation' => 1221785805,
'expiration' => 0,
'canSign' => true,
'canEncrypt' => false,
'hasPrivate' => true
));
$this->assertSame((string) $key, '');
$key->addSubKey($firstSubKey);
$this->assertSame((string) $key, $firstSubKey->getId());
}
// }}}
// mutators
// {{{ testAddSubKey()
/**
* @group mutators
*/
public function testAddSubKey()
{
$key = new Crypt_GPG_Key();
$subKeys = $key->getSubKeys();
$this->assertTrue(is_array($subKeys),
'Failed to assert returned sub-keys is an array.');
$this->assertEquals(0, count($subKeys),
'Failed to assert there are no sub-keys.');
// add first sub-key
$firstSubKey = new Crypt_GPG_SubKey(array(
'id' => 'C097D9EC94C06363',
'algorithm' => Crypt_GPG_SubKey::ALGORITHM_DSA,
'fingerprint' => '8D2299D9C5C211128B32BBB0C097D9EC94C06363',
'length' => 1024,
'creation' => 1221785805,
'expiration' => 0,
'canSign' => true,
'canEncrypt' => false,
'hasPrivate' => true
));
$key->addSubKey($firstSubKey);
$subKeys = $key->getSubKeys();
$this->assertTrue(is_array($subKeys),
'Failed to assert returned sub-keys is an array.');
$this->assertEquals(1, count($subKeys),
'Failed to assert number of returned sub-keys is the same as ' .
'the number of sub-keys added.');
$this->assertContainsOnly('Crypt_GPG_SubKey', $subKeys, false,
'Failed to assert all returned sub-keys are Crypt_GPG_SubKey ' .
'objects.');
$this->assertArrayHasKey(0, $subKeys);
$this->assertEquals($subKeys[0], $firstSubKey,
'Failed to assert the first sub-key is the same as the first ' .
'added sub-key.');
// add second sub-key
$secondSubKey = new Crypt_GPG_SubKey(array(
'id' => '9F93F9116728EF12',
'algorithm' => Crypt_GPG_SubKey::ALGORITHM_ELGAMAL_ENC,
'fingerprint' => 'C9C65B3BBF040E40D0EA27B79F93F9116728EF12',
'length' => 2048,
'creation' => 1221785821,
'expiration' => 0,
'canSign' => false,
'canEncrypt' => true,
'hasPrivate' => true
));
$key->addSubKey($secondSubKey);
$subKeys = $key->getSubKeys();
$this->assertTrue(is_array($subKeys),
'Failed to assert returned sub-keys is an array.');
$this->assertEquals(2, count($subKeys),
'Failed to assert number of returned sub-keys is the same as ' .
'the number of sub-keys added.');
$this->assertContainsOnly('Crypt_GPG_SubKey', $subKeys, false,
'Failed to assert all returned sub-keys are Crypt_GPG_SubKey ' .
'objects.');
$this->assertArrayHasKey(0, $subKeys);
$this->assertEquals($subKeys[0], $firstSubKey,
'Failed to assert the first sub-key is the same as the first ' .
'added sub-key.');
$this->assertArrayHasKey(1, $subKeys);
$this->assertEquals($subKeys[1], $secondSubKey,
'Failed to assert the second sub-key is the same as the second ' .
'added sub-key.');
}
// }}}
// {{{ testAddUserId()
/**
* @group mutators
*/
public function testAddUserId()
{
$key = new Crypt_GPG_Key();
$userIds = $key->getUserIds();
$this->assertTrue(is_array($userIds),
'Failed to assert returned user ids is an array.');
$this->assertEquals(0, count($userIds),
'Failed to assert there are no user ids.');
// add first user id
$firstUserId = new Crypt_GPG_UserId(array(
'name' => 'Alice',
'comment' => 'shipping',
'email' => 'alice@example.com'
));
$key->addUserId($firstUserId);
$userIds = $key->getUserIds();
$this->assertTrue(is_array($userIds),
'Failed to assert returned user ids is an array.');
$this->assertEquals(1, count($userIds),
'Failed to assert number of returned user ids is the same as ' .
'the number of user ids added.');
$this->assertContainsOnly('Crypt_GPG_UserId', $userIds, false,
'Failed to assert all returned user ids are Crypt_GPG_UserId ' .
'objects.');
$this->assertArrayHasKey(0, $userIds);
$this->assertEquals($userIds[0], $firstUserId,
'Failed to assert the first user id is the same as the first ' .
'added user id.');
// add second user id
$secondUserId = new Crypt_GPG_UserId(array(
'name' => 'Bob',
'comment' => 'receiving',
'email' => 'bob@example.com'
));
$key->addUserId($secondUserId);
$userIds = $key->getUserIds();
$this->assertTrue(is_array($userIds),
'Failed to assert returned user ids is an array.');
$this->assertEquals(2, count($userIds),
'Failed to assert number of returned user ids is the same as ' .
'the number of user ids added.');
$this->assertContainsOnly('Crypt_GPG_UserId', $userIds, false,
'Failed to assert all returned user ids are Crypt_GPG_UserId ' .
'objects.');
$this->assertArrayHasKey(0, $userIds);
$this->assertEquals($userIds[0], $firstUserId,
'Failed to assert the first user id is the same as the first ' .
'added user id.');
$this->assertArrayHasKey(1, $userIds);
$this->assertEquals($userIds[1], $secondUserId,
'Failed to assert the second user id is the same as the second ' .
'added user id.');
}
// }}}
// fluent interface
// {{{ testFluentInterface
/**
* @group fluent
*/
public function testFluentInterface()
{
$key = new Crypt_GPG_Key();
// add first sub-key
$firstSubKey = new Crypt_GPG_SubKey(array(
'id' => 'C097D9EC94C06363',
'algorithm' => Crypt_GPG_SubKey::ALGORITHM_DSA,
'fingerprint' => '8D2299D9C5C211128B32BBB0C097D9EC94C06363',
'length' => 1024,
'creation' => 1221785805,
'expiration' => 0,
'canSign' => true,
'canEncrypt' => false,
'hasPrivate' => true
));
$returnedKey = $key->addSubKey($firstSubKey);
$this->assertEquals(
$key,
$returnedKey,
'Failed asserting fluent interface works for addSubKey() method.'
);
$firstUserId = new Crypt_GPG_UserId(array(
'name' => 'Alice',
'comment' => 'shipping',
'email' => 'alice@example.com'
));
$returnedKey = $key->addUserId($firstUserId);
$this->assertEquals(
$key,
$returnedKey,
'Failed asserting fluent interface works for addUserId() method.'
);
}
// }}}
}
?>