tests/unit/ZipExtensionTest.php

   1 <?php
   2
   3 declare(strict_types=1);
   4
   5 namespace PhpMyAdmin\Tests;
   6
   7 use PhpMyAdmin\ZipExtension;
   8 use PHPUnit\Framework\Attributes\CoversClass;
   9 use PHPUnit\Framework\Attributes\DataProvider;
  10 use PHPUnit\Framework\Attributes\RequiresPhpExtension;
  11 use ZipArchive;
  12
  13 use function file_put_contents;
  14 use function tempnam;
  15 use function unlink;
  16
  17 #[CoversClass(ZipExtension::class)]
  18 #[RequiresPhpExtension('zip')]
  19 class ZipExtensionTest extends AbstractTestCase
  20 {
  21     private ZipExtension $zipExtension;
  22
  23     protected function setUp(): void
  24     {
  25         parent::setUp();
  26
  27         $this->zipExtension = new ZipExtension(new ZipArchive());
  28     }
  29
  30     /**
  31      * Test for getContents
  32      *
  33      * @param string                $file          path to zip file
  34      * @param string|null           $specificEntry regular expression to match a file
  35      * @param array<string, string> $output        expected output
  36      * @psalm-param array{error: string, data: string} $output
  37      */
  38     #[DataProvider('provideTestGetContents')]
  39     public function testGetContents(string $file, string|null $specificEntry, array $output): void
  40     {
  41         self::assertSame(
  42             $this->zipExtension->getContents($file, $specificEntry),
  43             $output,
  44         );
  45     }
  46
  47     /**
  48      * @return array<string, array<int, array<string, string>|string|null>>
  49      * @psalm-return array<string, array{string, string|null, array{error: string, data: string}}>
  50      */
  51     public static function provideTestGetContents(): array
  52     {
  53         return [
  54             'null as specific entry' => [
  55                 './tests/test_data/test.zip',
  56                 null,
  57                 ['error' => '', 'data' => 'TEST FILE' . "\n"],
  58             ],
  59             'an existent specific entry' => [
  60                 './tests/test_data/test.zip',
  61                 '/test.file/',
  62                 ['error' => '', 'data' => 'TEST FILE' . "\n"],
  63             ],
  64             'a nonexistent specific entry' => [
  65                 './tests/test_data/test.zip',
  66                 '/foobar/',
  67                 ['error' => 'Error in ZIP archive: Could not find "/foobar/"', 'data' => ''],
  68             ],
  69         ];
  70     }
  71
  72     /**
  73      * Test for findFile
  74      *
  75      * @param string      $file       path to zip file
  76      * @param string      $fileRegexp regular expression for the file name to match
  77      * @param string|bool $output     expected output
  78      * @psalm-param string|false $output
  79      */
  80     #[DataProvider('provideTestFindFile')]
  81     public function testFindFile(string $file, string $fileRegexp, string|bool $output): void
  82     {
  83         self::assertSame(
  84             $this->zipExtension->findFile($file, $fileRegexp),
  85             $output,
  86         );
  87     }
  88
  89     /**
  90      * Provider for testFindFileFromZipArchive
  91      *
  92      * @return array<int, array<int, string|bool>>
  93      * @psalm-return array<int, array{string, string, string|false}>
  94      */
  95     public static function provideTestFindFile(): array
  96     {
  97         return [
  98             ['./tests/test_data/test.zip', '/test/', 'test.file'],
  99             ['./tests/test_data/test.zip', '/invalid/', false],
 100         ];
 101     }
 102
 103     /**
 104      * Test for getNumberOfFiles
 105      */
 106     public function testGetNumberOfFiles(): void
 107     {
 108         self::assertSame(
 109             $this->zipExtension->getNumberOfFiles('./tests/test_data/test.zip'),
 110             1,
 111         );
 112     }
 113
 114     /**
 115      * Test for extract
 116      */
 117     public function testExtract(): void
 118     {
 119         self::assertFalse(
 120             $this->zipExtension->extract(
 121                 './tests/test_data/test.zip',
 122                 'wrongName',
 123             ),
 124         );
 125         self::assertSame(
 126             "TEST FILE\n",
 127             $this->zipExtension->extract(
 128                 './tests/test_data/test.zip',
 129                 'test.file',
 130             ),
 131         );
 132     }
 133
 134     /**
 135      * Test for createFile
 136      */
 137     public function testCreateSingleFile(): void
 138     {
 139         $file = $this->zipExtension->createFile('Test content', 'test.txt');
 140         self::assertIsString($file);
 141         self::assertNotEmpty($file);
 142
 143         $tmp = tempnam('./', 'zip-test');
 144         self::assertNotFalse($tmp);
 145         self::assertNotFalse(file_put_contents($tmp, $file));
 146
 147         $zip = new ZipArchive();
 148         self::assertTrue(
 149             $zip->open($tmp),
 150         );
 151
 152         self::assertSame(0, $zip->locateName('test.txt'));
 153
 154         $zip->close();
 155         unlink($tmp);
 156     }
 157
 158     /**
 159      * Test for createFile
 160      */
 161     public function testCreateFailure(): void
 162     {
 163         self::assertFalse(
 164             $this->zipExtension->createFile(
 165                 'Content',
 166                 ['name1.txt', 'name2.txt'],
 167             ),
 168         );
 169     }
 170
 171     /**
 172      * Test for createFile
 173      */
 174     public function testCreateMultiFile(): void
 175     {
 176         $file = $this->zipExtension->createFile(
 177             ['Content', 'Content2'],
 178             ['name1.txt', 'name2.txt'],
 179         );
 180         self::assertIsString($file);
 181         self::assertNotEmpty($file);
 182
 183         $tmp = tempnam('./', 'zip-test');
 184         self::assertNotFalse($tmp);
 185         self::assertNotFalse(file_put_contents($tmp, $file));
 186
 187         $zip = new ZipArchive();
 188         self::assertTrue(
 189             $zip->open($tmp),
 190         );
 191
 192         self::assertSame(0, $zip->locateName('name1.txt'));
 193         self::assertSame(1, $zip->locateName('name2.txt'));
 194
 195         $zip->close();
 196         unlink($tmp);
 197     }
 198 }