private function assessOutputMatch(Job $job, $content)
{
if (!Tester\Assert::isMatching($content, $job->getOutput())) {
Dumper::saveOutput($job->getFile(), $job->getOutput(), '.actual');
Dumper::saveOutput($job->getFile(), $content, '.expected');
return array(Runner::FAILED, 'Failed: output should match ' . Dumper::toLine(rtrim($content)));
}
}
/**
* @param string $presenterName is fully qualified presenter name (module:module:presenter)
* @param string $action
* @param string $method
* @param array $params
* @param array $post
* @return Application\IResponse
*/
public function assertFormSubmitted($presenterName, $action, $method = 'GET', $params = array(), $post = array())
{
$presenter = $this->createPresenter($presenterName);
$res = $this->processRequest($presenter, $presenterName, $action, $method, $params, $post);
Assert::type('Nette\\Application\\Responses\\RedirectResponse', $res);
return $res;
}
function routeIn(Nette\Application\IRouter $route, $url, $expectedPresenter = NULL, $expectedParams = NULL, $expectedUrl = NULL, $scriptPath = NULL)
{
$url = new Nette\Http\UrlScript("http://example.com{$url}");
if ($scriptPath) {
$url->setScriptPath($scriptPath);
}
if ($url->getQueryParameter('presenter') === NULL) {
$url->setQueryParameter('presenter', 'querypresenter');
}
$url->appendQuery(['test' => 'testvalue']);
$httpRequest = new Nette\Http\Request($url);
$request = $route->match($httpRequest);
if ($request) {
// matched
$params = $request->getParameters();
asort($params);
asort($expectedParams);
Assert::same($expectedPresenter, $request->getPresenterName());
Assert::same($expectedParams, $params);
$result = $route->constructUrl($request, $url);
Assert::same($expectedUrl, $result);
} else {
// not matched
Assert::null($expectedPresenter);
}
}
public function __construct($abc, $xyz, $false, $null)
{
\Tester\Assert::same('test', $abc);
\Tester\Assert::same(159753, $xyz);
\Tester\Assert::same(FALSE, $false);
\Tester\Assert::null($null);
}
/**
* @eventListener onFoo
* @param int $one
* @param int $two
* @param int $three
*/
public function onFoo($one, $two, $three)
{
Assert::equal(1, $one);
Assert::equal(2, $two);
Assert::equal(3, $three);
$this->called = TRUE;
}
function _register_wrapper($namespace)
{
$fs = new FileSystem(new Connector(new ConnectorConfig(), new PathTranslator($namespace)));
Assert::true(Wrapper::register($fs));
$context = stream_context_create(array('dir' => array('recursive' => true)));
@rmdir('redis://', $context);
}
/**
* @param array $configs
* @return Nette\DI\Container
*/
protected function createContainer(array $configs = [])
{
$sl = $this->parentCreateContainer($configs);
/** @var DbConnectionMock $db */
$db = $sl->getByType('Doctrine\\DBAL\\Connection');
if (!$db instanceof DbConnectionMock) {
$serviceNames = $sl->findByType('Doctrine\\DBAL\\Connection');
throw new \LogicException(sprintf('The service %s should be instance of Kdyby\\TesterExtras\\DbConnectionMock, to allow lazy schema initialization', reset($serviceNames)));
}
$db->onConnect[] = function (Connection $db) use($sl) {
if ($this->databaseName !== NULL) {
return;
}
try {
if (!method_exists($this, 'doSetupDatabase')) {
throw new \LogicException(sprintf("Method %s:%s is not implemented", get_class($this), __FUNCTION__));
}
$this->doSetupDatabase($db);
} catch (\Exception $e) {
Tracy\Debugger::log($e, Tracy\Debugger::ERROR);
Assert::fail($e->getMessage());
}
};
return $sl;
}
public function __construct(array $params, DBAL\Driver $driver, DBAL\Configuration $config = NULL, Common\EventManager $eventManager = NULL)
{
$container = \Testbench\ContainerFactory::create(FALSE);
$this->onConnect[] = function (DoctrineConnectionMock $connection) use($container) {
if ($this->__testbench_databaseName !== NULL) {
//already initialized (needed for pgsql)
return;
}
try {
$config = $container->parameters['testbench'];
if ($config['shareDatabase'] === TRUE) {
$registry = new \Testbench\DatabasesRegistry();
$dbName = $container->parameters['testbench']['dbprefix'] . getenv(\Tester\Environment::THREAD);
if ($registry->registerDatabase($dbName)) {
$this->__testbench_database_setup($connection, $container, TRUE);
} else {
$this->__testbench_databaseName = $dbName;
$this->__testbench_database_change($connection, $container);
}
} else {
// always create new test database
$this->__testbench_database_setup($connection, $container);
}
} catch (\Exception $e) {
\Tester\Assert::fail($e->getMessage());
}
};
parent::__construct($params, $driver, $config, $eventManager);
}
public function testDelete()
{
$req = Request::create($this->baseDomain . '/test/1', Methods::DELETE);
$app = new App(NULL, $req);
$app->attach($this->router);
$app->run();
\Tester\Assert::equal('DELETE 1', $this->callResult);
}
public static function close()
{
foreach (self::$expected as $functionName => $expectedArgs) {
if (!isset(self::$called[$functionName])) {
Assert::fail("Function '{$functionName}' was expected, but not called");
}
}
}
public static function assertTypeError($function)
{
if (PHP_VERSION_ID < 70000) {
Assert::error($function, E_RECOVERABLE_ERROR);
} else {
Assert::exception($function, '\\TypeError');
}
}
/**
* @param IComparable $five
* @param IComparable $six
*/
public function assertForComparison(IComparable $five, IComparable $six)
{
Assert::true($five->isLessThan($six));
Assert::true($five->isLessThanOrEqual($six));
Assert::false($six->isLessThan($five));
Assert::false($six->isLessThanOrEqual($five));
Assert::false($five->isEqual($six));
Assert::false($six->isEqual($five));
}
function testExport()
{
Helper::$presenter->forceAjaxMode = FALSE;
$params = $this->params + array('do' => 'grid-export-export');
ob_start();
Helper::request($params)->send(mock('\\Nette\\Http\\IRequest'), new \Nette\Http\Response());
$output = ob_get_clean();
Assert::same(file_get_contents(__DIR__ . "/files/export.expect"), $output);
}
/**
* @param string $expectedJson
* @param string $input
*/
public static function json($expectedJson, $input)
{
$decodedExpectedJson = self::jsonDecode($expectedJson, 'Expected-json');
$decodedInput = self::jsonDecode($input, 'Input-json');
try {
Assert::equal($decodedExpectedJson, $decodedInput);
} catch (AssertException $e) {
throw new AssertException('%1 should be equal to %2', self::makeJsonPretty($expectedJson), self::makeJsonPretty($input));
}
}
private function assertLimit(IDataSource $source)
{
$all = $source->fetchAll();
Assert::count(self::LIMIT, $all);
Assert::count(self::FULL_USER_COUNT, $source->fetchFullData());
Assert::count(self::FULL_USER_COUNT, $source->fetchAllForExport());
Assert::same(self::FULL_USER_COUNT, $source->getTotalCount());
Assert::same(self::LIMIT, $source->count());
return $all;
}
/**
* @param $destination
* @param array $args
*/
protected function assertDestination($destination, $args = array())
{
$appRequest = $this->seleniumContext->getSession()->presenter();
Assert::true(empty($appRequest));
Assert::same($destination, $appRequest->getPresenterName());
foreach ($args as $param => $value) {
Assert::true(array_key_exists($param, $appRequest->parameters));
Assert::same($value, $appRequest->parameters[$param]);
}
}
function testExport()
{
Helper::$presenter->forceAjaxMode = FALSE;
$params = $this->params + array('do' => 'grid-export-export');
ob_start();
Helper::request($params)->send(mock('\\Nette\\Http\\IRequest'), new \Nette\Http\Response());
$output = ob_get_clean();
//@todo - resolve this wtf? different sorting (dibi, nette db, doctrine) vs (array source)
$type = in_array(get_called_class(), array('Grido\\Tests\\ArraySourceTest')) ? '.array' : '';
Assert::same(file_get_contents(__DIR__ . "/files/export{$type}.expect"), $output);
}
public function testCallback()
{
$form = new Form();
$sug = $form->addSuggestion('suggestion')->setCallback(array($this, 'suggestionCallback'));
$this->assertSame(array('query1', 'query2'), $sug->call('query'));
A::throws(function () use($sug) {
$sug->getControl();
}, 'Nette\\InvalidStateException');
$this->assertInstanceOf('Nette\\Utils\\Html', $sug->getControl(FALSE));
$sug->setLink('link');
$this->assertInstanceOf('Nette\\Utils\\Html', $sug->getControl());
}
public function testFetchLastRawRows()
{
$source = $this->createArraySourceWithDataStructure();
Assert::exception(function () use($source) {
$source->fetchLastRawRows();
}, InvalidStateException::class);
$source->fetchAll();
$rawData = $source->fetchLastRawRows();
Assert::count(self::FULL_USER_COUNT, $rawData);
foreach ($rawData as $item) {
Assert::type(ArrayHash::class, $item);
}
}
protected function checkRenderOutput(IComponent $control, $expected, array $renderParameters = [])
{
if (!$control->getParent()) {
$this->attachToPresenter($control);
}
ob_start();
$control->render(...$renderParameters);
if (is_file($expected)) {
\Tester\Assert::matchFile($expected, ob_get_clean());
} else {
\Tester\Assert::match($expected, ob_get_clean());
}
}
public function testBasicFunctionality()
{
$inputData = ['courier' => ['name' => 'Nikola Tesla'], 'checkpoints' => [['type' => 'source', 'arrivalExpected' => '2014-10-16 19:00:00 +0200', 'arrivalReal' => '2014-10-16 19:00:00 +0200', 'departureReal' => NULL, 'estimatedDelay' => 0], ['type' => 'destination', 'arrivalExpected' => NULL, 'arrivalReal' => NULL, 'departureReal' => NULL, 'estimatedDelay' => 0]], 'isWarrantyClaim' => TRUE, 'orderId' => 12345678];
$orderTimesDTO = new OrderTimesDTO($inputData);
Assert::same('Nikola Tesla', $orderTimesDTO->getCourierName());
Assert::equal(new \DateTime('2014-10-16 19:00:00 +0200'), $orderTimesDTO->getSourceCheckpoint()['arrivalExpected']);
Assert::equal(new \DateTime('2014-10-16 19:00:00 +0200'), $orderTimesDTO->getSourceCheckpoint()['arrivalReal']);
Assert::same(NULL, $orderTimesDTO->getSourceCheckpoint()['departureReal']);
Assert::same(0, $orderTimesDTO->getSourceCheckpoint()['estimatedDelay']);
Assert::same(NULL, $orderTimesDTO->getDestinationCheckpoint()['arrivalExpected']);
Assert::same(NULL, $orderTimesDTO->getDestinationCheckpoint()['arrivalReal']);
Assert::same(NULL, $orderTimesDTO->getDestinationCheckpoint()['departureReal']);
Assert::same(0, $orderTimesDTO->getDestinationCheckpoint()['estimatedDelay']);
Assert::same(TRUE, $orderTimesDTO->isIsWarrantyClaim());
}
public function testMask()
{
$form = new Form();
$mask = $form->addMask('mask');
$mask->setMask('999 *** aaa');
$mask->getControl();
$rules = $mask->getRules()->getIterator();
$this->assertSame('[0-9][0-9][0-9] [0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z] [a-zA-Z][a-zA-Z][a-zA-Z]', $rules[0]->arg);
A::throws(function () use($mask) {
$mask->setMask('999');
}, 'Exception');
A::throws(function () use($mask) {
$mask->setRegex('999');
}, 'Exception');
}
public function testExportFiltered()
{
$data = $this->data;
$callback = function ($source) use($data) {
Assert::same($data, $source);
};
$export = $this->grid->addExportCallback('Export', $callback, TRUE);
$this->grid->addFilterText('name', 'Name');
$grid = $this->grid;
$trigger = function () use($grid) {
$this->grid->handleExport(1);
};
Assert::exception($trigger, 'Ublaboo\\DataGrid\\Exception\\DataGridException', 'You have to set a data source first.');
$this->grid->setDataSource($this->data);
$this->grid->handleExport(1);
}
/**
* @internal
* @return \Nette\DI\Container
*/
private function __testbench_ndb_getContainer()
{
if ($this->__testbench_ndb_container === NULL) {
$container = \Testbench\ContainerFactory::create(FALSE);
/** @var Connection $db */
$db = $container->getByType('Nette\\Database\\Connection');
$db->onConnect[] = function (Connection $db) use($container) {
if ($this->__testbench_ndb_databaseName !== NULL) {
return;
}
try {
$this->__testbench_ndb_setupDatabase($db, $container);
} catch (\Exception $e) {
\Tester\Assert::fail($e->getMessage());
}
};
$this->__testbench_ndb_container = $container;
}
return $this->__testbench_ndb_container;
}
protected function createContainer()
{
$container = $this->parentCreateContainer();
/** @var ConnectionMock $db */
$db = $container->getByType(Connection::class);
if (!$db instanceof ConnectionMock) {
throw new \LogicException("Connection service should be instance of ConnectionMock");
}
$db->onConnect[] = function (Connection $db) use($container) {
if ($this->databaseName !== NULL) {
return;
}
try {
$this->setupDatabase($db);
} catch (\Exception $e) {
Tester\Assert::fail($e->getMessage());
}
};
return $container;
}
/** @internal */
private function __testbench_createContainer()
{
if (!class_exists('Doctrine\\DBAL\\Connection')) {
\Tester\Environment::skip('TDoctrine trait supports only Doctrine at this moment.');
}
$container = \Testbench\ContainerFactory::create(FALSE);
/** @var ConnectionMock $db */
$db = $container->getByType('Doctrine\\DBAL\\Connection');
if (!$db instanceof ConnectionMock) {
$serviceNames = $container->findByType('Doctrine\\DBAL\\Connection');
throw new \LogicException(sprintf('The service %s should be instance of Ant\\Tests\\ConnectionMock, to allow lazy schema initialization.', reset($serviceNames)));
}
$db->onConnect[] = function (ConnectionMock $db) use($container) {
if ($this->__testbench_databaseName !== NULL) {
return;
}
try {
$this->setupDatabase($db, $container);
} catch (\Exception $e) {
\Tester\Assert::fail($e->getMessage());
}
};
return $container;
}
protected static function matchCounts(IFilterSource $source, $filteredCount, $fullCount, $rawClassType)
{
static $lastRowsDescription = 'Output from fetchLastRawRows after %s';
$users = $source->fetchAll();
if (count($users) > 0) {
Assert::type(ArrayHash::class, reset($users));
}
Assert::count($filteredCount, $users, 'Output from fetchAll');
$lastRows = $source->fetchLastRawRows();
if (count($lastRows) > 0) {
Assert::type($rawClassType, reset($lastRows));
}
Assert::count($filteredCount, $lastRows, sprintf($lastRowsDescription, 'fetchAll'));
$fullData = $source->fetchFullData();
if (count($fullData) > 0) {
Assert::type(ArrayHash::class, reset($fullData));
}
Assert::count($fullCount, $fullData, 'Output from fetchFullData');
$lastRows = $source->fetchLastRawRows();
if (count($lastRows) > 0) {
Assert::type($rawClassType, reset($lastRows));
}
Assert::count($fullCount, $lastRows, sprintf($lastRowsDescription, 'fetchFullData'));
}
/**
* @return $this
*/
public function valid()
{
Assert::true($this->getObject()->isValid());
return $this;
}
protected function assertBuilder($expected, QueryBuilder $builder)
{
$args = $builder->getQueryParameters();
array_unshift($args, $builder->getQuerySql());
Assert::same($expected, $args);
}
/**
* Assert array equality without considering key order and with strict comparision
*
* In numeric-indexed arrays, keys are considered insignificant, ie. array(1, 2, 3) and array(3, 2, 1) are equal in terms of this assertion.
* In associative arrays, keys are significant, however order of items in array is not.
*
* Items are compared using strict operator ===
*
* @param array $expected
* @param array $actual
*/
static function arraySame($expected, $actual)
{
if (!self::isArraySame($expected, $actual)) {
NAssert::fail('%1 should be same (without considering key order) to %2', $actual, $expected);
}
}
