interface/modules/zend_modules/library/Zend/Http/Client/Adapter/Test.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Http\Client\Adapter;
  11
  12 use Traversable;
  13 use Zend\Http\Response;
  14 use Zend\Stdlib\ArrayUtils;
  15
  16 /**
  17  * A testing-purposes adapter.
  18  *
  19  * Should be used to test all components that rely on Zend\Http\Client,
  20  * without actually performing an HTTP request. You should instantiate this
  21  * object manually, and then set it as the client's adapter. Then, you can
  22  * set the expected response using the setResponse() method.
  23  */
  24 class Test implements AdapterInterface
  25 {
  26     /**
  27      * Parameters array
  28      *
  29      * @var array
  30      */
  31     protected $config = array();
  32
  33     /**
  34      * Buffer of responses to be returned by the read() method.  Can be
  35      * set using setResponse() and addResponse().
  36      *
  37      * @var array
  38      */
  39     protected $responses = array("HTTP/1.1 400 Bad Request\r\n\r\n");
  40
  41     /**
  42      * Current position in the response buffer
  43      *
  44      * @var int
  45      */
  46     protected $responseIndex = 0;
  47
  48     /**
  49      * Whether or not the next request will fail with an exception
  50      *
  51      * @var bool
  52      */
  53     protected $nextRequestWillFail = false;
  54
  55     /**
  56      * Adapter constructor, currently empty. Config is set using setOptions()
  57      */
  58     public function __construct()
  59     { }
  60
  61     /**
  62      * Set the nextRequestWillFail flag
  63      *
  64      * @param  bool $flag
  65      * @return \Zend\Http\Client\Adapter\Test
  66      */
  67     public function setNextRequestWillFail($flag)
  68     {
  69         $this->nextRequestWillFail = (bool) $flag;
  70
  71         return $this;
  72     }
  73
  74     /**
  75      * Set the configuration array for the adapter
  76      *
  77      * @param  array|Traversable $options
  78      * @throws Exception\InvalidArgumentException
  79      */
  80     public function setOptions($options = array())
  81     {
  82         if ($options instanceof Traversable) {
  83             $options = ArrayUtils::iteratorToArray($options);
  84         }
  85
  86         if (! is_array($options)) {
  87             throw new Exception\InvalidArgumentException(
  88                 'Array or Traversable object expected, got ' . gettype($options)
  89             );
  90         }
  91
  92         foreach ($options as $k => $v) {
  93             $this->config[strtolower($k)] = $v;
  94         }
  95     }
  96
  97
  98     /**
  99      * Connect to the remote server
 100      *
 101      * @param  string $host
 102      * @param  int    $port
 103      * @param  bool   $secure
 104      * @throws Exception\RuntimeException
 105      */
 106     public function connect($host, $port = 80, $secure = false)
 107     {
 108         if ($this->nextRequestWillFail) {
 109             $this->nextRequestWillFail = false;
 110             throw new Exception\RuntimeException('Request failed');
 111         }
 112     }
 113
 114     /**
 115      * Send request to the remote server
 116      *
 117      * @param string        $method
 118      * @param \Zend\Uri\Uri $uri
 119      * @param string        $httpVer
 120      * @param array         $headers
 121      * @param string        $body
 122      * @return string Request as string
 123      */
 124     public function write($method, $uri, $httpVer = '1.1', $headers = array(), $body = '')
 125     {
 126         $host = $uri->getHost();
 127             $host = (strtolower($uri->getScheme()) == 'https' ? 'sslv2://' . $host : $host);
 128
 129         // Build request headers
 130         $path = $uri->getPath();
 131         if (empty($path)) {
 132             $path = '/';
 133         }
 134         if ($uri->getQuery()) $path .= '?' . $uri->getQuery();
 135         $request = "{$method} {$path} HTTP/{$httpVer}\r\n";
 136         foreach ($headers as $k => $v) {
 137             if (is_string($k)) $v = ucfirst($k) . ": $v";
 138             $request .= "$v\r\n";
 139         }
 140
 141         // Add the request body
 142         $request .= "\r\n" . $body;
 143
 144         // Do nothing - just return the request as string
 145
 146         return $request;
 147     }
 148
 149     /**
 150      * Return the response set in $this->setResponse()
 151      *
 152      * @return string
 153      */
 154     public function read()
 155     {
 156         if ($this->responseIndex >= count($this->responses)) {
 157             $this->responseIndex = 0;
 158         }
 159         return $this->responses[$this->responseIndex++];
 160     }
 161
 162     /**
 163      * Close the connection (dummy)
 164      *
 165      */
 166     public function close()
 167     { }
 168
 169     /**
 170      * Set the HTTP response(s) to be returned by this adapter
 171      *
 172      * @param \Zend\Http\Response|array|string $response
 173      */
 174     public function setResponse($response)
 175     {
 176         if ($response instanceof Response) {
 177             $response = $response->toString();
 178         }
 179
 180         $this->responses = (array) $response;
 181         $this->responseIndex = 0;
 182     }
 183
 184     /**
 185      * Add another response to the response buffer.
 186      *
 187      * @param string|Response $response
 188      */
 189     public function addResponse($response)
 190     {
 191          if ($response instanceof Response) {
 192             $response = $response->toString();
 193          }
 194
 195         $this->responses[] = $response;
 196     }
 197
 198     /**
 199      * Sets the position of the response buffer.  Selects which
 200      * response will be returned on the next call to read().
 201      *
 202      * @param int $index
 203      * @throws Exception\OutOfRangeException
 204      */
 205     public function setResponseIndex($index)
 206     {
 207         if ($index < 0 || $index >= count($this->responses)) {
 208             throw new Exception\OutOfRangeException(
 209                 'Index out of range of response buffer size');
 210         }
 211         $this->responseIndex = $index;
 212     }
 213 }