/**
* @When I create an expense list named :name
*/
public function iCreateAnExpenseListNamed($name)
{
$json = <<<JSON
{
"name": "{$name}"
}
JSON;
$this->client->request('POST', '/expense_list/', [], [], ['CONTENT_TYPE' => 'application/json'], $json);
$response = $this->client->getResponse();
PHPUnit_Framework_Assert::assertEquals(Response::HTTP_CREATED, $response->getStatusCode());
PHPUnit_Framework_Assert::assertJson($response->getContent());
$responseData = json_decode($response->getContent());
PHPUnit_Framework_Assert::assertNotNull($responseData);
PHPUnit_Framework_Assert::assertObjectHasAttribute('id', $responseData);
$this->expenseListId = $responseData->id;
}
/**
* Returns the value of an object's attribute.
* This also works for attributes that are declared protected or private.
*
* @param object $object
* @param string $attributeName
* @return mixed
* @throws InvalidArgumentException
* @since Method available since Release 3.4.0
*/
public static function getObjectAttribute($object, $attributeName)
{
if (!is_object($object)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(1, 'object');
}
if (!is_string($attributeName)) {
throw PHPUnit_Util_InvalidArgumentHelper::factory(2, 'string');
}
PHPUnit_Framework_Assert::assertObjectHasAttribute($attributeName, $object);
try {
$attribute = new ReflectionProperty($object, $attributeName);
} catch (ReflectionException $e) {
$reflector = new ReflectionObject($object);
while ($reflector = $reflector->getParentClass()) {
try {
$attribute = $reflector->getProperty($attributeName);
break;
} catch (ReflectionException $e) {
}
}
}
if ($attribute == NULL || $attribute->isPublic()) {
return $object->{$attributeName};
} else {
$array = (array) $object;
$protectedName = "*" . $attributeName;
if (array_key_exists($protectedName, $array)) {
return $array[$protectedName];
} else {
$classes = self::getHierarchy(get_class($object));
foreach ($classes as $class) {
$privateName = sprintf("%s%s", $class, $attributeName);
if (array_key_exists($privateName, $array)) {
return $array[$privateName];
}
}
}
}
throw new PHPUnit_Framework_Exception(sprintf('Attribute "%s" not found in object.', $attributeName));
}
/**
* Asserts that an object has a specified attribute.
*
* @param string $attributeName
* @param object $object
* @param string $message
* @since Method available since Release 3.0.0
*/
function assertObjectHasAttribute($attributeName, $object, $message = '')
{
return PHPUnit_Framework_Assert::assertObjectHasAttribute($attributeName, $object, $message);
}
public function hasAttribute($attribute)
{
if (is_string($attribute)) {
a::assertClassHasAttribute($attribute, $this->actual, $this->description);
} else {
a::assertObjectHasAttribute($attribute, $this->actual, $this->description);
}
}
/**
* @Then there should be a :key property in the response
*/
public function thereShouldBeAPropertyInTheResponse($key)
{
PHPUnit::assertObjectHasAttribute($key, $this->responseJSON());
}
/**
* Expect that a class or an object has a specified attribute.
*
* @param string $attributeName
* @param string $message
*
* @return Expect
*/
public function toHaveAttribute($attributeName, $message = '')
{
if (is_string($this->value)) {
// class
Assert::assertClassHasAttribute($attributeName, $this->value, $message);
} else {
// object
Assert::assertObjectHasAttribute($attributeName, $this->value, $message);
}
return $this;
}
/**
* @When open task with id :arg1
*/
public function openTaskWithId($arg1)
{
$task = new Task($this->pdo);
$this->task = $task->read($arg1);
UT::assertObjectHasAttribute('title', $this->task);
}
/**
* Assert that the document has an errors key, and return an errors tester.
*
* @param string|null $message
* @return ErrorsTester
*/
public function assertErrors($message = null)
{
$message = $message ?: 'Document does not contain errors.';
PHPUnit::assertObjectHasAttribute(Keys::KEYWORD_ERRORS, $this->document, $message);
return new ErrorsTester((array) $this->document->{Keys::KEYWORD_ERRORS});
}
/**
* Validate Jwt token data
*
* @param string $token_field_name
* @param PyStringNode $jsonString
*
* @Then /^(?:the )?response should contain jwt token in field "([^"]*)" with data:$/
*/
public function responseShouldContainJwtTokenInFieldWithData($token_field_name, PyStringNode $jsonString)
{
$expected = json_decode($this->replacePlaceHolder($jsonString->getRaw()), true);
$response = $this->response->json();
Assertions::assertArrayHasKey($token_field_name, $response);
$actual = \JWT::decode($response[$token_field_name], $this->config['secret_key']);
foreach ($expected as $key => $needle) {
Assertions::assertObjectHasAttribute($key, $actual);
Assertions::assertEquals($expected[$key], $actual->{$key});
}
}
public function toHaveAttribute($attributeName)
{
\PHPUnit_Framework_Assert::assertObjectHasAttribute($attributeName, $this->actual);
}
/**
* @Given /^the key "([^"]*)" should have a subkey "([^"]*)" in index (\d+)$/
*/
public function theKeyShouldHaveASubKeyInSpecificIndex($keyword, $subkeyword, $index)
{
$value = json_decode($this->getResponse()->getBody())->{$keyword};
Assertions::assertObjectHasAttribute($subkeyword, $value[$index]);
}
public function hasAttribute($attribute)
{
Assert::assertObjectHasAttribute($attribute, $this->actual, $this->description);
return $this;
}
public function testJsonDataResponse()
{
$path = '/test/path';
$headers = array('h1' => 'a', 'h2' => 'b');
$parameters = array('p1' => 'c', 'p2' => 'd');
$method = AbstractClient::METHOD_GET;
$responseData = array('status' => 'ok', 'data' => 123, 'message' => 'This is a test');
$responseContent = json_encode($responseData);
$mockAdapter = new MockAdapter();
// Adds mock basic OK response
$mockAdapter->addResponseBy(Response::STATUS_OK, '', $responseContent);
// Add mock adapter
$this->_client->setAdapter($mockAdapter);
// Send request
$data = $this->_client->get($path, $parameters, $headers);
// Gets response object
$response = $this->_client->getResponse();
// Content is being returned correctly
\PHPUnit_Framework_Assert::assertJson($response->getRawContent());
\PHPUnit_Framework_Assert::assertJsonStringEqualsJsonString($responseContent, $response->getRawContent());
// Content is being parsed correctly (json)
\PHPUnit_Framework_Assert::assertInternalType(\PHPUnit_Framework_Constraint_IsType::TYPE_OBJECT, $data);
// Check data parsed
foreach ($responseData as $key => $value) {
\PHPUnit_Framework_Assert::assertObjectHasAttribute($key, $data);
\PHPUnit_Framework_Assert::assertEquals($value, $data->{$key});
}
\PHPUnit_Framework_Assert::assertTrue($response->isOK());
}
/**
* @Then the result should have the property :propertyName on it
*/
public function theResultShouldHaveThePropertyOnIt($propertyName)
{
\PHPUnit_Framework_Assert::assertObjectHasAttribute($propertyName, $this->result);
}