LocalInfoTest::testIsAdvancedUsage() - Code Metrics - Inspection of "Add storage engine component" - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#407)

by Kirill

created 2021-04-30 17:07 UTC

LocalInfoTest::testIsAdvancedUsage() A

↳ Parent: LocalInfoTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	53
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	31
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	53
rs	9.424

How to fix Long Method

<?php

declare(strict_types=1);

namespace Spiral\Tests\Storage\Unit\Config\DTO\FileSystemInfo;

use League\Flysystem\Local\LocalFilesystemAdapter;
use Spiral\Storage\Exception\ConfigException;
use Spiral\Storage\Config\DTO\FileSystemInfo\LocalInfo;
use Spiral\Storage\Exception\StorageException;
use Spiral\Storage\Resolver\AwsS3Resolver;
use Spiral\Storage\Resolver\LocalSystemResolver;
use Spiral\Tests\Storage\Unit\UnitTestCase;

class LocalInfoTest extends UnitTestCase
{
    /**
     * @throws StorageException
     */
    public function testValidateSimple(): void
    {
        $rootDirOption = LocalInfo::ROOT_DIR_KEY;
        $hostOption = LocalInfo::HOST_KEY;

        $missedOption = 'missedOption';

        $options = [
            $rootDirOption => '/some/root/',
            $hostOption => self::CONFIG_HOST,
            $missedOption => 'someMissedVal',
        ];

        $fsName = 'some';
        $fsInfo = new LocalInfo(
            $fsName,
            [
                LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
                LocalInfo::OPTIONS_KEY => $options,
            ]
        );

        $this->assertEquals(LocalFilesystemAdapter::class, $fsInfo->getAdapterClass());
        $this->assertEquals(LocalSystemResolver::class, $fsInfo->getResolverClass());
        $this->assertEquals($fsName, $fsInfo->getName());

        foreach ($options as $optionKey => $optionVal) {
            if ($optionKey === $missedOption) {
                $this->assertNull($fsInfo->getOption($optionKey));
                continue;
            }

            $this->assertEquals($optionVal, $fsInfo->getOption($optionKey));
        }
    }

    /**
     * @throws StorageException
     */
    public function testGetResolver(): void
    {
        $fsInfo = new LocalInfo(
            'someServer',
            [
                LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
                // wrong resolver but you can define any resolver
                LocalInfo::RESOLVER_KEY => AwsS3Resolver::class,
                LocalInfo::OPTIONS_KEY => [
                    LocalInfo::ROOT_DIR_KEY => '/some/root/',
                    LocalInfo::HOST_KEY => self::CONFIG_HOST,
                ],
            ]
        );

        $this->assertEquals(AwsS3Resolver::class, $fsInfo->getResolverClass());
    }

    /**
     * @dataProvider getMissedRequiredOptions
     *
     * @param string $fsName
     * @param array $options
     * @param string $exceptionMsg
     *
     * @throws StorageException
     */
    public function testValidateRequiredOptionsFailed(string $fsName, array $options, string $exceptionMsg): void
    {
        $this->expectException(ConfigException::class);
        $this->expectExceptionMessage($exceptionMsg);

        new LocalInfo(
            $fsName,
            [
                LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
                LocalInfo::OPTIONS_KEY => $options,
            ]
        );
    }

    /**
     * @throws StorageException
     */
    public function testValidateOptionalOptionsVisibilityFailed(): void
    {
        $this->expectException(ConfigException::class);
        $this->expectExceptionMessage(
            'Option `visibility` defined in wrong format for filesystem `some`, array expected'
        );

        new LocalInfo(
            'some',
            [
                LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
                LocalInfo::OPTIONS_KEY => [
                    LocalInfo::ROOT_DIR_KEY => '/some/dir/',
                    LocalInfo::HOST_KEY => self::CONFIG_HOST,
                    LocalInfo::VISIBILITY_KEY => 12,
                ],
            ]
        );
    }

    /**
     * @dataProvider getOptionalIntOptions
     *
     * @param string $label
     *
     * @throws StorageException
     */
    public function testValidateOptionalOptionsWriteFlagsFailed(string $label): void
    {
        $this->expectException(ConfigException::class);
        $this->expectExceptionMessage(
            \sprintf('Option `%s` defined in wrong format for filesystem `some`, int expected', $label)
        );

        new LocalInfo(
            'some',
            [
                LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
                LocalInfo::OPTIONS_KEY => [
                    LocalInfo::ROOT_DIR_KEY => '/some/dir/',
                    LocalInfo::HOST_KEY => self::CONFIG_HOST,
                    $label => 'MyFlag',
                ],
            ]
        );
    }

    /**
     * @throws StorageException
     */
    public function testIsAdvancedUsage(): void
    {
        $simpleLocal = new LocalInfo(
            'some',
            [
                LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
                LocalInfo::OPTIONS_KEY => [
                    LocalInfo::ROOT_DIR_KEY => '/some/root/',
                    LocalInfo::HOST_KEY => self::CONFIG_HOST,
                ],
            ]
        );

        $this->assertFalse($simpleLocal->isAdvancedUsage());

        $baseAdvancedUsage = new LocalInfo(
            'some',
            [
                LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
                LocalInfo::OPTIONS_KEY => [
                    LocalInfo::ROOT_DIR_KEY => '/some/root/',
                    LocalInfo::HOST_KEY => self::CONFIG_HOST,
                    LocalInfo::WRITE_FLAGS_KEY => LOCK_EX,
                ],
            ]
        );

        $this->assertTrue($baseAdvancedUsage->isAdvancedUsage());

        $advancedUsage = new LocalInfo(
            'some',
            [
                LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
                LocalInfo::OPTIONS_KEY => [
                    LocalInfo::ROOT_DIR_KEY => '/some/root/',
                    LocalInfo::HOST_KEY => self::CONFIG_HOST,
                    LocalInfo::WRITE_FLAGS_KEY => LOCK_EX,
                    LocalInfo::LINK_HANDLING_KEY => LocalFilesystemAdapter::DISALLOW_LINKS,
                    LocalInfo::VISIBILITY_KEY => [
                        'file' => [
                            'public' => 0640,
                            'private' => 0604,
                        ],
                        'dir' => [
                            'public' => 0740,
                            'private' => 7604,
                        ],
                    ],
                ],
            ]
        );

        $this->assertTrue($advancedUsage->isAdvancedUsage());
    }

    /**
     * @throws StorageException
     */
    public function testIntParamsUsage(): void
    {
        $baseAdvancedUsage = new LocalInfo(
            'some',
            [
                LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
                LocalInfo::OPTIONS_KEY => [
                    LocalInfo::ROOT_DIR_KEY => '/some/root/',
                    LocalInfo::HOST_KEY => self::CONFIG_HOST,
                    LocalInfo::WRITE_FLAGS_KEY => '15',
                ],
            ]
        );

        $this->assertIsInt($baseAdvancedUsage->getOption(LocalInfo::WRITE_FLAGS_KEY));
    }

    public function getMissedRequiredOptions(): array
    {
        $fsName = self::SERVER_NAME;

        return [
            [
                $fsName,
                [],
                \sprintf('Option `rootDir` not detected for filesystem `%s`', $fsName),
            ],
            [
                'some',
                [
                    LocalInfo::HOST_KEY => self::CONFIG_HOST,
                ],
                'Option `rootDir` not detected for filesystem `some`'
            ]
        ];
    }

    public function getOptionalIntOptions(): array
    {
        return [
            [LocalInfo::WRITE_FLAGS_KEY],
            [LocalInfo::LINK_HANDLING_KEY]
        ];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Spiral\Tests\Storage\Unit\Config\DTO\FileSystemInfo;
6
7			use League\Flysystem\Local\LocalFilesystemAdapter;
8			use Spiral\Storage\Exception\ConfigException;
9			use Spiral\Storage\Config\DTO\FileSystemInfo\LocalInfo;
10			use Spiral\Storage\Exception\StorageException;
11			use Spiral\Storage\Resolver\AwsS3Resolver;
12			use Spiral\Storage\Resolver\LocalSystemResolver;
13			use Spiral\Tests\Storage\Unit\UnitTestCase;
14
15			class LocalInfoTest extends UnitTestCase
16			{
17			/**
18			* @throws StorageException
19			*/
20			public function testValidateSimple(): void
21			{
22			$rootDirOption = LocalInfo::ROOT_DIR_KEY;
23			$hostOption = LocalInfo::HOST_KEY;
24
25			$missedOption = 'missedOption';
26
27			$options = [
28			$rootDirOption => '/some/root/',
29			$hostOption => self::CONFIG_HOST,
30			$missedOption => 'someMissedVal',
31			];
32
33			$fsName = 'some';
34			$fsInfo = new LocalInfo(
35			$fsName,
36			[
37			LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
38			LocalInfo::OPTIONS_KEY => $options,
39			]
40			);
41
42			$this->assertEquals(LocalFilesystemAdapter::class, $fsInfo->getAdapterClass());
43			$this->assertEquals(LocalSystemResolver::class, $fsInfo->getResolverClass());
44			$this->assertEquals($fsName, $fsInfo->getName());
45
46			foreach ($options as $optionKey => $optionVal) {
47			if ($optionKey === $missedOption) {
48			$this->assertNull($fsInfo->getOption($optionKey));
49			continue;
50			}
51
52			$this->assertEquals($optionVal, $fsInfo->getOption($optionKey));
53			}
54			}
55
56			/**
57			* @throws StorageException
58			*/
59			public function testGetResolver(): void
60			{
61			$fsInfo = new LocalInfo(
62			'someServer',
63			[
64			LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
65			// wrong resolver but you can define any resolver
66			LocalInfo::RESOLVER_KEY => AwsS3Resolver::class,
67			LocalInfo::OPTIONS_KEY => [
68			LocalInfo::ROOT_DIR_KEY => '/some/root/',
69			LocalInfo::HOST_KEY => self::CONFIG_HOST,
70			],
71			]
72			);
73
74			$this->assertEquals(AwsS3Resolver::class, $fsInfo->getResolverClass());
75			}
76
77			/**
78			* @dataProvider getMissedRequiredOptions
79			*
80			* @param string $fsName
81			* @param array $options
82			* @param string $exceptionMsg
83			*
84			* @throws StorageException
85			*/
86			public function testValidateRequiredOptionsFailed(string $fsName, array $options, string $exceptionMsg): void
87			{
88			$this->expectException(ConfigException::class);
89			$this->expectExceptionMessage($exceptionMsg);
90
91			new LocalInfo(
92			$fsName,
93			[
94			LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
95			LocalInfo::OPTIONS_KEY => $options,
96			]
97			);
98			}
99
100			/**
101			* @throws StorageException
102			*/
103			public function testValidateOptionalOptionsVisibilityFailed(): void
104			{
105			$this->expectException(ConfigException::class);
106			$this->expectExceptionMessage(
107			'Option `visibility` defined in wrong format for filesystem `some`, array expected'
108			);
109
110			new LocalInfo(
111			'some',
112			[
113			LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
114			LocalInfo::OPTIONS_KEY => [
115			LocalInfo::ROOT_DIR_KEY => '/some/dir/',
116			LocalInfo::HOST_KEY => self::CONFIG_HOST,
117			LocalInfo::VISIBILITY_KEY => 12,
118			],
119			]
120			);
121			}
122
123			/**
124			* @dataProvider getOptionalIntOptions
125			*
126			* @param string $label
127			*
128			* @throws StorageException
129			*/
130			public function testValidateOptionalOptionsWriteFlagsFailed(string $label): void
131			{
132			$this->expectException(ConfigException::class);
133			$this->expectExceptionMessage(
134			\sprintf('Option `%s` defined in wrong format for filesystem `some`, int expected', $label)
135			);
136
137			new LocalInfo(
138			'some',
139			[
140			LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
141			LocalInfo::OPTIONS_KEY => [
142			LocalInfo::ROOT_DIR_KEY => '/some/dir/',
143			LocalInfo::HOST_KEY => self::CONFIG_HOST,
144			$label => 'MyFlag',
145			],
146			]
147			);
148			}
149
150			/**
151			* @throws StorageException
152			*/
153			public function testIsAdvancedUsage(): void
154			{
155			$simpleLocal = new LocalInfo(
156			'some',
157			[
158			LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
159			LocalInfo::OPTIONS_KEY => [
160			LocalInfo::ROOT_DIR_KEY => '/some/root/',
161			LocalInfo::HOST_KEY => self::CONFIG_HOST,
162			],
163			]
164			);
165
166			$this->assertFalse($simpleLocal->isAdvancedUsage());
167
168			$baseAdvancedUsage = new LocalInfo(
169			'some',
170			[
171			LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
172			LocalInfo::OPTIONS_KEY => [
173			LocalInfo::ROOT_DIR_KEY => '/some/root/',
174			LocalInfo::HOST_KEY => self::CONFIG_HOST,
175			LocalInfo::WRITE_FLAGS_KEY => LOCK_EX,
176			],
177			]
178			);
179
180			$this->assertTrue($baseAdvancedUsage->isAdvancedUsage());
181
182			$advancedUsage = new LocalInfo(
183			'some',
184			[
185			LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
186			LocalInfo::OPTIONS_KEY => [
187			LocalInfo::ROOT_DIR_KEY => '/some/root/',
188			LocalInfo::HOST_KEY => self::CONFIG_HOST,
189			LocalInfo::WRITE_FLAGS_KEY => LOCK_EX,
190			LocalInfo::LINK_HANDLING_KEY => LocalFilesystemAdapter::DISALLOW_LINKS,
191			LocalInfo::VISIBILITY_KEY => [
192			'file' => [
193			'public' => 0640,
194			'private' => 0604,
195			],
196			'dir' => [
197			'public' => 0740,
198			'private' => 7604,
199			],
200			],
201			],
202			]
203			);
204
205			$this->assertTrue($advancedUsage->isAdvancedUsage());
206			}
207
208			/**
209			* @throws StorageException
210			*/
211			public function testIntParamsUsage(): void
212			{
213			$baseAdvancedUsage = new LocalInfo(
214			'some',
215			[
216			LocalInfo::ADAPTER_KEY => LocalFilesystemAdapter::class,
217			LocalInfo::OPTIONS_KEY => [
218			LocalInfo::ROOT_DIR_KEY => '/some/root/',
219			LocalInfo::HOST_KEY => self::CONFIG_HOST,
220			LocalInfo::WRITE_FLAGS_KEY => '15',
221			],
222			]
223			);
224
225			$this->assertIsInt($baseAdvancedUsage->getOption(LocalInfo::WRITE_FLAGS_KEY));
226			}
227
228			public function getMissedRequiredOptions(): array
229			{
230			$fsName = self::SERVER_NAME;
231
232			return [
233			[
234			$fsName,
235			[],
236			\sprintf('Option `rootDir` not detected for filesystem `%s`', $fsName),
237			],
238			[
239			'some',
240			[
241			LocalInfo::HOST_KEY => self::CONFIG_HOST,
242			],
243			'Option `rootDir` not detected for filesystem `some`'
244			]
245			];
246			}
247
248			public function getOptionalIntOptions(): array
249			{
250			return [
251			[LocalInfo::WRITE_FLAGS_KEY],
252			[LocalInfo::LINK_HANDLING_KEY]
253			];
254			}
255			}
256

spiral / framework

Pull Request — master (#407)

LocalInfoTest::testIsAdvancedUsage() A

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like