ILIAS\Filesystem\Util\ZipTest Class Reference

Inheritance diagram for ILIAS\Filesystem\Util\ZipTest:

Collaboration diagram for ILIAS\Filesystem\Util\ZipTest:

Public Member Functions
	testZip ()
	testLegacyZip ()
	LegacyZipWithTop ()
	testUnzip (string $zip, bool $has_multiple_root_entries, int $expected_amount_directories, array $expected_directories, int $expected_amount_files, array $expected_files)
	testWrongZip ()
	testLargeZIPs ()
	testLegacyUnzip (string $zip, bool $has_multiple_root_entries, int $expected_amount_directories, array $expected_directories, int $expected_amount_files, array $expected_files)

Static Public Member Functions
static	getZips ()

Data Fields
const	ZIPPED_ZIP = 'zipped.zip'

Protected Member Functions
	setUp ()
	tearDown ()

Protected Attributes
string	$zips_dir = __DIR__ . '/zips/'
string	$unzips_dir = __DIR__ . '/unzips/'

Static Protected Attributes
static array	$files_mixed
static array	$directories_mixed
static array	$files_three

Private Member Functions
	recurseRmdir (string $path_to_directory)
	directoryToArray (string $path_to_directory)

Detailed Description

Author

Fabian Schmid fabia.nosp@m.n@sr.nosp@m..solu.nosp@m.tion.nosp@m.s

Definition at line 41 of file ZipTest.php.

Member Function Documentation

directoryToArray()

ILIAS\Filesystem\Util\ZipTest::directoryToArray ( string  $path_to_directory )

private

Returns

string[]|string[][]

Definition at line 251 of file ZipTest.php.

                                                                : array
    {
        $iterator = new \RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator($path_to_directory, \RecursiveDirectoryIterator::SKIP_DOTS),
            \RecursiveIteratorIterator::SELF_FIRST,
            \RecursiveIteratorIterator::CATCH_GET_CHILD
        );
        $paths = [];
        foreach ($iterator as $item) {
            $relative_path = str_replace($path_to_directory . '/', '', $item->getPathname());
            $paths[] = $item->isDir() ? $relative_path . '/' : $relative_path;
        }
 
        sort($paths);
 
        return $paths;
    }

References ILIAS\UI\examples\Symbol\Glyph\Sort\sort().

Here is the call graph for this function:

getZips()

static ILIAS\Filesystem\Util\ZipTest::getZips ( )

static

Definition at line 271 of file ZipTest.php.

                                    : \Iterator
    {
        yield ['1_folder_mac.zip', false, 10, self::$directories_one, 15, self::$files_one];
        yield ['1_folder_win.zip', false, 10, self::$directories_one, 15, self::$files_one];
        yield ['3_folders_mac.zip', true, 9, self::$directories_three, 12, self::$files_three];
        yield ['3_folders_win.zip', true, 9, self::$directories_three, 12, self::$files_three];
        yield ['1_folder_1_file_mac.zip', true, 3, self::$directories_mixed, 5, self::$files_mixed];
    }

LegacyZipWithTop()

ILIAS\Filesystem\Util\ZipTest::LegacyZipWithTop

(

)

Definition at line 104 of file ZipTest.php.

                                      : void
    {
        $legacy = new LegacyArchives();
 
        define('CLIENT_WEB_DIR', __DIR__);
        define('ILIAS_WEB_DIR', 'public/data');
        define('CLIENT_ID', 'test');
        define('CLIENT_DATA_DIR', __DIR__);
        define('ILIAS_ABSOLUTE_PATH', __DIR__);
 
        mkdir($this->unzips_dir);
        $legacy->zip($this->zips_dir, $this->unzips_dir . self::ZIPPED_ZIP, true);
        $this->assertFileExists($this->unzips_dir . self::ZIPPED_ZIP);
 
        $unzip_again = new Unzip(new UnzipOptions(), Streams::ofResource(fopen($this->unzips_dir . self::ZIPPED_ZIP, 'r')));
        $this->assertSame(5, $unzip_again->getAmountOfFiles());
 
        $depth = 0;
        foreach ($unzip_again->getPaths() as $path) {
            $parts = explode('/', $path);
            $depth = max($depth, count($parts));
        }
        $this->assertEquals(2, $depth);
        $this->recurseRmdir($this->unzips_dir);
    }

References $parts, $path, ILIAS\Filesystem\Stream\Streams\ofResource(), and ILIAS\Filesystem\Util\ZipTest\recurseRmdir().

Here is the call graph for this function:

recurseRmdir()

ILIAS\Filesystem\Util\ZipTest::recurseRmdir ( string  $path_to_directory )

private

Definition at line 237 of file ZipTest.php.

                                                            : bool
    {
        $files = array_diff(scandir($path_to_directory), ['.', '..']);
        foreach ($files as $file) {
            (is_dir("$path_to_directory/$file") && !is_link("$path_to_directory/$file")) ? $this->recurseRmdir(
                "$path_to_directory/$file"
            ) : unlink("$path_to_directory/$file");
        }
        return rmdir($path_to_directory);
    }

Referenced by ILIAS\Filesystem\Util\ZipTest\LegacyZipWithTop(), ILIAS\Filesystem\Util\ZipTest\tearDown(), and ILIAS\Filesystem\Util\ZipTest\testLegacyZip().

Here is the caller graph for this function:

setUp()

ILIAS\Filesystem\Util\ZipTest::setUp ( )

protected

Definition at line 47 of file ZipTest.php.

                              : void
    {
        if (file_exists($this->unzips_dir . self::ZIPPED_ZIP)) {
            unlink($this->unzips_dir . self::ZIPPED_ZIP);
        }
        if (!file_exists($this->unzips_dir)) {
            mkdir($this->unzips_dir);
        }
    }

tearDown()

ILIAS\Filesystem\Util\ZipTest::tearDown ( )

protected

Definition at line 57 of file ZipTest.php.

                                 : void
    {
        if (file_exists($this->unzips_dir)) {
            $this->recurseRmdir($this->unzips_dir);
        }
    }

References ILIAS\Filesystem\Util\ZipTest\recurseRmdir().

Here is the call graph for this function:

testLargeZIPs()

ILIAS\Filesystem\Util\ZipTest::testLargeZIPs

(

)

Definition at line 174 of file ZipTest.php.

                                   : void
    {
        // get ulimit
        $ulimit = (int) shell_exec('ulimit -n');
        $limit = 2500;
        if ($ulimit >= $limit) {
            $this->markTestSkipped('ulimit is too high and would take too much resources');
        }
        $this->assertLessThan($limit, $ulimit);
 
        $zip = new Zip(new ZipOptions());
 
        $file_names = [];
 
        for ($i = 0; $i < $ulimit * 2; $i++) {
            $path_inside_zip = $file_names[] = 'test' . $i;
            $zip->addStream(Streams::ofString('-'), $path_inside_zip);
        }
        $this->assertTrue(true); // no warning or error
 
        // check if the zip now contains all files
        $unzip = new Unzip(new UnzipOptions(), $zip->get());
        $file_names_in_zip = iterator_to_array($unzip->getFiles());
        sort($file_names);
        sort($file_names_in_zip);
        $this->assertEquals($file_names, $file_names_in_zip);
    }

References ILIAS\Repository\int(), ILIAS\Filesystem\Stream\Streams\ofString(), and ILIAS\UI\examples\Symbol\Glyph\Sort\sort().

Here is the call graph for this function:

testLegacyUnzip()

ILIAS\Filesystem\Util\ZipTest::testLegacyUnzip	(	string	$zip,
		bool	$has_multiple_root_entries,
		int	$expected_amount_directories,
		array	$expected_directories,
		int	$expected_amount_files,
		array	$expected_files
	)

Parameters

mixed[]	$expected_directories
mixed[]	$expected_files

Definition at line 207 of file ZipTest.php.

     : void {
        $legacy = new LegacyArchives();
 
        $this->assertStringContainsString('.zip', $zip);
        $zip_path = $this->zips_dir . $zip;
        $this->assertFileExists($zip_path);
 
        $temp_unzip_path = $this->unzips_dir . uniqid('unzip', true);
 
        $return = $legacy->unzip(
            $zip_path,
            $temp_unzip_path
        );
 
        $this->assertTrue($return);
 
        $unzipped_files = $this->directoryToArray($temp_unzip_path);
        $expected_paths = array_merge($expected_directories, $expected_files);
        sort($expected_paths);
        $this->assertEquals($expected_paths, $unzipped_files);
        $this->assertTrue($this->recurseRmdir($temp_unzip_path));
    }

testLegacyZip()

ILIAS\Filesystem\Util\ZipTest::testLegacyZip

(

)

Definition at line 79 of file ZipTest.php.

                                   : void
    {
        $legacy = new LegacyArchives();
 
        define('CLIENT_WEB_DIR', __DIR__);
        define('ILIAS_WEB_DIR', 'public/data');
        define('CLIENT_ID', 'test');
        define('CLIENT_DATA_DIR', __DIR__);
        define('ILIAS_ABSOLUTE_PATH', __DIR__);
 
        $legacy->zip($this->zips_dir, $this->unzips_dir . self::ZIPPED_ZIP, false);
        $this->assertFileExists($this->unzips_dir . self::ZIPPED_ZIP);
 
        $unzip_again = new Unzip(new UnzipOptions(), Streams::ofResource(fopen($this->unzips_dir . self::ZIPPED_ZIP, 'r')));
        $this->assertSame(5, $unzip_again->getAmountOfFiles());
 
        $depth = 0;
        foreach ($unzip_again->getPaths() as $path) {
            $parts = explode('/', $path);
            $depth = max($depth, count($parts));
        }
        $this->assertEquals(2, $depth);
        $this->recurseRmdir($this->unzips_dir);
    }

References $parts, $path, ILIAS\Filesystem\Stream\Streams\ofResource(), and ILIAS\Filesystem\Util\ZipTest\recurseRmdir().

Here is the call graph for this function:

testUnzip()

ILIAS\Filesystem\Util\ZipTest::testUnzip	(	string	$zip,
		bool	$has_multiple_root_entries,
		int	$expected_amount_directories,
		array	$expected_directories,
		int	$expected_amount_files,
		array	$expected_files
	)

Parameters

mixed[]	$expected_directories
mixed[]	$expected_files

Definition at line 135 of file ZipTest.php.

     : void {
        $this->assertStringContainsString('.zip', $zip);
        $zip_path = $this->zips_dir . $zip;
        $this->assertFileExists($zip_path);
 
        $stream = Streams::ofResource(fopen($zip_path, 'rb'));
        $options = new UnzipOptions();
        $unzip = new Unzip($options, $stream);
 
        $this->assertFalse($unzip->hasZipReadingError());
        $this->assertSame($has_multiple_root_entries, $unzip->hasMultipleRootEntriesInZip());
        $this->assertSame($expected_amount_directories, $unzip->getAmountOfDirectories());
        $this->assertEquals($expected_directories, iterator_to_array($unzip->getDirectories()));
        $this->assertSame($expected_amount_files, $unzip->getAmountOfFiles());
        $this->assertEquals($expected_files, iterator_to_array($unzip->getFiles()));
    }

testWrongZip()

ILIAS\Filesystem\Util\ZipTest::testWrongZip

(

)

Definition at line 159 of file ZipTest.php.

                                  : void
    {
        $stream = Streams::ofResource(fopen(__FILE__, 'rb'));
        $options = new UnzipOptions();
        $unzip = new Unzip($options, $stream);
        $this->assertTrue($unzip->hasZipReadingError());
        $this->assertFalse($unzip->hasMultipleRootEntriesInZip());
        $this->assertCount(0, iterator_to_array($unzip->getFiles()));
        $this->assertCount(0, iterator_to_array($unzip->getDirectories()));
        $this->assertCount(0, iterator_to_array($unzip->getPaths()));
        $this->assertSame([], iterator_to_array($unzip->getDirectories()));
        $this->assertSame([], iterator_to_array($unzip->getFiles()));
    }

References ILIAS\UI\Implementation\Component\Input\Field\$options, and ILIAS\Filesystem\Stream\Streams\ofResource().

Here is the call graph for this function:

testZip()

ILIAS\Filesystem\Util\ZipTest::testZip

(

)

Definition at line 64 of file ZipTest.php.

                             : void
    {
        $zip_options = new ZipOptions();
        $streams = [
            Streams::ofResource(fopen($this->zips_dir . '1_folder_1_file_mac.zip', 'r')),
            Streams::ofResource(fopen($this->zips_dir . '1_folder_win.zip', 'r')),
        ];
        $zip = new Zip($zip_options, ...$streams);
        $zip_stream = $zip->get();
        $this->assertGreaterThan(0, $zip_stream->getSize());
 
        $unzip_again = new Unzip(new UnzipOptions(), $zip_stream);
        $this->assertSame(2, $unzip_again->getAmountOfFiles());
    }

References ILIAS\Filesystem\Stream\Streams\ofResource().

Here is the call graph for this function:

Field Documentation

$directories_mixed

array ILIAS\Filesystem\Util\ZipTest::$directories_mixed

staticprotected

Definition at line 288 of file ZipTest.php.

$files_mixed

array ILIAS\Filesystem\Util\ZipTest::$files_mixed

staticprotected

Initial value:

= [
        0 => '03_Test.pdf',
        1 => 'Ordner A/01_Test.pdf',
        2 => 'Ordner A/02_Test.pdf',
        3 => 'Ordner A/Ordner A_2/07_Test.pdf',
        4 => 'Ordner A/Ordner A_2/08_Test.pdf'
    ]

Definition at line 280 of file ZipTest.php.

$files_three

array ILIAS\Filesystem\Util\ZipTest::$files_three

staticprotected

Initial value:

= [
        0 => 'Ordner A/01_Test.pdf',
        1 => 'Ordner A/02_Test.pdf',
        2 => 'Ordner A/Ordner A_2/07_Test.pdf',
        3 => 'Ordner A/Ordner A_2/08_Test.pdf',
        4 => 'Ordner B/03_Test.pdf',
        5 => 'Ordner B/04_Test.pdf',
        6 => 'Ordner B/Ordner B_2/09_Test.pdf',
        7 => 'Ordner B/Ordner B_2/10_Test.pdf',
        8 => 'Ordner C/05_Test.pdf',
        9 => 'Ordner C/06_Test.pdf',
        10 => 'Ordner C/Ordner C_2/11_Test.pdf',
        11 => 'Ordner C/Ordner C_2/12_Test.pdf',
    ]

Definition at line 336 of file ZipTest.php.

$unzips_dir

string ILIAS\Filesystem\Util\ZipTest::$unzips_dir = __DIR__ . '/unzips/'

protected

Definition at line 45 of file ZipTest.php.

$zips_dir

string ILIAS\Filesystem\Util\ZipTest::$zips_dir = __DIR__ . '/zips/'

protected

Definition at line 44 of file ZipTest.php.

ZIPPED_ZIP

const ILIAS\Filesystem\Util\ZipTest::ZIPPED_ZIP = 'zipped.zip'

Definition at line 43 of file ZipTest.php.

---

The documentation for this class was generated from the following file:

• components/ILIAS/Filesystem/tests/Util/ZipTest.php