feat(expect): updates test suite to use expectation api

tests/Features/AfterAll.php

@@ -8,8 +8,8 @@ afterAll(function () use ($file) {
 
 test('deletes file after all', function () use ($file) {
     file_put_contents($file, 'foo');
-    assertFileExists($file);
+    $this->assertFileExists($file);
     register_shutdown_function(function () use ($file) {
-        assertFileNotExists($file);
+        $this->assertFileNotExists($file);
     });
 });

tests/Features/AfterEach.php

@@ -11,10 +11,10 @@ afterEach(function () use ($state) {
 });
 
 it('does not get executed before the test', function () {
-    assertFalse(property_exists($this->state, 'bar'));
+    expect(property_exists($this->state, 'bar'))->toBeFalse();
 });
 
 it('gets executed after the test', function () {
-    assertTrue(property_exists($this->state, 'bar'));
-    assertEquals(2, $this->state->bar);
+    expect(property_exists($this->state, 'bar'))->toBeTrue();
+    expect($this->state->bar)->toBe(2);
 });

tests/Features/BeforeAll.php

@@ -8,11 +8,11 @@ beforeAll(function () use ($foo) {
 });
 
 it('gets executed before tests', function () use ($foo) {
-    assertEquals($foo->bar, 1);
+    expect($foo->bar)->toBe(1);
 
     $foo->bar = 'changed';
 });
 
 it('do not get executed before each test', function () use ($foo) {
-    assertEquals($foo->bar, 'changed');
+    expect($foo->bar)->toBe('changed');
 });

tests/Features/BeforeEach.php

@@ -5,11 +5,11 @@ beforeEach(function () {
 });
 
 it('gets executed before each test', function () {
-    assertEquals($this->bar, 2);
+    expect($this->bar)->toBe(2);
 
     $this->bar = 'changed';
 });
 
 it('gets executed before each test once again', function () {
-    assertEquals($this->bar, 2);
+    expect($this->bar)->toBe(2);
 });

tests/Features/Datasets.php

@@ -23,13 +23,13 @@ it('sets closures', function () {
         yield [1];
     });
 
-    assertEquals([[1]], iterator_to_array(Datasets::get('foo')()));
+    expect(iterator_to_array(Datasets::get('foo')()))->toBe([[1]]);
 });
 
 it('sets arrays', function () {
     Datasets::set('bar', [[2]]);
 
-    assertEquals([[2]], Datasets::get('bar'));
+    expect(Datasets::get('bar'))->toBe([[2]]);
 });
 
 it('gets bound to test case object', function () {
@@ -37,7 +37,7 @@ it('gets bound to test case object', function () {
 })->with([['a'], ['b']]);
 
 test('it truncates the description', function () {
-    assertTrue(true);
+    expect(true)->toBe(true);
     // it gets tested by the integration test
 })->with([str_repeat('Fooo', 10000000)]);
 
@@ -48,51 +48,51 @@ $datasets = [[1], [2]];
 
 test('lazy datasets', function ($text) use ($state, $datasets) {
     $state->text .= $text;
-    assertTrue(in_array([$text], $datasets));
+    expect(in_array([$text], $datasets))->toBe(true);
 })->with($datasets);
 
 test('lazy datasets did the job right', function () use ($state) {
-    assertEquals('12', $state->text);
+    expect($state->text)->toBe('12');
 });
 
 $state->text = '';
 
 test('eager datasets', function ($text) use ($state, $datasets) {
     $state->text .= $text;
-    assertTrue(in_array([$text], $datasets));
+    expect($datasets)->toContain([$text]);
 })->with(function () use ($datasets) {
     return $datasets;
 });
 
 test('eager datasets did the job right', function () use ($state) {
-    assertEquals('1212', $state->text);
+    expect($state->text)->toBe('1212');
 });
 
 test('lazy registered datasets', function ($text) use ($state, $datasets) {
     $state->text .= $text;
-    assertTrue(in_array([$text], $datasets));
+    expect($datasets)->toContain([$text]);
 })->with('numbers.array');
 
 test('lazy registered datasets did the job right', function () use ($state) {
-    assertEquals('121212', $state->text);
+    expect($state->text)->toBe('121212');
 });
 
 test('eager registered datasets', function ($text) use ($state, $datasets) {
     $state->text .= $text;
-    assertTrue(in_array([$text], $datasets));
+    expect($datasets)->toContain([$text]);
 })->with('numbers.closure');
 
 test('eager registered datasets did the job right', function () use ($state) {
-    assertEquals('12121212', $state->text);
+    expect($state->text)->toBe('12121212');
 });
 
 test('eager wrapped registered datasets', function ($text) use ($state, $datasets) {
     $state->text .= $text;
-    assertTrue(in_array([$text], $datasets));
+    expect($datasets)->toContain([$text]);
 })->with('numbers.closure.wrapped');
 
 test('eager registered wrapped datasets did the job right', function () use ($state) {
-    assertEquals('1212121212', $state->text);
+    expect($state->text)->toBe('1212121212');
 });
 
 class Bar
@@ -105,13 +105,13 @@ $namedDatasets = [
 ];
 
 test('lazy named datasets', function ($text) use ($state, $datasets) {
-    assertTrue(true);
+    expect(true)->toBeTrue();
 })->with($namedDatasets);
 
 $counter = 0;
 
 it('creates unique test case names', function (string $name, Plugin $plugin, bool $bool) use (&$counter) {
-    assertTrue(true);
+    expect(true)->toBeTrue();
     $counter++;
 })->with([
     ['Name 1', new Plugin(), true],
@@ -123,5 +123,5 @@ it('creates unique test case names', function (string $name, Plugin $plugin, boo
 ]);
 
 it('creates unique test case names - count', function () use (&$counter) {
-    assertEquals(6, $counter);
+    expect($counter)->toBe(6);
 });

tests/Features/Depends.php

@@ -3,38 +3,32 @@
 $runCounter = 0;
 
 test('first', function () use (&$runCounter) {
-    assertTrue(true);
+    expect(true)->toBeTrue();
     $runCounter++;
 
     return 'first';
 });
 
 test('second', function () use (&$runCounter) {
-    assertTrue(true);
+    expect(true)->toBeTrue();
     $runCounter++;
 
     return 'second';
 });
 
 test('depends', function () {
-    assertEquals(
-        ['first', 'second'],
-        func_get_args()
-    );
+    expect(func_get_args())->toBe(['first', 'second']);
 })->depends('first', 'second');
 
 test('depends with ...params', function (string ...$params) {
-    assertEquals(
-        ['first', 'second'],
-        $params
-    );
+    expect(func_get_args())->toBe($params);
 })->depends('first', 'second');
 
 test('depends with defined arguments', function (string $first, string $second) {
-    assertEquals('first', $first);
-    assertEquals('second', $second);
+    expect($first)->toBe('first');
+    expect($second)->toBe('second');
 })->depends('first', 'second');
 
 test('depends run test only once', function () use (&$runCounter) {
-    assertEquals(2, $runCounter);
+    expect($runCounter)->toBe(2);
 })->depends('first', 'second');

tests/Features/Helpers.php

@@ -7,7 +7,7 @@ function addUser()
 
 it('can set/get properties on $this', function () {
     addUser();
-    assertEquals('nuno', $this->user);
+    expect($this->user)->toBe('nuno');
 });
 
 it('throws error if property do not exist', function () {
@@ -27,15 +27,14 @@ function mockUser()
     $mock = test()->createMock(User::class);
 
     $mock->method('getName')
-         ->willReturn('maduro');
+        ->willReturn('maduro');
 
     return $mock;
 }
 
 it('allows to call underlying protected/private methods', function () {
     $user = mockUser();
-
-    assertEquals('maduro', $user->getName());
+    expect($user->getName())->toBe('maduro');
 });
 
 it('throws error if method do not exist', function () {

tests/Features/It.php

@@ -1,7 +1,7 @@
 <?php
 
 it('is a test', function () {
-    assertArrayHasKey('key', ['key' => 'foo']);
+    $this->assertArrayHasKey('key', ['key' => 'foo']);
 });
 
-it('is a higher order message test')->assertTrue(true);
+it('is a higher order message test')->expect(true)->toBeTrue();

tests/Features/Macro.php

@@ -6,7 +6,7 @@ use PHPUnit\Framework\TestCase;
 uses(Macroable::class);
 
 beforeEach()->macro('bar', function () {
-    assertInstanceOf(TestCase::class, $this);
+    expect($this)->toBeInstanceOf(TestCase::class);
 });
 
 it('can call chained macro method')->bar();

tests/Features/PendingHigherOrderTests.php

@@ -1,11 +1,12 @@
 <?php
 
+use Pest\PendingObjects\TestCall;
 use PHPUnit\Framework\TestCase;
 
 uses(Gettable::class);
 
 /**
- * @return TestCase|Gettable
+ * @return TestCase|TestCall|Gettable
  */
 function get(string $route)
 {
@@ -15,15 +16,15 @@ function get(string $route)
 trait Gettable
 {
     /**
-     * @return TestCase|Gettable
+     * @return TestCase|TestCall|Gettable
      */
     public function get(string $route)
     {
-        assertNotEmpty($route);
+        expect($route)->not->toBeEmpty();
 
         return $this;
     }
 }
 
-get('foo')->get('bar')->assertTrue(true);
-get('foo')->assertTrue(true);
+get('foo')->get('bar')->expect(true)->toBeTrue();
+get('foo')->expect(true)->toBeTrue();

tests/Features/Test.php

@@ -1,7 +1,7 @@
 <?php
 
 test('a test', function () {
-    assertArrayHasKey('key', ['key' => 'foo']);
+    $this->assertArrayHasKey('key', ['key' => 'foo']);
 });
 
-test('higher order message test')->assertTrue(true);
+test('higher order message test')->expect(true)->toBeTrue();

tests/Features/TestCycle.php

@@ -20,8 +20,8 @@ afterAll(function () {
 });
 
 register_shutdown_function(function () use ($foo) {
-    assertFalse($foo->beforeAll);
-    assertFalse($foo->beforeEach);
-    assertFalse($foo->afterEach);
-    assertFalse($foo->afterAll);
+    expect($foo->beforeAll)->toBeFalse();
+    expect($foo->beforeEach)->toBeFalse();
+    expect($foo->afterEach)->toBeFalse();
+    expect($foo->afterAll)->toBeFalse();
 });