1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
<?php
namespace GuzzleHttp\Tests\Ring\Client;
use GuzzleHttp\Ring\Client\StreamHandler;
use GuzzleHttp\Ring\Core;
/**
* Class uses to control the test webserver.
*
* Queued responses will be served to requests using a FIFO order. All requests
* received by the server are stored on the node.js server and can be retrieved
* by calling {@see Server::received()}.
*
* Mock responses that don't require data to be transmitted over HTTP a great
* for testing. Mock response, however, cannot test the actual sending of an
* HTTP request using cURL. This test server allows the simulation of any
* number of HTTP request response transactions to test the actual sending of
* requests over the wire without having to leave an internal network.
*/
class Server
{
public static $started;
public static $url = 'http://127.0.0.1:8125/';
public static $host = '127.0.0.1:8125';
public static $port = 8125;
/**
* Flush the received requests from the server
* @throws \RuntimeException
*/
public static function flush()
{
self::send('DELETE', '/guzzle-server/requests');
}
/**
* Queue an array of responses or a single response on the server.
*
* Any currently queued responses will be overwritten. Subsequent requests
* on the server will return queued responses in FIFO order.
*
* @param array $responses An array of responses. The shape of a response
* is the shape described in the RingPHP spec.
* @throws \Exception
*/
public static function enqueue(array $responses)
{
$data = [];
foreach ($responses as $response) {
if (!is_array($response)) {
throw new \Exception('Each response must be an array');
}
if (isset($response['body'])) {
$response['body'] = base64_encode($response['body']);
}
$response += ['headers' => [], 'reason' => '', 'body' => ''];
$data[] = $response;
}
self::send('PUT', '/guzzle-server/responses', json_encode($data));
}
/**
* Get all of the received requests as a RingPHP request structure.
*
* @return array
* @throws \RuntimeException
*/
public static function received()
{
if (!self::$started) {
return [];
}
$response = self::send('GET', '/guzzle-server/requests');
$body = Core::body($response);
$result = json_decode($body, true);
if ($result === false) {
throw new \RuntimeException('Error decoding response: '
. json_last_error());
}
foreach ($result as &$res) {
if (isset($res['uri'])) {
$res['resource'] = $res['uri'];
}
if (isset($res['query_string'])) {
$res['resource'] .= '?' . $res['query_string'];
}
if (!isset($res['resource'])) {
$res['resource'] = '';
}
// Ensure that headers are all arrays
if (isset($res['headers'])) {
foreach ($res['headers'] as &$h) {
$h = (array) $h;
}
unset($h);
}
}
unset($res);
return $result;
}
/**
* Stop running the node.js server
*/
public static function stop()
{
if (self::$started) {
self::send('DELETE', '/guzzle-server');
}
self::$started = false;
}
public static function wait($maxTries = 20)
{
$tries = 0;
while (!self::isListening() && ++$tries < $maxTries) {
usleep(100000);
}
if (!self::isListening()) {
throw new \RuntimeException('Unable to contact node.js server');
}
}
public static function start()
{
if (self::$started) {
return;
}
try {
self::wait();
} catch (\Exception $e) {
exec('node ' . __DIR__ . \DIRECTORY_SEPARATOR . 'server.js '
. self::$port . ' >> /tmp/server.log 2>&1 &');
self::wait();
}
self::$started = true;
}
private static function isListening()
{
$response = self::send('GET', '/guzzle-server/perf', null, [
'connect_timeout' => 1,
'timeout' => 1
]);
return !isset($response['error']);
}
private static function send(
$method,
$path,
$body = null,
array $client = []
) {
$handler = new StreamHandler();
$request = [
'http_method' => $method,
'uri' => $path,
'request_port' => 8125,
'headers' => ['host' => ['127.0.0.1:8125']],
'body' => $body,
'client' => $client,
];
if ($body) {
$request['headers']['content-length'] = [strlen($body)];
}
return $handler($request);
}
}
|
