UserTest::testCannotBeOwnedByAnotherOwned() - Code Metrics - Inspection of "Don't suggest users that are owned to be owner #79..." - Ecodev/my-ichtus - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( dad11e...8233a2 )

by Adrien

created 2021-04-07 08:49 UTC

UserTest::testCannotBeOwnedByAnotherOwned() A

↳ Parent: UserTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

declare(strict_types=1);

namespace ApplicationTest\Model;

use Application\DBAL\Types\BookingStatusType;
use Application\Model\Account;
use Application\Model\Booking;
use Application\Model\User;
use Cake\Chronos\Chronos;
use PHPUnit\Framework\TestCase;

class UserTest extends TestCase
{
    protected function tearDown(): void
    {
        User::setCurrent(null);
    }

    /**
     * @dataProvider providerSetRole
     */
    public function testSetRole(string $currentRole, string $oldRole, string $newRole, ?string $exception): void
    {
        User::setCurrent(null);
        if ($currentRole !== User::ROLE_ANONYMOUS) {
            $currentUser = new User($currentRole);
            User::setCurrent($currentUser);
        }

        $user2 = new User($oldRole);

        if ($exception) {
            $this->expectExceptionMessage($exception);
        }

        $user2->setRole($newRole);
        self::assertSame($newRole, $user2->getRole());
    }

    public function providerSetRole(): array
    {
        return [
            [User::ROLE_ANONYMOUS, User::ROLE_ADMINISTRATOR, User::ROLE_MEMBER, 'anonymous is not allowed to change role from administrator to member'],
            [User::ROLE_ANONYMOUS, User::ROLE_MEMBER, User::ROLE_ADMINISTRATOR, 'anonymous is not allowed to change role from member to administrator'],

            [User::ROLE_MEMBER, User::ROLE_MEMBER, User::ROLE_MEMBER, null],
            [User::ROLE_MEMBER, User::ROLE_MEMBER, User::ROLE_ADMINISTRATOR, 'member is not allowed to change role from member to administrator'],

            [User::ROLE_ADMINISTRATOR, User::ROLE_MEMBER, User::ROLE_ADMINISTRATOR, null],
            [User::ROLE_ADMINISTRATOR, User::ROLE_ADMINISTRATOR, User::ROLE_MEMBER, null],
        ];
    }

    public function testCannotOwnMyself(): void
    {
        $user = new User();
        $this->expectExceptionMessage('This user cannot be owned by himself');
        $user->setOwner($user);
    }

    public function testCannotBeOwnedByAnotherOwned(): void
    {
        $user = new User();
        $owner1 = new User();
        $owner2 = new User();
        $owner1->setOwner($owner2);
        self::assertSame($owner2, $owner1->getOwner());

        $this->expectExceptionMessage('This user cannot be owned by a user who is himself owned by somebody else');
        $user->setOwner($owner1);
    }

    public function testCannotBeOwnedBecauseIsOwner(): void
    {
        $user = new User();
        $owned = new User();
        $owned->setOwner($user);
        self::assertSame($user, $owned->getOwner());

        $owner = new User();

        $this->expectExceptionMessage('This user owns other users, so he cannot himself be owned by somebody else');
        $user->setOwner($owner);
    }

    public function providerCanOpenDoor(): array
    {
        return [
            'anonymous cannot open' => [
                User::ROLE_ANONYMOUS,
                User::STATUS_ACTIVE,
                ['door1' => true, 'door2' => true, 'door3' => true, 'door4' => true],
                ['door1' => false, 'door2' => false, 'door3' => false, 'door4' => false],
            ],
            'individual member can open' => [
                User::ROLE_INDIVIDUAL,
                User::STATUS_ACTIVE,
                ['door1' => true, 'door2' => true, 'door3' => true, 'door4' => false],
                ['door1' => true, 'door2' => true, 'door3' => true, 'door4' => false],
            ],
            'active member can open' => [
                User::ROLE_MEMBER,
                User::STATUS_ACTIVE,
                ['door1' => true, 'door2' => true, 'door3' => true, 'door4' => false],
                ['door1' => true, 'door2' => true, 'door3' => true, 'door4' => false],
            ],
            'inactive member cannot open' => [
                User::ROLE_MEMBER,
                User::STATUS_INACTIVE,
                ['door1' => true, 'door2' => true, 'door3' => true, 'door4' => false],
                ['door1' => false, 'door2' => false, 'door3' => false, 'door4' => false],
            ],
            'responsible can open' => [
                User::ROLE_RESPONSIBLE,
                User::STATUS_ACTIVE,
                ['door1' => true, 'door2' => true, 'door3' => true, 'door4' => true],
                ['door1' => true, 'door2' => true, 'door3' => true, 'door4' => true],
            ],
            'administrator can open' => [
                User::ROLE_ADMINISTRATOR,
                User::STATUS_ACTIVE,
                ['door1' => true, 'door2' => true, 'door3' => true, 'door4' => true],
                ['door1' => true, 'door2' => true, 'door3' => true, 'door4' => true],
            ],
        ];
    }

    /**
     * @dataProvider providerCanOpenDoor,
     */
    public function testCanOpenDoor(string $role, string $status, array $doors, array $result): void
    {
        $user = new User($role);
        $user->setStatus($status);
        foreach ($doors as $door => $value) {
            $setter = 'set' . ucfirst($door);
            $user->$setter($value);
        }

        foreach ($result as $door => $canOpen) {
            self::assertSame($canOpen, $user->getCanOpenDoor($door));
        }
    }

    public function testGetAccount(): void
    {
        $user1 = new User();
        $user2 = new User();

        self::assertNull($user1->getAccount());
        self::assertNull($user2->getAccount());

        $account1 = new Account();
        $account2 = new Account();
        $account1->setOwner($user1);
        $account2->setOwner($user2);

        self::assertSame($account1, $user1->getAccount());
        self::assertSame($account2, $user2->getAccount());

        $user2->setOwner($user1);

        self::assertSame($account1, $user1->getAccount());
        self::assertSame($account1, $user2->getAccount(), 'user2 should now use user1 account');

        User::setCurrent($user1);
        $user2->setOwner(null);

        self::assertSame($account1, $user1->getAccount());
        self::assertSame($account2, $user2->getAccount(), 'user2 should be use his own account again');

        User::setCurrent($user2);
        $user2->setOwner(null);

        self::assertSame($account1, $user1->getAccount());
        self::assertSame($account2, $user2->getAccount(), 'user2 should be use his own account again');
    }

    public function testGetRunningBookings(): void
    {
        $user = new User();

        $unapproved = new Booking();
        $unapproved->setOwner($user);
        $unapproved->setStatus(BookingStatusType::APPLICATION);

        $completed = new Booking();
        $completed->setOwner($user);
        $completed->setStatus(BookingStatusType::BOOKED);
        $completed->setEndDate(Chronos::yesterday());

        $running = new Booking();
        $running->setOwner($user);
        $running->setStatus(BookingStatusType::BOOKED);

        $runnings = $user->getRunningBookings();

        self::assertCount(1, $runnings);
    }

    public function testSetStatus(): void
    {
        $u1 = new User();
        $u2 = new User();

        // Initial status
        self::assertSame(User::STATUS_NEW, $u1->getStatus());
        self::assertSame(User::STATUS_NEW, $u2->getStatus());

        $u2->setOwner($u1);
        $u1->setStatus(User::STATUS_INACTIVE);

        // Status is propagated to existing users
        self::assertSame(User::STATUS_INACTIVE, $u1->getStatus());
        self::assertSame(User::STATUS_INACTIVE, $u2->getStatus());

        $u1->setStatus(user::STATUS_ACTIVE);
        self::assertSame(User::STATUS_ACTIVE, $u1->getStatus());
        self::assertSame(User::STATUS_ACTIVE, $u2->getStatus());

        // Status is propagated on new users too
        $u3 = new User();
        self::assertSame(User::STATUS_NEW, $u3->getStatus());
        $u3->setOwner($u1);
        self::assertSame(User::STATUS_ACTIVE, $u3->getStatus());

        // Status 'archived' sets resign date
        Chronos::setTestNow((new Chronos()));
        $u1->setStatus(User::STATUS_ARCHIVED);
        self::assertTrue($u1->getResignDate() && $u1->getResignDate()->isToday());
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ApplicationTest\Model;
6
7			use Application\DBAL\Types\BookingStatusType;
8			use Application\Model\Account;
9			use Application\Model\Booking;
10			use Application\Model\User;
11			use Cake\Chronos\Chronos;
12			use PHPUnit\Framework\TestCase;
13
14			class UserTest extends TestCase
15			{
16			protected function tearDown(): void
17			{
18			User::setCurrent(null);
19			}
20
21			/**
22			* @dataProvider providerSetRole
23			*/
24			public function testSetRole(string $currentRole, string $oldRole, string $newRole, ?string $exception): void
25			{
26			User::setCurrent(null);
27			if ($currentRole !== User::ROLE_ANONYMOUS) {
28			$currentUser = new User($currentRole);
29			User::setCurrent($currentUser);
30			}
31
32			$user2 = new User($oldRole);
33
34			if ($exception) {
35			$this->expectExceptionMessage($exception);
36			}
37
38			$user2->setRole($newRole);
39			self::assertSame($newRole, $user2->getRole());
40			}
41
42			public function providerSetRole(): array
43			{
44			return [
45			[User::ROLE_ANONYMOUS, User::ROLE_ADMINISTRATOR, User::ROLE_MEMBER, 'anonymous is not allowed to change role from administrator to member'],
46			[User::ROLE_ANONYMOUS, User::ROLE_MEMBER, User::ROLE_ADMINISTRATOR, 'anonymous is not allowed to change role from member to administrator'],
47
48			[User::ROLE_MEMBER, User::ROLE_MEMBER, User::ROLE_MEMBER, null],
49			[User::ROLE_MEMBER, User::ROLE_MEMBER, User::ROLE_ADMINISTRATOR, 'member is not allowed to change role from member to administrator'],
50
51			[User::ROLE_ADMINISTRATOR, User::ROLE_MEMBER, User::ROLE_ADMINISTRATOR, null],
52			[User::ROLE_ADMINISTRATOR, User::ROLE_ADMINISTRATOR, User::ROLE_MEMBER, null],
53			];
54			}
55
56			public function testCannotOwnMyself(): void
57			{
58			$user = new User();
59			$this->expectExceptionMessage('This user cannot be owned by himself');
60			$user->setOwner($user);
61			}
62
63			public function testCannotBeOwnedByAnotherOwned(): void
64			{
65			$user = new User();
66			$owner1 = new User();
67			$owner2 = new User();
68			$owner1->setOwner($owner2);
69			self::assertSame($owner2, $owner1->getOwner());
70
71			$this->expectExceptionMessage('This user cannot be owned by a user who is himself owned by somebody else');
72			$user->setOwner($owner1);
73			}
74
75			public function testCannotBeOwnedBecauseIsOwner(): void
76			{
77			$user = new User();
78			$owned = new User();
79			$owned->setOwner($user);
80			self::assertSame($user, $owned->getOwner());
81
82			$owner = new User();
83
84			$this->expectExceptionMessage('This user owns other users, so he cannot himself be owned by somebody else');
85			$user->setOwner($owner);
86			}
87
88			public function providerCanOpenDoor(): array
89			{
90			return [
91			'anonymous cannot open' => [
92			User::ROLE_ANONYMOUS,
93			User::STATUS_ACTIVE,
94			['door1' => true, 'door2' => true, 'door3' => true, 'door4' => true],
95			['door1' => false, 'door2' => false, 'door3' => false, 'door4' => false],
96			],
97			'individual member can open' => [
98			User::ROLE_INDIVIDUAL,
99			User::STATUS_ACTIVE,
100			['door1' => true, 'door2' => true, 'door3' => true, 'door4' => false],
101			['door1' => true, 'door2' => true, 'door3' => true, 'door4' => false],
102			],
103			'active member can open' => [
104			User::ROLE_MEMBER,
105			User::STATUS_ACTIVE,
106			['door1' => true, 'door2' => true, 'door3' => true, 'door4' => false],
107			['door1' => true, 'door2' => true, 'door3' => true, 'door4' => false],
108			],
109			'inactive member cannot open' => [
110			User::ROLE_MEMBER,
111			User::STATUS_INACTIVE,
112			['door1' => true, 'door2' => true, 'door3' => true, 'door4' => false],
113			['door1' => false, 'door2' => false, 'door3' => false, 'door4' => false],
114			],
115			'responsible can open' => [
116			User::ROLE_RESPONSIBLE,
117			User::STATUS_ACTIVE,
118			['door1' => true, 'door2' => true, 'door3' => true, 'door4' => true],
119			['door1' => true, 'door2' => true, 'door3' => true, 'door4' => true],
120			],
121			'administrator can open' => [
122			User::ROLE_ADMINISTRATOR,
123			User::STATUS_ACTIVE,
124			['door1' => true, 'door2' => true, 'door3' => true, 'door4' => true],
125			['door1' => true, 'door2' => true, 'door3' => true, 'door4' => true],
126			],
127			];
128			}
129
130			/**
131			* @dataProvider providerCanOpenDoor,
132			*/
133			public function testCanOpenDoor(string $role, string $status, array $doors, array $result): void
134			{
135			$user = new User($role);
136			$user->setStatus($status);
137			foreach ($doors as $door => $value) {
138			$setter = 'set' . ucfirst($door);
139			$user->$setter($value);
140			}
141
142			foreach ($result as $door => $canOpen) {
143			self::assertSame($canOpen, $user->getCanOpenDoor($door));
144			}
145			}
146
147			public function testGetAccount(): void
148			{
149			$user1 = new User();
150			$user2 = new User();
151
152			self::assertNull($user1->getAccount());
153			self::assertNull($user2->getAccount());
154
155			$account1 = new Account();
156			$account2 = new Account();
157			$account1->setOwner($user1);
158			$account2->setOwner($user2);
159
160			self::assertSame($account1, $user1->getAccount());
161			self::assertSame($account2, $user2->getAccount());
162
163			$user2->setOwner($user1);
164
165			self::assertSame($account1, $user1->getAccount());
166			self::assertSame($account1, $user2->getAccount(), 'user2 should now use user1 account');
167
168			User::setCurrent($user1);
169			$user2->setOwner(null);
170
171			self::assertSame($account1, $user1->getAccount());
172			self::assertSame($account2, $user2->getAccount(), 'user2 should be use his own account again');
173
174			User::setCurrent($user2);
175			$user2->setOwner(null);
176
177			self::assertSame($account1, $user1->getAccount());
178			self::assertSame($account2, $user2->getAccount(), 'user2 should be use his own account again');
179			}
180
181			public function testGetRunningBookings(): void
182			{
183			$user = new User();
184
185			$unapproved = new Booking();
186			$unapproved->setOwner($user);
187			$unapproved->setStatus(BookingStatusType::APPLICATION);
188
189			$completed = new Booking();
190			$completed->setOwner($user);
191			$completed->setStatus(BookingStatusType::BOOKED);
192			$completed->setEndDate(Chronos::yesterday());
193
194			$running = new Booking();
195			$running->setOwner($user);
196			$running->setStatus(BookingStatusType::BOOKED);
197
198			$runnings = $user->getRunningBookings();
199
200			self::assertCount(1, $runnings);
201			}
202
203			public function testSetStatus(): void
204			{
205			$u1 = new User();
206			$u2 = new User();
207
208			// Initial status
209			self::assertSame(User::STATUS_NEW, $u1->getStatus());
210			self::assertSame(User::STATUS_NEW, $u2->getStatus());
211
212			$u2->setOwner($u1);
213			$u1->setStatus(User::STATUS_INACTIVE);
214
215			// Status is propagated to existing users
216			self::assertSame(User::STATUS_INACTIVE, $u1->getStatus());
217			self::assertSame(User::STATUS_INACTIVE, $u2->getStatus());
218
219			$u1->setStatus(user::STATUS_ACTIVE);
220			self::assertSame(User::STATUS_ACTIVE, $u1->getStatus());
221			self::assertSame(User::STATUS_ACTIVE, $u2->getStatus());
222
223			// Status is propagated on new users too
224			$u3 = new User();
225			self::assertSame(User::STATUS_NEW, $u3->getStatus());
226			$u3->setOwner($u1);
227			self::assertSame(User::STATUS_ACTIVE, $u3->getStatus());
228
229			// Status 'archived' sets resign date
230			Chronos::setTestNow((new Chronos()));
231			$u1->setStatus(User::STATUS_ARCHIVED);
232			self::assertTrue($u1->getResignDate() && $u1->getResignDate()->isToday());
233			}
234			}
235

Ecodev / my-ichtus

Push — master ( dad11e...8233a2 )

UserTest::testCannotBeOwnedByAnotherOwned() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like