[8.x] Cannot test with fake emails when using Email Validation rules.

[DarkGhostHunter]

• Laravel Version: 8.61.0
• PHP Version: 8.0.5
• Database Driver & Version: MySQL 8.26

Description:

There is no way to fake an email on testing when dealing with a route validating email with RFC, DNS, or a custom one. Since the rule cannot be bypassed instead of mocked or faked (just for the email), any test fails, unless the whole validation system is faked in an additional test case.

Steps To Reproduce:

1. Create any test with this code.

use Illuminate/Support/Facades/Route;

public function test_bad()
{
    Route::post('test', function (Request $request): string {
        $request->validate(['email' => 'email:dns,rfc']);

        return 'ok';
    });

    $this->post('test', ['email' => '[email protected]'])->assertOk();
}

The is no way to allow to bypass email validation, leaving these alternatives:

1. Faking the validation entirely on a separate test.
2. Enabling validation for that rule separately using app()->environment('testing') conditionally.

Possible solutions.

1. Allow the container to resolve the EmailValidator instance so it can be faked/mocked.
2. Create a fakeRules() helper for the Validator to allow bypassing certain keys, or certain rule keys.

[driesvints]

This is a feature request so I'm moving it to discussions. Also please note that you can't perform two HTTP calls in a single test as that's not a real-life scenario.

[JustinByrne]

Assuming you are creating this test in a standard test file you should have the following at the top of the file.

use Illuminate\Foundation\Testing\WithFaker;

If you do then you can then use the freeEmail() method from FakerPHP. For example:

use Illuminate\Support\Facades\Route;
use Illuminate\Foundation\Testing\WithFaker;

public function test_bad()
{
    Route::post('test', function (Request $request): string {
        $request->validate(['email' => 'email:dns,rfc']);

        return 'ok';
    });

    $this->post('test', ['email' => $this->faker->freeEmail()])->assertOk();
}

This will create a fake email with a genuine email domain allowing for the test to pass.

[mariomka]

It would be good to have a way to mock the DNS check to avoid making requests in the tests.

[Livijn]

Yeah, I would also like the opportunity to mock the DNS check in testing. The only way I know how to mock it is by creating a custom rule that implements basically the same logic as the one below but in tests, just mock the calls.

framework/src/Illuminate/Validation/Concerns/ValidatesAttributes.php

Lines 851 to 882 in 73f5e1b

	/**
	* Validate that an attribute is a valid e-mail address.
	*
	* @param string $attribute
	* @param mixed $value
	* @param array<int, int|string> $parameters
	* @return bool
	*/
	public function validateEmail($attribute, $value, $parameters)
	{
	if (! is_string($value) && ! (is_object($value) && method_exists($value, '__toString'))) {
	return false;
	}
	$validations = collect($parameters)
	->unique()
	->map(fn ($validation) => match (true) {
	$validation === 'strict' => new NoRFCWarningsValidation(),
	$validation === 'dns' => new DNSCheckValidation(),
	$validation === 'spoof' => new SpoofCheckValidation(),
	$validation === 'filter' => new FilterEmailValidation(),
	$validation === 'filter_unicode' => FilterEmailValidation::unicode(),
	is_string($validation) && class_exists($validation) => $this->container->make($validation),
	default => new RFCValidation(),
	})
	->values()
	->all() ?: [new RFCValidation];
	$emailValidator = Container::getInstance()->make(EmailValidator::class);
	return $emailValidator->isValid($value, new MultipleValidationWithAnd($validations));
	}

I thought I would be able to mock the DNS by doing this, but the mock wasn't used by the DNSCheckValidation:

        $this->mock(DNSGetRecordWrapper::class, function (MockInterface $mock) {
            $mock->shouldIgnoreMissing();
        });

[carlobeltrame]

I was able to solve this as follows:
In the validation rule, we can not only pass the nice short 'dns' string, but we can also pass the name of a class. Then, the class is not instantiated via new, but via the app container instead, and therefore is mockable.

So, in my request, I have the following:

    public function rules() {
        return [
            'email' => 'required|email:strict,Egulias\EmailValidator\Validation\DNSCheckValidation',
        ];
    }

In my unit tests (only the ones that trigger the validation), I completely mock the DNS validation by doing the following:

    public function setUp(): void {
        parent::setUp();

        $this->app->bind(DNSCheckValidation::class, TestDNSCheckValidation::class);
    }

class TestDNSCheckValidation extends DNSCheckValidation {
    /**
     * In this test, we want the DNS validation to fail for fail.com domains, and pass for all others.
     */
    public function isValid(string $email, EmailLexer $emailLexer): bool {
        return !str_ends_with($email, 'fail.com');
    }
}

This way, my tests are happy even when I have no internet connection.