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)
	getZips More...
	testWrongZip ()
	testLargeZIPs ()
	testLegacyUnzip (string $zip, bool $has_multiple_root_entries, int $expected_amount_directories, array $expected_directories, int $expected_amount_files, array $expected_files)
	getZips More...

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 static array	$directories_mixed
static array static array static array	$directories_one
static array static array static array static array	$directories_three
static array static array static array static array static array	$files_one
static array static array static array static array static array 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

// This is required for the test to work since we define some constants in the test disabled disabled disabled

Definition at line 37 of file ZipTest.php.

Member Function Documentation

directoryToArray()

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

private

Returns

string[]|string[][]

Definition at line 247 of file ZipTest.php.

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

Referenced by ILIAS\Filesystem\Util\ZipTest\testLegacyUnzip().

                                                                : 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;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

getZips()

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

static

Definition at line 267 of file ZipTest.php.

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

LegacyZipWithTop()

ILIAS\Filesystem\Util\ZipTest::LegacyZipWithTop

(

)

Definition at line 100 of file ZipTest.php.

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

                                      : 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->assertEquals(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);
    }

Here is the call graph for this function:

recurseRmdir()

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

private

Definition at line 233 of file ZipTest.php.

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

                                                            : 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);
    }

Here is the caller graph for this function:

setUp()

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

protected

Definition at line 43 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 53 of file ZipTest.php.

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

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

Here is the call graph for this function:

testLargeZIPs()

ILIAS\Filesystem\Util\ZipTest::testLargeZIPs

(

)

Definition at line 170 of file ZipTest.php.

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

                                   : 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);
    }

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
	)

getZips

Parameters

mixed[]	$expected_directories
mixed[]	$expected_files

Definition at line 203 of file ZipTest.php.

References ILIAS\Filesystem\Util\ZipTest\directoryToArray(), ILIAS\Filesystem\Util\ZipTest\recurseRmdir(), and ILIAS\UI\examples\Symbol\Glyph\Sort\sort().

     : 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));
    }

Here is the call graph for this function:

testLegacyZip()

ILIAS\Filesystem\Util\ZipTest::testLegacyZip

(

)

Definition at line 75 of file ZipTest.php.

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

                                   : 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->assertEquals(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);
    }

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
	)

getZips

Parameters

mixed[]	$expected_directories
mixed[]	$expected_files

Definition at line 131 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->assertEquals($has_multiple_root_entries, $unzip->hasMultipleRootEntriesInZip());
        $this->assertEquals($expected_amount_directories, $unzip->getAmountOfDirectories());
        $this->assertEquals($expected_directories, iterator_to_array($unzip->getDirectories()));
        $this->assertEquals($expected_amount_files, $unzip->getAmountOfFiles());
        $this->assertEquals($expected_files, iterator_to_array($unzip->getFiles()));
    }

testWrongZip()

ILIAS\Filesystem\Util\ZipTest::testWrongZip

(

)

Definition at line 155 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->assertEquals(0, iterator_count($unzip->getFiles()));
        $this->assertEquals(0, iterator_count($unzip->getDirectories()));
        $this->assertEquals(0, iterator_count($unzip->getPaths()));
        $this->assertEquals([], iterator_to_array($unzip->getDirectories()));
        $this->assertEquals([], iterator_to_array($unzip->getFiles()));
    }

testZip()

ILIAS\Filesystem\Util\ZipTest::testZip

(

)

Definition at line 60 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->assertEquals(2, $unzip_again->getAmountOfFiles());
    }

Field Documentation

$directories_mixed

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

staticprotected

Initial value:

= [
        0 => 'Ordner A/'

Definition at line 286 of file ZipTest.php.

$directories_one

array static array static array ILIAS\Filesystem\Util\ZipTest::$directories_one

staticprotected

Initial value:

= [
        0 => 'Ordner 0/'

Definition at line 292 of file ZipTest.php.

$directories_three

array static array static array static array ILIAS\Filesystem\Util\ZipTest::$directories_three

staticprotected

Initial value:

= [
        0 => 'Ordner A/'

Definition at line 304 of file ZipTest.php.

$files_mixed

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

staticprotected

Initial value:

= [
        0 => '03_Test.pdf'

Definition at line 278 of file ZipTest.php.

$files_one

array static array static array static array static array ILIAS\Filesystem\Util\ZipTest::$files_one

staticprotected

Initial value:

= [
        0 => 'Ordner 0/13_Test.pdf'

Definition at line 316 of file ZipTest.php.

$files_three

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

staticprotected

Initial value:

= [
        0 => 'Ordner A/01_Test.pdf'

Definition at line 334 of file ZipTest.php.

$unzips_dir

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

protected

Definition at line 41 of file ZipTest.php.

$zips_dir

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

protected

Definition at line 40 of file ZipTest.php.

ZIPPED_ZIP

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

Definition at line 39 of file ZipTest.php.

---

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

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