DomainValidatorTest::testSimpleErrorMessage() - Code Metrics - Inspection of "Fixes for Code Climate." - dmitry-kulikov/yii2-domain-validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( a4b7b7...e08bee )

by Dmitry
created 2021-10-23 05:47 UTC
DomainValidatorTest::testSimpleErrorMessage() A

↳ Parent: DomainValidatorTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	6
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	4
c	0
b	0
f	0
nc	1
nop	0
dl	0
loc	6
rs	10
<?php

namespace kdn\yii2\validators;

use kdn\yii2\validators\mocks\ModelMock;
use stdClass;
use Yii;
use yii\base\InvalidConfigException;

/**
 * Class DomainValidatorTest.
 * @package kdn\yii2\validators
 * @covers \kdn\yii2\validators\DomainValidator::init
 */
class DomainValidatorTest extends TestCase
{
    const NONEXISTENT_DOMAIN = 'nonexistent-subdomain.example.com';

    /**
     * @var DomainValidator
     */
    protected $validator;

    /**
     * @before
     */
    protected function prepare()
    {
        parent::prepare();
        $this->validator = new DomainValidator(['labelNumberMin' => 1]);
    }

    public static function validDomainProvider()
    {
        return [
            'one domain name label' => ['localhost'],
            'two domain name labels' => ['example.com'],
            'domain name with trailing dot' => ['example.com.'],
            '127 levels, 253 characters and trailing dot' => [
                'a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.' .
                'a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.' .
                'a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.' .
                'a.a.a.a.',
            ],
            'domain name labels with 63 characters' => [
                'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.' .
                'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.' .
                'example.com',
            ],
            'domain name with various symbols' => ['1.a-B.c2'],
            'Punycode, mixed domain name' => ['xn--e1afmkfd.test.xn--80akhbyknj4f'],
        ];
    }

    public static function validDomainInUrlProvider()
    {
        return [
            'HTTP, one domain name label' => ['http://localhost'],
            'HTTP, two domain name labels' => ['http://example.com/index.html'],
            'FTP, domain name with trailing dot' => ['ftp://example.com./img/dir/'],
            'HTTPS, 127 levels, 253 characters and trailing dot' => [
                'https://a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.' .
                'a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.' .
                'a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.' .
                'a.a.a.a./index.html',
            ],
            'missing scheme, domain name labels with 63 characters' => [
                '//aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.' .
                'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.' .
                'example.com',
            ],
            'complex URL, domain name with various symbols' => [
                'http://username:[email protected]:9090/path?a=b&c=d#anchor',
            ],
            'Punycode, FTP, mixed domain name' => ['ftp://xn--e1afmkfd.test.xn--80akhbyknj4f/img/dir/'],
        ];
    }

    public static function validDomainIdnProvider()
    {
        return [
            'IDN, one domain name label' => ['пример'],
            'IDN, two domain name labels' => ['пример.испытание'],
            'IDN, domain name with trailing dot' => ['пример.испытание.'],
            'IDN, mixed domain name' => ['пример.test.испытание'],
            'IDN, 34 levels, 253 characters (ф. == xn--t1a.) and trailing dot' => [
                'ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.s.s.s.',
            ],
            'IDN, domain name labels with 63 characters' => [
                'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                'испытание',
            ],
            'IDN, domain name with various symbols' => ['1.a-B.cф2'],
            'IDN, hot beverage' => ['☕.us'],
            'IDN, full-width characters' => ['日本語。ＪＰ'],
            'IDN, box-drawing character' => ['ex╬ample.com'],
        ];
    }

    public static function validDomainIdnInUrlProvider()
    {
        return [
            'IDN, HTTP, one domain name label' => ['http://пример'],
            'IDN, HTTP, two domain name labels' => ['http://пример.испытание/index.html'],
            'IDN, FTP, domain name with trailing dot' => ['ftp://пример.испытание./img/dir/'],
            'IDN, FTP, mixed domain name' => ['ftp://пример.test.испытание/img/dir/'],
            'IDN, HTTPS, 34 levels, 253 characters (ф. == xn--t1a.) and trailing dot' => [
                'https://ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.s.s.s./index.html',
            ],
            'IDN, missing scheme, domain name labels with 63 characters' => [
                '//ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                'испытание',
            ],
            'IDN, complex URL, domain name with various symbols' => [
                'http://username:[email protected]ф2:9090/path?a=ф&c=d#-пример',
            ],
            'IDN, HTTP, hot beverage' => ['http://☕.us/index.html'],
            'IDN, HTTP, full-width characters' => ['http://日本語。ＪＰ/index.html'],
            'IDN, HTTP, box-drawing character' => ['http://ex╬ample.com/index.html'],
        ];
    }

    public static function validDomainAllWithoutIdnProvider()
    {
        return array_merge(
            static::validDomainProvider(),
            static::validDomainInUrlProvider()
        );
    }

    public static function validDomainAllOnlyIdnProvider()
    {
        return array_merge(
            static::validDomainIdnProvider(),
            static::validDomainIdnInUrlProvider()
        );
    }

    public static function validDomainAllProvider()
    {
        return array_merge(
            static::validDomainProvider(),
            static::validDomainInUrlProvider(),
            static::validDomainIdnProvider(),
            static::validDomainIdnInUrlProvider()
        );
    }

    /**
     * @param string $value
     * @covers       \kdn\yii2\validators\DomainValidator::validateValue
     * @dataProvider validDomainAllWithoutIdnProvider
     * @small
     */
    public function testValidDomain($value)
    {
        $this->assertTrue($this->validator->validate($value));
    }

    /**
     * @param string $value
     * @covers       \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers       \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers       \kdn\yii2\validators\DomainValidator::validateValue
     * @dataProvider validDomainAllOnlyIdnProvider
     * @small
     */
    public function testInvalidDomainWithDisabledIdn($value)
    {
        $this->assertFalse($this->validator->validate($value, $errorMessage));
        $this->assertEquals(
            'Each label of the input value can consist of only latin letters, numbers and hyphens.',
            $errorMessage
        );
    }

    /**
     * @param string $value
     * @covers       \kdn\yii2\validators\DomainValidator::validateValue
     * @dataProvider validDomainAllProvider
     * @small
     */
    public function testValidDomainWithEnabledIdn($value)
    {
        if (!function_exists('idn_to_ascii')) {
            $this->markTestSkipped('intl extension required.');
            return;
        }

        $this->validator->enableIDN = true;
        $this->testValidDomain($value);
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::checkDNS
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @large
     */
    public function testDns()
    {
        $validator = $this->validator;
        $nonexistentDomain = static::NONEXISTENT_DOMAIN;
        $this->assertTrue($validator->validate($nonexistentDomain));
        $validator->checkDNS = true;
        $this->assertFalse($validator->validate($nonexistentDomain, $errorMessage));
        $this->assertEquals('DNS record corresponding to the input value not found.', $errorMessage);

        $data = [
            'google.com',
            'http://username:[email protected]:9090/path?a=b&c=d#anchor',
        ];
        foreach ($data as $value) {
            $this->assertTrue(
                $validator->validate($value),
                "Failed to validate \"$value\" (checkDNS = true)."
            );
        }
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @large
     */
    public function testDnsCallable()
    {
        $validator = $this->validator;
        $nonexistentDomain = static::NONEXISTENT_DOMAIN;
        $this->assertTrue($validator->validate($nonexistentDomain));
        $customErrorMessage = 'test';
        $validator->checkDNS = function ($value) use ($nonexistentDomain, $customErrorMessage) {
            $records = @dns_get_record("$value.", DNS_MX); // @ is just for simplicity of test, avoid using it
            if (empty($records)) {
                $this->assertEquals($nonexistentDomain, $value);

                return [$customErrorMessage, []];
            }

            return null;
        };
        $this->assertFalse($validator->validate($nonexistentDomain, $errorMessage));
        $this->assertEquals($customErrorMessage, $errorMessage);

        $data = [
            'gmail.com',
            'http://username:[email protected]:9090/path?a=b&c=d#anchor',
        ];
        foreach ($data as $value) {
            $this->assertTrue(
                $validator->validate($value),
                "Failed to validate \"$value\" (checkDNS is callable)."
            );
        }
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::checkDNS
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @large
     */
    public function testDnsWithEnabledIdn()
    {
        if (!function_exists('idn_to_ascii')) {
            $this->markTestSkipped('intl extension required.');
            return;
        }

        $validator = $this->validator;
        $validator->checkDNS = true;
        // enabling of IDN should not affect error message
        $validator->enableIDN = true;
        $this->assertFalse($validator->validate(static::NONEXISTENT_DOMAIN, $errorMessage));
        $this->assertEquals('DNS record corresponding to the input value not found.', $errorMessage);

        $data = [
            'google.com',
            'http://username:[email protected]:9090/path?a=b&c=d#anchor',
            'яндекс.рф',
            'http://username:password@яндекс.рф:9090/path?a=ф&c=d#-пример',
        ];
        foreach ($data as $value) {
            $this->assertTrue(
                $validator->validate($value),
                "Failed to validate \"$value\" (checkDNS = true, enableIDN = true)."
            );
        }
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @small
     */
    public function testUnderscore()
    {
        $validator = $this->validator;
        $validator->allowUnderscore = true;

        $data = [
            'ex_ample.com',
            'http://username:password@ex_ample.com:9090/path?a=b&c=d#anchor',
        ];
        foreach ($data as $value) {
            $this->assertTrue(
                $validator->validate($value),
                "Failed to validate \"$value\" (allowUnderscore = true)."
            );
        }

        $this->assertFalse($validator->validate('a_@_a', $errorMessage));
        if ($validator->enableIDN) {
            $expectedErrorMessage =
                'Each label of the input value can consist of only letters, numbers, hyphens and underscores.';
        } else {
            $expectedErrorMessage =
                'Each label of the input value can consist of only latin letters, numbers, hyphens and underscores.';
        }
        $this->assertEquals($expectedErrorMessage, $errorMessage);
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @small
     */
    public function testUnderscoreWithEnabledIdn()
    {
        if (!function_exists('idn_to_ascii')) {
            $this->markTestSkipped('intl extension required.');
            return;
        }

        $this->validator->enableIDN = true;
        $this->testUnderscore();
    }

    public static function urlNotAllowedProvider()
    {
        return array_merge(
            static::arrayAddColumn(static::validDomainProvider(), true),
            static::arrayAddColumn(static::validDomainInUrlProvider(), false)
        );
    }

    /**
     * @param string $value
     * @param bool $expectedResult
     * @covers       \kdn\yii2\validators\DomainValidator::validateValue
     * @uses         \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @uses         \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @dataProvider urlNotAllowedProvider
     * @small
     */
    public function testUrlNotAllowed($value, $expectedResult)
    {
        $validator = $this->validator;
        $validator->allowURL = false;
        $this->assertEquals($expectedResult, $validator->validate($value));
    }

    public static function urlNotAllowedProviderWithEnabledIdn()
    {
        return array_merge(
            static::urlNotAllowedProvider(),
            static::arrayAddColumn(static::validDomainIdnProvider(), true),
            static::arrayAddColumn(static::validDomainIdnInUrlProvider(), false)
        );
    }

    /**
     * @param string $value
     * @param bool $expectedResult
     * @covers       \kdn\yii2\validators\DomainValidator::validateValue
     * @uses         \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @uses         \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @dataProvider urlNotAllowedProviderWithEnabledIdn
     * @small
     */
    public function testUrlNotAllowedWithEnabledIdn($value, $expectedResult)
    {
        if (!function_exists('idn_to_ascii')) {
            $this->markTestSkipped('intl extension required.');
            return;
        }

        $this->validator->enableIDN = true;
        $this->testUrlNotAllowed($value, $expectedResult);
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @small
     */
    public function testLabelNumberMin()
    {
        $validator = $this->validator;
        $validator->labelNumberMin = 2;
        $this->assertFalse($validator->validate('localhost', $errorMessage));
        $this->assertEquals('the input value should consist of at least 2 labels separated by dot.', $errorMessage);
        $this->assertTrue($validator->validate('example.com'));
        $this->assertTrue($validator->validate('test.example.com'));
        $validator->labelNumberMin = 3;
        $this->assertFalse($validator->validate('example.com', $errorMessage));
        $this->assertEquals('the input value should consist of at least 3 labels separated by dots.', $errorMessage);
        $this->assertTrue($validator->validate('test.example.com'));
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @small
     */
    public function testLabelNumberMinWithEnabledIdn()
    {
        if (!function_exists('idn_to_ascii')) {
            $this->markTestSkipped('intl extension required.');
            return;
        }

        $this->validator->enableIDN = true;
        $this->testLabelNumberMin();
    }

    public static function invalidDomainProvider($testName)
    {
        if ($testName == 'testInvalidDomain') {
            $messageInvalidCharacter =
                'Each label of the input value can consist of only latin letters, numbers and hyphens.';
            $messageLabelStartEnd = 'Each label of the input value should start and end with latin letter or number.' .
                ' The rightmost label of the input value should start with latin letter.';
            $messageLabelTooLong = 'Each label of the input value should contain at most 63 characters.';
            $messageTooLong = 'the input value should contain at most 253 characters.';
        } else {
            $messageInvalidCharacter =
                'Each label of the input value can consist of only letters, numbers and hyphens.';
            $messageLabelStartEnd = 'Each label of the input value should start and end with letter or number.' .
                ' The rightmost label of the input value should start with letter.';
            $messageLabelTooLong = 'Label of the input value is too long.';
            $messageTooLong = 'the input value is too long.';
        }
        $messageLabelTooShort = 'Each label of the input value should contain at least 1 character.';
        $messageNotString = 'the input value must be a string.';
        $messageTooShort = 'the input value should contain at least 1 character.';
        return [
            'null' => [null, $messageNotString],
            'boolean' => [true, $messageNotString],
            'integer' => [1, $messageNotString],
            'float' => [1.2, $messageNotString],
            'array' => [[], $messageNotString],
            'object' => [new stdClass(), $messageNotString],

            'domain name too long' => [str_repeat('a.', 126) . 'aa', $messageTooLong],

            'domain name too short' => ['', $messageTooShort],

            'first domain name label starts with hyphen' => ['-example.com', $messageLabelStartEnd],
            'first domain name label ends with hyphen' => ['example-.com', $messageLabelStartEnd],
            'last domain name label starts with hyphen' => ['example.-com', $messageLabelStartEnd],
            'last domain name label ends with hyphen' => ['example.com-', $messageLabelStartEnd],

            'IDN, first domain name label starts with hyphen' => ['-пример.испытание', $messageInvalidCharacter],
            'IDN, first domain name label ends with hyphen' => ['пример-.испытание', $messageInvalidCharacter],
            'IDN, last domain name label starts with hyphen' => ['пример.-испытание', $messageInvalidCharacter],
            'IDN, last domain name label ends with hyphen' => ['пример.испытание-', $messageInvalidCharacter],

            'IDN, HTTP, first domain name label starts with hyphen' => [
                'http://-пример.испытание/index.html',
                $messageInvalidCharacter,
            ],
            'IDN, HTTP, first domain name label ends with hyphen' => [
                'http://пример-.испытание/index.html',
                $messageInvalidCharacter,
            ],
            'IDN, HTTP, last domain name label starts with hyphen' => [
                'http://пример.-испытание/index.html',
                $messageInvalidCharacter,
            ],
            'IDN, HTTP, last domain name label ends with hyphen' => [
                'http://пример.испытание-/index.html',
                $messageInvalidCharacter,
            ],

            'last domain name label starts with number' => ['example.4om', $messageLabelStartEnd],

            'domain name label too long' => [str_repeat('a', 64), $messageLabelTooLong],

            'dot' => ['.', $messageLabelTooShort],
            'domain name starts with dot' => ['.example.com', $messageLabelTooShort],
            'domain name ends with two dots' => ['example.com..', $messageLabelTooShort],
            'domain name contains two dots in a row' => ['example..com', $messageLabelTooShort],

            'domain name contains underscore' => ['ex_ample.com', $messageInvalidCharacter],
            'domain name contains space' => ['ex ample.com', $messageInvalidCharacter],
            'domain name contains disallowed character' => ['a⒈com', $messageInvalidCharacter],

            'IDN, domain name too long' => [
                'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.',
                $messageInvalidCharacter,
            ],
            'IDN, domain name label too long' => [
                'фффффффффффффффффффффффффффффффффффффффффффффффффффффффффs',
                $messageInvalidCharacter,
            ],

            'invalid url with valid domain name' => ['http//example.com/index.html', $messageInvalidCharacter],
            'IDN, invalid url with valid domain name' => ['http//пример.com/index.html', $messageInvalidCharacter],
        ];
    }

    /**
     * @param string $value
     * @param string $expectedErrorMessage
     * @covers       \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers       \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers       \kdn\yii2\validators\DomainValidator::validateValue
     * @dataProvider invalidDomainProvider
     * @small
     */
    public function testInvalidDomain($value, $expectedErrorMessage)
    {
        $this->assertFalse($this->validator->validate($value, $errorMessage));
        $this->assertEquals($expectedErrorMessage, $errorMessage);
    }

    public static function invalidDomainWithEnabledIdnProvider()
    {
        $message = 'the input value is invalid.';
        $messageLabelStartEnd = 'Each label of the input value should start and end with letter or number.' .
            ' The rightmost label of the input value should start with letter.';
        $messageLabelTooLong = 'Label of the input value is too long.';
        $messageTooLong = 'the input value is too long.';
        return array_merge(
            static::invalidDomainProvider('testInvalidDomainWithEnabledIdn'),
            [
                'IDN, domain name too long, numerous labels' => [
                    'ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.ф.s.s.s.s',
                    $messageTooLong,
                ],
                'IDN, domain name too long, long labels' => [
                    'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                    'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                    'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                    'фффффффффффффффффффффффффффффффффффффффффффффффффффффффф.',
                    $messageTooLong,
                ],

                'IDN, first domain name label starts with hyphen' => ['-пример.испытание', $messageLabelStartEnd],
                'IDN, first domain name label ends with hyphen' => ['пример-.испытание', $messageLabelStartEnd],
                'IDN, last domain name label starts with hyphen' => ['пример.-испытание', $messageLabelStartEnd],
                'IDN, last domain name label ends with hyphen' => ['пример.испытание-', $messageLabelStartEnd],

                'IDN, HTTP, first domain name label starts with hyphen' => [
                    'http://-пример.испытание/index.html',
                    $messageLabelStartEnd,
                ],
                'IDN, HTTP, first domain name label ends with hyphen' => [
                    'http://пример-.испытание/index.html',
                    $messageLabelStartEnd,
                ],
                'IDN, HTTP, last domain name label starts with hyphen' => [
                    'http://пример.-испытание/index.html',
                    $messageLabelStartEnd,
                ],
                'IDN, HTTP, last domain name label ends with hyphen' => [
                    'http://пример.испытание-/index.html',
                    $messageLabelStartEnd,
                ],

                'IDN, domain name too long' => [
                    'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                    'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                    'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.' .
                    'ффффффффффффффффффффффффффффффффффффффффффффффффффффффффф.',
                    $messageTooLong,
                ],
                'IDN, domain name label too long' => [
                    'фффффффффффффффффффффффффффффффффффффффффффффффффффффффффs',
                    $messageLabelTooLong,
                ],

                'IDN, IDNA_ERROR_HYPHEN_3_4' => ['aa--a', $message],
                'IDN, IDNA_ERROR_LEADING_COMBINING_MARK' => [static::u('\u0308c'), $message],
                'IDN, IDNA_ERROR_PUNYCODE' => ['xn--0', $message],
                'IDN, IDNA_ERROR_INVALID_ACE_LABEL' => ['xn--a', $message],
                'IDN, IDNA_ERROR_BIDI' => [static::u('0A.\u05D0'), $message],
            ]
        );
    }

    /**
     * @param string $value
     * @param string $expectedErrorMessage
     * @covers       \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers       \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers       \kdn\yii2\validators\DomainValidator::validateValue
     * @dataProvider invalidDomainWithEnabledIdnProvider
     * @small
     */
    public function testInvalidDomainWithEnabledIdn($value, $expectedErrorMessage)
    {
        if (!function_exists('idn_to_ascii')) {
            $this->markTestSkipped('intl extension required.');
            return;
        }

        $this->validator->enableIDN = true;
        $this->testInvalidDomain($value, $expectedErrorMessage);
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @small
     */
    public function testCustomErrorMessage()
    {
        $validator = $this->validator;
        $messageNotString = 'test';
        $validator->messageNotString = $messageNotString;
        $this->assertFalse($validator->validate(null, $errorMessage));
        $this->assertEquals($messageNotString, $errorMessage);
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @small
     */
    public function testSimpleErrorMessage()
    {
        $validator = $this->validator;
        $validator->simpleErrorMessage = true;
        $this->assertFalse($validator->validate('-', $errorMessage));
        $this->assertEquals('the input value is invalid.', $errorMessage);
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @small
     */
    public function testValidateAttribute()
    {
        $model = new ModelMock(['domain' => 'example']);
        $validator = $this->validator;

        $validator->validateAttribute($model, 'domain');
        $this->assertFalse($model->hasErrors('domain'));

        $validator->labelNumberMin = 2;
        $validator->validateAttribute($model, 'domain');
        $this->assertTrue($model->hasErrors('domain'));
    }

    /**
     * @covers \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @small
     */
    public function testValidateAttributeAndI18n()
    {
        if (!function_exists('idn_to_ascii')) {
            $this->markTestSkipped('intl extension required.');
            return;
        }

        Yii::$app->language = 'ru-RU';
        $model = new ModelMock(['domain' => 'example']);
        $validator = $this->validator;

        $validator->validateAttribute($model, 'domain');
        $this->assertFalse($model->hasErrors('domain'));

        $validator->labelNumberMin = 2;
        $validator->validateAttribute($model, 'domain');
        $this->assertTrue($model->hasErrors('domain'));
        $this->assertEquals(
            'Значение «Доменное имя» должно состоять минимум из 2 меток, разделённых точкой.',
            $model->getFirstError('domain')
        );

        $model->clearErrors('domain');

        $validator->labelNumberMin = 21;
        $validator->validateAttribute($model, 'domain');
        $this->assertTrue($model->hasErrors('domain'));
        $this->assertEquals(
            'Значение «Доменное имя» должно состоять минимум из 21 метки, разделённых точками.',
            $model->getFirstError('domain')
        );
    }

    /**
     * IMPORTANT: this test should be executed after others, because it can remove function "idn_to_ascii".
     * @covers \kdn\yii2\validators\DomainValidator::init
     * @small
     */
    public function testInitIdnIntlException()
    {
        $runkitFunctionName = null;
        if (ini_get('runkit.internal_override')) {
            if (function_exists('runkit7_function_remove')) {
                $runkitFunctionName = 'runkit7_function_remove';
            } elseif (function_exists('runkit_function_remove')) {
                $runkitFunctionName = 'runkit_function_remove';
            }
        }

        if ($runkitFunctionName === null) {
            $this->markTestSkipped('runkit extension required. runkit.internal_override should be set to "On".');
            return;
        }

        $runkitFunctionName('idn_to_ascii');

        $expectedException = new InvalidConfigException(
            'In order to use IDN validation intl extension must be installed and enabled.'
        );
        $actualException = null;
        try {
            new DomainValidator(['enableIDN' => true]);
        } catch (InvalidConfigException $e) {
            $actualException = $e;
        }
        $this->assertEquals($expectedException, $actualException);
    }

    /**
     * IMPORTANT: this test should be executed after others, because it can replace function "dns_get_record".
     * @covers \kdn\yii2\validators\DomainValidator::checkDNS
     * @covers \kdn\yii2\validators\DomainValidator::getDefaultErrorMessages
     * @covers \kdn\yii2\validators\DomainValidator::getErrorMessage
     * @covers \kdn\yii2\validators\DomainValidator::validateValue
     * @small
     */
    public function testDnsWarning()
    {
        $runkitFunctionName = null;
        if (ini_get('runkit.internal_override')) {
            if (function_exists('runkit7_function_redefine')) {
                $runkitFunctionName = 'runkit7_function_redefine';
            } elseif (function_exists('runkit_function_redefine')) {
                $runkitFunctionName = 'runkit_function_redefine';
            }
        }

        if ($runkitFunctionName === null) {
            $this->markTestSkipped('runkit extension required. runkit.internal_override should be set to "On".');
            return;
        }

        // redefine dns_get_record to emit PHP Warning, which will be converted by Yii to yii\base\ErrorException
        if (!$runkitFunctionName('dns_get_record', '', 'trigger_error("Warning", E_USER_WARNING);')) {
            $this->markTestSkipped('Cannot redefine function "dns_get_record".');
            return;
        }

        $validator = $this->validator;
        $validator->checkDNS = true;
        $this->assertFalse($validator->validate('google.com', $errorMessage));
        $this->assertEquals('DNS record corresponding to the input value not found.', $errorMessage);
    }
}

dmitry-kulikov / yii2-domain-validator

Push — master ( a4b7b7...e08bee )

DomainValidatorTest::testSimpleErrorMessage() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
