tests/unit/Plugins/Export/ExportHtmlwordTest.php

   1 <?php
   2
   3 declare(strict_types=1);
   4
   5 namespace PhpMyAdmin\Tests\Plugins\Export;
   6
   7 use PhpMyAdmin\Column;
   8 use PhpMyAdmin\Config;
   9 use PhpMyAdmin\ConfigStorage\Relation;
  10 use PhpMyAdmin\ConfigStorage\RelationParameters;
  11 use PhpMyAdmin\Current;
  12 use PhpMyAdmin\Dbal\DatabaseInterface;
  13 use PhpMyAdmin\Export\Export;
  14 use PhpMyAdmin\Http\Factory\ServerRequestFactory;
  15 use PhpMyAdmin\Identifiers\TableName;
  16 use PhpMyAdmin\Identifiers\TriggerName;
  17 use PhpMyAdmin\Plugins\Export\ExportHtmlword;
  18 use PhpMyAdmin\Properties\Options\Groups\OptionsPropertyMainGroup;
  19 use PhpMyAdmin\Properties\Options\Groups\OptionsPropertyRootGroup;
  20 use PhpMyAdmin\Properties\Options\Items\BoolPropertyItem;
  21 use PhpMyAdmin\Properties\Options\Items\RadioPropertyItem;
  22 use PhpMyAdmin\Properties\Options\Items\TextPropertyItem;
  23 use PhpMyAdmin\Properties\Plugins\ExportPluginProperties;
  24 use PhpMyAdmin\Tests\AbstractTestCase;
  25 use PhpMyAdmin\Tests\Stubs\DbiDummy;
  26 use PhpMyAdmin\Tests\Stubs\DummyResult;
  27 use PhpMyAdmin\Transformations;
  28 use PhpMyAdmin\Triggers\Event;
  29 use PhpMyAdmin\Triggers\Timing;
  30 use PhpMyAdmin\Triggers\Trigger;
  31 use PHPUnit\Framework\Attributes\CoversClass;
  32 use PHPUnit\Framework\Attributes\Medium;
  33 use ReflectionMethod;
  34 use ReflectionProperty;
  35
  36 use function __;
  37 use function ob_get_clean;
  38 use function ob_start;
  39
  40 #[CoversClass(ExportHtmlword::class)]
  41 #[Medium]
  42 class ExportHtmlwordTest extends AbstractTestCase
  43 {
  44     protected DatabaseInterface $dbi;
  45
  46     protected DbiDummy $dummyDbi;
  47
  48     protected ExportHtmlword $object;
  49
  50     /**
  51      * Configures global environment.
  52      */
  53     protected function setUp(): void
  54     {
  55         parent::setUp();
  56
  57         $this->dummyDbi = $this->createDbiDummy();
  58         $this->dbi = $this->createDatabaseInterface($this->dummyDbi);
  59         DatabaseInterface::$instance = $this->dbi;
  60         $this->object = new ExportHtmlword(
  61             new Relation($this->dbi),
  62             new Export($this->dbi),
  63             new Transformations(),
  64         );
  65         Export::$outputKanjiConversion = false;
  66         Export::$outputCharsetConversion = false;
  67         Export::$bufferNeeded = false;
  68         Export::$asFile = true;
  69         Export::$saveOnServer = false;
  70         Current::$database = '';
  71         Current::$table = '';
  72         Current::$lang = '';
  73         Config::getInstance()->selectedServer['DisableIS'] = true;
  74     }
  75
  76     /**
  77      * tearDown for test cases
  78      */
  79     protected function tearDown(): void
  80     {
  81         parent::tearDown();
  82
  83         unset($this->object);
  84     }
  85
  86     public function testSetProperties(): void
  87     {
  88         $method = new ReflectionMethod(ExportHtmlword::class, 'setProperties');
  89         $method->invoke($this->object, null);
  90
  91         $attrProperties = new ReflectionProperty(ExportHtmlword::class, 'properties');
  92         $properties = $attrProperties->getValue($this->object);
  93
  94         self::assertInstanceOf(ExportPluginProperties::class, $properties);
  95
  96         self::assertSame(
  97             'Microsoft Word 2000',
  98             $properties->getText(),
  99         );
 100
 101         self::assertSame(
 102             'doc',
 103             $properties->getExtension(),
 104         );
 105
 106         self::assertSame(
 107             'application/vnd.ms-word',
 108             $properties->getMimeType(),
 109         );
 110
 111         self::assertSame(
 112             'Options',
 113             $properties->getOptionsText(),
 114         );
 115
 116         self::assertTrue(
 117             $properties->getForceFile(),
 118         );
 119
 120         $options = $properties->getOptions();
 121
 122         self::assertInstanceOf(OptionsPropertyRootGroup::class, $options);
 123
 124         self::assertSame(
 125             'Format Specific Options',
 126             $options->getName(),
 127         );
 128
 129         $generalOptionsArray = $options->getProperties();
 130         $generalOptions = $generalOptionsArray->current();
 131         $generalOptionsArray->next();
 132
 133         self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 134
 135         self::assertSame(
 136             'dump_what',
 137             $generalOptions->getName(),
 138         );
 139
 140         self::assertSame(
 141             'Dump table',
 142             $generalOptions->getText(),
 143         );
 144
 145         $generalProperties = $generalOptions->getProperties();
 146
 147         $property = $generalProperties->current();
 148
 149         self::assertInstanceOf(RadioPropertyItem::class, $property);
 150
 151         self::assertSame(
 152             'structure_or_data',
 153             $property->getName(),
 154         );
 155
 156         self::assertSame(
 157             ['structure' => __('structure'), 'data' => __('data'), 'structure_and_data' => __('structure and data')],
 158             $property->getValues(),
 159         );
 160
 161         $generalOptions = $generalOptionsArray->current();
 162
 163         self::assertInstanceOf(OptionsPropertyMainGroup::class, $generalOptions);
 164
 165         self::assertSame(
 166             'dump_what',
 167             $generalOptions->getName(),
 168         );
 169
 170         self::assertSame(
 171             'Data dump options',
 172             $generalOptions->getText(),
 173         );
 174
 175         self::assertSame(
 176             'structure',
 177             $generalOptions->getForce(),
 178         );
 179
 180         $generalProperties = $generalOptions->getProperties();
 181
 182         $property = $generalProperties->current();
 183         $generalProperties->next();
 184
 185         self::assertInstanceOf(TextPropertyItem::class, $property);
 186
 187         self::assertSame(
 188             'null',
 189             $property->getName(),
 190         );
 191
 192         self::assertSame(
 193             'Replace NULL with:',
 194             $property->getText(),
 195         );
 196
 197         $property = $generalProperties->current();
 198
 199         self::assertInstanceOf(BoolPropertyItem::class, $property);
 200
 201         self::assertSame(
 202             'columns',
 203             $property->getName(),
 204         );
 205
 206         self::assertSame(
 207             'Put columns names in the first row',
 208             $property->getText(),
 209         );
 210     }
 211
 212     public function testExportHeader(): void
 213     {
 214         ob_start();
 215         $this->object->exportHeader();
 216         $result = ob_get_clean();
 217
 218         $expected = '<html xmlns:o="urn:schemas-microsoft-com:office:office"
 219             xmlns:x="urn:schemas-microsoft-com:office:word"
 220             xmlns="http://www.w3.org/TR/REC-html40">
 221
 222             <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"'
 223             . ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 224             <html>
 225             <head>
 226                 <meta http-equiv="Content-type" content="text/html;charset='
 227             . 'utf-8" />
 228             </head>
 229             <body>';
 230
 231         self::assertSame($expected, $result);
 232
 233         // case 2
 234
 235         Current::$charset = 'ISO-8859-1';
 236         ob_start();
 237         $this->object->exportHeader();
 238         $result = ob_get_clean();
 239
 240         $expected = '<html xmlns:o="urn:schemas-microsoft-com:office:office"
 241             xmlns:x="urn:schemas-microsoft-com:office:word"
 242             xmlns="http://www.w3.org/TR/REC-html40">
 243
 244             <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"'
 245             . ' "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 246             <html>
 247             <head>
 248                 <meta http-equiv="Content-type" content="text/html;charset='
 249             . 'ISO-8859-1" />
 250             </head>
 251             <body>';
 252
 253         self::assertSame($expected, $result);
 254     }
 255
 256     public function testExportFooter(): void
 257     {
 258         ob_start();
 259         self::assertTrue(
 260             $this->object->exportFooter(),
 261         );
 262         $result = ob_get_clean();
 263
 264         self::assertSame('</body></html>', $result);
 265     }
 266
 267     public function testExportDBHeader(): void
 268     {
 269         ob_start();
 270         self::assertTrue(
 271             $this->object->exportDBHeader('d"b'),
 272         );
 273         $result = ob_get_clean();
 274
 275         self::assertSame('<h1>Database d&quot;b</h1>', $result);
 276     }
 277
 278     public function testExportDBFooter(): void
 279     {
 280         self::assertTrue(
 281             $this->object->exportDBFooter('testDB'),
 282         );
 283     }
 284
 285     public function testExportDBCreate(): void
 286     {
 287         self::assertTrue(
 288             $this->object->exportDBCreate('testDB'),
 289         );
 290     }
 291
 292     public function testExportData(): void
 293     {
 294         // case 1
 295         Export::$outputKanjiConversion = false;
 296         Export::$outputCharsetConversion = false;
 297         Export::$bufferNeeded = false;
 298         Export::$asFile = true;
 299         Export::$saveOnServer = false;
 300
 301         $request = ServerRequestFactory::create()->createServerRequest('POST', 'https://example.com/')
 302             ->withParsedBody(['htmlword_columns' => 'On']);
 303
 304         $this->object->setExportOptions($request, []);
 305
 306         ob_start();
 307         self::assertTrue($this->object->exportData(
 308             'test_db',
 309             'test_table',
 310             'SELECT * FROM `test_db`.`test_table`;',
 311         ));
 312         $result = ob_get_clean();
 313
 314         self::assertSame(
 315             '<h2>Dumping data for table test_table</h2>'
 316             . '<table width="100%" cellspacing="1"><tr class="print-category">'
 317             . '<td class="print"><strong>id</strong></td>'
 318             . '<td class="print"><strong>name</strong></td>'
 319             . '<td class="print"><strong>datetimefield</strong></td>'
 320             . '</tr><tr class="print-category">'
 321             . '<td class="print">1</td><td class="print">abcd</td><td class="print">2011-01-20 02:00:02</td>'
 322             . '</tr><tr class="print-category">'
 323             . '<td class="print">2</td><td class="print">foo</td><td class="print">2010-01-20 02:00:02</td>'
 324             . '</tr><tr class="print-category">'
 325             . '<td class="print">3</td><td class="print">Abcd</td><td class="print">2012-01-20 02:00:02</td>'
 326             . '</tr></table>',
 327             $result,
 328         );
 329     }
 330
 331     public function testGetTableDefStandIn(): void
 332     {
 333         $this->object = $this->getMockBuilder(ExportHtmlword::class)
 334             ->onlyMethods(['formatOneColumnDefinition'])
 335             ->disableOriginalConstructor()
 336             ->getMock();
 337
 338         // case 1
 339
 340         $keys = [['Non_unique' => 0, 'Column_name' => 'name1'], ['Non_unique' => 1, 'Column_name' => 'name2']];
 341
 342         $dbi = $this->getMockBuilder(DatabaseInterface::class)
 343             ->disableOriginalConstructor()
 344             ->getMock();
 345
 346         $dbi->expects(self::once())
 347             ->method('getTableIndexes')
 348             ->with('database', 'view')
 349             ->willReturn($keys);
 350
 351         $column = new Column('column', '', null, false, '', null, '', '', '');
 352
 353         $dbi->expects(self::once())
 354             ->method('getColumns')
 355             ->with('database', 'view')
 356             ->willReturn([$column]);
 357
 358         DatabaseInterface::$instance = $dbi;
 359
 360         $this->object->expects(self::once())
 361             ->method('formatOneColumnDefinition')
 362             ->with($column, ['name1'], 'column')
 363             ->willReturn('1');
 364
 365         self::assertSame(
 366             '<table width="100%" cellspacing="1">' .
 367             '<tr class="print-category"><th class="print">Column</th>' .
 368             '<td class="print"><strong>Type</strong></td>' .
 369             '<td class="print"><strong>Null</strong></td>' .
 370             '<td class="print"><strong>Default</strong></td></tr>' .
 371             '1</tr></table>',
 372             $this->object->getTableDefStandIn('database', 'view'),
 373         );
 374     }
 375
 376     public function testGetTableDef(): void
 377     {
 378         $this->object = $this->getMockBuilder(ExportHtmlword::class)
 379             ->onlyMethods(['formatOneColumnDefinition'])
 380             ->setConstructorArgs([new Relation($this->dbi), new Export($this->dbi), new Transformations()])
 381             ->getMock();
 382
 383         $keys = [['Non_unique' => 0, 'Column_name' => 'name1'], ['Non_unique' => 1, 'Column_name' => 'name2']];
 384
 385         // case 1
 386
 387         $resultStub = self::createMock(DummyResult::class);
 388
 389         $dbi = $this->getMockBuilder(DatabaseInterface::class)
 390             ->disableOriginalConstructor()
 391             ->getMock();
 392
 393         $dbi->expects(self::exactly(2))
 394             ->method('fetchResult')
 395             ->willReturn(
 396                 [],
 397                 ['fieldname' => ['values' => 'test-', 'transformation' => 'testfoo', 'mimetype' => 'test<']],
 398             );
 399
 400         $dbi->expects(self::once())
 401             ->method('getTableIndexes')
 402             ->with('database', '')
 403             ->willReturn($keys);
 404
 405         $column = new Column('fieldname', '', null, false, '', null, '', '', '');
 406         $dbi->expects(self::once())
 407             ->method('getColumns')
 408             ->with('database', '')
 409             ->willReturn([$column]);
 410
 411         $dbi->expects(self::once())
 412             ->method('tryQueryAsControlUser')
 413             ->willReturn($resultStub);
 414
 415         $resultStub->expects(self::once())
 416             ->method('numRows')
 417             ->willReturn(1);
 418
 419         $resultStub->expects(self::once())
 420             ->method('fetchAssoc')
 421             ->willReturn(['comment' => 'testComment']);
 422
 423         DatabaseInterface::$instance = $dbi;
 424         $this->object->relation = new Relation($dbi);
 425
 426         $this->object->expects(self::exactly(3))
 427             ->method('formatOneColumnDefinition')
 428             ->with($column, ['name1'])
 429             ->willReturn('1');
 430
 431         $relationParameters = RelationParameters::fromArray([
 432             'relwork' => true,
 433             'commwork' => true,
 434             'mimework' => true,
 435             'db' => 'database',
 436             'relation' => 'rel',
 437             'column_info' => 'col',
 438         ]);
 439         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 440
 441         $request = ServerRequestFactory::create()->createServerRequest('POST', 'https://example.com/')
 442             ->withParsedBody(['htmlword_relation' => 'On', 'htmlword_mime' => 'On', 'htmlword_comments' => 'On']);
 443
 444         $this->object->setExportOptions($request, []);
 445
 446         $result = $this->object->getTableDef('database', '');
 447
 448         self::assertSame(
 449             '<table width="100%" cellspacing="1">' .
 450             '<tr class="print-category"><th class="print">Column</th>' .
 451             '<td class="print"><strong>Type</strong></td>' .
 452             '<td class="print"><strong>Null</strong></td>' .
 453             '<td class="print"><strong>Default</strong></td>' .
 454             '<td class="print"><strong>Comments</strong></td>' .
 455             '<td class="print"><strong>Media type</strong></td></tr>' .
 456             '1<td class="print"></td><td class="print">Test&lt;</td></tr></table>',
 457             $result,
 458         );
 459
 460         // case 2
 461
 462         $resultStub = self::createMock(DummyResult::class);
 463
 464         $dbi = $this->getMockBuilder(DatabaseInterface::class)
 465             ->disableOriginalConstructor()
 466             ->getMock();
 467
 468         $dbi->expects(self::exactly(2))
 469             ->method('fetchResult')
 470             ->willReturn(
 471                 ['fieldname' => ['foreign_table' => 'ftable', 'foreign_field' => 'ffield']],
 472                 ['field' => ['values' => 'test-', 'transformation' => 'testfoo', 'mimetype' => 'test<']],
 473             );
 474
 475         $dbi->expects(self::once())
 476             ->method('getTableIndexes')
 477             ->with('database', '')
 478             ->willReturn($keys);
 479
 480         $column = new Column('fieldname', '', null, false, '', null, '', '', '');
 481
 482         $dbi->expects(self::once())
 483             ->method('getColumns')
 484             ->with('database', '')
 485             ->willReturn([$column]);
 486
 487         $dbi->expects(self::once())
 488             ->method('tryQueryAsControlUser')
 489             ->willReturn($resultStub);
 490
 491         $resultStub->expects(self::once())
 492             ->method('numRows')
 493             ->willReturn(1);
 494
 495         $resultStub->expects(self::once())
 496             ->method('fetchAssoc')
 497             ->willReturn(['comment' => 'testComment']);
 498
 499         DatabaseInterface::$instance = $dbi;
 500         $this->object->relation = new Relation($dbi);
 501
 502         $relationParameters = RelationParameters::fromArray([
 503             'relwork' => true,
 504             'commwork' => true,
 505             'mimework' => true,
 506             'db' => 'database',
 507             'relation' => 'rel',
 508             'column_info' => 'col',
 509         ]);
 510         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 511
 512         $result = $this->object->getTableDef('database', '');
 513
 514         self::assertStringContainsString('<td class="print">ftable (ffield)</td>', $result);
 515
 516         self::assertStringContainsString('<td class="print"></td><td class="print"></td>', $result);
 517
 518         // case 3
 519
 520         $dbi = $this->getMockBuilder(DatabaseInterface::class)
 521             ->disableOriginalConstructor()
 522             ->getMock();
 523
 524         $dbi->expects(self::once())
 525             ->method('getTableIndexes')
 526             ->with('database', '')
 527             ->willReturn($keys);
 528
 529         $column = new Column('fieldname', '', null, false, '', null, '', '', '');
 530
 531         $dbi->expects(self::once())
 532             ->method('getColumns')
 533             ->with('database', '')
 534             ->willReturn([$column]);
 535
 536         $dbi->expects(self::never())
 537             ->method('tryQuery');
 538
 539         DatabaseInterface::$instance = $dbi;
 540
 541         $relationParameters = RelationParameters::fromArray([
 542             'db' => 'database',
 543             'relation' => 'rel',
 544             'column_info' => 'col',
 545         ]);
 546         (new ReflectionProperty(Relation::class, 'cache'))->setValue(null, $relationParameters);
 547
 548         $request = ServerRequestFactory::create()->createServerRequest('POST', 'https://example.com/')
 549             ->withParsedBody(['htmlword_relation' => 'On', 'htmlword_mime' => 'On']);
 550
 551         $this->object->setExportOptions($request, []);
 552
 553         $result = $this->object->getTableDef('database', '');
 554
 555         self::assertSame(
 556             '<table width="100%" cellspacing="1">' .
 557             '<tr class="print-category"><th class="print">Column</th>' .
 558             '<td class="print"><strong>Type</strong></td>' .
 559             '<td class="print"><strong>Null</strong></td>' .
 560             '<td class="print"><strong>Default</strong></td></tr>1</tr></table>',
 561             $result,
 562         );
 563     }
 564
 565     public function testGetTriggers(): void
 566     {
 567         $triggers = [
 568             new Trigger(
 569                 TriggerName::from('tna"me'),
 570                 Timing::Before,
 571                 Event::Update,
 572                 TableName::from('table'),
 573                 'def',
 574                 'test_user@localhost',
 575             ),
 576         ];
 577
 578         $method = new ReflectionMethod(ExportHtmlword::class, 'getTriggers');
 579         $result = $method->invoke($this->object, $triggers);
 580
 581         self::assertStringContainsString(
 582             '<td class="print">tna&quot;me</td>' .
 583             '<td class="print">BEFORE</td>' .
 584             '<td class="print">UPDATE</td>' .
 585             '<td class="print">def</td>',
 586             $result,
 587         );
 588     }
 589
 590     public function testExportStructure(): void
 591     {
 592         ob_start();
 593         $this->dummyDbi->addSelectDb('test_db');
 594         self::assertTrue($this->object->exportStructure('test_db', 'test_table', 'create_table'));
 595         $this->dummyDbi->assertAllSelectsConsumed();
 596         $result = ob_get_clean();
 597
 598         self::assertSame(
 599             '<h2>Table structure for table test_table</h2>'
 600             . '<table width="100%" cellspacing="1"><tr class="print-category">'
 601             . '<th class="print">Column</th><td class="print"><strong>Type</strong></td>'
 602             . '<td class="print"><strong>Null</strong></td><td class="print"><strong>Default</strong></td></tr>'
 603             . '<tr class="print-category"><td class="print"><em><strong>id</strong></em></td>'
 604             . '<td class="print">int(11)</td><td class="print">No</td><td class="print">NULL</td></tr>'
 605             . '<tr class="print-category"><td class="print">name</td><td class="print">varchar(20)</td>'
 606             . '<td class="print">No</td><td class="print">NULL</td></tr><tr class="print-category">'
 607             . '<td class="print">datetimefield</td><td class="print">datetime</td>'
 608             . '<td class="print">No</td><td class="print">NULL</td></tr></table>',
 609             $result,
 610         );
 611
 612         ob_start();
 613         self::assertTrue($this->object->exportStructure('test_db', 'test_table', 'triggers'));
 614         $result = ob_get_clean();
 615
 616         self::assertSame(
 617             '<h2>Triggers test_table</h2><table width="100%" cellspacing="1">'
 618             . '<tr class="print-category"><th class="print">Name</th>'
 619             . '<td class="print"><strong>Time</strong></td><td class="print"><strong>Event</strong></td>'
 620             . '<td class="print"><strong>Definition</strong></td></tr><tr class="print-category">'
 621             . '<td class="print">test_trigger</td><td class="print">AFTER</td>'
 622             . '<td class="print">INSERT</td><td class="print">BEGIN END</td></tr></table>',
 623             $result,
 624         );
 625
 626         ob_start();
 627         $this->dummyDbi->addSelectDb('test_db');
 628         self::assertTrue($this->object->exportStructure('test_db', 'test_table', 'create_view'));
 629         $this->dummyDbi->assertAllSelectsConsumed();
 630         $result = ob_get_clean();
 631
 632         self::assertSame(
 633             '<h2>Structure for view test_table</h2>'
 634             . '<table width="100%" cellspacing="1"><tr class="print-category">'
 635             . '<th class="print">Column</th><td class="print"><strong>Type</strong></td>'
 636             . '<td class="print"><strong>Null</strong></td><td class="print"><strong>Default</strong>'
 637             . '</td></tr><tr class="print-category"><td class="print"><em><strong>id</strong></em></td>'
 638             . '<td class="print">int(11)</td><td class="print">No</td><td class="print">NULL</td></tr>'
 639             . '<tr class="print-category"><td class="print">name</td><td class="print">varchar(20)</td>'
 640             . '<td class="print">No</td><td class="print">NULL</td></tr><tr class="print-category">'
 641             . '<td class="print">datetimefield</td><td class="print">datetime</td>'
 642             . '<td class="print">No</td><td class="print">NULL</td></tr></table>',
 643             $result,
 644         );
 645
 646         ob_start();
 647         self::assertTrue($this->object->exportStructure('test_db', 'test_table', 'stand_in'));
 648         $result = ob_get_clean();
 649
 650         self::assertSame(
 651             '<h2>Stand-in structure for view test_table</h2>'
 652             . '<table width="100%" cellspacing="1"><tr class="print-category">'
 653             . '<th class="print">Column</th><td class="print"><strong>Type</strong></td>'
 654             . '<td class="print"><strong>Null</strong></td><td class="print"><strong>Default</strong></td>'
 655             . '</tr><tr class="print-category">'
 656             . '<td class="print"><em><strong>id</strong></em></td><td class="print">int(11)</td>'
 657             . '<td class="print">No</td><td class="print">NULL</td></tr><tr class="print-category">'
 658             . '<td class="print">name</td><td class="print">varchar(20)</td><td class="print">No</td>'
 659             . '<td class="print">NULL</td></tr><tr class="print-category">'
 660             . '<td class="print">datetimefield</td><td class="print">datetime</td>'
 661             . '<td class="print">No</td><td class="print">NULL</td></tr></table>',
 662             $result,
 663         );
 664     }
 665
 666     public function testFormatOneColumnDefinition(): void
 667     {
 668         $method = new ReflectionMethod(ExportHtmlword::class, 'formatOneColumnDefinition');
 669
 670         $column = new Column('field', 'set(abc)enum123', null, true, 'PRI', null, '', '', '');
 671
 672         $uniqueKeys = ['field'];
 673
 674         self::assertSame(
 675             '<tr class="print-category"><td class="print"><em>' .
 676             '<strong>field</strong></em></td><td class="print">set(abc)</td>' .
 677             '<td class="print">Yes</td><td class="print">NULL</td>',
 678             $method->invoke($this->object, $column, $uniqueKeys),
 679         );
 680
 681         $column = new Column('fields', '', null, false, 'COMP', 'def', '', '', '');
 682
 683         $uniqueKeys = ['field'];
 684
 685         self::assertSame(
 686             '<tr class="print-category"><td class="print">fields</td>' .
 687             '<td class="print">&amp;nbsp;</td><td class="print">No</td>' .
 688             '<td class="print">def</td>',
 689             $method->invoke($this->object, $column, $uniqueKeys),
 690         );
 691     }
 692 }