/**
* @Given /^There are activity for questions$/
*/
public function thereAreActivityForQuestions(TableNode $table)
{
/* @var $em EntityManager */
$em = $this->getEm();
/* @var $activityService \Civix\CoreBundle\Service\ActivityUpdate */
$activityService = $this->getMainContext()->getContainer()->get('civix_core.activity_update');
$hash = $table->getHash();
$diffSec = 0;
foreach ($hash as $row) {
/* @var $question Question */
$diffSec++;
$question = $em->getRepository(Question::class)->findOneBySubject($row['question']);
$activity = $activityService->publishQuestionToActivity($question);
Assert::assertInstanceOf(Activity::class, $activity);
$activity->getSentAt()->sub(new \DateInterval('PT' . (count($hash) - $diffSec) . 'S'));
$activity->setSentAt(clone $activity->getSentAt());
$em->flush($activity);
if (!empty($row['expired_interval_direction'])) {
$expired = new \DateTime();
$expired->{$row}['expired_interval_direction'](new \DateInterval($row['expired_interval_value']));
$activity->setExpireAt($expired);
$em->flush($activity);
}
}
$result = $em->getRepository(QuestionActivity::class)->findAll();
Assert::assertTrue(count($result) >= count($hash));
}
public function assertLockDiscoveryPropertyCorrect(ezcWebdavMemoryBackend $backend)
{
$prop = $backend->getProperty('/collection/newcollection', 'lockdiscovery');
PHPUnit_Framework_Assert::assertNotNull($prop, 'Lock discovery property not set.');
PHPUnit_Framework_Assert::assertInstanceOf('ezcWebdavLockDiscoveryProperty', $prop, 'Lock discovery property has incorrect type.');
PHPUnit_Framework_Assert::assertEquals(1, count($prop->activeLock), 'Number of activeLock elements incorrect.');
PHPUnit_Framework_Assert::assertEquals(new ezcWebdavPotentialUriContent('http://example.com/some/user', true), $prop->activeLock[0]->owner, 'Lock owner not correct.');
}
public function testProcess()
{
if (!class_exists(TransactionMiddleware::class)) {
$this->markTestSkipped('"league/tactician-doctrine" is not installed');
}
$this->container->shouldReceive('hasParameter')->with('doctrine.entity_managers')->once()->andReturn(true);
$this->container->shouldReceive('getParameter')->with('doctrine.entity_managers')->once()->andReturn(['default' => 'doctrine.orm.default_entity_manager', 'second' => 'doctrine.orm.second_entity_manager']);
$this->container->shouldReceive('getParameter')->with('doctrine.default_entity_manager')->once()->andReturn('default');
$this->container->shouldReceive('setDefinition')->andReturnUsing(function ($name, Definition $def) {
\PHPUnit_Framework_Assert::assertEquals('tactician.middleware.doctrine.default', $name);
\PHPUnit_Framework_Assert::assertEquals(TransactionMiddleware::class, $def->getClass());
\PHPUnit_Framework_Assert::assertCount(1, $def->getArguments());
\PHPUnit_Framework_Assert::assertInstanceOf(Reference::class, $def->getArgument(0));
\PHPUnit_Framework_Assert::assertEquals('doctrine.orm.default_entity_manager', (string) $def->getArgument(0));
})->once();
$this->container->shouldReceive('setDefinition')->andReturnUsing(function ($name, Definition $def) {
\PHPUnit_Framework_Assert::assertEquals('tactician.middleware.doctrine.second', $name);
\PHPUnit_Framework_Assert::assertEquals(TransactionMiddleware::class, $def->getClass());
\PHPUnit_Framework_Assert::assertCount(1, $def->getArguments());
\PHPUnit_Framework_Assert::assertInstanceOf(Reference::class, $def->getArgument(0));
\PHPUnit_Framework_Assert::assertEquals('doctrine.orm.second_entity_manager', (string) $def->getArgument(0));
})->once();
$this->container->shouldReceive('setDefinition')->with('tactician.middleware.doctrine.second')->once();
$this->container->shouldReceive('setAlias')->once()->with('tactician.middleware.doctrine', 'tactician.middleware.doctrine.default');
$this->compiler->process($this->container);
}
/**
* @Given /^the Search Hits are Content objects$/
*/
public function theSearchHitsAreContentObjects()
{
/** @var SearchHit[] $searchHits */
$searchHits = $this->getResponseObject()->result->searchHits;
foreach ($searchHits as $searchHit) {
Assertion::assertInstanceOf('eZ\\Publish\\API\\Repository\\Values\\Content\\Content', $searchHit->valueObject);
}
}
/**
* @test
*/
public function shouldCreateAnUser()
{
$user = $this->mockUser();
$userToken = $this->mockUserToken();
$factory = new UserSessionFactoryDefault();
$userSession = $factory->create($user, $userToken);
\PHPUnit_Framework_Assert::assertInstanceOf(UserSessionDefault::class, $userSession);
}
/**
* @test
*/
public function shouldCreateAnUser()
{
$container = $this->mockDependencyInjectionContainer();
$serializer = $this->mockSerializer();
$factory = new UserFactoryDefault($container, $serializer);
$user = $factory->create();
\PHPUnit_Framework_Assert::assertInstanceOf(User::class, $user);
}
public function testSendIdentitiedRequest()
{
$guzzleClient = $this->getGuzzleClientMock('{}');
$client = new Client('API_KEY', $guzzleClient);
$request = new RequestById(new Id('tt3665102'));
$response = $client->send($request);
\PHPUnit_Framework_Assert::assertInstanceOf('ClearCode\\OMDB\\Response\\Response', $response);
}
public function assertLockDiscoveryPropertyNowhere(ezcWebdavMemoryBackend $backend)
{
$prop = $backend->getProperty('/collection', 'lockdiscovery');
PHPUnit_Framework_Assert::assertInstanceOf('ezcWebdavLockDiscoveryProperty', $prop, 'Property has incorrect type.');
PHPUnit_Framework_Assert::assertEquals(0, count($prop->activeLock), 'Active lock element not removed correctly.');
$prop = $backend->getProperty('/collection/resource.html', 'lockdiscovery');
PHPUnit_Framework_Assert::assertNull($prop);
}
public function assertSourceStillThere(ezcWebdavMemoryBackend $backend)
{
PHPUnit_Framework_Assert::assertTrue($backend->nodeExists('/collection/resource.html'));
$prop = $backend->getProperty('/collection/resource.html', 'lockdiscovery');
PHPUnit_Framework_Assert::assertNotNull($prop, 'Lock discovery property removed from source.');
PHPUnit_Framework_Assert::assertInstanceOf('ezcWebdavLockDiscoveryProperty', $prop);
PHPUnit_Framework_Assert::assertEquals(1, count($prop->activeLock), 'Active lock element removed from source.');
PHPUnit_Framework_Assert::assertEquals('opaquelocktoken:1234', $prop->activeLock[0]->token->__toString(), 'Active lock token on destination parent incorrect.');
}
/**
* Checks the integrity of operations links.
*
* @param mixed[] $operations_links
*/
protected function assertOperationsLinks(array $operations_links)
{
foreach ($operations_links as $link) {
\PHPUnit_Framework_Assert::assertArrayHasKey('title', $link);
\PHPUnit_Framework_Assert::assertNotEmpty($link['title']);
\PHPUnit_Framework_Assert::assertArrayHasKey('url', $link);
\PHPUnit_Framework_Assert::assertInstanceOf(Url::class, $link['url']);
}
}
public function assertDestinationCorrect(ezcWebdavMemoryBackend $backend)
{
PHPUnit_Framework_Assert::assertTrue($backend->nodeExists('/other_collection/moved_resource.html'));
$prop = $backend->getProperty('/other_collection/moved_resource.html', 'lockdiscovery');
PHPUnit_Framework_Assert::assertNotNull($prop, 'Lock discovery property not available on destination.');
PHPUnit_Framework_Assert::assertInstanceOf('ezcWebdavLockDiscoveryProperty', $prop);
PHPUnit_Framework_Assert::assertEquals(1, count($prop->activeLock), 'Active lock element not available on destination.');
PHPUnit_Framework_Assert::assertEquals('opaquelocktoken:5678', $prop->activeLock[0]->token->__toString(), 'Active lock token on destination incorrect.');
}
/**
* @Given /^response contains only the user with the email "([^"]*)"$/
*/
public function responseContainsOnlyUsersWithTheEmail($email)
{
$userList = $this->getResponseObject();
Assertion::assertGreaterThan(0, count($userList), 'UserList was expected to contain one user only');
foreach ($userList as $user) {
Assertion::assertInstanceOf('eZ\\Publish\\API\\Repository\\Values\\User\\User', $user, 'Non User found in the response');
Assertion::assertEquals($email, $user->email, "UserList was expected to contain only users with email '{$email}'");
}
}
public function assertRedirect($uri, $str = null)
{
PHPUnit::assertInstanceOf('Illuminate\\Http\\RedirectResponse', $this->response);
if ($str) {
PHPUnit::assertEquals($this->app['url']->to($uri), $this->response->headers->get('Location'), 'Caller: ' . $this->getCaller() . ' ' . $str);
} else {
PHPUnit::assertEquals($this->app['url']->to($uri), $this->response->headers->get('Location'));
}
}
/**
* @test
*/
public function it_returns_new_command_with_uuid_instance()
{
$argumentProcessor = new ArgumentsProcessor([new UuidConverter()]);
$commandReflection = CommandReflection::fromClass(DummyCommandWithUuid::class);
$commandParameters = ['lorem ipsum', '1a67b1de-e3cb-471e-90d3-005341a29b3d'];
$command = $commandReflection->createCommand($commandParameters, $argumentProcessor);
\PHPUnit_Framework_Assert::assertInstanceOf(DummyCommandWithUuid::class, $command);
\PHPUnit_Framework_Assert::assertEquals('lorem ipsum', $command->argument1);
\PHPUnit_Framework_Assert::assertTrue(Uuid::fromString('1a67b1de-e3cb-471e-90d3-005341a29b3d')->equals($command->argument2));
}
public function tryList(FunctionalTester $I)
{
$I->wantTo("Check module list output");
$this->routeMatch->setParam('action', 'show');
$result = $this->controller->dispatch(new ConsoleRequest(array(0 => 'public/index.php', 1 => 'modules', 2 => 'list')));
/** @var Zend\Http\PhpEnvironment\Response $response */
$response = $this->controller->getResponse();
\PHPUnit_Framework_Assert::assertEquals(200, $response->getStatusCode());
\PHPUnit_Framework_Assert::assertEquals('', $result);
\PHPUnit_Framework_Assert::assertInstanceOf('ComposerLockParser\\PackagesCollection', $this->viewModel->getPackages());
\PHPUnit_Framework_Assert::assertGreaterThan(0, $this->viewModel->getPackages()->count());
\PHPUnit_Framework_Assert::assertInstanceOf('ComposerLockParser\\Package', $this->viewModel->getPackages()->getByName('t4web/modules'));
}
/**
* @param string|string[] $expected
* @param Exception $ex
*/
public function assertUsageException($expected, Exception $ex)
{
Assert::assertInstanceOf('UsageException', $ex);
/** @var UsageException $ex */
if (is_string($expected)) {
$expected = array('code' => $expected);
}
if (isset($expected['code'])) {
Assert::assertEquals($expected['code'], $ex->getCodeString());
}
if (isset($expected['message'])) {
Assert::assertContains($expected['message'], $ex->getMessage());
}
}
public function testSetterAndGetter()
{
$user = new UserDefault();
PHPUnit::assertInstanceOf(DateTime::class, $user->getCreatedAt());
PHPUnit::assertInstanceOf(DateTime::class, $user->getUpdatedAt());
PHPUnit::assertNull($user->getDeletedAt());
PHPUnit::assertSame('user', $user->getRole()->getName());
$role = new UserRoleDefault('test');
$user->setRole($role);
PHPUnit::assertSame($role, $user->getRole());
PHPUnit::assertFalse($user->isEnabled());
$user->enable();
PHPUnit::assertTrue($user->isEnabled());
$user->disable();
PHPUnit::assertFalse($user->isEnabled());
}
public function testMessagesTypes()
{
$path = '/test/path';
$mockAdapter = new MockAdapter();
// Adds mock basic OK response
$mockAdapter->addResponseBy();
// Add mock adapter
$this->_client->setAdapter($mockAdapter);
// Send request
$this->_client->get($path);
// Gets message objects
$request = $this->_client->getRequest();
$response = $this->_client->getResponse();
// Tests request and response are objects
\PHPUnit_Framework_Assert::assertInstanceOf(self::CLIENT_NAMESPACE . 'Request', $request);
\PHPUnit_Framework_Assert::assertInstanceOf(self::CLIENT_NAMESPACE . 'Response', $response);
}
/**
* @test
*/
public function it_should_handle_with_response()
{
$wholeMessageLength = 0 + \Madkom\EventStore\Client\Domain\Socket\Message\MessageConfiguration::INT_32_LENGTH + \Madkom\EventStore\Client\Domain\Socket\Message\MessageConfiguration::HEADER_LENGTH;
$buffer = new \TrafficCophp\ByteBuffer\Buffer($wholeMessageLength);
$buffer->writeInt32LE(18, 0);
$buffer->writeInt8(\Madkom\EventStore\Client\Domain\Socket\Message\MessageType::PING, \Madkom\EventStore\Client\Domain\Socket\Message\MessageConfiguration::MESSAGE_TYPE_OFFSET);
$buffer->writeInt8(\Madkom\EventStore\Client\Domain\Socket\Message\MessageConfiguration::FLAGS_NONE, \Madkom\EventStore\Client\Domain\Socket\Message\MessageConfiguration::FLAG_OFFSET);
$buffer->write(hex2bin('12350000000000000000000000000000'), \Madkom\EventStore\Client\Domain\Socket\Message\MessageConfiguration::CORRELATION_ID_OFFSET);
$messageTypeChanged = $this->internalProphet->prophesize('Madkom\\EventStore\\Client\\Domain\\Socket\\Message\\MessageType');
$messageTypeChanged->getType()->willReturn(\Madkom\EventStore\Client\Domain\Socket\Message\MessageType::HEARTBEAT_REQUEST);
$messageTypeChanged = $messageTypeChanged->reveal();
$this->socketMessage->getMessageType()->willReturn($messageTypeChanged);
$this->socketMessage->getCorrelationID()->willReturn('some');
$this->messageDecomposer->decomposeMessage((string) $buffer)->willReturn($this->socketMessage->reveal());
$this->messageComposer->compose(\Prophecy\Argument::type('Madkom\\EventStore\\Client\\Domain\\Socket\\Message\\SocketMessage'))->willReturn('someBinary');
$this->stream->write('someBinary')->shouldBeCalledTimes(1);
$this->stream->reveal();
PHPUnit_Framework_Assert::assertInstanceOf('Madkom\\EventStore\\Client\\Domain\\Socket\\Message\\SocketMessage', $this->streamHandler->handle((string) $buffer));
}
public function testBitstampDriver()
{
$client = $this->getQuoteClient();
$quotes = $client->getQuotes('bitstamp', [['base' => 'USD', 'target' => 'BTC']]);
if (getenv('ECHO_QUOTES')) {
echo "\$quotes:\n" . json_encode($quotes, 192) . "\n";
}
PHPUnit::assertInstanceOf('Tokenly\\CryptoQuoteClient\\Quote', $quotes[0]);
PHPUnit::assertGreaterThan(100, $quotes[0]['bid']);
PHPUnit::assertGreaterThan(100, $quotes[0]['ask']);
PHPUnit::assertGreaterThan(100, $quotes[0]['last']);
$quote = $client->getQuote('bitstamp', 'USD', 'BTC');
if (getenv('ECHO_QUOTES')) {
echo "\$quote:\n" . json_encode($quote, 192) . "\n";
}
PHPUnit::assertGreaterThan(100, $quote['bid']);
PHPUnit::assertGreaterThan(100, $quote['ask']);
PHPUnit::assertGreaterThan(100, $quote['last']);
}
/**
* Assert whether the client was redirected to a given URI.
*
* @param string $uri
* @param array $with
* @return $this
*/
public function assertRedirectedTo($uri, $with = [])
{
PHPUnit::assertInstanceOf('Illuminate\\Http\\RedirectResponse', $this->response);
PHPUnit::assertEquals($this->app['url']->to($uri), $this->response->headers->get('Location'));
$this->assertSessionHasAll($with);
return $this;
}
/**
* Check if one of the given nodes has the given text.
*
* @param NodeElement[] $elements
* @param string $text
*
* @throws \Exception
*/
private function assertANodeElementContainsText(array $elements, $text)
{
foreach ($elements as $element) {
PHPUnit::assertInstanceOf(NodeElement::class, $element, sprintf('Expected a %s element', NodeElement::class));
try {
$this->assertNodeElementContainsText($element, $text);
return;
} catch (\PHPUnit_Framework_AssertionFailedError $exception) {
// Does nothing
}
}
// The given text has not been found, throw an error
throw new \Exception(sprintf('No element contains the text "%s".', $text));
}
/**
* @When /^I get a user and receive a retrofit response$/
*/
public function iGetAUserAndReceiveARetrofitResponse()
{
$this->setExpectations('GET', '/api/basic/user');
$client = $this->getClient();
/** @var Response $response */
$response = $client->getUserReturnRetrofitResponse();
Assert::assertInstanceOf(Response::class, $response);
$this->response = $response->body();
}
/**
* Asserts that a variable is of a given type.
*
* @param string $expected
* @param mixed $actual
* @param string $message
* @since Method available since Release 3.5.0
*/
function assertInstanceOf($expected, $actual, $message = '')
{
return PHPUnit_Framework_Assert::assertInstanceOf($expected, $actual, $message);
}
/**
* @throws ParseFailureException
*/
function it_can_parse_Literal_directive()
{
/** @var RootNode $root */
$root = $this->parse(<<<EOF
internal "txt";
EOF
);
$root->shouldReturnAnInstanceOf(RootNode::class);
$directives = $root->search(function (Node $node) {
return $node;
})->getWrappedObject();
/** @var Directive $directive */
foreach ($directives as $directive) {
break;
}
Assert::assertEquals($directive->getName(), 'internal');
Assert::assertInstanceOf(Traversable::class, $directive->getParams());
/** @var Param $param */
foreach ($directive->getParams() as $param) {
Assert::assertInstanceOf(Literal::class, $param);
}
}
public function testDownloadCallback()
{
// Upload a file.
$upload_file_path = Helper\get_png();
$upload_test = new Test();
$upload_test->server('upload_response', 'POST', array('image' => '@' . $upload_file_path));
$uploaded_file_path = $upload_test->curl->response->file_path;
// Download the file.
$download_callback_called = false;
$multi_curl = new MultiCurl();
$multi_curl->setHeader('X-DEBUG-TEST', 'download_response');
$multi_curl->addDownload(Test::TEST_URL . '?' . http_build_query(array('file_path' => $uploaded_file_path)), function ($instance, $fh) use(&$download_callback_called) {
PHPUnit_Framework_Assert::assertFalse($download_callback_called);
PHPUnit_Framework_Assert::assertInstanceOf('Curl\\Curl', $instance);
PHPUnit_Framework_Assert::assertTrue(is_resource($fh));
PHPUnit_Framework_Assert::assertEquals('stream', get_resource_type($fh));
PHPUnit_Framework_Assert::assertGreaterThan(0, strlen(stream_get_contents($fh)));
PHPUnit_Framework_Assert::assertEquals(0, strlen(stream_get_contents($fh)));
PHPUnit_Framework_Assert::assertTrue(fclose($fh));
$download_callback_called = true;
});
$multi_curl->start();
$this->assertTrue($download_callback_called);
// Remove server file.
$this->assertEquals('true', $upload_test->server('upload_cleanup', 'POST', array('file_path' => $uploaded_file_path)));
unlink($upload_file_path);
$this->assertFalse(file_exists($upload_file_path));
$this->assertFalse(file_exists($uploaded_file_path));
}
public function testErrorCallback()
{
$before_send_called = false;
$success_called = false;
$error_called = false;
$complete_called = false;
$test = new Test();
$curl = $test->curl;
$curl->setHeader('X-DEBUG-TEST', 'get');
$curl->setOpt(CURLOPT_CONNECTTIMEOUT_MS, 2000);
$curl->beforeSend(function ($instance) use(&$before_send_called, &$success_called, &$error_called, &$complete_called) {
PHPUnit_Framework_Assert::assertInstanceOf('Curl\\Curl', $instance);
PHPUnit_Framework_Assert::assertFalse($before_send_called);
PHPUnit_Framework_Assert::assertFalse($success_called);
PHPUnit_Framework_Assert::assertFalse($error_called);
PHPUnit_Framework_Assert::assertFalse($complete_called);
$before_send_called = true;
});
$curl->success(function ($instance) use(&$before_send_called, &$success_called, &$error_called, &$complete_called) {
$success_called = true;
});
$curl->error(function ($instance) use(&$before_send_called, &$success_called, &$error_called, &$complete_called) {
PHPUnit_Framework_Assert::assertInstanceOf('Curl\\Curl', $instance);
PHPUnit_Framework_Assert::assertTrue($before_send_called);
PHPUnit_Framework_Assert::assertFalse($success_called);
PHPUnit_Framework_Assert::assertFalse($error_called);
PHPUnit_Framework_Assert::assertFalse($complete_called);
$error_called = true;
});
$curl->complete(function ($instance) use(&$before_send_called, &$success_called, &$error_called, &$complete_called) {
PHPUnit_Framework_Assert::assertInstanceOf('Curl\\Curl', $instance);
PHPUnit_Framework_Assert::assertTrue($before_send_called);
PHPUnit_Framework_Assert::assertFalse($success_called);
PHPUnit_Framework_Assert::assertTrue($error_called);
PHPUnit_Framework_Assert::assertFalse($complete_called);
$complete_called = true;
});
$curl->get(Test::ERROR_URL);
$this->assertTrue($before_send_called);
$this->assertFalse($success_called);
$this->assertTrue($error_called);
$this->assertTrue($complete_called);
}
/**
* @Then /the (.+) user should be registered library user/
*/
public function theUserShouldBeRegisteredLibraryUser($email)
{
\PHPUnit_Framework_Assert::assertInstanceOf(User::class, $this->userRepository()->get($email));
}
/**
* Checks that the property is a passed type.
* Either 'int', 'bool', 'string', 'array', 'float', 'null', 'resource', 'scalar' can be passed for simple types.
* Otherwise the parameter must be a class and the property must be an instance of that class.
*
* Bear in mind that testing non-public properties is not a good practice.
* Use it only if you have no other way to test it.
*
* @param $object
* @param $property
* @param $type
* @deprecated
*/
public function seePropertyIs($object, $property, $type)
{
$current = $this->retrieveProperty($object, $property);
if (in_array($type, array('int', 'bool', 'string', 'array', 'float', 'null', 'resource', 'scalar'))) {
\PHPUnit_Framework_Assert::assertInternalType($type, $current);
return;
}
\PHPUnit_Framework_Assert::assertInstanceOf($type, $current);
}
/**
* @Then I should be authenticated
*/
public function iShouldBeAuthenticated()
{
PHPUnit_Framework_Assert::assertInstanceOf('\\Hasmo\\Salesforce\\Authentication\\AccessToken', $this->apiResponse);
}