EmployeeControllerTest::testMustInactiveAnEmployee() - Code Metrics - guastallaigor/laravel-backoffice-example - Measure and Improve Code Quality continuously with Scrutinizer

testMustInactiveAnEmployee() A
last analyzed 2019-12-03 11:10 UTC

↳ Parent: EmployeeControllerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	23
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	10
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	23
rs	9.9332

<?php

namespace Tests\Feature;

use App\Models\Employee;
use Tests\AuthenticatedTestCase;
use Illuminate\Foundation\Testing\DatabaseMigrations;

class EmployeeControllerTest extends AuthenticatedTestCase
{
    use DatabaseMigrations;

    /**
     * @var string $endpoint
     */
    private $endpoint = 'api/v1/backoffice/employee/';

    public function testResourceShowMethodMustReturnAnEmployeeData()
    {
        // We create 10 employees
        $employees = factory(Employee::class, 10)->create();
        $first = $employees->first();

        // When we request the first one
        $response = $this->json('GET', $this->endpoint.$first->id);

        // It should return a valid, one employee json
        $response
            ->assertStatus(200)
            ->assertJson($this->jsonEmployeeStructure($first));
    }

    public function testResourceIndexMethodMustReturnAnEmployeeList()
    {
        // We create 10 employees
        factory(Employee::class, 10)->create();

        // When we request the all of the employees
        $response = $this->json('GET', $this->endpoint);

        // It should return a valid, pagination employee json
        $response
            ->assertStatus(200)
            ->assertJsonStructure([
                'current_page',
                'data' => [
                    '*' => [
                        'id',
                        'full_name',
                        'br_cpf',
                        'email',
                        'telephone_type',
                        'telephone',
                        'zip_code',
                        'city',
                        'state',
                        'avenue',
                        'number',
                        'neighborhood',
                        'complement',
                        'active',
                        'updated_at',
                        'created_at',
                    ],
                ],
                'first_page_url',
                'from',
                'last_page',
                'last_page_url',
                'next_page_url',
                'path',
                'per_page',
                'prev_page_url',
                'to',
                'total',
            ]);
    }

    public function testMustCreateANewEmployee()
    {
        // We create one new employee and save it on the database
        $employee = factory(Employee::class)->create();

        // We create one new employee on memory
        $newEmployee = factory(Employee::class)->make()->toArray();

        // Find the last employee
        $findedEmployee = Employee::find($employee->id);
        $id = $findedEmployee ? $findedEmployee->id + 1 : 1;

        // When we save this new employee
        $newEmployee[ 'password' ] = 'teste123';
        $newEmployee[ 'password_confirmation' ] = 'teste123';
        $newEmployee[ 'active' ] = true;
        $response = $this->json('POST', $this->endpoint, $newEmployee);

        // It should return this valid json employee
        $response
            ->assertStatus(201)
            ->assertJson([
                'id' => $id,
                'full_name' => $newEmployee[ 'full_name' ],
                'br_cpf' => $newEmployee[ 'br_cpf' ],
                'email' => $newEmployee[ 'email' ],
                'telephone_type' => $newEmployee[ 'telephone_type' ],
                'telephone' => $newEmployee[ 'telephone' ],
                'zip_code' => $newEmployee[ 'zip_code' ],
                'city' => $newEmployee[ 'city' ],
                'state' => $newEmployee[ 'state' ],
                'avenue' => $newEmployee[ 'avenue' ],
                'number' => $newEmployee[ 'number' ],
                'neighborhood' => $newEmployee[ 'neighborhood' ],
                'complement' => $newEmployee[ 'complement' ],
                'active' => $newEmployee[ 'active' ],
            ])
            ->assertJsonStructure([
                'updated_at',
                'created_at',
            ]);
    }

    public function testUpdateAnEmployee()
    {
        // We create one new employee and save it on the database
        $employee = factory(Employee::class)->create();

        // We create one new employee on memory
        $employeeModified = factory(Employee::class)->make()->toArray();
        $employeeModified[ 'password' ] = 'teste123';
        $employeeModified[ 'password_confirmation' ] = 'teste123';

        // When we edit this employee
        $uri = $this->endpoint.$employee->id;
        $response = $this->json('PUT', $uri, $employeeModified);

        // And find the employee edited in the database
        $findedEmployee = Employee::find($employee->id)->toArray();

        // It should return this valid json employee, with the full_name changed
        $response
            ->assertStatus(200)
            ->assertJsonFragment($findedEmployee);
    }

    public function testMustDeleteAnEmployee()
    {
        // We create one new employee and save it on the database
        $employee = factory(Employee::class)->create();

        // When we delete this employee
        $uri = $this->endpoint.$employee->id;
        $response = $this->json('DELETE', $uri);

        // And then try to find it
        $employeeRemove = Employee::find($employee->id);

        // It should return nothing (null)
        $response->assertStatus(204);
        $this->assertEquals(null, $employeeRemove);
    }

    public function testMustActiveAnEmployee()
    {
        // We create one new employee and save it on the database
        $employee = factory(Employee::class)->create();

        // This employee is inactive
        $employee->active = false;

        // When we change this employee to active
        $uri = $this->endpoint.'active/'.$employee->id;
        $response = $this->json('POST', $uri);

        // And then try to find it
        $employeeChanged = Employee::find($employee->id);

        // It should this valid json employee, with active = true
        $response
            ->assertStatus(200)
            ->assertJsonFragment([
                'active' => true,
            ]);

        $this->assertEquals(true, $employeeChanged->active);
    }

    public function testMustInactiveAnEmployee()
    {
        // We create one new employee and save it on the database
        $employee = factory(Employee::class)->create();

        // This employee is active
        $employee->active = true;

        // When we change this employee to inactive
        $uri = $this->endpoint.'inactive/'.$employee->id;
        $response = $this->json('POST', $uri);

        // And then try to find it
        $employeeChanged = Employee::find($employee->id);

        // It should this valid json employee, with active = false
        $response
            ->assertStatus(200)
            ->assertJsonFragment([
                'active' => false,
            ]);

        $this->assertEquals(false, $employeeChanged->active);
    }

    private function jsonEmployeeStructure($employee)
    {
        return [
            'id' => $employee->id,
            'full_name' => $employee->full_name,
            'br_cpf' => $employee->br_cpf,
            'email' => $employee->email,
            'telephone_type' => $employee->telephone_type,
            'telephone' => $employee->telephone,
            'zip_code' => $employee->zip_code,
            'city' => $employee->city,
            'state' => $employee->state,
            'avenue' => $employee->avenue,
            'number' => $employee->number,
            'neighborhood' => $employee->neighborhood,
            'complement' => $employee->complement,
            'active' => $employee->active,
            'updated_at' => $employee->updated_at,
            'created_at' => $employee->created_at,
        ];
    }
}


1			<?php
2
3			namespace Tests\Feature;
4
5			use App\Models\Employee;
6			use Tests\AuthenticatedTestCase;
7			use Illuminate\Foundation\Testing\DatabaseMigrations;
8
9			class EmployeeControllerTest extends AuthenticatedTestCase
10			{
11			use DatabaseMigrations;
12
13			/**
14			* @var string $endpoint
15			*/
16			private $endpoint = 'api/v1/backoffice/employee/';
17
18			public function testResourceShowMethodMustReturnAnEmployeeData()
19			{
20			// We create 10 employees
21			$employees = factory(Employee::class, 10)->create();
22			$first = $employees->first();
23
24			// When we request the first one
25			$response = $this->json('GET', $this->endpoint.$first->id);
26
27			// It should return a valid, one employee json
28			$response
29			->assertStatus(200)
30			->assertJson($this->jsonEmployeeStructure($first));
31			}
32
33			public function testResourceIndexMethodMustReturnAnEmployeeList()
34			{
35			// We create 10 employees
36			factory(Employee::class, 10)->create();
37
38			// When we request the all of the employees
39			$response = $this->json('GET', $this->endpoint);
40
41			// It should return a valid, pagination employee json
42			$response
43			->assertStatus(200)
44			->assertJsonStructure([
45			'current_page',
46			'data' => [
47			'*' => [
48			'id',
49			'full_name',
50			'br_cpf',
51			'email',
52			'telephone_type',
53			'telephone',
54			'zip_code',
55			'city',
56			'state',
57			'avenue',
58			'number',
59			'neighborhood',
60			'complement',
61			'active',
62			'updated_at',
63			'created_at',
64			],
65			],
66			'first_page_url',
67			'from',
68			'last_page',
69			'last_page_url',
70			'next_page_url',
71			'path',
72			'per_page',
73			'prev_page_url',
74			'to',
75			'total',
76			]);
77			}
78
79			public function testMustCreateANewEmployee()
80			{
81			// We create one new employee and save it on the database
82			$employee = factory(Employee::class)->create();
83
84			// We create one new employee on memory
85			$newEmployee = factory(Employee::class)->make()->toArray();
86
87			// Find the last employee
88			$findedEmployee = Employee::find($employee->id);
89			$id = $findedEmployee ? $findedEmployee->id + 1 : 1;
90
91			// When we save this new employee
92			$newEmployee[ 'password' ] = 'teste123';
93			$newEmployee[ 'password_confirmation' ] = 'teste123';
94			$newEmployee[ 'active' ] = true;
95			$response = $this->json('POST', $this->endpoint, $newEmployee);
96
97			// It should return this valid json employee
98			$response
99			->assertStatus(201)
100			->assertJson([
101			'id' => $id,
102			'full_name' => $newEmployee[ 'full_name' ],
103			'br_cpf' => $newEmployee[ 'br_cpf' ],
104			'email' => $newEmployee[ 'email' ],
105			'telephone_type' => $newEmployee[ 'telephone_type' ],
106			'telephone' => $newEmployee[ 'telephone' ],
107			'zip_code' => $newEmployee[ 'zip_code' ],
108			'city' => $newEmployee[ 'city' ],
109			'state' => $newEmployee[ 'state' ],
110			'avenue' => $newEmployee[ 'avenue' ],
111			'number' => $newEmployee[ 'number' ],
112			'neighborhood' => $newEmployee[ 'neighborhood' ],
113			'complement' => $newEmployee[ 'complement' ],
114			'active' => $newEmployee[ 'active' ],
115			])
116			->assertJsonStructure([
117			'updated_at',
118			'created_at',
119			]);
120			}
121
122			public function testUpdateAnEmployee()
123			{
124			// We create one new employee and save it on the database
125			$employee = factory(Employee::class)->create();
126
127			// We create one new employee on memory
128			$employeeModified = factory(Employee::class)->make()->toArray();
129			$employeeModified[ 'password' ] = 'teste123';
130			$employeeModified[ 'password_confirmation' ] = 'teste123';
131
132			// When we edit this employee
133			$uri = $this->endpoint.$employee->id;
134			$response = $this->json('PUT', $uri, $employeeModified);
135
136			// And find the employee edited in the database
137			$findedEmployee = Employee::find($employee->id)->toArray();
138
139			// It should return this valid json employee, with the full_name changed
140			$response
141			->assertStatus(200)
142			->assertJsonFragment($findedEmployee);
143			}
144
145			public function testMustDeleteAnEmployee()
146			{
147			// We create one new employee and save it on the database
148			$employee = factory(Employee::class)->create();
149
150			// When we delete this employee
151			$uri = $this->endpoint.$employee->id;
152			$response = $this->json('DELETE', $uri);
153
154			// And then try to find it
155			$employeeRemove = Employee::find($employee->id);
156
157			// It should return nothing (null)
158			$response->assertStatus(204);
159			$this->assertEquals(null, $employeeRemove);
160			}
161
162			public function testMustActiveAnEmployee()
163			{
164			// We create one new employee and save it on the database
165			$employee = factory(Employee::class)->create();
166
167			// This employee is inactive
168			$employee->active = false;
169
170			// When we change this employee to active
171			$uri = $this->endpoint.'active/'.$employee->id;
172			$response = $this->json('POST', $uri);
173
174			// And then try to find it
175			$employeeChanged = Employee::find($employee->id);
176
177			// It should this valid json employee, with active = true
178			$response
179			->assertStatus(200)
180			->assertJsonFragment([
181			'active' => true,
182			]);
183
184			$this->assertEquals(true, $employeeChanged->active);
185			}
186
187			public function testMustInactiveAnEmployee()
188			{
189			// We create one new employee and save it on the database
190			$employee = factory(Employee::class)->create();
191
192			// This employee is active
193			$employee->active = true;
194
195			// When we change this employee to inactive
196			$uri = $this->endpoint.'inactive/'.$employee->id;
197			$response = $this->json('POST', $uri);
198
199			// And then try to find it
200			$employeeChanged = Employee::find($employee->id);
201
202			// It should this valid json employee, with active = false
203			$response
204			->assertStatus(200)
205			->assertJsonFragment([
206			'active' => false,
207			]);
208
209			$this->assertEquals(false, $employeeChanged->active);
210			}
211
212			private function jsonEmployeeStructure($employee)
213			{
214			return [
215			'id' => $employee->id,
216			'full_name' => $employee->full_name,
217			'br_cpf' => $employee->br_cpf,
218			'email' => $employee->email,
219			'telephone_type' => $employee->telephone_type,
220			'telephone' => $employee->telephone,
221			'zip_code' => $employee->zip_code,
222			'city' => $employee->city,
223			'state' => $employee->state,
224			'avenue' => $employee->avenue,
225			'number' => $employee->number,
226			'neighborhood' => $employee->neighborhood,
227			'complement' => $employee->complement,
228			'active' => $employee->active,
229			'updated_at' => $employee->updated_at,
230			'created_at' => $employee->created_at,
231			];
232			}
233			}
234

guastallaigor / laravel-backoffice-example

testMustInactiveAnEmployee() A last analyzed 2019-12-03 11:10 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

testMustInactiveAnEmployee() A
last analyzed 2019-12-03 11:10 UTC