FilesTest::testDataOnly() - Code Metrics - Inspection of "kw_auth - test for some edge cases, non-existent f..." - alex-kalanis/kw_auth - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d309df...7ec489 )

by Petr

created 2022-08-28 23:34 UTC

FilesTest::testDataOnly() A

↳ Parent: FilesTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace SourcesTests\Files\Volume;


use CommonTestClass;
use kalanis\kw_auth\AuthException;
use kalanis\kw_auth\Data\FileCertUser;
use kalanis\kw_auth\Data\FileGroup;
use kalanis\kw_auth\Sources\Files\Volume\Files;
use kalanis\kw_locks\LockException;


class FilesTest extends CommonTestClass
{
    protected $sourcePath = '';

    protected function setUp(): void
    {
        $this->sourcePath = __DIR__ . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'data';
    }

    /**
     * @throws AuthException
     * @throws LockException
     */
    public function testDataOnly(): void
    {
        $lib = $this->fileSources();
        $this->assertEmpty($lib->getDataOnly('does not exist'));
        $user = $lib->getDataOnly('manager');
        $this->assertNotEmpty($user);
        $this->assertEquals('Manage', $user->getDisplayName());
    }

    /**
     * @throws AuthException
     * @throws LockException
     */
    public function testAuthenticate(): void
    {
        $lib = $this->fileSources();
        $this->assertEmpty($lib->authenticate('manager', ['password' => 'thisisnotreal']));
        $user = $lib->authenticate('manager', ['password' => 'valid']);
        $this->assertNotEmpty($user);
        $this->assertEquals('Manage', $user->getDisplayName());
    }

    /**
     * @throws AuthException
     * @throws LockException
     */
    public function testAuthenticateNoPass(): void
    {
        $lib = $this->fileSources();
        $this->expectException(AuthException::class);
        $lib->authenticate('manager', []);
    }

    /**
     * @throws AuthException
     * @throws LockException
     */
    public function testAccountManipulation(): void
    {
        $lib = $this->fileSources();
        $user = $this->wantedUser();

        // create
        $lib->createAccount($user, 'here to set');
        // check data
        $saved = $lib->getDataOnly($user->getAuthName());
        $this->assertEquals('Testing another', $saved->getDisplayName());
        $this->assertEquals('why_here', $saved->getDir());
        $this->assertEquals(3, $saved->getClass());

        // check login
        $this->assertNotEmpty($lib->authenticate($user->getAuthName(), ['password' => 'here to set']));

        // update
        $user->setData(
            $user->getAuthId(),
            $user->getAuthName(),
            $user->getGroup(),
            2,
            'WheĐn yoĐu dđo nođt knđow',
            $user->getDir()
        );
        $user->addCertInfo('==public key for accessing that content==', 'hidden salt');
        $lib->updateAccount($user);
        $lib->updateCertKeys($user->getAuthName(), $user->getPubKey(), $user->getPubSalt());

        // update name
        $user->setData(
            $user->getAuthId(),
            'changed name',
            $user->getGroup(),
            $user->getClass(),
            $user->getDisplayName(),
            $user->getDir()
        );
        $lib->updateAccount($user);

        // check data - again with new values
        $saved = $lib->getCertData($user->getAuthName());
        $this->assertEquals('When you do not know', $saved->getDisplayName());
        $this->assertEquals(2, $saved->getClass());
        $this->assertEquals($user->getPubKey(), $saved->getPubKey());
        $this->assertEquals($user->getPubSalt(), $saved->getPubSalt());


        // update password
        $lib->updatePassword($user->getAuthName(), 'another pass');
        // check login
        $this->assertEmpty($lib->authenticate($user->getAuthName(), ['password' => 'here to set']));
        $this->assertNotEmpty($lib->authenticate($user->getAuthName(), ['password' => 'another pass']));

        // remove
        $lib->deleteAccount($user->getAuthName());
        // check for existence
        $this->assertEmpty($lib->getDataOnly($user->getAuthName()));
    }

    /**
     * @throws AuthException
     * @throws LockException
     * AuthId is not correct but auth name is
     */
    public function testAccountUpdateFail(): void
    {
        $lib = $this->fileSources();
        $user = new FileCertUser();
        $user->setData(600, 'worker', 0, 0, 'Die on set', 'so_here');

        $this->expectException(AuthException::class);
        $lib->updateAccount($user);
    }

    /**
     * @throws AuthException
     * @throws LockException
     */
    public function testCreateFail(): void
    {
        $lib = $this->fileSources();
        $user = $this->wantedUser();
        $this->expectException(AuthException::class);
        $lib->createAccount($user, '');
    }

    /**
     * @throws AuthException
     * @throws LockException
     */
    public function testAllUsers(): void
    {
        $lib = $this->fileSources();
        $data = $lib->readAccounts();
        $this->assertEquals(1, $data[0]->getClass());
        $this->assertEquals('manager', $data[1]->getAuthName());
    }

    /**
     * Contains a full comedy/tragedy of work with locks
     * @throws LockException
     * @return Files
     */
    protected function fileSources(): Files
    {
        return new Files(
            new \MockModes(),
            $this->getLockPath(),
            $this->sourcePath
        );
    }

    protected function wantedUser(): FileCertUser
    {
        $user = new FileCertUser();
        $user->setData(1003, 'another', 0, 0, 'Testing another', 'why_here');
        return $user;
    }

    /**
     * @throws AuthException
     * @throws LockException
     */
    public function testGroupManipulation(): void
    {
        $lib = $this->fileSources();
        $group = $this->wantedGroup();

        // create
        $lib->createGroup($group);
        // check data
        $saved = $lib->getGroupDataOnly($group->getGroupId());
        $this->assertEquals('another', $saved->getGroupName());
        $this->assertEquals('Testing group', $saved->getGroupDesc());
        $this->assertEquals(1001, $saved->getGroupAuthorId());

        // update
        $group->setData(
            $group->getGroupId(),
            $group->getGroupName(),
            1002,
            'WheĐn yoĐu dđo nođt knđow'
        );
        $lib->updateGroup($group);

        // check data - again with new values
        $saved = $lib->getGroupDataOnly($group->getGroupId());
        $this->assertEquals('When you do not know', $saved->getGroupDesc()); // overwrite this
        $this->assertEquals(1001, $saved->getGroupAuthorId()); // cannot overwrite this

        // remove
        $lib->deleteGroup($group->getGroupId());
        // check for existence
        $this->assertEmpty($lib->getGroupDataOnly($group->getGroupId()));
    }

    /**
     * @throws AuthException
     * @throws LockException
     */
    public function testCreateGroupFail(): void
    {
        $lib = $this->fileSources();
        $group = $this->wantedGroup('');
        $this->expectException(AuthException::class);
        $lib->createGroup($group);
    }

    /**
     * @throws AuthException
     * @throws LockException
     */
    public function testDeleteGroupFail(): void
    {
        $lib = $this->fileSources();
        $this->expectException(AuthException::class);
        $lib->deleteGroup(1);
    }

    /**
     * @throws AuthException
     * @throws LockException
     */
    public function testAllGroups(): void
    {
        $lib = $this->fileSources();
        $data = $lib->readGroup();
        $this->assertEquals('Maintainers', $data[0]->getGroupDesc());
        $this->assertEquals(1000, $data[1]->getGroupAuthorId());
    }

    protected function wantedGroup($name = 'another'): FileGroup
    {
        $user = new FileGroup();
        $user->setData(3, $name, 1001, 'Testing group');
        return $user;
    }
}


1			<?php
2
3			namespace SourcesTests\Files\Volume;
4
5
6			use CommonTestClass;
7			use kalanis\kw_auth\AuthException;
8			use kalanis\kw_auth\Data\FileCertUser;
9			use kalanis\kw_auth\Data\FileGroup;
10			use kalanis\kw_auth\Sources\Files\Volume\Files;
11			use kalanis\kw_locks\LockException;
12
13
14			class FilesTest extends CommonTestClass
15			{
16			protected $sourcePath = '';
17
18			protected function setUp(): void
19			{
20			$this->sourcePath = __DIR__ . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'data';
21			}
22
23			/**
24			* @throws AuthException
25			* @throws LockException
26			*/
27			public function testDataOnly(): void
28			{
29			$lib = $this->fileSources();
30			$this->assertEmpty($lib->getDataOnly('does not exist'));
31			$user = $lib->getDataOnly('manager');
32			$this->assertNotEmpty($user);
33			$this->assertEquals('Manage', $user->getDisplayName());
34			}
35
36			/**
37			* @throws AuthException
38			* @throws LockException
39			*/
40			public function testAuthenticate(): void
41			{
42			$lib = $this->fileSources();
43			$this->assertEmpty($lib->authenticate('manager', ['password' => 'thisisnotreal']));
44			$user = $lib->authenticate('manager', ['password' => 'valid']);
45			$this->assertNotEmpty($user);
46			$this->assertEquals('Manage', $user->getDisplayName());
47			}
48
49			/**
50			* @throws AuthException
51			* @throws LockException
52			*/
53			public function testAuthenticateNoPass(): void
54			{
55			$lib = $this->fileSources();
56			$this->expectException(AuthException::class);
57			$lib->authenticate('manager', []);
58			}
59
60			/**
61			* @throws AuthException
62			* @throws LockException
63			*/
64			public function testAccountManipulation(): void
65			{
66			$lib = $this->fileSources();
67			$user = $this->wantedUser();
68
69			// create
70			$lib->createAccount($user, 'here to set');
71			// check data
72			$saved = $lib->getDataOnly($user->getAuthName());
73			$this->assertEquals('Testing another', $saved->getDisplayName());
74			$this->assertEquals('why_here', $saved->getDir());
75			$this->assertEquals(3, $saved->getClass());
76
77			// check login
78			$this->assertNotEmpty($lib->authenticate($user->getAuthName(), ['password' => 'here to set']));
79
80			// update
81			$user->setData(
82			$user->getAuthId(),
83			$user->getAuthName(),
84			$user->getGroup(),
85			2,
86			'WheĐn yoĐu dđo nođt knđow',
87			$user->getDir()
88			);
89			$user->addCertInfo('==public key for accessing that content==', 'hidden salt');
90			$lib->updateAccount($user);
91			$lib->updateCertKeys($user->getAuthName(), $user->getPubKey(), $user->getPubSalt());
92
93			// update name
94			$user->setData(
95			$user->getAuthId(),
96			'changed name',
97			$user->getGroup(),
98			$user->getClass(),
99			$user->getDisplayName(),
100			$user->getDir()
101			);
102			$lib->updateAccount($user);
103
104			// check data - again with new values
105			$saved = $lib->getCertData($user->getAuthName());
106			$this->assertEquals('When you do not know', $saved->getDisplayName());
107			$this->assertEquals(2, $saved->getClass());
108			$this->assertEquals($user->getPubKey(), $saved->getPubKey());
109			$this->assertEquals($user->getPubSalt(), $saved->getPubSalt());
110
111
112			// update password
113			$lib->updatePassword($user->getAuthName(), 'another pass');
114			// check login
115			$this->assertEmpty($lib->authenticate($user->getAuthName(), ['password' => 'here to set']));
116			$this->assertNotEmpty($lib->authenticate($user->getAuthName(), ['password' => 'another pass']));
117
118			// remove
119			$lib->deleteAccount($user->getAuthName());
120			// check for existence
121			$this->assertEmpty($lib->getDataOnly($user->getAuthName()));
122			}
123
124			/**
125			* @throws AuthException
126			* @throws LockException
127			* AuthId is not correct but auth name is
128			*/
129			public function testAccountUpdateFail(): void
130			{
131			$lib = $this->fileSources();
132			$user = new FileCertUser();
133			$user->setData(600, 'worker', 0, 0, 'Die on set', 'so_here');
134
135			$this->expectException(AuthException::class);
136			$lib->updateAccount($user);
137			}
138
139			/**
140			* @throws AuthException
141			* @throws LockException
142			*/
143			public function testCreateFail(): void
144			{
145			$lib = $this->fileSources();
146			$user = $this->wantedUser();
147			$this->expectException(AuthException::class);
148			$lib->createAccount($user, '');
149			}
150
151			/**
152			* @throws AuthException
153			* @throws LockException
154			*/
155			public function testAllUsers(): void
156			{
157			$lib = $this->fileSources();
158			$data = $lib->readAccounts();
159			$this->assertEquals(1, $data[0]->getClass());
160			$this->assertEquals('manager', $data[1]->getAuthName());
161			}
162
163			/**
164			* Contains a full comedy/tragedy of work with locks
165			* @throws LockException
166			* @return Files
167			*/
168			protected function fileSources(): Files
169			{
170			return new Files(
171			new \MockModes(),
172			$this->getLockPath(),
173			$this->sourcePath
174			);
175			}
176
177			protected function wantedUser(): FileCertUser
178			{
179			$user = new FileCertUser();
180			$user->setData(1003, 'another', 0, 0, 'Testing another', 'why_here');
181			return $user;
182			}
183
184			/**
185			* @throws AuthException
186			* @throws LockException
187			*/
188			public function testGroupManipulation(): void
189			{
190			$lib = $this->fileSources();
191			$group = $this->wantedGroup();
192
193			// create
194			$lib->createGroup($group);
195			// check data
196			$saved = $lib->getGroupDataOnly($group->getGroupId());
197			$this->assertEquals('another', $saved->getGroupName());
198			$this->assertEquals('Testing group', $saved->getGroupDesc());
199			$this->assertEquals(1001, $saved->getGroupAuthorId());
200
201			// update
202			$group->setData(
203			$group->getGroupId(),
204			$group->getGroupName(),
205			1002,
206			'WheĐn yoĐu dđo nođt knđow'
207			);
208			$lib->updateGroup($group);
209
210			// check data - again with new values
211			$saved = $lib->getGroupDataOnly($group->getGroupId());
212			$this->assertEquals('When you do not know', $saved->getGroupDesc()); // overwrite this
213			$this->assertEquals(1001, $saved->getGroupAuthorId()); // cannot overwrite this
214
215			// remove
216			$lib->deleteGroup($group->getGroupId());
217			// check for existence
218			$this->assertEmpty($lib->getGroupDataOnly($group->getGroupId()));
219			}
220
221			/**
222			* @throws AuthException
223			* @throws LockException
224			*/
225			public function testCreateGroupFail(): void
226			{
227			$lib = $this->fileSources();
228			$group = $this->wantedGroup('');
229			$this->expectException(AuthException::class);
230			$lib->createGroup($group);
231			}
232
233			/**
234			* @throws AuthException
235			* @throws LockException
236			*/
237			public function testDeleteGroupFail(): void
238			{
239			$lib = $this->fileSources();
240			$this->expectException(AuthException::class);
241			$lib->deleteGroup(1);
242			}
243
244			/**
245			* @throws AuthException
246			* @throws LockException
247			*/
248			public function testAllGroups(): void
249			{
250			$lib = $this->fileSources();
251			$data = $lib->readGroup();
252			$this->assertEquals('Maintainers', $data[0]->getGroupDesc());
253			$this->assertEquals(1000, $data[1]->getGroupAuthorId());
254			}
255
256			protected function wantedGroup($name = 'another'): FileGroup
257			{
258			$user = new FileGroup();
259			$user->setData(3, $name, 1001, 'Testing group');
260			return $user;
261			}
262			}
263

alex-kalanis / kw_auth

Push — master ( d309df...7ec489 )

FilesTest::testDataOnly() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like