AwsS3V3AdapterTest::failing_to_delete_a_file() - Code Metrics - Inspection of "Corrected meta getting failure detection" - thephpleague/flysystem-aws-s3-v3 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 2.x ( 01e849...3ea09a )

by Frank

created 2020-10-21 20:12 UTC

AwsS3V3AdapterTest::failing_to_delete_a_file() A

↳ Parent: AwsS3V3AdapterTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.9666
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

namespace League\Flysystem\AwsS3V3;

use Aws\Result;
use Aws\S3\S3Client;
use Aws\S3\S3ClientInterface;
use Generator;
use League\Flysystem\AdapterTestUtilities\FilesystemAdapterTestCase;
use League\Flysystem\Config;
use League\Flysystem\FileAttributes;
use League\Flysystem\FilesystemAdapter;
use League\Flysystem\StorageAttributes;
use League\Flysystem\UnableToCheckFileExistence;
use League\Flysystem\UnableToDeleteFile;
use League\Flysystem\UnableToMoveFile;

/**
 * @group aws
 */
class AwsS3V3AdapterTest extends FilesystemAdapterTestCase
{
    /**
     * @var bool
     */
    private $shouldCleanUp = false;

    /**
     * @var string
     */
    private static $adapterPrefix = 'test-prefix';

    /**
     * @var S3ClientInterface|null
     */
    private static $s3Client;

    /**
     * @var S3ClientStub
     */
    private static $stubS3Client;

    public static function setUpBeforeClass(): void
    {
        static::$adapterPrefix = 'ci/' . bin2hex(random_bytes(10));
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }

    protected function tearDown(): void
    {
        if ( ! $this->shouldCleanUp) {
            return;
        }

        $adapter = $this->adapter();
        $adapter->deleteDirectory('/');
        /** @var StorageAttributes[] $listing */
        $listing = $adapter->listContents('', false);

        foreach ($listing as $item) {
            if ($item->isFile()) {
                $adapter->delete($item->path());
            } else {
                $adapter->deleteDirectory($item->path());
            }
        }
    }

    private static function s3Client(): S3ClientInterface
    {
        if (static::$s3Client instanceof S3ClientInterface) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            return static::$s3Client;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        }

        $key = getenv('FLYSYSTEM_AWS_S3_KEY');
        $secret = getenv('FLYSYSTEM_AWS_S3_SECRET');
        $bucket = getenv('FLYSYSTEM_AWS_S3_BUCKET');
        $region = getenv('FLYSYSTEM_AWS_S3_REGION') ?: 'eu-central-1';

        if ( ! $key || ! $secret || ! $bucket) {
            self::markTestSkipped('No AWS credentials present for testing.');
        }

        $options = ['version' => 'latest', 'credentials' => compact('key', 'secret'), 'region' => $region];

        return static::$s3Client = new S3Client($options);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }

    /**
     * @test
     */
    public function writing_with_a_specific_mime_type(): void
    {
        $adapter = $this->adapter();
        $adapter->write('some/path.txt', 'contents', new Config(['ContentType' => 'text/plain+special']));
        $mimeType = $adapter->mimeType('some/path.txt')->mimeType();
        $this->assertEquals('text/plain+special', $mimeType);
    }

    /**
     * @test
     */
    public function listing_contents_recursive(): void
    {
        $adapter = $this->adapter();
        $adapter->write('something/0/here.txt', 'contents', new Config());
        $adapter->write('something/1/also/here.txt', 'contents', new Config());

        $contents = iterator_to_array($adapter->listContents('', true));

        $this->assertCount(2, $contents);
        $this->assertContainsOnlyInstancesOf(FileAttributes::class, $contents);
        /** @var FileAttributes $file */
        $file = $contents[0];
        $this->assertEquals('something/0/here.txt', $file->path());
        /** @var FileAttributes $file */
        $file = $contents[1];
        $this->assertEquals('something/1/also/here.txt', $file->path());
    }

    /**
     * @test
     */
    public function failing_to_delete_while_moving(): void
    {
        $adapter = $this->adapter();
        $adapter->write('source.txt', 'contents to be copied', new Config());
        static::$stubS3Client->failOnNextCopy();
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        $this->expectException(UnableToMoveFile::class);

        $adapter->move('source.txt', 'destination.txt', new Config());
    }

    /**
     * @test
     */
    public function failing_to_delete_a_file(): void
    {
        $adapter = $this->adapter();
        static::$stubS3Client->throwExceptionWhenExecutingCommand('DeleteObject');
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        $this->expectException(UnableToDeleteFile::class);

        $adapter->delete('path.txt');
    }

    /**
     * @test
     */
    public function fetching_unknown_mime_type_of_a_file(): void
    {
        $this->adapter();
        $result = new Result([
            'Key' => static::$adapterPrefix . '/unknown-mime-type.md5',
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        ]);
        static::$stubS3Client->stageResultForCommand('HeadObject', $result);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        parent::fetching_unknown_mime_type_of_a_file();
    }

    /**
     * @test
     */
    public function failing_to_check_for_file_existence(): void
    {
        $adapter = $this->adapter();

        static::$stubS3Client->throw500ExceptionWhenExecutingCommand('HeadObject');
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        $this->expectException(UnableToCheckFileExistence::class);

        $adapter->fileExists('something-that-does-exist.txt');
    }

    /**
     * @test
     * @dataProvider casesWhereHttpStreamingInfluencesSeekability
     */
    public function streaming_reads_are_not_seekable_and_non_streaming_are(bool $streaming, bool $seekable): void
    {
        if (getenv('COMPOSER_OPTS') === '--prefer-lowest') {
            $this->markTestSkipped('The SDK does not support streaming in low versions.');
        }

        $adapter = $this->useAdapter($this->createFilesystemAdapter($streaming));
        $this->givenWeHaveAnExistingFile('path.txt');

        $resource = $adapter->readStream('path.txt');
        $metadata = stream_get_meta_data($resource);
        fclose($resource);

        $this->assertEquals($seekable, $metadata['seekable']);
    }

    public function casesWhereHttpStreamingInfluencesSeekability(): Generator
    {
        yield "not streaming reads have seekable stream" => [false, true];
        yield "streaming reads have non-seekable stream" => [true, false];
    }

    /**
     * @test
     * @dataProvider casesWhereHttpStreamingInfluencesSeekability
     */
    public function configuring_http_streaming_via_options(bool $streaming): void
    {
        $adapter = $this->useAdapter($this->createFilesystemAdapter($streaming, ['@http' => ['stream' => false]]));
        $this->givenWeHaveAnExistingFile('path.txt');

        $resource = $adapter->readStream('path.txt');
        $metadata = stream_get_meta_data($resource);
        fclose($resource);

        $this->assertTrue($metadata['seekable']);
    }

    protected static function createFilesystemAdapter(bool $streaming = true, array $options = []): FilesystemAdapter
    {
        static::$stubS3Client = new S3ClientStub(static::s3Client());
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        /** @var string $bucket */
        $bucket = getenv('FLYSYSTEM_AWS_S3_BUCKET');
        $prefix = getenv('FLYSYSTEM_AWS_S3_PREFIX') ?: static::$adapterPrefix;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}

        return new AwsS3V3Adapter(static::$stubS3Client, $bucket, $prefix, null, null, $options, $streaming);
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace League\Flysystem\AwsS3V3;
6
7			use Aws\Result;
8			use Aws\S3\S3Client;
9			use Aws\S3\S3ClientInterface;
10			use Generator;
11			use League\Flysystem\AdapterTestUtilities\FilesystemAdapterTestCase;
12			use League\Flysystem\Config;
13			use League\Flysystem\FileAttributes;
14			use League\Flysystem\FilesystemAdapter;
15			use League\Flysystem\StorageAttributes;
16			use League\Flysystem\UnableToCheckFileExistence;
17			use League\Flysystem\UnableToDeleteFile;
18			use League\Flysystem\UnableToMoveFile;
19
20			/**
21			* @group aws
22			*/
23			class AwsS3V3AdapterTest extends FilesystemAdapterTestCase
24			{
25			/**
26			* @var bool
27			*/
28			private $shouldCleanUp = false;
29
30			/**
31			* @var string
32			*/
33			private static $adapterPrefix = 'test-prefix';
34
35			/**
36			* @var S3ClientInterface\|null
37			*/
38			private static $s3Client;
39
40			/**
41			* @var S3ClientStub
42			*/
43			private static $stubS3Client;
44
45			public static function setUpBeforeClass(): void
46			{
47			static::$adapterPrefix = 'ci/' . bin2hex(random_bytes(10));
			0 ignored issues – show Bug introduced 2020-03-08 16:13 UTC by Report Bug Copy Issue Report Since `$adapterPrefix` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$adapterPrefix` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
48			}
49
50			protected function tearDown(): void
51			{
52			if ( ! $this->shouldCleanUp) {
53			return;
54			}
55
56			$adapter = $this->adapter();
57			$adapter->deleteDirectory('/');
58			/** @var StorageAttributes[] $listing */
59			$listing = $adapter->listContents('', false);
60
61			foreach ($listing as $item) {
62			if ($item->isFile()) {
63			$adapter->delete($item->path());
64			} else {
65			$adapter->deleteDirectory($item->path());
66			}
67			}
68			}
69
70			private static function s3Client(): S3ClientInterface
71			{
72			if (static::$s3Client instanceof S3ClientInterface) {
			0 ignored issues – show Bug introduced 2020-08-23 06:51 UTC by Report Bug Copy Issue Report Since `$s3Client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$s3Client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
73			return static::$s3Client;
			0 ignored issues – show Bug introduced 2020-08-23 06:51 UTC by Report Bug Copy Issue Report Since `$s3Client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$s3Client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
74			}
75
76			$key = getenv('FLYSYSTEM_AWS_S3_KEY');
77			$secret = getenv('FLYSYSTEM_AWS_S3_SECRET');
78			$bucket = getenv('FLYSYSTEM_AWS_S3_BUCKET');
79			$region = getenv('FLYSYSTEM_AWS_S3_REGION') ?: 'eu-central-1';
80
81			if ( ! $key \|\| ! $secret \|\| ! $bucket) {
82			self::markTestSkipped('No AWS credentials present for testing.');
83			}
84
85			$options = ['version' => 'latest', 'credentials' => compact('key', 'secret'), 'region' => $region];
86
87			return static::$s3Client = new S3Client($options);
			0 ignored issues – show Bug introduced 2020-08-23 06:51 UTC by Report Bug Copy Issue Report Since `$s3Client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$s3Client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
88			}
89
90			/**
91			* @test
92			*/
93			public function writing_with_a_specific_mime_type(): void
94			{
95			$adapter = $this->adapter();
96			$adapter->write('some/path.txt', 'contents', new Config(['ContentType' => 'text/plain+special']));
97			$mimeType = $adapter->mimeType('some/path.txt')->mimeType();
98			$this->assertEquals('text/plain+special', $mimeType);
99			}
100
101			/**
102			* @test
103			*/
104			public function listing_contents_recursive(): void
105			{
106			$adapter = $this->adapter();
107			$adapter->write('something/0/here.txt', 'contents', new Config());
108			$adapter->write('something/1/also/here.txt', 'contents', new Config());
109
110			$contents = iterator_to_array($adapter->listContents('', true));
111
112			$this->assertCount(2, $contents);
113			$this->assertContainsOnlyInstancesOf(FileAttributes::class, $contents);
114			/** @var FileAttributes $file */
115			$file = $contents[0];
116			$this->assertEquals('something/0/here.txt', $file->path());
117			/** @var FileAttributes $file */
118			$file = $contents[1];
119			$this->assertEquals('something/1/also/here.txt', $file->path());
120			}
121
122			/**
123			* @test
124			*/
125			public function failing_to_delete_while_moving(): void
126			{
127			$adapter = $this->adapter();
128			$adapter->write('source.txt', 'contents to be copied', new Config());
129			static::$stubS3Client->failOnNextCopy();
			0 ignored issues – show Bug introduced 2020-10-13 12:48 UTC by Report Bug Copy Issue Report Since `$stubS3Client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$stubS3Client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
130
131			$this->expectException(UnableToMoveFile::class);
132
133			$adapter->move('source.txt', 'destination.txt', new Config());
134			}
135
136			/**
137			* @test
138			*/
139			public function failing_to_delete_a_file(): void
140			{
141			$adapter = $this->adapter();
142			static::$stubS3Client->throwExceptionWhenExecutingCommand('DeleteObject');
			0 ignored issues – show Bug introduced 2020-08-23 06:51 UTC by Report Bug Copy Issue Report Since `$stubS3Client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$stubS3Client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
143
144			$this->expectException(UnableToDeleteFile::class);
145
146			$adapter->delete('path.txt');
147			}
148
149			/**
150			* @test
151			*/
152			public function fetching_unknown_mime_type_of_a_file(): void
153			{
154			$this->adapter();
155			$result = new Result([
156			'Key' => static::$adapterPrefix . '/unknown-mime-type.md5',
			0 ignored issues – show Bug introduced 2020-10-21 19:36 UTC by Report Bug Copy Issue Report Since `$adapterPrefix` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$adapterPrefix` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
157			]);
158			static::$stubS3Client->stageResultForCommand('HeadObject', $result);
			0 ignored issues – show Bug introduced 2020-10-21 19:36 UTC by Report Bug Copy Issue Report Since `$stubS3Client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$stubS3Client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
159
160			parent::fetching_unknown_mime_type_of_a_file();
161			}
162
163			/**
164			* @test
165			*/
166			public function failing_to_check_for_file_existence(): void
167			{
168			$adapter = $this->adapter();
169
170			static::$stubS3Client->throw500ExceptionWhenExecutingCommand('HeadObject');
			0 ignored issues – show Bug introduced 2020-08-23 06:51 UTC by Report Bug Copy Issue Report Since `$stubS3Client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$stubS3Client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
171
172			$this->expectException(UnableToCheckFileExistence::class);
173
174			$adapter->fileExists('something-that-does-exist.txt');
175			}
176
177			/**
178			* @test
179			* @dataProvider casesWhereHttpStreamingInfluencesSeekability
180			*/
181			public function streaming_reads_are_not_seekable_and_non_streaming_are(bool $streaming, bool $seekable): void
182			{
183			if (getenv('COMPOSER_OPTS') === '--prefer-lowest') {
184			$this->markTestSkipped('The SDK does not support streaming in low versions.');
185			}
186
187			$adapter = $this->useAdapter($this->createFilesystemAdapter($streaming));
188			$this->givenWeHaveAnExistingFile('path.txt');
189
190			$resource = $adapter->readStream('path.txt');
191			$metadata = stream_get_meta_data($resource);
192			fclose($resource);
193
194			$this->assertEquals($seekable, $metadata['seekable']);
195			}
196
197			public function casesWhereHttpStreamingInfluencesSeekability(): Generator
198			{
199			yield "not streaming reads have seekable stream" => [false, true];
200			yield "streaming reads have non-seekable stream" => [true, false];
201			}
202
203			/**
204			* @test
205			* @dataProvider casesWhereHttpStreamingInfluencesSeekability
206			*/
207			public function configuring_http_streaming_via_options(bool $streaming): void
208			{
209			$adapter = $this->useAdapter($this->createFilesystemAdapter($streaming, ['@http' => ['stream' => false]]));
210			$this->givenWeHaveAnExistingFile('path.txt');
211
212			$resource = $adapter->readStream('path.txt');
213			$metadata = stream_get_meta_data($resource);
214			fclose($resource);
215
216			$this->assertTrue($metadata['seekable']);
217			}
218
219			protected static function createFilesystemAdapter(bool $streaming = true, array $options = []): FilesystemAdapter
220			{
221			static::$stubS3Client = new S3ClientStub(static::s3Client());
			0 ignored issues – show Bug introduced 2020-08-23 06:51 UTC by Report Bug Copy Issue Report Since `$stubS3Client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$stubS3Client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history... Bug introduced 2020-08-23 06:51 UTC by Report Bug Copy Issue Report Since `s3Client()` is declared private, calling it with `static` will lead to errors in possible sub-classes. You can either use `self`, or increase the visibility of `s3Client()` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return static::getTemperature(); } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { private static function getTemperature() { return "-182 °C"; } } print YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class YourClass { private static function getTemperature() { return "3422 °C"; } public static function getSomeVariable() { return self::getTemperature(); } } Loading history...
222			/** @var string $bucket */
223			$bucket = getenv('FLYSYSTEM_AWS_S3_BUCKET');
224			$prefix = getenv('FLYSYSTEM_AWS_S3_PREFIX') ?: static::$adapterPrefix;
			0 ignored issues – show Bug introduced 2020-03-08 16:13 UTC by Report Bug Copy Issue Report Since `$adapterPrefix` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$adapterPrefix` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
225
226			return new AwsS3V3Adapter(static::$stubS3Client, $bucket, $prefix, null, null, $options, $streaming);
			0 ignored issues – show Bug introduced 2020-08-23 06:51 UTC by Report Bug Copy Issue Report Since `$stubS3Client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$stubS3Client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
227			}
228			}
229

thephpleague / flysystem-aws-s3-v3

Push — 2.x ( 01e849...3ea09a )

AwsS3V3AdapterTest::failing_to_delete_a_file() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like