SecurityTest::testHandleSetsCacheIfAllGood() - Code Metrics - abterphp/framework - Measure and Improve Code Quality continuously with Scrutinizer

SecurityTest::testHandleSetsCacheIfAllGood() A
last analyzed 2023-01-23 22:11 UTC

↳ Parent: SecurityTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	33
Code Lines	18

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	0

Metric	Value
cc	1
eloc	18
nc	1
nop	0
dl	0
loc	33
rs	9.6666
c	2
b	1
f	0

<?php

declare(strict_types=1);

namespace AbterPhp\Framework\Http\Middleware;

use AbterPhp\Framework\Constant\Env;
use Exception;
use Opulence\Cache\ArrayBridge;
use Opulence\Environments\Environment;
use Opulence\Http\Requests\Request;
use Opulence\Http\Responses\Response;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;

class SecurityTest extends TestCase
{
    /** @var ArrayBridge|MockObject */
    protected $cacheBridgeMock;

    public function setUp(): void
    {
        parent::setUp();

        $this->cacheBridgeMock = $this->createMock(ArrayBridge::class);
    }

    public function testHandleSkipsAllIfEnvironmentIsNotProduction(): void
    {
        $sut = new Security($this->cacheBridgeMock, Environment::TESTING);

        /** @var Request|MockObject $requestMock */
        $requestMock = $this->createMock(Request::class);

        /** @var Response|MockObject $requestMock */
        $responseMock = $this->createMock(Response::class);

        $next = fn () => $responseMock;

        $this->cacheBridgeMock->expects($this->never())->method('get');

        $actualResult = $sut->handle($requestMock, $next);

        $this->assertSame($responseMock, $actualResult);
    }

    public function testHandleSkipsAllIfCacheIsSet(): void
    {
        $sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);

        /** @var Request|MockObject $requestMock */
        $requestMock = $this->createMock(Request::class);

        /** @var Response|MockObject $requestMock */
        $responseMock = $this->createMock(Response::class);

        $next = fn () => $responseMock;

        $this->cacheBridgeMock->expects($this->once())->method('get')->willReturn(true);

        $actualResult = $sut->handle($requestMock, $next);

        $this->assertSame($responseMock, $actualResult);
    }

    public function testHandleSetsCacheIfAllGood(): void
    {
        $sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);

        /** @var Request|MockObject $requestMock */
        $requestMock = $this->createMock(Request::class);

        /** @var Response|MockObject $requestMock */
        $responseMock = $this->createMock(Response::class);

        $next = fn () => $responseMock;

        $sut->setVar(
            [
                Env::DB_PASSWORD                 => 'abc',
                Env::ENCRYPTION_KEY              => 'bcd',
                Env::CRYPTO_FRONTEND_SALT        => 'cde',
                Env::CRYPTO_ENCRYPTION_PEPPER    => 'def',
                Env::OAUTH2_PRIVATE_KEY_PATH     => 'efg',
                Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
                Env::OAUTH2_PUBLIC_KEY_PATH      => 'ghi',
                Env::OAUTH2_ENCRYPTION_KEY       => 'hij',
            ]
        );

        $sut->setSettings(['display_errors' => '']);

        $this->cacheBridgeMock->expects($this->any())->method('get')->willReturn(false);
        $this->cacheBridgeMock->expects($this->once())->method('set')->willReturn(true);

        $actualResult = $sut->handle($requestMock, $next);

        $this->assertSame($responseMock, $actualResult);
    }

    public function testHandleRunsNormalIfCacheGetThrowsException(): void
    {
        $sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);

        /** @var Request|MockObject $requestMock */
        $requestMock = $this->createMock(Request::class);

        /** @var Response|MockObject $requestMock */
        $responseMock = $this->createMock(Response::class);

        $next = fn () => $responseMock;

        $sut->setVar(
            [
                Env::DB_PASSWORD                 => 'abc',
                Env::ENCRYPTION_KEY              => 'bcd',
                Env::CRYPTO_FRONTEND_SALT        => 'cde',
                Env::CRYPTO_ENCRYPTION_PEPPER    => 'def',
                Env::OAUTH2_PRIVATE_KEY_PATH     => 'efg',
                Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
                Env::OAUTH2_PUBLIC_KEY_PATH      => 'ghi',
                Env::OAUTH2_ENCRYPTION_KEY       => 'hij',
            ]
        );

        $sut->setSettings(['display_errors' => '']);

        $this->cacheBridgeMock->expects($this->any())->method('get')->willThrowException(new Exception());
        $this->cacheBridgeMock->expects($this->once())->method('set')->willReturn(true);

        $actualResult = $sut->handle($requestMock, $next);

        $this->assertSame($responseMock, $actualResult);
    }

    public function handleThrowsSecurityExceptionIfNeededProvider(): array
    {
        return [
            'test-password'                    => [
                [
                    Env::DB_PASSWORD                 => Security::TEST_DB_PASSWORD,
                    Env::ENCRYPTION_KEY              => 'bcd',
                    Env::CRYPTO_FRONTEND_SALT        => 'cde',
                    Env::CRYPTO_ENCRYPTION_PEPPER    => 'def',
                    Env::OAUTH2_PRIVATE_KEY_PATH     => 'efg',
                    Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
                    Env::OAUTH2_PUBLIC_KEY_PATH      => 'ghi',
                    Env::OAUTH2_ENCRYPTION_KEY       => 'hij',
                ],
                [
                    'display_errors' => '',
                ],
            ],
            'test-encryption-key'              => [
                [
                    Env::DB_PASSWORD                 => 'abc',
                    Env::ENCRYPTION_KEY              => Security::TEST_ENCRYPTION_KEY,
                    Env::CRYPTO_FRONTEND_SALT        => 'cde',
                    Env::CRYPTO_ENCRYPTION_PEPPER    => 'def',
                    Env::OAUTH2_PRIVATE_KEY_PATH     => 'efg',
                    Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
                    Env::OAUTH2_PUBLIC_KEY_PATH      => 'ghi',
                    Env::OAUTH2_ENCRYPTION_KEY       => 'hij',
                ],
                [
                    'display_errors' => '',
                ],
            ],
            'test-frontend-salt'               => [
                [
                    Env::DB_PASSWORD                 => 'abc',
                    Env::ENCRYPTION_KEY              => 'bcd',
                    Env::CRYPTO_FRONTEND_SALT        => Security::TEST_CRYPTO_FRONTEND_SALT,
                    Env::CRYPTO_ENCRYPTION_PEPPER    => 'def',
                    Env::OAUTH2_PRIVATE_KEY_PATH     => 'efg',
                    Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
                    Env::OAUTH2_PUBLIC_KEY_PATH      => 'ghi',
                    Env::OAUTH2_ENCRYPTION_KEY       => 'hij',
                ],
                [
                    'display_errors' => '',
                ],
            ],
            'test-encryption-pepper'           => [
                [
                    Env::DB_PASSWORD                 => 'abc',
                    Env::ENCRYPTION_KEY              => 'bcd',
                    Env::CRYPTO_FRONTEND_SALT        => 'cde',
                    Env::CRYPTO_ENCRYPTION_PEPPER    => Security::TEST_CRYPTO_ENCRYPTION_PEPPER,
                    Env::OAUTH2_PRIVATE_KEY_PATH     => 'efg',
                    Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
                    Env::OAUTH2_PUBLIC_KEY_PATH      => 'ghi',
                    Env::OAUTH2_ENCRYPTION_KEY       => 'hij',
                ],
                [
                    'display_errors' => '',
                ],
            ],
            'test-oauth2-private-key-path'     => [
                [
                    Env::DB_PASSWORD                 => 'abc',
                    Env::ENCRYPTION_KEY              => 'bcd',
                    Env::CRYPTO_FRONTEND_SALT        => 'cde',
                    Env::CRYPTO_ENCRYPTION_PEPPER    => 'def',
                    Env::OAUTH2_PRIVATE_KEY_PATH     => Security::TEST_OAUTH2_PRIVATE_KEY_PATH,
                    Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
                    Env::OAUTH2_PUBLIC_KEY_PATH      => 'ghi',
                    Env::OAUTH2_ENCRYPTION_KEY       => 'hij',
                ],
                [
                    'display_errors' => '',
                ],
            ],
            'test-oauth2-private-key-password' => [
                [
                    Env::DB_PASSWORD                 => 'abc',
                    Env::ENCRYPTION_KEY              => 'bcd',
                    Env::CRYPTO_FRONTEND_SALT        => 'cde',
                    Env::CRYPTO_ENCRYPTION_PEPPER    => 'def',
                    Env::OAUTH2_PRIVATE_KEY_PATH     => 'efg',
                    Env::OAUTH2_PRIVATE_KEY_PASSWORD => Security::TEST_OAUTH2_PRIVATE_KEY_PASSWORD,
                    Env::OAUTH2_PUBLIC_KEY_PATH      => 'ghi',
                    Env::OAUTH2_ENCRYPTION_KEY       => 'hij',
                ],
                [
                    'display_errors' => '',
                ],
            ],
            'test-oauth2-public-key-path'      => [
                [
                    Env::DB_PASSWORD                 => 'abc',
                    Env::ENCRYPTION_KEY              => 'bcd',
                    Env::CRYPTO_FRONTEND_SALT        => 'cde',
                    Env::CRYPTO_ENCRYPTION_PEPPER    => 'def',
                    Env::OAUTH2_PRIVATE_KEY_PATH     => 'efg',
                    Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
                    Env::OAUTH2_PUBLIC_KEY_PATH      => Security::TEST_OAUTH2_PUBLIC_KEY_PATH,
                    Env::OAUTH2_ENCRYPTION_KEY       => 'hij',
                ],
                [
                    'display_errors' => '',
                ],
            ],
            'test-oauth2-encryption-key'       => [
                [
                    Env::DB_PASSWORD                 => 'abc',
                    Env::ENCRYPTION_KEY              => 'bcd',
                    Env::CRYPTO_FRONTEND_SALT        => 'cde',
                    Env::CRYPTO_ENCRYPTION_PEPPER    => 'def',
                    Env::OAUTH2_PRIVATE_KEY_PATH     => 'efg',
                    Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
                    Env::OAUTH2_PUBLIC_KEY_PATH      => 'ghi',
                    Env::OAUTH2_ENCRYPTION_KEY       => Security::TEST_OAUTH2_ENCRYPTION_KEY,
                ],
                [
                    'display_errors' => '',
                ],
            ],
            'display_errors-on'                => [
                [
                    Env::DB_PASSWORD                 => 'abc',
                    Env::ENCRYPTION_KEY              => 'bcd',
                    Env::CRYPTO_FRONTEND_SALT        => 'cde',
                    Env::CRYPTO_ENCRYPTION_PEPPER    => 'def',
                    Env::OAUTH2_PRIVATE_KEY_PATH     => 'efg',
                    Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
                    Env::OAUTH2_PUBLIC_KEY_PATH      => 'ghi',
                    Env::OAUTH2_ENCRYPTION_KEY       => 'hij',
                ],
                [
                    'display_errors' => '1',
                ],
            ],
        ];
    }

    /**
     * @dataProvider handleThrowsSecurityExceptionIfNeededProvider
     *
     * @param array $environmentData
     * @param array $settingsData
     */
    public function testHandleThrowsSecurityExceptionIfNeeded(array $environmentData, array $settingsData): void
    {
        $this->expectException(\AbterPhp\Framework\Exception\Security::class);

        $sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);

        /** @var Request|MockObject $requestMock */
        $requestMock = $this->createMock(Request::class);

        /** @var Response|MockObject $requestMock */
        $responseMock = $this->createMock(Response::class);

        $next = fn () => $responseMock;

        $sut->setVar($environmentData);

        $sut->setSettings($settingsData);

        $this->cacheBridgeMock->expects($this->any())->method('get')->willReturn(false);

        $actualResult = $sut->handle($requestMock, $next);

        $this->assertSame($responseMock, $actualResult);
    }

    public function testGetSettingsCanUseValuesSet(): void
    {
        $key   = 'foo';
        $value = 'bar';

        $sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);

        $sut->setSettings([$key => $value]);

        $actualValue = $sut->getSetting($key);

        $this->assertSame($actualValue, $value);
    }

    public function testGetSettingsCanCheckPhpSettingsIfValueIsNotSet(): void
    {
        $key   = 'memory_limit';
        $value = ini_get($key);

        $sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);

        $actualValue = $sut->getSetting($key);

        $this->assertSame($actualValue, $value);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace AbterPhp\Framework\Http\Middleware;
6
7			use AbterPhp\Framework\Constant\Env;
8			use Exception;
9			use Opulence\Cache\ArrayBridge;
10			use Opulence\Environments\Environment;
11			use Opulence\Http\Requests\Request;
12			use Opulence\Http\Responses\Response;
13			use PHPUnit\Framework\MockObject\MockObject;
14			use PHPUnit\Framework\TestCase;
15
16			class SecurityTest extends TestCase
17			{
18			/** @var ArrayBridge\|MockObject */
19			protected $cacheBridgeMock;
20
21			public function setUp(): void
22			{
23			parent::setUp();
24
25			$this->cacheBridgeMock = $this->createMock(ArrayBridge::class);
26			}
27
28			public function testHandleSkipsAllIfEnvironmentIsNotProduction(): void
29			{
30			$sut = new Security($this->cacheBridgeMock, Environment::TESTING);
31
32			/** @var Request\|MockObject $requestMock */
33			$requestMock = $this->createMock(Request::class);
34
35			/** @var Response\|MockObject $requestMock */
36			$responseMock = $this->createMock(Response::class);
37
38			$next = fn () => $responseMock;
39
40			$this->cacheBridgeMock->expects($this->never())->method('get');
41
42			$actualResult = $sut->handle($requestMock, $next);
43
44			$this->assertSame($responseMock, $actualResult);
45			}
46
47			public function testHandleSkipsAllIfCacheIsSet(): void
48			{
49			$sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);
50
51			/** @var Request\|MockObject $requestMock */
52			$requestMock = $this->createMock(Request::class);
53
54			/** @var Response\|MockObject $requestMock */
55			$responseMock = $this->createMock(Response::class);
56
57			$next = fn () => $responseMock;
58
59			$this->cacheBridgeMock->expects($this->once())->method('get')->willReturn(true);
60
61			$actualResult = $sut->handle($requestMock, $next);
62
63			$this->assertSame($responseMock, $actualResult);
64			}
65
66			public function testHandleSetsCacheIfAllGood(): void
67			{
68			$sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);
69
70			/** @var Request\|MockObject $requestMock */
71			$requestMock = $this->createMock(Request::class);
72
73			/** @var Response\|MockObject $requestMock */
74			$responseMock = $this->createMock(Response::class);
75
76			$next = fn () => $responseMock;
77
78			$sut->setVar(
79			[
80			Env::DB_PASSWORD => 'abc',
81			Env::ENCRYPTION_KEY => 'bcd',
82			Env::CRYPTO_FRONTEND_SALT => 'cde',
83			Env::CRYPTO_ENCRYPTION_PEPPER => 'def',
84			Env::OAUTH2_PRIVATE_KEY_PATH => 'efg',
85			Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
86			Env::OAUTH2_PUBLIC_KEY_PATH => 'ghi',
87			Env::OAUTH2_ENCRYPTION_KEY => 'hij',
88			]
89			);
90
91			$sut->setSettings(['display_errors' => '']);
92
93			$this->cacheBridgeMock->expects($this->any())->method('get')->willReturn(false);
94			$this->cacheBridgeMock->expects($this->once())->method('set')->willReturn(true);
95
96			$actualResult = $sut->handle($requestMock, $next);
97
98			$this->assertSame($responseMock, $actualResult);
99			}
100
101			public function testHandleRunsNormalIfCacheGetThrowsException(): void
102			{
103			$sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);
104
105			/** @var Request\|MockObject $requestMock */
106			$requestMock = $this->createMock(Request::class);
107
108			/** @var Response\|MockObject $requestMock */
109			$responseMock = $this->createMock(Response::class);
110
111			$next = fn () => $responseMock;
112
113			$sut->setVar(
114			[
115			Env::DB_PASSWORD => 'abc',
116			Env::ENCRYPTION_KEY => 'bcd',
117			Env::CRYPTO_FRONTEND_SALT => 'cde',
118			Env::CRYPTO_ENCRYPTION_PEPPER => 'def',
119			Env::OAUTH2_PRIVATE_KEY_PATH => 'efg',
120			Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
121			Env::OAUTH2_PUBLIC_KEY_PATH => 'ghi',
122			Env::OAUTH2_ENCRYPTION_KEY => 'hij',
123			]
124			);
125
126			$sut->setSettings(['display_errors' => '']);
127
128			$this->cacheBridgeMock->expects($this->any())->method('get')->willThrowException(new Exception());
129			$this->cacheBridgeMock->expects($this->once())->method('set')->willReturn(true);
130
131			$actualResult = $sut->handle($requestMock, $next);
132
133			$this->assertSame($responseMock, $actualResult);
134			}
135
136			public function handleThrowsSecurityExceptionIfNeededProvider(): array
137			{
138			return [
139			'test-password' => [
140			[
141			Env::DB_PASSWORD => Security::TEST_DB_PASSWORD,
142			Env::ENCRYPTION_KEY => 'bcd',
143			Env::CRYPTO_FRONTEND_SALT => 'cde',
144			Env::CRYPTO_ENCRYPTION_PEPPER => 'def',
145			Env::OAUTH2_PRIVATE_KEY_PATH => 'efg',
146			Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
147			Env::OAUTH2_PUBLIC_KEY_PATH => 'ghi',
148			Env::OAUTH2_ENCRYPTION_KEY => 'hij',
149			],
150			[
151			'display_errors' => '',
152			],
153			],
154			'test-encryption-key' => [
155			[
156			Env::DB_PASSWORD => 'abc',
157			Env::ENCRYPTION_KEY => Security::TEST_ENCRYPTION_KEY,
158			Env::CRYPTO_FRONTEND_SALT => 'cde',
159			Env::CRYPTO_ENCRYPTION_PEPPER => 'def',
160			Env::OAUTH2_PRIVATE_KEY_PATH => 'efg',
161			Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
162			Env::OAUTH2_PUBLIC_KEY_PATH => 'ghi',
163			Env::OAUTH2_ENCRYPTION_KEY => 'hij',
164			],
165			[
166			'display_errors' => '',
167			],
168			],
169			'test-frontend-salt' => [
170			[
171			Env::DB_PASSWORD => 'abc',
172			Env::ENCRYPTION_KEY => 'bcd',
173			Env::CRYPTO_FRONTEND_SALT => Security::TEST_CRYPTO_FRONTEND_SALT,
174			Env::CRYPTO_ENCRYPTION_PEPPER => 'def',
175			Env::OAUTH2_PRIVATE_KEY_PATH => 'efg',
176			Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
177			Env::OAUTH2_PUBLIC_KEY_PATH => 'ghi',
178			Env::OAUTH2_ENCRYPTION_KEY => 'hij',
179			],
180			[
181			'display_errors' => '',
182			],
183			],
184			'test-encryption-pepper' => [
185			[
186			Env::DB_PASSWORD => 'abc',
187			Env::ENCRYPTION_KEY => 'bcd',
188			Env::CRYPTO_FRONTEND_SALT => 'cde',
189			Env::CRYPTO_ENCRYPTION_PEPPER => Security::TEST_CRYPTO_ENCRYPTION_PEPPER,
190			Env::OAUTH2_PRIVATE_KEY_PATH => 'efg',
191			Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
192			Env::OAUTH2_PUBLIC_KEY_PATH => 'ghi',
193			Env::OAUTH2_ENCRYPTION_KEY => 'hij',
194			],
195			[
196			'display_errors' => '',
197			],
198			],
199			'test-oauth2-private-key-path' => [
200			[
201			Env::DB_PASSWORD => 'abc',
202			Env::ENCRYPTION_KEY => 'bcd',
203			Env::CRYPTO_FRONTEND_SALT => 'cde',
204			Env::CRYPTO_ENCRYPTION_PEPPER => 'def',
205			Env::OAUTH2_PRIVATE_KEY_PATH => Security::TEST_OAUTH2_PRIVATE_KEY_PATH,
206			Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
207			Env::OAUTH2_PUBLIC_KEY_PATH => 'ghi',
208			Env::OAUTH2_ENCRYPTION_KEY => 'hij',
209			],
210			[
211			'display_errors' => '',
212			],
213			],
214			'test-oauth2-private-key-password' => [
215			[
216			Env::DB_PASSWORD => 'abc',
217			Env::ENCRYPTION_KEY => 'bcd',
218			Env::CRYPTO_FRONTEND_SALT => 'cde',
219			Env::CRYPTO_ENCRYPTION_PEPPER => 'def',
220			Env::OAUTH2_PRIVATE_KEY_PATH => 'efg',
221			Env::OAUTH2_PRIVATE_KEY_PASSWORD => Security::TEST_OAUTH2_PRIVATE_KEY_PASSWORD,
222			Env::OAUTH2_PUBLIC_KEY_PATH => 'ghi',
223			Env::OAUTH2_ENCRYPTION_KEY => 'hij',
224			],
225			[
226			'display_errors' => '',
227			],
228			],
229			'test-oauth2-public-key-path' => [
230			[
231			Env::DB_PASSWORD => 'abc',
232			Env::ENCRYPTION_KEY => 'bcd',
233			Env::CRYPTO_FRONTEND_SALT => 'cde',
234			Env::CRYPTO_ENCRYPTION_PEPPER => 'def',
235			Env::OAUTH2_PRIVATE_KEY_PATH => 'efg',
236			Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
237			Env::OAUTH2_PUBLIC_KEY_PATH => Security::TEST_OAUTH2_PUBLIC_KEY_PATH,
238			Env::OAUTH2_ENCRYPTION_KEY => 'hij',
239			],
240			[
241			'display_errors' => '',
242			],
243			],
244			'test-oauth2-encryption-key' => [
245			[
246			Env::DB_PASSWORD => 'abc',
247			Env::ENCRYPTION_KEY => 'bcd',
248			Env::CRYPTO_FRONTEND_SALT => 'cde',
249			Env::CRYPTO_ENCRYPTION_PEPPER => 'def',
250			Env::OAUTH2_PRIVATE_KEY_PATH => 'efg',
251			Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
252			Env::OAUTH2_PUBLIC_KEY_PATH => 'ghi',
253			Env::OAUTH2_ENCRYPTION_KEY => Security::TEST_OAUTH2_ENCRYPTION_KEY,
254			],
255			[
256			'display_errors' => '',
257			],
258			],
259			'display_errors-on' => [
260			[
261			Env::DB_PASSWORD => 'abc',
262			Env::ENCRYPTION_KEY => 'bcd',
263			Env::CRYPTO_FRONTEND_SALT => 'cde',
264			Env::CRYPTO_ENCRYPTION_PEPPER => 'def',
265			Env::OAUTH2_PRIVATE_KEY_PATH => 'efg',
266			Env::OAUTH2_PRIVATE_KEY_PASSWORD => 'fgh',
267			Env::OAUTH2_PUBLIC_KEY_PATH => 'ghi',
268			Env::OAUTH2_ENCRYPTION_KEY => 'hij',
269			],
270			[
271			'display_errors' => '1',
272			],
273			],
274			];
275			}
276
277			/**
278			* @dataProvider handleThrowsSecurityExceptionIfNeededProvider
279			*
280			* @param array $environmentData
281			* @param array $settingsData
282			*/
283			public function testHandleThrowsSecurityExceptionIfNeeded(array $environmentData, array $settingsData): void
284			{
285			$this->expectException(\AbterPhp\Framework\Exception\Security::class);
286
287			$sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);
288
289			/** @var Request\|MockObject $requestMock */
290			$requestMock = $this->createMock(Request::class);
291
292			/** @var Response\|MockObject $requestMock */
293			$responseMock = $this->createMock(Response::class);
294
295			$next = fn () => $responseMock;
296
297			$sut->setVar($environmentData);
298
299			$sut->setSettings($settingsData);
300
301			$this->cacheBridgeMock->expects($this->any())->method('get')->willReturn(false);
302
303			$actualResult = $sut->handle($requestMock, $next);
304
305			$this->assertSame($responseMock, $actualResult);
306			}
307
308			public function testGetSettingsCanUseValuesSet(): void
309			{
310			$key = 'foo';
311			$value = 'bar';
312
313			$sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);
314
315			$sut->setSettings([$key => $value]);
316
317			$actualValue = $sut->getSetting($key);
318
319			$this->assertSame($actualValue, $value);
320			}
321
322			public function testGetSettingsCanCheckPhpSettingsIfValueIsNotSet(): void
323			{
324			$key = 'memory_limit';
325			$value = ini_get($key);
326
327			$sut = new Security($this->cacheBridgeMock, Environment::PRODUCTION);
328
329			$actualValue = $sut->getSetting($key);
330
331			$this->assertSame($actualValue, $value);
332			}
333			}
334

abterphp / framework

SecurityTest::testHandleSetsCacheIfAllGood() A last analyzed 2023-01-23 22:11 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SecurityTest::testHandleSetsCacheIfAllGood() A
last analyzed 2023-01-23 22:11 UTC