AbstractEnumTest::isShouldAllowToCallMethodsBasedOnConstantNames() - Code Metrics - Werkspot/Enum - Measure and Improve Code Quality continuously with Scrutinizer

isShouldAllowToCallMethodsBasedOnConstantNames() A
last analyzed 2017-12-11 13:19 UTC

↳ Parent: AbstractEnumTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	7
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	4
nc	1
nop	0

<?php

declare(strict_types=1);

namespace Werkspot\Enum\Tests;

use PHPUnit\Framework\TestCase;

final class AbstractEnumTest extends TestCase
{
    /**
     * @test
     */
    public function enum(): void
    {
        $a = TestEnum::get(TestEnum::A);
        $b = TestEnum::get(TestEnum::B);

        self::assertSame(TestEnum::A, $a->getValue());
        self::assertSame(TestEnum::B, $b->getValue());
        self::assertSame(TestEnum::A, (string) $a);
        self::assertSame(TestEnum::B, (string) $b);
    }

    /**
     * @test
     */
    public function null(): void
    {
        $nullEnum = TestEnum::get(null);
        self::assertNull($nullEnum->getValue());
        self::assertSame('', (string) $nullEnum);
    }

    /**
     * @test
     */
    public function integer(): void
    {
        $integerEnum = TestEnum::get(3);
        self::assertSame(3, $integerEnum->getValue());
        self::assertSame('3', (string) $integerEnum);
    }

    /**
     * @test
     */
    public function isShouldReturnTrueWhenComparingObjectsWithTheSameTypeAndValue(): void
    {
        $a = TestEnum::get(TestEnum::A);

        self::assertTrue($a->isA());
    }

    /**
     * @test
     */
    public function isShouldReturnFalseWhenComparingObjectsWithTheSameTypeAndDifferentValue(): void
    {
        $a = TestEnum::get(TestEnum::A);

        self::assertFalse($a->isB());
    }

    /**
     * @test
     */
    public function equalsShouldReturnTrueWhenComparingObjectsWithTheSameTypeAndValue(): void
    {
        $a = TestEnum::get(TestEnum::A);

        self::assertTrue($a->equals(TestEnum::get(TestEnum::A)));
    }

    /**
     * @test
     */
    public function equalsShouldReturnFalseWhenComparingObjectsWithTheSameTypeButDifferentValue(): void
    {
        $a = TestEnum::get(TestEnum::A);

        self::assertFalse($a->equals(TestEnum::get(TestEnum::B)));
    }

    /**
     * @test
     */
    public function equalsShouldReturnFalseWhenComparingObjectsWithTheSameValueButDifferentType(): void
    {
        $a = TestEnum::get(TestEnum::A);

        self::assertFalse($a->equals(Test2Enum::get(Test2Enum::A)));
    }

    /**
     * @test
     */
    public function equalsShouldReturnTrueWhenComparingObjectsWithDifferentTypeAndValue(): void
    {
        $a = TestEnum::get(TestEnum::A);

        self::assertFalse($a->equals(Test2Enum::get(Test2Enum::C)));
    }

    /**
     * @test
     *
     * @expectedException \InvalidArgumentException
     * @expectedExceptionMessage Value [anything] is not matching any valid value of class "TestEnum". Valid values are ['A', 'BEE', 1, 3, NULL, true].
     */
    public function exceptionMessage(): void
    {
        TestEnum::get('anything');
    }

    /**
     * @test
     *
     * @dataProvider getInvertedCaseOptions
     * @expectedException \InvalidArgumentException
     *
     * @param mixed $option
     */
    public function getWithInvertedCaseIsIncorrect($option): void
    {
        TestEnum::get($option);
    }

    public function getInvertedCaseOptions()
    {
        return [
            [strtolower(TestEnum::A)],
            [strtolower(TestEnum::B)],
        ];
    }

    /**
     * @test
     *
     * @expectedException \InvalidArgumentException
     */
    public function getWithStrictEqualMatchThrowsException(): void
    {
        TestEnum::get('1');
    }


    /**
     * @test
     */
    public function isShouldAllowToCallMethodsBasedOnConstantNames(): void
    {
        $enum = TestEnum::nameWithUnderscore();

        self::assertInstanceOf(TestEnum::class, $enum);
        self::assertSame(TestEnum::NAME_WITH_UNDERSCORE, $enum->getValue());
    }

    /**
     * @test
     *
     * @expectedException \BadMethodCallException
     * @expectedExceptionMessage Werkspot\Enum\Tests\TestEnum::isDoesNotExist() does not exist
     */
    public function isShouldThrowAnExceptionWhenWhenCallingAnInvalidMethod(): void
    {
        $enum = TestEnum::a();
        $enum->isDoesNotExist();
    }

    /**
     * @test
     *
     * @expectedException \BadMethodCallException
     * @expectedExceptionMessage Werkspot\Enum\Tests\TestEnum::doesNotExist() does not exist
     */
    public function shouldThrowAnExceptionWhenWhenCallingAnInvalidStaticMethod(): void
    {
        TestEnum::doesNotExist();
    }

    /**
     * @test
     */
    public function getValidOptions(): void
    {
        self::assertSame(
            [
                TestEnum::A,
                TestEnum::B,
                TestEnum::A1,
                TestEnum::A3,
                TestEnum::ANULL,
                TestEnum::NAME_WITH_UNDERSCORE,
            ],
            TestEnum::getValidOptions()
        );
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Werkspot\Enum\Tests;
6
7			use PHPUnit\Framework\TestCase;
8
9			final class AbstractEnumTest extends TestCase
10			{
11			/**
12			* @test
13			*/
14			public function enum(): void
15			{
16			$a = TestEnum::get(TestEnum::A);
17			$b = TestEnum::get(TestEnum::B);
18
19			self::assertSame(TestEnum::A, $a->getValue());
20			self::assertSame(TestEnum::B, $b->getValue());
21			self::assertSame(TestEnum::A, (string) $a);
22			self::assertSame(TestEnum::B, (string) $b);
23			}
24
25			/**
26			* @test
27			*/
28			public function null(): void
29			{
30			$nullEnum = TestEnum::get(null);
31			self::assertNull($nullEnum->getValue());
32			self::assertSame('', (string) $nullEnum);
33			}
34
35			/**
36			* @test
37			*/
38			public function integer(): void
39			{
40			$integerEnum = TestEnum::get(3);
41			self::assertSame(3, $integerEnum->getValue());
42			self::assertSame('3', (string) $integerEnum);
43			}
44
45			/**
46			* @test
47			*/
48			public function isShouldReturnTrueWhenComparingObjectsWithTheSameTypeAndValue(): void
49			{
50			$a = TestEnum::get(TestEnum::A);
51
52			self::assertTrue($a->isA());
53			}
54
55			/**
56			* @test
57			*/
58			public function isShouldReturnFalseWhenComparingObjectsWithTheSameTypeAndDifferentValue(): void
59			{
60			$a = TestEnum::get(TestEnum::A);
61
62			self::assertFalse($a->isB());
63			}
64
65			/**
66			* @test
67			*/
68			public function equalsShouldReturnTrueWhenComparingObjectsWithTheSameTypeAndValue(): void
69			{
70			$a = TestEnum::get(TestEnum::A);
71
72			self::assertTrue($a->equals(TestEnum::get(TestEnum::A)));
73			}
74
75			/**
76			* @test
77			*/
78			public function equalsShouldReturnFalseWhenComparingObjectsWithTheSameTypeButDifferentValue(): void
79			{
80			$a = TestEnum::get(TestEnum::A);
81
82			self::assertFalse($a->equals(TestEnum::get(TestEnum::B)));
83			}
84
85			/**
86			* @test
87			*/
88			public function equalsShouldReturnFalseWhenComparingObjectsWithTheSameValueButDifferentType(): void
89			{
90			$a = TestEnum::get(TestEnum::A);
91
92			self::assertFalse($a->equals(Test2Enum::get(Test2Enum::A)));
93			}
94
95			/**
96			* @test
97			*/
98			public function equalsShouldReturnTrueWhenComparingObjectsWithDifferentTypeAndValue(): void
99			{
100			$a = TestEnum::get(TestEnum::A);
101
102			self::assertFalse($a->equals(Test2Enum::get(Test2Enum::C)));
103			}
104
105			/**
106			* @test
107			*
108			* @expectedException \InvalidArgumentException
109			* @expectedExceptionMessage Value [anything] is not matching any valid value of class "TestEnum". Valid values are ['A', 'BEE', 1, 3, NULL, true].
110			*/
111			public function exceptionMessage(): void
112			{
113			TestEnum::get('anything');
114			}
115
116			/**
117			* @test
118			*
119			* @dataProvider getInvertedCaseOptions
120			* @expectedException \InvalidArgumentException
121			*
122			* @param mixed $option
123			*/
124			public function getWithInvertedCaseIsIncorrect($option): void
125			{
126			TestEnum::get($option);
127			}
128
129			public function getInvertedCaseOptions()
130			{
131			return [
132			[strtolower(TestEnum::A)],
133			[strtolower(TestEnum::B)],
134			];
135			}
136
137			/**
138			* @test
139			*
140			* @expectedException \InvalidArgumentException
141			*/
142			public function getWithStrictEqualMatchThrowsException(): void
143			{
144			TestEnum::get('1');
145			}
146
147
148			/**
149			* @test
150			*/
151			public function isShouldAllowToCallMethodsBasedOnConstantNames(): void
152			{
153			$enum = TestEnum::nameWithUnderscore();
154
155			self::assertInstanceOf(TestEnum::class, $enum);
156			self::assertSame(TestEnum::NAME_WITH_UNDERSCORE, $enum->getValue());
157			}
158
159			/**
160			* @test
161			*
162			* @expectedException \BadMethodCallException
163			* @expectedExceptionMessage Werkspot\Enum\Tests\TestEnum::isDoesNotExist() does not exist
164			*/
165			public function isShouldThrowAnExceptionWhenWhenCallingAnInvalidMethod(): void
166			{
167			$enum = TestEnum::a();
168			$enum->isDoesNotExist();
169			}
170
171			/**
172			* @test
173			*
174			* @expectedException \BadMethodCallException
175			* @expectedExceptionMessage Werkspot\Enum\Tests\TestEnum::doesNotExist() does not exist
176			*/
177			public function shouldThrowAnExceptionWhenWhenCallingAnInvalidStaticMethod(): void
178			{
179			TestEnum::doesNotExist();
180			}
181
182			/**
183			* @test
184			*/
185			public function getValidOptions(): void
186			{
187			self::assertSame(
188			[
189			TestEnum::A,
190			TestEnum::B,
191			TestEnum::A1,
192			TestEnum::A3,
193			TestEnum::ANULL,
194			TestEnum::NAME_WITH_UNDERSCORE,
195			],
196			TestEnum::getValidOptions()
197			);
198			}
199			}
200

Werkspot / Enum

isShouldAllowToCallMethodsBasedOnConstantNames() A last analyzed 2017-12-11 13:19 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

isShouldAllowToCallMethodsBasedOnConstantNames() A
last analyzed 2017-12-11 13:19 UTC