Merge pull request #16 from martin-helmich/feature/support-phpunit9

martin-helmich · web-flow · commit 1ac4e9fc095f · 2020-03-28T14:47:46.000+01:00
Add support for PHPUnit 9 and migrate to Github Actions
diff --git a/.github/workflows/php.yml b/.github/workflows/php.yml
@@ -0,0 +1,64 @@
+name: Unit tests
+
+on: [push]
+
+jobs:
+  build:
+    strategy:      
+      matrix:
+        php: ['7.2', '7.3', '7.4']
+        phpunit: ['8.0', '9.0']
+        exclude:
+          - php: '7.2'
+            phpunit: '9.0'
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+      
+    - name: Setup PHP
+      uses: shivammathur/setup-php@v1
+      with:
+        php-version: ${{ matrix.php }}
+        extensions: mbstring, intl, json
+        coverage: pcov
+    
+    - name: Validate composer.json and composer.lock
+      run: composer validate
+
+    - name: Declare required PHPUnit version
+      run: |
+        composer require --no-update --dev phpunit/phpunit ~${{ matrix.phpunit }}
+
+    - name: Install dependencies
+      run: composer install --prefer-dist --no-progress --no-suggest
+
+    #- name: Run type checker
+    #  run: ./vendor/bin/psalm
+      
+    - name: Run unit tests
+      run: ./vendor/bin/phpunit --testdox
+
+  coverage:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+
+    - name: Setup PHP
+      uses: shivammathur/setup-php@v1
+      with:
+        php-version: 7.4
+        extensions: mbstring, intl, json
+        coverage: pcov
+    
+    - name: Install dependencies
+      run: composer install --prefer-dist --no-progress --no-suggest
+  
+    - name: Test & publish code coverage
+      uses: paambaati/codeclimate-action@v2.3.0
+      env:
+        CC_TEST_REPORTER_ID: ${{ secrets.codeClimateReporterID }}
+      with:
+        coverageCommand: ./vendor/bin/phpunit --coverage-clover=clover.xml
+        debug: true
diff --git a/README.md b/README.md
@@ -24,12 +24,12 @@ There are several release branches of this library, each of these being compatib
 with different releases of PHPUnit and PHP. The following table should give an
 easy overview:
 
-| PSR-7 assertion version | PHPUnit 4 | PHPUnit 5 | PHPUnit 6 | PHPUnit 7 | PHPUnit 8 |
-| ----------------------- | --------- | --------- | --------- | --------- | --------- |
-| v1 (branch `v1`), **unsupported** | :white_check_mark: | :white_check_mark: | :no_entry_sign: | :no_entry_sign: | :no_entry_sign: |
-| v2 (branch `v2`), **unsupported** | :no_entry_sign: | :no_entry_sign: | :white_check_mark: | :no_entry_sign: | :no_entry_sign: |
-| v3 (branch `v3`) | :no_entry_sign: | :no_entry_sign: | :no_entry_sign: | :white_check_mark: | :no_entry_sign: |
-| v4 (branch `master`) | :no_entry_sign: | :no_entry_sign: | :no_entry_sign: | :no_entry_sign: | :white_check_mark: |
+| PSR-7 assertion version | PHPUnit 4 | PHPUnit 5 | PHPUnit 6 | PHPUnit 7 | PHPUnit 8 | PHPUnit 9 |
+| ----------------------- | --------- | --------- | --------- | --------- | --------- | --------- |
+| v1 (branch `v1`), **unsupported** | :white_check_mark: | :white_check_mark: | :no_entry_sign: | :no_entry_sign: | :no_entry_sign: | :no_entry_sign: |
+| v2 (branch `v2`), **unsupported** | :no_entry_sign: | :no_entry_sign: | :white_check_mark: | :no_entry_sign: | :no_entry_sign: | :no_entry_sign: |
+| v3 (branch `v3`) | :no_entry_sign: | :no_entry_sign: | :no_entry_sign: | :white_check_mark: | :no_entry_sign: | :no_entry_sign: |
+| v4 (branch `master`) | :no_entry_sign: | :no_entry_sign: | :no_entry_sign: | :no_entry_sign: | :white_check_mark: | :white_check_mark: |
 
 When you are using `composer require` and have already declared a dependency to
 `phpunit/phpunit` in your `composer.json` file, Composer should pick latest
diff --git a/composer.json b/composer.json
@@ -10,15 +10,15 @@
     ],
     "require": {
         "php": "^7.1",
-        "helmich/phpunit-json-assert": "^3.0",
+        "helmich/phpunit-json-assert": "^3.1",
         "psr/http-message": "^1.0"
     },
     "require-dev": {
         "guzzlehttp/psr7": "^1.2",
-        "phpunit/phpunit": "^8.0"
+        "phpunit/phpunit": "^8.0 || ^9.0"
     },
     "conflict": {
-        "phpunit/phpunit": "<8.0 || >= 9.0"
+        "phpunit/phpunit": "<8.0 || >= 10.0"
     },
     "autoload": {
         "psr-4": {
@@ -27,12 +27,11 @@
     },
     "autoload-dev": {
         "files": [
-            "vendor/phpunit/phpunit/src/Framework/Assert/Functions.php",
             "vendor/helmich/phpunit-json-assert/src/Functions.php",
             "src/Functions.php"
         ]
     },
     "config": {
         "sort-packages": true
     }
-}
+}
diff --git a/tests/Functional/FunctionalConstraintTest.php b/tests/Functional/FunctionalConstraintTest.php
@@ -14,49 +14,49 @@ class FunctionalConstraintTest extends TestCase
     public function testHasUriCanSucceed()
     {
         $request = new Request('GET', '/foo');
-        assertThat($request, hasUri('/foo'));
+        self::assertThat($request, hasUri('/foo'));
     }
 
     public function testHasUriCanFail()
     {
         $this->expectException(AssertionFailedError::class);
 
         $request = new Request('GET', '/foo');
-        assertThat($request, hasUri('/bar'));
+        self::assertThat($request, hasUri('/bar'));
     }
 
     public function testHasHeaderCanSucceedWithPrimitiveValue()
     {
         $request = new Request('GET', '/', ['x-foo' => 'bar']);
-        assertThat($request, hasHeader('X-Foo', 'bar'));
+        self::assertThat($request, hasHeader('X-Foo', 'bar'));
     }
 
     public function testHasHeaderCanFailWithPrimitiveValue()
     {
         $this->expectException(AssertionFailedError::class);
 
         $request = new Request('GET', '/', ['x-foo' => 'baz']);
-        assertThat($request, hasHeader('X-Foo', 'bar'));
+        self::assertThat($request, hasHeader('X-Foo', 'bar'));
     }
 
     public function testHasHeaderCanFailWithNonExistingHeader()
     {
         $this->expectException(AssertionFailedError::class);
 
         $request = new Request('GET', '/', []);
-        assertThat($request, hasHeader('X-Foo', 'bar'));
+        self::assertThat($request, hasHeader('X-Foo', 'bar'));
     }
 
     public function testHasHeaderCanSucceedWithConstraint()
     {
         $request = new Request('GET', '/', ['x-foo' => 14]);
-        assertThat($request, hasHeader('X-Foo', greaterThanOrEqual(10)));
+        self::assertThat($request, hasHeader('X-Foo', self::greaterThanOrEqual(10)));
     }
 
     public function testHasHeadersCanSucceedWithConstraint()
     {
         $request = new Request('GET', '/', ['x-foo' => 14, 'content-type' => 'text/plain']);
-        assertThat($request, hasHeaders([
+        self::assertThat($request, hasHeaders([
             'X-Foo'        => Assert::greaterThanOrEqual(10),
             'Content-Type' => 'text/plain',
         ]));
@@ -67,27 +67,27 @@ public function testHasHeaderCanFailWithConstraint()
         $this->expectException(AssertionFailedError::class);
 
         $request = new Request('GET', '/', ['x-foo' => 4]);
-        assertThat($request, hasHeader('X-Foo', greaterThanOrEqual(10)));
+        self::assertThat($request, hasHeader('X-Foo', self::greaterThanOrEqual(10)));
     }
 
     public function testBodyMatchesCanSucceed()
     {
         $request = new Request('GET', '/', [], 'foobar');
-        assertThat($request, bodyMatches(equalTo('foobar')));
+        self::assertThat($request, bodyMatches(self::equalTo('foobar')));
     }
 
     public function testBodyMatchesCanFail()
     {
         $this->expectException(AssertionFailedError::class);
 
         $request = new Request('GET', '/', [], 'foobar');
-        assertThat($request, bodyMatches(equalTo('barbaz')));
+        self::assertThat($request, bodyMatches(self::equalTo('barbaz')));
     }
 
     public function testBodyMatchesJsonCanSucceed()
     {
         $request = new Request('GET', '/foo', ['content-type' => 'application/json'], json_encode(['foo' => 'bar']));
-        assertThat($request, bodyMatchesJson(['$.foo' => 'bar']));
+        self::assertThat($request, bodyMatchesJson(['$.foo' => 'bar']));
     }
 
     public function dataForRequestMethods()
@@ -109,55 +109,55 @@ public function dataForRequestMethods()
      */
     public function testAssertRequestHasMethodCanSucceed($method)
     {
-        assertThat(new Request($method, '/'), hasMethod($method));
+        self::assertThat(new Request($method, '/'), hasMethod($method));
     }
 
     public function testIsGetCanSucceed()
     {
-        assertThat(new Request('GET', '/'), isGet());
+        self::assertThat(new Request('GET', '/'), isGet());
     }
 
     public function testIsGetCanFail()
     {
         $this->expectException(AssertionFailedError::class);
 
-        assertThat(new Request('POST', '/'), isGet());
+        self::assertThat(new Request('POST', '/'), isGet());
     }
 
     public function testIsPostCanSucceed()
     {
-        assertThat(new Request('POST', '/'), isPost());
+        self::assertThat(new Request('POST', '/'), isPost());
     }
 
     public function testIsPostCanFail()
     {
         $this->expectException(AssertionFailedError::class);
 
-        assertThat(new Request('GET', '/'), isPost());
+        self::assertThat(new Request('GET', '/'), isPost());
     }
 
     public function testIsPutCanSucceed()
     {
-        assertThat(new Request('PUT', '/'), isPut());
+        self::assertThat(new Request('PUT', '/'), isPut());
     }
 
     public function testIsPutCanFail()
     {
         $this->expectException(AssertionFailedError::class);
 
-        assertThat(new Request('GET', '/'), isPut());
+        self::assertThat(new Request('GET', '/'), isPut());
     }
 
     public function testIsDeleteCanSucceed()
     {
-        assertThat(new Request('DELETE', '/'), isDelete());
+        self::assertThat(new Request('DELETE', '/'), isDelete());
     }
 
     public function testIsDeleteCanFail()
     {
         $this->expectException(AssertionFailedError::class);
 
-        assertThat(new Request('POST', '/'), isDelete());
+        self::assertThat(new Request('POST', '/'), isDelete());
     }
 
     public function dataForStatusCodes()
@@ -175,60 +175,60 @@ public function dataForStatusCodes()
      */
     public function testHasStatusCanSucceed($status)
     {
-        assertThat(new Response($status), hasStatus($status));
+        self::assertThat(new Response($status), hasStatus($status));
     }
 
     public function testHasStatusCanFail()
     {
         $this->expectException(AssertionFailedError::class);
 
-        assertThat(new Response(400), hasStatus(200));
+        self::assertThat(new Response(400), hasStatus(200));
     }
 
     public function testIsSuccessCanSucceed()
     {
-        assertThat(new Response(200), isSuccess());
+        self::assertThat(new Response(200), isSuccess());
     }
 
     public function testIsSuccessCanFail()
     {
         $this->expectException(AssertionFailedError::class);
 
-        assertThat(new Response(404), isSuccess());
+        self::assertThat(new Response(404), isSuccess());
     }
 
     public function testIsClientErrorCanSucceed()
     {
-        assertThat(new Response(404), isClientError());
+        self::assertThat(new Response(404), isClientError());
     }
 
     public function testIsClientErrorCanFail()
     {
         $this->expectException(AssertionFailedError::class);
 
-        assertThat(new Response(200), isClientError());
+        self::assertThat(new Response(200), isClientError());
     }
 
     public function testIsServerErrorCanSucceed()
     {
-        assertThat(new Response(503), isServerError());
+        self::assertThat(new Response(503), isServerError());
     }
 
     public function testIsServerErrorCanFail()
     {
         $this->expectException(AssertionFailedError::class);
 
-        assertThat(new Response(200), isServerError());
+        self::assertThat(new Response(200), isServerError());
     }
 
     public function testHasContentTypeSucceedsOnEquality()
     {
-        assertThat(new Response(200, ['content-type' => ['application/json']]), hasContentType('application/json'));
+        self::assertThat(new Response(200, ['content-type' => ['application/json']]), hasContentType('application/json'));
     }
 
     public function testHasContentTypeSucceedsWithCharset()
     {
-        assertThat(new Response(200, ['content-type' => ['application/json;charset=utf8']]), hasContentType('application/json'));
+        self::assertThat(new Response(200, ['content-type' => ['application/json;charset=utf8']]), hasContentType('application/json'));
     }
 
 }
diff --git a/tests/Unit/Constraint/HasQueryParameterConstraintTest.php b/tests/Unit/Constraint/HasQueryParameterConstraintTest.php
@@ -14,31 +14,31 @@ public function testMatchesStringUrls()
         $url = "https://some-domain.example/foo?bar=baz";
         $constraint = new HasQueryParameterConstraint("bar", "baz");
 
-        assertThat($constraint->evaluate($url, "", true), isTrue());
+        self::assertThat($constraint->evaluate($url, "", true), self::isTrue());
     }
 
     public function testMatchesStringUrlsNegative()
     {
         $url = "https://some-domain.example/foo?bar=baz";
         $constraint = new HasQueryParameterConstraint("tulpen", "bunt");
 
-        assertThat($constraint->evaluate($url, "", true), isFalse());
+        self::assertThat($constraint->evaluate($url, "", true), self::isFalse());
     }
 
     public function testMatchesPsr7Uris()
     {
         $uri = uri_for("https://some-domain.example/foo?bar=baz");
         $constraint = new HasQueryParameterConstraint("bar", "baz");
 
-        assertThat($constraint->evaluate($uri, "", true), isTrue());
+        self::assertThat($constraint->evaluate($uri, "", true), self::isTrue());
     }
 
     public function testMatchesPsr7UrisNegative()
     {
         $uri = uri_for("https://some-domain.example/foo?autobahn=1");
         $constraint = new HasQueryParameterConstraint("bar", "baz");
 
-        assertThat($constraint->evaluate($uri, "", true), isFalse());
+        self::assertThat($constraint->evaluate($uri, "", true), self::isFalse());
     }
 
     public function testMatchesRequest()
@@ -48,6 +48,6 @@ public function testMatchesRequest()
 
         $constraint = new HasQueryParameterConstraint("bar", "baz");
 
-        assertThat($constraint->evaluate($request, "", true), isTrue());
+        self::assertThat($constraint->evaluate($request, "", true), self::isTrue());
     }
 }
diff --git a/tests/Unit/Constraint/HasQueryParametersConstraintTest.php b/tests/Unit/Constraint/HasQueryParametersConstraintTest.php
diff --git a/tests/Unit/Constraint/IsAbsoluteUriConstraintTest.php b/tests/Unit/Constraint/IsAbsoluteUriConstraintTest.php

Original file line number	Diff line number	Diff line change
`@@ -14,49 +14,49 @@ class FunctionalConstraintTest extends TestCase`
`14`	`14`	`public function testHasUriCanSucceed()`
`15`	`15`	`{`
`16`	`16`	`$request = new Request('GET', '/foo');`
`17`		`- assertThat($request, hasUri('/foo'));`
	`17`	`+ self::assertThat($request, hasUri('/foo'));`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`public function testHasUriCanFail()`
`21`	`21`	`{`
`22`	`22`	`$this->expectException(AssertionFailedError::class);`
`23`	`23`
`24`	`24`	`$request = new Request('GET', '/foo');`
`25`		`- assertThat($request, hasUri('/bar'));`
	`25`	`+ self::assertThat($request, hasUri('/bar'));`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`public function testHasHeaderCanSucceedWithPrimitiveValue()`
`29`	`29`	`{`
`30`	`30`	`$request = new Request('GET', '/', ['x-foo' => 'bar']);`
`31`		`- assertThat($request, hasHeader('X-Foo', 'bar'));`
	`31`	`+ self::assertThat($request, hasHeader('X-Foo', 'bar'));`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`public function testHasHeaderCanFailWithPrimitiveValue()`
`35`	`35`	`{`
`36`	`36`	`$this->expectException(AssertionFailedError::class);`
`37`	`37`
`38`	`38`	`$request = new Request('GET', '/', ['x-foo' => 'baz']);`
`39`		`- assertThat($request, hasHeader('X-Foo', 'bar'));`
	`39`	`+ self::assertThat($request, hasHeader('X-Foo', 'bar'));`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`public function testHasHeaderCanFailWithNonExistingHeader()`
`43`	`43`	`{`
`44`	`44`	`$this->expectException(AssertionFailedError::class);`
`45`	`45`
`46`	`46`	`$request = new Request('GET', '/', []);`
`47`		`- assertThat($request, hasHeader('X-Foo', 'bar'));`
	`47`	`+ self::assertThat($request, hasHeader('X-Foo', 'bar'));`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`public function testHasHeaderCanSucceedWithConstraint()`
`51`	`51`	`{`
`52`	`52`	`$request = new Request('GET', '/', ['x-foo' => 14]);`
`53`		`- assertThat($request, hasHeader('X-Foo', greaterThanOrEqual(10)));`
	`53`	`+ self::assertThat($request, hasHeader('X-Foo', self::greaterThanOrEqual(10)));`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`public function testHasHeadersCanSucceedWithConstraint()`
`57`	`57`	`{`
`58`	`58`	`$request = new Request('GET', '/', ['x-foo' => 14, 'content-type' => 'text/plain']);`
`59`		`- assertThat($request, hasHeaders([`
	`59`	`+ self::assertThat($request, hasHeaders([`
`60`	`60`	`'X-Foo' => Assert::greaterThanOrEqual(10),`
`61`	`61`	`'Content-Type' => 'text/plain',`
`62`	`62`	`]));`
`@@ -67,27 +67,27 @@ public function testHasHeaderCanFailWithConstraint()`
`67`	`67`	`$this->expectException(AssertionFailedError::class);`
`68`	`68`
`69`	`69`	`$request = new Request('GET', '/', ['x-foo' => 4]);`
`70`		`- assertThat($request, hasHeader('X-Foo', greaterThanOrEqual(10)));`
	`70`	`+ self::assertThat($request, hasHeader('X-Foo', self::greaterThanOrEqual(10)));`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`public function testBodyMatchesCanSucceed()`
`74`	`74`	`{`
`75`	`75`	`$request = new Request('GET', '/', [], 'foobar');`
`76`		`- assertThat($request, bodyMatches(equalTo('foobar')));`
	`76`	`+ self::assertThat($request, bodyMatches(self::equalTo('foobar')));`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`public function testBodyMatchesCanFail()`
`80`	`80`	`{`
`81`	`81`	`$this->expectException(AssertionFailedError::class);`
`82`	`82`
`83`	`83`	`$request = new Request('GET', '/', [], 'foobar');`
`84`		`- assertThat($request, bodyMatches(equalTo('barbaz')));`
	`84`	`+ self::assertThat($request, bodyMatches(self::equalTo('barbaz')));`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`public function testBodyMatchesJsonCanSucceed()`
`88`	`88`	`{`
`89`	`89`	`$request = new Request('GET', '/foo', ['content-type' => 'application/json'], json_encode(['foo' => 'bar']));`
`90`		`- assertThat($request, bodyMatchesJson(['$.foo' => 'bar']));`
	`90`	`+ self::assertThat($request, bodyMatchesJson(['$.foo' => 'bar']));`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`public function dataForRequestMethods()`
`@@ -109,55 +109,55 @@ public function dataForRequestMethods()`
`109`	`109`	`*/`
`110`	`110`	`public function testAssertRequestHasMethodCanSucceed($method)`
`111`	`111`	`{`
`112`		`- assertThat(new Request($method, '/'), hasMethod($method));`
	`112`	`+ self::assertThat(new Request($method, '/'), hasMethod($method));`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`public function testIsGetCanSucceed()`
`116`	`116`	`{`
`117`		`- assertThat(new Request('GET', '/'), isGet());`
	`117`	`+ self::assertThat(new Request('GET', '/'), isGet());`
`118`	`118`	`}`
`119`	`119`
`120`	`120`	`public function testIsGetCanFail()`
`121`	`121`	`{`
`122`	`122`	`$this->expectException(AssertionFailedError::class);`
`123`	`123`
`124`		`- assertThat(new Request('POST', '/'), isGet());`
	`124`	`+ self::assertThat(new Request('POST', '/'), isGet());`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`public function testIsPostCanSucceed()`
`128`	`128`	`{`
`129`		`- assertThat(new Request('POST', '/'), isPost());`
	`129`	`+ self::assertThat(new Request('POST', '/'), isPost());`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`public function testIsPostCanFail()`
`133`	`133`	`{`
`134`	`134`	`$this->expectException(AssertionFailedError::class);`
`135`	`135`
`136`		`- assertThat(new Request('GET', '/'), isPost());`
	`136`	`+ self::assertThat(new Request('GET', '/'), isPost());`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`public function testIsPutCanSucceed()`
`140`	`140`	`{`
`141`		`- assertThat(new Request('PUT', '/'), isPut());`
	`141`	`+ self::assertThat(new Request('PUT', '/'), isPut());`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`public function testIsPutCanFail()`
`145`	`145`	`{`
`146`	`146`	`$this->expectException(AssertionFailedError::class);`
`147`	`147`
`148`		`- assertThat(new Request('GET', '/'), isPut());`
	`148`	`+ self::assertThat(new Request('GET', '/'), isPut());`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`public function testIsDeleteCanSucceed()`
`152`	`152`	`{`
`153`		`- assertThat(new Request('DELETE', '/'), isDelete());`
	`153`	`+ self::assertThat(new Request('DELETE', '/'), isDelete());`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`public function testIsDeleteCanFail()`
`157`	`157`	`{`
`158`	`158`	`$this->expectException(AssertionFailedError::class);`
`159`	`159`
`160`		`- assertThat(new Request('POST', '/'), isDelete());`
	`160`	`+ self::assertThat(new Request('POST', '/'), isDelete());`
`161`	`161`	`}`
`162`	`162`
`163`	`163`	`public function dataForStatusCodes()`
`@@ -175,60 +175,60 @@ public function dataForStatusCodes()`
`175`	`175`	`*/`
`176`	`176`	`public function testHasStatusCanSucceed($status)`
`177`	`177`	`{`
`178`		`- assertThat(new Response($status), hasStatus($status));`
	`178`	`+ self::assertThat(new Response($status), hasStatus($status));`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`public function testHasStatusCanFail()`
`182`	`182`	`{`
`183`	`183`	`$this->expectException(AssertionFailedError::class);`
`184`	`184`
`185`		`- assertThat(new Response(400), hasStatus(200));`
	`185`	`+ self::assertThat(new Response(400), hasStatus(200));`
`186`	`186`	`}`
`187`	`187`
`188`	`188`	`public function testIsSuccessCanSucceed()`
`189`	`189`	`{`
`190`		`- assertThat(new Response(200), isSuccess());`
	`190`	`+ self::assertThat(new Response(200), isSuccess());`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`public function testIsSuccessCanFail()`
`194`	`194`	`{`
`195`	`195`	`$this->expectException(AssertionFailedError::class);`
`196`	`196`
`197`		`- assertThat(new Response(404), isSuccess());`
	`197`	`+ self::assertThat(new Response(404), isSuccess());`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`public function testIsClientErrorCanSucceed()`
`201`	`201`	`{`
`202`		`- assertThat(new Response(404), isClientError());`
	`202`	`+ self::assertThat(new Response(404), isClientError());`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`public function testIsClientErrorCanFail()`
`206`	`206`	`{`
`207`	`207`	`$this->expectException(AssertionFailedError::class);`
`208`	`208`
`209`		`- assertThat(new Response(200), isClientError());`
	`209`	`+ self::assertThat(new Response(200), isClientError());`
`210`	`210`	`}`
`211`	`211`
`212`	`212`	`public function testIsServerErrorCanSucceed()`
`213`	`213`	`{`
`214`		`- assertThat(new Response(503), isServerError());`
	`214`	`+ self::assertThat(new Response(503), isServerError());`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`public function testIsServerErrorCanFail()`
`218`	`218`	`{`
`219`	`219`	`$this->expectException(AssertionFailedError::class);`
`220`	`220`
`221`		`- assertThat(new Response(200), isServerError());`
	`221`	`+ self::assertThat(new Response(200), isServerError());`
`222`	`222`	`}`
`223`	`223`
`224`	`224`	`public function testHasContentTypeSucceedsOnEquality()`
`225`	`225`	`{`
`226`		`- assertThat(new Response(200, ['content-type' => ['application/json']]), hasContentType('application/json'));`
	`226`	`+ self::assertThat(new Response(200, ['content-type' => ['application/json']]), hasContentType('application/json'));`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`public function testHasContentTypeSucceedsWithCharset()`
`230`	`230`	`{`
`231`		`- assertThat(new Response(200, ['content-type' => ['application/json;charset=utf8']]), hasContentType('application/json'));`
	`231`	`+ self::assertThat(new Response(200, ['content-type' => ['application/json;charset=utf8']]), hasContentType('application/json'));`
`232`	`232`	`}`
`233`	`233`
`234`	`234`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,31 +14,31 @@ public function testMatchesStringUrls()`
`14`	`14`	`$url = "https://some-domain.example/foo?bar=baz";`
`15`	`15`	`$constraint = new HasQueryParameterConstraint("bar", "baz");`
`16`	`16`
`17`		`- assertThat($constraint->evaluate($url, "", true), isTrue());`
	`17`	`+ self::assertThat($constraint->evaluate($url, "", true), self::isTrue());`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`public function testMatchesStringUrlsNegative()`
`21`	`21`	`{`
`22`	`22`	`$url = "https://some-domain.example/foo?bar=baz";`
`23`	`23`	`$constraint = new HasQueryParameterConstraint("tulpen", "bunt");`
`24`	`24`
`25`		`- assertThat($constraint->evaluate($url, "", true), isFalse());`
	`25`	`+ self::assertThat($constraint->evaluate($url, "", true), self::isFalse());`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`public function testMatchesPsr7Uris()`
`29`	`29`	`{`
`30`	`30`	`$uri = uri_for("https://some-domain.example/foo?bar=baz");`
`31`	`31`	`$constraint = new HasQueryParameterConstraint("bar", "baz");`
`32`	`32`
`33`		`- assertThat($constraint->evaluate($uri, "", true), isTrue());`
	`33`	`+ self::assertThat($constraint->evaluate($uri, "", true), self::isTrue());`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`public function testMatchesPsr7UrisNegative()`
`37`	`37`	`{`
`38`	`38`	`$uri = uri_for("https://some-domain.example/foo?autobahn=1");`
`39`	`39`	`$constraint = new HasQueryParameterConstraint("bar", "baz");`
`40`	`40`
`41`		`- assertThat($constraint->evaluate($uri, "", true), isFalse());`
	`41`	`+ self::assertThat($constraint->evaluate($uri, "", true), self::isFalse());`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public function testMatchesRequest()`
`@@ -48,6 +48,6 @@ public function testMatchesRequest()`
`48`	`48`
`49`	`49`	`$constraint = new HasQueryParameterConstraint("bar", "baz");`
`50`	`50`
`51`		`- assertThat($constraint->evaluate($request, "", true), isTrue());`
	`51`	`+ self::assertThat($constraint->evaluate($request, "", true), self::isTrue());`
`52`	`52`	`}`
`53`	`53`	`}`