Merge remote-tracking branch 'origin/test-assertions' into test-asser…

…tions

# Conflicts:
#	src/LaravelConsoleValidatorServiceProvider.php

src/LaravelConsoleValidatorServiceProvider.php

@@ -2,7 +2,6 @@
 
 declare(strict_types=1);
 
-
 namespace PerryvanderMeer\LaravelConsoleValidator;
 
 use Illuminate\Support\ServiceProvider;

tests/TestCase.php

@@ -1,18 +1,18 @@
-<?php
-
-declare(strict_types=1);
-
-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,
-        ];
-    }
-}
+<?php
+
+declare(strict_types=1);
+
+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,
+        ];
+    }
+}

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'));

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'")

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'")

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();

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')

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',

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',

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()],

tests/Unit/Testing/AddAssertionsTest.php

@@ -4,11 +4,12 @@
 
 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::registerCommand(new FakeCommandWithRule);
 
     artisan(FakeCommandWithRule::class, ['foo' => 'foo-bop'])
         ->assertSuccessful();

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();

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.')

tests/Unit/ValidatesArguments/ValidatorMessagesTest.php

@@ -11,7 +11,7 @@
 
 test('that the validator returns custom messages for a whole argument', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithRulesAndMessages());
+    Artisan::registerCommand(new FakeCommandWithRulesAndMessages);
 
     artisan(FakeCommandWithRulesAndMessages::class, ['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz'])
         ->expectsOutput('Whoo general message for foo argument..!')
@@ -23,7 +23,7 @@
 
 test('that the validator returns custom messages for a specific rule', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithRulesAndMessages());
+    Artisan::registerCommand(new FakeCommandWithRulesAndMessages);
 
     artisan(FakeCommandWithRulesAndMessages::class, ['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz'])
         ->expectsOutput('Hmm the bar argument is very short..!')
@@ -35,7 +35,7 @@
 
 test('that the validator returns default messages ', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithRulesAndMessages());
+    Artisan::registerCommand(new FakeCommandWithRulesAndMessages);
 
     artisan(FakeCommandWithRulesAndMessages::class, ['foo' => 'foo', 'bar' => 'bar', 'baz' => 'baz'])
         ->expectsOutput('The baz field must be at least 6 characters.')
@@ -48,7 +48,7 @@
 {
     config()->set('app.locale', 'nl');
 
-    Artisan::registerCommand(new FakeCommandWithRulesAndMessages());
+    Artisan::registerCommand(new FakeCommandWithRulesAndMessages);
 
     Lang::addLines(
         lines: [

tests/Unit/ValidatesArguments/ValidatorRulesTest.php

@@ -12,7 +12,7 @@
 
 test('that the validator validates a single argument', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithRule());
+    Artisan::registerCommand(new FakeCommandWithRule);
 
     artisan(FakeCommandWithRule::class, ['foo' => 'foo'])
         ->expectsOutput('The foo field must be at least 4 characters.')
@@ -34,7 +34,7 @@
 
 test('that the validator validates multiple arguments', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithRules());
+    Artisan::registerCommand(new FakeCommandWithRules);
 
     artisan(FakeCommandWithRules::class, ['foo' => 'foo', 'bar' => 'bar'])
         ->expectsOutput('The foo field must be at least 4 characters.')
@@ -62,7 +62,7 @@
 
 test('that the validator performs the argument preparation before validating the arguments', function () : void
 {
-    Artisan::registerCommand(new FakeCommandWithRulesAndArgumentPreparation());
+    Artisan::registerCommand(new FakeCommandWithRulesAndArgumentPreparation);
 
     artisan(FakeCommandWithRulesAndArgumentPreparation::class, ['foo' => 'foo', 'bar' => 'bar'])
         ->expectsOutput('The foo field must be at least 7 characters.')