PHP PHPUnit_Framework_Assert::assertObjectHasAttribute方法代码示例

    /**
     * @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);
 }