ValidationResultTest::testSuccess() - Code Metrics - Inspection of "Fix sending coverage to scrutinizer" - jasny/validation-result - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( a71273...1706ff )

by Arnold

created 2024-09-03 20:42 UTC

ValidationResultTest::testSuccess() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

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

<?php

namespace Jasny\Tests;

use Jasny\PHPUnit\CallbackMockTrait;
use Jasny\PHPUnit\ConsecutiveTrait;
use Jasny\PHPUnit\ExpectWarningTrait;
use Jasny\ValidationException;
use Jasny\ValidationResult;
use PHPUnit\Framework\Attributes\BackupStaticProperties;
use PHPUnit\Framework\Attributes\CoversClass;
use PHPUnit\Framework\MockObject\Builder\InvocationMocker;
use PHPUnit\Framework\TestCase;

#[BackupStaticProperties(true)]
#[CoversClass(ValidationResult::class)]
class ValidationResultTest extends TestCase
{
    use CallbackMockTrait;
    use ConsecutiveTrait;
    use ExpectWarningTrait;

    public function tearDown(): void
    {
        ValidationResult::$translate = null;
    }

    public function testAddError(): void
    {
        $validation = new ValidationResult();
        $validation->addError("Test");

        $this->assertEquals(["Test"], $validation->getErrors());
    }

    public function testAddErrorMultiple(): void
    {
        $validation = new ValidationResult();
        $validation->addError("Foo");
        $validation->addError("Bar");

        $this->assertEquals(["Foo", "Bar"], $validation->getErrors());
    }

    public function testAddErrorWithArgs(): void
    {
        $validation = new ValidationResult();
        $validation->addError("Colors %s and %s for %03d", "red", "blue", 20);

        $this->assertEquals(["Colors red and blue for 020"], $validation->getErrors());
    }


    public function testAdd(): void
    {
        $validation = new ValidationResult();
        $validation->addError("Qux");

        $error = new ValidationResult();
        $error->addError("Foo");
        $error->addError("Bar");

        $validation->add($error);

        $this->assertEquals(["Qux", "Foo", "Bar"], $validation->getErrors());
    }

    public function testAddWithPrefix(): void
    {
        $validation = new ValidationResult();
        $validation->addError("Qux");

        $error = new ValidationResult();
        $error->addError("Foo");
        $error->addError("Bar");

        $validation->add($error, "bad");

        $this->assertEquals(["Qux", "bad Foo", "bad Bar"], $validation->getErrors());
    }


    public function testTranslate(): void
    {
        $translator = $this->createCallbackMock($this->exactly(2), function (InvocationMocker $invoke) {
            $invoke
                ->with(...$this->consecutive(['Foo'], ['Bar']))
                ->willReturnOnConsecutiveCalls('Red', 'Blue');
        });

        ValidationResult::$translate = $translator;

        $validation = new ValidationResult();
        $validation->addError("Foo");
        $validation->addError("Bar");

        $this->assertEquals(["Red", "Blue"], $validation->getErrors());
    }

    public function testTranslatePrefix(): void
    {
        $translator = $this->createCallbackMock($this->exactly(2), function (InvocationMocker $invoke) {
            $invoke
                ->with(...$this->consecutive(['Color %s'], ['error']))
                ->willReturnOnConsecutiveCalls('Colour %s', 'fault');
        });

        ValidationResult::$translate = $translator;

        $error = new ValidationResult();
        $error->addError("Color %s", "red");

        $validation = new ValidationResult();
        $validation->add($error, "error");

        $this->assertEquals(["fault Colour red"], $validation->getErrors());
    }


    public function testSucceeded(): void
    {
        $validation = new ValidationResult();
        $this->assertTrue($validation->succeeded());
        $this->assertTrue($validation->isSuccess(), 'alias');

        $validation->addError("Test");
        $this->assertFalse($validation->succeeded());
        $this->assertFalse($validation->isSuccess(), 'alias');
    }

    public function testFailed(): void
    {
        $validation = new ValidationResult();
        $this->assertFalse($validation->failed());

        $validation->addError("Test");
        $this->assertTrue($validation->failed());
    }


    public function testGetError(): void
    {
        $validation = new ValidationResult();
        $validation->addError("Foo");

        $this->assertEquals("Foo", $validation->getError());
    }

    public function testGetErrorWithMultiple(): void
    {
        $this->expectNoticeMessage("There are multiple errors, returning only the first");

        $validation = new ValidationResult();
        $validation->addError("Foo");
        $validation->addError("Bar");

        $validation->getError();
    }

    public function testMustSucceedForSuccess(): void
    {
        $validation = new ValidationResult();
        $validation->mustSucceed();

        $this->assertTrue(true, 'No exception was thrown');
    }

    public function testMustSucceedForFailed(): void
    {
        $validation = new ValidationResult();
        $validation->addError("Foo");

        try {
            $validation->mustSucceed();
        } catch (ValidationException $exception) {
            $this->assertSame($validation, $exception->getValidationResult());
            return;
        }

        $this->fail("No validation exception was thrown");
    }


    public function testSuccess(): void
    {
        $validation = ValidationResult::success();

        $this->assertInstanceOf(ValidationResult::class, $validation);
        $this->assertEquals([], $validation->getErrors());
    }

    public function testError(): void
    {
        $validation = ValidationResult::error("Foo");

        $this->assertInstanceOf(ValidationResult::class, $validation);
        $this->assertEquals(["Foo"], $validation->getErrors());
    }

    public function testErrorWithArgs(): void
    {
        $validation = ValidationResult::error("Colors %s and %s for %03d", "red", "blue", 20);

        $this->assertInstanceOf(ValidationResult::class, $validation);
        $this->assertEquals(["Colors red and blue for 020"], $validation->getErrors());
    }
}


1			<?php
2
3			namespace Jasny\Tests;
4
5			use Jasny\PHPUnit\CallbackMockTrait;
6			use Jasny\PHPUnit\ConsecutiveTrait;
7			use Jasny\PHPUnit\ExpectWarningTrait;
8			use Jasny\ValidationException;
9			use Jasny\ValidationResult;
10			use PHPUnit\Framework\Attributes\BackupStaticProperties;
11			use PHPUnit\Framework\Attributes\CoversClass;
12			use PHPUnit\Framework\MockObject\Builder\InvocationMocker;
13			use PHPUnit\Framework\TestCase;
14
15			#[BackupStaticProperties(true)]
16			#[CoversClass(ValidationResult::class)]
17			class ValidationResultTest extends TestCase
18			{
19			use CallbackMockTrait;
20			use ConsecutiveTrait;
21			use ExpectWarningTrait;
22
23			public function tearDown(): void
24			{
25			ValidationResult::$translate = null;
26			}
27
28			public function testAddError(): void
29			{
30			$validation = new ValidationResult();
31			$validation->addError("Test");
32
33			$this->assertEquals(["Test"], $validation->getErrors());
34			}
35
36			public function testAddErrorMultiple(): void
37			{
38			$validation = new ValidationResult();
39			$validation->addError("Foo");
40			$validation->addError("Bar");
41
42			$this->assertEquals(["Foo", "Bar"], $validation->getErrors());
43			}
44
45			public function testAddErrorWithArgs(): void
46			{
47			$validation = new ValidationResult();
48			$validation->addError("Colors %s and %s for %03d", "red", "blue", 20);
49
50			$this->assertEquals(["Colors red and blue for 020"], $validation->getErrors());
51			}
52
53
54			public function testAdd(): void
55			{
56			$validation = new ValidationResult();
57			$validation->addError("Qux");
58
59			$error = new ValidationResult();
60			$error->addError("Foo");
61			$error->addError("Bar");
62
63			$validation->add($error);
64
65			$this->assertEquals(["Qux", "Foo", "Bar"], $validation->getErrors());
66			}
67
68			public function testAddWithPrefix(): void
69			{
70			$validation = new ValidationResult();
71			$validation->addError("Qux");
72
73			$error = new ValidationResult();
74			$error->addError("Foo");
75			$error->addError("Bar");
76
77			$validation->add($error, "bad");
78
79			$this->assertEquals(["Qux", "bad Foo", "bad Bar"], $validation->getErrors());
80			}
81
82
83			public function testTranslate(): void
84			{
85			$translator = $this->createCallbackMock($this->exactly(2), function (InvocationMocker $invoke) {
86			$invoke
87			->with(...$this->consecutive(['Foo'], ['Bar']))
88			->willReturnOnConsecutiveCalls('Red', 'Blue');
89			});
90
91			ValidationResult::$translate = $translator;
92
93			$validation = new ValidationResult();
94			$validation->addError("Foo");
95			$validation->addError("Bar");
96
97			$this->assertEquals(["Red", "Blue"], $validation->getErrors());
98			}
99
100			public function testTranslatePrefix(): void
101			{
102			$translator = $this->createCallbackMock($this->exactly(2), function (InvocationMocker $invoke) {
103			$invoke
104			->with(...$this->consecutive(['Color %s'], ['error']))
105			->willReturnOnConsecutiveCalls('Colour %s', 'fault');
106			});
107
108			ValidationResult::$translate = $translator;
109
110			$error = new ValidationResult();
111			$error->addError("Color %s", "red");
112
113			$validation = new ValidationResult();
114			$validation->add($error, "error");
115
116			$this->assertEquals(["fault Colour red"], $validation->getErrors());
117			}
118
119
120			public function testSucceeded(): void
121			{
122			$validation = new ValidationResult();
123			$this->assertTrue($validation->succeeded());
124			$this->assertTrue($validation->isSuccess(), 'alias');
125
126			$validation->addError("Test");
127			$this->assertFalse($validation->succeeded());
128			$this->assertFalse($validation->isSuccess(), 'alias');
129			}
130
131			public function testFailed(): void
132			{
133			$validation = new ValidationResult();
134			$this->assertFalse($validation->failed());
135
136			$validation->addError("Test");
137			$this->assertTrue($validation->failed());
138			}
139
140
141			public function testGetError(): void
142			{
143			$validation = new ValidationResult();
144			$validation->addError("Foo");
145
146			$this->assertEquals("Foo", $validation->getError());
147			}
148
149			public function testGetErrorWithMultiple(): void
150			{
151			$this->expectNoticeMessage("There are multiple errors, returning only the first");
152
153			$validation = new ValidationResult();
154			$validation->addError("Foo");
155			$validation->addError("Bar");
156
157			$validation->getError();
158			}
159
160			public function testMustSucceedForSuccess(): void
161			{
162			$validation = new ValidationResult();
163			$validation->mustSucceed();
164
165			$this->assertTrue(true, 'No exception was thrown');
166			}
167
168			public function testMustSucceedForFailed(): void
169			{
170			$validation = new ValidationResult();
171			$validation->addError("Foo");
172
173			try {
174			$validation->mustSucceed();
175			} catch (ValidationException $exception) {
176			$this->assertSame($validation, $exception->getValidationResult());
177			return;
178			}
179
180			$this->fail("No validation exception was thrown");
181			}
182
183
184			public function testSuccess(): void
185			{
186			$validation = ValidationResult::success();
187
188			$this->assertInstanceOf(ValidationResult::class, $validation);
189			$this->assertEquals([], $validation->getErrors());
190			}
191
192			public function testError(): void
193			{
194			$validation = ValidationResult::error("Foo");
195
196			$this->assertInstanceOf(ValidationResult::class, $validation);
197			$this->assertEquals(["Foo"], $validation->getErrors());
198			}
199
200			public function testErrorWithArgs(): void
201			{
202			$validation = ValidationResult::error("Colors %s and %s for %03d", "red", "blue", 20);
203
204			$this->assertInstanceOf(ValidationResult::class, $validation);
205			$this->assertEquals(["Colors red and blue for 020"], $validation->getErrors());
206			}
207			}
208

jasny / validation-result

Push — master ( a71273...1706ff )

ValidationResultTest::testSuccess() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like