Merge pull request #20 from evertharmeling/develop

Bumped supported versions of httplug + upgraded phpunit version (and …

Author: Evert Harmeling

.gitignore

@@ -1,3 +1,4 @@
+.phpunit.result.cache
 composer.lock
 coverage
 phpunit.xml

.travis.yml

@@ -1,15 +1,47 @@
 language: php
+sudo: false
+cache:
+    directories:
+        - $HOME/.composer/cache/files
 
-php:
-    - 5.5
-    - 5.6
-    - 7.0
-    - 7.1
+env:
+    global:
+        - PHPUNIT_FLAGS="-v -c ."
+        - SYMFONY_DEPRECATIONS_HELPER="max[self]=0"
 
-before_script:
-    - composer install
+matrix:
+    fast_finish: true
+    include:
+        # Minimum supported dependencies with the latest and oldest PHP version
+        - php: 7.3
+          env: COMPOSER_FLAGS="--prefer-stable --prefer-lowest"
+        - php: 7.1
+          env: COMPOSER_FLAGS="--prefer-stable --prefer-lowest"
 
-script: phpunit --coverage-text
+        # Test the latest stable release
+        - php: 7.1
+        - php: 7.2
+        - php: 7.3
+          env: COVERAGE=true PHPUNIT_FLAGS="-v --coverage-text"
+
+        # Latest commit to master
+        - php: 7.3
+          env: STABILITY="dev"
+
+    allow_failures:
+        # Dev-master is allowed to fail.
+        - env: STABILITY="dev"
+
+before_install:
+    - if [[ $COVERAGE != true ]]; then phpenv config-rm xdebug.ini || true; fi
+    - if ! [ -z "$STABILITY" ]; then composer config minimum-stability ${STABILITY}; fi;
+
+install:
+    - composer update ${COMPOSER_FLAGS} --prefer-dist --no-interaction
+
+script:
+    - composer validate --strict --no-check-lock
+    - ./vendor/bin/phpunit $PHPUNIT_FLAGS
 
 notifications:
-    email: "travis-ci@freshheads.com"
+    email:  [ 'travis-ci@freshheads.com' ]

composer.json

@@ -16,13 +16,13 @@
         }
     ],
     "require": {
-        "php": ">=5.4.0",
-        "php-http/httplug": "^1.1",
+        "php": "^7.1",
+        "php-http/httplug": "^2.0",
         "guzzlehttp/psr7": "^1.3"
     },
     "require-dev": {
-        "phpunit/phpunit": "^4.3.5|^5.0",
-        "php-http/mock-client": "^0.3.0"
+        "phpunit/phpunit": "^7.5 || ^8.2",
+        "php-http/mock-client": "^1.3.0"
     },
     "suggest": {
         "php-http/guzzle6-adapter": "An HTTPlug adapter for the Guzzle 6 HTTP client"
@@ -36,6 +36,6 @@
         }
     },
     "scripts": {
-        "test": "./vendor/phpunit/phpunit/phpunit --coverage-text"
+        "test": "./vendor/bin/phpunit"
     }
 }

tests/FH/PostcodeAPI/ClientTest.php

@@ -3,47 +3,41 @@
 namespace FH\PostcodeAPI\Test;
 
 use FH\PostcodeAPI\Client;
+use FH\PostcodeAPI\Exception\InvalidApiKeyException;
+use FH\PostcodeAPI\Exception\ServerErrorException;
 use GuzzleHttp\Psr7\Response;
+use Http\Mock\Client as MockClient;
+use PHPUnit\Framework\Assert;
+use PHPUnit\Framework\TestCase;
+use stdClass;
+
+use function GuzzleHttp\Psr7\parse_response;
 
 /**
  * @author Gijs Nieuwenhuis <gijs.nieuwenhuis@freshheads.com>
  */
-final class ClientTest extends \PHPUnit_Framework_TestCase
+final class ClientTest extends TestCase
 {
-    /** @var string */
-    const POSTCODE_PATTERN = '/^[\d]{4}[\w]{2}$/i';
-
-    /** @var string */
-    const FRESHHEADS_POSTCODE = '5041EB';
-
-    /** @var int */
-    const FRESHHEADS_NUMBER = 21;
-
-    /** @var string */
-    const FRESHHEADS_CITY = 'Tilburg';
-
-    /** @var float */
-    const FRESHHEADS_LONGITUDE = 5.07717893166;
-
-    /** @var float */
-    const FRESHHEADS_LATITUDE = 51.566414786;
-
-    /** @var string */
-    const FRESHHEADS_ADDRESS_ID = '0855200000061001';
-
-    /**
-     * @expectedException FH\PostcodeAPI\Exception\InvalidApiKeyException
-     */
-    public function testRequestExceptionIsThrownWhenUsingAnInvalidApiKey()
+    private const POSTCODE_PATTERN = '/^[\d]{4}[\w]{2}$/i';
+    private const FRESHHEADS_POSTCODE = '5041EB';
+    private const FRESHHEADS_NUMBER = 21;
+    private const FRESHHEADS_CITY = 'Tilburg';
+    private const FRESHHEADS_LONGITUDE = 5.07717893166;
+    private const FRESHHEADS_LATITUDE = 51.566414786;
+    private const FRESHHEADS_ADDRESS_ID = '0855200000061001';
+
+    public function testRequestExceptionIsThrownWhenUsingAnInvalidApiKey(): void
     {
+        $this->expectException(InvalidApiKeyException::class);
+
         $client = $this->createClient(
             $this->loadMockResponse('failed_list_with_invalid_api_key')
         );
 
         $client->getAddresses();
     }
 
-    public function testListResourceReturnsAllAddressesWhenNoParamsAreSupplied()
+    public function testListResourceReturnsAllAddressesWhenNoParamsAreSupplied(): void
     {
         $client = $this->createClient(
             $this->loadMockResponse('successful_list_without_filtering')
@@ -55,12 +49,12 @@ public function testListResourceReturnsAllAddressesWhenNoParamsAreSupplied()
 
         $addresses = $response->_embedded->addresses;
 
-        static::assertGreaterThan(0, count($addresses), 'Expecting that there are always addresses available');
+        Assert::assertGreaterThan(0, count($addresses), 'Expecting that there are always addresses available');
 
         $this->applyAddressFieldAreSetAndOfTheCorrectTypeAssertions($addresses[0]);
     }
 
-    public function testListResourceReturnsExpectedAddressWhenPostcodeAndNumberAreSupplied()
+    public function testListResourceReturnsExpectedAddressWhenPostcodeAndNumberAreSupplied(): void
     {
         $client = $this->createClient(
             $this->loadMockResponse('successful_list_freshheads_postcode_and_number')
@@ -72,15 +66,15 @@ public function testListResourceReturnsExpectedAddressWhenPostcodeAndNumberAreSu
 
         $addresses = $response->_embedded->addresses;
 
-        static::assertGreaterThan(0, count($addresses), 'Expecting that there are always addresses available when no filters are applied');
+        Assert::assertGreaterThan(0, count($addresses), 'Expecting that there are always addresses available when no filters are applied');
 
         $firstAddress = $addresses[0];
 
         $this->applyAddressFieldAreSetAndOfTheCorrectTypeAssertions($firstAddress);
         $this->applyIsFreshheadsAddressAssertions($firstAddress);
     }
 
-    public function testExpectedAddressInformationIsReturnedFromDetailResource()
+    public function testExpectedAddressInformationIsReturnedFromDetailResource(): void
     {
         $client = $this->createClient(
             $this->loadMockResponse('successful_detail_freshheads')
@@ -92,97 +86,78 @@ public function testExpectedAddressInformationIsReturnedFromDetailResource()
         $this->applyIsFreshheadsAddressAssertions($address);
     }
 
-    /**
-     * @expectedException FH\PostcodeAPI\Exception\ServerErrorException
-     */
-    public function testClientThrowsExceptionWhenInvalidInputIsSupplied()
+    public function testClientThrowsExceptionWhenInvalidInputIsSupplied(): void
     {
+        $this->expectException(ServerErrorException::class);
+
         $client = $this->createClient(
             $this->loadMockResponse('failed_list_with_invalid_postalcode_and_number')
         );
 
         $client->getAddresses('invalid_postcode', 'invalid_number');
     }
 
-    /**
-     * @param string $name
-     *
-     * @return string
-     */
-    private function loadMockResponse($name)
+    private function loadMockResponse(string $name): Response
     {
-        return \GuzzleHttp\Psr7\parse_response(file_get_contents(__DIR__ . "/../../Mock/{$name}"));
+        return parse_response(file_get_contents(__DIR__ . "/../../Mock/{$name}"));
     }
 
-    /**
-     * @param \stdClass $address
-     */
-    private function applyIsFreshheadsAddressAssertions(\stdClass $address)
+    private function applyIsFreshheadsAddressAssertions(stdClass $address): void
     {
-        static::assertSame(strtoupper($address->postcode), self::FRESHHEADS_POSTCODE, 'Incoming postcode did not match the expected postcode');
-        static::assertSame((string)$address->number, (string)self::FRESHHEADS_NUMBER, 'Incoming number did not match the expected number');
-        static::assertSame($address->city->label, self::FRESHHEADS_CITY, 'Incoming city did not match the expected city');
+        Assert::assertSame(strtoupper($address->postcode), self::FRESHHEADS_POSTCODE, 'Incoming postcode did not match the expected postcode');
+        Assert::assertSame((string)$address->number, (string)self::FRESHHEADS_NUMBER, 'Incoming number did not match the expected number');
+        Assert::assertSame($address->city->label, self::FRESHHEADS_CITY, 'Incoming city did not match the expected city');
 
         // use number_format number rounding to allow for minor changes between expected and actual value
         $wgs84 = $address->geo->center->wgs84;
 
-        static::assertSame(
+        Assert::assertSame(
             number_format($wgs84->coordinates[0], 5),
             number_format(self::FRESHHEADS_LONGITUDE, 5),
             'Incoming longitude did not match the expected value'
         );
-        static::assertSame(
+
+        Assert::assertSame(
             number_format($wgs84->coordinates[1], 5),
             number_format(self::FRESHHEADS_LATITUDE, 5),
             'Incoming latitude did not match the expected value'
         );
     }
 
-    /**
-     * @param \stdClass $response
-     */
-    private function applyAssertsToMakeSureAddressesArrayIsAvailableInResponse(\stdClass $response)
+    private function applyAssertsToMakeSureAddressesArrayIsAvailableInResponse(stdClass $response): void
     {
-        static::assertTrue(isset($response->_embedded->addresses));
-        static::assertTrue(is_array($response->_embedded->addresses));
+        Assert::assertTrue(isset($response->_embedded->addresses));
+        Assert::assertIsArray($response->_embedded->addresses);
     }
 
-    /**
-     * @param \stdClass $address
-     */
-    private function applyAddressFieldAreSetAndOfTheCorrectTypeAssertions(\stdClass $address)
+    private function applyAddressFieldAreSetAndOfTheCorrectTypeAssertions(stdClass $address): void
     {
         // only test the availability of the most import fields and their values
 
-        static::assertTrue(isset($address->street), 'Incoming address did not have a street field');
-        static::assertTrue(is_string($address->street), 'Incoming address did not have a street value of type string');
+        Assert::assertTrue(isset($address->street), 'Incoming address did not have a street field');
+        Assert::assertIsString($address->street, 'Incoming address did not have a street value of type string');
 
-        static::assertTrue(isset($address->city->label), 'Incoming address did not have a city.label field');
-        static::assertTrue(is_string($address->city->label), 'Incoming address did not have a city.label value of type string');
+        Assert::assertTrue(isset($address->city->label), 'Incoming address did not have a city.label field');
+        Assert::assertIsString($address->city->label, 'Incoming address did not have a city.label value of type string');
 
-        static::assertTrue(isset($address->postcode), 'Incoming address did not have a postcode field');
-        static::assertTrue(preg_match(self::POSTCODE_PATTERN, $address->postcode) === 1, 'Incoming address did not have a postcode value that matches the pattern: ' . self::POSTCODE_PATTERN);
+        Assert::assertTrue(isset($address->postcode), 'Incoming address did not have a postcode field');
+        Assert::assertTrue(preg_match(self::POSTCODE_PATTERN, $address->postcode) === 1, 'Incoming address did not have a postcode value that matches the pattern: ' . self::POSTCODE_PATTERN);
 
-        static::assertTrue(isset($address->number), 'Incoming address did not have a number field');
-        static::assertTrue(is_string($address->number) || is_numeric($address->number), 'Incoming address did not have a number field with type string');
+        Assert::assertTrue(isset($address->number), 'Incoming address did not have a number field');
+        Assert::assertTrue(is_string($address->number) || is_numeric($address->number), 'Incoming address did not have a number field with type string');
 
         $wgs84 = $address->geo->center->wgs84;
 
-        static::assertTrue(isset($wgs84->coordinates[0]), 'Incoming address did not have a longitude field');
-        static::assertTrue(is_float($address->geo->center->wgs84->coordinates[0]), 'Incoming address did not have a longitude value of type float');
+        Assert::assertTrue(isset($wgs84->coordinates[0]), 'Incoming address did not have a longitude field');
+        Assert::assertIsFloat($wgs84->coordinates[0], 'Incoming address did not have a longitude value of type float');
 
-        static::assertTrue(isset($wgs84->coordinates[1]), 'Incoming address did not have a latitude field');
-        static::assertTrue(is_float($address->geo->center->wgs84->coordinates[1]), 'Incoming address did not have a latitude value of type float');
+        Assert::assertTrue(isset($wgs84->coordinates[1]), 'Incoming address did not have a latitude field');
+        Assert::assertIsFloat($wgs84->coordinates[1], 'Incoming address did not have a latitude value of type float');
     }
 
-    /**
-     * @param string $mockedResponses
-     *
-     * @return Client
-     */
-    private function createClient(Response $mockedResponse)
+    private function createClient(Response $mockedResponse): Client
     {
-        $httpClient = new \Http\Mock\Client();
+        $httpClient = new MockClient();
         $httpClient->addResponse($mockedResponse);
 
         return new Client($httpClient);