protected function doCreate(RecordInterface $record, Version $version)
{
$this->testCase->assertEquals(3, $record->getUserId());
$this->testCase->assertEquals('test', $record->getTitle());
$this->testCase->assertInstanceOf('DateTime', $record->getDate());
return array('success' => true, 'message' => 'You have successful create a record');
}
/**
* Calls assertType() or assertInstanceOf() depending on the PHPUnit version.
* Available from PHPUnit >= 3.5
*
* @param string $expected Expected value
* @param mixed $actual Actual value
* @param string $message Message to print if assertion is wrong
*/
public static function assertInstanceOf($expected, $actual, $message = '')
{
if (self::_checkMethod('assertInstanceOf')) {
parent::assertInstanceOf($expected, $actual, $message);
} else {
parent::assertType($expected, $actual, $message);
}
}
public function getPostFilter()
{
return array(function ($request, $response, $stack) {
$this->testCase->assertInstanceOf('PSX\\Http\\Request', $request);
$this->testCase->assertInstanceOf('PSX\\Http\\Response', $response);
$stack->handle($request, $response);
});
}
/**
* Asserts that a variable is of a given type.
*
* If $expected is an array, each string value will be used in a type
* check. This is useful for checking if a class also implements certain
* interfaces.
*
* @param string|array $expected
* @param mixed $actual
* @param string $message
*/
public static function assertInstanceOf($expected, $actual, $message = '')
{
if (is_array($expected)) {
foreach ($expected as $expectedSingle) {
parent::assertInstanceOf($expectedSingle, $actual, $message);
}
return;
}
parent::assertInstanceOf($expected, $actual, $message);
}
/**
* Helper method to allow PHPUnit versions < 3.5.x
*
* @param string $expected The expected class or interface.
* @param mixed $actual The actual variable/value.
* @param string $message Optional error/fail message.
*
* @return void
* @since 0.10.2
*/
public static function assertInstanceOf($expected, $actual, $message = '')
{
if (is_callable(get_parent_class(__CLASS__) . '::') . __FUNCTION__) {
return parent::assertInstanceOf($expected, $actual, $message);
}
return parent::assertType($expected, $actual, $message);
}
/**
* @param object $instance
* @param string $propertyName
* @param mixed $testItem
*/
public static function assertPropertyCollection($instance, $propertyName, $testItem)
{
$propertyAccess = new CollectionAccessor($instance, $propertyName);
// Check default value
\PHPUnit_Framework_TestCase::assertInstanceOf('Doctrine\\Common\\Collections\\Collection', $propertyAccess->getItems(), $propertyName . ': Default value must be instance of Collection');
// Check default size
\PHPUnit_Framework_TestCase::assertCount(0, $propertyAccess->getItems(), $propertyName . ': Default collection size must be 0');
// Add first item
\PHPUnit_Framework_TestCase::assertSame($instance, $propertyAccess->addItem($testItem), sprintf('%s::%s() - must return %s', ClassUtils::getClass($instance), $propertyAccess->getAddItemMethod(), ClassUtils::getClass($instance)));
// Check added item
\PHPUnit_Framework_TestCase::assertCount(1, $propertyAccess->getItems(), $propertyName . ': After add item - collection size must be 1');
\PHPUnit_Framework_TestCase::assertInstanceOf('Doctrine\\Common\\Collections\\Collection', $propertyAccess->getItems(), $propertyName . ': After addition of a first item - property value must be instance of Collection');
\PHPUnit_Framework_TestCase::assertEquals([$testItem], $propertyAccess->getItems()->toArray(), $propertyName . ': After addition of a first item - collections must be equals');
// Add already added item
$propertyAccess->addItem($testItem);
\PHPUnit_Framework_TestCase::assertCount(1, $propertyAccess->getItems(), $propertyName . ': After addition already added item - collection size must be same and equal 1');
// Remove item
\PHPUnit_Framework_TestCase::assertSame($instance, $propertyAccess->removeItem($testItem), sprintf('%s:%s() - must return %s', ClassUtils::getClass($instance), $propertyAccess->getRemoveItemMethod(), ClassUtils::getClass($instance)));
\PHPUnit_Framework_TestCase::assertCount(0, $propertyAccess->getItems(), $propertyName . ': After removal of a single item - collection size must be 0');
// Remove already removed item
$propertyAccess->removeItem($testItem);
\PHPUnit_Framework_TestCase::assertCount(0, $propertyAccess->getItems(), $propertyName . ': After removal already removed item - collection size must be same and equal 0');
\PHPUnit_Framework_TestCase::assertNotContains($testItem, $propertyAccess->getItems()->toArray(), $propertyName . ': After removal of a single item - collection must not contains test item');
}
public function testGet()
{
$get = $this->entityGet();
if (is_object($get)) {
TestCase::assertInstanceOf("Countable", $get, $this->msg(self::$MSG_GET_METHOD_MUST_RETURN_COUNTABLE_OBJECT));
TestCase::assertInstanceOf("Traversable", $get, $this->msg(self::$MSG_GET_METHOD_MUST_RETURN_TRAVERSABLE_OBJECT));
} elseif (!is_null($get)) {
TestCase::assertInternalType("array", $get, $this->msg(self::$MSG_GET_METHOD_MUST_RETURN_AN_ARRAY));
} else {
throw new AssertionFailedError($this->msg(self::$MSG_GET_METHOD_MUST_NOT_RETURN_NULL));
}
}
/**
* @deprecated since 2.3
* @static
* @param mixed $actual
* @param mixed $expected
* @param string $message
*/
public static function assertIsA($actual, $expected, $message = '')
{
parent::assertInstanceOf($expected, $actual, $message);
}
public function onExecute(Parameters $parameters, OutputInterface $output)
{
// test properties
$this->testCase->assertInstanceOf('PSX\\Loader\\Context', $this->context);
$this->testCase->assertInstanceOf('PSX\\Config', $this->config);
}
/**
* @test
*/
public function emptyHandlers()
{
$handlers = $this->handlerContainer->getHandlers();
parent::assertInstanceOf(\Traversable::class, $handlers);
parent::assertEmpty($handlers);
}
/**
* @param CompiledExpression|null $actual
* @param string $message
*/
protected function assertInstanceOfCompiledExpression($actual, $message = '')
{
parent::assertInstanceOf(CompiledExpression::class, $actual, $message);
}
/**
* Checks whether the data we received as post is converted to the right
* types
*
* @param \PHPUnit_Framework_TestCase $testCase
* @param \PSX\Data\RecordInterface $record
*/
public static function assertRecord(\PHPUnit_Framework_TestCase $testCase, RecordInterface $record)
{
$testCase->assertInternalType('array', $record->getArray());
$testCase->assertEquals(1, count($record->getArray()));
$testCase->assertEquals(['bar'], $record->getArray());
$testCase->assertInternalType('array', $record->getArrayComplex());
$testCase->assertEquals(2, count($record->getArrayComplex()));
$testCase->assertInstanceOf('PSX\\Data\\RecordInterface', $record->getArrayComplex()[0]);
$testCase->assertEquals(['foo' => 'bar'], $record->getArrayComplex()[0]->getRecordInfo()->getFields());
$testCase->assertInstanceOf('PSX\\Data\\RecordInterface', $record->getArrayComplex()[1]);
$testCase->assertEquals(['foo' => 'foo'], $record->getArrayComplex()[1]->getRecordInfo()->getFields());
$testCase->assertInternalType('array', $record->getArrayChoice());
$testCase->assertEquals(3, count($record->getArrayChoice()));
$testCase->assertInstanceOf('PSX\\Data\\RecordInterface', $record->getArrayChoice()[0]);
$testCase->assertEquals(['foo' => 'baz'], $record->getArrayChoice()[0]->getRecordInfo()->getFields());
$testCase->assertInstanceOf('PSX\\Data\\RecordInterface', $record->getArrayChoice()[1]);
$testCase->assertEquals(['bar' => 'bar'], $record->getArrayChoice()[1]->getRecordInfo()->getFields());
$testCase->assertInstanceOf('PSX\\Data\\RecordInterface', $record->getArrayChoice()[2]);
$testCase->assertEquals(['foo' => 'foo'], $record->getArrayChoice()[2]->getRecordInfo()->getFields());
$testCase->assertInternalType('boolean', $record->getBoolean());
$testCase->assertEquals(true, $record->getBoolean());
$testCase->assertInstanceOf('PSX\\Data\\RecordInterface', $record->getChoice());
$testCase->assertEquals(['foo' => 'bar'], $record->getComplex()->getRecordInfo()->getFields());
$testCase->assertInstanceOf('PSX\\Data\\RecordInterface', $record->getComplex());
$testCase->assertEquals(['foo' => 'bar'], $record->getComplex()->getRecordInfo()->getFields());
$testCase->assertInstanceOf('PSX\\DateTime\\Date', $record->getDate());
$testCase->assertEquals('2015-05-01', $record->getDate()->format('Y-m-d'));
$testCase->assertInstanceOf('PSX\\DateTime', $record->getDateTime());
$testCase->assertEquals('2015-05-01T13:37:14Z', $record->getDateTime()->format('Y-m-d\\TH:i:s\\Z'));
$testCase->assertInstanceOf('PSX\\DateTime\\Duration', $record->getDuration());
$testCase->assertEquals('000100000000', $record->getDuration()->format('%Y%M%D%H%I%S'));
$testCase->assertInternalType('float', $record->getFloat());
$testCase->assertEquals(13.37, $record->getFloat());
$testCase->assertInternalType('integer', $record->getInteger());
$testCase->assertEquals(7, $record->getInteger());
$testCase->assertInternalType('string', $record->getString());
$testCase->assertEquals('bar', $record->getString());
$testCase->assertInstanceOf('PSX\\DateTime\\Time', $record->getTime());
$testCase->assertEquals('13:37:14', $record->getTime()->format('H:i:s'));
}
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);
}
protected function doCreate(RecordInterface $record, Version $version)
{
$this->testCase->assertEquals(3, $record->getUserId());
$this->testCase->assertEquals('test', $record->getTitle());
$this->testCase->assertInstanceOf('DateTime', $record->getDate());
}
public function test_debug_function_is_called()
{
$this->http->method('request')->will($this->returnCallback(function () {
return new \Communique\RESTClientResponse(200, 'response+payload', array('X-PoweredBy' => 'Dreams'));
}));
$rest = new \Communique\Communique('http://domain.com/', array(), $this->http);
$rest->get('users', array('request' => 'payload'), array('Foo' => 'Bar'), function ($request, $response) {
PHPUnit_Framework_TestCase::assertInstanceOf('\\Communique\\RESTClientRequest', $request);
PHPUnit_Framework_TestCase::assertEquals($request->url, 'http://domain.com/users');
PHPUnit_Framework_TestCase::assertEquals($request->payload, array('request' => 'payload'));
PHPUnit_Framework_TestCase::assertEquals($request->headers, array('Foo' => 'Bar'));
PHPUnit_Framework_TestCase::assertInstanceOf('\\Communique\\RESTClientResponse', $response);
PHPUnit_Framework_TestCase::assertEquals($response->status, 200);
PHPUnit_Framework_TestCase::assertEquals($response->payload, 'response+payload');
PHPUnit_Framework_TestCase::assertEquals($response->headers, array('X-PoweredBy' => 'Dreams'));
});
}
/**
* @test
*/
public function getUnbuffered()
{
$ipProvider = $this->getIpProvider(false);
parent::assertInstanceOf(IpProvider::class, $ipProvider);
}
/**
* @test
*/
public function emptyProcessors()
{
$processors = $this->processorContainer->getProcessors();
parent::assertInstanceOf(\Traversable::class, $processors);
parent::assertEmpty($processors);
}
/**
* 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
*/
public static function assertInstanceOf($expected, $actual, $message = '')
{
if (self::$_assert_type_compatability) {
return self::assertType($expected, $actual, $message);
}
return parent::assertInstanceOf($expected, $actual, $message);
}
/**
* @deprecated since 2.3
* @static
* @param mixed $actual
* @param mixed $expected
* @param string $message
* @return void
*/
public static function assertIsA($actual, $expected, $message = '')
{
if ($expected === 'array') {
parent::assertEquals('array', gettype($actual), $message);
} else {
parent::assertInstanceOf($expected, $actual, $message);
}
}
/**
* @test
*/
public function formatterNotEmpty()
{
$formatter = $this->formatterContainer->getFormatter();
parent::assertInstanceOf(FormatterInterface::class, $formatter);
}
/**
* @dataProvider multipleTypeDataProvider
* @param bool $isMultiple
*/
public function testCreateEntitiesToIdsTransformer($isMultiple)
{
$options = array('em' => $this->getMockEntityManager(), 'multiple' => $isMultiple, 'class' => 'TestClass', 'property' => 'id', 'queryBuilder' => function ($repository, array $ids) {
return $repository->createQueryBuilder('o')->where('o.id IN (:values)')->setParameter('values', $ids);
}, 'values_delimiter' => ',');
$builder = $this->getMockBuilder('Symfony\\Component\\Form\\Test\\FormBuilderInterface')->setMethods(array('addViewTransformer', 'addEventSubscriber'))->getMockForAbstractClass();
$builder->expects($this->at(0))->method('addViewTransformer')->with($this->callback(function ($transformer) use($options, $isMultiple) {
if ($isMultiple) {
\PHPUnit_Framework_TestCase::assertInstanceOf('Oro\\Bundle\\FormBundle\\Form\\DataTransformer\\EntitiesToIdsTransformer', $transformer);
} else {
\PHPUnit_Framework_TestCase::assertInstanceOf('Oro\\Bundle\\FormBundle\\Form\\DataTransformer\\EntityToIdTransformer', $transformer);
}
\PHPUnit_Framework_TestCase::assertAttributeEquals($options['em'], 'em', $transformer);
\PHPUnit_Framework_TestCase::assertAttributeEquals($options['class'], 'className', $transformer);
\PHPUnit_Framework_TestCase::assertAttributeEquals($options['property'], 'property', $transformer);
\PHPUnit_Framework_TestCase::assertAttributeEquals($options['queryBuilder'], 'queryBuilderCallback', $transformer);
return true;
}))->will($this->returnSelf());
if ($isMultiple) {
$builder->expects($this->at(1))->method('addViewTransformer')->will($this->returnSelf());
}
$this->type = new EntityIdentifierType($this->getMockManagerRegistry());
$this->type->buildForm($builder, $options);
}
/**
* Assert there is possibility of creating an instance
* of the given class.
*
* @param string $class
*/
protected static function assertClassIsInstantiable($class)
{
$object = new $class();
parent::assertInstanceOf($class, $object);
unset($object);
}
/**
* @test
* @dataProvider getInstanceValues
*/
public function hasCollectionInterface()
{
parent::assertInstanceOf(CollectionInterface::class, $this->getCollectionInstance());
}
