<?php
/**
* Test methods for the P4 Counter class.
*
* @copyright 2012 Perforce Software. All rights reserved.
* @license Please see LICENSE.txt in top-level folder of this distribution.
* @version <release>/<patch>
*/
namespace P4Test\Counter;
use P4Test\TestCase;
use P4\Counter\Counter;
use P4\Connection\Connection;
use P4\Connection\Exception\CommandException;
class Test extends TestCase
{
/**
* Test fetchAll method
*/
public function testFetchAll()
{
$entries = array(
'test1' => 'value1',
'test2' => 'value2',
'test3' => 'value3',
'test4' => 'value4',
'test5' => 'value5',
'test6' => 'value6',
);
$startEntries = array_combine(
Counter::fetchAll()->invoke('getId'),
Counter::fetchAll()->invoke('get')
);
if (USE_UNICODE_P4D) {
$expectedCounters = array('unicode', 'upgrade');
} else {
$expectedCounters = array('upgrade');
}
$this->assertSame(
$expectedCounters,
array_keys($startEntries),
'Expected list of counters to start'
);
// prime the data
foreach ($entries as $id => $value) {
$counter = new Counter;
$counter->setId($id)->set($value);
}
// merge in and sort the startEntries
$entries = array_merge($entries, $startEntries);
ksort($entries);
// run a fetch all and validate result
$counters = Counter::fetchAll();
foreach ($counters as $counter) {
$this->assertTrue(
array_key_exists($counter->getId(), $entries),
'Expected counter '.$counter->getId().' to exist in our entries array'
);
$this->assertSame(
$entries[$counter->getId()],
$counter->get(),
'Expected matching counter value for entry '.$counter->getId()
);
}
// Verify fetchAll with made up option works
$this->assertSame(
count($entries),
count(Counter::fetchAll(array('fooBar' => true))),
'Expected fetch all with made up option to match'
);
// Verify full FETCH_MAXIMUM works
$this->assertSame(
array_slice(array_keys($entries), 0, 3),
Counter::fetchAll(array(Counter::FETCH_MAXIMUM => '3'))->invoke('getId'),
'Expected fetch all with Maximum to match'
);
}
/**
* Test fetchAll with 'after' works
*/
public function testFetchAllAfter()
{
$entries = array(
'test1' => 'value1',
'test2' => 'value2',
'test3' => 'value3',
'test4' => 'value4',
'test5' => 'value5',
'test6' => 'value6',
);
$startEntries = array_combine(
Counter::fetchAll()->invoke('getId'),
Counter::fetchAll()->invoke('get')
);
// prime the data
foreach ($entries as $id => $value) {
$counter = new Counter;
$counter->setId($id)->set($value);
}
$after = Counter::fetchAll(
array(
Counter::FETCH_BY_NAME => 'test*',
Counter::FETCH_AFTER => 'test3'
)
);
$this->assertSame(
array_slice(array_keys($entries), 3),
$after->invoke('getId'),
'expected results to start after test3'
);
}
/**
* Ensure calling fetchAll() with FETCH_BY_NAME flag works.
*/
public function testFetchAllWithOptions()
{
// add counters to test
$counters = array(
'testcounter1',
'testcounter2',
'testcounter3',
'testa',
'testb',
'testc',
'counter1',
'counter2',
'testcounter4'
);
foreach ($counters as $id) {
$counter = new Counter;
$counter->setId($id)
->set(1);
}
// define tests
$tests = array(
array(
'pattern' => 'testc',
'expected' => array(
'testc'
)
),
array(
'pattern' => 'testc*',
'expected' => array(
'testcounter1',
'testcounter2',
'testcounter3',
'testc',
'testcounter4'
)
),
array(
'pattern' => '*stc*',
'expected' => array(
'testcounter1',
'testcounter2',
'testcounter3',
'testcounter4',
'testc'
)
)
);
// run tests
foreach ($tests as $test) {
$options = array(
Counter::FETCH_BY_NAME => $test['pattern']
);
$result = Counter::fetchAll($options)->invoke('getId');
// sort resulting arrays as counters may come in different order
// from the server
sort($result);
sort($test['expected']);
$this->assertSame(
$test['expected'],
$result
);
}
}
/**
* Test calling set without an ID
*/
public function testSetNoId()
{
try {
$counter = new Counter;
$counter->set('test');
$this->fail('unexpected success');
} catch (\PHPUnit\Framework\AssertionFailedError $e) {
$this->fail($e->getMessage());
} catch (\P4\Exception $e) {
$this->assertSame(
"Cannot set value. No id has been set.",
$e->getMessage(),
'unexpected exception message'
);
} catch (\Exception $e) {
$this->fail(': unexpected exception ('. get_class($e) .') '. $e->getMessage());
}
}
/**
* Test the get value function
*/
public function testGetSet()
{
$counter = new Counter();
$counter->setId('test')->set('testValue');
$counter = Counter::fetch('test');
$this->assertSame(
'test',
$counter->getId(),
'Expected matching Id'
);
$this->assertSame(
'testValue',
$counter->get(),
'Expected matching value'
);
Counter::fetch('test')->set('testValue2');
$this->assertSame(
'testValue',
$counter->get(),
'Expected cached value after outside modification'
);
$this->assertSame(
'testValue2',
$counter->get(true),
'Expected matching value after outside modification'
);
$counter = new Counter;
$this->assertSame(
null,
$counter->get(),
'Expected no-id counter value to match'
);
$counter->setId('newCounter');
$this->assertSame(
null,
$counter->get(),
'Expected non-existent counter value to match'
);
}
/**
* Test a good call to fetch
*/
public function testFetch()
{
$counter = new Counter();
$counter->setId('test')->set('testValue');
$counter = Counter::fetch('test');
$this->assertSame(
'test',
$counter->getId(),
'Expected matching Id'
);
$this->assertSame(
'testValue',
$counter->get(),
'Expected matching value'
);
}
/**
* Test fetch of non-existent record
*/
public function testNonExistentFetch()
{
// ensure fetch fails for a non-existant counter.
try {
Counter::fetch('alskdfj2134');
$this->fail("Fetch should fail for a non-existant counter.");
} catch (\PHPUnit\Framework\AssertionFailedError $e) {
$this->fail($e->getMessage());
} catch (\P4\Exception $e) {
$this->assertSame(
"Cannot fetch entry. Id does not exist.",
$e->getMessage(),
'unexpected exception message'
);
} catch (\Exception $e) {
$this->fail(': unexpected exception ('. get_class($e) .') '. $e->getMessage());
}
}
/**
* Test fetch of bad id record
*/
public function testBadIdFetch()
{
// ensure fetch fails for a bad Id.
try {
Counter::fetch('te/st');
$this->fail("Fetch should fail for a il-formated counter.");
} catch (\PHPUnit\Framework\AssertionFailedError $e) {
$this->fail($e->getMessage());
} catch (\InvalidArgumentException $e) {
$this->assertSame(
"Must supply a valid id to fetch.",
$e->getMessage(),
'unexpected exception message'
);
} catch (\Exception $e) {
$this->fail(': unexpected exception ('. get_class($e) .') '. $e->getMessage());
}
}
/**
* test bad values for setId
*/
public function testBadSetId()
{
$tests = array(
array(
'title' => __LINE__." leading minus",
'value' => '-test'
),
array(
'title' => __LINE__." forward slash",
'value' => 'te/st'
),
array(
'title' => __LINE__." all numeric",
'value' => '1234'
),
);
foreach ($tests as $test) {
// ensure fetch fails for a non-existant counter.
try {
$counter = new Counter;
$counter->setId($test['value']);
$this->fail($test['title'].': unexpected success');
} catch (\PHPUnit\Framework\AssertionFailedError $e) {
$this->fail($e->getMessage());
} catch (\InvalidArgumentException $e) {
$this->assertSame(
"Cannot set id. Id is invalid.",
$e->getMessage(),
$test['title'].': unexpected exception message'
);
} catch (\Exception $e) {
$this->fail($test['title'].': : unexpected exception ('. get_class($e) .') '. $e->getMessage());
}
}
}
/**
* Test exists
*/
public function testExists()
{
// ensure id-exists returns false for ill formatted counter
$this->assertFalse(Counter::exists("-alsdjf"), "Leading - counter id should not exist.");
$this->assertFalse(Counter::exists("als/djf"), "Forward slash counter id should not exist.");
// ensure id-exists returns false for non-existant counter
$this->assertFalse(Counter::exists("alsdjf"), "Given counter id should not exist.");
// create counter and ensure it exists.
$group = new Counter;
$group->setId('test')
->set('tester');
$this->assertTrue(Counter::exists("test"), "Given counter id should exist.");
}
/**
* Test the increment function
*/
public function testIncrement()
{
$counter = new Counter;
// Test counter that already exists, starting at 0
$counter->setId('existing')->set(0);
$this->assertSame(
"1",
$counter->increment(),
'Expected matching value when starting at 0'
);
$this->assertSame(
"1",
Counter::fetch('existing')->get(),
'Expected matching value when starting at 0 on independent fetch'
);
$this->assertSame(
"2",
$counter->increment(),
'Expected matching value after second increment'
);
$this->assertSame(
"2",
Counter::fetch('existing')->get(),
'Expected matching value after second increment on independent fetch'
);
// Test counter that already exists starting at 1
$counter->set(1);
$this->assertSame(
"2",
$counter->increment(),
'Expected matching value when starting at 2'
);
// Test increment will create a counter if it doesn't exist
$counter = new Counter;
$counter->setId('newCounter');
$this->assertSame(
"1",
$counter->increment(),
'Expected matching value for new counter'
);
$this->assertSame(
"1",
Counter::fetch('newCounter')->get(),
'Expected matching value for new counter on independent fetch'
);
}
/**
* Test the increment function with bad starting value
*/
public function testBadIncrement()
{
// Test counter that already exists, starting at 'bad'
try {
$counter = new Counter;
$counter->setId('existing')->set('bad');
$counter->increment();
$this->fail("Increment should fail for a il-valued counter.");
} catch (\PHPUnit\Framework\AssertionFailedError $e) {
$this->fail($e->getMessage());
} catch (\P4\Exception $e) {
$this->assertSame(
"Command failed: Can't increment counter 'existing' - value is not numeric.",
$e->getMessage(),
'unexpected exception message'
);
} catch (\Exception $e) {
$this->fail(': unexpected exception ('. get_class($e) .') '. $e->getMessage());
}
}
/**
* Test the delete function
*/
public function testDelete()
{
$counter = new Counter;
$counter->setId('test')->set('testValue');
$this->assertTrue(Counter::exists('test'), 'expected test entry to exist');
$counter->delete('test');
$this->assertFalse(Counter::exists('test'), 'expected test entry was deleted');
$counters = Counter::fetchAll();
$this->assertFalse(
in_array('test', $counters->invoke('getId')),
'expected deleted entry would not be returned by fetchall'
);
}
/**
* Test the delete function with non-existent id
*/
public function testMissingIdDelete()
{
try {
$counter = new Counter;
$counter->setId('missing')->delete();
$this->fail("Delete should fail for a missing counter.");
} catch (\PHPUnit\Framework\AssertionFailedError $e) {
$this->fail($e->getMessage());
} catch (\P4\Exception $e) {
$this->assertSame(
"Cannot delete entry. Id does not exist.",
$e->getMessage(),
'unexpected exception message'
);
} catch (\Exception $e) {
$this->fail(': unexpected exception ('. get_class($e) .') '. $e->getMessage());
}
}
/**
* Test the delete function with no id
*/
public function testNoIdDelete()
{
try {
$counter = new Counter;
$counter->delete();
$this->fail("Delete should fail when no id is set.");
} catch (\PHPUnit\Framework\AssertionFailedError $e) {
$this->fail($e->getMessage());
} catch (\P4\Exception $e) {
$this->assertSame(
"Cannot delete. No id has been set.",
$e->getMessage(),
'unexpected exception message'
);
} catch (\Exception $e) {
$this->fail(': unexpected exception ('. get_class($e) .') '. $e->getMessage());
}
}
/**
* Test the force option.
*/
public function testForce()
{
// ensure 'security' counter protected.
$counter = new Counter;
$counter->setId('security');
try {
$counter->set(1);
$this->fail("Expected exception");
} catch (CommandException $e) {
$this->assertTrue(true);
}
// set a protected counter.
$counter->set(1, true);
$this->assertSame(1, (int) $counter->get(), "Expected security level 1");
// now try to delete it.
try {
$counter->delete();
$this->fail("Expected exception");
} catch (CommandException $e) {
$this->assertTrue(true);
}
// delete with force.
$counter->delete(true);
$this->assertFalse(
Counter::exists('security'),
"Expected 'security' counter to be deleted."
);
}
}