Evaluates a PHPUnit_Framework_Constraint matcher object.
| public static assertThat ( mixed $value, PHPUnit_Framework_Constraint $constraint, string $message = '' ) | ||
| $value | mixed | |
| $constraint | PHPUnit_Framework_Constraint | |
| $message | string | |
/**
* Asserts response headers match with the media types defined.
*
* @param string[] $headers
* @param SchemaManager $schemaManager
* @param string $path percent-encoded path used on the request.
* @param string $httpMethod
* @param int $httpCode
* @param string $message
*/
public function assertResponseHeadersMatch(array $headers, SchemaManager $schemaManager, $path, $httpMethod, $httpCode, $message = '')
{
if (!$schemaManager->findPathInTemplates($path, $template, $params)) {
throw new \RuntimeException('Request URI does not match with any swagger path definition');
}
$constraint = new ResponseHeadersConstraint($schemaManager, $template, $httpMethod, $httpCode);
Assert::assertThat($headers, $constraint, $message);
}
/**
* Evaluates the constraint for test case
*
* @param string $testCaseName
* @return bool
*/
protected function matches($testCaseName)
{
$result = true;
foreach ($this->constraints as $constraint) {
\PHPUnit_Framework_Assert::assertThat("", $constraint);
$result = $result && $constraint->getResult();
}
return $result;
}
/**
* @param mixed $needle
* @param mixed $haystack
* @param string $message
* @param bool $ignoreCase
* @param bool $checkForObjectIdentity
* @param bool $checkForNonObjectIdentity
*/
public static function assertNotContains($needle, $haystack, $message = '', $ignoreCase = false, $checkForObjectIdentity = true, $checkForNonObjectIdentity = false)
{
if (is_array($haystack) || is_object($haystack) && $haystack instanceof \Traversable) {
$constraint = new \PHPUnit_Framework_Constraint_Not(self::contains($needle, $checkForObjectIdentity, $checkForNonObjectIdentity));
} elseif (is_string($haystack)) {
if (!is_string($needle)) {
throw \PHPUnit_Util_InvalidArgumentHelper::factory(1, 'string');
}
$constraint = new \PHPUnit_Framework_Constraint_Not(new \PHPUnit_Framework_Constraint_StringContains($needle, $ignoreCase));
} else {
throw \PHPUnit_Util_InvalidArgumentHelper::factory(2, 'array, traversable or string');
}
\PHPUnit_Framework_Assert::assertThat($haystack, $constraint, $message);
}
/**
* @test
*/
public function thatHandles()
{
$messages = array(new Message(self::DUMMY_MESSAGE_UNIQUE_ID, self::DUMMY_MESSAGE_ID, self::DUMMY_MESSAGE_SUBJECT, self::DUMMY_MESSAGE_CONTENT, $this->getDummyFrom(), self::DUMMY_MESSAGE_TO, self::DUMMY_MESSAGE_REFERENCE));
$strategies = array($this->strategy);
$this->provider->expects($this->once())->method('fetchMessagesToProcess')->will($this->returnValue($messages));
$this->strategyHolder->expects($this->once())->method('getStrategies')->will($this->returnValue($strategies));
$this->context->expects($this->exactly(count($strategies)))->method('setStrategy')->with($this->isInstanceOf('\\Diamante\\EmailProcessingBundle\\Model\\Processing\\Strategy'));
$this->context->expects($this->exactly(count($messages) * count($strategies)))->method('execute')->with($this->isInstanceOf('Diamante\\EmailProcessingBundle\\Model\\Message'));
$this->provider->expects($this->once())->method('markMessagesAsProcessed')->with($this->logicalAnd($this->isType(\PHPUnit_Framework_Constraint_IsType::TYPE_ARRAY), $this->countOf(count($messages)), $this->callback(function ($other) {
$result = true;
foreach ($other as $message) {
$constraint = \PHPUnit_Framework_Assert::isInstanceOf('Diamante\\EmailProcessingBundle\\Model\\Message');
try {
\PHPUnit_Framework_Assert::assertThat($message, $constraint);
} catch (\PHPUnit_Framework_ExpectationFailedException $e) {
$result = false;
}
}
return $result;
})));
$this->manager->handle($this->provider);
}
/**
* @test
*/
public function thatHandlesAndMarksMessages()
{
$messages = $this->getMessages();
$strategies = array($this->strategy);
$this->settings->expects($this->any())->method('getDeleteProcessedMessages')->will($this->returnValue(false));
$this->provider->expects($this->once())->method('fetchMessagesToProcess')->will($this->returnValue($messages));
$this->strategyHolder->expects($this->once())->method('getStrategies')->will($this->returnValue($strategies));
$this->context->expects($this->exactly(count($strategies)))->method('setStrategy')->with($this->isInstanceOf('\\Diamante\\EmailProcessingBundle\\Model\\Processing\\Strategy'));
$this->context->expects($this->exactly(count($messages) * count($strategies)))->method('execute')->with($this->isInstanceOf('Diamante\\EmailProcessingBundle\\Model\\Message'));
$this->provider->expects($this->once())->method('markMessagesAsProcessed')->with($this->logicalAnd($this->isType(\PHPUnit_Framework_Constraint_IsType::TYPE_ARRAY), $this->countOf(count($messages)), $this->callback(function ($other) {
$result = true;
foreach ($other as $message) {
$constraint = \PHPUnit_Framework_Assert::isInstanceOf('Diamante\\EmailProcessingBundle\\Model\\Message');
try {
\PHPUnit_Framework_Assert::assertThat($message, $constraint);
} catch (\PHPUnit_Framework_ExpectationFailedException $e) {
$result = false;
}
}
return $result;
})));
$this->manager->handle($this->provider);
}
/**
* Asserts that the two strings match but that all whitespaces are
* not necessarily equal.
*
* @param array $expected
* @param array $actual
* @param string $message
*/
public static function assertStringMatchIgnoreWhitespace($expected, $actual, $message = '')
{
PHPUnit_Framework_Assert::assertThat($actual, new PHPUnit_Extensions_Constraint_StringMatchIgnoreWhitespace($expected), $message);
}
/**
* Checks whether the last JSON response contains provided array.
* The response is converted to array with json_decode($response, true)
* Thus, JSON is represented by associative array.
* This method matches that response array contains provided array.
*
* Examples:
*
* ``` php
* <?php
* // response: {name: john, email: john@gmail.com}
* $I->seeResponseContainsJson(array('name' => 'john'));
*
* // response {user: john, profile: { email: john@gmail.com }}
* $I->seeResponseContainsJson(array('email' => '*****@*****.**'));
*
* ?>
* ```
*
* This method recursively checks if one array can be found inside of another.
*
* @param array $json
* @part json
*/
public function seeResponseContainsJson($json = [])
{
\PHPUnit_Framework_Assert::assertThat($this->connectionModule->_getResponseContent(), new JsonContains($json));
}
/**
* Evaluates a PHPUnit_Framework_Constraint matcher object.
*
* @param mixed$value
* @param PHPUnit_Framework_Constraint $constraint
* @param string $message
* @since Method available since Release 3.0.0
*/
function assertThat($value, PHPUnit_Framework_Constraint $constraint, $message = '')
{
return PHPUnit_Framework_Assert::assertThat($value, $constraint, $message);
}
/**
* Asserts protocol version is valid.
*
* Protocol version MUST be:
* - String type.
* - Valid HTTP protocol version number.
*
* @param string $protocolVersion
* @param string $message
*/
public static function assertValid($protocolVersion, $message = '')
{
Assert::assertThat($protocolVersion, new self(), $message);
}
public function processObjectFreeze()
{
PHPUnit_Framework_Assert::assertThat(true, PHPUnit_Framework_Assert::isTrue());
}
/**
* @Then the response should be json/JSON
* @Then the response is json/JSON
*/
public function theResponseIsJson()
{
Assert::assertThat(static::$response->headers->get('Content-Type'), Assert::logicalOr(Assert::stringStartsWith('application/json'), Assert::stringStartsWith('text/javascript')));
Assert::assertJson($this->getResponseContent());
}
public function shouldNotContain($value)
{
Assert::assertThat($this->it, Assert::logicalNot(Assert::contains($value)));
}
public static function assertRequestIsDelete(RequestInterface $request)
{
Assert::assertThat($request, static::isDelete());
}
/**
* Asserts two objects are the same type but not the same instance.
*
* @param object $original
* @param object $new
* @param string $message
*/
public static function assertImmutable($original, $new, $message = '')
{
Assert::assertThat($new, new self($original), $message);
}
/**
* @param Spec $spec
* @param string $class
* @param mixed $actual
* @param string $msg
*/
protected static final function assertDefinitionSchema(Spec $spec, $class, $actual, $msg = '')
{
Assert::assertThat($actual, new JsonSchemaConstraint($spec->getDefinition($class)), $msg);
}
/**
* Run Update Customer Entity test
*
* @param Customer $initialCustomer
* @param Customer $customer
* @param Address $address
* @param AssertCustomerInfoSuccessSavedMessage $assertCustomerInfoSuccessSavedMessage
* @return void
*/
public function test(Customer $initialCustomer, Customer $customer, Address $address, AssertCustomerInfoSuccessSavedMessage $assertCustomerInfoSuccessSavedMessage)
{
// Preconditions
$initialCustomer->persist();
// Steps
$this->objectManager->create('Magento\\Customer\\Test\\TestStep\\LoginCustomerOnFrontendStep', ['customer' => $initialCustomer])->run();
$this->customerAccountIndex->getInfoBlock()->openEditContactInfo();
$this->customerAccountEdit->getAccountInfoForm()->fill($customer);
$this->customerAccountEdit->getAccountInfoForm()->submit();
\PHPUnit_Framework_Assert::assertThat($this->getName(), $assertCustomerInfoSuccessSavedMessage);
$this->cmsIndex->getCmsPageBlock()->waitPageInit();
$this->customerAccountIndex->getDashboardAddress()->editBillingAddress();
$this->customerAddressEdit->getEditForm()->fill($address);
$this->customerAddressEdit->getEditForm()->saveAddress();
}
/**
* Perform assert.
*
* @param AbstractConstraint $assert
* @param InjectableFixture $product
* @return void
*/
protected function productCompareAssert(AbstractConstraint $assert, InjectableFixture $product)
{
$assert->configure(['catalogProductView' => $this->catalogProductView, 'product' => $product]);
\PHPUnit_Framework_Assert::assertThat($this->getName(), $assert);
}
/**
* Assert a value with a constraint.
*
* @param mixed $value
* @param Constraint $constraint
* @param string $message
*
* @return self
*/
protected function assert($value, Constraint $constraint, $message = '')
{
Assert::assertThat($value, $constraint, $message);
return $this;
}
public function toBeJson()
{
if ($this->negate) {
a::assertThat($this->actual, a::logicalAnd(a::isType('string'), a::logicalNot(a::isJson())));
} else {
a::assertJson($this->actual);
}
}
/**
* Assert that a JSON document matches a given JSON schema.
*
* @param mixed $jsonDocument A JSON document. If this is a string, it will
* be assumed to be an encoded JSON document
* @param array $schema A JSON schema
* @return void
*/
public static function assertJsonDocumentMatchesSchema($jsonDocument, $schema)
{
Assert::assertThat($jsonDocument, new JsonValueMatchesSchema($schema));
}
/**
* Checks that haystack doesn't attend
*
* @param $haystack
* @param $constraint
* @param string $message
*/
protected function assertThatItsNot($haystack, $constraint, $message)
{
$constraint = new \PHPUnit_Framework_Constraint_Not($constraint);
\PHPUnit_Framework_Assert::assertThat($haystack, $constraint, $message);
}
public static function assertJsonStringEqualsJsonString($expectedJson, $actualJson, $message = '')
{
Assertions::assertJson($expectedJson, $message);
Assertions::assertJson($actualJson, $message);
$expected = json_decode($expectedJson);
$actual = json_decode($actualJson);
Assertions::assertThat($actual, new ConstraintIsSimilar($expected), $message);
}
/**
* Run Update Customer Entity test
*
* @param Customer $initialCustomer
* @param Customer $customer
* @param Address $address
* @param AssertCustomerInfoSuccessSavedMessage $assertCustomerInfoSuccessSavedMessage
* @return void
*/
public function test(Customer $initialCustomer, Customer $customer, Address $address, AssertCustomerInfoSuccessSavedMessage $assertCustomerInfoSuccessSavedMessage)
{
// Preconditions
$initialCustomer->persist();
// Steps
$this->cmsIndex->open();
$this->cmsIndex->getLinksBlock()->openLink('Log In');
sleep(3);
$this->customerAccountLogin->getLoginBlock()->fill($initialCustomer);
$this->customerAccountLogin->getLoginBlock()->submit();
$this->customerAccountIndex->getInfoBlock()->openEditContactInfo();
$this->customerAccountEdit->getAccountInfoForm()->fill($customer);
$this->customerAccountEdit->getAccountInfoForm()->submit();
\PHPUnit_Framework_Assert::assertThat($this->getName(), $assertCustomerInfoSuccessSavedMessage);
$this->customerAccountIndex->getDashboardAddress()->editBillingAddress();
$this->customerAddressEdit->getEditForm()->fill($address);
$this->customerAddressEdit->getEditForm()->saveAddress();
}
/**
* Assert that an html button tag does not exist inside the current tag
* @param string|array $selector
* @param array $filters
* @param string $message
* @return Functest_Node $this
*/
public static function assertHasNoButton($node, $selector, array $filters = array(), $message = NULL)
{
return \PHPUnit_Framework_Assert::assertThat($node, new Constraint_Locator_Negative('button', $selector, $filters), $message);
}