These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more
1 | <?php |
||
2 | |||
3 | namespace Graze\TelnetClient\Test\Unit; |
||
4 | |||
5 | use Exception; |
||
6 | use Graze\TelnetClient\Exception\TelnetExceptionInterface; |
||
7 | use Graze\TelnetClient\InterpretAsCommand; |
||
8 | use Graze\TelnetClient\PromptMatcher; |
||
9 | use Graze\TelnetClient\TelnetClient; |
||
10 | use Graze\TelnetClient\TelnetResponseInterface; |
||
11 | use Mockery as m; |
||
12 | use PHPUnit_Framework_TestCase; |
||
13 | use Socket\Raw\Factory as SocketFactory; |
||
14 | use Socket\Raw\Socket; |
||
15 | |||
16 | class TelnetClientTest extends PHPUnit_Framework_TestCase |
||
17 | { |
||
18 | /** |
||
19 | * @dataProvider dataProviderConnect |
||
20 | * |
||
21 | * @param string $prompt |
||
22 | * @param string $promptError |
||
23 | * @param string $lineEnding |
||
24 | * @param float|null $timeout |
||
25 | * |
||
26 | * @return void |
||
27 | */ |
||
28 | public function testConnect($prompt = null, $promptError = null, $lineEnding = null, $timeout = null) |
||
29 | { |
||
30 | $dsn = 'localhost:80'; |
||
31 | $socket = m::mock(Socket::class); |
||
32 | $socketFactory = m::mock(SocketFactory::class) |
||
33 | ->shouldReceive('createClient') |
||
34 | ->with($dsn, $timeout) |
||
35 | ->andReturn($socket) |
||
36 | ->once() |
||
37 | ->getMock(); |
||
38 | |||
39 | $telnetClient = m::mock( |
||
40 | TelnetClient::class, |
||
41 | [$socketFactory, m::mock(PromptMatcher::class), m::mock(InterpretAsCommand::class)] |
||
42 | ) |
||
43 | ->shouldReceive('setSocket') |
||
44 | ->with($socket) |
||
45 | ->once(); |
||
46 | |||
47 | if ($prompt !== null) { |
||
48 | $telnetClient |
||
49 | ->shouldReceive('setPrompt') |
||
50 | ->with($prompt) |
||
51 | ->once(); |
||
52 | } else { |
||
53 | $telnetClient |
||
54 | ->shouldReceive('setPrompt') |
||
55 | ->never(); |
||
56 | } |
||
57 | |||
58 | if ($promptError !== null) { |
||
59 | $telnetClient |
||
60 | ->shouldReceive('setPromptError') |
||
61 | ->with($promptError) |
||
62 | ->once(); |
||
63 | } else { |
||
64 | $telnetClient |
||
65 | ->shouldReceive('setPromptError') |
||
66 | ->never(); |
||
67 | } |
||
68 | |||
69 | if ($lineEnding !== null) { |
||
70 | $telnetClient |
||
71 | ->shouldReceive('setLineEnding') |
||
72 | ->with($lineEnding) |
||
73 | ->once(); |
||
74 | } else { |
||
75 | $telnetClient |
||
76 | ->shouldReceive('setLineEnding') |
||
77 | ->never(); |
||
78 | } |
||
79 | |||
80 | $telnetClient = $telnetClient->getMock()->makePartial(); |
||
81 | $telnetClient->connect($dsn, $prompt, $promptError, $lineEnding, $timeout); |
||
82 | } |
||
83 | |||
84 | /** |
||
85 | * @return array |
||
86 | */ |
||
87 | public function dataProviderConnect() |
||
88 | { |
||
89 | return [ |
||
90 | ['PROMPT', 'PROMPTERROR', 'LINENDING'], |
||
91 | ['PROMPT', 'PROMPTERROR', 'LINENDING', 5], |
||
92 | [null, null, null] |
||
93 | ]; |
||
94 | } |
||
95 | /** |
||
96 | * @dataProvider dataProviderExecute |
||
97 | * |
||
98 | * @param string $command |
||
99 | * @param array $promptMatches |
||
100 | * @param bool $isError |
||
101 | * @param string $promptResponse |
||
102 | * @param string $promptGlobal |
||
103 | * @param string $promptLocal |
||
104 | * @param string $promptError |
||
105 | * @param string $lineEnding |
||
106 | * |
||
107 | * @return void |
||
108 | */ |
||
109 | View Code Duplication | public function testExecute( |
|
110 | $command, |
||
111 | array $promptMatches, |
||
112 | $isError, |
||
113 | $promptResponse, |
||
114 | $promptGlobal = null, |
||
115 | $promptLocal = null, |
||
116 | $promptError = null, |
||
117 | $lineEnding = null |
||
118 | ) { |
||
119 | $lineEnding = $lineEnding ?: "\n"; |
||
120 | $socket = m::mock(Socket::class) |
||
121 | ->shouldReceive('write') |
||
122 | ->with($command.$lineEnding) |
||
123 | ->once(); |
||
124 | |||
125 | // echo the command back when reading each character one-by-one from the socket |
||
126 | $commandResponse = str_split($command.$lineEnding.$promptResponse.$lineEnding); |
||
127 | $socket = $socket |
||
128 | ->shouldReceive('read') |
||
129 | ->with(1); |
||
130 | call_user_func_array([$socket, 'andReturn'], $commandResponse); |
||
131 | $socket = $socket |
||
132 | ->times(count($commandResponse)) |
||
133 | ->shouldReceive('close') |
||
134 | ->once() |
||
135 | ->getMock(); |
||
136 | |||
137 | /** @var SocketFactory $socketFactory */ |
||
138 | $socketFactory = m::mock(SocketFactory::class) |
||
139 | ->shouldReceive('createClient') |
||
140 | ->andReturn($socket) |
||
141 | ->once() |
||
142 | ->getMock(); |
||
143 | |||
144 | $promptMatcher = new PromptMatcher(); |
||
145 | |||
146 | /** @var InterpretAsCommand $interpretAsCommand */ |
||
147 | $interpretAsCommand = m::mock(InterpretAsCommand::class) |
||
148 | ->shouldReceive('interpret') |
||
149 | ->times(count($commandResponse)) |
||
150 | ->andReturn(false) |
||
151 | ->getMock(); |
||
152 | |||
153 | $telnetClient = new TelnetClient($socketFactory, $promptMatcher, $interpretAsCommand); |
||
154 | $telnetClient->connect('127.0.0.1:23', $promptGlobal, $promptError, $lineEnding); |
||
155 | |||
156 | $response = $telnetClient->execute($command, $promptLocal); |
||
157 | $this->assertInstanceOf(TelnetResponseInterface::class, $response); |
||
158 | $this->assertEquals($isError, $response->isError()); |
||
159 | $this->assertEquals($command, $response->getResponseText()); |
||
160 | $this->assertEquals($promptMatches, $response->getPromptMatches()); |
||
161 | } |
||
162 | |||
163 | /** |
||
164 | * @dataProvider dataProviderExecute |
||
165 | * |
||
166 | * @param string $command |
||
167 | * @param array $promptMatches |
||
168 | * @param bool $isError |
||
169 | * @param string $promptResponse |
||
170 | * @param string $promptGlobal |
||
171 | * @param string $promptLocal |
||
172 | * @param string $promptError |
||
173 | * @param string $lineEnding |
||
174 | * |
||
175 | * @return void |
||
176 | */ |
||
177 | View Code Duplication | public function testExecutePromptError( |
|
178 | $command, |
||
179 | array $promptMatches, |
||
180 | $isError, |
||
181 | $promptResponse, |
||
182 | $promptGlobal = null, |
||
183 | $promptLocal = null, |
||
184 | $promptError = null, |
||
185 | $lineEnding = null |
||
186 | ) { |
||
187 | $lineEnding = $lineEnding ?: "\n"; |
||
188 | $socket = m::mock(Socket::class) |
||
189 | ->shouldReceive('write') |
||
190 | ->with($command.$lineEnding) |
||
191 | ->once(); |
||
192 | |||
193 | // echo the command back when reading each character one-by-one from the socket |
||
194 | $commandResponse = str_split($command.$lineEnding.$promptResponse.$lineEnding); |
||
195 | $socket = $socket |
||
196 | ->shouldReceive('read') |
||
197 | ->with(1); |
||
198 | call_user_func_array([$socket, 'andReturn'], $commandResponse); |
||
199 | $socket = $socket |
||
200 | ->times(count($commandResponse)) |
||
201 | ->shouldReceive('close') |
||
202 | ->once() |
||
203 | ->getMock(); |
||
204 | |||
205 | /** @var SocketFactory $socketFactory */ |
||
206 | $socketFactory = m::mock(SocketFactory::class) |
||
207 | ->shouldReceive('createClient') |
||
208 | ->andReturn($socket) |
||
209 | ->once() |
||
210 | ->getMock(); |
||
211 | |||
212 | $promptMatcher = new PromptMatcher(); |
||
213 | |||
214 | /** @var InterpretAsCommand $interpretAsCommand */ |
||
215 | $interpretAsCommand = m::mock(InterpretAsCommand::class) |
||
216 | ->shouldReceive('interpret') |
||
217 | ->times(count($commandResponse)) |
||
218 | ->andReturn(false) |
||
219 | ->getMock(); |
||
220 | |||
221 | $telnetClient = new TelnetClient($socketFactory, $promptMatcher, $interpretAsCommand); |
||
222 | $telnetClient->connect('127.0.0.1:23', $promptGlobal, null, $lineEnding); |
||
223 | |||
224 | $response = $telnetClient->execute($command, $promptLocal, $promptError); |
||
225 | $this->assertInstanceOf(TelnetResponseInterface::class, $response); |
||
226 | $this->assertEquals($isError, $response->isError()); |
||
227 | $this->assertEquals($command, $response->getResponseText()); |
||
228 | $this->assertEquals($promptMatches, $response->getPromptMatches()); |
||
229 | } |
||
230 | |||
231 | /** |
||
232 | * @return array |
||
233 | */ |
||
234 | public function dataProviderExecute() |
||
235 | { |
||
236 | return [ |
||
237 | ['party', ['$'], false, "\$"], // success |
||
238 | ['party', ['OK'], false, 'OK', 'OK'], // success custom global prompt |
||
239 | ['party', ['OK'], false, 'OK', null, 'OK'], // success custom local prompt |
||
240 | ['party', ['ERROR'], true, 'ERROR'], // error |
||
241 | // error custom prompt |
||
242 | ['party', ['DAMN 123', 'DAMN', '123'], true, 'DAMN 123', null, null, '(DAMN) ([0-9]{3})'], |
||
243 | ['party', ['$'], false, "\$", null, null, null, 'LOL'], // success custom line ending |
||
244 | ['party', ['ERROR'], true, "ERROR", null, null, null, 'LOL'], // error custom line ending |
||
245 | ]; |
||
246 | } |
||
247 | |||
248 | public function testExecuteException() |
||
249 | { |
||
250 | $this->setExpectedException(TelnetExceptionInterface::class); |
||
251 | |||
252 | $client = m::mock(TelnetClient::class)->makePartial(); |
||
253 | $client->execute('aCommand'); |
||
254 | } |
||
255 | |||
256 | View Code Duplication | public function testWriteException() |
|
257 | { |
||
258 | $this->setExpectedException(TelnetExceptionInterface::class); |
||
259 | |||
260 | $client = m::mock(TelnetClient::class)->makePartial(); |
||
261 | |||
262 | $socket = m::mock(Socket::class) |
||
263 | ->shouldReceive('write') |
||
264 | ->andThrow(Exception::class) |
||
265 | ->shouldReceive('close') |
||
266 | ->getMock(); |
||
267 | |||
268 | $client->setSocket($socket); |
||
269 | $client->execute('aCommand'); |
||
270 | } |
||
271 | |||
272 | View Code Duplication | public function testReadException() |
|
273 | { |
||
274 | $this->setExpectedException(TelnetExceptionInterface::class); |
||
275 | |||
276 | $client = m::mock(TelnetClient::class)->makePartial(); |
||
277 | |||
278 | $socket = m::mock(Socket::class) |
||
279 | ->shouldReceive('write') |
||
280 | ->shouldReceive('close') |
||
281 | ->shouldReceive('read') |
||
282 | ->andThrow(Exception::class) |
||
283 | ->getMock(); |
||
284 | |||
285 | $client->setSocket($socket); |
||
286 | $client->execute('aCommand'); |
||
287 | } |
||
288 | |||
289 | public function testFactory() |
||
290 | { |
||
291 | $client = TelnetClient::factory(); |
||
292 | $this->assertInstanceOf(TelnetClient::class, $client); |
||
293 | } |
||
294 | |||
295 | /** |
||
296 | * @dataProvider setReadTimeoutDataProvider |
||
297 | * @param float $timeout |
||
298 | * @param int $expectedSec |
||
299 | * @param int $expectedUsec |
||
300 | */ |
||
301 | public function testSetReadTimeout($timeout, $expectedSec, $expectedUsec) |
||
302 | { |
||
303 | $client = m::mock(TelnetClient::class)->makePartial(); |
||
304 | |||
305 | $socket = m::mock(Socket::class) |
||
0 ignored issues
–
show
|
|||
306 | ->shouldReceive('setOption') |
||
307 | ->with(SOL_SOCKET, SO_RCVTIMEO, ['sec' => $expectedSec, 'usec' => $expectedUsec]) |
||
308 | ->shouldReceive('close') |
||
309 | ->getMock(); |
||
310 | |||
311 | $client->setSocket($socket); |
||
312 | |||
313 | $client->setReadTimeout($timeout); |
||
314 | } |
||
315 | |||
316 | /** |
||
317 | * @return mixed[] |
||
318 | */ |
||
319 | public function setReadTimeoutDataProvider() |
||
320 | { |
||
321 | return [ |
||
322 | [1, 1, 0], |
||
323 | [0.5, 0, 500000], |
||
324 | [2.345, 2, 345000], |
||
325 | ]; |
||
326 | } |
||
327 | |||
328 | public function testSetReadTimeoutException() |
||
329 | { |
||
330 | $this->setExpectedException(TelnetExceptionInterface::class); |
||
0 ignored issues
–
show
The method
PHPUnit_Framework_TestCase::setExpectedException() has been deprecated with message: Method deprecated since Release 5.2.0
This method has been deprecated. The supplier of the class has supplied an explanatory message. The explanatory message should give you some clue as to whether and when the method will be removed from the class and what other method or class to use instead.
Loading history...
|
|||
331 | |||
332 | $client = m::mock(TelnetClient::class)->makePartial(); |
||
333 | |||
334 | $client->setReadTimeout(1); |
||
335 | } |
||
336 | } |
||
337 |
This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces.
This is most likely a typographical error or the method has been renamed.