| Current File : /home/k/a/r/karenpetzb/www/items/category/Test.zip |
PK �$H[�`6�- �- PHPUnit/Constraint/DomQuery.phpnu &1i� <?php
/** PHPUnit_Framework_Constraint */
require_once 'PHPUnit/Framework/Constraint.php';
/** Zend_Dom_Query */
require_once 'Zend/Dom/Query.php';
/**
* Zend_Dom_Query-based PHPUnit Constraint
*
* @uses PHPUnit_Framework_Constraint
* @package Zend_Test
* @subpackage PHPUnit
* @copyright Copyright (C) 2008 - Present, Zend Technologies, Inc.
* @license New BSD {@link http://framework.zend.com/license/new-bsd}
*/
class Zend_Test_PHPUnit_Constraint_DomQuery extends PHPUnit_Framework_Constraint
{
/**#@+
* @const string Assertion type constants
*/
const ASSERT_QUERY = 'assertQuery';
const ASSERT_CONTENT_CONTAINS = 'assertQueryContentContains';
const ASSERT_CONTENT_REGEX = 'assertQueryContentRegex';
const ASSERT_CONTENT_COUNT = 'assertQueryCount';
const ASSERT_CONTENT_COUNT_MIN= 'assertQueryCountMin';
const ASSERT_CONTENT_COUNT_MAX= 'assertQueryCountMax';
/**#@-*/
/**
* Current assertion type
* @var string
*/
protected $_assertType = null;
/**
* Available assertion types
* @var array
*/
protected $_assertTypes = array(
self::ASSERT_QUERY,
self::ASSERT_CONTENT_CONTAINS,
self::ASSERT_CONTENT_REGEX,
self::ASSERT_CONTENT_COUNT,
self::ASSERT_CONTENT_COUNT_MIN,
self::ASSERT_CONTENT_COUNT_MAX,
);
/**
* Content being matched
* @var string
*/
protected $_content = null;
/**
* Whether or not assertion is negated
* @var bool
*/
protected $_negate = false;
/**
* CSS selector or XPath path to select against
* @var string
*/
protected $_path = null;
/**
* Whether or not to use XPath when querying
* @var bool
*/
protected $_useXpath = false;
/**
* Constructor; setup constraint state
*
* @param string $path CSS selector path
* @return void
*/
public function __construct($path)
{
$this->_path = $path;
}
/**
* Indicate negative match
*
* @param bool $flag
* @return void
*/
public function setNegate($flag = true)
{
$this->_negate = $flag;
}
/**
* Whether or not path is a straight XPath expression
*
* @param bool $flag
* @return Zend_Test_PHPUnit_Constraint_DomQuery
*/
public function setUseXpath($flag = true)
{
$this->_useXpath = (bool) $flag;
return $this;
}
/**
* Evaluate an object to see if it fits the constraints
*
* @param string $other String to examine
* @param null|string Assertion type
* @return bool
*/
public function evaluate($other, $assertType = null)
{
if (strstr($assertType, 'Not')) {
$this->setNegate(true);
$assertType = str_replace('Not', '', $assertType);
}
if (strstr($assertType, 'Xpath')) {
$this->setUseXpath(true);
$assertType = str_replace('Xpath', 'Query', $assertType);
}
if (!in_array($assertType, $this->_assertTypes)) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception(sprintf('Invalid assertion type "%s" provided to %s constraint', $assertType, __CLASS__));
}
$this->_assertType = $assertType;
$method = $this->_useXpath ? 'queryXpath' : 'query';
$domQuery = new Zend_Dom_Query($other);
$result = $domQuery->$method($this->_path);
$argv = func_get_args();
$argc = func_num_args();
switch ($assertType) {
case self::ASSERT_CONTENT_CONTAINS:
if (3 > $argc) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('No content provided against which to match');
}
$this->_content = $content = $argv[2];
return ($this->_negate)
? $this->_notMatchContent($result, $content)
: $this->_matchContent($result, $content);
case self::ASSERT_CONTENT_REGEX:
if (3 > $argc) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('No pattern provided against which to match');
}
$this->_content = $content = $argv[2];
return ($this->_negate)
? $this->_notRegexContent($result, $content)
: $this->_regexContent($result, $content);
case self::ASSERT_CONTENT_COUNT:
case self::ASSERT_CONTENT_COUNT_MIN:
case self::ASSERT_CONTENT_COUNT_MAX:
if (3 > $argc) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('No count provided against which to compare');
}
$this->_content = $content = $argv[2];
return $this->_countContent($result, $content, $assertType);
case self::ASSERT_QUERY:
default:
if ($this->_negate) {
return (0 == count($result));
} else {
return (0 != count($result));
}
}
}
/**
* Report Failure
*
* @see PHPUnit_Framework_Constraint for implementation details
* @param mixed $other CSS selector path
* @param string $description
* @param bool $not
* @return void
* @throws PHPUnit_Framework_ExpectationFailedException
*/
public function fail($other, $description, $not = false)
{
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
switch ($this->_assertType) {
case self::ASSERT_CONTENT_CONTAINS:
$failure = 'Failed asserting node denoted by %s CONTAINS content "%s"';
if ($this->_negate) {
$failure = 'Failed asserting node DENOTED BY %s DOES NOT CONTAIN content "%s"';
}
$failure = sprintf($failure, $other, $this->_content);
break;
case self::ASSERT_CONTENT_REGEX:
$failure = 'Failed asserting node denoted by %s CONTAINS content MATCHING "%s"';
if ($this->_negate) {
$failure = 'Failed asserting node DENOTED BY %s DOES NOT CONTAIN content MATCHING "%s"';
}
$failure = sprintf($failure, $other, $this->_content);
break;
case self::ASSERT_CONTENT_COUNT:
$failure = 'Failed asserting node DENOTED BY %s OCCURS EXACTLY %d times';
if ($this->_negate) {
$failure = 'Failed asserting node DENOTED BY %s DOES NOT OCCUR EXACTLY %d times';
}
$failure = sprintf($failure, $other, $this->_content);
break;
case self::ASSERT_CONTENT_COUNT_MIN:
$failure = 'Failed asserting node DENOTED BY %s OCCURS AT LEAST %d times';
$failure = sprintf($failure, $other, $this->_content);
break;
case self::ASSERT_CONTENT_COUNT_MAX:
$failure = 'Failed asserting node DENOTED BY %s OCCURS AT MOST %d times';
$failure = sprintf($failure, $other, $this->_content);
break;
case self::ASSERT_QUERY:
default:
$failure = 'Failed asserting node DENOTED BY %s EXISTS';
if ($this->_negate) {
$failure = 'Failed asserting node DENOTED BY %s DOES NOT EXIST';
}
$failure = sprintf($failure, $other);
break;
}
if (!empty($description)) {
$failure = $description . "\n" . $failure;
}
throw new Zend_Test_PHPUnit_Constraint_Exception($failure);
}
/**
* Complete implementation
*
* @return string
*/
public function toString()
{
return '';
}
/**
* Check to see if content is matched in selected nodes
*
* @param Zend_Dom_Query_Result $result
* @param string $match Content to match
* @return bool
*/
protected function _matchContent($result, $match)
{
if (0 == count($result)) {
return false;
}
foreach ($result as $node) {
$content = $this->_getNodeContent($node);
if (strstr($content, $match)) {
return true;
}
}
return false;
}
/**
* Check to see if content is NOT matched in selected nodes
*
* @param Zend_Dom_Query_Result $result
* @param string $match
* @return bool
*/
protected function _notMatchContent($result, $match)
{
if (0 == count($result)) {
return true;
}
foreach ($result as $node) {
$content = $this->_getNodeContent($node);
if (strstr($content, $match)) {
return false;
}
}
return true;
}
/**
* Check to see if content is matched by regex in selected nodes
*
* @param Zend_Dom_Query_Result $result
* @param string $pattern
* @return bool
*/
protected function _regexContent($result, $pattern)
{
if (0 == count($result)) {
return false;
}
foreach ($result as $node) {
$content = $this->_getNodeContent($node);
if (preg_match($pattern, $content)) {
return true;
}
}
return false;
}
/**
* Check to see if content is NOT matched by regex in selected nodes
*
* @param Zend_Dom_Query_Result $result
* @param string $pattern
* @return bool
*/
protected function _notRegexContent($result, $pattern)
{
if (0 == count($result)) {
return true;
}
foreach ($result as $node) {
$content = $this->_getNodeContent($node);
if (preg_match($pattern, $content)) {
return false;
}
}
return true;
}
/**
* Determine if content count matches criteria
*
* @param Zend_Dom_Query_Result $result
* @param int $test Value against which to test
* @param string $type assertion type
* @return boolean
*/
protected function _countContent($result, $test, $type)
{
$count = count($result);
switch ($type) {
case self::ASSERT_CONTENT_COUNT:
return ($this->_negate)
? ($test != $count)
: ($test == $count);
case self::ASSERT_CONTENT_COUNT_MIN:
return ($count >= $test);
case self::ASSERT_CONTENT_COUNT_MAX:
return ($count <= $test);
default:
return false;
}
}
/**
* Get node content, minus node markup tags
*
* @param DOMNode $node
* @return string
*/
protected function _getNodeContent(DOMNode $node)
{
$doc = $node->ownerDocument;
$content = $doc->saveXML($node);
$tag = $node->nodeName;
$regex = '|</?' . $tag . '[^>]*>|';
return preg_replace($regex, '', $content);
}
}
PK �$H[�e�� PHPUnit/Constraint/Exception.phpnu &1i� <?php
/** PHPUnit_Framework_ExpectationFailedException */
require_once 'PHPUnit/Framework/ExpectationFailedException.php';
/**
* Zend_Test_PHPUnit_Constraint_Exception
*
* @uses PHPUnit_Framework_ExpectationFailedException
* @package Zend_Test
* @subpackage PHPUnit
* @copyright Copyright (C) 2008 - Present, Zend Technologies, Inc.
* @license New BSD {@link http://framework.zend.com/license/new-bsd}
*/
class Zend_Test_PHPUnit_Constraint_Exception extends PHPUnit_Framework_ExpectationFailedException
{
}
PK �$H[���.� � PHPUnit/Constraint/Redirect.phpnu &1i� <?php
/** PHPUnit_Framework_Constraint */
require_once 'PHPUnit/Framework/Constraint.php';
/**
* Redirection constraints
*
* @uses PHPUnit_Framework_Constraint
* @package Zend_Test
* @subpackage PHPUnit
* @copyright Copyright (C) 2008 - Present, Zend Technologies, Inc.
* @license New BSD {@link http://framework.zend.com/license/new-bsd}
*/
class Zend_Test_PHPUnit_Constraint_Redirect extends PHPUnit_Framework_Constraint
{
/**#@+
* @const string Assertion type constants
*/
const ASSERT_REDIRECT = 'assertRedirect';
const ASSERT_REDIRECT_TO = 'assertRedirectTo';
const ASSERT_REDIRECT_REGEX = 'assertRedirectRegex';
/**#@-*/
/**
* Current assertion type
* @var string
*/
protected $_assertType = null;
/**
* Available assertion types
* @var array
*/
protected $_assertTypes = array(
self::ASSERT_REDIRECT,
self::ASSERT_REDIRECT_TO,
self::ASSERT_REDIRECT_REGEX,
);
/**
* Pattern to match against
* @var string
*/
protected $_match = null;
/**
* Whether or not assertion is negated
* @var bool
*/
protected $_negate = false;
/**
* Constructor; setup constraint state
*
* @return void
*/
public function __construct()
{
}
/**
* Indicate negative match
*
* @param bool $flag
* @return void
*/
public function setNegate($flag = true)
{
$this->_negate = $flag;
}
/**
* Evaluate an object to see if it fits the constraints
*
* @param string $other String to examine
* @param null|string Assertion type
* @return bool
*/
public function evaluate($other, $assertType = null)
{
if (!$other instanceof Zend_Controller_Response_Abstract) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('Redirect constraint assertions require a response object');
}
if (strstr($assertType, 'Not')) {
$this->setNegate(true);
$assertType = str_replace('Not', '', $assertType);
}
if (!in_array($assertType, $this->_assertTypes)) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception(sprintf('Invalid assertion type "%s" provided to %s constraint', $assertType, __CLASS__));
}
$this->_assertType = $assertType;
$response = $other;
$argv = func_get_args();
$argc = func_num_args();
switch ($assertType) {
case self::ASSERT_REDIRECT_TO:
if (3 > $argc) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('No redirect URL provided against which to match');
}
$this->_match = $match = $argv[2];
return ($this->_negate)
? $this->_notMatch($response, $match)
: $this->_match($response, $match);
case self::ASSERT_REDIRECT_REGEX:
if (3 > $argc) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('No pattern provided against which to match redirect');
}
$this->_match = $match = $argv[2];
return ($this->_negate)
? $this->_notRegex($response, $match)
: $this->_regex($response, $match);
case self::ASSERT_REDIRECT:
default:
return ($this->_negate) ? !$response->isRedirect() : $response->isRedirect();
}
}
/**
* Report Failure
*
* @see PHPUnit_Framework_Constraint for implementation details
* @param mixed $other
* @param string $description Additional message to display
* @param bool $not
* @return void
* @throws PHPUnit_Framework_ExpectationFailedException
*/
public function fail($other, $description, $not = false)
{
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
switch ($this->_assertType) {
case self::ASSERT_REDIRECT_TO:
$failure = 'Failed asserting response redirects to "%s"';
if ($this->_negate) {
$failure = 'Failed asserting response DOES NOT redirect to "%s"';
}
$failure = sprintf($failure, $this->_match);
break;
case self::ASSERT_REDIRECT_REGEX:
$failure = 'Failed asserting response redirects to URL MATCHING "%s"';
if ($this->_negate) {
$failure = 'Failed asserting response DOES NOT redirect to URL MATCHING "%s"';
}
$failure = sprintf($failure, $this->_match);
break;
case self::ASSERT_REDIRECT:
default:
$failure = 'Failed asserting response is a redirect';
if ($this->_negate) {
$failure = 'Failed asserting response is NOT a redirect';
}
break;
}
if (!empty($description)) {
$failure = $description . "\n" . $failure;
}
throw new Zend_Test_PHPUnit_Constraint_Exception($failure);
}
/**
* Complete implementation
*
* @return string
*/
public function toString()
{
return '';
}
/**
* Check to see if content is matched in selected nodes
*
* @param Zend_Controller_Response_HttpTestCase $response
* @param string $match Content to match
* @return bool
*/
protected function _match($response, $match)
{
if (!$response->isRedirect()) {
return false;
}
$headers = $response->sendHeaders();
$redirect = $headers['location'];
$redirect = str_replace('Location: ', '', $redirect);
return ($redirect == $match);
}
/**
* Check to see if content is NOT matched in selected nodes
*
* @param Zend_Controller_Response_HttpTestCase $response
* @param string $match
* @return bool
*/
protected function _notMatch($response, $match)
{
if (!$response->isRedirect()) {
return true;
}
$headers = $response->sendHeaders();
$redirect = $headers['location'];
$redirect = str_replace('Location: ', '', $redirect);
return ($redirect != $match);
}
/**
* Check to see if content is matched by regex in selected nodes
*
* @param Zend_Controller_Response_HttpTestCase $response
* @param string $pattern
* @return bool
*/
protected function _regex($response, $pattern)
{
if (!$response->isRedirect()) {
return false;
}
$headers = $response->sendHeaders();
$redirect = $headers['location'];
$redirect = str_replace('Location: ', '', $redirect);
return preg_match($pattern, $redirect);
}
/**
* Check to see if content is NOT matched by regex in selected nodes
*
* @param Zend_Controller_Response_HttpTestCase $response
* @param string $pattern
* @return bool
*/
protected function _notRegex($response, $pattern)
{
if (!$response->isRedirect()) {
return true;
}
$headers = $response->sendHeaders();
$redirect = $headers['location'];
$redirect = str_replace('Location: ', '', $redirect);
return !preg_match($pattern, $redirect);
}
}
PK �$H[-��9t0 t0 % PHPUnit/Constraint/ResponseHeader.phpnu &1i� <?php
/** PHPUnit_Framework_Constraint */
require_once 'PHPUnit/Framework/Constraint.php';
/**
* Response header PHPUnit Constraint
*
* @uses PHPUnit_Framework_Constraint
* @package Zend_Test
* @subpackage PHPUnit
* @copyright Copyright (C) 2008 - Present, Zend Technologies, Inc.
* @license New BSD {@link http://framework.zend.com/license/new-bsd}
*/
class Zend_Test_PHPUnit_Constraint_ResponseHeader extends PHPUnit_Framework_Constraint
{
/**#@+
* @const string Assertion type constants
*/
const ASSERT_RESPONSE_CODE = 'assertResponseCode';
const ASSERT_HEADER = 'assertHeader';
const ASSERT_HEADER_CONTAINS = 'assertHeaderContains';
const ASSERT_HEADER_REGEX = 'assertHeaderRegex';
/**#@-*/
/**
* Current assertion type
* @var string
*/
protected $_assertType = null;
/**
* Available assertion types
* @var array
*/
protected $_assertTypes = array(
self::ASSERT_RESPONSE_CODE,
self::ASSERT_HEADER,
self::ASSERT_HEADER_CONTAINS,
self::ASSERT_HEADER_REGEX,
);
/**
* @var int Response code
*/
protected $_code = 200;
/**
* @var string Header
*/
protected $_header = null;
/**
* @var string pattern against which to compare header content
*/
protected $_match = null;
/**
* Whether or not assertion is negated
* @var bool
*/
protected $_negate = false;
/**
* Constructor; setup constraint state
*
* @return void
*/
public function __construct()
{
}
/**
* Indicate negative match
*
* @param bool $flag
* @return void
*/
public function setNegate($flag = true)
{
$this->_negate = $flag;
}
/**
* Evaluate an object to see if it fits the constraints
*
* @param Zend_Controller_Response_Abstract $other String to examine
* @param null|string Assertion type
* @return bool
*/
public function evaluate($other, $assertType = null)
{
if (!$other instanceof Zend_Controller_Response_Abstract) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('Header constraint assertions require a response object');
}
if (strstr($assertType, 'Not')) {
$this->setNegate(true);
$assertType = str_replace('Not', '', $assertType);
}
if (!in_array($assertType, $this->_assertTypes)) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception(sprintf('Invalid assertion type "%s" provided to %s constraint', $assertType, __CLASS__));
}
$this->_assertType = $assertType;
$response = $other;
$argv = func_get_args();
$argc = func_num_args();
switch ($assertType) {
case self::ASSERT_RESPONSE_CODE:
if (3 > $argc) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('No response code provided against which to match');
}
$this->_code = $code = $argv[2];
return ($this->_negate)
? $this->_notCode($response, $code)
: $this->_code($response, $code);
case self::ASSERT_HEADER:
if (3 > $argc) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('No header provided against which to match');
}
$this->_header = $header = $argv[2];
return ($this->_negate)
? $this->_notHeader($response, $header)
: $this->_header($response, $header);
case self::ASSERT_HEADER_CONTAINS:
if (4 > $argc) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('Both a header name and content to match are required for ' . __FUNCTION__);
}
$this->_header = $header = $argv[2];
$this->_match = $match = $argv[3];
return ($this->_negate)
? $this->_notHeaderContains($response, $header, $match)
: $this->_headerContains($response, $header, $match);
case self::ASSERT_HEADER_REGEX:
if (4 > $argc) {
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('Both a header name and content to match are required for ' . __FUNCTION__);
}
$this->_header = $header = $argv[2];
$this->_match = $match = $argv[3];
return ($this->_negate)
? $this->_notHeaderRegex($response, $header, $match)
: $this->_headerRegex($response, $header, $match);
default:
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
throw new Zend_Test_PHPUnit_Constraint_Exception('Invalid assertion type ' . __FUNCTION__);
}
}
/**
* Report Failure
*
* @see PHPUnit_Framework_Constraint for implementation details
* @param mixed $other
* @param string $description Additional message to display
* @param bool $not
* @return void
* @throws PHPUnit_Framework_ExpectationFailedException
*/
public function fail($other, $description, $not = false)
{
require_once 'Zend/Test/PHPUnit/Constraint/Exception.php';
switch ($this->_assertType) {
case self::ASSERT_RESPONSE_CODE:
$failure = 'Failed asserting response code "%s"';
if ($this->_negate) {
$failure = 'Failed asserting response code IS NOT "%s"';
}
$failure = sprintf($failure, $this->_code);
break;
case self::ASSERT_HEADER:
$failure = 'Failed asserting response header "%s" found';
if ($this->_negate) {
$failure = 'Failed asserting response response header "%s" WAS NOT found';
}
$failure = sprintf($failure, $this->_header);
break;
case self::ASSERT_HEADER_CONTAINS:
$failure = 'Failed asserting response header "%s" exists and contains "%s"';
if ($this->_negate) {
$failure = 'Failed asserting response header "%s" DOES NOT CONTAIN "%s"';
}
$failure = sprintf($failure, $this->_header, $this->_match);
break;
case self::ASSERT_HEADER_REGEX:
$failure = 'Failed asserting response header "%s" exists and matches regex "%s"';
if ($this->_negate) {
$failure = 'Failed asserting response header "%s" DOES NOT MATCH regex "%s"';
}
$failure = sprintf($failure, $this->_header, $this->_match);
break;
default:
throw new Zend_Test_PHPUnit_Constraint_Exception('Invalid assertion type ' . __FUNCTION__);
}
if (!empty($description)) {
$failure = $description . "\n" . $failure;
}
throw new Zend_Test_PHPUnit_Constraint_Exception($failure);
}
/**
* Complete implementation
*
* @return string
*/
public function toString()
{
return '';
}
/**
* Compare response code for positive match
*
* @param Zend_Controller_Response_Abstract $response
* @param int $code
* @return bool
*/
protected function _code(Zend_Controller_Response_Abstract $response, $code)
{
$test = $this->_getCode($response);
return ($test == $code);
}
/**
* Compare response code for negative match
*
* @param Zend_Controller_Response_Abstract $response
* @param int $code
* @return bool
*/
protected function _notCode(Zend_Controller_Response_Abstract $response, $code)
{
$test = $this->_getCode($response);
return ($test != $code);
}
/**
* Retrieve response code
*
* @param Zend_Controller_Response_Abstract $response
* @return int
*/
protected function _getCode(Zend_Controller_Response_Abstract $response)
{
$test = $response->getHttpResponseCode();
if (null === $test) {
$test = 200;
}
return $test;
}
/**
* Positive check for response header presence
*
* @param Zend_Controller_Response_Abstract $response
* @param string $header
* @return bool
*/
protected function _header(Zend_Controller_Response_Abstract $response, $header)
{
return (null !== $this->_getHeader($response, $header));
}
/**
* Negative check for response header presence
*
* @param Zend_Controller_Response_Abstract $response
* @param string $header
* @return bool
*/
protected function _notHeader(Zend_Controller_Response_Abstract $response, $header)
{
return (null === $this->_getHeader($response, $header));
}
/**
* Retrieve response header
*
* @param Zend_Controller_Response_Abstract $response
* @param string $header
* @return string|null
*/
protected function _getHeader(Zend_Controller_Response_Abstract $response, $header)
{
$headers = $response->sendHeaders();
$header = strtolower($header);
if (array_key_exists($header, $headers)) {
return $headers[$header];
}
return null;
}
/**
* Positive check for header contents matching pattern
*
* @param Zend_Controller_Response_Abstract $response
* @param string $header
* @param string $match
* @return bool
*/
protected function _headerContains(Zend_Controller_Response_Abstract $response, $header, $match)
{
if (null === ($fullHeader = $this->_getHeader($response, $header))) {
return false;
}
$contents = str_replace($header . ': ', '', $fullHeader);
return (strstr($contents, $match));
}
/**
* Negative check for header contents matching pattern
*
* @param Zend_Controller_Response_Abstract $response
* @param string $header
* @param string $match
* @return bool
*/
protected function _notHeaderContains(Zend_Controller_Response_Abstract $response, $header, $match)
{
if (null === ($fullHeader = $this->_getHeader($response, $header))) {
return true;
}
$contents = str_replace($header . ': ', '', $fullHeader);
return (!strstr($contents, $match));
}
/**
* Positive check for header contents matching regex
*
* @param Zend_Controller_Response_Abstract $response
* @param string $header
* @param string $pattern
* @return bool
*/
protected function _headerRegex(Zend_Controller_Response_Abstract $response, $header, $pattern)
{
if (null === ($fullHeader = $this->_getHeader($response, $header))) {
return false;
}
$contents = str_replace($header . ': ', '', $fullHeader);
return preg_match($pattern, $contents);
}
/**
* Negative check for header contents matching regex
*
* @param Zend_Controller_Response_Abstract $response
* @param string $header
* @param string $pattern
* @return bool
*/
protected function _notHeaderRegex(Zend_Controller_Response_Abstract $response, $header, $pattern)
{
if (null === ($fullHeader = $this->_getHeader($response, $header))) {
return true;
}
$contents = str_replace($header . ': ', '', $fullHeader);
return !preg_match($pattern, $contents);
}
}
PK �$H[�]�6b� b� PHPUnit/ControllerTestCase.phpnu &1i� <?php
/** PHPUnit_Framework_TestCase */
require_once 'PHPUnit/Framework/TestCase.php';
/** PHPUnit_Runner_Version */
require_once 'PHPUnit/Runner/Version.php';
/** Zend_Controller_Front */
require_once 'Zend/Controller/Front.php';
/** Zend_Controller_Action_HelperBroker */
require_once 'Zend/Controller/Action/HelperBroker.php';
/** Zend_Layout */
require_once 'Zend/Layout.php';
/** Zend_Session */
require_once 'Zend/Session.php';
/** Zend_Registry */
require_once 'Zend/Registry.php';
/**
* Functional testing scaffold for MVC applications
*
* @uses PHPUnit_Framework_TestCase
* @package Zend_Test
* @subpackage PHPUnit
* @copyright Copyright (C) 2008 - Present, Zend Technologies, Inc.
* @license New BSD {@link http://framework.zend.com/license/new-bsd}
*/
abstract class Zend_Test_PHPUnit_ControllerTestCase extends PHPUnit_Framework_TestCase
{
/**
* @var mixed Bootstrap file path or callback
*/
public $bootstrap;
/**
* @var Zend_Controller_Front
*/
protected $_frontController;
/**
* @var Zend_Dom_Query
*/
protected $_query;
/**
* @var Zend_Controller_Request_Abstract
*/
protected $_request;
/**
* @var Zend_Controller_Response_Abstract
*/
protected $_response;
/**
* Overlaoding: prevent overloading to special properties
*
* @param string $name
* @param mixed $value
* @return void
*/
public function __set($name, $value)
{
if (in_array($name, array('request', 'response', 'frontController'))) {
throw new Zend_Exception(sprintf('Setting %s object manually is not allowed', $name));
}
$this->$name = $value;
}
/**
* Overloading for common properties
*
* Provides overloading for request, response, and frontController objects.
*
* @param mixed $name
* @return void
*/
public function __get($name)
{
switch ($name) {
case 'request':
return $this->getRequest();
case 'response':
return $this->getResponse();
case 'frontController':
return $this->getFrontController();
}
return null;
}
/**
* Set up MVC app
*
* Calls {@link bootstrap()} by default
*
* @return void
*/
protected function setUp()
{
$this->bootstrap();
}
/**
* Bootstrap the front controller
*
* Resets the front controller, and then bootstraps it.
*
* If {@link $bootstrap} is a callback, executes it; if it is a file, it include's
* it. When done, sets the test case request and response objects into the
* front controller.
*
* @return void
*/
final public function bootstrap()
{
$this->reset();
if (null !== $this->bootstrap) {
if (is_callable($this->bootstrap)) {
call_user_func($this->bootstrap);
} elseif (is_string($this->bootstrap)) {
require_once 'Zend/Loader.php';
if (Zend_Loader::isReadable($this->bootstrap)) {
include $this->bootstrap;
}
}
}
$this->frontController
->setRequest($this->getRequest())
->setResponse($this->getResponse());
}
/**
* Dispatch the MVC
*
* If a URL is provided, sets it as the request URI in the request object.
* Then sets test case request and response objects in front controller,
* disables throwing exceptions, and disables returning the response.
* Finally, dispatches the front controller.
*
* @param string|null $url
* @return void
*/
public function dispatch($url = null)
{
// redirector should not exit
$redirector = Zend_Controller_Action_HelperBroker::getStaticHelper('redirector');
$redirector->setExit(false);
// json helper should not exit
$json = Zend_Controller_Action_HelperBroker::getStaticHelper('json');
$json->suppressExit = true;
$request = $this->getRequest();
if (null !== $url) {
$request->setRequestUri($url);
}
$request->setPathInfo(null);
$controller = $this->getFrontController();
$this->frontController
->setRequest($request)
->setResponse($this->getResponse())
->throwExceptions(false)
->returnResponse(false);
$this->frontController->dispatch();
}
/**
* Reset MVC state
*
* Creates new request/response objects, resets the front controller
* instance, and resets the action helper broker.
*
* @todo Need to update Zend_Layout to add a resetInstance() method
* @return void
*/
public function reset()
{
$_SESSION = array();
$_GET = array();
$_POST = array();
$_COOKIE = array();
$this->resetRequest();
$this->resetResponse();
Zend_Layout::resetMvcInstance();
Zend_Controller_Action_HelperBroker::resetHelpers();
$this->frontController->resetInstance();
Zend_Session::$_unitTestEnabled = true;
}
/**
* Rest all view placeholders
*
* @return void
*/
protected function _resetPlaceholders()
{
$registry = Zend_Registry::getInstance();
$remove = array();
foreach ($registry as $key => $value) {
if (strstr($key, '_View_')) {
$remove[] = $key;
}
}
foreach ($remove as $key) {
unset($registry[$key]);
}
}
/**
* Reset the request object
*
* Useful for test cases that need to test multiple trips to the server.
*
* @return Zend_Test_PHPUnit_ControllerTestCase
*/
public function resetRequest()
{
$this->_request = null;
return $this;
}
/**
* Reset the response object
*
* Useful for test cases that need to test multiple trips to the server.
*
* @return Zend_Test_PHPUnit_ControllerTestCase
*/
public function resetResponse()
{
$this->_response = null;
$this->_resetPlaceholders();
return $this;
}
/**
* Assert against DOM selection
*
* @param string $path CSS selector path
* @param string $message
* @return void
*/
public function assertQuery($path, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against DOM selection
*
* @param string $path CSS selector path
* @param string $message
* @return void
*/
public function assertNotQuery($path, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against DOM selection; node should contain content
*
* @param string $path CSS selector path
* @param string $match content that should be contained in matched nodes
* @param string $message
* @return void
*/
public function assertQueryContentContains($path, $match, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $match)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against DOM selection; node should NOT contain content
*
* @param string $path CSS selector path
* @param string $match content that should NOT be contained in matched nodes
* @param string $message
* @return void
*/
public function assertNotQueryContentContains($path, $match, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $match)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against DOM selection; node should match content
*
* @param string $path CSS selector path
* @param string $pattern Pattern that should be contained in matched nodes
* @param string $message
* @return void
*/
public function assertQueryContentRegex($path, $pattern, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $pattern)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against DOM selection; node should NOT match content
*
* @param string $path CSS selector path
* @param string $pattern pattern that should NOT be contained in matched nodes
* @param string $message
* @return void
*/
public function assertNotQueryContentRegex($path, $pattern, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $pattern)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against DOM selection; should contain exact number of nodes
*
* @param string $path CSS selector path
* @param string $count Number of nodes that should match
* @param string $message
* @return void
*/
public function assertQueryCount($path, $count, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $count)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against DOM selection; should NOT contain exact number of nodes
*
* @param string $path CSS selector path
* @param string $count Number of nodes that should NOT match
* @param string $message
* @return void
*/
public function assertNotQueryCount($path, $count, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $count)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against DOM selection; should contain at least this number of nodes
*
* @param string $path CSS selector path
* @param string $count Minimum number of nodes that should match
* @param string $message
* @return void
*/
public function assertQueryCountMin($path, $count, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $count)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against DOM selection; should contain no more than this number of nodes
*
* @param string $path CSS selector path
* @param string $count Maximum number of nodes that should match
* @param string $message
* @return void
*/
public function assertQueryCountMax($path, $count, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $count)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against XPath selection
*
* @param string $path XPath path
* @param string $message
* @return void
*/
public function assertXpath($path, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against XPath selection
*
* @param string $path XPath path
* @param string $message
* @return void
*/
public function assertNotXpath($path, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against XPath selection; node should contain content
*
* @param string $path XPath path
* @param string $match content that should be contained in matched nodes
* @param string $message
* @return void
*/
public function assertXpathContentContains($path, $match, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $match)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against XPath selection; node should NOT contain content
*
* @param string $path XPath path
* @param string $match content that should NOT be contained in matched nodes
* @param string $message
* @return void
*/
public function assertNotXpathContentContains($path, $match, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $match)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against XPath selection; node should match content
*
* @param string $path XPath path
* @param string $pattern Pattern that should be contained in matched nodes
* @param string $message
* @return void
*/
public function assertXpathContentRegex($path, $pattern, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $pattern)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against XPath selection; node should NOT match content
*
* @param string $path XPath path
* @param string $pattern pattern that should NOT be contained in matched nodes
* @param string $message
* @return void
*/
public function assertNotXpathContentRegex($path, $pattern, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $pattern)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against XPath selection; should contain exact number of nodes
*
* @param string $path XPath path
* @param string $count Number of nodes that should match
* @param string $message
* @return void
*/
public function assertXpathCount($path, $count, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $count)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against XPath selection; should NOT contain exact number of nodes
*
* @param string $path XPath path
* @param string $count Number of nodes that should NOT match
* @param string $message
* @return void
*/
public function assertNotXpathCount($path, $count, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $count)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against XPath selection; should contain at least this number of nodes
*
* @param string $path XPath path
* @param string $count Minimum number of nodes that should match
* @param string $message
* @return void
*/
public function assertXpathCountMin($path, $count, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $count)) {
$constraint->fail($path, $message);
}
}
/**
* Assert against XPath selection; should contain no more than this number of nodes
*
* @param string $path XPath path
* @param string $count Maximum number of nodes that should match
* @param string $message
* @return void
*/
public function assertXpathCountMax($path, $count, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/DomQuery.php';
$constraint = new Zend_Test_PHPUnit_Constraint_DomQuery($path);
$content = $this->response->outputBody();
if (!$constraint->evaluate($content, __FUNCTION__, $count)) {
$constraint->fail($path, $message);
}
}
/**
* Assert that response is a redirect
*
* @param string $message
* @return void
*/
public function assertRedirect($message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/Redirect.php';
$constraint = new Zend_Test_PHPUnit_Constraint_Redirect();
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__)) {
$constraint->fail($response, $message);
}
}
/**
* Assert that response is NOT a redirect
*
* @param string $message
* @return void
*/
public function assertNotRedirect($message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/Redirect.php';
$constraint = new Zend_Test_PHPUnit_Constraint_Redirect();
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__)) {
$constraint->fail($response, $message);
}
}
/**
* Assert that response redirects to given URL
*
* @param string $url
* @param string $message
* @return void
*/
public function assertRedirectTo($url, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/Redirect.php';
$constraint = new Zend_Test_PHPUnit_Constraint_Redirect();
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $url)) {
$constraint->fail($response, $message);
}
}
/**
* Assert that response does not redirect to given URL
*
* @param string $url
* @param string $message
* @return void
*/
public function assertNotRedirectTo($url, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/Redirect.php';
$constraint = new Zend_Test_PHPUnit_Constraint_Redirect();
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $url)) {
$constraint->fail($response, $message);
}
}
/**
* Assert that redirect location matches pattern
*
* @param string $pattern
* @param string $message
* @return void
*/
public function assertRedirectRegex($pattern, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/Redirect.php';
$constraint = new Zend_Test_PHPUnit_Constraint_Redirect();
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $pattern)) {
$constraint->fail($response, $message);
}
}
/**
* Assert that redirect location does not match pattern
*
* @param string $pattern
* @param string $message
* @return void
*/
public function assertNotRedirectRegex($pattern, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/Redirect.php';
$constraint = new Zend_Test_PHPUnit_Constraint_Redirect();
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $pattern)) {
$constraint->fail($response, $message);
}
}
/**
* Assert response code
*
* @param int $code
* @param string $message
* @return void
*/
public function assertResponseCode($code, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/ResponseHeader.php';
$constraint = new Zend_Test_PHPUnit_Constraint_ResponseHeader();
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $code)) {
$constraint->fail($response, $message);
}
}
/**
* Assert response code
*
* @param int $code
* @param string $message
* @return void
*/
public function assertNotResponseCode($code, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/ResponseHeader.php';
$constraint = new Zend_Test_PHPUnit_Constraint_ResponseHeader();
$constraint->setNegate(true);
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $code)) {
$constraint->fail($response, $message);
}
}
/**
* Assert response header exists
*
* @param string $header
* @param string $message
* @return void
*/
public function assertHeader($header, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/ResponseHeader.php';
$constraint = new Zend_Test_PHPUnit_Constraint_ResponseHeader();
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $header)) {
$constraint->fail($response, $message);
}
}
/**
* Assert response header does not exist
*
* @param string $header
* @param string $message
* @return void
*/
public function assertNotHeader($header, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/ResponseHeader.php';
$constraint = new Zend_Test_PHPUnit_Constraint_ResponseHeader();
$constraint->setNegate(true);
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $header)) {
$constraint->fail($response, $message);
}
}
/**
* Assert response header exists and contains the given string
*
* @param string $header
* @param string $match
* @param string $message
* @return void
*/
public function assertHeaderContains($header, $match, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/ResponseHeader.php';
$constraint = new Zend_Test_PHPUnit_Constraint_ResponseHeader();
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $header, $match)) {
$constraint->fail($response, $message);
}
}
/**
* Assert response header does not exist and/or does not contain the given string
*
* @param string $header
* @param string $match
* @param string $message
* @return void
*/
public function assertNotHeaderContains($header, $match, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/ResponseHeader.php';
$constraint = new Zend_Test_PHPUnit_Constraint_ResponseHeader();
$constraint->setNegate(true);
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $header, $match)) {
$constraint->fail($response, $message);
}
}
/**
* Assert response header exists and matches the given pattern
*
* @param string $header
* @param string $pattern
* @param string $message
* @return void
*/
public function assertHeaderRegex($header, $pattern, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/ResponseHeader.php';
$constraint = new Zend_Test_PHPUnit_Constraint_ResponseHeader();
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $header, $pattern)) {
$constraint->fail($response, $message);
}
}
/**
* Assert response header does not exist and/or does not match the given regex
*
* @param string $header
* @param string $pattern
* @param string $message
* @return void
*/
public function assertNotHeaderRegex($header, $pattern, $message = '')
{
$this->_incrementAssertionCount();
require_once 'Zend/Test/PHPUnit/Constraint/ResponseHeader.php';
$constraint = new Zend_Test_PHPUnit_Constraint_ResponseHeader();
$constraint->setNegate(true);
$response = $this->response;
if (!$constraint->evaluate($response, __FUNCTION__, $header, $pattern)) {
$constraint->fail($response, $message);
}
}
/**
* Assert that the last handled request used the given module
*
* @param string $module
* @param string $message
* @return void
*/
public function assertModule($module, $message = '')
{
$this->_incrementAssertionCount();
if ($module != $this->request->getModuleName()) {
$msg = sprintf('Failed asserting last module used was "%s"', $module);
if (!empty($message)) {
$msg = $message . "\n" . $msg;
}
$this->fail($msg);
}
}
/**
* Assert that the last handled request did NOT use the given module
*
* @param string $module
* @param string $message
* @return void
*/
public function assertNotModule($module, $message = '')
{
$this->_incrementAssertionCount();
if ($module == $this->request->getModuleName()) {
$msg = sprintf('Failed asserting last module used was NOT "%s"', $module);
if (!empty($message)) {
$msg = $message . "\n" . $msg;
}
$this->fail($msg);
}
}
/**
* Assert that the last handled request used the given controller
*
* @param string $controller
* @param string $message
* @return void
*/
public function assertController($controller, $message = '')
{
$this->_incrementAssertionCount();
if ($controller != $this->request->getControllerName()) {
$msg = sprintf('Failed asserting last controller used was "%s"', $controller);
if (!empty($message)) {
$msg = $message . "\n" . $msg;
}
$this->fail($msg);
}
}
/**
* Assert that the last handled request did NOT use the given controller
*
* @param string $controller
* @param string $message
* @return void
*/
public function assertNotController($controller, $message = '')
{
$this->_incrementAssertionCount();
if ($controller == $this->request->getControllerName()) {
$msg = sprintf('Failed asserting last controller used was NOT "%s"', $controller);
if (!empty($message)) {
$msg = $message . "\n" . $msg;
}
$this->fail($msg);
}
}
/**
* Assert that the last handled request used the given action
*
* @param string $action
* @param string $message
* @return void
*/
public function assertAction($action, $message = '')
{
$this->_incrementAssertionCount();
if ($action != $this->request->getActionName()) {
$msg = sprintf('Failed asserting last action used was "%s"', $action);
if (!empty($message)) {
$msg = $message . "\n" . $msg;
}
$this->fail($msg);
}
}
/**
* Assert that the last handled request did NOT use the given action
*
* @param string $action
* @param string $message
* @return void
*/
public function assertNotAction($action, $message = '')
{
$this->_incrementAssertionCount();
if ($action == $this->request->getActionName()) {
$msg = sprintf('Failed asserting last action used was NOT "%s"', $action);
if (!empty($message)) {
$msg = $message . "\n" . $msg;
}
$this->fail($msg);
}
}
/**
* Assert that the specified route was used
*
* @param string $route
* @param string $message
* @return void
*/
public function assertRoute($route, $message = '')
{
$this->_incrementAssertionCount();
$router = $this->frontController->getRouter();
if ($route != $router->getCurrentRouteName()) {
$msg = sprintf('Failed asserting route matched was "%s"', $route);
if (!empty($message)) {
$msg = $message . "\n" . $msg;
}
$this->fail($msg);
}
}
/**
* Assert that the route matched is NOT as specified
*
* @param string $route
* @param string $message
* @return void
*/
public function assertNotRoute($route, $message = '')
{
$this->_incrementAssertionCount();
$router = $this->frontController->getRouter();
if ($route == $router->getCurrentRouteName()) {
$msg = sprintf('Failed asserting route matched was NOT "%s"', $route);
if (!empty($message)) {
$msg = $message . "\n" . $msg;
}
$this->fail($msg);
}
}
/**
* Retrieve front controller instance
*
* @return Zend_Controller_Front
*/
public function getFrontController()
{
if (null === $this->_frontController) {
$this->_frontController = Zend_Controller_Front::getInstance();
}
return $this->_frontController;
}
/**
* Retrieve test case request object
*
* @return Zend_Controller_Request_Abstract
*/
public function getRequest()
{
if (null === $this->_request) {
require_once 'Zend/Controller/Request/HttpTestCase.php';
$this->_request = new Zend_Controller_Request_HttpTestCase;
}
return $this->_request;
}
/**
* Retrieve test case response object
*
* @return Zend_Controller_Response_Abstract
*/
public function getResponse()
{
if (null === $this->_response) {
require_once 'Zend/Controller/Response/HttpTestCase.php';
$this->_response = new Zend_Controller_Response_HttpTestCase;
}
return $this->_response;
}
/**
* Retrieve DOM query object
*
* @return Zend_Dom_Query
*/
public function getQuery()
{
if (null === $this->_query) {
require_once 'Zend/Dom/Query.php';
$this->_query = new Zend_Dom_Query;
}
return $this->_query;
}
/**
* Increment assertion count
*
* @return void
*/
protected function _incrementAssertionCount()
{
$stack = debug_backtrace();
foreach (debug_backtrace() as $step) {
if (isset($step['object'])
&& $step['object'] instanceof PHPUnit_Framework_TestCase
) {
if (version_compare(PHPUnit_Runner_Version::id(), '3.3.3', 'lt')) {
$step['object']->incrementAssertionCounter();
} else {
$step['object']->addToAssertionCount(1);
}
break;
}
}
}
}
PK �$H[�`6�- �- PHPUnit/Constraint/DomQuery.phpnu &1i� PK �$H[�e�� . PHPUnit/Constraint/Exception.phpnu &1i� PK �$H[���.� � �0 PHPUnit/Constraint/Redirect.phpnu &1i� PK �$H[-��9t0 t0 % �O PHPUnit/Constraint/ResponseHeader.phpnu &1i� PK �$H[�]�6b� b� j� PHPUnit/ControllerTestCase.phpnu &1i� PK �