Add support for assertFailedWithValidationError() (#1)

PerryvanderMeer · web-flow · commit 69125aaf5b89 · 2024-08-07T14:48:12.000+02:00
diff --git a/README.md b/README.md
diff --git a/composer.json b/composer.json
@@ -51,6 +51,13 @@
             "pestphp/pest-plugin": true
         }
     },
+    "extra": {
+        "laravel": {
+            "providers": [
+                "PerryvanderMeer\\LaravelConsoleValidator\\LaravelConsoleValidatorServiceProvider"
+            ]
+        }
+    },
     "minimum-stability": "dev",
     "prefer-stable": true
 }
diff --git a/src/LaravelConsoleValidatorServiceProvider.php b/src/LaravelConsoleValidatorServiceProvider.php
@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PerryvanderMeer\LaravelConsoleValidator;
+
+use Illuminate\Support\ServiceProvider;
+use Illuminate\Testing\PendingCommand;
+use PerryvanderMeer\LaravelConsoleValidator\Testing\PendingCommandMixin;
+
+final class LaravelConsoleValidatorServiceProvider extends ServiceProvider
+{
+    /**
+     * Bootstrap any application services.
+     */
+    public function boot() : void
+    {
+        // Mixin with PendingCommand is only available
+        // from laravel/framework version 11.9.0...
+        if (method_exists(PendingCommand::class, 'mixin'))
+        {
+            PendingCommand::mixin(new PendingCommandMixin);
+        }
+    }
+}
diff --git a/src/Testing/PendingCommandMixin.php b/src/Testing/PendingCommandMixin.php
@@ -0,0 +1,26 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PerryvanderMeer\LaravelConsoleValidator\Testing;
+
+use Closure;
+use Symfony\Component\Console\Command\Command;
+
+/** @mixin \Illuminate\Testing\PendingCommand */
+final class PendingCommandMixin
+{
+    /**
+     * Assert that the current command fails with a validation error.
+     */
+    public function assertFailedWithValidationError() : Closure
+    {
+        return function () : self
+        {
+            $this->assertExitCode(Command::INVALID)
+                ->assertFailed();
+
+            return $this;
+        };
+    }
+}
diff --git a/tests/TestCase.php b/tests/TestCase.php
@@ -5,7 +5,14 @@
 namespace PerryvanderMeer\LaravelConsoleValidator\Tests;
 
 use Orchestra\Testbench\TestCase as Orchestra;
+use PerryvanderMeer\LaravelConsoleValidator\LaravelConsoleValidatorServiceProvider;
 
 class TestCase extends Orchestra
 {
+    protected function getPackageProviders($app) : array
+    {
+        return [
+            LaravelConsoleValidatorServiceProvider::class,
+        ];
+    }
 }
diff --git a/tests/TestCommands/CanGetValidatedArguments/FakeCommandToCastASingleValidatedArgumentAsBool.php b/tests/TestCommands/CanGetValidatedArguments/FakeCommandToCastASingleValidatedArgumentAsBool.php
@@ -35,7 +35,7 @@ public function handle() : int
     {
         if ($this->bool('foo') !== $this->boolean('foo'))
         {
-            throw new LogicException();
+            throw new LogicException;
         }
 
         $type = gettype($this->bool('foo'));
diff --git a/tests/Unit/CanGetValidatedArguments/CommandCanCastValidatedArguments.php b/tests/Unit/CanGetValidatedArguments/CommandCanCastValidatedArguments.php
@@ -10,7 +10,7 @@
 
 test('that the command can cast a validated argument as string', function () : void
 {
-    Artisan::registerCommand(new FakeCommandToCastASingleValidatedArgumentAsString());
+    Artisan::registerCommand(new FakeCommandToCastASingleValidatedArgumentAsString);
 
     artisan(FakeCommandToCastASingleValidatedArgumentAsString::class, ['foo' => null])
         ->expectsOutput("Type: 'string'")
@@ -35,7 +35,7 @@
 
 test('that the command can cast a validated argument as boolean', function () : void
 {
-    Artisan::registerCommand(new FakeCommandToCastASingleValidatedArgumentAsBool());
+    Artisan::registerCommand(new FakeCommandToCastASingleValidatedArgumentAsBool);
 
     artisan(FakeCommandToCastASingleValidatedArgumentAsBool::class, ['foo' => null])
         ->expectsOutput("Type: 'boolean'")
diff --git a/tests/Unit/CanGetValidatedArguments/CommandCanGetValidatedArguments.php b/tests/Unit/CanGetValidatedArguments/CommandCanGetValidatedArguments.php
@@ -13,7 +13,7 @@
 
 test('that the command can get a single validated argument', function () : void
 {
-    Artisan::registerCommand(new FakeCommandToGetASingleValidatedArgument());
+    Artisan::registerCommand(new FakeCommandToGetASingleValidatedArgument);
 
     artisan(FakeCommandToGetASingleValidatedArgument::class, ['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz'])
         ->expectsOutput("Foo: 'foo'")
@@ -23,7 +23,7 @@
 
 test('that the command can get a validated nullable argument', function () : void
 {
-    Artisan::registerCommand(new FakeCommandToGetASingleValidatedArgument());
+    Artisan::registerCommand(new FakeCommandToGetASingleValidatedArgument);
 
     artisan(FakeCommandToGetASingleValidatedArgument::class, ['foo' => 'foo', 'bar' => null, 'baz' => 'baz'])
         ->expectsOutput("Foo: 'foo'")
@@ -36,15 +36,15 @@
     $this->expectException(UnvalidatedArgumentException::class);
     $this->expectExceptionMessage('The requested argument [foo] is not validated.');
 
-    Artisan::registerCommand(new FakeCommandToGetAnUnvalidatedArgument());
+    Artisan::registerCommand(new FakeCommandToGetAnUnvalidatedArgument);
 
     artisan(FakeCommandToGetAnUnvalidatedArgument::class, ['foo' => 'foo'])
         ->assertSuccessful();
 });
 
 test('that the command can get all validated argument', function () : void
 {
-    Artisan::registerCommand(new FakeCommandToGetAllValidatedArguments());
+    Artisan::registerCommand(new FakeCommandToGetAllValidatedArguments);
 
     artisan(FakeCommandToGetAllValidatedArguments::class, ['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz'])
         ->expectsOutput('{"foo":"foo","bar":"bar"}')
@@ -53,7 +53,7 @@
 
 test('that the command can collect all validated argument', function () : void
 {
-    Artisan::registerCommand(new FakeCommandToCollectAllValidatedArguments());
+    Artisan::registerCommand(new FakeCommandToCollectAllValidatedArguments);
 
     artisan(FakeCommandToCollectAllValidatedArguments::class, ['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz'])
         ->expectsOutput("Type: 'Illuminate\Support\Collection'")
diff --git a/tests/Unit/FakeCommandTest.php b/tests/Unit/FakeCommandTest.php
@@ -10,15 +10,15 @@
 
 test('that a normal command is working', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithoutValidator());
+    Artisan::registerCommand(new FakeCommandWithoutValidator);
 
     artisan(FakeCommandWithoutValidator::class)
         ->assertSuccessful();
 });
 
 test('that a command with the validator is working', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithValidator());
+    Artisan::registerCommand(new FakeCommandWithValidator);
 
     artisan(FakeCommandWithValidator::class)
         ->assertSuccessful();
diff --git a/tests/Unit/PrepareArgumentsForValidation/PrepareArgumentsForValidationTest.php b/tests/Unit/PrepareArgumentsForValidation/PrepareArgumentsForValidationTest.php
@@ -10,7 +10,7 @@
 
 test('that the validator prepares the argument for validation', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithArgumentPreparation());
+    Artisan::registerCommand(new FakeCommandWithArgumentPreparation);
 
     artisan(FakeCommandWithArgumentPreparation::class, ['foo' => 'foo'])
         ->expectsOutput('foo-bar')
@@ -21,7 +21,7 @@
 
 test('that the validator prepares the arguments for validation', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithArgumentsPreparation());
+    Artisan::registerCommand(new FakeCommandWithArgumentsPreparation);
 
     artisan(FakeCommandWithArgumentsPreparation::class, ['foo' => 'foo', 'bar' => 'bar'])
         ->expectsOutput('foo-bar')
diff --git a/tests/Unit/ResolveValidationLogic/RegisterValidatorAttributesTest.php b/tests/Unit/ResolveValidationLogic/RegisterValidatorAttributesTest.php
@@ -11,12 +11,12 @@
 
 test('that the validator registers attributes from the attributes property', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithAttributesProperty());
+    Artisan::registerCommand(new FakeCommandWithAttributesProperty);
 
     artisan(FakeCommandWithAttributesProperty::class)
         ->assertSuccessful();
 
-    expect((new FakeCommandWithAttributesProperty())->getExtractedValidationAttributesForCommand())
+    expect((new FakeCommandWithAttributesProperty)->getExtractedValidationAttributesForCommand())
         ->toBeArray()
         ->toBe([
             'foo' => 'bar',
@@ -26,12 +26,12 @@
 
 test('that the validator registers attributes from the attributes method', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithAttributesMethod());
+    Artisan::registerCommand(new FakeCommandWithAttributesMethod);
 
     artisan(FakeCommandWithAttributesMethod::class)
         ->assertSuccessful();
 
-    expect((new FakeCommandWithAttributesMethod())->getExtractedValidationAttributesForCommand())
+    expect((new FakeCommandWithAttributesMethod)->getExtractedValidationAttributesForCommand())
         ->toBeArray()
         ->toEqual([
             'baz' => 'bax',
@@ -41,12 +41,12 @@
 
 test('that the validator registers attributes from the both the attributes property and the attributes method', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithAttributesPropertyAndMethod());
+    Artisan::registerCommand(new FakeCommandWithAttributesPropertyAndMethod);
 
     artisan(FakeCommandWithAttributesPropertyAndMethod::class)
         ->assertSuccessful();
 
-    expect((new FakeCommandWithAttributesPropertyAndMethod())->getExtractedValidationAttributesForCommand())
+    expect((new FakeCommandWithAttributesPropertyAndMethod)->getExtractedValidationAttributesForCommand())
         ->toBeArray()
         ->toEqual([
             'foo' => 'bar',
diff --git a/tests/Unit/ResolveValidationLogic/RegisterValidatorMessagesTest.php b/tests/Unit/ResolveValidationLogic/RegisterValidatorMessagesTest.php
@@ -11,12 +11,12 @@
 
 test('that the validator registers messages from the messages property', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithMessagesProperty());
+    Artisan::registerCommand(new FakeCommandWithMessagesProperty);
 
     artisan(FakeCommandWithMessagesProperty::class)
         ->assertSuccessful();
 
-    expect((new FakeCommandWithMessagesProperty())->getExtractedValidationMessagesForCommand())
+    expect((new FakeCommandWithMessagesProperty)->getExtractedValidationMessagesForCommand())
         ->toBeArray()
         ->toBe([
             'foo' => 'bar',
@@ -26,12 +26,12 @@
 
 test('that the validator registers messages from the messages method', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithMessagesMethod());
+    Artisan::registerCommand(new FakeCommandWithMessagesMethod);
 
     artisan(FakeCommandWithMessagesMethod::class)
         ->assertSuccessful();
 
-    expect((new FakeCommandWithMessagesMethod())->getExtractedValidationMessagesForCommand())
+    expect((new FakeCommandWithMessagesMethod)->getExtractedValidationMessagesForCommand())
         ->toBeArray()
         ->toEqual([
             'baz' => 'bax',
@@ -41,12 +41,12 @@
 
 test('that the validator registers messages from the both the messages property and the messages method', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithMessagesPropertyAndMethod());
+    Artisan::registerCommand(new FakeCommandWithMessagesPropertyAndMethod);
 
     artisan(FakeCommandWithMessagesPropertyAndMethod::class)
         ->assertSuccessful();
 
-    expect((new FakeCommandWithMessagesPropertyAndMethod())->getExtractedValidationMessagesForCommand())
+    expect((new FakeCommandWithMessagesPropertyAndMethod)->getExtractedValidationMessagesForCommand())
         ->toBeArray()
         ->toEqual([
             'foo' => 'bar',
diff --git a/tests/Unit/ResolveValidationLogic/RegisterValidatorRulesTest.php b/tests/Unit/ResolveValidationLogic/RegisterValidatorRulesTest.php
@@ -12,12 +12,12 @@
 
 test('that the validator registers rules from the rules property', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithRulesProperty());
+    Artisan::registerCommand(new FakeCommandWithRulesProperty);
 
     artisan(FakeCommandWithRulesProperty::class)
         ->assertSuccessful();
 
-    expect((new FakeCommandWithRulesProperty())->getExtractedValidationRulesForCommand())
+    expect((new FakeCommandWithRulesProperty)->getExtractedValidationRulesForCommand())
         ->toBeArray()
         ->toBe([
             'foo' => ['bar'],
@@ -28,12 +28,12 @@
 
 test('that the validator registers rules from the rules method', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithRulesMethod());
+    Artisan::registerCommand(new FakeCommandWithRulesMethod);
 
     artisan(FakeCommandWithRulesMethod::class)
         ->assertSuccessful();
 
-    expect((new FakeCommandWithRulesMethod())->getExtractedValidationRulesForCommand())
+    expect((new FakeCommandWithRulesMethod)->getExtractedValidationRulesForCommand())
         ->toBeArray()
         ->toEqual([
             'foo' => [Rule::file()],
@@ -44,12 +44,12 @@
 
 test('that the validator registers rules from the both the rules property and the rules method', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithRulesPropertyAndMethod());
+    Artisan::registerCommand(new FakeCommandWithRulesPropertyAndMethod);
 
     artisan(FakeCommandWithRulesPropertyAndMethod::class)
         ->assertSuccessful();
 
-    expect((new FakeCommandWithRulesPropertyAndMethod())->getExtractedValidationRulesForCommand())
+    expect((new FakeCommandWithRulesPropertyAndMethod)->getExtractedValidationRulesForCommand())
         ->toBeArray()
         ->toEqual([
             'foo' => ['bar', Rule::file()],
diff --git a/tests/Unit/Testing/AddAssertionsTest.php b/tests/Unit/Testing/AddAssertionsTest.php
@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+use Illuminate\Support\Facades\Artisan;
+use PerryvanderMeer\LaravelConsoleValidator\Tests\TestCommands\ValidatesArguments\FakeCommandWithRule;
+
+use function Pest\Laravel\artisan;
+
+test('that the assertFailedWithValidationError() assertion works', function () : void
+{
+    Artisan::registerCommand(new FakeCommandWithRule);
+
+    artisan(FakeCommandWithRule::class, ['foo' => 'foo-bop'])
+        ->assertSuccessful();
+
+    artisan(FakeCommandWithRule::class, ['foo' => 'foo'])
+        ->assertFailedWithValidationError();
+})->skip(
+    fn () : bool => version_compare(app()->version(), '11.9.0', '<'),
+    'Mixin with PendingCommand is only available from 11.9.0',
+);
diff --git a/tests/Unit/ValidatesArguments/HandleMethodShouldNotBeCalledTest.php b/tests/Unit/ValidatesArguments/HandleMethodShouldNotBeCalledTest.php
@@ -13,7 +13,7 @@
 {
     Session::shouldReceive('put')->never();
 
-    Artisan::registerCommand(new FakeCommandToTestHandleMethod());
+    Artisan::registerCommand(new FakeCommandToTestHandleMethod);
 
     artisan(FakeCommandToTestHandleMethod::class, ['foo' => 'foo'])
         ->assertExitCode(Command::INVALID)
@@ -24,7 +24,7 @@
 {
     Session::shouldReceive('put')->once();
 
-    Artisan::registerCommand(new FakeCommandToTestHandleMethod());
+    Artisan::registerCommand(new FakeCommandToTestHandleMethod);
 
     artisan(FakeCommandToTestHandleMethod::class, ['foo' => 'foo-bar'])
         ->assertSuccessful();
diff --git a/tests/Unit/ValidatesArguments/ValidatorAttributesTest.php b/tests/Unit/ValidatesArguments/ValidatorAttributesTest.php
@@ -10,7 +10,7 @@
 
 test('that the validator supports custom attributes for an argument', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithRulesAndAttributes());
+    Artisan::registerCommand(new FakeCommandWithRulesAndAttributes);
 
     artisan(FakeCommandWithRulesAndAttributes::class, ['foo' => 'foo', 'bar' => 'bar'])
         ->expectsOutput('The first field must be at least 4 characters.')
diff --git a/tests/Unit/ValidatesArguments/ValidatorMessagesTest.php b/tests/Unit/ValidatesArguments/ValidatorMessagesTest.php
diff --git a/tests/Unit/ValidatesArguments/ValidatorRulesTest.php b/tests/Unit/ValidatesArguments/ValidatorRulesTest.php

Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,13 @@`
`51`	`51`	`"pestphp/pest-plugin": true`
`52`	`52`	`}`
`53`	`53`	`},`
	`54`	`+ "extra": {`
	`55`	`+ "laravel": {`
	`56`	`+ "providers": [`
	`57`	`+ "PerryvanderMeer\\LaravelConsoleValidator\\LaravelConsoleValidatorServiceProvider"`
	`58`	`+ ]`
	`59`	`+ }`
	`60`	`+ },`
`54`	`61`	`"minimum-stability": "dev",`
`55`	`62`	`"prefer-stable": true`
`56`	`63`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,14 @@`
`5`	`5`	`namespace PerryvanderMeer\LaravelConsoleValidator\Tests;`
`6`	`6`
`7`	`7`	`use Orchestra\Testbench\TestCase as Orchestra;`
	`8`	`+use PerryvanderMeer\LaravelConsoleValidator\LaravelConsoleValidatorServiceProvider;`
`8`	`9`
`9`	`10`	`class TestCase extends Orchestra`
`10`	`11`	`{`
	`12`	`+ protected function getPackageProviders($app) : array`
	`13`	`+ {`
	`14`	`+ return [`
	`15`	`+ LaravelConsoleValidatorServiceProvider::class,`
	`16`	`+ ];`
	`17`	`+ }`
`11`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public function handle() : int`
`35`	`35`	`{`
`36`	`36`	`if ($this->bool('foo') !== $this->boolean('foo'))`
`37`	`37`	`{`
`38`		`- throw new LogicException();`
	`38`	`+ throw new LogicException;`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`$type = gettype($this->bool('foo'));`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`
`11`	`11`	`test('that the command can cast a validated argument as string', function () : void`
`12`	`12`	`{`
`13`		`- Artisan::registerCommand(new FakeCommandToCastASingleValidatedArgumentAsString());`
	`13`	`+ Artisan::registerCommand(new FakeCommandToCastASingleValidatedArgumentAsString);`
`14`	`14`
`15`	`15`	`artisan(FakeCommandToCastASingleValidatedArgumentAsString::class, ['foo' => null])`
`16`	`16`	`->expectsOutput("Type: 'string'")`
`@@ -35,7 +35,7 @@`
`35`	`35`
`36`	`36`	`test('that the command can cast a validated argument as boolean', function () : void`
`37`	`37`	`{`
`38`		`- Artisan::registerCommand(new FakeCommandToCastASingleValidatedArgumentAsBool());`
	`38`	`+ Artisan::registerCommand(new FakeCommandToCastASingleValidatedArgumentAsBool);`
`39`	`39`
`40`	`40`	`artisan(FakeCommandToCastASingleValidatedArgumentAsBool::class, ['foo' => null])`
`41`	`41`	`->expectsOutput("Type: 'boolean'")`
Original file line number	Diff line number	Diff line change
`@@ -10,15 +10,15 @@`
`10`	`10`
`11`	`11`	`test('that a normal command is working', function () : void`
`12`	`12`	`{`
`13`		`- Artisan::registerCommand(new FakeCommandWithoutValidator());`
	`13`	`+ Artisan::registerCommand(new FakeCommandWithoutValidator);`
`14`	`14`
`15`	`15`	`artisan(FakeCommandWithoutValidator::class)`
`16`	`16`	`->assertSuccessful();`
`17`	`17`	`});`
`18`	`18`
`19`	`19`	`test('that a command with the validator is working', function () : void`
`20`	`20`	`{`
`21`		`- Artisan::registerCommand(new FakeCommandWithValidator());`
	`21`	`+ Artisan::registerCommand(new FakeCommandWithValidator);`
`22`	`22`
`23`	`23`	`artisan(FakeCommandWithValidator::class)`
`24`	`24`	`->assertSuccessful();`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@`
`13`	`13`	`{`
`14`	`14`	`Session::shouldReceive('put')->never();`
`15`	`15`
`16`		`- Artisan::registerCommand(new FakeCommandToTestHandleMethod());`
	`16`	`+ Artisan::registerCommand(new FakeCommandToTestHandleMethod);`
`17`	`17`
`18`	`18`	`artisan(FakeCommandToTestHandleMethod::class, ['foo' => 'foo'])`
`19`	`19`	`->assertExitCode(Command::INVALID)`
`@@ -24,7 +24,7 @@`
`24`	`24`	`{`
`25`	`25`	`Session::shouldReceive('put')->once();`
`26`	`26`
`27`		`- Artisan::registerCommand(new FakeCommandToTestHandleMethod());`
	`27`	`+ Artisan::registerCommand(new FakeCommandToTestHandleMethod);`
`28`	`28`
`29`	`29`	`artisan(FakeCommandToTestHandleMethod::class, ['foo' => 'foo-bar'])`
`30`	`30`	`->assertSuccessful();`