tests/unit/Plugins/Export/ExportPdfTest.php

   1 <?php
   2
   3 declare(strict_types=1);
   4
   5 namespace PhpMyAdmin\Tests\Plugins\Export;
   6
   7 use PhpMyAdmin\ConfigStorage\Relation;
   8 use PhpMyAdmin\Dbal\DatabaseInterface;
   9 use PhpMyAdmin\Export\Export;
  10 use PhpMyAdmin\Plugins\Export\ExportPdf;
  11 use PhpMyAdmin\Plugins\Export\Helpers\Pdf;
  12 use PhpMyAdmin\Properties\Options\Groups\OptionsPropertyMainGroup;
  13 use PhpMyAdmin\Properties\Options\Groups\OptionsPropertyRootGroup;
  14 use PhpMyAdmin\Properties\Options\Items\RadioPropertyItem;
  15 use PhpMyAdmin\Properties\Options\Items\TextPropertyItem;
  16 use PhpMyAdmin\Properties\Plugins\ExportPluginProperties;
  17 use PhpMyAdmin\Tests\AbstractTestCase;
  18 use PhpMyAdmin\Transformations;
  19 use PHPUnit\Framework\Attributes\CoversClass;
  20 use PHPUnit\Framework\Attributes\Medium;
  21 use ReflectionMethod;
  22 use ReflectionProperty;
  23
  24 use function __;
  25
  26 #[CoversClass(ExportPdf::class)]
  27 #[Medium]
  28 class ExportPdfTest extends AbstractTestCase
  29 {
  30     protected ExportPdf $object;
  31
  32     /**
  33      * Configures global environment.
  34      */
  35     protected function setUp(): void
  36     {
  37         parent::setUp();
  38
  39         $dbi = $this->createDatabaseInterface();
  40         DatabaseInterface::$instance = $dbi;
  41         Export::$outputKanjiConversion = false;
  42         Export::$outputCharsetConversion = false;
  43         Export::$bufferNeeded = false;
  44         Export::$asFile = true;
  45         Export::$saveOnServer = false;
  46         $this->object = new ExportPdf(
  47             new Relation($dbi),
  48             new Export($dbi),
  49             new Transformations(),
  50         );
  51     }
  52
  53     /**
  54      * tearDown for test cases
  55      */
  56     protected function tearDown(): void
  57     {
  58         parent::tearDown();
  59
  60         unset($this->object);
  61     }
  62
  63     public function testSetProperties(): void
  64     {
  65         $method = new ReflectionMethod(ExportPdf::class, 'setProperties');
  66         $method->invoke($this->object, null);
  67
  68         $attrProperties = new ReflectionProperty(ExportPdf::class, 'properties');
  69         $properties = $attrProperties->getValue($this->object);
  70
  71         self::assertInstanceOf(ExportPluginProperties::class, $properties);
  72
  73         self::assertSame(
  74             'PDF',
  75             $properties->getText(),
  76         );
  77
  78         self::assertSame(
  79             'pdf',
  80             $properties->getExtension(),
  81         );
  82
  83         self::assertSame(
  84             'application/pdf',
  85             $properties->getMimeType(),
  86         );
  87
  88         self::assertSame(
  89             'Options',
  90             $properties->getOptionsText(),
  91         );
  92
  93         self::assertTrue(
  94             $properties->getForceFile(),
  95         );
  96
  97         $options = $properties->getOptions();
  98
  99         self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 100
 101         self::assertSame(
 102             'Format Specific Options',
 103             $options->getName(),
 104         );
 105
 106         $generalOptionsArray = $options->getProperties();
 107
 108         $generalOptions = $generalOptionsArray->current();
 109         $generalOptionsArray->next();
 110
 111         self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 112
 113         self::assertSame(
 114             'general_opts',
 115             $generalOptions->getName(),
 116         );
 117
 118         $generalProperties = $generalOptions->getProperties();
 119
 120         $property = $generalProperties->current();
 121
 122         self::assertInstanceOf(TextPropertyItem::class, $property);
 123
 124         self::assertSame(
 125             'report_title',
 126             $property->getName(),
 127         );
 128
 129         $generalOptions = $generalOptionsArray->current();
 130
 131         self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 132
 133         self::assertSame(
 134             'dump_what',
 135             $generalOptions->getName(),
 136         );
 137
 138         self::assertSame(
 139             'Dump table',
 140             $generalOptions->getText(),
 141         );
 142
 143         $generalProperties = $generalOptions->getProperties();
 144
 145         $property = $generalProperties->current();
 146
 147         self::assertInstanceOf(RadioPropertyItem::class, $property);
 148
 149         self::assertSame(
 150             'structure_or_data',
 151             $property->getName(),
 152         );
 153
 154         self::assertSame(
 155             ['structure' => __('structure'), 'data' => __('data'), 'structure_and_data' => __('structure and data')],
 156             $property->getValues(),
 157         );
 158     }
 159
 160     public function testExportHeader(): void
 161     {
 162         $pdf = $this->getMockBuilder(Pdf::class)
 163             ->disableOriginalConstructor()
 164             ->getMock();
 165
 166         $pdf->expects(self::once())
 167             ->method('Open');
 168
 169         $pdf->expects(self::once())
 170             ->method('setTopMargin');
 171
 172         $attrPdf = new ReflectionProperty(ExportPdf::class, 'pdf');
 173         $attrPdf->setValue($this->object, $pdf);
 174
 175         self::assertTrue(
 176             $this->object->exportHeader(),
 177         );
 178     }
 179
 180     public function testExportFooter(): void
 181     {
 182         $pdf = $this->getMockBuilder(Pdf::class)
 183             ->disableOriginalConstructor()
 184             ->getMock();
 185
 186         $pdf->expects(self::once())
 187             ->method('getPDFData')
 188             ->willReturn('');
 189
 190         $attrPdf = new ReflectionProperty(ExportPdf::class, 'pdf');
 191         $attrPdf->setValue($this->object, $pdf);
 192
 193         self::assertTrue(
 194             $this->object->exportFooter(),
 195         );
 196     }
 197
 198     public function testExportDBHeader(): void
 199     {
 200         self::assertTrue(
 201             $this->object->exportDBHeader('testDB'),
 202         );
 203     }
 204
 205     public function testExportDBFooter(): void
 206     {
 207         self::assertTrue(
 208             $this->object->exportDBFooter('testDB'),
 209         );
 210     }
 211
 212     public function testExportDBCreate(): void
 213     {
 214         self::assertTrue(
 215             $this->object->exportDBCreate('testDB'),
 216         );
 217     }
 218
 219     public function testExportData(): void
 220     {
 221         $pdf = $this->getMockBuilder(Pdf::class)
 222             ->disableOriginalConstructor()
 223             ->getMock();
 224
 225         $pdf->expects(self::once())
 226             ->method('mysqlReport')
 227             ->with('SELECT');
 228
 229         $attrPdf = new ReflectionProperty(ExportPdf::class, 'pdf');
 230         $attrPdf->setValue($this->object, $pdf);
 231
 232         self::assertTrue(
 233             $this->object->exportData(
 234                 'db',
 235                 'table',
 236                 'SELECT',
 237             ),
 238         );
 239     }
 240
 241     /**
 242      * Test for
 243      *     - PhpMyAdmin\Plugins\Export\ExportPdf::setPdf
 244      *     - PhpMyAdmin\Plugins\Export\ExportPdf::getPdf
 245      */
 246     public function testSetGetPdf(): void
 247     {
 248         $setter = new ReflectionMethod(ExportPdf::class, 'setPdf');
 249         $setter->invoke($this->object, new Pdf());
 250
 251         $getter = new ReflectionMethod(ExportPdf::class, 'getPdf');
 252         self::assertInstanceOf(
 253             Pdf::class,
 254             $getter->invoke($this->object),
 255         );
 256     }
 257 }