1
|
|
|
<?php |
2
|
|
|
|
3
|
|
|
declare(strict_types=1); |
4
|
|
|
|
5
|
|
|
namespace Sunrise\Http\ServerRequest\Tests; |
6
|
|
|
|
7
|
|
|
/** |
8
|
|
|
* Import classes |
9
|
|
|
*/ |
10
|
|
|
use Psr\Http\Message\ServerRequestInterface; |
11
|
|
|
use Sunrise\Http\Message\Request; |
12
|
|
|
use Sunrise\Http\ServerRequest\ServerRequest; |
13
|
|
|
use Sunrise\Http\ServerRequest\UploadedFile; |
14
|
|
|
|
15
|
|
|
/** |
16
|
|
|
* ServerRequestTest |
17
|
|
|
*/ |
18
|
|
|
class ServerRequestTest extends AbstractTestCase |
19
|
|
|
{ |
20
|
|
|
|
21
|
|
|
/** |
22
|
|
|
* @return void |
23
|
|
|
*/ |
24
|
|
|
public function testContracts() : void |
25
|
|
|
{ |
26
|
|
|
$request = new ServerRequest(); |
27
|
|
|
|
28
|
|
|
$this->assertInstanceOf(Request::class, $request); |
29
|
|
|
$this->assertInstanceOf(ServerRequestInterface::class, $request); |
30
|
|
|
} |
31
|
|
|
|
32
|
|
|
/** |
33
|
|
|
* @return void |
34
|
|
|
*/ |
35
|
|
|
public function testConstructor() : void |
36
|
|
|
{ |
37
|
|
|
$stream = $this->createStream(); |
38
|
|
|
$uploadedFile = new UploadedFile($stream); |
39
|
|
|
|
40
|
|
|
$dataset = [ |
41
|
|
|
// method |
42
|
|
|
'POST', |
43
|
|
|
// URI |
44
|
|
|
'http://localhost:8000/foo?bar', |
45
|
|
|
// headers |
46
|
|
|
['X-Foo' => 'bar'], |
47
|
|
|
// body |
48
|
|
|
$stream, |
49
|
|
|
// request target |
50
|
|
|
'/bar?baz', |
51
|
|
|
// protocol version |
52
|
|
|
'2.0', |
53
|
|
|
// server params |
54
|
|
|
['foo' => 'bar'], |
55
|
|
|
// query params |
56
|
|
|
['bar' => 'baz'], |
57
|
|
|
// cookie params |
58
|
|
|
['baz' => 'bat'], |
59
|
|
|
// uploaded files |
60
|
|
|
['bat' => $uploadedFile], |
61
|
|
|
// parsed body |
62
|
|
|
['qux' => 'quux'], |
63
|
|
|
// attributes |
64
|
|
|
['quux' => 'quuux'], |
65
|
|
|
]; |
66
|
|
|
|
67
|
|
|
$request = new ServerRequest(...$dataset); |
|
|
|
|
68
|
|
|
|
69
|
|
|
$this->assertSame($dataset[0], $request->getMethod()); |
70
|
|
|
$this->assertSame($dataset[1], (string) $request->getUri()); |
71
|
|
|
$this->assertSame($dataset[2]['X-Foo'], $request->getHeaderLine('X-Foo')); |
72
|
|
|
$this->assertSame($dataset[3], $request->getBody()); |
73
|
|
|
$this->assertSame($dataset[4], $request->getRequestTarget()); |
74
|
|
|
$this->assertSame($dataset[5], $request->getProtocolVersion()); |
75
|
|
|
$this->assertSame($dataset[6], $request->getServerParams()); |
76
|
|
|
$this->assertSame($dataset[7], $request->getQueryParams()); |
77
|
|
|
$this->assertSame($dataset[8], $request->getCookieParams()); |
78
|
|
|
$this->assertSame($dataset[9], $request->getUploadedFiles()); |
79
|
|
|
$this->assertSame($dataset[10], $request->getParsedBody()); |
80
|
|
|
$this->assertSame($dataset[11], $request->getAttributes()); |
81
|
|
|
} |
82
|
|
|
|
83
|
|
|
/** |
84
|
|
|
* @return void |
85
|
|
|
*/ |
86
|
|
|
public function testConstructorWithInvalidUploadedFiles() : void |
87
|
|
|
{ |
88
|
|
|
$this->expectException(\InvalidArgumentException::class); |
89
|
|
|
$this->expectExceptionMessage('Invalid uploaded files'); |
90
|
|
|
|
91
|
|
|
new ServerRequest(null, null, null, null, null, null, [], [], [], ['foo' => 'bar']); |
92
|
|
|
} |
93
|
|
|
|
94
|
|
|
/** |
95
|
|
|
* @return void |
96
|
|
|
*/ |
97
|
|
|
public function testConstructorWithInvalidParsedBody() : void |
98
|
|
|
{ |
99
|
|
|
$this->expectException(\InvalidArgumentException::class); |
100
|
|
|
$this->expectExceptionMessage('Invalid parsed body'); |
101
|
|
|
|
102
|
|
|
new ServerRequest(null, null, null, null, null, null, [], [], [], [], \STDOUT); |
103
|
|
|
} |
104
|
|
|
|
105
|
|
|
/** |
106
|
|
|
* @return void |
107
|
|
|
*/ |
108
|
|
|
public function testSetQueryParams() : void |
109
|
|
|
{ |
110
|
|
|
$queryParams = ['foo' => 'bar']; |
111
|
|
|
|
112
|
|
|
$request = new ServerRequest(); |
113
|
|
|
$this->assertSame([], $request->getQueryParams()); |
114
|
|
|
|
115
|
|
|
$clone = $request->withQueryParams($queryParams); |
116
|
|
|
$this->assertInstanceOf(ServerRequestInterface::class, $clone); |
117
|
|
|
$this->assertNotSame($request, $clone); |
118
|
|
|
$this->assertSame([], $request->getQueryParams()); |
119
|
|
|
$this->assertSame($queryParams, $clone->getQueryParams()); |
120
|
|
|
} |
121
|
|
|
|
122
|
|
|
/** |
123
|
|
|
* @return void |
124
|
|
|
*/ |
125
|
|
|
public function testSetCookieParams() : void |
126
|
|
|
{ |
127
|
|
|
$cookieParams = ['foo' => 'bar']; |
128
|
|
|
|
129
|
|
|
$request = new ServerRequest(); |
130
|
|
|
$this->assertSame([], $request->getCookieParams()); |
131
|
|
|
|
132
|
|
|
$clone = $request->withCookieParams($cookieParams); |
133
|
|
|
$this->assertInstanceOf(ServerRequestInterface::class, $clone); |
134
|
|
|
$this->assertNotSame($request, $clone); |
135
|
|
|
$this->assertSame([], $request->getCookieParams()); |
136
|
|
|
$this->assertSame($cookieParams, $clone->getCookieParams()); |
137
|
|
|
} |
138
|
|
|
|
139
|
|
|
/** |
140
|
|
|
* @return void |
141
|
|
|
*/ |
142
|
|
|
public function testSetUploadedFiles() : void |
143
|
|
|
{ |
144
|
|
|
$uploadedFiles = []; |
145
|
|
|
|
146
|
|
|
$stream = $this->createStream(); |
147
|
|
|
$uploadedFile = new UploadedFile($stream); |
148
|
|
|
$uploadedFiles['foo'] = $uploadedFile; |
149
|
|
|
|
150
|
|
|
$request = new ServerRequest(); |
151
|
|
|
$this->assertSame([], $request->getUploadedFiles()); |
152
|
|
|
|
153
|
|
|
$clone = $request->withUploadedFiles($uploadedFiles); |
154
|
|
|
$this->assertInstanceOf(ServerRequestInterface::class, $clone); |
155
|
|
|
$this->assertNotSame($request, $clone); |
156
|
|
|
$this->assertSame([], $request->getUploadedFiles()); |
157
|
|
|
$this->assertSame($uploadedFiles, $clone->getUploadedFiles()); |
158
|
|
|
} |
159
|
|
|
|
160
|
|
|
/** |
161
|
|
|
* @return void |
162
|
|
|
*/ |
163
|
|
|
public function testSetInvalidUploadedFiles() : void |
164
|
|
|
{ |
165
|
|
|
$request = new ServerRequest(); |
166
|
|
|
|
167
|
|
|
$this->expectException(\InvalidArgumentException::class); |
168
|
|
|
$this->expectExceptionMessage('Invalid uploaded files'); |
169
|
|
|
|
170
|
|
|
$request->withUploadedFiles(['foo' => 'bar']); |
171
|
|
|
} |
172
|
|
|
|
173
|
|
|
/** |
174
|
|
|
* @return void |
175
|
|
|
*/ |
176
|
|
|
public function testSetParsedBody() : void |
177
|
|
|
{ |
178
|
|
|
$parsedBody = ['foo' => 'bar']; |
179
|
|
|
|
180
|
|
|
$request = new ServerRequest(); |
181
|
|
|
$this->assertNull($request->getParsedBody()); |
182
|
|
|
|
183
|
|
|
$clone = $request->withParsedBody($parsedBody); |
184
|
|
|
$this->assertInstanceOf(ServerRequestInterface::class, $clone); |
185
|
|
|
$this->assertNotSame($request, $clone); |
186
|
|
|
$this->assertNull($request->getParsedBody()); |
187
|
|
|
$this->assertSame($parsedBody, $clone->getParsedBody()); |
188
|
|
|
} |
189
|
|
|
|
190
|
|
|
/** |
191
|
|
|
* @return void |
192
|
|
|
*/ |
193
|
|
|
public function testSetInvalidParsedBody() : void |
194
|
|
|
{ |
195
|
|
|
$request = new ServerRequest(); |
196
|
|
|
|
197
|
|
|
$this->expectException(\InvalidArgumentException::class); |
198
|
|
|
$this->expectExceptionMessage('Invalid parsed body'); |
199
|
|
|
|
200
|
|
|
$request->withParsedBody(\STDOUT); |
201
|
|
|
} |
202
|
|
|
|
203
|
|
|
/** |
204
|
|
|
* @return void |
205
|
|
|
*/ |
206
|
|
|
public function testSetAttributes() : void |
207
|
|
|
{ |
208
|
|
|
$request = new ServerRequest(); |
209
|
|
|
$this->assertSame([], $request->getAttributes()); |
210
|
|
|
$this->assertNull($request->getAttribute('foo')); |
211
|
|
|
$this->assertFalse($request->getAttribute('foo', false)); |
212
|
|
|
|
213
|
|
|
$clone = $request->withAttribute('foo', 'bar'); |
214
|
|
|
$this->assertInstanceOf(ServerRequestInterface::class, $clone); |
215
|
|
|
$this->assertNotSame($request, $clone); |
216
|
|
|
$this->assertSame([], $request->getAttributes()); |
217
|
|
|
$this->assertNull($request->getAttribute('foo')); |
218
|
|
|
$this->assertSame(['foo' => 'bar'], $clone->getAttributes()); |
219
|
|
|
$this->assertSame('bar', $clone->getAttribute('foo')); |
220
|
|
|
} |
221
|
|
|
|
222
|
|
|
/** |
223
|
|
|
* @return void |
224
|
|
|
*/ |
225
|
|
|
public function testRemoveAttributes() : void |
226
|
|
|
{ |
227
|
|
|
$request = (new ServerRequest)->withAttribute('foo', 'bar'); |
228
|
|
|
|
229
|
|
|
$clone = $request->withoutAttribute('foo'); |
230
|
|
|
$this->assertInstanceOf(ServerRequestInterface::class, $clone); |
231
|
|
|
$this->assertNotSame($request, $clone); |
232
|
|
|
$this->assertSame(['foo' => 'bar'], $request->getAttributes()); |
233
|
|
|
$this->assertSame('bar', $request->getAttribute('foo')); |
234
|
|
|
$this->assertSame([], $clone->getAttributes()); |
235
|
|
|
$this->assertNull($clone->getAttribute('foo')); |
236
|
|
|
} |
237
|
|
|
} |
238
|
|
|
|