<?php
/**
* Test methods for the P4 api interface.
*
* @copyright 2012 Perforce Software. All rights reserved.
* @license Please see LICENSE.txt in top-level folder of this distribution.
* @version <release>/<patch>
*/
namespace P4Test\Connection;
use P4Test\TestCase;
use P4\Connection\Connection;
use P4\Connection\Exception\LoginException;
use P4\Spec\User;
abstract class InterfaceTest extends TestCase
{
/**
* Test that connecting / disconnecting works.
*/
public function testConnectAndDisconnect()
{
$this->p4->connect();
$this->assertTrue($this->p4->isConnected());
$this->p4->disconnect();
$this->assertFalse($this->p4->isConnected());
// try connecting to a bogus server.
// should throw an exception.
$this->p4->setPort('laskdjfskdlafj:4231');
try {
$this->p4->connect();
$this->fail('Expect failure with a bogus server.');
} catch (\P4\Connection\Exception\ConnectException $e) {
$this->assertTrue(true);
} catch (\Exception $e) {
$this->fail('Unexpected exception: '. $e->getMessage());
}
}
/**
* Test setting/getting port.
*/
public function testPort()
{
$this->p4->setPort('hostname.something.com:5555');
$this->assertSame('hostname.something.com:5555', $this->p4->getPort(), 'Expect just-set port');
// test port via constructor.
$type = get_class($this->p4);
$p4 = Connection::factory('1234', null, null, null, null, $type);
$this->assertSame($p4->getPort(), '1234', 'Expect factory-set port.');
// getPort should always return a string
$this->p4->setPort(3333);
$this->assertTrue(is_string($this->p4->getPort()));
$this->assertSame($this->p4->getPort(), '3333', 'Expect correct string.');
$this->assertEquals($this->p4->getPort(), 3333, 'Expect correct numeric value.');
$this->assertNotSame($this->p4->getPort(), 3333, 'Expect port to be non-numeric.');
}
/**
* Test setting/getting user.
*/
public function testUser()
{
$this->p4->setUser('john_doe');
$this->assertSame($this->p4->getUser(), 'john_doe', 'Expected user.');
// test setting user via constructor.
$type = get_class($this->p4);
$p4 = Connection::factory(null, 'jdoe', null, null, null, $type);
$this->assertSame($p4->getUser(), 'jdoe', 'Expected factory user.');
// test user name acceptance
$tests = array(
// valid cases
array('name' => 'jdoe', 'valid' => true),
array('name' => 'jdoe.', 'valid' => true),
array('name' => 'jdoe..', 'valid' => true),
array('name' => 'j_doe', 'valid' => true),
array('name' => 'jdoe"', 'valid' => true),
array('name' => "jdoe'", 'valid' => true),
array('name' => 'jdoe&', 'valid' => true),
array('name' => 'jdoe1', 'valid' => true),
array('name' => 'jdoe%%', 'valid' => true),
array('name' => 'j/doe', 'valid' => true),
// invalid cases
array(
'name' => '1234',
'valid' => false,
'error' => 'Username: Purely numeric values are not allowed.'
),
array(
'name' => 'john doe',
'valid' => false,
'error' => 'Username: Whitespace is not permitted.'
),
array(
'name' => 'jdoe*',
'valid' => false,
'error' => "Username: Wildcards ('*', '...') are not permitted."
),
array(
'name' => 'jdoe...',
'valid' => false,
'error' => "Username: Wildcards ('*', '...') are not permitted."
),
array(
'name' => 'jdoe#',
'valid' => false,
'error' => "Username: Revision characters ('#', '@') are not permitted."
),
array(
'name' => 'jdoe@',
'valid' => false,
'error' => "Username: Revision characters ('#', '@') are not permitted."
),
);
foreach ($tests as $test) {
try {
$this->p4->setUser($test['name']);
if (!$test['valid']) {
$this->fail("Expected '". $test['name'] ."' to fail.");
}
} catch (\P4\Exception $e) {
if ($test['valid']) {
$this->fail("Expected '". $test['name'] ."' to succeed: ". $e->getMessage());
} else {
$this->assertEquals(
$test['error'],
$e->getMessage(),
'Expected error message'
);
}
} catch (\Exception $e) {
$this->fail('Unexpected exception: '. $e->getMessage());
}
}
}
/**
* Test setting/getting client.
*/
public function testClient()
{
$this->p4->setClient('test-client');
$this->assertSame('test-client', $this->p4->getClient(), 'Expected client.');
$this->assertNotSame('blah', $this->p4->getClient(), 'Unexpected client.');
// test setting client via constructor.
$type = get_class($this->p4);
$p4 = Connection::factory(null, null, 'jdoes_client', null, null, $type);
$this->assertSame($p4->getClient(), 'jdoes_client', 'Expected factory client.');
// test user name acceptance
$tests = array(
// valid cases
array('client' => 'johnsclient', 'valid' => true),
array('client' => 'johnsClient', 'valid' => true),
array('client' => 'johns_client', 'valid' => true),
array('client' => 'johns_client.', 'valid' => true),
array('client' => 'johns_client..', 'valid' => true),
array('client' => 'johns_client"', 'valid' => true),
array('client' => "johns_client'", 'valid' => true),
array('client' => 'johns_client&', 'valid' => true),
array('client' => 'johns_client1', 'valid' => true),
// invalid cases
array(
'client' => '1234',
'valid' => false,
'error' => 'Client name: Purely numeric values are not allowed.'
),
array(
'client' => 'johns client',
'valid' => false,
'error' => 'Client name: Whitespace is not permitted.'
),
array(
'client' => 'johns_client*',
'valid' => false,
'error' => "Client name: Wildcards ('*', '...') are not permitted."
),
array(
'client' => 'johns_client...',
'valid' => false,
'error' => "Client name: Wildcards ('*', '...') are not permitted."
),
array(
'client' => 'johns_client%%',
'valid' => false,
'error' => "Client name: Positional specifiers ('%%x') are not permitted."
),
array(
'client' => 'johns_client#',
'valid' => false,
'error' => "Client name: Revision characters ('#', '@') are not permitted."
),
array(
'client' => 'johns_client@',
'valid' => false,
'error' => "Client name: Revision characters ('#', '@') are not permitted."
),
);
foreach ($tests as $test) {
try {
$this->p4->setClient($test['client']);
if (!$test['valid']) {
$this->fail("Expected '". $test['client'] ."' to fail.");
}
} catch (\P4\Exception $e) {
if ($test['valid']) {
$this->fail("Expected '". $test['client'] ."' to succeed: ". $e->getMessage());
} else {
$this->assertEquals(
$test['error'],
$e->getMessage(),
'Expected error message'
);
}
} catch (\Exception $e) {
$this->fail('Unexpected exception: '. $e->getMessage());
}
}
}
/**
* Test setting/getting password.
*/
public function testPassword()
{
$this->p4->setPassword('test-password');
$this->assertSame('test-password', $this->p4->getPassword());
$this->assertNotSame('blah', $this->p4->getPassword());
// test setting password via constructor.
$type = get_class($this->p4);
$p4 = Connection::factory(null, null, null, 'secret key', null, $type);
$this->assertTrue($p4->getPassword() == 'secret key');
}
/**
* Test setting/getting ticket.
*/
public function testTicket()
{
$this->p4->setTicket('ALKSJROIEL2134235');
$this->assertSame('ALKSJROIEL2134235', $this->p4->getTicket(), 'Expected ticket.');
$this->assertNotSame('blah', $this->p4->getTicket(), 'Unexpected ticket.');
// test setting ticket via constructor.
$type = get_class($this->p4);
$p4 = Connection::factory(null, null, null, null, 'ALKSJROIEL2134235', $type);
$this->assertSame($p4->getTicket(), 'ALKSJROIEL2134235', 'Expected factory ticket.');
}
/**
* Test Connection identity.
*/
public function testConnectionIdentity()
{
$identity = $this->p4->getConnectionIdentity();
$this->assertTrue(isset($identity['name']), 'Expect name is set.');
$this->assertTrue(isset($identity['platform']), 'Expect platform is set.');
$this->assertTrue(isset($identity['version']), 'Expect version is set.');
$this->assertTrue(isset($identity['build']), 'Expect build is set.');
$this->assertTrue(isset($identity['apiversion']), 'Expect apiversion is set.');
$this->assertTrue(isset($identity['apibuild']), 'Expect apibuild is set.');
$this->assertTrue(isset($identity['date']), 'Expect date is set.');
$this->assertTrue(isset($identity['original']), 'Expect original is set.');
}
/**
* Test get info.
*/
public function testGetInfo()
{
$info = $this->p4->getInfo();
$this->assertTrue(is_array($info), 'Expect info to be an array.');
$this->assertTrue(isset($info['userName']), 'Expect userName is set.');
$this->assertTrue(isset($info['clientName']), 'Expect clientName is set.');
$this->assertTrue(isset($info['clientCwd']), 'Expect clientCwd is set.');
$this->assertTrue(isset($info['clientHost']), 'Expect clientHost is set.');
$this->assertTrue(isset($info['clientAddress']), 'Expect clientAddress is set.');
$this->assertTrue(isset($info['serverAddress']), 'Expect serverAddress is set.');
$this->assertTrue(isset($info['serverRoot']), 'Expect serverRoot is set.');
$this->assertTrue(isset($info['serverDate']), 'Expect serverDate is set.');
$this->assertTrue(isset($info['serverUptime']), 'Expect serverUptime is set.');
$this->assertTrue(isset($info['serverVersion']), 'Expect serverVersion is set.');
$this->assertTrue(isset($info['serverLicense']), 'Expect serverLicense is set.');
// test that cache is cleared when connection params change.
$this->p4->setClient('a-client');
$info2 = $this->p4->getInfo();
$this->assertNotEquals(serialize($info), serialize($info2), 'Unexpected client match.');
}
/**
* Test client root accessor.
*/
public function testGetClientRoot()
{
$root = $this->p4->getClientRoot();
$info = $this->p4->getInfo();
if ($root) {
$this->assertSame($root, $info['clientRoot'], 'Expect root to match info.');
} else {
$this->assertFalse(isset($info['clientRoot']), 'Unexpected clientRoot with no root.');
}
}
/**
* Test login/authentication.
*/
public function testLogin()
{
$this->assertTrue(
$this->p4->isAuthenticated(),
'Expected user to be authenticated'
);
try {
$ticket = $this->p4->login();
$this->assertTrue(strlen($ticket) > 0, "Expected login ticket");
} catch (LoginException $e) {
$this->fail("Expected login to succeed");
}
try {
$this->p4->setPassword('alskdfj23523');
$ticket = $this->p4->login();
$this->fail("Expected login failure");
} catch (LoginException $e) {
$this->assertSame(
LoginException::CREDENTIAL_INVALID,
$e->getCode(),
"Expected credential invalid login exception"
);
}
// erase the successful login ticket so that the password is re-evaluated
$this->p4->setTicket(null);
$this->assertFalse(
$this->p4->isAuthenticated(),
'Expected user not to be authenticated'
);
try {
$this->p4->setUser('laksdjflkasdfj');
$ticket = $this->p4->login();
$this->fail("Expected login failure");
} catch (LoginException $e) {
$this->assertSame(
LoginException::IDENTITY_NOT_FOUND,
$e->getCode(),
"Expected identity not found login exception"
);
}
}
/**
* Test running a command.
*/
public function testRun()
{
$result = $this->p4->run('users', null, null, false);
$this->assertFalse($result->isTagged(), 'Expect untagged result.');
$result = $this->p4->run('users');
$this->assertTrue($result->isTagged(), 'Expect tagger result.');
$data = $result->getData();
$this->assertSame(
serialize($result->getData(0)),
serialize($data[0]),
'Expect getData match.'
);
$this->assertSame(
$result->getData(0, 'User'),
$data[0]['User'],
'Expect getData User match.'
);
$this->assertSame($result->getCommand(), 'users', 'Expect command match.');
}
/**
* Test super user detection.
*/
public function testSuperUser()
{
// instance _p4 object runs as super.
$this->assertTrue($this->p4->isSuperUser(), 'Connection should have super user privs.');
// create un-privileged user.
$user = $this->p4->run('user', array('-o', 'jdoe'));
$this->p4->run('user', array('-i', '-f'), $user->getData(-1));
// connect as un-privileged user.
$class = get_class($this->p4);
$p4 = new $class;
$p4->setUser('jdoe');
$p4->setPort($this->p4->getPort());
$p4->connect();
$this->assertFalse($p4->isSuperUser(), 'Connection should not have super user privs.');
}
/**
* Test the security level.
*/
public function testSecurityLevel()
{
// should be zero to start.
$this->assertTrue($this->p4->getSecurityLevel() == 0, "Expected security level zero");
$counter = new \P4\Counter\Counter;
$counter->setId('security');
// 1
$counter->set(1, true);
$this->assertTrue($this->p4->getSecurityLevel() == 1, "Expected security level one");
// 2
$counter->set(2, true);
// once the security counter is increased to 2, the current user's password must be reset.
// see the Perforce System Administrator's Guide, Chapter 3, Server Security Levels
// http://www.perforce.com/perforce/doc.current/manuals/p4sag/03_superuser.html#1081537
//
// Unfortunately, this doesn't work the way you'd hope. The desire would be to write
// something similar to:
//
// $user = \P4\Spec\User::fetch($this->p4->getUser())
// ->setPassword('testing321')
// ->save();
//
// Calling setPassword() invokes other Perforce commands prior to the password command
// (for lazy loading, verifying protections, etc.), and these commands will fail due
// to the password reset requirement.
//
// So, we need to directly execute the password command.
$newPassword = 'newPassword123';
$this->p4->run(
'password',
null,
array(
$this->p4->getPassword(),
$newPassword,
$newPassword
)
);
$this->p4->setPassword($newPassword);
$this->assertTrue($this->p4->getSecurityLevel() == 2, "Expected security level two");
// 3
$counter->set(3, true);
// must login.
$this->p4->login();
$this->assertTrue($this->p4->getSecurityLevel() == 3, "Expected security level three");
}
/**
* Test app name
*/
public function testAppName()
{
$root = $this->getP4Params('serverRoot');
$port = $this->p4->getPort() . ' -vrpc=3 -L ' . $root . '/test-log';
$p4 = Connection::factory(
$port,
$this->getP4Params('user'),
$this->getP4Params('client'),
$this->getP4Params('password')
);
// verify can set/get app name
$p4->setAppName('some-name');
$this->assertSame('some-name', $p4->getAppName());
// verify can set/get program name
$p4->setProgName('my-prog');
$this->assertSame('my-prog', $p4->getProgName());
// verify can set/get program version
$p4->setProgVersion('2013.1.WHATEVER/123456');
$this->assertSame('2013.1.WHATEVER/123456', $p4->getProgVersion());
// verify server sees app name
$p4->getInfo();
$log = file_get_contents($root . '/test-log');
$this->assertTrue(strpos($log, 'app = some-name') !== false, "Looking for app name in log.");
}
/**
* Test the service locator facilities of the connection
*/
public function testServiceLocator()
{
$p4 = $this->p4;
// should throw for non-existent services
try {
$p4->getService('foo');
$this->fail();
} catch (\P4\Connection\Exception\ServiceNotFoundException $e) {
$this->assertTrue(true);
}
// should require a object or callable
try {
$p4->setService('foo', 'bar');
$this->fail();
} catch (\InvalidArgumentException $e) {
$this->assertTrue(true);
}
// configure a basic service
$service = new \stdClass;
$service->value = true;
$p4->setService('foo', $service);
$this->assertSame($service, $p4->getService('foo'));
// configure a service factory
$factory = function ($p4, $name) {
$service = new \stdClass;
$service->p4 = $p4;
$service->name = $name;
return $service;
};
$p4->setService('baz', $factory);
$service = $p4->getService('baz');
$this->assertTrue($service instanceof \stdClass);
$this->assertSame($p4, $service->p4);
$this->assertSame('baz', $service->name);
// once created, service should be reused
$this->assertTrue($service === $p4->getService('baz'));
}
public function testIsAuthenticated()
{
$user = new User($this->p4);
$user->setId('jdoe');
$user->setPassword('abc123');
$user->setEmail('jdoe@example.com');
$user->setFullName('Jonathan H. Doe');
$user->save();
$user2 = new User($this->p4);
$user2->setId('jdoe2');
$user2->setEmail('jdoe2@example.com');
$user2->setFullName('Jonathan H. DEUX');
$user2->save();
// test valid password
$p4 = Connection::factory($this->p4->getPort(), 'jdoe', null, 'abc123');
$this->assertTrue($p4->isAuthenticated());
// test invalid password
$p4 = Connection::factory($this->p4->getPort(), 'jdoe', null, 'xyz789');
$this->assertFalse($p4->isAuthenticated());
// test valid ticket
$p4 = Connection::factory($this->p4->getPort(), 'jdoe', null, 'abc123');
$p4->login();
$p4->setPassword(null);
$this->assertNotNull($p4->getTicket());
$p4->setTicket($p4->getTicket());
$this->assertTrue($p4->isAuthenticated());
// test invalid ticket
$ticket = $p4->getTicket();
$p4->run('logout');
$p4->disconnect();
$this->assertFalse($p4->isAuthenticated());
// test edge case of valid blank password
$p4 = Connection::factory($this->p4->getPort(), 'jdoe2', null, null);
$this->assertTrue($p4->isAuthenticated());
// test edge case of invalid password (when login not required)
$p4 = Connection::factory($this->p4->getPort(), 'jdoe2', null, 'abc123');
$this->assertFalse($p4->isAuthenticated());
// test invalid ticket (recycling invalid ticket from above)
$p4 = Connection::factory($this->p4->getPort(), 'jdoe2', null, null, $ticket);
$this->assertFalse($p4->isAuthenticated());
}
}