StringValidationTest - Code Metrics - nilportugues/validator - Measure and Improve Code Quality continuously with Scrutinizer

StringValidationTest A
last analyzed 2015-12-15 18:43 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	523
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
wmc	34
lcom	1
cbo	2
dl	0
loc	523
rs	9.2
c	1
b	0
f	0

34 Methods

Rating	Name	Size	Complexity
A	itShouldCheckStringIsString()	10	1
A	itShouldCheckStringIsAlphanumeric()	10	1
A	itShouldCheckStringIsAlpha()	10	1
A	itShouldCheckStringIsBetween()	10	1
A	itShouldCheckStringIsBetweenException()	5	1
A	itShouldCheckStringIsCharset()	8	1
A	itShouldCheckStringIsAllConsonants()	10	1
A	itShouldCheckStringIsContains()	14	1
A	itShouldCheckStringIsControlCharacters()	10	1
A	itShouldCheckStringIsDigit()	10	1
A	itShouldCheckStringIsEndsWith()	14	1
A	itShouldCheckStringIsEquals()	15	1
A	itShouldCheckStringIsIn()	14	1
A	itShouldCheckStringIsGraph()	10	1
A	itShouldCheckStringIsLength()	12	1
A	itShouldCheckStringIsLowercase()	6	1
A	itShouldCheckStringIsNotEmpty()	10	1
A	itShouldCheckStringIsNoWhitespace()	10	1
A	itShouldCheckStringIsPrintable()	10	1
A	itShouldCheckStringIsPunctuation()	10	1
A	itShouldCheckStringIsRegex()	12	1
A	itShouldCheckStringIsSlug()	18	1
A	itShouldCheckStringIsSpace()	10	1
A	itShouldCheckStringIsStartsWith()	14	1
A	itShouldCheckStringIsUppercase()	10	1
A	itShouldCheckStringIsVersion()	18	1
A	itShouldCheckStringIsVowel()	10	1
A	itShouldCheckStringIsHexDigit()	10	1
A	itShouldCheckIfHasLowercaseAndUppercase()	14	1
A	itShouldCheckIfHasNumeric()	8	1
A	itShouldCheckIfHasSpecialCharacters()	8	1
A	itShouldCheckIfIsEmail()	12	1
A	itShouldCheckIfIsUrl()	9	1
B	itShouldValidateUUID()	24	1

<?php
/**
 * Author: Nil Portugués Calderó <[email protected]>
 * Date: 9/17/14
 * Time: 8:44 PM
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Tests\NilPortugues\Validator\Validation\String;

use NilPortugues\Validator\Validation\String\StringValidation;

/**
 * Class StringValidationTest
 * @package Tests\NilPortugues\Validator\Validation\StringAttribute
 */
class StringValidationTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @test
     */
    public function itShouldCheckStringIsString()
    {
        $value  = 'asdsdadds';
        $result = StringValidation::isString($value);
        $this->assertTrue($result);

        $value  = new \StdClass();
        $result = StringValidation::isString($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsAlphanumeric()
    {
        $value  = 'Qwerty1234';
        $result = StringValidation::isAlphanumeric($value);
        $this->assertTrue($result);

        $value  = '';
        $result = StringValidation::isAlphanumeric($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsAlpha()
    {
        $value  = 'querty';
        $result = StringValidation::isAlpha($value);
        $this->assertTrue($result);

        $value  = 'querty123';
        $result = StringValidation::isAlpha($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsBetween()
    {
        $value  = 'Nil';
        $result = StringValidation::isBetween($value, 2, 4, false);
        $this->assertTrue($result);

        $value  = 'Nilo';
        $result = StringValidation::isBetween($value, 2, 4, true);
        $this->assertTrue($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsBetweenException()
    {
        $this->setExpectedException('\InvalidArgumentException');
        StringValidation::isBetween('Nil', 12, 4, false);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsCharset()
    {
        $value = 'Portugués';

        $result = StringValidation::isCharset($value, 'UTF-8');

        $this->assertTrue($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsAllConsonants()
    {
        $value  = 'a';
        $result = StringValidation::isAllConsonants($value);
        $this->assertFalse($result);

        $value  = 'bs';
        $result = StringValidation::isAllConsonants($value);
        $this->assertTrue($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsContains()
    {
        $value     = 'AAAAAAAaaaA';
        $contains  = 'aaa';
        $identical = true;
        $result    = StringValidation::contains($value, $contains, $identical);
        $this->assertTrue($result);

        $value     = 'AAAAAAA123A';
        $contains  = 123;
        $identical = false;
        $result    = StringValidation::contains($value, $contains, $identical);
        $this->assertTrue($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsControlCharacters()
    {
        $value  = "\n\t";
        $result = StringValidation::isControlCharacters($value);
        $this->assertTrue($result);

        $value  = "\nHello\tWorld";
        $result = StringValidation::isControlCharacters($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsDigit()
    {
        $value  = 'A';
        $result = StringValidation::isDigit($value);
        $this->assertFalse($result);

        $value  = 145.6;
        $result = StringValidation::isDigit($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsEndsWith()
    {
        $value     = 'AAAAAAAaaaA';
        $contains  = 'aaaA';
        $identical = true;
        $result    = StringValidation::endsWith($value, $contains, $identical);
        $this->assertTrue($result);

        $value     = 'AAAAAAA123';
        $contains  = 123;
        $identical = false;
        $result    = StringValidation::endsWith($value, $contains, $identical);
        $this->assertTrue($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsEquals()
    {
        $value         = 'hello';
        $comparedValue = 'hello';
        $identical     = true;
        $result        = StringValidation::equals($value, $comparedValue, $identical);
        $this->assertTrue($result);

        $value         = '1';
        $comparedValue = 1;
        $identical     = false;
        $result        = StringValidation::equals($value, $comparedValue, $identical);

        $this->assertTrue($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsIn()
    {
        $haystack  = 'a12245 asdhsjasd 63-211';
        $value     = "122";
        $identical = false;
        $result    = StringValidation::in($value, $haystack, $identical);
        $this->assertTrue($result);

        $haystack  = 'a12245 asdhsjasd 63-211';
        $value     = '5 asd';
        $identical = true;
        $result    = StringValidation::in($value, $haystack, $identical);
        $this->assertTrue($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsGraph()
    {
        $value  = 'arf12';
        $result = StringValidation::hasGraphicalCharsOnly($value);
        $this->assertTrue($result);

        $value  = "asdf\n\r\t";
        $result = StringValidation::hasGraphicalCharsOnly($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsLength()
    {
        $value  = 'abcdefgh';
        $length = 5;
        $result = StringValidation::hasLength($value, $length);
        $this->assertFalse($result);

        $value  = 'abcdefgh';
        $length = 8;
        $result = StringValidation::hasLength($value, $length);
        $this->assertTrue($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsLowercase()
    {
        $value  = 'strtolower';
        $result = StringValidation::isLowercase($value);
        $this->assertTrue($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsNotEmpty()
    {
        $value  = 'a';
        $result = StringValidation::notEmpty($value);
        $this->assertTrue($result);

        $value  = '';
        $result = StringValidation::notEmpty($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsNoWhitespace()
    {
        $value  = 'aaaaa';
        $result = StringValidation::noWhitespace($value);
        $this->assertTrue($result);

        $value  = 'lorem ipsum';
        $result = StringValidation::noWhitespace($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsPrintable()
    {
        $value  = 'LMKA0$% _123';
        $result = StringValidation::hasPrintableCharsOnly($value);
        $this->assertTrue($result);

        $value  = "LMKA0$%\t_123";
        $result = StringValidation::hasPrintableCharsOnly($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsPunctuation()
    {
        $value  = '&,.;[]';
        $result = StringValidation::isPunctuation($value);
        $this->assertTrue($result);

        $value  = 'a';
        $result = StringValidation::isPunctuation($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsRegex()
    {
        $value  = 'a';
        $regex  = '/[a-z]/';
        $result = StringValidation::matchesRegex($value, $regex);
        $this->assertTrue($result);

        $value  = 'A';
        $regex  = '/[a-z]/';
        $result = StringValidation::matchesRegex($value, $regex);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsSlug()
    {
        $value  = 'hello-world-yeah';
        $result = StringValidation::isSlug($value);
        $this->assertTrue($result);

        $value  = '-hello-world-yeah';
        $result = StringValidation::isSlug($value);
        $this->assertFalse($result);

        $value  = 'hello-world-yeah-';
        $result = StringValidation::isSlug($value);
        $this->assertFalse($result);

        $value  = 'hello-world----yeah';
        $result = StringValidation::isSlug($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsSpace()
    {
        $value  = '    ';
        $result = StringValidation::isSpace($value);
        $this->assertTrue($result);

        $value  = 'e e';
        $result = StringValidation::isSpace($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsStartsWith()
    {
        $value     = 'aaaAAAAAAAA';
        $contains  = 'aaaA';
        $identical = true;
        $result    = StringValidation::startsWith($value, $contains, $identical);
        $this->assertTrue($result);

        $value     = '123AAAAAAA';
        $contains  = 123;
        $identical = false;
        $result    = StringValidation::startsWith($value, $contains, $identical);
        $this->assertTrue($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsUppercase()
    {
        $value  = 'AAAAAA';
        $result = StringValidation::isUppercase($value);
        $this->assertTrue($result);

        $value  = 'aaaa';
        $result = StringValidation::isUppercase($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsVersion()
    {
        $value  = '1.0.2';
        $result = StringValidation::isVersion($value);
        $this->assertTrue($result);

        $value  = '1.0.2-beta';
        $result = StringValidation::isVersion($value);
        $this->assertTrue($result);

        $value  = '1.0';
        $result = StringValidation::isVersion($value);
        $this->assertTrue($result);

        $value  = '1.0.2 beta';
        $result = StringValidation::isVersion($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsVowel()
    {
        $value  = 'aeA';
        $result = StringValidation::isVowel($value);
        $this->assertTrue($result);

        $value  = 'cds';
        $result = StringValidation::isVowel($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckStringIsHexDigit()
    {
        $value  = '100';
        $result = StringValidation::isHexDigit($value);
        $this->assertTrue($result);

        $value  = 'h0000';
        $result = StringValidation::isHexDigit($value);
        $this->assertFalse($result);
    }

    /**
     * @test
     */
    public function itShouldCheckIfHasLowercaseAndUppercase()
    {
        $this->assertTrue(StringValidation::hasLowercase('HELLOWOrLD'));
        $this->assertTrue(StringValidation::hasLowercase('HeLLoWOrLD', 3));

        $this->assertFalse(StringValidation::hasLowercase('HELLOWORLD'));
        $this->assertFalse(StringValidation::hasLowercase('el', 3));

        $this->assertTrue(StringValidation::hasUppercase('hello World'));
        $this->assertTrue(StringValidation::hasUppercase('Hello World', 2));

        $this->assertFalse(StringValidation::hasUppercase('hello world'));
        $this->assertFalse(StringValidation::hasUppercase('helloWorld', 2));
    }

    /**
     * @test
     */
    public function itShouldCheckIfHasNumeric()
    {
        $this->assertTrue(StringValidation::hasNumeric('hell0 W0rld'));
        $this->assertTrue(StringValidation::hasNumeric('H3ll0 W0rld', 3));

        $this->assertFalse(StringValidation::hasNumeric('hello world'));
        $this->assertFalse(StringValidation::hasNumeric('h3lloWorld', 2));
    }

    /**
     * @test
     */
    public function itShouldCheckIfHasSpecialCharacters()
    {
        $this->assertTrue(StringValidation::hasSpecialCharacters('hell0@W0rld'));
        $this->assertTrue(StringValidation::hasSpecialCharacters('H3ll0@W0@rld', 2));

        $this->assertFalse(StringValidation::hasSpecialCharacters('hello world'));
        $this->assertFalse(StringValidation::hasSpecialCharacters('h3llo@World', 2));
    }

    /**
     * @test
     */
    public function itShouldCheckIfIsEmail()
    {
        $this->assertTrue(StringValidation::isEmail('[email protected]'));
        $this->assertTrue(StringValidation::isEmail('[email protected]'));
        $this->assertTrue(StringValidation::isEmail('[email protected]'));
        $this->assertTrue(StringValidation::isEmail('[email protected]'));
        $this->assertTrue(StringValidation::isEmail('[email protected]'));
        $this->assertTrue(StringValidation::isEmail('[email protected]'));
        $this->assertTrue(StringValidation::isEmail('[email protected]'));

        $this->assertFalse(StringValidation::isEmail('hello.earth+moon@localhost'));
    }

    /**
     * @test
     */
    public function itShouldCheckIfIsUrl()
    {
        $this->assertTrue(StringValidation::isUrl('http://google.com'));
        $this->assertTrue(StringValidation::isUrl('http://google.com/robots.txt'));
        $this->assertTrue(StringValidation::isUrl('https://google.com'));
        $this->assertTrue(StringValidation::isUrl('https://google.com/robots.txt'));
        $this->assertTrue(StringValidation::isUrl('//google.com'));
        $this->assertTrue(StringValidation::isUrl('//google.com/robots.txt'));
    }

    /**
     * @test
     */
    public function itShouldValidateUUID()
    {
        $this->assertTrue(StringValidation::isUUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8'));
        $this->assertTrue(StringValidation::isUUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8'));
        $this->assertTrue(StringValidation::isUUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8'));
        $this->assertTrue(StringValidation::isUUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8'));
        $this->assertTrue(StringValidation::isUUID('00000000-0000-0000-0000-000000000000'));

        $this->assertTrue(StringValidation::isUUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8', false));
        $this->assertTrue(StringValidation::isUUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8', false));
        $this->assertTrue(StringValidation::isUUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8', false));
        $this->assertTrue(StringValidation::isUUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8', false));
        $this->assertTrue(StringValidation::isUUID('00000000-0000-0000-0000-000000000000', false));

        $this->assertFalse(StringValidation::isUUID('{6ba7b810-9dad-11d1-80b4-00c04fd430c8}'));
        $this->assertFalse(StringValidation::isUUID('216f-ff40-98d9-11e3-a5e2-0800-200c-9a66'));
        $this->assertFalse(StringValidation::isUUID('{216fff40-98d9-11e3-a5e2-0800200c9a66}'));
        $this->assertFalse(StringValidation::isUUID('216fff4098d911e3a5e20800200c9a66'));

        $this->assertTrue(StringValidation::isUUID('{6ba7b810-9dad-11d1-80b4-00c04fd430c8}', false));
        $this->assertTrue(StringValidation::isUUID('216f-ff40-98d9-11e3-a5e2-0800-200c-9a66', false));
        $this->assertTrue(StringValidation::isUUID('{216fff40-98d9-11e3-a5e2-0800200c9a66}', false));
        $this->assertTrue(StringValidation::isUUID('216fff4098d911e3a5e20800200c9a66', false));
    }
}


1			<?php
2			/**
3			* Author: Nil Portugués Calderó <[email protected]>
4			* Date: 9/17/14
5			* Time: 8:44 PM
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10
11			namespace Tests\NilPortugues\Validator\Validation\String;
12
13			use NilPortugues\Validator\Validation\String\StringValidation;
14
15			/**
16			* Class StringValidationTest
17			* @package Tests\NilPortugues\Validator\Validation\StringAttribute
18			*/
19			class StringValidationTest extends \PHPUnit_Framework_TestCase
20			{
21			/**
22			* @test
23			*/
24			public function itShouldCheckStringIsString()
25			{
26			$value = 'asdsdadds';
27			$result = StringValidation::isString($value);
28			$this->assertTrue($result);
29
30			$value = new \StdClass();
31			$result = StringValidation::isString($value);
32			$this->assertFalse($result);
33			}
34
35			/**
36			* @test
37			*/
38			public function itShouldCheckStringIsAlphanumeric()
39			{
40			$value = 'Qwerty1234';
41			$result = StringValidation::isAlphanumeric($value);
42			$this->assertTrue($result);
43
44			$value = '';
45			$result = StringValidation::isAlphanumeric($value);
46			$this->assertFalse($result);
47			}
48
49			/**
50			* @test
51			*/
52			public function itShouldCheckStringIsAlpha()
53			{
54			$value = 'querty';
55			$result = StringValidation::isAlpha($value);
56			$this->assertTrue($result);
57
58			$value = 'querty123';
59			$result = StringValidation::isAlpha($value);
60			$this->assertFalse($result);
61			}
62
63			/**
64			* @test
65			*/
66			public function itShouldCheckStringIsBetween()
67			{
68			$value = 'Nil';
69			$result = StringValidation::isBetween($value, 2, 4, false);
70			$this->assertTrue($result);
71
72			$value = 'Nilo';
73			$result = StringValidation::isBetween($value, 2, 4, true);
74			$this->assertTrue($result);
75			}
76
77			/**
78			* @test
79			*/
80			public function itShouldCheckStringIsBetweenException()
81			{
82			$this->setExpectedException('\InvalidArgumentException');
83			StringValidation::isBetween('Nil', 12, 4, false);
84			}
85
86			/**
87			* @test
88			*/
89			public function itShouldCheckStringIsCharset()
90			{
91			$value = 'Portugués';
92
93			$result = StringValidation::isCharset($value, 'UTF-8');
94
95			$this->assertTrue($result);
96			}
97
98			/**
99			* @test
100			*/
101			public function itShouldCheckStringIsAllConsonants()
102			{
103			$value = 'a';
104			$result = StringValidation::isAllConsonants($value);
105			$this->assertFalse($result);
106
107			$value = 'bs';
108			$result = StringValidation::isAllConsonants($value);
109			$this->assertTrue($result);
110			}
111
112			/**
113			* @test
114			*/
115			public function itShouldCheckStringIsContains()
116			{
117			$value = 'AAAAAAAaaaA';
118			$contains = 'aaa';
119			$identical = true;
120			$result = StringValidation::contains($value, $contains, $identical);
121			$this->assertTrue($result);
122
123			$value = 'AAAAAAA123A';
124			$contains = 123;
125			$identical = false;
126			$result = StringValidation::contains($value, $contains, $identical);
127			$this->assertTrue($result);
128			}
129
130			/**
131			* @test
132			*/
133			public function itShouldCheckStringIsControlCharacters()
134			{
135			$value = "\n\t";
136			$result = StringValidation::isControlCharacters($value);
137			$this->assertTrue($result);
138
139			$value = "\nHello\tWorld";
140			$result = StringValidation::isControlCharacters($value);
141			$this->assertFalse($result);
142			}
143
144			/**
145			* @test
146			*/
147			public function itShouldCheckStringIsDigit()
148			{
149			$value = 'A';
150			$result = StringValidation::isDigit($value);
151			$this->assertFalse($result);
152
153			$value = 145.6;
154			$result = StringValidation::isDigit($value);
155			$this->assertFalse($result);
156			}
157
158			/**
159			* @test
160			*/
161			public function itShouldCheckStringIsEndsWith()
162			{
163			$value = 'AAAAAAAaaaA';
164			$contains = 'aaaA';
165			$identical = true;
166			$result = StringValidation::endsWith($value, $contains, $identical);
167			$this->assertTrue($result);
168
169			$value = 'AAAAAAA123';
170			$contains = 123;
171			$identical = false;
172			$result = StringValidation::endsWith($value, $contains, $identical);
173			$this->assertTrue($result);
174			}
175
176			/**
177			* @test
178			*/
179			public function itShouldCheckStringIsEquals()
180			{
181			$value = 'hello';
182			$comparedValue = 'hello';
183			$identical = true;
184			$result = StringValidation::equals($value, $comparedValue, $identical);
185			$this->assertTrue($result);
186
187			$value = '1';
188			$comparedValue = 1;
189			$identical = false;
190			$result = StringValidation::equals($value, $comparedValue, $identical);
191
192			$this->assertTrue($result);
193			}
194
195			/**
196			* @test
197			*/
198			public function itShouldCheckStringIsIn()
199			{
200			$haystack = 'a12245 asdhsjasd 63-211';
201			$value = "122";
202			$identical = false;
203			$result = StringValidation::in($value, $haystack, $identical);
204			$this->assertTrue($result);
205
206			$haystack = 'a12245 asdhsjasd 63-211';
207			$value = '5 asd';
208			$identical = true;
209			$result = StringValidation::in($value, $haystack, $identical);
210			$this->assertTrue($result);
211			}
212
213			/**
214			* @test
215			*/
216			public function itShouldCheckStringIsGraph()
217			{
218			$value = 'arf12';
219			$result = StringValidation::hasGraphicalCharsOnly($value);
220			$this->assertTrue($result);
221
222			$value = "asdf\n\r\t";
223			$result = StringValidation::hasGraphicalCharsOnly($value);
224			$this->assertFalse($result);
225			}
226
227			/**
228			* @test
229			*/
230			public function itShouldCheckStringIsLength()
231			{
232			$value = 'abcdefgh';
233			$length = 5;
234			$result = StringValidation::hasLength($value, $length);
235			$this->assertFalse($result);
236
237			$value = 'abcdefgh';
238			$length = 8;
239			$result = StringValidation::hasLength($value, $length);
240			$this->assertTrue($result);
241			}
242
243			/**
244			* @test
245			*/
246			public function itShouldCheckStringIsLowercase()
247			{
248			$value = 'strtolower';
249			$result = StringValidation::isLowercase($value);
250			$this->assertTrue($result);
251			}
252
253			/**
254			* @test
255			*/
256			public function itShouldCheckStringIsNotEmpty()
257			{
258			$value = 'a';
259			$result = StringValidation::notEmpty($value);
260			$this->assertTrue($result);
261
262			$value = '';
263			$result = StringValidation::notEmpty($value);
264			$this->assertFalse($result);
265			}
266
267			/**
268			* @test
269			*/
270			public function itShouldCheckStringIsNoWhitespace()
271			{
272			$value = 'aaaaa';
273			$result = StringValidation::noWhitespace($value);
274			$this->assertTrue($result);
275
276			$value = 'lorem ipsum';
277			$result = StringValidation::noWhitespace($value);
278			$this->assertFalse($result);
279			}
280
281			/**
282			* @test
283			*/
284			public function itShouldCheckStringIsPrintable()
285			{
286			$value = 'LMKA0$% _123';
287			$result = StringValidation::hasPrintableCharsOnly($value);
288			$this->assertTrue($result);
289
290			$value = "LMKA0$%\t_123";
291			$result = StringValidation::hasPrintableCharsOnly($value);
292			$this->assertFalse($result);
293			}
294
295			/**
296			* @test
297			*/
298			public function itShouldCheckStringIsPunctuation()
299			{
300			$value = '&,.;[]';
301			$result = StringValidation::isPunctuation($value);
302			$this->assertTrue($result);
303
304			$value = 'a';
305			$result = StringValidation::isPunctuation($value);
306			$this->assertFalse($result);
307			}
308
309			/**
310			* @test
311			*/
312			public function itShouldCheckStringIsRegex()
313			{
314			$value = 'a';
315			$regex = '/[a-z]/';
316			$result = StringValidation::matchesRegex($value, $regex);
317			$this->assertTrue($result);
318
319			$value = 'A';
320			$regex = '/[a-z]/';
321			$result = StringValidation::matchesRegex($value, $regex);
322			$this->assertFalse($result);
323			}
324
325			/**
326			* @test
327			*/
328			public function itShouldCheckStringIsSlug()
329			{
330			$value = 'hello-world-yeah';
331			$result = StringValidation::isSlug($value);
332			$this->assertTrue($result);
333
334			$value = '-hello-world-yeah';
335			$result = StringValidation::isSlug($value);
336			$this->assertFalse($result);
337
338			$value = 'hello-world-yeah-';
339			$result = StringValidation::isSlug($value);
340			$this->assertFalse($result);
341
342			$value = 'hello-world----yeah';
343			$result = StringValidation::isSlug($value);
344			$this->assertFalse($result);
345			}
346
347			/**
348			* @test
349			*/
350			public function itShouldCheckStringIsSpace()
351			{
352			$value = ' ';
353			$result = StringValidation::isSpace($value);
354			$this->assertTrue($result);
355
356			$value = 'e e';
357			$result = StringValidation::isSpace($value);
358			$this->assertFalse($result);
359			}
360
361			/**
362			* @test
363			*/
364			public function itShouldCheckStringIsStartsWith()
365			{
366			$value = 'aaaAAAAAAAA';
367			$contains = 'aaaA';
368			$identical = true;
369			$result = StringValidation::startsWith($value, $contains, $identical);
370			$this->assertTrue($result);
371
372			$value = '123AAAAAAA';
373			$contains = 123;
374			$identical = false;
375			$result = StringValidation::startsWith($value, $contains, $identical);
376			$this->assertTrue($result);
377			}
378
379			/**
380			* @test
381			*/
382			public function itShouldCheckStringIsUppercase()
383			{
384			$value = 'AAAAAA';
385			$result = StringValidation::isUppercase($value);
386			$this->assertTrue($result);
387
388			$value = 'aaaa';
389			$result = StringValidation::isUppercase($value);
390			$this->assertFalse($result);
391			}
392
393			/**
394			* @test
395			*/
396			public function itShouldCheckStringIsVersion()
397			{
398			$value = '1.0.2';
399			$result = StringValidation::isVersion($value);
400			$this->assertTrue($result);
401
402			$value = '1.0.2-beta';
403			$result = StringValidation::isVersion($value);
404			$this->assertTrue($result);
405
406			$value = '1.0';
407			$result = StringValidation::isVersion($value);
408			$this->assertTrue($result);
409
410			$value = '1.0.2 beta';
411			$result = StringValidation::isVersion($value);
412			$this->assertFalse($result);
413			}
414
415			/**
416			* @test
417			*/
418			public function itShouldCheckStringIsVowel()
419			{
420			$value = 'aeA';
421			$result = StringValidation::isVowel($value);
422			$this->assertTrue($result);
423
424			$value = 'cds';
425			$result = StringValidation::isVowel($value);
426			$this->assertFalse($result);
427			}
428
429			/**
430			* @test
431			*/
432			public function itShouldCheckStringIsHexDigit()
433			{
434			$value = '100';
435			$result = StringValidation::isHexDigit($value);
436			$this->assertTrue($result);
437
438			$value = 'h0000';
439			$result = StringValidation::isHexDigit($value);
440			$this->assertFalse($result);
441			}
442
443			/**
444			* @test
445			*/
446			public function itShouldCheckIfHasLowercaseAndUppercase()
447			{
448			$this->assertTrue(StringValidation::hasLowercase('HELLOWOrLD'));
449			$this->assertTrue(StringValidation::hasLowercase('HeLLoWOrLD', 3));
450
451			$this->assertFalse(StringValidation::hasLowercase('HELLOWORLD'));
452			$this->assertFalse(StringValidation::hasLowercase('el', 3));
453
454			$this->assertTrue(StringValidation::hasUppercase('hello World'));
455			$this->assertTrue(StringValidation::hasUppercase('Hello World', 2));
456
457			$this->assertFalse(StringValidation::hasUppercase('hello world'));
458			$this->assertFalse(StringValidation::hasUppercase('helloWorld', 2));
459			}
460
461			/**
462			* @test
463			*/
464			public function itShouldCheckIfHasNumeric()
465			{
466			$this->assertTrue(StringValidation::hasNumeric('hell0 W0rld'));
467			$this->assertTrue(StringValidation::hasNumeric('H3ll0 W0rld', 3));
468
469			$this->assertFalse(StringValidation::hasNumeric('hello world'));
470			$this->assertFalse(StringValidation::hasNumeric('h3lloWorld', 2));
471			}
472
473			/**
474			* @test
475			*/
476			public function itShouldCheckIfHasSpecialCharacters()
477			{
478			$this->assertTrue(StringValidation::hasSpecialCharacters('hell0@W0rld'));
479			$this->assertTrue(StringValidation::hasSpecialCharacters('H3ll0@W0@rld', 2));
480
481			$this->assertFalse(StringValidation::hasSpecialCharacters('hello world'));
482			$this->assertFalse(StringValidation::hasSpecialCharacters('h3llo@World', 2));
483			}
484
485			/**
486			* @test
487			*/
488			public function itShouldCheckIfIsEmail()
489			{
490			$this->assertTrue(StringValidation::isEmail('[email protected]'));
491			$this->assertTrue(StringValidation::isEmail('[email protected]'));
492			$this->assertTrue(StringValidation::isEmail('[email protected]'));
493			$this->assertTrue(StringValidation::isEmail('[email protected]'));
494			$this->assertTrue(StringValidation::isEmail('[email protected]'));
495			$this->assertTrue(StringValidation::isEmail('[email protected]'));
496			$this->assertTrue(StringValidation::isEmail('[email protected]'));
497
498			$this->assertFalse(StringValidation::isEmail('hello.earth+moon@localhost'));
499			}
500
501			/**
502			* @test
503			*/
504			public function itShouldCheckIfIsUrl()
505			{
506			$this->assertTrue(StringValidation::isUrl('http://google.com'));
507			$this->assertTrue(StringValidation::isUrl('http://google.com/robots.txt'));
508			$this->assertTrue(StringValidation::isUrl('https://google.com'));
509			$this->assertTrue(StringValidation::isUrl('https://google.com/robots.txt'));
510			$this->assertTrue(StringValidation::isUrl('//google.com'));
511			$this->assertTrue(StringValidation::isUrl('//google.com/robots.txt'));
512			}
513
514			/**
515			* @test
516			*/
517			public function itShouldValidateUUID()
518			{
519			$this->assertTrue(StringValidation::isUUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8'));
520			$this->assertTrue(StringValidation::isUUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8'));
521			$this->assertTrue(StringValidation::isUUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8'));
522			$this->assertTrue(StringValidation::isUUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8'));
523			$this->assertTrue(StringValidation::isUUID('00000000-0000-0000-0000-000000000000'));
524
525			$this->assertTrue(StringValidation::isUUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8', false));
526			$this->assertTrue(StringValidation::isUUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8', false));
527			$this->assertTrue(StringValidation::isUUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8', false));
528			$this->assertTrue(StringValidation::isUUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8', false));
529			$this->assertTrue(StringValidation::isUUID('00000000-0000-0000-0000-000000000000', false));
530
531			$this->assertFalse(StringValidation::isUUID('{6ba7b810-9dad-11d1-80b4-00c04fd430c8}'));
532			$this->assertFalse(StringValidation::isUUID('216f-ff40-98d9-11e3-a5e2-0800-200c-9a66'));
533			$this->assertFalse(StringValidation::isUUID('{216fff40-98d9-11e3-a5e2-0800200c9a66}'));
534			$this->assertFalse(StringValidation::isUUID('216fff4098d911e3a5e20800200c9a66'));
535
536			$this->assertTrue(StringValidation::isUUID('{6ba7b810-9dad-11d1-80b4-00c04fd430c8}', false));
537			$this->assertTrue(StringValidation::isUUID('216f-ff40-98d9-11e3-a5e2-0800-200c-9a66', false));
538			$this->assertTrue(StringValidation::isUUID('{216fff40-98d9-11e3-a5e2-0800200c9a66}', false));
539			$this->assertTrue(StringValidation::isUUID('216fff4098d911e3a5e20800200c9a66', false));
540			}
541			}
542

nilportugues / validator

StringValidationTest A last analyzed 2015-12-15 18:43 UTC

Complexity

Size/Duplication

Coupling/Cohesion

Importance

34 Methods

Duplication Side-by-Side

Filter issues like

StringValidationTest A
last analyzed 2015-12-15 18:43 UTC