ProcessorTest::testUploadEarly() - Code Metrics - Inspection of "Upload Per Partes - update php dependencies, tests..." - alex-kalanis/upload-per-partes - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1b6475...610123 )

by Petr

created 2023-05-17 03:05 UTC

ProcessorTest::testUploadEarly() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	14
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	12
nc	1
nop	0
dl	0
loc	14
rs	9.8666
c	0
b	0
f	0

<?php

namespace BasicTests;


use CommonTestClass;
use Support;
use kalanis\UploadPerPartes\Exceptions;
use kalanis\UploadPerPartes\InfoFormat;
use kalanis\UploadPerPartes\Interfaces;
use kalanis\UploadPerPartes\Uploader;


class ProcessorTest extends CommonTestClass
{
    /** @var Interfaces\IInfoStorage|null */
    protected $infoStorage = null;
    /** @var Interfaces\IDataStorage|null */
    protected $dataStorage = null;
    /** @var Uploader\DriveFile|null */
    protected $driveFile = null;
    /** @var Uploader\Processor|null */
    protected $processor = null;

    /**
     * @throws Exceptions\UploadException
     */
    public function tearDown(): void
    {
        $this->initProcessor();
        if ($this->driveFile->exists($this->mockKey())) {
            $this->driveFile->remove($this->mockKey());
        }
        parent::tearDown();
    }

    /**
     * @throws Exceptions\UploadException
     */
    public function testInit(): void
    {
        $this->initProcessor();

        $pack = $this->mockData();
        $pack->lastKnownPart = 5;
        $data = $this->processor->init($pack, $this->mockSharedKey());

        $this->assertInstanceOf(InfoFormat\Data::class, $data);
        $this->assertEquals('abcdef', $data->fileName);
        $this->assertEquals($this->getTestDir() . 'abcdef', $data->tempLocation);
        $this->assertEquals(123456, $data->fileSize);
        $this->assertEquals(12, $data->partsCount);
        $this->assertEquals(64, $data->bytesPerPart);
        $this->assertEquals(5, $data->lastKnownPart);

        $data2 = $this->processor->done($this->mockKey());
        $this->assertInstanceOf(InfoFormat\Data::class, $data2);
        $this->assertEquals('abcdef', $data2->fileName);
        $this->assertEquals($this->getTestDir() . 'abcdef', $data2->tempLocation);
        $this->assertEquals(123456, $data2->fileSize);
        $this->assertEquals(12, $data2->partsCount);
        $this->assertEquals(64, $data2->bytesPerPart);
        $this->assertEquals(5, $data2->lastKnownPart);
    }

    /**
     * @throws Exceptions\UploadException
     */
    public function testInitFail(): void
    {
        $this->initProcessor();

        $pack = $this->mockData();
        $pack->lastKnownPart = 4;
        $data = $this->processor->init($pack, $this->mockSharedKey());

        $this->assertInstanceOf(InfoFormat\Data::class, $data);
        $this->assertEquals(4, $data->lastKnownPart);

        $pack->lastKnownPart = 8;
        $data2 = $this->processor->init($pack, $this->mockSharedKey());
        $this->assertEquals(4, $data2->lastKnownPart);
        $this->assertNotEquals(8, $data2->lastKnownPart);
    }

    /**
     * @throws Exceptions\UploadException
     */
    public function testUploadEarly(): void
    {
        $this->initProcessor();
        $pack = $this->mockData();
        $pack->fileSize = 80;
        $pack->bytesPerPart = 10;
        $pack->lastKnownPart = 4;
        $pack->partsCount = 8;
        $this->processor->init($pack, $this->mockSharedKey());
        $datacont = 'asdfghjklyxcvbnmqwertzuiop1234567890';
        $this->processor->upload($this->mockSharedKey(), $datacont, 5); // pass, last is 4, wanted 5
        $this->expectException(Exceptions\UploadException::class);
        $this->processor->upload($this->mockSharedKey(), $datacont, 7); // fail, last is 5, wanted 6
        $this->expectExceptionMessageMatches('READ TOO EARLY');
    }

    /**
     * @throws Exceptions\UploadException
     */
    public function testCheckSegmentSubZero(): void
    {
        $this->initProcessor();
        $pack = $this->mockData();
        $pack->fileSize = 80;
        $pack->bytesPerPart = 10;
        $pack->lastKnownPart = 4;
        $pack->partsCount = 8;
        $this->processor->init($pack, $this->mockSharedKey());
        $this->expectException(Exceptions\UploadException::class);
        $this->processor->check($this->mockSharedKey(), -5); // fail, sub zero
        $this->expectExceptionMessageMatches('SEGMENT OUT OF BOUNDS');
    }

    /**
     * @throws Exceptions\UploadException
     */
    public function testCheckSegmentAvailableParts(): void
    {
        $this->initProcessor();
        $pack = $this->mockData();
        $pack->fileSize = 80;
        $pack->bytesPerPart = 10;
        $pack->lastKnownPart = 4;
        $pack->partsCount = 8;
        $this->processor->init($pack, $this->mockSharedKey());
        $this->expectException(Exceptions\UploadException::class);
        $this->processor->check($this->mockSharedKey(), 10); // fail, out of size
        $this->expectExceptionMessageMatches('SEGMENT OUT OF BOUNDS');
    }

    /**
     * @throws Exceptions\UploadException
     */
    public function testCheckSegmentNotUploaded(): void
    {
        $this->initProcessor();
        $pack = $this->mockData();
        $pack->fileSize = 80;
        $pack->bytesPerPart = 10;
        $pack->lastKnownPart = 4;
        $pack->partsCount = 8;
        $this->processor->init($pack, $this->mockSharedKey());
        $this->expectException(Exceptions\UploadException::class);
        $this->processor->check($this->mockSharedKey(), 6); // fail, outside upload
        $this->expectExceptionMessageMatches('SEGMENT NOT UPLOADED YET');
    }

    /**
     * @throws Exceptions\UploadException
     */
    public function testSimpleThru(): void
    {
        $this->initProcessor();
        $cont = file_get_contents($this->getTestFile(), false, null, 0, 80);
        $pack = $this->mockData();
        $pack->fileSize = 80;
        $pack->bytesPerPart = 10;
        $pack->lastKnownPart = 4;
        $pack->partsCount = 8;
        $data = $this->processor->init($pack, $this->mockSharedKey());
        $dataCont = Support\Strings::substr($cont, 0, 30, '') . 'asdfghjklyxcvbnmqwer';
        // set problematic content
        $this->processor->upload($this->mockSharedKey(), $dataCont);
        // now checks
        for ($i = 0; $i < $data->lastKnownPart; $i++) {
            $remoteMd5 = $this->processor->check($this->mockSharedKey(), $i);
            $localMd5 = md5(Support\Strings::substr($cont, $i * $data->bytesPerPart, $data->bytesPerPart, ''));
            if ($remoteMd5 != $localMd5) {
                $this->processor->truncateFrom($this->mockSharedKey(), $i);
                break;
            }
        }
        $data = $this->driveFile->read($this->mockSharedKey());
        $this->assertEquals(3, $data->lastKnownPart);
        // set rest
        for ($i = $data->lastKnownPart + 1; $i <= $data->partsCount; $i++) {
            $dataPack = Support\Strings::substr($cont, $i * $data->lastKnownPart, $data->bytesPerPart, '');
            $this->processor->upload($this->mockSharedKey(), $dataPack);
        }
        $this->processor->cancel($this->mockSharedKey()); // intended, because pass will be checked in upload itself
    }

    /**
     * @throws Exceptions\UploadException
     */
    public function testSimpleAll(): void
    {
        $this->initProcessor();
        $cont = file_get_contents($this->getTestFile(), false, null, 0, 80);
        $pack = $this->mockData();
        $pack->fileSize = 80;
        $pack->bytesPerPart = 10;
        $pack->lastKnownPart = 7;
        $pack->partsCount = 8;
        $this->processor->init($pack, $this->mockSharedKey());
        $this->processor->upload($this->mockSharedKey(), $cont);
        $data = $this->processor->done($this->mockSharedKey());
        $this->assertEquals(8, $data->lastKnownPart);
        $this->assertEquals(8, $data->partsCount);
    }

    protected function mockKey(): string
    {
        return 'fghjkl' . Uploader\TargetSearch::FILE_DRIVER_SUFF;
    }

    protected function initProcessor(): void
    {
        $lang = new Uploader\Translations();
        $this->infoStorage = new Support\InfoRam($lang);
        $this->dataStorage = new Support\DataRam($lang);
        $target = new Uploader\TargetSearch($this->infoStorage, $this->dataStorage, $lang);
        $key = new Support\Key($target, $lang);
        $format = new InfoFormat\Json();
        $hashed = new Uploader\Hashed();
        $this->driveFile = new Uploader\DriveFile($this->infoStorage, $format, $key, $lang);
        $this->processor = new Uploader\Processor($this->driveFile, $this->dataStorage, $hashed, $lang);
    }
}


1			<?php
2
3			namespace BasicTests;
4
5
6			use CommonTestClass;
7			use Support;
8			use kalanis\UploadPerPartes\Exceptions;
9			use kalanis\UploadPerPartes\InfoFormat;
10			use kalanis\UploadPerPartes\Interfaces;
11			use kalanis\UploadPerPartes\Uploader;
12
13
14			class ProcessorTest extends CommonTestClass
15			{
16			/** @var Interfaces\IInfoStorage\|null */
17			protected $infoStorage = null;
18			/** @var Interfaces\IDataStorage\|null */
19			protected $dataStorage = null;
20			/** @var Uploader\DriveFile\|null */
21			protected $driveFile = null;
22			/** @var Uploader\Processor\|null */
23			protected $processor = null;
24
25			/**
26			* @throws Exceptions\UploadException
27			*/
28			public function tearDown(): void
29			{
30			$this->initProcessor();
31			if ($this->driveFile->exists($this->mockKey())) {
32			$this->driveFile->remove($this->mockKey());
33			}
34			parent::tearDown();
35			}
36
37			/**
38			* @throws Exceptions\UploadException
39			*/
40			public function testInit(): void
41			{
42			$this->initProcessor();
43
44			$pack = $this->mockData();
45			$pack->lastKnownPart = 5;
46			$data = $this->processor->init($pack, $this->mockSharedKey());
47
48			$this->assertInstanceOf(InfoFormat\Data::class, $data);
49			$this->assertEquals('abcdef', $data->fileName);
50			$this->assertEquals($this->getTestDir() . 'abcdef', $data->tempLocation);
51			$this->assertEquals(123456, $data->fileSize);
52			$this->assertEquals(12, $data->partsCount);
53			$this->assertEquals(64, $data->bytesPerPart);
54			$this->assertEquals(5, $data->lastKnownPart);
55
56			$data2 = $this->processor->done($this->mockKey());
57			$this->assertInstanceOf(InfoFormat\Data::class, $data2);
58			$this->assertEquals('abcdef', $data2->fileName);
59			$this->assertEquals($this->getTestDir() . 'abcdef', $data2->tempLocation);
60			$this->assertEquals(123456, $data2->fileSize);
61			$this->assertEquals(12, $data2->partsCount);
62			$this->assertEquals(64, $data2->bytesPerPart);
63			$this->assertEquals(5, $data2->lastKnownPart);
64			}
65
66			/**
67			* @throws Exceptions\UploadException
68			*/
69			public function testInitFail(): void
70			{
71			$this->initProcessor();
72
73			$pack = $this->mockData();
74			$pack->lastKnownPart = 4;
75			$data = $this->processor->init($pack, $this->mockSharedKey());
76
77			$this->assertInstanceOf(InfoFormat\Data::class, $data);
78			$this->assertEquals(4, $data->lastKnownPart);
79
80			$pack->lastKnownPart = 8;
81			$data2 = $this->processor->init($pack, $this->mockSharedKey());
82			$this->assertEquals(4, $data2->lastKnownPart);
83			$this->assertNotEquals(8, $data2->lastKnownPart);
84			}
85
86			/**
87			* @throws Exceptions\UploadException
88			*/
89			public function testUploadEarly(): void
90			{
91			$this->initProcessor();
92			$pack = $this->mockData();
93			$pack->fileSize = 80;
94			$pack->bytesPerPart = 10;
95			$pack->lastKnownPart = 4;
96			$pack->partsCount = 8;
97			$this->processor->init($pack, $this->mockSharedKey());
98			$datacont = 'asdfghjklyxcvbnmqwertzuiop1234567890';
99			$this->processor->upload($this->mockSharedKey(), $datacont, 5); // pass, last is 4, wanted 5
100			$this->expectException(Exceptions\UploadException::class);
101			$this->processor->upload($this->mockSharedKey(), $datacont, 7); // fail, last is 5, wanted 6
102			$this->expectExceptionMessageMatches('READ TOO EARLY');
103			}
104
105			/**
106			* @throws Exceptions\UploadException
107			*/
108			public function testCheckSegmentSubZero(): void
109			{
110			$this->initProcessor();
111			$pack = $this->mockData();
112			$pack->fileSize = 80;
113			$pack->bytesPerPart = 10;
114			$pack->lastKnownPart = 4;
115			$pack->partsCount = 8;
116			$this->processor->init($pack, $this->mockSharedKey());
117			$this->expectException(Exceptions\UploadException::class);
118			$this->processor->check($this->mockSharedKey(), -5); // fail, sub zero
119			$this->expectExceptionMessageMatches('SEGMENT OUT OF BOUNDS');
120			}
121
122			/**
123			* @throws Exceptions\UploadException
124			*/
125			public function testCheckSegmentAvailableParts(): void
126			{
127			$this->initProcessor();
128			$pack = $this->mockData();
129			$pack->fileSize = 80;
130			$pack->bytesPerPart = 10;
131			$pack->lastKnownPart = 4;
132			$pack->partsCount = 8;
133			$this->processor->init($pack, $this->mockSharedKey());
134			$this->expectException(Exceptions\UploadException::class);
135			$this->processor->check($this->mockSharedKey(), 10); // fail, out of size
136			$this->expectExceptionMessageMatches('SEGMENT OUT OF BOUNDS');
137			}
138
139			/**
140			* @throws Exceptions\UploadException
141			*/
142			public function testCheckSegmentNotUploaded(): void
143			{
144			$this->initProcessor();
145			$pack = $this->mockData();
146			$pack->fileSize = 80;
147			$pack->bytesPerPart = 10;
148			$pack->lastKnownPart = 4;
149			$pack->partsCount = 8;
150			$this->processor->init($pack, $this->mockSharedKey());
151			$this->expectException(Exceptions\UploadException::class);
152			$this->processor->check($this->mockSharedKey(), 6); // fail, outside upload
153			$this->expectExceptionMessageMatches('SEGMENT NOT UPLOADED YET');
154			}
155
156			/**
157			* @throws Exceptions\UploadException
158			*/
159			public function testSimpleThru(): void
160			{
161			$this->initProcessor();
162			$cont = file_get_contents($this->getTestFile(), false, null, 0, 80);
163			$pack = $this->mockData();
164			$pack->fileSize = 80;
165			$pack->bytesPerPart = 10;
166			$pack->lastKnownPart = 4;
167			$pack->partsCount = 8;
168			$data = $this->processor->init($pack, $this->mockSharedKey());
169			$dataCont = Support\Strings::substr($cont, 0, 30, '') . 'asdfghjklyxcvbnmqwer';
170			// set problematic content
171			$this->processor->upload($this->mockSharedKey(), $dataCont);
172			// now checks
173			for ($i = 0; $i < $data->lastKnownPart; $i++) {
174			$remoteMd5 = $this->processor->check($this->mockSharedKey(), $i);
175			$localMd5 = md5(Support\Strings::substr($cont, $i * $data->bytesPerPart, $data->bytesPerPart, ''));
176			if ($remoteMd5 != $localMd5) {
177			$this->processor->truncateFrom($this->mockSharedKey(), $i);
178			break;
179			}
180			}
181			$data = $this->driveFile->read($this->mockSharedKey());
182			$this->assertEquals(3, $data->lastKnownPart);
183			// set rest
184			for ($i = $data->lastKnownPart + 1; $i <= $data->partsCount; $i++) {
185			$dataPack = Support\Strings::substr($cont, $i * $data->lastKnownPart, $data->bytesPerPart, '');
186			$this->processor->upload($this->mockSharedKey(), $dataPack);
187			}
188			$this->processor->cancel($this->mockSharedKey()); // intended, because pass will be checked in upload itself
189			}
190
191			/**
192			* @throws Exceptions\UploadException
193			*/
194			public function testSimpleAll(): void
195			{
196			$this->initProcessor();
197			$cont = file_get_contents($this->getTestFile(), false, null, 0, 80);
198			$pack = $this->mockData();
199			$pack->fileSize = 80;
200			$pack->bytesPerPart = 10;
201			$pack->lastKnownPart = 7;
202			$pack->partsCount = 8;
203			$this->processor->init($pack, $this->mockSharedKey());
204			$this->processor->upload($this->mockSharedKey(), $cont);
205			$data = $this->processor->done($this->mockSharedKey());
206			$this->assertEquals(8, $data->lastKnownPart);
207			$this->assertEquals(8, $data->partsCount);
208			}
209
210			protected function mockKey(): string
211			{
212			return 'fghjkl' . Uploader\TargetSearch::FILE_DRIVER_SUFF;
213			}
214
215			protected function initProcessor(): void
216			{
217			$lang = new Uploader\Translations();
218			$this->infoStorage = new Support\InfoRam($lang);
219			$this->dataStorage = new Support\DataRam($lang);
220			$target = new Uploader\TargetSearch($this->infoStorage, $this->dataStorage, $lang);
221			$key = new Support\Key($target, $lang);
222			$format = new InfoFormat\Json();
223			$hashed = new Uploader\Hashed();
224			$this->driveFile = new Uploader\DriveFile($this->infoStorage, $format, $key, $lang);
225			$this->processor = new Uploader\Processor($this->driveFile, $this->dataStorage, $hashed, $lang);
226			}
227			}
228

alex-kalanis / upload-per-partes

Push — master ( 1b6475...610123 )

ProcessorTest::testUploadEarly() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like