/**
* Test a factory.
*
* @param string $className
* @return void
*/
public function testFactory($classname, array $requiredOptions, array $options)
{
// Test that the factory does not allow a scalar option.
try {
$classname::factory(0);
$this->testCase->fail('An expected exception was not thrown');
} catch (\Zend\Mvc\Router\Exception\InvalidArgumentException $e) {
$this->testCase->assertContains('factory expects an array or Traversable set of options', $e->getMessage());
}
// Test required options.
foreach ($requiredOptions as $option => $exceptionMessage) {
$testOptions = $options;
unset($testOptions[$option]);
try {
$classname::factory($testOptions);
$this->testCase->fail('An expected exception was not thrown');
} catch (\Zend\Mvc\Router\Exception\InvalidArgumentException $e) {
$this->testCase->assertContains($exceptionMessage, $e->getMessage());
}
}
// Create the route, will throw an exception if something goes wrong.
$classname::factory($options);
// Try the same with an iterator.
$classname::factory(new ArrayIterator($options));
}
/**
* @param \PHPUnit_Framework_TestCase $testCase
* @param array[] $expectedCalls
*/
function assertCalls(\PHPUnit_Framework_TestCase $testCase, array $expectedCalls)
{
if (array_values($expectedCalls) !== $expectedCalls) {
throw new \InvalidArgumentException('$expectedCalls must be a numeric array with no keys missing.');
}
$extractFunction = array($this, 'callGetFunction');
$testCase->assertEquals("\n" . implode("\n", array_map($extractFunction, $expectedCalls)) . "\n", "\n" . implode("\n", array_map($extractFunction, $this->calls)) . "\n");
$testCase->assertEquals($expectedCalls, $this->calls);
for ($i = 0; TRUE; ++$i) {
$actualCall = isset($this->calls[$i]) ? $this->calls[$i] : NULL;
$expectedCall = isset($expectedCalls[$i]) ? $expectedCalls[$i] : NULL;
if (NULL === $actualCall && NULL === $expectedCall) {
break;
}
if (NULL === $actualCall) {
$testCase->fail("Call {$i} missing.\nExpected: " . var_export($expectedCall, TRUE));
break;
}
if (NULL === $expectedCall) {
$testCase->fail("Call {$i} was not expected.\nActual: " . var_export($actualCall, TRUE));
break;
}
if ($actualCall !== $expectedCall) {
$testCase->fail("Call {$i} mismatch.\nExpected: " . var_export($expectedCall, TRUE) . "\nActual: " . var_export($this->calls[$i], TRUE));
break;
}
}
$testCase->assertEquals($expectedCalls, $this->calls);
}
/**
* Checks if deployment configuration has been changed by a test
*
* Changing deployment configuration violates isolation between tests, so further tests may become broken.
* To fix this issue, find out why this test changes deployment configuration.
* If this is intentional, then it must be reverted to the previous state within the test.
* After that, the application needs to be wiped out and reinstalled.
*
* @param \PHPUnit_Framework_TestCase $test
* @return void
*/
public function endTest(\PHPUnit_Framework_TestCase $test)
{
$config = $this->reader->load();
if ($this->config != $config) {
$error = "\n\nERROR: deployment configuration is corrupted. The application state is no longer valid.\n" . 'Further tests may fail.' . " This test failure may be misleading, if you are re-running it on a corrupted application.\n" . $test->toString() . "\n";
$test->fail($error);
}
}
/**
* Overwritten lime_test method
*
* @see lime_test#fail()
*/
public function fail($message = '')
{
// $this->testCase->fail could not be called here, otherwise
// the ugly exception
// "Exception thrown without a stack frame in Unknown on line 0" will be thrown
$this->testCase->fail($message);
// @TODO find a solution to be able calling the fail method directly
#$this->testCase->assertTrue(false, 'FAIL: ' . $message);
}
/**
* Assert that conformation message is present.
*
* @param Customer $customer
* @param CustomerAccountEdit $customerAccountEdit
* @return void
*/
public function processAssert(Customer $customer, CustomerAccountEdit $customerAccountEdit)
{
$validationMessages = $customerAccountEdit->getAccountInfoForm()->getValidationMessages($customer);
if (isset($validationMessages['password_confirmation'])) {
\PHPUnit_Framework_Assert::assertEquals(self::CONFIRMATION_MESSAGE, $validationMessages['password_confirmation'], 'Wrong password confirmation validation text message.');
} else {
\PHPUnit_Framework_TestCase::fail('Password confirmation validation message is absent.');
}
}
/**
* Asserts that the log buffer does NOT contain specified message
*
* @param string $expected Message subsctring
* @param string $errmsg The error message to display.
*
* @return void
*/
public function assertNotInLogs($message, $errorMsg = "Unexpected string '%s' found in logs:\n\n%s")
{
foreach ($this->getLines() as $log) {
if (false !== stripos($log, $message)) {
$this->testCase->fail(sprintf($errorMsg, $message, var_export($this->getLines(), true)));
}
}
$this->testCase->assertEquals(1, 1);
// increase number of positive assertions
}
public static function isSpecification(\PHPUnit_Framework_TestCase $test)
{
if ($test->getName(false) === NULL) {
throw new \PHPUnit_Framework_Exception('PHPUnit_Framework_TestCase::$name must not be NULL.');
}
try {
$class = new \ReflectionClass($test);
$method = $class->getMethod($test->getName(false));
$methodName = $method->getName();
return substr($methodName, -4) == 'Spec' || preg_match('/\\s+@spec\\s+/', $method->getDocComment());
} catch (\ReflectionException $e) {
$test->fail($e->getMessage());
}
return false;
}
public static function fail($message = '')
{
// save in a static var that this particular test has failed
// (but only if not called from subclass objects / multitests)
if (function_exists('debug_backtrace') && strtolower(get_called_class()) == 'localhosttests') {
$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
for ($i = 0; $i < count($trace); $i++) {
if (strpos($trace[$i]['function'], 'test') === 0) {
self::$failed_tests[$trace[$i]['function']] = true;
break;
}
}
}
parent::fail($message);
}
/**
* Analyze results of aggregated tests execution and complete test case appropriately
*
* @param array $results
* @param int $passed
* @return void
*/
protected function processResults(array $results, $passed)
{
$totalCountsMessage = sprintf('Passed: %d, Failed: %d, Incomplete: %d, Skipped: %d.', $passed, count($results['PHPUnit_Framework_AssertionFailedError']), count($results['PHPUnit_Framework_IncompleteTestError']), count($results['PHPUnit_Framework_SkippedTestError']));
if ($results['PHPUnit_Framework_AssertionFailedError']) {
$this->_testCase->fail($totalCountsMessage . PHP_EOL . implode(PHP_EOL, $results['PHPUnit_Framework_AssertionFailedError']));
}
if (!$results['PHPUnit_Framework_IncompleteTestError'] && !$results['PHPUnit_Framework_SkippedTestError']) {
return;
}
$message = $totalCountsMessage . PHP_EOL . implode(PHP_EOL, $results['PHPUnit_Framework_IncompleteTestError']) . PHP_EOL . implode(PHP_EOL, $results['PHPUnit_Framework_SkippedTestError']);
if ($results['PHPUnit_Framework_IncompleteTestError']) {
$this->_testCase->markTestIncomplete($message);
} elseif ($results['PHPUnit_Framework_SkippedTestError']) {
$this->_testCase->markTestSkipped($message);
}
}
/**
* testFiles
*
* Run simple syntax checks, if the filename ends with pass.php - expect it to pass
*/
public static function testProvider()
{
$tests = array();
$standard = dirname(dirname(__FILE__));
if (basename($standard) !== 'CakePHP') {
PHPUnit_Framework_TestCase::fail("The dirname for the standard must be CakePHP");
}
$iterator = new RecursiveIteratorIterator(new RecursiveDirectoryIterator(dirname(__FILE__) . '/files'));
foreach ($iterator as $dir) {
if ($dir->isDir()) {
continue;
}
$file = $dir->getPathname();
$expectPass = substr($file, -8) === 'pass.php';
$tests[] = array($file, $standard, $expectPass);
}
return $tests;
}
/**
* Overwritten lime_test method
*
* @see lime_test#fail()
*/
public function fail($message = '')
{
$this->testCase->fail($message);
return false;
}
/**
* Fails the test with specified error message
*
* @param string $message
* @param \PHPUnit_Framework_TestCase $test
* @throws \Exception
*/
private static function fail($message, \PHPUnit_Framework_TestCase $test)
{
$test->fail("{$message} in the test '{$test->toString()}'");
throw new \Exception('The above line was supposed to throw an exception.');
}
public function existeUnObjetoDe($name, $arg1, $arg2)
{
foreach ($this->getObjects($name) as $objeto) {
if ($objeto[$arg1] == $arg2) {
return true;
}
}
\PHPUnit_Framework_TestCase::fail("No existe {$arg1} == {$arg2}");
return false;
}
protected function prepare()
{
$this->container = \Mockery::mock(Container::class)->makePartial();
$schemaMapper = \Mockery::mock(SchemaMapper::class)->makePartial();
$schemaMapper->shouldReceive('buildCredentialsFromInlineFormat')->once()->passthru();
$this->container->shouldReceive('resolve')->once()->with('Domain\\Mapper\\Schema')->andReturn($schemaMapper);
$credentialsMatcher = \Mockery::on(function ($args) {
/** @var CredentialsInterface $credentials */
$credentials = $args[0];
\PHPUnit_Framework_TestCase::assertInstanceOf(CredentialsInterface::class, $credentials);
$actual = $credentials->toArray();
$expected = ["username" => "user1", "password" => "pass2", "host" => "sample.host", "database" => "sample_database"];
if ($expected != $actual) {
\PHPUnit_Framework_TestCase::fail('Check credentials format or sample.');
}
return true;
});
$pdo = \Mockery::mock(\PDO::class);
$this->container->shouldReceive('resolve')->once()->with('Persistence\\Storage\\PDO', $credentialsMatcher)->andReturn($pdo);
$storageMatcher = \Mockery::on(function ($args) use($pdo) {
/** @var StorageInterface $storage */
$storage = $args[0];
if ($pdo != $storage) {
\PHPUnit_Framework_TestCase::fail('Check pipes.');
}
return true;
});
$gateway = \Mockery::mock(MySQLGateway::class);
$this->container->shouldReceive('resolve')->once()->with('Persistence\\Gateway\\Schema\\MySQL', $storageMatcher)->andReturn($gateway);
$gatewayAndMapperMatcher = \Mockery::on(function ($args) use($gateway, $schemaMapper) {
if ($args[0] != $gateway) {
\PHPUnit_Framework_TestCase::fail('Gateway mismatch.');
}
if ($args[1] != $schemaMapper) {
\PHPUnit_Framework_TestCase::fail('Mapper mismatch.');
}
return true;
});
$this->schemaService = \Mockery::mock(SchemaService::class);
$this->container->shouldReceive('resolve')->once()->with('Infrastructure\\Services\\Schema', $gatewayAndMapperMatcher)->andReturn($this->schemaService);
$classCommand = '\\DatabaseInspect\\Console\\Command\\DetailsCommand[execute]';
$this->command = \Mockery::mock($classCommand, [$this->container])->makePartial();
$this->input = \Mockery::mock(ArgvInput::class);
$this->input->shouldReceive('getArgument')->once()->andReturn('user1:pass2@sample.host/sample_database');
$this->output = \Mockery::mock(ConsoleOutput::class);
}
