Files
Testing/tus-php/tests/FileTest.php

679 lines
16 KiB
PHP
Raw Permalink Normal View History

2026-11-17 16:15:01 -05:00
<?php
namespace TusPhp\Test;
use TusPhp\File;
use Mockery as m;
use TusPhp\Cache\FileStore;
use TusPhp\Cache\CacheFactory;
use PHPUnit\Framework\TestCase;
use TusPhp\Exception\FileException;
use TusPhp\Test\Fixtures\FileFixture;
use TusPhp\Exception\OutOfRangeException;
/**
* @coversDefaultClass \TusPhp\File
*/
class FileTest extends TestCase
{
/** @var File */
protected $file;
/**
* Prepare vars.
*
* @return void
*/
public function setUp() : void
{
$this->file = new File('tus.txt', CacheFactory::make());
$this->file->setMeta(100, 1024, '/path/to/file.txt', 'http://tus.local/uploads/file.txt');
parent::setUp();
}
/**
* @test
*
* @covers ::__construct
* @covers ::setMeta
* @covers ::details
*/
public function it_sets_meta_and_gets_details() : void
{
$this->file->setMeta(200, 2056, '/path/to/file.pdf', 'http://tus.local/uploads/file.pdf');
$meta = $this->file->details();
$this->assertEquals('tus.txt', $meta['name']);
$this->assertEquals(2056, $meta['size']);
$this->assertEquals(200, $meta['offset']);
$this->assertEquals('http://tus.local/uploads/file.pdf', $meta['location']);
$this->assertEquals('/path/to/file.pdf', $meta['file_path']);
$this->assertEquals('Fri, 08 Dec 2017 00:00:00 GMT', $meta['created_at']);
$this->assertEquals('Sat, 09 Dec 2017 00:00:00 GMT', $meta['expires_at']);
}
/**
* @test
*
* @covers ::getName
* @covers ::setName
*/
public function it_sets_and_gets_name() : void
{
$this->assertEquals('tus.txt', $this->file->getName());
$this->assertInstanceOf(File::class, $this->file->setName('file.txt'));
$this->assertEquals('file.txt', $this->file->getName());
}
/**
* @test
*
* @covers ::setFileSize
* @covers ::getFileSize
*/
public function it_sets_and_gets_file_size() : void
{
$this->assertEquals(1024, $this->file->getFileSize());
$this->assertInstanceOf(File::class, $this->file->setFileSize(2056));
$this->assertEquals(2056, $this->file->getFileSize());
}
/**
* @test
*
* @covers ::getChecksum
* @covers ::setChecksum
*/
public function it_sets_and_gets_checksum() : void
{
$checksum = '74f02d6da32082463e382f2274e85fd8eae3e81f739f8959abc91865656e3b3a';
$this->assertInstanceOf(File::class, $this->file->setChecksum($checksum));
$this->assertEquals($checksum, $this->file->getChecksum());
}
/**
* @test
*
* @covers ::setKey
* @covers ::getKey
*/
public function it_sets_and_gets_key() : void
{
$key = uniqid();
$this->assertInstanceOf(File::class, $this->file->setKey($key));
$this->assertEquals($key, $this->file->getKey());
}
/**
* @test
*
* @covers ::getOffset
* @covers ::setOffset
*/
public function it_sets_and_gets_offset() : void
{
$this->assertEquals(100, $this->file->getOffset());
$this->assertInstanceOf(File::class, $this->file->setOffset(500));
$this->assertEquals(500, $this->file->getOffset());
}
/**
* @test
*
* @covers ::getLocation
* @covers ::setLocation
*/
public function it_sets_and_gets_location() : void
{
$this->assertEquals('http://tus.local/uploads/file.txt', $this->file->getLocation());
$location = 'http://tus.local/uploads/file.pdf';
$this->assertInstanceOf(File::class, $this->file->setLocation($location));
$this->assertEquals($location, $this->file->getLocation());
}
/**
* @test
*
* @covers ::getFilePath
* @covers ::setFilePath
*/
public function it_sets_and_gets_file_path() : void
{
$this->assertEquals('/path/to/file.txt', $this->file->getFilePath());
$filePath = '/path/to/file.pdf';
$this->assertInstanceOf(File::class, $this->file->setFilePath($filePath));
$this->assertEquals($filePath, $this->file->getFilePath());
}
/**
* @test
*
* @covers ::getInputStream
*/
public function it_gets_input_stream() : void
{
$this->assertEquals('php://input', $this->file->getInputStream());
}
/**
* @test
*
* @covers ::setUploadMetadata
*/
public function it_sets_upload_metadata() : void
{
$metadata = [
'offset' => 200,
'fileSize' => 2056,
'filePath' => '/path/to/file.pdf',
];
$this->assertInstanceOf(File::class, $this->file->setUploadMetadata($metadata));
}
/**
* @test
*
* @covers ::open
* @covers ::exists
*/
public function it_throws_404_for_invalid_file() : void
{
$this->expectException(FileException::class);
$this->expectExceptionMessage('File not found.');
$this->file->open('/path/to/invalid/file.txt', 'rb');
}
/**
* @test
*
* @covers ::open
* @covers ::exists
*/
public function it_throws_exception_for_file_with_no_permission() : void
{
$this->expectException(FileException::class);
$this->expectErrorMessageMatches('/Unable to open [a-zA-Z0-9-\/.]+/');
$file = __DIR__ . '/Fixtures/403.txt';
chmod($file, 0444);
$this->file->open($file, 'w');
}
/**
* @test
*
* @covers ::open
* @covers ::exists
* @covers ::close
*/
public function it_opens_a_file() : void
{
$file = __DIR__ . '/Fixtures/empty.txt';
$resource = $this->file->open($file, 'rb');
$this->assertIsResource($resource);
$this->file->close($resource);
}
/**
* @test
*
* @covers ::exists
*/
public function it_checks_if_file_exists_based_on_mode() : void
{
$this->assertTrue($this->file->exists('php://input'));
$this->assertTrue($this->file->exists(__DIR__ . '/Fixtures/empty.txt'));
$this->assertTrue($this->file->exists(__DIR__ . '/Fixtures/invalid.txt', 'wb+'));
}
/**
* @test
*
* @covers ::exists
*/
public function it_throws_file_exception_if_file_doesnt_exists_for_read_mode() : void
{
$this->expectException(FileException::class);
$this->expectExceptionMessage('File not found.');
$this->assertFalse($this->file->exists(__DIR__ . '/Fixtures/invalid.txt'));
}
/**
* @test
*
* @covers ::seek
*
* @runInSeparateProcess
*/
public function it_throws_exception_if_it_cannot_seek() : void
{
$this->expectException(FileException::class);
$this->expectExceptionMessage('Cannot move pointer to desired position.');
$file = __DIR__ . '/Fixtures/empty.txt';
$handle = $this->file->open($file, 'r');
$this->file->seek($handle, -1);
$this->file->close($handle);
}
/**
* @test
*
* @covers ::seek
* @covers ::close
*/
public function it_moves_to_proper_location_in_a_file() : void
{
$file = __DIR__ . '/Fixtures/data.txt';
$handle = $this->file->open($file, 'r');
$this->file->seek($handle, 5);
$this->assertEquals(5, ftell($handle));
$this->file->close($handle);
}
/**
* @test
*
* @covers ::seek
* @covers ::read
* @covers ::close
*/
public function it_reads_from_a_file() : void
{
$file = __DIR__ . '/Fixtures/data.txt';
$handle = $this->file->open($file, 'r');
$this->file->seek($handle, 49);
$this->assertEquals('Sherlock Holmes', $this->file->read($handle, 15));
$this->file->close($handle);
}
/**
* @test
*
* @covers ::open
* @covers ::write
* @covers ::read
* @covers ::close
*/
public function it_writes_to_a_file() : void
{
$file = __DIR__ . '/.tmp/upload.txt';
$handle = $this->file->open($file, 'w+');
$bytes = 15;
$this->file->write($handle, 'Sherlock Holmes', $bytes);
$this->assertEquals('', $this->file->read($handle, $bytes));
$this->file->seek($handle, 0);
$this->assertEquals('Sherlock Holmes', $this->file->read($handle, $bytes));
$this->file->close($handle);
@unlink($file);
}
/**
* @test
*
* @covers ::merge
*/
public function it_throws_file_exception_if_file_to_merge_doesnt_exist() : void
{
$this->expectException(FileException::class);
$this->expectExceptionMessage('File to be merged not found.');
$path = __DIR__ . '/.tmp/fld';
$files = [
['file_path' => "$path/1", 'offset' => 10],
];
FileFixture::makeFilesAndFolder($path, $files);
$files[] = ['file_path' => "$path/invalid", 'offset' => 0];
$mergedFilePath = $path . '/../file.txt';
$this->file->setFilePath($mergedFilePath)->merge($files);
}
/**
* @test
*
* @covers ::copy
* @covers ::merge
*/
public function it_merges_two_or_more_files() : string
{
$path = __DIR__ . '/.tmp/fld';
$files = [
['file_path' => "$path/1", 'offset' => 10],
['file_path' => "$path/2", 'offset' => 20],
['file_path' => "$path/3", 'offset' => 30],
];
FileFixture::makeFilesAndFolder($path, $files);
$mergedFilePath = $path . '/../file.txt';
$this->file->setFilePath($mergedFilePath)->merge($files);
$this->assertFileExists($mergedFilePath);
$this->assertEquals('123', file_get_contents($mergedFilePath));
$this->assertEquals(60, $this->file->getOffset());
$this->assertEquals(3, $this->file->getFileSize());
@unlink($mergedFilePath);
return $path;
}
/**
* @test
*
* @depends it_merges_two_or_more_files
*
* @covers ::delete
*/
public function it_deletes_all_files_and_folder(string $path) : void
{
$files = [
"$path/1",
"$path/2",
"$path/3",
];
$this->file->delete($files, true);
$this->assertFileNotExists($path);
}
/**
* @test
*
* @covers ::copy
* @covers ::merge
*/
public function it_throws_file_exception_if_it_cannot_copy_file() : void
{
$this->expectException(FileException::class);
$this->expectExceptionMessageMatches('/Cannot copy source \(.+\) to destination \(.+\)\./');
$path = __DIR__ . '/.tmp/fld';
$files = [
['file_path' => "$path/invalid", 'offset' => 10],
];
$this->file->merge($files);
}
/**
* @test
*
* @covers ::delete
* @covers ::deleteFiles
*/
public function it_deletes_files_only() : string
{
$path = __DIR__ . '/.tmp/fld';
$files = [
"$path/1",
"$path/2",
"$path/3",
];
FileFixture::makeFilesAndFolder($path, [
['file_path' => "$path/1", 'offset' => 10],
['file_path' => "$path/2", 'offset' => 20],
['file_path' => "$path/3", 'offset' => 30],
]);
$this->file->delete($files);
foreach ($files as $file) {
$this->assertFileNotExists($file);
}
$this->assertFileExists($path);
$this->assertDirectoryExists($path);
return $path;
}
/**
* @test
*
* @depends it_deletes_files_only
*
* @covers ::delete
* @covers ::deleteFiles
*/
public function it_doesnt_delete_folder_if_file_path_is_not_given(string $path) : void
{
$this->file->delete([], true);
$this->assertFileExists($path);
}
/**
* @test
*
* @depends it_deletes_files_only
*
* @covers ::delete
* @covers ::deleteFiles
*/
public function it_deletes_empty_folder(string $path)
{
$this->file->delete(["$path/1"], true);
$this->assertFileNotExists($path);
}
/**
* @test
*
* @covers ::upload
*/
public function it_throws_file_exception_if_already_uploaded() : void
{
$this->assertEquals(1000, $this->file->setOffset(1000)->upload(1000));
}
/**
* @test
*
* @covers ::upload
* @covers ::open
*/
public function it_throws_404_if_source_file_not_found() : void
{
$this->expectException(FileException::class);
$this->expectExceptionMessageMatches('/Unable to open [a-zA-Z0-9-\/.]+/');
$this->file->setOffset(10)->upload(100);
}
/**
* @test
*
* @covers ::upload
*/
public function it_throws_exception_if_uploaded_file_is_corrupt() : void
{
$this->expectException(OutOfRangeException::class);
$this->expectExceptionMessage('The uploaded file is corrupt.');
$file = __DIR__ . '/.tmp/upload.txt';
$data = file_get_contents(__DIR__ . '/Fixtures/data.txt');
$key = uniqid();
$bytes = \strlen($data);
$cacheMock = m::mock(FileStore::class);
$fileMock = m::mock(File::class, [null, $cacheMock])->makePartial();
$fileMock
->shouldReceive('read')
->once()
->andReturn($data);
$fileMock
->shouldReceive('getKey')
->once()
->andReturn($key);
$cacheMock
->shouldReceive('set')
->once()
->with($key, ['offset' => $bytes])
->andReturn(null);
$fileMock
->setFilePath($file)
->setOffset(0)
->upload($bytes - 1);
@unlink($file);
}
/**
* @test
*
* @covers ::upload
*
* @runInSeparateProcess
*/
public function it_uploads_a_chunk() : void
{
$file = __DIR__ . '/.tmp/upload.txt';
$dataFile = __DIR__ . '/Fixtures/large.txt';
$key = uniqid();
$chunkSize = 8192;
$totalBytes = 17548;
$cacheMock = m::mock(FileStore::class);
$fileMock = m::mock(File::class, [null, $cacheMock])->makePartial();
$fileMock
->shouldReceive('getInputStream')
->once()
->andReturn($dataFile);
$fileMock
->shouldReceive('getKey')
->once()
->andReturn($key);
$cacheMock
->shouldReceive('set')
->once()
->with($key, ['offset' => $chunkSize])
->andReturn(null);
$cacheMock
->shouldReceive('set')
->once()
->with($key, ['offset' => $chunkSize * 2])
->andReturn(null);
$cacheMock
->shouldReceive('set')
->once()
->with($key, ['offset' => $totalBytes])
->andReturn(null);
$bytesWritten = $fileMock
->setFilePath($file)
->setOffset(0)
->upload($totalBytes);
$this->assertEquals($totalBytes, $bytesWritten);
@unlink($file);
}
/**
* @test
*
* @covers ::upload
*
* @runInSeparateProcess
*/
public function it_uploads_complete_file() : void
{
$file = __DIR__ . '/.tmp/upload.txt';
$data = file_get_contents(__DIR__ . '/Fixtures/data.txt');
$key = uniqid();
$totalBytes = \strlen($data);
$cacheMock = m::mock(FileStore::class);
$fileMock = m::mock(File::class, [null, $cacheMock])->makePartial();
$fileMock
->shouldReceive('read')
->once()
->andReturn($data);
$fileMock
->shouldReceive('getKey')
->once()
->andReturn($key);
$cacheMock
->shouldReceive('set')
->once()
->with($key, ['offset' => $totalBytes])
->andReturn(null);
$bytesWritten = $fileMock
->setFilePath($file)
->setOffset(0)
->upload($totalBytes);
$this->assertEquals($totalBytes, $bytesWritten);
@unlink($file);
}
/**
* Close mockery connection.
*
* @return void.
*/
public function tearDown() : void
{
m::close();
parent::tearDown();
}
}