From 38e429c3136d630eb3d4ef8cf9dd83c8097efabd Mon Sep 17 00:00:00 2001 From: Julien Arcin Date: Tue, 19 Mar 2024 18:38:48 +0700 Subject: [PATCH 1/3] Correct tests for last phpunit version compatibility --- .gitignore | 1 + phpunit.xml.dist | 12 ++++++------ tests/Integration/BelongsToMany/AttachTest.php | 2 +- tests/Integration/BelongsToMany/DetachTest.php | 2 +- tests/Integration/BelongsToMany/SyncTest.php | 2 +- tests/Integration/BelongsToMany/ToggleTest.php | 2 +- .../BelongsToMany/UpdateExistingPivotTest.php | 2 +- tests/Integration/MorphToMany/AttachTest.php | 2 +- tests/Integration/MorphToMany/DetachTest.php | 2 +- tests/Integration/MorphToMany/SyncTest.php | 2 +- tests/Integration/MorphToMany/ToggleTest.php | 2 +- .../MorphToMany/UpdateExistingPivotTest.php | 2 +- 12 files changed, 17 insertions(+), 16 deletions(-) diff --git a/.gitignore b/.gitignore index 55b53fe..48baa5b 100644 --- a/.gitignore +++ b/.gitignore @@ -7,4 +7,5 @@ .phpunit.result.cache composer.lock phpunit.xml +.phpunit.cache yarn.lock diff --git a/phpunit.xml.dist b/phpunit.xml.dist index dcdcb3d..bf2c4c1 100644 --- a/phpunit.xml.dist +++ b/phpunit.xml.dist @@ -1,13 +1,13 @@ - - - - ./src - - + ./tests + + + ./src + + diff --git a/tests/Integration/BelongsToMany/AttachTest.php b/tests/Integration/BelongsToMany/AttachTest.php index 007aac5..fd35761 100644 --- a/tests/Integration/BelongsToMany/AttachTest.php +++ b/tests/Integration/BelongsToMany/AttachTest.php @@ -138,7 +138,7 @@ class AttachTest extends EventuallyTestCase /** * @return array */ - public function attachProvider(): array + public static function attachProvider(): array { return [ [ diff --git a/tests/Integration/BelongsToMany/DetachTest.php b/tests/Integration/BelongsToMany/DetachTest.php index d2d376e..3e8fc68 100644 --- a/tests/Integration/BelongsToMany/DetachTest.php +++ b/tests/Integration/BelongsToMany/DetachTest.php @@ -151,7 +151,7 @@ class DetachTest extends EventuallyTestCase /** * @return array */ - public function detachProvider(): array + public static function detachProvider(): array { return [ [ diff --git a/tests/Integration/BelongsToMany/SyncTest.php b/tests/Integration/BelongsToMany/SyncTest.php index 6f3ea46..38bfa7e 100644 --- a/tests/Integration/BelongsToMany/SyncTest.php +++ b/tests/Integration/BelongsToMany/SyncTest.php @@ -136,7 +136,7 @@ class SyncTest extends EventuallyTestCase /** * @return array */ - public function syncProvider(): array + public static function syncProvider(): array { return [ [ diff --git a/tests/Integration/BelongsToMany/ToggleTest.php b/tests/Integration/BelongsToMany/ToggleTest.php index a459747..505211e 100644 --- a/tests/Integration/BelongsToMany/ToggleTest.php +++ b/tests/Integration/BelongsToMany/ToggleTest.php @@ -135,7 +135,7 @@ class ToggleTest extends EventuallyTestCase /** * @return array */ - public function toggleProvider(): array + public static function toggleProvider(): array { return [ [ diff --git a/tests/Integration/BelongsToMany/UpdateExistingPivotTest.php b/tests/Integration/BelongsToMany/UpdateExistingPivotTest.php index 57273ef..2050c69 100644 --- a/tests/Integration/BelongsToMany/UpdateExistingPivotTest.php +++ b/tests/Integration/BelongsToMany/UpdateExistingPivotTest.php @@ -156,7 +156,7 @@ class UpdateExistingPivotTest extends EventuallyTestCase /** * @return array */ - public function updateExistingPivotProvider(): array + public static function updateExistingPivotProvider(): array { return [ [ diff --git a/tests/Integration/MorphToMany/AttachTest.php b/tests/Integration/MorphToMany/AttachTest.php index 664d57f..6aa0354 100644 --- a/tests/Integration/MorphToMany/AttachTest.php +++ b/tests/Integration/MorphToMany/AttachTest.php @@ -148,7 +148,7 @@ class AttachTest extends EventuallyTestCase /** * @return array */ - public function attachProvider(): array + public static function attachProvider(): array { return [ [ diff --git a/tests/Integration/MorphToMany/DetachTest.php b/tests/Integration/MorphToMany/DetachTest.php index 10842d9..37bfff6 100644 --- a/tests/Integration/MorphToMany/DetachTest.php +++ b/tests/Integration/MorphToMany/DetachTest.php @@ -156,7 +156,7 @@ class DetachTest extends EventuallyTestCase /** * @return array */ - public function detachProvider(): array + public static function detachProvider(): array { return [ [ diff --git a/tests/Integration/MorphToMany/SyncTest.php b/tests/Integration/MorphToMany/SyncTest.php index 56142c9..e9a7195 100644 --- a/tests/Integration/MorphToMany/SyncTest.php +++ b/tests/Integration/MorphToMany/SyncTest.php @@ -138,7 +138,7 @@ class SyncTest extends EventuallyTestCase /** * @return array */ - public function syncProvider(): array + public static function syncProvider(): array { return [ [ diff --git a/tests/Integration/MorphToMany/ToggleTest.php b/tests/Integration/MorphToMany/ToggleTest.php index e4e091b..2ba769d 100644 --- a/tests/Integration/MorphToMany/ToggleTest.php +++ b/tests/Integration/MorphToMany/ToggleTest.php @@ -137,7 +137,7 @@ class ToggleTest extends EventuallyTestCase /** * @return array */ - public function toggleProvider(): array + public static function toggleProvider(): array { return [ [ diff --git a/tests/Integration/MorphToMany/UpdateExistingPivotTest.php b/tests/Integration/MorphToMany/UpdateExistingPivotTest.php index 5546682..a4edb4a 100644 --- a/tests/Integration/MorphToMany/UpdateExistingPivotTest.php +++ b/tests/Integration/MorphToMany/UpdateExistingPivotTest.php @@ -158,7 +158,7 @@ class UpdateExistingPivotTest extends EventuallyTestCase /** * @return array */ - public function updateExistingPivotProvider(): array + public static function updateExistingPivotProvider(): array { return [ [ -- GitLab From 54676b5177f607acef47a3531f72e148f54076a0 Mon Sep 17 00:00:00 2001 From: Julien Arcin Date: Tue, 19 Mar 2024 23:44:48 +0700 Subject: [PATCH 2/3] Update phpunit metadata to php attributese --- .../Integration/BelongsToMany/AttachTest.php | 237 ++++++++------- .../Integration/BelongsToMany/DetachTest.php | 261 +++++++++-------- tests/Integration/BelongsToMany/SyncTest.php | 233 ++++++++------- .../Integration/BelongsToMany/ToggleTest.php | 231 ++++++++------- .../BelongsToMany/UpdateExistingPivotTest.php | 271 +++++++++--------- tests/Integration/FirePivotEventTest.php | 9 +- tests/Integration/MorphToMany/AttachTest.php | 257 ++++++++--------- tests/Integration/MorphToMany/DetachTest.php | 271 +++++++++--------- tests/Integration/MorphToMany/SyncTest.php | 237 ++++++++------- tests/Integration/MorphToMany/ToggleTest.php | 235 ++++++++------- .../MorphToMany/UpdateExistingPivotTest.php | 257 ++++++++--------- tests/Unit/HasEventsTest.php | 5 +- 12 files changed, 1235 insertions(+), 1269 deletions(-) diff --git a/tests/Integration/BelongsToMany/AttachTest.php b/tests/Integration/BelongsToMany/AttachTest.php index fd35761..5fcfa8e 100644 --- a/tests/Integration/BelongsToMany/AttachTest.php +++ b/tests/Integration/BelongsToMany/AttachTest.php @@ -12,129 +12,11 @@ use Illuminate\Database\Eloquent\Collection; use Illuminate\Database\Eloquent\Model; use Illuminate\Support\Collection as BaseCollection; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\DataProvider; +use PHPUnit\Framework\Attributes\Test; class AttachTest extends EventuallyTestCase { - /** - * @test - */ - public function itSuccessfullyRegistersEventListeners(): void - { - User::attaching(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('articles', $relation); - - self::assertSame([ - [ - 'user_id' => 1, - 'article_id' => 1, - ], - [ - 'user_id' => 1, - 'article_id' => 2, - ], - ], $properties); - }); - - User::attached(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('articles', $relation); - - self::assertSame([ - [ - 'user_id' => 1, - 'article_id' => 1, - ], - [ - 'user_id' => 1, - 'article_id' => 2, - ], - ], $properties); - }); - - $user = UserFactory::new()->create(); - $articles = ArticleFactory::new()->count(2)->create(); - - self::assertCount(0, $user->articles()->get()); - - self::assertTrue($user->articles()->attach($articles)); - - self::assertCount(2, $user->articles()->get()); - } - - /** - * @test - */ - public function itPreventsModelsFromBeingAttached(): void - { - User::attaching(static function () { - return false; - }); - - $user = UserFactory::new()->create(); - $articles = ArticleFactory::new()->count(2)->create(); - - self::assertCount(0, $user->articles()->get()); - - self::assertFalse($user->articles()->attach($articles)); - - self::assertCount(0, $user->articles()->get()); - } - - /** - * @test - * @dataProvider attachProvider - * - * @param mixed $id - * @param array $attributes - * @param array $expectedPayload - */ - public function itSuccessfullyAttachesModels($id, array $attributes, array $expectedPayload): void - { - $user = UserFactory::new()->create(); - $articles = ArticleFactory::new()->count(2)->create(); - - self::assertCount(0, $user->articles()->get()); - - Event::fake(); - - switch ($id) { - case Model::class: - $id = $articles->first(); - break; - - case Collection::class: - $id = $articles; - break; - } - - self::assertTrue($user->articles()->attach($id, $attributes)); - - Event::assertDispatched(sprintf('eloquent.attaching: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - self::assertTrue($halt); - - return true; - }); - - Event::assertDispatched(sprintf('eloquent.attached: %s', User::class), static function ($event, $payload) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - return true; - }); - } - /** * @return array */ @@ -304,4 +186,119 @@ class AttachTest extends EventuallyTestCase ], ]; } + + #[Test] + public function itSuccessfullyRegistersEventListeners(): void + { + User::attaching(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('articles', $relation); + + self::assertSame([ + [ + 'user_id' => 1, + 'article_id' => 1, + ], + [ + 'user_id' => 1, + 'article_id' => 2, + ], + ], $properties); + }); + + User::attached(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('articles', $relation); + + self::assertSame([ + [ + 'user_id' => 1, + 'article_id' => 1, + ], + [ + 'user_id' => 1, + 'article_id' => 2, + ], + ], $properties); + }); + + $user = UserFactory::new()->create(); + $articles = ArticleFactory::new()->count(2)->create(); + + self::assertCount(0, $user->articles()->get()); + + self::assertTrue($user->articles()->attach($articles)); + + self::assertCount(2, $user->articles()->get()); + } + + #[Test] + public function itPreventsModelsFromBeingAttached(): void + { + User::attaching(static function () { + return false; + }); + + $user = UserFactory::new()->create(); + $articles = ArticleFactory::new()->count(2)->create(); + + self::assertCount(0, $user->articles()->get()); + + self::assertFalse($user->articles()->attach($articles)); + + self::assertCount(0, $user->articles()->get()); + } + + /** + * @param mixed $id + * @param array $attributes + * @param array $expectedPayload + */ + #[Test] + #[DataProvider('attachProvider')] + public function itSuccessfullyAttachesModels($id, array $attributes, array $expectedPayload): void + { + $user = UserFactory::new()->create(); + $articles = ArticleFactory::new()->count(2)->create(); + + self::assertCount(0, $user->articles()->get()); + + Event::fake(); + + switch ($id) { + case Model::class: + $id = $articles->first(); + break; + + case Collection::class: + $id = $articles; + break; + } + + self::assertTrue($user->articles()->attach($id, $attributes)); + + Event::assertDispatched(sprintf('eloquent.attaching: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + self::assertTrue($halt); + + return true; + }); + + Event::assertDispatched(sprintf('eloquent.attached: %s', User::class), static function ($event, $payload) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + return true; + }); + } } diff --git a/tests/Integration/BelongsToMany/DetachTest.php b/tests/Integration/BelongsToMany/DetachTest.php index 3e8fc68..39cb677 100644 --- a/tests/Integration/BelongsToMany/DetachTest.php +++ b/tests/Integration/BelongsToMany/DetachTest.php @@ -13,141 +13,11 @@ use Illuminate\Database\Eloquent\Collection; use Illuminate\Database\Eloquent\Model; use Illuminate\Support\Collection as BaseCollection; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\DataProvider; +use PHPUnit\Framework\Attributes\Test; class DetachTest extends EventuallyTestCase { - /** - * @test - */ - public function itSuccessfullyRegistersEventListeners(): void - { - User::detaching(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('articles', $relation); - - self::assertSame([ - [ - 'user_id' => 1, - 'article_id' => 1, - ], - [ - 'user_id' => 1, - 'article_id' => 2, - ], - ], $properties); - }); - - User::detached(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('articles', $relation); - - self::assertSame([ - [ - 'user_id' => 1, - 'article_id' => 1, - ], - [ - 'user_id' => 1, - 'article_id' => 2, - ], - ], $properties); - }); - - $user = UserFactory::new()->create(); - $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { - $article->users()->attach($user); - }); - - self::assertCount(2, $user->articles()->get()); - - self::assertSame(2, $user->articles()->detach($articles)); - - self::assertCount(0, $user->articles()->get()); - } - - /** - * @test - */ - public function itPreventsModelsFromBeingDetached(): void - { - User::detaching(static function () { - return false; - }); - - $user = UserFactory::new()->create(); - - $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { - $article->users()->attach($user); - }); - - self::assertCount(2, $user->articles()->get()); - - self::assertFalse($user->articles()->detach($articles)); - - self::assertCount(2, $user->articles()->get()); - } - - /** - * @test - * @dataProvider detachProvider - * - * @param int $results - * @param mixed $id - * @param array $expectedPayload - */ - public function itSuccessfullyDetachesModels(int $results, $id, array $expectedPayload): void - { - $user = UserFactory::new()->create(); - - $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { - $article->users()->attach($user, [ - 'liked' => (bool) random_int(0, 1), - ]); - }); - - self::assertCount(2, $user->articles()->get()); - - Event::fake(); - - switch ($id) { - case Model::class: - $id = $articles->first(); - break; - - case Collection::class: - $id = $articles; - break; - } - - self::assertSame($results, $user->articles()->detach($id)); - - self::assertCount(2 - $results, $user->articles()->get()); - - Event::assertDispatched(sprintf('eloquent.detaching: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - self::assertTrue($halt); - - return true; - }); - - Event::assertDispatched(sprintf('eloquent.detached: %s', User::class), static function ($event, $payload) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - return true; - }); - } - /** * @return array */ @@ -331,4 +201,131 @@ class DetachTest extends EventuallyTestCase ], ]; } + + #[Test] + public function itSuccessfullyRegistersEventListeners(): void + { + User::detaching(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('articles', $relation); + + self::assertSame([ + [ + 'user_id' => 1, + 'article_id' => 1, + ], + [ + 'user_id' => 1, + 'article_id' => 2, + ], + ], $properties); + }); + + User::detached(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('articles', $relation); + + self::assertSame([ + [ + 'user_id' => 1, + 'article_id' => 1, + ], + [ + 'user_id' => 1, + 'article_id' => 2, + ], + ], $properties); + }); + + $user = UserFactory::new()->create(); + $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { + $article->users()->attach($user); + }); + + self::assertCount(2, $user->articles()->get()); + + self::assertSame(2, $user->articles()->detach($articles)); + + self::assertCount(0, $user->articles()->get()); + } + + #[Test] + public function itPreventsModelsFromBeingDetached(): void + { + User::detaching(static function () { + return false; + }); + + $user = UserFactory::new()->create(); + + $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { + $article->users()->attach($user); + }); + + self::assertCount(2, $user->articles()->get()); + + self::assertFalse($user->articles()->detach($articles)); + + self::assertCount(2, $user->articles()->get()); + } + + /** + * @param int $results + * @param mixed $id + * @param array $expectedPayload + */ + #[Test] + #[DataProvider('detachProvider')] + public function itSuccessfullyDetachesModels(int $results, $id, array $expectedPayload): void + { + $user = UserFactory::new()->create(); + + $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { + $article->users()->attach($user, [ + 'liked' => (bool) random_int(0, 1), + ]); + }); + + self::assertCount(2, $user->articles()->get()); + + Event::fake(); + + switch ($id) { + case Model::class: + $id = $articles->first(); + break; + + case Collection::class: + $id = $articles; + break; + } + + self::assertSame($results, $user->articles()->detach($id)); + + self::assertCount(2 - $results, $user->articles()->get()); + + Event::assertDispatched(sprintf('eloquent.detaching: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + self::assertTrue($halt); + + return true; + }); + + Event::assertDispatched(sprintf('eloquent.detached: %s', User::class), static function ($event, $payload) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + return true; + }); + } } diff --git a/tests/Integration/BelongsToMany/SyncTest.php b/tests/Integration/BelongsToMany/SyncTest.php index 38bfa7e..6930b4f 100644 --- a/tests/Integration/BelongsToMany/SyncTest.php +++ b/tests/Integration/BelongsToMany/SyncTest.php @@ -12,127 +12,11 @@ use Illuminate\Database\Eloquent\Collection; use Illuminate\Database\Eloquent\Model; use Illuminate\Support\Collection as BaseCollection; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\DataProvider; +use PHPUnit\Framework\Attributes\Test; class SyncTest extends EventuallyTestCase { - /** - * @test - */ - public function itSuccessfullyRegistersEventListeners(): void - { - User::syncing(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('articles', $relation); - - self::assertSame([ - [ - 'user_id' => 1, - 'article_id' => 1, - ], - ], $properties); - }); - - User::synced(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('articles', $relation); - - self::assertSame([ - [ - 'user_id' => 1, - 'article_id' => 1, - ], - ], $properties); - }); - - $user = UserFactory::new()->create(); - $article = ArticleFactory::new()->create(); - - self::assertCount(0, $user->articles()->get()); - - self::assertSame([ - 'attached' => [ - 1, - ], - 'detached' => [], - 'updated' => [], - ], $user->articles()->sync($article)); - - self::assertCount(1, $user->articles()->get()); - } - - /** - * @test - */ - public function itPreventsModelsFromBeingSynced(): void - { - User::syncing(static function () { - return false; - }); - - $user = UserFactory::new()->create(); - $articles = ArticleFactory::new()->count(2)->create(); - - self::assertCount(0, $user->articles()->get()); - - self::assertFalse($user->articles()->sync($articles)); - - self::assertCount(0, $user->articles()->get()); - } - - /** - * @test - * @dataProvider syncProvider - * - * @param array $results - * @param mixed $id - * @param array $expectedPayload - */ - public function itSuccessfullySyncsModels(array $results, $id, array $expectedPayload): void - { - $user = UserFactory::new()->create(); - $articles = ArticleFactory::new()->count(2)->create(); - - self::assertCount(0, $user->articles()->get()); - - Event::fake(); - - switch ($id) { - case Model::class: - $id = $articles->first(); - break; - - case Collection::class: - $id = $articles; - break; - } - - self::assertSame($results, $user->articles()->sync($id)); - - Event::assertDispatched(sprintf('eloquent.syncing: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - self::assertTrue($halt); - - return true; - }); - - Event::assertDispatched(sprintf('eloquent.synced: %s', User::class), static function ($event, $payload) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - return true; - }); - } - /** * @return array */ @@ -374,4 +258,117 @@ class SyncTest extends EventuallyTestCase ], ]; } + + #[Test] + public function itSuccessfullyRegistersEventListeners(): void + { + User::syncing(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('articles', $relation); + + self::assertSame([ + [ + 'user_id' => 1, + 'article_id' => 1, + ], + ], $properties); + }); + + User::synced(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('articles', $relation); + + self::assertSame([ + [ + 'user_id' => 1, + 'article_id' => 1, + ], + ], $properties); + }); + + $user = UserFactory::new()->create(); + $article = ArticleFactory::new()->create(); + + self::assertCount(0, $user->articles()->get()); + + self::assertSame([ + 'attached' => [ + 1, + ], + 'detached' => [], + 'updated' => [], + ], $user->articles()->sync($article)); + + self::assertCount(1, $user->articles()->get()); + } + + #[Test] + public function itPreventsModelsFromBeingSynced(): void + { + User::syncing(static function () { + return false; + }); + + $user = UserFactory::new()->create(); + $articles = ArticleFactory::new()->count(2)->create(); + + self::assertCount(0, $user->articles()->get()); + + self::assertFalse($user->articles()->sync($articles)); + + self::assertCount(0, $user->articles()->get()); + } + + /** + * @param array $results + * @param mixed $id + * @param array $expectedPayload + */ + #[Test] + #[DataProvider('syncProvider')] + public function itSuccessfullySyncsModels(array $results, $id, array $expectedPayload): void + { + $user = UserFactory::new()->create(); + $articles = ArticleFactory::new()->count(2)->create(); + + self::assertCount(0, $user->articles()->get()); + + Event::fake(); + + switch ($id) { + case Model::class: + $id = $articles->first(); + break; + + case Collection::class: + $id = $articles; + break; + } + + self::assertSame($results, $user->articles()->sync($id)); + + Event::assertDispatched(sprintf('eloquent.syncing: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + self::assertTrue($halt); + + return true; + }); + + Event::assertDispatched(sprintf('eloquent.synced: %s', User::class), static function ($event, $payload) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + return true; + }); + } } diff --git a/tests/Integration/BelongsToMany/ToggleTest.php b/tests/Integration/BelongsToMany/ToggleTest.php index 505211e..7d99452 100644 --- a/tests/Integration/BelongsToMany/ToggleTest.php +++ b/tests/Integration/BelongsToMany/ToggleTest.php @@ -12,126 +12,11 @@ use Illuminate\Database\Eloquent\Collection; use Illuminate\Database\Eloquent\Model; use Illuminate\Support\Collection as BaseCollection; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\DataProvider; +use PHPUnit\Framework\Attributes\Test; class ToggleTest extends EventuallyTestCase { - /** - * @test - */ - public function itSuccessfullyRegistersEventListeners(): void - { - User::toggling(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('articles', $relation); - - self::assertSame([ - [ - 'user_id' => 1, - 'article_id' => 1, - ], - ], $properties); - }); - - User::toggled(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('articles', $relation); - - self::assertSame([ - [ - 'user_id' => 1, - 'article_id' => 1, - ], - ], $properties); - }); - - $user = UserFactory::new()->create(); - $article = ArticleFactory::new()->create(); - - self::assertCount(0, $user->articles()->get()); - - self::assertSame([ - 'attached' => [ - 1, - ], - 'detached' => [], - ], $user->articles()->toggle($article)); - - self::assertCount(1, $user->articles()->get()); - } - - /** - * @test - */ - public function itPreventsModelsFromBeingToggled(): void - { - User::toggling(static function () { - return false; - }); - - $user = UserFactory::new()->create(); - $articles = ArticleFactory::new()->count(2)->create(); - - self::assertCount(0, $user->articles()->get()); - - self::assertFalse($user->articles()->toggle($articles)); - - self::assertCount(0, $user->articles()->get()); - } - - /** - * @test - * @dataProvider toggleProvider - * - * @param array $results - * @param mixed $id - * @param array $expectedPayload - */ - public function itSuccessfullyTogglesModels(array $results, $id, array $expectedPayload): void - { - $user = UserFactory::new()->create(); - $articles = ArticleFactory::new()->count(2)->create(); - - self::assertCount(0, $user->articles()->get()); - - Event::fake(); - - switch ($id) { - case Model::class: - $id = $articles->first(); - break; - - case Collection::class: - $id = $articles; - break; - } - - self::assertSame($results, $user->articles()->toggle($id)); - - Event::assertDispatched(sprintf('eloquent.toggling: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - self::assertTrue($halt); - - return true; - }); - - Event::assertDispatched(sprintf('eloquent.toggled: %s', User::class), static function ($event, $payload) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - return true; - }); - } - /** * @return array */ @@ -330,4 +215,116 @@ class ToggleTest extends EventuallyTestCase ], ]; } + + #[Test] + public function itSuccessfullyRegistersEventListeners(): void + { + User::toggling(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('articles', $relation); + + self::assertSame([ + [ + 'user_id' => 1, + 'article_id' => 1, + ], + ], $properties); + }); + + User::toggled(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('articles', $relation); + + self::assertSame([ + [ + 'user_id' => 1, + 'article_id' => 1, + ], + ], $properties); + }); + + $user = UserFactory::new()->create(); + $article = ArticleFactory::new()->create(); + + self::assertCount(0, $user->articles()->get()); + + self::assertSame([ + 'attached' => [ + 1, + ], + 'detached' => [], + ], $user->articles()->toggle($article)); + + self::assertCount(1, $user->articles()->get()); + } + + #[Test] + public function itPreventsModelsFromBeingToggled(): void + { + User::toggling(static function () { + return false; + }); + + $user = UserFactory::new()->create(); + $articles = ArticleFactory::new()->count(2)->create(); + + self::assertCount(0, $user->articles()->get()); + + self::assertFalse($user->articles()->toggle($articles)); + + self::assertCount(0, $user->articles()->get()); + } + + /** + * @param array $results + * @param mixed $id + * @param array $expectedPayload + */ + #[Test] + #[DataProvider('toggleProvider')] + public function itSuccessfullyTogglesModels(array $results, $id, array $expectedPayload): void + { + $user = UserFactory::new()->create(); + $articles = ArticleFactory::new()->count(2)->create(); + + self::assertCount(0, $user->articles()->get()); + + Event::fake(); + + switch ($id) { + case Model::class: + $id = $articles->first(); + break; + + case Collection::class: + $id = $articles; + break; + } + + self::assertSame($results, $user->articles()->toggle($id)); + + Event::assertDispatched(sprintf('eloquent.toggling: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + self::assertTrue($halt); + + return true; + }); + + Event::assertDispatched(sprintf('eloquent.toggled: %s', User::class), static function ($event, $payload) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + return true; + }); + } } diff --git a/tests/Integration/BelongsToMany/UpdateExistingPivotTest.php b/tests/Integration/BelongsToMany/UpdateExistingPivotTest.php index 2050c69..76af2fa 100644 --- a/tests/Integration/BelongsToMany/UpdateExistingPivotTest.php +++ b/tests/Integration/BelongsToMany/UpdateExistingPivotTest.php @@ -13,146 +13,11 @@ use Illuminate\Database\Eloquent\Collection; use Illuminate\Database\Eloquent\Model; use Illuminate\Support\Collection as BaseCollection; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\DataProvider; +use PHPUnit\Framework\Attributes\Test; class UpdateExistingPivotTest extends EventuallyTestCase { - /** - * @test - */ - public function itSuccessfullyRegistersEventListeners(): void - { - User::updatingExistingPivot(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('articles', $relation); - - self::assertSame([ - [ - 'user_id' => 1, - 'liked' => true, - 'article_id' => 1, - ], - [ - 'user_id' => 1, - 'liked' => true, - 'article_id' => 2, - ], - ], $properties); - }); - - User::existingPivotUpdated(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('articles', $relation); - - self::assertSame([ - [ - 'user_id' => 1, - 'liked' => true, - 'article_id' => 1, - ], - [ - 'user_id' => 1, - 'liked' => true, - 'article_id' => 2, - ], - ], $properties); - }); - - $user = UserFactory::new()->create(); - - $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { - $article->users()->attach($user); - }); - - self::assertCount(2, $user->articles()->get()); - - self::assertSame(2, $user->articles()->updateExistingPivot($articles, [ - 'liked' => true, - ])); - } - - /** - * @test - */ - public function itPreventsExistingPivotFromBeingUpdated(): void - { - User::updatingExistingPivot(static function () { - return false; - }); - - $user = UserFactory::new()->create(); - - $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { - $article->users()->attach($user); - }); - - self::assertCount(2, $user->articles()->get()); - - self::assertFalse($user->articles()->updateExistingPivot($articles, [ - 'liked' => true, - ])); - - self::assertCount(2, $user->articles()->get()); - } - - /** - * @test - * @dataProvider updateExistingPivotProvider - * - * @param int $results - * @param mixed $id - * @param array $attributes - * @param array $expectedPayload - */ - public function itSuccessfullyUpdatesExistingPivot(int $results, $id, array $attributes, array $expectedPayload): void - { - $user = UserFactory::new()->create(); - - $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { - $article->users()->attach($user); - }); - - self::assertCount(2, $user->articles()->get()); - - Event::fake(); - - switch ($id) { - case Model::class: - $id = $articles->first(); - break; - - case Collection::class: - $id = $articles; - break; - } - - self::assertSame($results, $user->articles()->updateExistingPivot($id, $attributes)); - - Event::assertDispatched(sprintf('eloquent.updatingExistingPivot: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - - self::assertTrue($halt); - - return true; - }); - - Event::assertDispatched(sprintf('eloquent.existingPivotUpdated: %s', User::class), static function ($event, $payload) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - return true; - }); - } - /** * @return array */ @@ -337,4 +202,136 @@ class UpdateExistingPivotTest extends EventuallyTestCase ], ]; } + + #[Test] + public function itSuccessfullyRegistersEventListeners(): void + { + User::updatingExistingPivot(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('articles', $relation); + + self::assertSame([ + [ + 'user_id' => 1, + 'liked' => true, + 'article_id' => 1, + ], + [ + 'user_id' => 1, + 'liked' => true, + 'article_id' => 2, + ], + ], $properties); + }); + + User::existingPivotUpdated(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('articles', $relation); + + self::assertSame([ + [ + 'user_id' => 1, + 'liked' => true, + 'article_id' => 1, + ], + [ + 'user_id' => 1, + 'liked' => true, + 'article_id' => 2, + ], + ], $properties); + }); + + $user = UserFactory::new()->create(); + + $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { + $article->users()->attach($user); + }); + + self::assertCount(2, $user->articles()->get()); + + self::assertSame(2, $user->articles()->updateExistingPivot($articles, [ + 'liked' => true, + ])); + } + + #[Test] + public function itPreventsExistingPivotFromBeingUpdated(): void + { + User::updatingExistingPivot(static function () { + return false; + }); + + $user = UserFactory::new()->create(); + + $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { + $article->users()->attach($user); + }); + + self::assertCount(2, $user->articles()->get()); + + self::assertFalse($user->articles()->updateExistingPivot($articles, [ + 'liked' => true, + ])); + + self::assertCount(2, $user->articles()->get()); + } + + /** + * @param int $results + * @param mixed $id + * @param array $attributes + * @param array $expectedPayload + */ + #[Test] + #[DataProvider('updateExistingPivotProvider')] + public function itSuccessfullyUpdatesExistingPivot(int $results, $id, array $attributes, array $expectedPayload): void + { + $user = UserFactory::new()->create(); + + $articles = ArticleFactory::new()->count(2)->create()->each(static function (Article $article) use ($user): void { + $article->users()->attach($user); + }); + + self::assertCount(2, $user->articles()->get()); + + Event::fake(); + + switch ($id) { + case Model::class: + $id = $articles->first(); + break; + + case Collection::class: + $id = $articles; + break; + } + + self::assertSame($results, $user->articles()->updateExistingPivot($id, $attributes)); + + Event::assertDispatched(sprintf('eloquent.updatingExistingPivot: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + + self::assertTrue($halt); + + return true; + }); + + Event::assertDispatched(sprintf('eloquent.existingPivotUpdated: %s', User::class), static function ($event, $payload) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + return true; + }); + } } diff --git a/tests/Integration/FirePivotEventTest.php b/tests/Integration/FirePivotEventTest.php index c5acc0e..4fd1fad 100644 --- a/tests/Integration/FirePivotEventTest.php +++ b/tests/Integration/FirePivotEventTest.php @@ -10,12 +10,11 @@ use Altek\Eventually\Tests\Events\CustomEvent; use Altek\Eventually\Tests\EventuallyTestCase; use Altek\Eventually\Tests\Models\User; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\Test; class FirePivotEventTest extends EventuallyTestCase { - /** - * @test - */ + #[Test] public function itDoesNotFireEventsWhenDispatcherIsNotSet(): void { User::unsetEventDispatcher(); @@ -30,9 +29,7 @@ class FirePivotEventTest extends EventuallyTestCase self::assertCount(2, $user->articles()->get()); } - /** - * @test - */ + #[Test] public function itPreventsModelsFromBeingAttachedViaCustomEventListener(): void { $articles = ArticleFactory::new()->count(2)->create(); diff --git a/tests/Integration/MorphToMany/AttachTest.php b/tests/Integration/MorphToMany/AttachTest.php index 6aa0354..a6a08d0 100644 --- a/tests/Integration/MorphToMany/AttachTest.php +++ b/tests/Integration/MorphToMany/AttachTest.php @@ -12,139 +12,11 @@ use Illuminate\Database\Eloquent\Collection; use Illuminate\Database\Eloquent\Model; use Illuminate\Support\Collection as BaseCollection; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\DataProvider; +use PHPUnit\Framework\Attributes\Test; class AttachTest extends EventuallyTestCase { - /** - * @test - */ - public function itSuccessfullyRegistersEventListeners(): void - { - User::attaching(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('awards', $relation); - - self::assertSame([ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'prize' => 1024, - 'award_id' => 1, - ], - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'prize' => 1024, - 'award_id' => 2, - ], - ], $properties); - }); - - User::attached(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('awards', $relation); - - self::assertSame([ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'prize' => 1024, - 'award_id' => 1, - ], - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'prize' => 1024, - 'award_id' => 2, - ], - ], $properties); - }); - - $user = UserFactory::new()->create(); - $awards = AwardFactory::new()->count(2)->create(); - - self::assertCount(0, $user->awards()->get()); - - self::assertTrue($user->awards()->attach($awards, [ - 'prize' => 1024, - ])); - - self::assertCount(2, $user->awards()->get()); - } - - /** - * @test - */ - public function itPreventsModelsFromBeingAttached(): void - { - User::attaching(static function () { - return false; - }); - - $user = UserFactory::new()->create(); - $awards = AwardFactory::new()->count(2)->create(); - - self::assertCount(0, $user->awards()->get()); - - self::assertFalse($user->awards()->attach($awards)); - - self::assertCount(0, $user->awards()->get()); - } - - /** - * @test - * @dataProvider attachProvider - * - * @param mixed $id - * @param array $attributes - * @param array $expectedPayload - */ - public function itSuccessfullyAttachesModels($id, array $attributes, array $expectedPayload): void - { - $user = UserFactory::new()->create(); - $awards = AwardFactory::new()->count(2)->create(); - - self::assertCount(0, $user->awards()->get()); - - Event::fake(); - - switch ($id) { - case Model::class: - $id = $awards->first(); - break; - - case Collection::class: - $id = $awards; - break; - } - - self::assertTrue($user->awards()->attach($id, $attributes)); - - Event::assertDispatched(sprintf('eloquent.attaching: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - self::assertTrue($halt); - - return true; - }); - - Event::assertDispatched(sprintf('eloquent.attached: %s', User::class), static function ($event, $payload) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - return true; - }); - } - /** * @return array */ @@ -329,4 +201,129 @@ class AttachTest extends EventuallyTestCase ], ]; } + + #[Test] + public function itSuccessfullyRegistersEventListeners(): void + { + User::attaching(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('awards', $relation); + + self::assertSame([ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'prize' => 1024, + 'award_id' => 1, + ], + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'prize' => 1024, + 'award_id' => 2, + ], + ], $properties); + }); + + User::attached(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('awards', $relation); + + self::assertSame([ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'prize' => 1024, + 'award_id' => 1, + ], + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'prize' => 1024, + 'award_id' => 2, + ], + ], $properties); + }); + + $user = UserFactory::new()->create(); + $awards = AwardFactory::new()->count(2)->create(); + + self::assertCount(0, $user->awards()->get()); + + self::assertTrue($user->awards()->attach($awards, [ + 'prize' => 1024, + ])); + + self::assertCount(2, $user->awards()->get()); + } + + #[Test] + public function itPreventsModelsFromBeingAttached(): void + { + User::attaching(static function () { + return false; + }); + + $user = UserFactory::new()->create(); + $awards = AwardFactory::new()->count(2)->create(); + + self::assertCount(0, $user->awards()->get()); + + self::assertFalse($user->awards()->attach($awards)); + + self::assertCount(0, $user->awards()->get()); + } + + /** + * @param mixed $id + * @param array $attributes + * @param array $expectedPayload + */ + #[Test] + #[DataProvider('attachProvider')] + public function itSuccessfullyAttachesModels($id, array $attributes, array $expectedPayload): void + { + $user = UserFactory::new()->create(); + $awards = AwardFactory::new()->count(2)->create(); + + self::assertCount(0, $user->awards()->get()); + + Event::fake(); + + switch ($id) { + case Model::class: + $id = $awards->first(); + break; + + case Collection::class: + $id = $awards; + break; + } + + self::assertTrue($user->awards()->attach($id, $attributes)); + + Event::assertDispatched(sprintf('eloquent.attaching: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + self::assertTrue($halt); + + return true; + }); + + Event::assertDispatched(sprintf('eloquent.attached: %s', User::class), static function ($event, $payload) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + return true; + }); + } } diff --git a/tests/Integration/MorphToMany/DetachTest.php b/tests/Integration/MorphToMany/DetachTest.php index 37bfff6..635954a 100644 --- a/tests/Integration/MorphToMany/DetachTest.php +++ b/tests/Integration/MorphToMany/DetachTest.php @@ -13,146 +13,11 @@ use Illuminate\Database\Eloquent\Collection; use Illuminate\Database\Eloquent\Model; use Illuminate\Support\Collection as BaseCollection; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\DataProvider; +use PHPUnit\Framework\Attributes\Test; class DetachTest extends EventuallyTestCase { - /** - * @test - */ - public function itSuccessfullyRegistersEventListeners(): void - { - User::detaching(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('awards', $relation); - - self::assertSame([ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'award_id' => 1, - ], - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'award_id' => 2, - ], - ], $properties); - }); - - User::detached(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('awards', $relation); - - self::assertSame([ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'award_id' => 1, - ], - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'award_id' => 2, - ], - ], $properties); - }); - - $user = UserFactory::new()->create(); - - $awards = AwardFactory::new()->count(2)->create()->each(static function (Award $award) use ($user): void { - $award->users()->attach($user); - }); - - self::assertCount(2, $user->awards()->get()); - - self::assertSame(2, $user->awards()->detach($awards)); - - self::assertCount(0, $user->awards()->get()); - } - - /** - * @test - */ - public function itPreventsModelsFromBeingDetached(): void - { - User::detaching(static function () { - return false; - }); - - $user = UserFactory::new()->create(); - - $awards = AwardFactory::new()->count(2)->create()->each(static function (Award $award) use ($user): void { - $award->users()->attach($user); - }); - - self::assertCount(2, $user->awards()->get()); - - self::assertFalse($user->awards()->detach($awards)); - - self::assertCount(2, $user->awards()->get()); - } - - /** - * @test - * @dataProvider detachProvider - * - * @param int $results - * @param mixed $id - * @param array $expectedPayload - */ - public function itSuccessfullyDetachesModels(int $results, $id, array $expectedPayload): void - { - $user = UserFactory::new()->create(); - - $awards = AwardFactory::new()->count(2)->create()->each(static function (Award $award) use ($user): void { - $award->users()->attach($user, [ - 'prize' => 8192, - ]); - }); - - self::assertCount(2, $user->awards()->get()); - - Event::fake(); - - switch ($id) { - case Model::class: - $id = $awards->first(); - break; - - case Collection::class: - $id = $awards; - break; - } - - self::assertSame($results, $user->awards()->detach($id)); - - self::assertCount(2 - $results, $user->awards()->get()); - - Event::assertDispatched(sprintf('eloquent.detaching: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - self::assertTrue($halt); - - return true; - }); - - Event::assertDispatched(sprintf('eloquent.detached: %s', User::class), static function ($event, $payload) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - return true; - }); - } - /** * @return array */ @@ -348,4 +213,136 @@ class DetachTest extends EventuallyTestCase ], ]; } + + #[Test] + public function itSuccessfullyRegistersEventListeners(): void + { + User::detaching(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('awards', $relation); + + self::assertSame([ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'award_id' => 1, + ], + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'award_id' => 2, + ], + ], $properties); + }); + + User::detached(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('awards', $relation); + + self::assertSame([ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'award_id' => 1, + ], + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'award_id' => 2, + ], + ], $properties); + }); + + $user = UserFactory::new()->create(); + + $awards = AwardFactory::new()->count(2)->create()->each(static function (Award $award) use ($user): void { + $award->users()->attach($user); + }); + + self::assertCount(2, $user->awards()->get()); + + self::assertSame(2, $user->awards()->detach($awards)); + + self::assertCount(0, $user->awards()->get()); + } + + #[Test] + public function itPreventsModelsFromBeingDetached(): void + { + User::detaching(static function () { + return false; + }); + + $user = UserFactory::new()->create(); + + $awards = AwardFactory::new()->count(2)->create()->each(static function (Award $award) use ($user): void { + $award->users()->attach($user); + }); + + self::assertCount(2, $user->awards()->get()); + + self::assertFalse($user->awards()->detach($awards)); + + self::assertCount(2, $user->awards()->get()); + } + + /** + * @param int $results + * @param mixed $id + * @param array $expectedPayload + */ + #[Test] + #[DataProvider('detachProvider')] + public function itSuccessfullyDetachesModels(int $results, $id, array $expectedPayload): void + { + $user = UserFactory::new()->create(); + + $awards = AwardFactory::new()->count(2)->create()->each(static function (Award $award) use ($user): void { + $award->users()->attach($user, [ + 'prize' => 8192, + ]); + }); + + self::assertCount(2, $user->awards()->get()); + + Event::fake(); + + switch ($id) { + case Model::class: + $id = $awards->first(); + break; + + case Collection::class: + $id = $awards; + break; + } + + self::assertSame($results, $user->awards()->detach($id)); + + self::assertCount(2 - $results, $user->awards()->get()); + + Event::assertDispatched(sprintf('eloquent.detaching: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + self::assertTrue($halt); + + return true; + }); + + Event::assertDispatched(sprintf('eloquent.detached: %s', User::class), static function ($event, $payload) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + return true; + }); + } } diff --git a/tests/Integration/MorphToMany/SyncTest.php b/tests/Integration/MorphToMany/SyncTest.php index e9a7195..c72c9d1 100644 --- a/tests/Integration/MorphToMany/SyncTest.php +++ b/tests/Integration/MorphToMany/SyncTest.php @@ -12,129 +12,11 @@ use Illuminate\Database\Eloquent\Collection; use Illuminate\Database\Eloquent\Model; use Illuminate\Support\Collection as BaseCollection; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\DataProvider; +use PHPUnit\Framework\Attributes\Test; class SyncTest extends EventuallyTestCase { - /** - * @test - */ - public function itSuccessfullyRegistersEventListeners(): void - { - User::syncing(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('awards', $relation); - - self::assertSame([ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'award_id' => 1, - ], - ], $properties); - }); - - User::synced(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('awards', $relation); - - self::assertSame([ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'award_id' => 1, - ], - ], $properties); - }); - - $user = UserFactory::new()->create(); - $award = AwardFactory::new()->create(); - - self::assertCount(0, $user->awards()->get()); - - self::assertSame([ - 'attached' => [ - 1, - ], - 'detached' => [], - 'updated' => [], - ], $user->awards()->sync($award)); - - self::assertCount(1, $user->awards()->get()); - } - - /** - * @test - */ - public function itPreventsModelsFromBeingSynced(): void - { - User::syncing(static function () { - return false; - }); - - $user = UserFactory::new()->create(); - $awards = AwardFactory::new()->count(2)->create(); - - self::assertCount(0, $user->awards()->get()); - - self::assertFalse($user->awards()->sync($awards)); - - self::assertCount(0, $user->awards()->get()); - } - - /** - * @test - * @dataProvider syncProvider - * - * @param array $results - * @param mixed $id - * @param array $expectedPayload - */ - public function itSuccessfullySyncsModels(array $results, $id, array $expectedPayload): void - { - $user = UserFactory::new()->create(); - $awards = AwardFactory::new()->count(2)->create(); - - self::assertCount(0, $user->awards()->get()); - - Event::fake(); - - switch ($id) { - case Model::class: - $id = $awards->first(); - break; - - case Collection::class: - $id = $awards; - break; - } - - self::assertSame($results, $user->awards()->sync($id)); - - Event::assertDispatched(sprintf('eloquent.syncing: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - self::assertTrue($halt); - - return true; - }); - - Event::assertDispatched(sprintf('eloquent.synced: %s', User::class), static function ($event, $payload) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - return true; - }); - } - /** * @return array */ @@ -397,4 +279,119 @@ class SyncTest extends EventuallyTestCase ], ]; } + + #[Test] + public function itSuccessfullyRegistersEventListeners(): void + { + User::syncing(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('awards', $relation); + + self::assertSame([ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'award_id' => 1, + ], + ], $properties); + }); + + User::synced(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('awards', $relation); + + self::assertSame([ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'award_id' => 1, + ], + ], $properties); + }); + + $user = UserFactory::new()->create(); + $award = AwardFactory::new()->create(); + + self::assertCount(0, $user->awards()->get()); + + self::assertSame([ + 'attached' => [ + 1, + ], + 'detached' => [], + 'updated' => [], + ], $user->awards()->sync($award)); + + self::assertCount(1, $user->awards()->get()); + } + + #[Test] + public function itPreventsModelsFromBeingSynced(): void + { + User::syncing(static function () { + return false; + }); + + $user = UserFactory::new()->create(); + $awards = AwardFactory::new()->count(2)->create(); + + self::assertCount(0, $user->awards()->get()); + + self::assertFalse($user->awards()->sync($awards)); + + self::assertCount(0, $user->awards()->get()); + } + + /** + * @param array $results + * @param mixed $id + * @param array $expectedPayload + */ + #[Test] + #[DataProvider('syncProvider')] + public function itSuccessfullySyncsModels(array $results, $id, array $expectedPayload): void + { + $user = UserFactory::new()->create(); + $awards = AwardFactory::new()->count(2)->create(); + + self::assertCount(0, $user->awards()->get()); + + Event::fake(); + + switch ($id) { + case Model::class: + $id = $awards->first(); + break; + + case Collection::class: + $id = $awards; + break; + } + + self::assertSame($results, $user->awards()->sync($id)); + + Event::assertDispatched(sprintf('eloquent.syncing: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + self::assertTrue($halt); + + return true; + }); + + Event::assertDispatched(sprintf('eloquent.synced: %s', User::class), static function ($event, $payload) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + return true; + }); + } } diff --git a/tests/Integration/MorphToMany/ToggleTest.php b/tests/Integration/MorphToMany/ToggleTest.php index 2ba769d..381f7bb 100644 --- a/tests/Integration/MorphToMany/ToggleTest.php +++ b/tests/Integration/MorphToMany/ToggleTest.php @@ -12,128 +12,11 @@ use Illuminate\Database\Eloquent\Collection; use Illuminate\Database\Eloquent\Model; use Illuminate\Support\Collection as BaseCollection; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\DataProvider; +use PHPUnit\Framework\Attributes\Test; class ToggleTest extends EventuallyTestCase { - /** - * @test - */ - public function itSuccessfullyRegistersEventListeners(): void - { - User::toggling(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('awards', $relation); - - self::assertSame([ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'award_id' => 1, - ], - ], $properties); - }); - - User::toggled(static function ($user, $relation, $properties): void { - self::assertInstanceOf(User::class, $user); - - self::assertSame('awards', $relation); - - self::assertSame([ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'award_id' => 1, - ], - ], $properties); - }); - - $user = UserFactory::new()->create(); - $award = AwardFactory::new()->create(); - - self::assertCount(0, $user->awards()->get()); - - self::assertSame([ - 'attached' => [ - 1, - ], - 'detached' => [], - ], $user->awards()->toggle($award)); - - self::assertCount(1, $user->awards()->get()); - } - - /** - * @test - */ - public function itPreventsModelsFromBeingToggled(): void - { - User::toggling(static function () { - return false; - }); - - $user = UserFactory::new()->create(); - $awards = AwardFactory::new()->count(2)->create(); - - self::assertCount(0, $user->awards()->get()); - - self::assertFalse($user->awards()->toggle($awards)); - - self::assertCount(0, $user->awards()->get()); - } - - /** - * @test - * @dataProvider toggleProvider - * - * @param array $results - * @param mixed $id - * @param array $expectedPayload - */ - public function itSuccessfullyTogglesModels(array $results, $id, array $expectedPayload): void - { - $user = UserFactory::new()->create(); - $awards = AwardFactory::new()->count(2)->create(); - - self::assertCount(0, $user->awards()->get()); - - Event::fake(); - - switch ($id) { - case Model::class: - $id = $awards->first(); - break; - - case Collection::class: - $id = $awards; - break; - } - - self::assertSame($results, $user->awards()->toggle($id)); - - Event::assertDispatched(sprintf('eloquent.toggling: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - self::assertTrue($halt); - - return true; - }); - - Event::assertDispatched(sprintf('eloquent.toggled: %s', User::class), static function ($event, $payload) use ($expectedPayload) { - self::assertInstanceOf(User::class, $payload[0]); - - unset($payload[0]); - - self::assertSame($expectedPayload, $payload); - - return true; - }); - } - /** * @return array */ @@ -342,4 +225,118 @@ class ToggleTest extends EventuallyTestCase ], ]; } + + #[Test] + public function itSuccessfullyRegistersEventListeners(): void + { + User::toggling(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('awards', $relation); + + self::assertSame([ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'award_id' => 1, + ], + ], $properties); + }); + + User::toggled(static function ($user, $relation, $properties): void { + self::assertInstanceOf(User::class, $user); + + self::assertSame('awards', $relation); + + self::assertSame([ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'award_id' => 1, + ], + ], $properties); + }); + + $user = UserFactory::new()->create(); + $award = AwardFactory::new()->create(); + + self::assertCount(0, $user->awards()->get()); + + self::assertSame([ + 'attached' => [ + 1, + ], + 'detached' => [], + ], $user->awards()->toggle($award)); + + self::assertCount(1, $user->awards()->get()); + } + + #[Test] + public function itPreventsModelsFromBeingToggled(): void + { + User::toggling(static function () { + return false; + }); + + $user = UserFactory::new()->create(); + $awards = AwardFactory::new()->count(2)->create(); + + self::assertCount(0, $user->awards()->get()); + + self::assertFalse($user->awards()->toggle($awards)); + + self::assertCount(0, $user->awards()->get()); + } + + /** + * @param array $results + * @param mixed $id + * @param array $expectedPayload + */ + #[Test] + #[DataProvider('toggleProvider')] + public function itSuccessfullyTogglesModels(array $results, $id, array $expectedPayload): void + { + $user = UserFactory::new()->create(); + $awards = AwardFactory::new()->count(2)->create(); + + self::assertCount(0, $user->awards()->get()); + + Event::fake(); + + switch ($id) { + case Model::class: + $id = $awards->first(); + break; + + case Collection::class: + $id = $awards; + break; + } + + self::assertSame($results, $user->awards()->toggle($id)); + + Event::assertDispatched(sprintf('eloquent.toggling: %s', User::class), static function ($event, $payload, $halt) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + self::assertTrue($halt); + + return true; + }); + + Event::assertDispatched(sprintf('eloquent.toggled: %s', User::class), static function ($event, $payload) use ($expectedPayload) { + self::assertInstanceOf(User::class, $payload[0]); + + unset($payload[0]); + + self::assertSame($expectedPayload, $payload); + + return true; + }); + } } diff --git a/tests/Integration/MorphToMany/UpdateExistingPivotTest.php b/tests/Integration/MorphToMany/UpdateExistingPivotTest.php index a4edb4a..3dcc8b0 100644 --- a/tests/Integration/MorphToMany/UpdateExistingPivotTest.php +++ b/tests/Integration/MorphToMany/UpdateExistingPivotTest.php @@ -12,12 +12,135 @@ use Altek\Eventually\Tests\Models\User; use Illuminate\Database\Eloquent\Collection; use Illuminate\Database\Eloquent\Model; use Illuminate\Support\Facades\Event; +use PHPUnit\Framework\Attributes\DataProvider; +use PHPUnit\Framework\Attributes\Test; class UpdateExistingPivotTest extends EventuallyTestCase { /** - * @test + * @return array */ + public static function updateExistingPivotProvider(): array + { + return [ + [ + // Results + 1, + + // Id + 1, + + // Attributes + [ + 'prize' => 128, + ], + + // Expected payload + [ + 1 => 'awards', + 2 => [ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'prize' => 128, + 'award_id' => 1, + ], + ], + ], + ], + + [ + // Results + 1, + + // Id + [ + 2, + ], + + // Attributes + [ + 'prize' => 1024, + ], + + // Expected payload + [ + 1 => 'awards', + 2 => [ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'prize' => 1024, + 'award_id' => 2, + ], + ], + ], + ], + + [ + // Results + 2, + + // Id + [ + 2, + 1, + ], + + // Attributes + [ + 'prize' => 32768, + ], + + // Expected payload + [ + 1 => 'awards', + 2 => [ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'prize' => 32768, + 'award_id' => 2, + ], + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'prize' => 32768, + 'award_id' => 1, + ], + ], + ], + ], + + [ + // Results + 1, + + // Id + Model::class, + + // Attributes + [ + 'prize' => 16384, + ], + + // Expected payload + [ + 1 => 'awards', + 2 => [ + [ + 'awardable_id' => 1, + 'awardable_type' => User::class, + 'prize' => 16384, + 'award_id' => 1, + ], + ], + ], + ], + ]; + } + + #[Test] public function itSuccessfullyRegistersEventListeners(): void { User::updatingExistingPivot(static function ($user, $relation, $properties): void { @@ -75,9 +198,7 @@ class UpdateExistingPivotTest extends EventuallyTestCase ])); } - /** - * @test - */ + #[Test] public function itPreventsExistingPivotFromBeingUpdated(): void { User::updatingExistingPivot(static function () { @@ -100,14 +221,13 @@ class UpdateExistingPivotTest extends EventuallyTestCase } /** - * @test - * @dataProvider updateExistingPivotProvider - * * @param int $results * @param mixed $id * @param array $attributes * @param array $expectedPayload */ + #[Test] + #[DataProvider('updateExistingPivotProvider')] public function itSuccessfullyUpdatesExistingPivot(int $results, $id, array $attributes, array $expectedPayload): void { $user = UserFactory::new()->create(); @@ -154,127 +274,4 @@ class UpdateExistingPivotTest extends EventuallyTestCase return true; }); } - - /** - * @return array - */ - public static function updateExistingPivotProvider(): array - { - return [ - [ - // Results - 1, - - // Id - 1, - - // Attributes - [ - 'prize' => 128, - ], - - // Expected payload - [ - 1 => 'awards', - 2 => [ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'prize' => 128, - 'award_id' => 1, - ], - ], - ], - ], - - [ - // Results - 1, - - // Id - [ - 2, - ], - - // Attributes - [ - 'prize' => 1024, - ], - - // Expected payload - [ - 1 => 'awards', - 2 => [ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'prize' => 1024, - 'award_id' => 2, - ], - ], - ], - ], - - [ - // Results - 2, - - // Id - [ - 2, - 1, - ], - - // Attributes - [ - 'prize' => 32768, - ], - - // Expected payload - [ - 1 => 'awards', - 2 => [ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'prize' => 32768, - 'award_id' => 2, - ], - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'prize' => 32768, - 'award_id' => 1, - ], - ], - ], - ], - - [ - // Results - 1, - - // Id - Model::class, - - // Attributes - [ - 'prize' => 16384, - ], - - // Expected payload - [ - 1 => 'awards', - 2 => [ - [ - 'awardable_id' => 1, - 'awardable_type' => User::class, - 'prize' => 16384, - 'award_id' => 1, - ], - ], - ], - ], - ]; - } } diff --git a/tests/Unit/HasEventsTest.php b/tests/Unit/HasEventsTest.php index 1868d53..44da366 100644 --- a/tests/Unit/HasEventsTest.php +++ b/tests/Unit/HasEventsTest.php @@ -6,12 +6,11 @@ namespace Altek\Eventually\Tests\Unit; use Altek\Eventually\Tests\EventuallyTestCase; use Altek\Eventually\Tests\Models\User; +use PHPUnit\Framework\Attributes\Test; class HasEventsTest extends EventuallyTestCase { - /** - * @test - */ + #[Test] public function itAssuresThePivotEventsAreObservable(): void { $user = new User(); -- GitLab From 44199566cfc64836906ce4ec9cab11f860be9303 Mon Sep 17 00:00:00 2001 From: Julien Arcin Date: Wed, 20 Mar 2024 18:15:44 +0700 Subject: [PATCH 3/3] Remove tests on php7.4 + php8.0 --- .gitlab-ci.yml | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 2acddfd..94d4dd8 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -31,21 +31,6 @@ variables: - php vendor/bin/phpunit --coverage-text --coverage-clover clover.xml --testdox - bash <(curl -s https://codecov.io/bash) -test:7.4: - variables: - XDEBUG_VERSION: 3.1.6 - - image: php:7.4 - <<: *test_definition - -test:8.0: - variables: - XDEBUG_VERSION: 3.3.1 - PHP_CS_FIXER_IGNORE_ENV: 1 - - image: php:8.0 - <<: *test_definition - test:8.1: variables: XDEBUG_VERSION: 3.3.1 -- GitLab