SecurityTest - Code Metrics - Inspection of "Github-Action" - abterphp/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1)

by Peter

created 2021-02-27 14:51 UTC

SecurityTest A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	326
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	171
dl	0
loc	326
rs	10
c	0
b	0
f	0
wmc	9

9 Methods

Rating	Name	Size	Complexity
A	testGetSettingsCanCheckPhpSettingsIfValueIsNotSet()	10	1
A	testHandleSkipsAllIfEnvironmentIsNotProduction()	19	1
B	handleThrowsSecurityExceptionIfNeededProvider()	136	1
A	setUp()	5	1
A	testGetSettingsCanUseValuesSet()	12	1
A	testHandleThrowsSecurityExceptionIfNeeded()	25	1
A	testHandleSkipsAllIfCacheIsSet()	19	1
A	testHandleRunsNormalIfCacheGetThrowsException()	35	1
A	testHandleSetsCacheIfAllGood()	35	1

<?php

declare(strict_types=1);

namespace AbterPhp\Framework\Http\Middleware;

use AbterPhp\Framework\Constant\Env;
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()
    {
        $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 = function () use ($responseMock) {
            return $responseMock;
        };

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

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

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

    public function testHandleSkipsAllIfCacheIsSet()
    {
        $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 = function () use ($responseMock) {
            return $responseMock;
        };

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

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

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

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

abterphp / framework

Pull Request — master (#1)

SecurityTest A

Complexity

Size/Duplication

Importance

9 Methods

Duplication Side-by-Side

Filter issues like