Telkins\Validation\Tests\FieldRuleSetTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	1

10 Methods

Rating	Name	Duplication	Size	Complexity
A	it_returns_the_expected_validation_message()	0	9	1
A	it_will_return_false_for_invalid_values()	0	3	1
A	it_can_use_a_rule_set_except_certain_rules()	0	7	1
A	getError()	0	3	1
A	it_returns_the_expected_validation_message_when_cannot_confirm_with_confirmed_and_request_data()	0	13	1
A	providesInvalidValues()	0	15	1
A	it_plays_nice_with_separate_confirmed_and_no_request_data()	0	15	1
A	it_will_return_true_for_valid_values()	0	3	1
A	it_returns_the_expected_validation_message_when_cannot_confirm_with_separate_confirmed_and_no_request_data()	0	18	1
A	it_plays_nice_with_confirmed_and_request_data()	0	8	1

<?php

namespace Telkins\Validation\Tests;

use Illuminate\Support\Facades\Validator;
use Telkins\Validation\Tests\TestRuleSets\NewEmailRuleSet;
use Telkins\Validation\Tests\TestRuleSets\NewConfirmedEmailRuleSet;

class FieldRuleSetTest extends TestCase
{
    protected function getError($key, $attribute, $extra = []) : string
    {
        return __($key, array_merge(['attribute' => str_replace('_', ' ', $attribute)], $extra));

The expression return __($key, array_merge(array('attribute' => str_replace('_', ' ', $attribute)), $extra)) could return the type array|null which is incompatible with the type-hinted return string. Consider adding an additional type-check to rule them out.

    }

    /**
     * @test
     */
    public function it_will_return_true_for_valid_values()
    {
        $this->assertTrue((new NewEmailRuleSet())->passes('attribute', 'me@mydomain.com'));
    }

    /**
     * @test
     */
    public function it_will_return_false_for_invalid_values()
    {
        $this->assertFalse((new NewEmailRuleSet())->passes('attribute', 'not.an.email'));
    }

    /**
     * @test
     * @dataProvider providesInvalidValues
     */
    public function it_returns_the_expected_validation_message($value, $errorKey, $extra = [])
    {
        $attribute = 'email_address';

        $rule = new NewEmailRuleSet();

        $rule->passes($attribute, $value);

        $this->assertEquals($this->getError($errorKey, $attribute, $extra), $rule->message());
    }

    /**
     * @test
     */
    public function it_can_use_a_rule_set_except_certain_rules()
    {
        $attribute = 'email_address';

        $rule = (new NewEmailRuleSet)->except('required', 'email');

        $this->assertTrue($rule->passes($attribute, null));
    }

    public function providesInvalidValues()
    {
        return [
            [
                null,
                'validation.required',
            ],
            [
                'not.an.email',
                'validation.email',
            ],
            [
                'this.email.address.is.a.bit.too.long@mydomain.com',
                'validation.max.string',
                ['max' => 25],
            ],
        ];
    }

    /**
     * @test
     */
    public function it_plays_nice_with_confirmed_and_request_data()
    {
        $requestData = [
            'email_address' => 'me@mydomain.com',
            'email_address_confirmation' => 'me@mydomain.com',
        ];

        $this->assertTrue((new NewConfirmedEmailRuleSet($requestData))->passes('email_address', 'me@mydomain.com'));
    }

    /**
     * @test
     */
    public function it_plays_nice_with_separate_confirmed_and_no_request_data()
    {
        $requestData = [
            'email_address' => 'me@mydomain.com',
            'email_address_confirmation' => 'me@mydomain.com',
        ];

        $validator = Validator::make($requestData, [
            'email_address' => [
                new NewEmailRuleSet(),
                'confirmed',
            ],
        ]);

        $this->assertTrue($validator->passes());
    }

    /**
     * @test
     */
    public function it_returns_the_expected_validation_message_when_cannot_confirm_with_confirmed_and_request_data()
    {
        $attribute = 'email_address';

        $requestData = [
            $attribute => 'me@mydomain.com',
            // NO CONFIRMATION...!
        ];

        $rule = new NewConfirmedEmailRuleSet($requestData);

        $this->assertFalse($rule->passes($attribute, 'me@mydomain.com'));
        $this->assertEquals($this->getError('validation.confirmed', $attribute), $rule->message());
    }

    /**
     * @test
     */
    public function it_returns_the_expected_validation_message_when_cannot_confirm_with_separate_confirmed_and_no_request_data()
    {
        $attribute = 'email_address';

        $validator = Validator::make(
            [
                $attribute => 'me@mydomain.com',
                // NO CONFIRMATION...!
            ], [
                $attribute => [
                    new NewEmailRuleSet(),
                    'confirmed',
                ],
            ]
        );

        $this->assertFalse($validator->passes());
        $this->assertEquals($this->getError('validation.confirmed', $attribute), $validator->errors()->first());
    }
}