ClientTest::testSetDefaultSchema() - Code Metrics - Inspection of "note: providing default-schema support" - crate/crate-pdo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — m/note-default-schema ( 4c069f...201d93 )

unknown

created 2016-01-18 10:32 UTC

ClientTest::testSetDefaultSchema() A

↳ Parent: ClientTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	10
rs	9.4285
cc	1
eloc	7
nc	1
nop	0

<?php
/**
 * @author Antoine Hedgcock
 */

namespace CrateTest\PDO\Http;

use Crate\PDO\Exception\RuntimeException;
use Crate\PDO\Exception\UnsupportedException;
use Crate\Stdlib\Collection;
use Crate\PDO\Http\Client;
use Crate\PDO\Http\Server;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Exception\ConnectException;
use GuzzleHttp\Message\RequestInterface;
use GuzzleHttp\Message\Response;
use GuzzleHttp\Message\ResponseInterface;
use GuzzleHttp\Stream\Stream;
use PHPUnit_Framework_TestCase;
use ReflectionClass;

/**
 * Class ClientTest
 *
 * @coversDefaultClass \Crate\PDO\Http\Client
 * @covers ::<!public>
 *
 * @group unit
 */
class ClientTest extends PHPUnit_Framework_TestCase
{

    /**
     * @var Client
     */
    private $client;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject
     */
    private $server;

    /**
     * @covers ::__construct
     */
    protected function setUp()
    {
        $server = 'localhost:4200';
        $this->client = new Client([$server], []);
        $this->server = $this->getMockBuilder(Server::class)
            ->disableOriginalConstructor()
            ->getMock();

        $clientReflection = new ReflectionClass($this->client);

        $availableServers = $clientReflection->getProperty('availableServers');
        $availableServers->setAccessible(true);
        $availableServers->setValue($this->client, [$server]);

        $serverPool = $clientReflection->getProperty('serverPool');
        $serverPool->setAccessible(true);
        $serverPool->setValue($this->client, [$server => $this->server]);
    }

    /**
     * @covers ::__construct
     */
    public function testMultiServerConstructor()
    {
        $servers = ['crate1:4200', 'crate2:4200', 'crate3:4200'];
        $client = new Client($servers, []);
        $clientReflection = new ReflectionClass($client);

        $p = $clientReflection->getProperty('availableServers');
        $p->setAccessible(true);
        $availableServers = $p->getValue($client);
        $this->assertEquals(3, count($availableServers));

        $p = $clientReflection->getProperty('serverPool');
        $p->setAccessible(true);
        $serverPool = $p->getValue($client);
        $this->assertEquals(3, count($serverPool));
    }

    /**
     * @covers ::nextServer
     */
    public function testNextServer()
    {
        $servers = ['crate1:4200', 'crate2:4200', 'crate3:4200'];
        $client = new Client($servers, []);
        $clientReflection = new ReflectionClass($client);

        $pAvailServers = $clientReflection->getProperty('availableServers');
        $pAvailServers->setAccessible(true);
        $pNextServer = $clientReflection->getMethod('nextServer');
        $pNextServer->setAccessible(true);

        $this->assertEquals('crate1:4200', $pNextServer->invoke($client));
        $this->assertEquals('crate2:4200', $pNextServer->invoke($client));
        $this->assertEquals('crate3:4200', $pNextServer->invoke($client));
        $this->assertEquals('crate1:4200', $pNextServer->invoke($client));
    }

    /**
     * @covers ::dropServer
     */
    public function testDropServer()
    {
        $servers = ['crate1:4200', 'crate2:4200'];
        $client = new Client($servers, []);
        $clientReflection = new ReflectionClass($client);

        $pAvailServers = $clientReflection->getProperty('availableServers');
        $pAvailServers->setAccessible(true);
        $pDropServer = $clientReflection->getMethod('dropServer');
        $pDropServer->setAccessible(true);

        $this->assertEquals(2, count($pAvailServers->getValue($client)));
        $pDropServer->invoke($client, 'crate2:4200', null);
        $this->assertEquals(1, count($pAvailServers->getValue($client)));
        $this->assertEquals(['crate1:4200'], $pAvailServers->getValue($client));
    }

    /**
     * @covers ::dropServer
     */
    public function testDropLastServer()
    {
        $servers = ['localhost:4200'];
        $client = new Client($servers, []);
        $clientReflection = new ReflectionClass($client);


        $this->setExpectedException(ConnectException::class, "No more servers available, exception from last server: Connection refused.");
        $ex = $this->getMock(ConnectException::class, null,
            ['Connection refused.', $this->getMock(RequestInterface::class), $this->getMock(ResponseInterface::class)]);

        $pDropServer = $clientReflection->getMethod('dropServer');
        $pDropServer->setAccessible(true);
        $pDropServer->invoke($client, 'localhost:4200');

        $pRaiseIfNoServers = $clientReflection->getMethod('raiseIfNoMoreServers');
        $pRaiseIfNoServers->setAccessible(true);
        $pRaiseIfNoServers->invoke($client, $ex);
    }

    /**
     * Create a response to be used
     *
     * @param int   $statusCode
     * @param array $body
     *
     * @return Response
     */
    private function createResponse($statusCode, array $body)
    {
        $body = Stream::factory(json_encode($body));

        return new Response($statusCode, [], $body);
    }

    /**
     * @covers ::execute
     */
    public function testExecuteWithResponseFailure()
    {
        $code    = 1337;
        $message = 'hello world';

        $this->setExpectedException(RuntimeException::class, $message, $code);

        $request = $this->getMock(RequestInterface::class);
        $response = $this->createResponse(400, ['error' => ['code' => $code, 'message' => $message]]);

        $exception = ClientException::create($request, $response);

        $this->server
            ->expects($this->once())
            ->method('doRequest')
            ->will($this->throwException($exception));

        $this->client->execute('SELECT ? FROM', ['foo']);
    }

    /**
     * @covers ::execute
     */
    public function testExecute()
    {
        $body = [
            'cols'     => ['name'],
            'rows'     => [['crate2'],['crate2']],
            'rowcount' => 2,
            'duration' => 0
        ];

        $response = $this->createResponse(200, $body);

        $this->server
            ->expects($this->once())
            ->method('doRequest')
            ->will($this->returnValue($response));

        $result = $this->client->execute('SELECT name FROM sys.nodes', []);

        $this->assertInstanceOf(Collection::class, $result);
    }

    /**
     * @covers ::getServerInfo
     */
    public function testGetServerInfo()
    {
        $this->setExpectedException(UnsupportedException::class);
        $this->client->getServerInfo();
    }

    /**
     * @covers ::getServerVersion
     */
    public function testGetServerVersion()
    {
        $this->setExpectedException(UnsupportedException::class);
        $this->client->getServerVersion();
    }

    /**
     * @covers ::setTimeout
     */
    public function testSetTimeout()
    {
        $this->server
            ->expects($this->once())
            ->method('setTimeout')
            ->with(4);

        $this->client->setTimeout('4');
    }

    /**
     * @covers ::setDefaultSchema
     */
    public function testSetDefaultSchema()
    {
        $schema = 'my_schema';
        $this->server
            ->expects($this->once())
            ->method('setHttpHeader')
            ->with('Default-Schema', $schema);

        $this->client->setDefaultSchema($schema);
    }
}


1			<?php
2			/**
3			* @author Antoine Hedgcock
4			*/
5
6			namespace CrateTest\PDO\Http;
7
8			use Crate\PDO\Exception\RuntimeException;
9			use Crate\PDO\Exception\UnsupportedException;
10			use Crate\Stdlib\Collection;
11			use Crate\PDO\Http\Client;
12			use Crate\PDO\Http\Server;
13			use GuzzleHttp\Exception\ClientException;
14			use GuzzleHttp\Exception\ConnectException;
15			use GuzzleHttp\Message\RequestInterface;
16			use GuzzleHttp\Message\Response;
17			use GuzzleHttp\Message\ResponseInterface;
18			use GuzzleHttp\Stream\Stream;
19			use PHPUnit_Framework_TestCase;
20			use ReflectionClass;
21
22			/**
23			* Class ClientTest
24			*
25			* @coversDefaultClass \Crate\PDO\Http\Client
26			* @covers ::<!public>
27			*
28			* @group unit
29			*/
30			class ClientTest extends PHPUnit_Framework_TestCase
31			{
32
33			/**
34			* @var Client
35			*/
36			private $client;
37
38			/**
39			* @var \PHPUnit_Framework_MockObject_MockObject
40			*/
41			private $server;
42
43			/**
44			* @covers ::__construct
45			*/
46			protected function setUp()
47			{
48			$server = 'localhost:4200';
49			$this->client = new Client([$server], []);
50			$this->server = $this->getMockBuilder(Server::class)
51			->disableOriginalConstructor()
52			->getMock();
53
54			$clientReflection = new ReflectionClass($this->client);
55
56			$availableServers = $clientReflection->getProperty('availableServers');
57			$availableServers->setAccessible(true);
58			$availableServers->setValue($this->client, [$server]);
59
60			$serverPool = $clientReflection->getProperty('serverPool');
61			$serverPool->setAccessible(true);
62			$serverPool->setValue($this->client, [$server => $this->server]);
63			}
64
65			/**
66			* @covers ::__construct
67			*/
68			public function testMultiServerConstructor()
69			{
70			$servers = ['crate1:4200', 'crate2:4200', 'crate3:4200'];
71			$client = new Client($servers, []);
72			$clientReflection = new ReflectionClass($client);
73
74			$p = $clientReflection->getProperty('availableServers');
75			$p->setAccessible(true);
76			$availableServers = $p->getValue($client);
77			$this->assertEquals(3, count($availableServers));
78
79			$p = $clientReflection->getProperty('serverPool');
80			$p->setAccessible(true);
81			$serverPool = $p->getValue($client);
82			$this->assertEquals(3, count($serverPool));
83			}
84
85			/**
86			* @covers ::nextServer
87			*/
88			public function testNextServer()
89			{
90			$servers = ['crate1:4200', 'crate2:4200', 'crate3:4200'];
91			$client = new Client($servers, []);
92			$clientReflection = new ReflectionClass($client);
93
94			$pAvailServers = $clientReflection->getProperty('availableServers');
95			$pAvailServers->setAccessible(true);
96			$pNextServer = $clientReflection->getMethod('nextServer');
97			$pNextServer->setAccessible(true);
98
99			$this->assertEquals('crate1:4200', $pNextServer->invoke($client));
100			$this->assertEquals('crate2:4200', $pNextServer->invoke($client));
101			$this->assertEquals('crate3:4200', $pNextServer->invoke($client));
102			$this->assertEquals('crate1:4200', $pNextServer->invoke($client));
103			}
104
105			/**
106			* @covers ::dropServer
107			*/
108			public function testDropServer()
109			{
110			$servers = ['crate1:4200', 'crate2:4200'];
111			$client = new Client($servers, []);
112			$clientReflection = new ReflectionClass($client);
113
114			$pAvailServers = $clientReflection->getProperty('availableServers');
115			$pAvailServers->setAccessible(true);
116			$pDropServer = $clientReflection->getMethod('dropServer');
117			$pDropServer->setAccessible(true);
118
119			$this->assertEquals(2, count($pAvailServers->getValue($client)));
120			$pDropServer->invoke($client, 'crate2:4200', null);
121			$this->assertEquals(1, count($pAvailServers->getValue($client)));
122			$this->assertEquals(['crate1:4200'], $pAvailServers->getValue($client));
123			}
124
125			/**
126			* @covers ::dropServer
127			*/
128			public function testDropLastServer()
129			{
130			$servers = ['localhost:4200'];
131			$client = new Client($servers, []);
132			$clientReflection = new ReflectionClass($client);
133
134
135			$this->setExpectedException(ConnectException::class, "No more servers available, exception from last server: Connection refused.");
136			$ex = $this->getMock(ConnectException::class, null,
137			['Connection refused.', $this->getMock(RequestInterface::class), $this->getMock(ResponseInterface::class)]);
138
139			$pDropServer = $clientReflection->getMethod('dropServer');
140			$pDropServer->setAccessible(true);
141			$pDropServer->invoke($client, 'localhost:4200');
142
143			$pRaiseIfNoServers = $clientReflection->getMethod('raiseIfNoMoreServers');
144			$pRaiseIfNoServers->setAccessible(true);
145			$pRaiseIfNoServers->invoke($client, $ex);
146			}
147
148			/**
149			* Create a response to be used
150			*
151			* @param int $statusCode
152			* @param array $body
153			*
154			* @return Response
155			*/
156			private function createResponse($statusCode, array $body)
157			{
158			$body = Stream::factory(json_encode($body));
159
160			return new Response($statusCode, [], $body);
161			}
162
163			/**
164			* @covers ::execute
165			*/
166			public function testExecuteWithResponseFailure()
167			{
168			$code = 1337;
169			$message = 'hello world';
170
171			$this->setExpectedException(RuntimeException::class, $message, $code);
172
173			$request = $this->getMock(RequestInterface::class);
174			$response = $this->createResponse(400, ['error' => ['code' => $code, 'message' => $message]]);
175
176			$exception = ClientException::create($request, $response);
177
178			$this->server
179			->expects($this->once())
180			->method('doRequest')
181			->will($this->throwException($exception));
182
183			$this->client->execute('SELECT ? FROM', ['foo']);
184			}
185
186			/**
187			* @covers ::execute
188			*/
189			public function testExecute()
190			{
191			$body = [
192			'cols' => ['name'],
193			'rows' => [['crate2'],['crate2']],
194			'rowcount' => 2,
195			'duration' => 0
196			];
197
198			$response = $this->createResponse(200, $body);
199
200			$this->server
201			->expects($this->once())
202			->method('doRequest')
203			->will($this->returnValue($response));
204
205			$result = $this->client->execute('SELECT name FROM sys.nodes', []);
206
207			$this->assertInstanceOf(Collection::class, $result);
208			}
209
210			/**
211			* @covers ::getServerInfo
212			*/
213			public function testGetServerInfo()
214			{
215			$this->setExpectedException(UnsupportedException::class);
216			$this->client->getServerInfo();
217			}
218
219			/**
220			* @covers ::getServerVersion
221			*/
222			public function testGetServerVersion()
223			{
224			$this->setExpectedException(UnsupportedException::class);
225			$this->client->getServerVersion();
226			}
227
228			/**
229			* @covers ::setTimeout
230			*/
231			public function testSetTimeout()
232			{
233			$this->server
234			->expects($this->once())
235			->method('setTimeout')
236			->with(4);
237
238			$this->client->setTimeout('4');
239			}
240
241			/**
242			* @covers ::setDefaultSchema
243			*/
244			public function testSetDefaultSchema()
245			{
246			$schema = 'my_schema';
247			$this->server
248			->expects($this->once())
249			->method('setHttpHeader')
250			->with('Default-Schema', $schema);
251
252			$this->client->setDefaultSchema($schema);
253			}
254			}
255

crate / crate-pdo

Push — m/note-default-schema ( 4c069f...201d93 )

ClientTest::testSetDefaultSchema() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like