Completed
Push — master ( ae5e03...0447ee )
by Jeroen
10:35 queued 04:37
created

Constraints/PasswordRestrictionsValidatorTest.php (1 issue)

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

1
<?php
2
3
namespace Kunstmaan\AdminBundle\Tests\Validator\Constraints;
4
5
use Kunstmaan\AdminBundle\Validator\Constraints\PasswordRestrictions;
6
use Kunstmaan\AdminBundle\Validator\Constraints\PasswordRestrictionsValidator;
7
use Symfony\Component\Validator\Test\ConstraintValidatorTestCase;
8
9
/**
10
 * Class PasswordRestrictionsValidatorTest
11
 *
12
 * Unit test for the password restrictions validator, will test with different sets of parameters
13
 * for the validator is possible.
14
 */
15
class PasswordRestrictionsValidatorTest extends ConstraintValidatorTestCase
16
{
17
    const PARAMETER_MIN_LENGTH = 8;
18
    const PARAMETER_MAX_LENGTH = 16;
19
    const PARAMETER_MIN_DIGITS = 3;
20
    const PARAMETER_MIN_UPPERCASE = 2;
21
    const PARAMETER_MIN_SPECIAL_CHARACTERS = 1;
22
23
    /**
24
     * @return PasswordRestrictionsValidator
25
     */
26
    protected function createValidator()
27
    {
28
        return new PasswordRestrictionsValidator(self::PARAMETER_MIN_DIGITS, self::PARAMETER_MIN_UPPERCASE, self::PARAMETER_MIN_SPECIAL_CHARACTERS, self::PARAMETER_MIN_LENGTH, self::PARAMETER_MAX_LENGTH);
29
    }
30
31
    /**
32
     * Set a validator with a limited number of parameters to overrule the default one from createValidator.
33
     *
34
     * @param int $minDigits
35
     * @param int $minUppercase
36
     * @param int $minSpecialCharacters
37
     * @param int $minLength
38
     * @param int $maxLength
39
     */
40
    protected function setValidator($minDigits, $minUppercase, $minSpecialCharacters, $minLength, $maxLength)
41
    {
42
        $this->validator = new PasswordRestrictionsValidator($minDigits, $minUppercase, $minSpecialCharacters, $minLength, $maxLength);
43
        $this->validator->initialize($this->context);
44
    }
45
46
    /**
47
     * @param string      $password
48
     * @param string|null $message
49
     * @param array       $parameters
50
     * @param null        $code
51
     *
52
     * @dataProvider dataPasswordsWithAllParameters
53
     */
54
    public function testPasswordWithAllParametersSet($password, $message = null, array $parameters = [], $code = null)
55
    {
56
        $this->buildAndTestPasswordRestrictions($password, $message, $parameters, $code);
57
    }
58
59
    /**
60
     * @param string      $password
61
     * @param string|null $message
62
     * @param array       $parameters
63
     * @param null        $code
64
     *
65
     * @dataProvider dataPasswordsToShort
66
     */
67
    public function testPasswordToShortOnlySet($password, $message = null, array $parameters = [], $code = null)
68
    {
69
        $this->setValidator(null, null, null, self::PARAMETER_MIN_LENGTH, null);
70
        $this->buildAndTestPasswordRestrictions($password, $message, $parameters, $code);
71
    }
72
73
    /**
74
     * @param string      $password
75
     * @param string|null $message
76
     * @param array       $parameters
77
     * @param null        $code
78
     *
79
     * @dataProvider dataPasswordsToLong
80
     */
81
    public function testPasswordToLongOnlySet($password, $message = null, array $parameters = [], $code = null)
82
    {
83
        $this->setValidator(null, null, null, null, self::PARAMETER_MAX_LENGTH);
84
        $this->buildAndTestPasswordRestrictions($password, $message, $parameters, $code);
85
    }
86
87
    /**
88
     * @param string      $password
89
     * @param string|null $message
90
     * @param array       $parameters
91
     * @param null        $code
92
     *
93
     * @dataProvider dataPasswordsMinimumDigits
94
     */
95
    public function testPasswordMinimumDigitsOnlySet($password, $message = null, array $parameters = [], $code = null)
96
    {
97
        $this->setValidator(self::PARAMETER_MIN_DIGITS, null, null, null, null);
98
        $this->buildAndTestPasswordRestrictions($password, $message, $parameters, $code);
99
    }
100
101
    /**
102
     * @param string      $password
103
     * @param string|null $message
104
     * @param array       $parameters
105
     * @param null        $code
106
     *
107
     * @dataProvider dataPasswordsMinimumUppercase
108
     */
109
    public function testPasswordMinimumUppercaseOnlySet($password, $message = null, array $parameters = [], $code = null)
110
    {
111
        $this->setValidator(null, self::PARAMETER_MIN_UPPERCASE, null, null, null);
112
        $this->buildAndTestPasswordRestrictions($password, $message, $parameters, $code);
113
    }
114
115
    /**
116
     * @param string      $password
117
     * @param string|null $message
118
     * @param array       $parameters
119
     * @param null        $code
120
     *
121
     * @dataProvider dataPasswordsMinimumSpecialCharacters
122
     */
123
    public function testPasswordMinimumSpecialCharactersOnlySet($password, $message = null, array $parameters = [], $code = null)
124
    {
125
        $this->setValidator(null, null, self::PARAMETER_MIN_SPECIAL_CHARACTERS, null, null);
126
        $this->buildAndTestPasswordRestrictions($password, $message, $parameters, $code);
127
    }
128
129
    /**
130
     * @param string      $password
131
     * @param string|null $message
132
     * @param array       $parameters
133
     * @param null        $code
134
     *
135
     * @dataProvider dataPasswordsLengthRange
136
     */
137
    public function testPasswordLengthRangeSet($password, $message = null, array $parameters = [], $code = null)
138
    {
139
        $this->setValidator(null, null, null, self::PARAMETER_MIN_LENGTH, self::PARAMETER_MAX_LENGTH);
140
        $this->buildAndTestPasswordRestrictions($password, $message, $parameters, $code);
141
    }
142
143
    /**
144
     * Uses the set validator combined with data to assert.
145
     *
146
     * @param string      $password
147
     * @param string|null $message
148
     * @param array       $parameters
149
     * @param null        $code
150
     */
151
    private function buildAndTestPasswordRestrictions($password, $message = null, array $parameters = [], $code = null)
152
    {
153
        $constraint = new PasswordRestrictions();
154
155
        $this->validator->validate($password, $constraint);
156
157
        if ($message && $code) {
0 ignored issues
show
Bug Best Practice introduced by Peter Zentjens
The expression $message of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

In PHP, under loose comparison (like ==, or !=, or switch conditions), values of different types might be equal.

For string values, the empty string '' is a special case, in particular the following results might be unexpected:

''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
Loading history...
158
            $this->buildViolation($message)
159
                ->setCode($code)
160
                ->setParameters($parameters)
161
                ->assertRaised();
162
        } else {
163
            $this->assertNoViolation();
164
        }
165
    }
166
167
    /**
168
     * @return array
169
     */
170
    public function dataPasswordsWithAllParameters()
171
    {
172
        return [
173
            ['ABcdef789!'],
174
            ['AB123!q', PasswordRestrictions::MESSAGE_MIN_LENGTH, ['{{ min_length }}' => self::PARAMETER_MIN_LENGTH], PasswordRestrictions::INVALID_MIN_LENGTH_ERROR],
175
            ['AB123!q541kkjhghvhb451', PasswordRestrictions::MESSAGE_MAX_LENGTH, ['{{ max_length }}' => self::PARAMETER_MAX_LENGTH], PasswordRestrictions::INVALID_MAX_LENGTH_ERROR],
176
            ['abCDEFG*', PasswordRestrictions::MESSAGE_MIN_DIGITS, ['{{ min_digits }}' => self::PARAMETER_MIN_DIGITS], PasswordRestrictions::INVALID_MIN_DIGITS_ERROR],
177
            ['ab123efg!', PasswordRestrictions::MESSAGE_MIN_UPPERCASE, ['{{ min_uppercase }}' => self::PARAMETER_MIN_UPPERCASE], PasswordRestrictions::INVALID_MIN_UPPERCASE_ERROR],
178
            ['AB123efg', PasswordRestrictions::MESSAGE_MIN_SPECIAL_CHARACTERS, ['{{ min_special_characters }}' => self::PARAMETER_MIN_SPECIAL_CHARACTERS], PasswordRestrictions::INVALID_MIN_SPECIAL_CHARACTERS_ERROR],
179
        ];
180
    }
181
182
    /**
183
     * @return array
184
     */
185
    public function dataPasswordsToShort()
186
    {
187
        return [
188
            ['password'],
189
            ['ABC?123', PasswordRestrictions::MESSAGE_MIN_LENGTH, ['{{ min_length }}' => self::PARAMETER_MIN_LENGTH], PasswordRestrictions::INVALID_MIN_LENGTH_ERROR],
190
            ['admin', PasswordRestrictions::MESSAGE_MIN_LENGTH, ['{{ min_length }}' => self::PARAMETER_MIN_LENGTH], PasswordRestrictions::INVALID_MIN_LENGTH_ERROR],
191
        ];
192
    }
193
194
    /**
195
     * @return array
196
     */
197
    public function dataPasswordsToLong()
198
    {
199
        return [
200
            ['correct!'],
201
            ['thispasswordistolong', PasswordRestrictions::MESSAGE_MAX_LENGTH, ['{{ max_length }}' => self::PARAMETER_MAX_LENGTH], PasswordRestrictions::INVALID_MAX_LENGTH_ERROR],
202
        ];
203
    }
204
205
    /**
206
     * @return array
207
     */
208
    public function dataPasswordsMinimumDigits()
209
    {
210
        return [
211
            ['withdigits123'],
212
            ['nodigits', PasswordRestrictions::MESSAGE_MIN_DIGITS, ['{{ min_digits }}' => self::PARAMETER_MIN_DIGITS], PasswordRestrictions::INVALID_MIN_DIGITS_ERROR],
213
        ];
214
    }
215
216
    /**
217
     * @return array
218
     */
219 View Code Duplication
    public function dataPasswordsMinimumUppercase()
220
    {
221
        return [
222
            ['PassworD'],
223
            ['password', PasswordRestrictions::MESSAGE_MIN_UPPERCASE, ['{{ min_uppercase }}' => self::PARAMETER_MIN_UPPERCASE], PasswordRestrictions::INVALID_MIN_UPPERCASE_ERROR],
224
        ];
225
    }
226
227
    /**
228
     * @return array
229
     */
230 View Code Duplication
    public function dataPasswordsMinimumSpecialCharacters()
231
    {
232
        return [
233
            ['password!'],
234
            ['password', PasswordRestrictions::MESSAGE_MIN_SPECIAL_CHARACTERS, ['{{ min_special_characters }}' => self::PARAMETER_MIN_SPECIAL_CHARACTERS], PasswordRestrictions::INVALID_MIN_SPECIAL_CHARACTERS_ERROR],
235
        ];
236
    }
237
238
    /**
239
     * Combine the data of the too long and too short test for an extra length
240
     * range test.
241
     *
242
     * @return array
243
     */
244
    public function dataPasswordsLengthRange()
245
    {
246
        return $this->dataPasswordsToLong() + $this->dataPasswordsToShort();
247
    }
248
}
249