Code Duplication - bruli/php-value-objects - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 36-40 lines in 9 locations

src/PhpValueObjects/Tests/Geography/LanguageCodeValueObjectTest.php 1 location


use PhpValueObjects\Geography\Exception\InvalidLanguageCodeException;
use PhpValueObjects\Tests\BaseUnitTestCase;

class LanguageCodeValueObjectTest extends BaseUnitTestCase
{
    /**
     * @test
     */
    public function itShouldReturnLanguageCode()
    {
        $language = $this->faker()->languageCode;

        $langVO = new LanguageCodeValueObject($language);

        $this->assertSame($language, $langVO->value());
        $this->assertSame($language, $langVO->__toString());
    }

    /**
     * @return array
     */
    public function invalidLanguageCodeProvider()
    {
        return [
            [null],
            [$this->faker()->address],
            [$this->faker()->numberBetween()],
        ];
    }
    /**
     * @test
     * @dataProvider invalidLanguageCodeProvider
     */
    public function isShouldThrowsException($data)
    {
        $this->expectException(InvalidLanguageCodeException::class);

        new LanguageCodeValueObject($data);
    }
}


src/PhpValueObjects/Tests/Identity/EmailValueObjectTest.php 1 location


use PhpValueObjects\Identity\Exception\InvalidEmailException;
use PhpValueObjects\Tests\BaseUnitTestCase;

class EmailValueObjectTest extends BaseUnitTestCase
{
    /**
     * @test
     */
    public function itShouldReturnEmail()
    {
        $email = $this->faker()->email;

        $emailVO = new EmailValueObject($email);

        $this->assertSame($email, $emailVO->value());
        $this->assertSame($email, $emailVO->__toString());
    }

    /**
     * @return array
     */
    public function invalidEmailProvider()
    {
        return [
            [null],
            [$this->faker()->numberBetween()],
            [$this->faker()->address],
        ];
    }

    /**
     * @test
     *
     * @dataProvider invalidEmailProvider
     */
    public function itShouldThrowsException($data)
    {
        $this->expectException(InvalidEmailException::class);

        new EmailValueObject($data);
    }
}


src/PhpValueObjects/Tests/Identity/UuidValueObjectTest.php 1 location


use PhpValueObjects\Identity\Exception\InvalidUuidException;
use PhpValueObjects\Tests\BaseUnitTestCase;

class UuidValueObjectTest extends BaseUnitTestCase
{
    /**
     * @test
     */
    public function itShouldReturnUuid()
    {
        $uuid = $this->faker()->uuid;

        $uuidVO = new UuidValueObject($uuid);

        $this->assertSame($uuid, $uuidVO->value());
        $this->assertSame($uuid, $uuidVO->__toString());
    }

    public function invalidUuidProvider()
    {
        return [
            [null],
            [$this->faker()->numberBetween()],
            [$this->faker()->address],
        ];
    }

    /**
     * @test
     *
     * @dataProvider invalidUuidProvider
     */
    public function itShouldThrowsException($data)
    {
        $this->expectException(InvalidUuidException::class);

        new UuidValueObject($data);
    }
}


src/PhpValueObjects/Tests/Network/Ipv4ValueObjectTest.php 1 location


use PhpValueObjects\Network\Exception\InvalidIpv4Exception;
use PhpValueObjects\Tests\BaseUnitTestCase;

class Ipv4ValueObjectTest extends BaseUnitTestCase
{
    /**
     * @test
     */
    public function itShouldReturnIpv4Address()
    {

        $ipAddress = $this->faker()->ipv4;

        $ipv4 = new Ipv4ValueObject($ipAddress);

        $this->assertSame($ipAddress, $ipv4->value());
        $this->assertSame($ipAddress, $ipv4->__toString());
    }

    /**
     * @return array
     */
    public function invalidIpv4AddressProvider()
    {
        return [
            [null],
            [$this->faker()->numberBetween()],
            [$this->faker()->ipv6]
        ];
    }

    /**
     * @test
     * @dataProvider invalidIpv4AddressProvider
     */
    public function itShouldThrowsException($data)
    {
        $this->expectException(InvalidIpv4Exception::class);

        new Ipv4ValueObject($data);
    }
}


src/PhpValueObjects/Tests/Network/Ipv6ValueObjectTest.php 1 location


use PhpValueObjects\Network\Exception\InvalidIpv6Exception;
use PhpValueObjects\Tests\BaseUnitTestCase;

class Ipv6ValueObjectTest extends BaseUnitTestCase
{
    /**
     * @test
     */
    public function itShouldReturnIpv6Address()
    {
        $ipAddress = $this->faker()->ipv6;

        $ipv6 = new Ipv6ValueObject($ipAddress);

        $this->assertSame($ipAddress, $ipv6->value());
        $this->assertSame($ipAddress, $ipv6->__toString());
    }

    /**
     * @return array
     */
    public function invalidIpv6Provider()
    {
        return [
            [null],
            [$this->faker()->ipv4],
            [$this->faker()->localIpv4],
            [$this->faker()->numberBetween()],
        ];
    }

    /**
     * @test
     * @dataProvider invalidIpv6Provider
     */
    public function itShouldThrowsException($data)
    {
        $this->expectException(InvalidIpv6Exception::class);

        new Ipv6ValueObject($data);
    }
}


src/PhpValueObjects/Tests/Network/UrlValueObjectTest.php 1 location


use PhpValueObjects\Network\Exception\InvalidUrlException;
use PhpValueObjects\Tests\BaseUnitTestCase;

class UrlValueObjectTest extends BaseUnitTestCase
{
    /**
     * @test
     */
    public function itShouldReturnUrl()
    {
        $url = $this->faker()->url;

        $urlVO = new UrlValueObject($url);

        $this->assertSame($url, $urlVO->value());
        $this->assertSame($url, $urlVO->__toString());
    }

    /**
     * @return array
     */
    public function invalidUrlProvider()
    {
        return [
            [null],
            [$this->faker()->email],
            [$this->faker()->phoneNumber],
        ];
    }

    /**
     * @test
     *
     * @dataProvider invalidUrlProvider
     */
    public function itShouldThrowsException($data)
    {
        $this->expectException(InvalidUrlException::class);

        new UrlValueObject($data);
    }
}


src/PhpValueObjects/Tests/Identity/Md5ValueObjectTest.php 1 location


use PhpValueObjects\Identity\Exception\InvalidMd5Exception;
use PhpValueObjects\Tests\BaseUnitTestCase;

class Md5ValueObjectTest extends BaseUnitTestCase
{
    /**
     * @test
     */
    public function itShouldReturnMd5Hash()
    {
        $md5Hash = $this->faker()->md5;

        $md5VO = new Md5ValueObject($md5Hash);

        $this->assertSame($md5Hash, $md5VO->value());
        $this->assertSame($md5Hash, $md5VO->__toString());
    }

    /**
     * @return array
     */
    public function invalidMd5HashProvider()
    {
        return [
            [$this->faker()->sha1],
            [$this->faker()->sha256],
            [$this->faker()->text],
        ];
    }

    /**
     * @test
     *
     * @dataProvider invalidMd5HashProvider
     */
    public function itShouldThrowsException($data)
    {
        $this->expectException(InvalidMd5Exception::class);

        new Md5ValueObject($data);
    }
}


src/PhpValueObjects/Tests/Identity/Sha1ValueObjectTest.php 1 location


use PhpValueObjects\Identity\Exception\InvalidSha1Exception;
use PhpValueObjects\Tests\BaseUnitTestCase;

class Sha1ValueObjectTest extends BaseUnitTestCase
{
    /**
     * @test
     */
    public function itShouldReturnSha1()
    {
        $sha1 = $this->faker()->sha1;

        $sha1VO = new Sha1ValueObject($sha1);

        $this->assertSame($sha1, $sha1VO->value());
        $this->assertSame($sha1, $sha1VO->__toString());
    }

    /**
     * @return array
     */
    public function invalidSha1Provider()
    {
        return [
            [null],
            [$this->faker()->md5],
            [$this->faker()->sha256],
            [$this->faker()->text],
        ];
    }

    /**
     * @test
     *
     * @dataProvider invalidSha1Provider
     */
    public function itShouldThrowsException($data)
    {
        $this->expectException(InvalidSha1Exception::class);

        new Sha1ValueObject($data);
    }
}


src/PhpValueObjects/Tests/Identity/Sha256ValueObjectTest.php 1 location


use PhpValueObjects\Identity\Exception\InvalidSha256Exception;
use PhpValueObjects\Tests\BaseUnitTestCase;

class Sha256ValueObjectTest extends BaseUnitTestCase
{
    /**
     * @test
     */
    public function itShouldReturnSha256()
    {
        $sha256 = $this->faker()->sha256;

        $sha256VO = new Sha256ValueObject($sha256);

        $this->assertSame($sha256, $sha256VO->value());
        $this->assertSame($sha256, $sha256VO->__toString());
    }

    /**
     * @return array
     */
    public function invalidSha256Provider()
    {
        return [
            [null],
            [$this->faker()->md5],
            [$this->faker()->sha1],
            [$this->faker()->text],
        ];
    }

    /**
     * @test
     * @dataProvider invalidSha256Provider
     */
    public function itShouldThrowsException($data)
    {
        $this->expectException(InvalidSha256Exception::class);

        new Sha256ValueObject($data);
    }
}


		@@ 8-44 (lines=37) @@
5		use PhpValueObjects\Geography\Exception\InvalidLanguageCodeException;
6		use PhpValueObjects\Tests\BaseUnitTestCase;
7
8		class LanguageCodeValueObjectTest extends BaseUnitTestCase
9		{
10		/**
11		* @test
12		*/
13		public function itShouldReturnLanguageCode()
14		{
15		$language = $this->faker()->languageCode;
16
17		$langVO = new LanguageCodeValueObject($language);
18
19		$this->assertSame($language, $langVO->value());
20		$this->assertSame($language, $langVO->__toString());
21		}
22
23		/**
24		* @return array
25		*/
26		public function invalidLanguageCodeProvider()
27		{
28		return [
29		[null],
30		[$this->faker()->address],
31		[$this->faker()->numberBetween()],
32		];
33		}
34		/**
35		* @test
36		* @dataProvider invalidLanguageCodeProvider
37		*/
38		public function isShouldThrowsException($data)
39		{
40		$this->expectException(InvalidLanguageCodeException::class);
41
42		new LanguageCodeValueObject($data);
43		}
44		}
45

		@@ 10-48 (lines=39) @@
7		use PhpValueObjects\Identity\Exception\InvalidEmailException;
8		use PhpValueObjects\Tests\BaseUnitTestCase;
9
10		class EmailValueObjectTest extends BaseUnitTestCase
11		{
12		/**
13		* @test
14		*/
15		public function itShouldReturnEmail()
16		{
17		$email = $this->faker()->email;
18
19		$emailVO = new EmailValueObject($email);
20
21		$this->assertSame($email, $emailVO->value());
22		$this->assertSame($email, $emailVO->__toString());
23		}
24
25		/**
26		* @return array
27		*/
28		public function invalidEmailProvider()
29		{
30		return [
31		[null],
32		[$this->faker()->numberBetween()],
33		[$this->faker()->address],
34		];
35		}
36
37		/**
38		* @test
39		*
40		* @dataProvider invalidEmailProvider
41		*/
42		public function itShouldThrowsException($data)
43		{
44		$this->expectException(InvalidEmailException::class);
45
46		new EmailValueObject($data);
47		}
48		}
49

		@@ 8-43 (lines=36) @@
5		use PhpValueObjects\Identity\Exception\InvalidUuidException;
6		use PhpValueObjects\Tests\BaseUnitTestCase;
7
8		class UuidValueObjectTest extends BaseUnitTestCase
9		{
10		/**
11		* @test
12		*/
13		public function itShouldReturnUuid()
14		{
15		$uuid = $this->faker()->uuid;
16
17		$uuidVO = new UuidValueObject($uuid);
18
19		$this->assertSame($uuid, $uuidVO->value());
20		$this->assertSame($uuid, $uuidVO->__toString());
21		}
22
23		public function invalidUuidProvider()
24		{
25		return [
26		[null],
27		[$this->faker()->numberBetween()],
28		[$this->faker()->address],
29		];
30		}
31
32		/**
33		* @test
34		*
35		* @dataProvider invalidUuidProvider
36		*/
37		public function itShouldThrowsException($data)
38		{
39		$this->expectException(InvalidUuidException::class);
40
41		new UuidValueObject($data);
42		}
43		}
44

		@@ 8-46 (lines=39) @@
5		use PhpValueObjects\Network\Exception\InvalidIpv4Exception;
6		use PhpValueObjects\Tests\BaseUnitTestCase;
7
8		class Ipv4ValueObjectTest extends BaseUnitTestCase
9		{
10		/**
11		* @test
12		*/
13		public function itShouldReturnIpv4Address()
14		{
15
16		$ipAddress = $this->faker()->ipv4;
17
18		$ipv4 = new Ipv4ValueObject($ipAddress);
19
20		$this->assertSame($ipAddress, $ipv4->value());
21		$this->assertSame($ipAddress, $ipv4->__toString());
22		}
23
24		/**
25		* @return array
26		*/
27		public function invalidIpv4AddressProvider()
28		{
29		return [
30		[null],
31		[$this->faker()->numberBetween()],
32		[$this->faker()->ipv6]
33		];
34		}
35
36		/**
37		* @test
38		* @dataProvider invalidIpv4AddressProvider
39		*/
40		public function itShouldThrowsException($data)
41		{
42		$this->expectException(InvalidIpv4Exception::class);
43
44		new Ipv4ValueObject($data);
45		}
46		}
47

		@@ 8-46 (lines=39) @@
5		use PhpValueObjects\Network\Exception\InvalidIpv6Exception;
6		use PhpValueObjects\Tests\BaseUnitTestCase;
7
8		class Ipv6ValueObjectTest extends BaseUnitTestCase
9		{
10		/**
11		* @test
12		*/
13		public function itShouldReturnIpv6Address()
14		{
15		$ipAddress = $this->faker()->ipv6;
16
17		$ipv6 = new Ipv6ValueObject($ipAddress);
18
19		$this->assertSame($ipAddress, $ipv6->value());
20		$this->assertSame($ipAddress, $ipv6->__toString());
21		}
22
23		/**
24		* @return array
25		*/
26		public function invalidIpv6Provider()
27		{
28		return [
29		[null],
30		[$this->faker()->ipv4],
31		[$this->faker()->localIpv4],
32		[$this->faker()->numberBetween()],
33		];
34		}
35
36		/**
37		* @test
38		* @dataProvider invalidIpv6Provider
39		*/
40		public function itShouldThrowsException($data)
41		{
42		$this->expectException(InvalidIpv6Exception::class);
43
44		new Ipv6ValueObject($data);
45		}
46		}
47

		@@ 8-47 (lines=40) @@
5		use PhpValueObjects\Identity\Exception\InvalidSha1Exception;
6		use PhpValueObjects\Tests\BaseUnitTestCase;
7
8		class Sha1ValueObjectTest extends BaseUnitTestCase
9		{
10		/**
11		* @test
12		*/
13		public function itShouldReturnSha1()
14		{
15		$sha1 = $this->faker()->sha1;
16
17		$sha1VO = new Sha1ValueObject($sha1);
18
19		$this->assertSame($sha1, $sha1VO->value());
20		$this->assertSame($sha1, $sha1VO->__toString());
21		}
22
23		/**
24		* @return array
25		*/
26		public function invalidSha1Provider()
27		{
28		return [
29		[null],
30		[$this->faker()->md5],
31		[$this->faker()->sha256],
32		[$this->faker()->text],
33		];
34		}
35
36		/**
37		* @test
38		*
39		* @dataProvider invalidSha1Provider
40		*/
41		public function itShouldThrowsException($data)
42		{
43		$this->expectException(InvalidSha1Exception::class);
44
45		new Sha1ValueObject($data);
46		}
47		}
48

bruli / php-value-objects

Code Duplication Length = 36-40 lines in 9 locations

src/PhpValueObjects/Tests/Geography/LanguageCodeValueObjectTest.php 1 location

src/PhpValueObjects/Tests/Identity/EmailValueObjectTest.php 1 location

src/PhpValueObjects/Tests/Identity/UuidValueObjectTest.php 1 location

src/PhpValueObjects/Tests/Network/Ipv4ValueObjectTest.php 1 location

src/PhpValueObjects/Tests/Network/Ipv6ValueObjectTest.php 1 location

src/PhpValueObjects/Tests/Network/UrlValueObjectTest.php 1 location

src/PhpValueObjects/Tests/Identity/Md5ValueObjectTest.php 1 location

src/PhpValueObjects/Tests/Identity/Sha1ValueObjectTest.php 1 location

src/PhpValueObjects/Tests/Identity/Sha256ValueObjectTest.php 1 location