FlashMessageTest::test_delay_method_with_invalid_argument() - Code Metrics - Inspection of "Fix/increase test coverage #6" - coderello/laraflash - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#9)

by Mathías

created 2018-10-03 07:58 UTC

test_delay_method_with_invalid_argument() A

↳ Parent: FlashMessageTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	3
dl	0
loc	6
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Coderello\Laraflash\Tests;

use Coderello\Laraflash\FlashMessage;
use Coderello\Laraflash\Exceptions\InvalidDelayException;
use Coderello\Laraflash\Exceptions\InvalidArgumentException;
use Coderello\Laraflash\Exceptions\InvalidHopsAmountException;
use Coderello\Laraflash\Contracts\FlashMessage as FlashMessageContract;

class FlashMessageTest extends AbstractTestCase
{
    public function test_implements_contract()
    {
        $this->assertTrue(new FlashMessage instanceof FlashMessageContract);
    }

    public function test_initial_state()
    {
        $message = new FlashMessage();
        $messageValues = $message->toArray();

        $this->assertEquals(null, $messageValues['title']);
        $this->assertEquals(null, $messageValues['content']);
        $this->assertEquals(null, $messageValues['type']);
        $this->assertEquals(1, $messageValues['hops']);
        $this->assertEquals(1, $messageValues['delay']);
        $this->assertEquals(false, $messageValues['important']);
    }

    public function test_title_method()
    {
        $message = new FlashMessage();
        $message->title('hello');
        $messageValues = $message->toArray();

        $this->assertEquals('hello', $messageValues['title']);
    }

    public function test_content_method()
    {
        $message = new FlashMessage();
        $message->content('hello');
        $messageValues = $message->toArray();

        $this->assertEquals('hello', $messageValues['content']);
    }

    public function test_type_method()
    {
        $message = new FlashMessage();
        $message->type('hello');
        $messageValues = $message->toArray();

        $this->assertEquals('hello', $messageValues['type']);
    }

    public function test_hops_method()
    {
        $message = new FlashMessage();
        $message->hops(2);
        $messageValues = $message->toArray();

        $this->assertEquals(2, $messageValues['hops']);
    }

    public function test_hops_method_with_invalid_argument()
    {
        $this->expectException(InvalidHopsAmountException::class);

        $message = new FlashMessage();
        $message->hops(-1);
    }

    public function test_delay_method()
    {
        $message = new FlashMessage();
        $message->delay(4);
        $messageValues = $message->toArray();

        $this->assertEquals(4, $messageValues['delay']);
    }

    public function test_delay_method_with_invalid_argument()
    {
        $this->expectException(InvalidDelayException::class);

        $message = new FlashMessage();
        $message->delay(-1);
    }

    public function test_important_method()
    {
        $message = new FlashMessage();

        $message->important();

        $this->assertEquals(true, $message['important']);

        $message->important(false);

        $this->assertEquals(false, $message['important']);

        $message->important(true);

        $this->assertEquals(true, $message['important']);
    }

    public function test_now_method()
    {
        $message = new FlashMessage();
        $message->delay(5)->now();
        $messageValues = $message->toArray();

        $this->assertEquals(0, $messageValues['delay']);
    }

    public function test_keep_method()
    {
        $message = new FlashMessage();
        $message->hops(3)->keep();
        $messageValues = $message->toArray();

        $this->assertEquals(4, $messageValues['hops']);
    }

    public function test_to_array_method()
    {
        $message = new FlashMessage();
        $message->title('hello')
            ->content('world')
            ->type('info')
            ->hops(5)
            ->delay(3)
            ->important();

        $this->assertEquals([
            'title' => 'hello',
            'content' => 'world',
            'type' => 'info',
            'hops' => 5,
            'delay' => 3,
            'important' => true,
        ], $message->toArray());
    }

    public function test_offset_exists_method()
    {
        $message = new FlashMessage();

        $this->assertTrue($message->offsetExists('title'));
        $this->assertTrue($message->offsetExists('content'));
        $this->assertTrue($message->offsetExists('type'));
        $this->assertTrue($message->offsetExists('hops'));
        $this->assertTrue($message->offsetExists('delay'));
        $this->assertFalse($message->offsetExists('fail'));
    }

    public function test_offset_get_method()
    {
        $message = new FlashMessage();

        $message->title('hello');

        $this->assertEquals('hello', $message['title']);
    }

    public function test_offset_get_method_with_invalid_argument()
    {
        $message = new FlashMessage();

        $this->expectException(InvalidArgumentException::class);

        $message->offsetGet('whoops');
    }

    public function test_offset_set_method()
    {
        $message = new FlashMessage();

        $message->offsetSet('title', 'it works');

        $this->assertEquals('it works', $message['title']);
    }

    public function test_offset_set_method_with_invalid_argument()
    {
        $message = new FlashMessage();

        $this->expectException(InvalidArgumentException::class);

        $message->offsetSet('whoops', 'some value');
    }

    public function test_offset_unset_method_does_not_affect_message()
    {
        $message = new FlashMessage();

        $message->title('hello');

        $messageValues = $message->toArray();

        unset($message['title']);

        $this->assertSame($messageValues, $message->toArray());
    }

    public function test_json_serialize_method()
    {
        $message = new FlashMessage();

        $message->title('hello');

        $response = $message->jsonSerialize();

        $this->assertEquals('hello', $response['title']);
    }

    public function test_to_json_method()
    {
        $message = new FlashMessage();

        $message->title('hello');

        $response = $message->toJson();

        $this->assertEquals('hello', json_decode($response)->title);
    }

    public function test_render_method()
    {
        $message = new FlashMessage();

        $message->title('hello');

        $message->type('hello');

        $message->content('hello');

        try {
            $this->assertEquals(
                view(config('laraflash.skin'), [
                    'title' => 'hello',
                    'type' => 'hello',
                    'content' => 'hello',
                ])->render(),
                $message->render()
            );
        } catch (\Throwable $e) {

        }
    }
}


1			<?php
2
3			namespace Coderello\Laraflash\Tests;
4
5			use Coderello\Laraflash\FlashMessage;
6			use Coderello\Laraflash\Exceptions\InvalidDelayException;
7			use Coderello\Laraflash\Exceptions\InvalidArgumentException;
8			use Coderello\Laraflash\Exceptions\InvalidHopsAmountException;
9			use Coderello\Laraflash\Contracts\FlashMessage as FlashMessageContract;
10
11			class FlashMessageTest extends AbstractTestCase
12			{
13			public function test_implements_contract()
14			{
15			$this->assertTrue(new FlashMessage instanceof FlashMessageContract);
16			}
17
18			public function test_initial_state()
19			{
20			$message = new FlashMessage();
21			$messageValues = $message->toArray();
22
23			$this->assertEquals(null, $messageValues['title']);
24			$this->assertEquals(null, $messageValues['content']);
25			$this->assertEquals(null, $messageValues['type']);
26			$this->assertEquals(1, $messageValues['hops']);
27			$this->assertEquals(1, $messageValues['delay']);
28			$this->assertEquals(false, $messageValues['important']);
29			}
30
31			public function test_title_method()
32			{
33			$message = new FlashMessage();
34			$message->title('hello');
35			$messageValues = $message->toArray();
36
37			$this->assertEquals('hello', $messageValues['title']);
38			}
39
40			public function test_content_method()
41			{
42			$message = new FlashMessage();
43			$message->content('hello');
44			$messageValues = $message->toArray();
45
46			$this->assertEquals('hello', $messageValues['content']);
47			}
48
49			public function test_type_method()
50			{
51			$message = new FlashMessage();
52			$message->type('hello');
53			$messageValues = $message->toArray();
54
55			$this->assertEquals('hello', $messageValues['type']);
56			}
57
58			public function test_hops_method()
59			{
60			$message = new FlashMessage();
61			$message->hops(2);
62			$messageValues = $message->toArray();
63
64			$this->assertEquals(2, $messageValues['hops']);
65			}
66
67			public function test_hops_method_with_invalid_argument()
68			{
69			$this->expectException(InvalidHopsAmountException::class);
70
71			$message = new FlashMessage();
72			$message->hops(-1);
73			}
74
75			public function test_delay_method()
76			{
77			$message = new FlashMessage();
78			$message->delay(4);
79			$messageValues = $message->toArray();
80
81			$this->assertEquals(4, $messageValues['delay']);
82			}
83
84			public function test_delay_method_with_invalid_argument()
85			{
86			$this->expectException(InvalidDelayException::class);
87
88			$message = new FlashMessage();
89			$message->delay(-1);
90			}
91
92			public function test_important_method()
93			{
94			$message = new FlashMessage();
95
96			$message->important();
97
98			$this->assertEquals(true, $message['important']);
99
100			$message->important(false);
101
102			$this->assertEquals(false, $message['important']);
103
104			$message->important(true);
105
106			$this->assertEquals(true, $message['important']);
107			}
108
109			public function test_now_method()
110			{
111			$message = new FlashMessage();
112			$message->delay(5)->now();
113			$messageValues = $message->toArray();
114
115			$this->assertEquals(0, $messageValues['delay']);
116			}
117
118			public function test_keep_method()
119			{
120			$message = new FlashMessage();
121			$message->hops(3)->keep();
122			$messageValues = $message->toArray();
123
124			$this->assertEquals(4, $messageValues['hops']);
125			}
126
127			public function test_to_array_method()
128			{
129			$message = new FlashMessage();
130			$message->title('hello')
131			->content('world')
132			->type('info')
133			->hops(5)
134			->delay(3)
135			->important();
136
137			$this->assertEquals([
138			'title' => 'hello',
139			'content' => 'world',
140			'type' => 'info',
141			'hops' => 5,
142			'delay' => 3,
143			'important' => true,
144			], $message->toArray());
145			}
146
147			public function test_offset_exists_method()
148			{
149			$message = new FlashMessage();
150
151			$this->assertTrue($message->offsetExists('title'));
152			$this->assertTrue($message->offsetExists('content'));
153			$this->assertTrue($message->offsetExists('type'));
154			$this->assertTrue($message->offsetExists('hops'));
155			$this->assertTrue($message->offsetExists('delay'));
156			$this->assertFalse($message->offsetExists('fail'));
157			}
158
159			public function test_offset_get_method()
160			{
161			$message = new FlashMessage();
162
163			$message->title('hello');
164
165			$this->assertEquals('hello', $message['title']);
166			}
167
168			public function test_offset_get_method_with_invalid_argument()
169			{
170			$message = new FlashMessage();
171
172			$this->expectException(InvalidArgumentException::class);
173
174			$message->offsetGet('whoops');
175			}
176
177			public function test_offset_set_method()
178			{
179			$message = new FlashMessage();
180
181			$message->offsetSet('title', 'it works');
182
183			$this->assertEquals('it works', $message['title']);
184			}
185
186			public function test_offset_set_method_with_invalid_argument()
187			{
188			$message = new FlashMessage();
189
190			$this->expectException(InvalidArgumentException::class);
191
192			$message->offsetSet('whoops', 'some value');
193			}
194
195			public function test_offset_unset_method_does_not_affect_message()
196			{
197			$message = new FlashMessage();
198
199			$message->title('hello');
200
201			$messageValues = $message->toArray();
202
203			unset($message['title']);
204
205			$this->assertSame($messageValues, $message->toArray());
206			}
207
208			public function test_json_serialize_method()
209			{
210			$message = new FlashMessage();
211
212			$message->title('hello');
213
214			$response = $message->jsonSerialize();
215
216			$this->assertEquals('hello', $response['title']);
217			}
218
219			public function test_to_json_method()
220			{
221			$message = new FlashMessage();
222
223			$message->title('hello');
224
225			$response = $message->toJson();
226
227			$this->assertEquals('hello', json_decode($response)->title);
228			}
229
230			public function test_render_method()
231			{
232			$message = new FlashMessage();
233
234			$message->title('hello');
235
236			$message->type('hello');
237
238			$message->content('hello');
239
240			try {
241			$this->assertEquals(
242			view(config('laraflash.skin'), [
243			'title' => 'hello',
244			'type' => 'hello',
245			'content' => 'hello',
246			])->render(),
247			$message->render()
248			);
249			} catch (\Throwable $e) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2018-10-03 07:49 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
250			}
251			}
252			}
253

coderello / laraflash

Pull Request — master (#9)

test_delay_method_with_invalid_argument() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like