lib/tests/tablelib_test.php

   1 <?php
   2 // This file is part of Moodle - http://moodle.org/
   3 //
   4 // Moodle is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU General Public License as published by
   6 // the Free Software Foundation, either version 3 of the License, or
   7 // (at your option) any later version.
   8 //
   9 // Moodle is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU General Public License
  15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 /**
  18  * Test tablelib.
  19  *
  20  * @package    core
  21  * @category   phpunit
  22  * @copyright  2013 Damyon Wiese <damyon@moodle.com>
  23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24  */
  25
  26 defined('MOODLE_INTERNAL') || die();
  27
  28 global $CFG;
  29 require_once($CFG->libdir . '/tablelib.php');
  30 require_once($CFG->libdir . '/tests/fixtures/testable_flexible_table.php');
  31
  32 /**
  33  * Test some of tablelib.
  34  *
  35  * @package    core
  36  * @category   phpunit
  37  * @copyright  2013 Damyon Wiese <damyon@moodle.com>
  38  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  39  */
  40 class core_tablelib_testcase extends basic_testcase {
  41     protected function generate_columns($cols) {
  42         $columns = array();
  43         foreach (range(0, $cols - 1) as $j) {
  44             array_push($columns, 'column' . $j);
  45         }
  46         return $columns;
  47     }
  48
  49     protected function generate_headers($cols) {
  50         $columns = array();
  51         foreach (range(0, $cols - 1) as $j) {
  52             array_push($columns, 'Column ' . $j);
  53         }
  54         return $columns;
  55     }
  56
  57     protected function generate_data($rows, $cols) {
  58         $data = array();
  59
  60         foreach (range(0, $rows - 1) as $i) {
  61             $row = array();
  62             foreach (range(0, $cols - 1) as $j) {
  63                 $val =  'row ' . $i . ' col ' . $j;
  64                 $row['column' . $j] = $val;
  65             }
  66             array_push($data, $row);
  67         }
  68         return $data;
  69     }
  70
  71     /**
  72      * Create a table with properties as passed in params, add data and output html.
  73      *
  74      * @param string[] $columns
  75      * @param string[] $headers
  76      * @param bool     $sortable
  77      * @param bool     $collapsible
  78      * @param string[] $suppress
  79      * @param string[] $nosorting
  80      * @param (array|object)[] $data
  81      * @param int      $pagesize
  82      */
  83     protected function run_table_test($columns, $headers, $sortable, $collapsible, $suppress, $nosorting, $data, $pagesize) {
  84         $table = $this->create_and_setup_table($columns, $headers, $sortable, $collapsible, $suppress, $nosorting);
  85         $table->pagesize($pagesize, count($data));
  86         foreach ($data as $row) {
  87             $table->add_data_keyed($row);
  88         }
  89         $table->finish_output();
  90     }
  91
  92     /**
  93      * Create a table with properties as passed in params.
  94      *
  95      * @param string[] $columns
  96      * @param string[] $headers
  97      * @param bool $sortable
  98      * @param bool $collapsible
  99      * @param string[] $suppress
 100      * @param string[] $nosorting
 101      * @return flexible_table
 102      */
 103     protected function create_and_setup_table($columns, $headers, $sortable, $collapsible, $suppress, $nosorting) {
 104         $table = new flexible_table('tablelib_test');
 105
 106         $table->define_columns($columns);
 107         $table->define_headers($headers);
 108         $table->define_baseurl('/invalid.php');
 109
 110         $table->sortable($sortable);
 111         $table->collapsible($collapsible);
 112         foreach ($suppress as $column) {
 113             $table->column_suppress($column);
 114         }
 115
 116         foreach ($nosorting as $column) {
 117             $table->no_sorting($column);
 118         }
 119
 120         $table->setup();
 121         return $table;
 122     }
 123
 124     public function test_empty_table() {
 125         $this->expectOutputRegex('/' . get_string('nothingtodisplay') . '/');
 126         $this->run_table_test(
 127             array('column1', 'column2'),       // Columns.
 128             array('Column 1', 'Column 2'),     // Headers.
 129             true,                              // Sortable.
 130             false,                             // Collapsible.
 131             array(),                           // Suppress columns.
 132             array(),                           // No sorting.
 133             array(),                           // Data.
 134             10                                 // Page size.
 135         );
 136     }
 137
 138     public function test_has_next_pagination() {
 139
 140         $data = $this->generate_data(11, 2);
 141         $columns = $this->generate_columns(2);
 142         $headers = $this->generate_headers(2);
 143
 144         // Search for pagination controls containing '1.*2</a>.*Next</a>'.
 145         $this->expectOutputRegex('/1.*2<\/a>.*' . get_string('next') . '<\/a>/');
 146
 147         $this->run_table_test(
 148             $columns,
 149             $headers,
 150             true,
 151             false,
 152             array(),
 153             array(),
 154             $data,
 155             10
 156         );
 157     }
 158
 159     public function test_has_hide() {
 160
 161         $data = $this->generate_data(11, 2);
 162         $columns = $this->generate_columns(2);
 163         $headers = $this->generate_headers(2);
 164
 165         // Search for 'hide' links in the column headers.
 166         $this->expectOutputRegex('/' . get_string('hide') . '/');
 167
 168         $this->run_table_test(
 169             $columns,
 170             $headers,
 171             true,
 172             true,
 173             array(),
 174             array(),
 175             $data,
 176             10
 177         );
 178     }
 179
 180     public function test_has_not_hide() {
 181
 182         $data = $this->generate_data(11, 2);
 183         $columns = $this->generate_columns(2);
 184         $headers = $this->generate_headers(2);
 185
 186         // Make sure there are no 'hide' links in the headers.
 187
 188         ob_start();
 189         $this->run_table_test(
 190             $columns,
 191             $headers,
 192             true,
 193             false,
 194             array(),
 195             array(),
 196             $data,
 197             10
 198         );
 199         $output = ob_get_contents();
 200         ob_end_clean();
 201         $this->assertNotContains(get_string('hide'), $output);
 202     }
 203
 204     public function test_has_sort() {
 205
 206         $data = $this->generate_data(11, 2);
 207         $columns = $this->generate_columns(2);
 208         $headers = $this->generate_headers(2);
 209
 210         // Search for pagination controls containing '1.*2</a>.*Next</a>'.
 211         $this->expectOutputRegex('/' . get_string('sortby') . '/');
 212
 213         $this->run_table_test(
 214             $columns,
 215             $headers,
 216             true,
 217             false,
 218             array(),
 219             array(),
 220             $data,
 221             10
 222         );
 223     }
 224
 225     public function test_has_not_sort() {
 226
 227         $data = $this->generate_data(11, 2);
 228         $columns = $this->generate_columns(2);
 229         $headers = $this->generate_headers(2);
 230
 231         // Make sure there are no 'Sort by' links in the headers.
 232
 233         ob_start();
 234         $this->run_table_test(
 235             $columns,
 236             $headers,
 237             false,
 238             false,
 239             array(),
 240             array(),
 241             $data,
 242             10
 243         );
 244         $output = ob_get_contents();
 245         ob_end_clean();
 246         $this->assertNotContains(get_string('sortby'), $output);
 247     }
 248
 249     public function test_has_not_next_pagination() {
 250
 251         $data = $this->generate_data(10, 2);
 252         $columns = $this->generate_columns(2);
 253         $headers = $this->generate_headers(2);
 254
 255         // Make sure there are no 'Next' links in the pagination.
 256
 257         ob_start();
 258         $this->run_table_test(
 259             $columns,
 260             $headers,
 261             true,
 262             false,
 263             array(),
 264             array(),
 265             $data,
 266             10
 267         );
 268
 269         $output = ob_get_contents();
 270         ob_end_clean();
 271         $this->assertNotContains(get_string('next'), $output);
 272     }
 273
 274     public function test_1_col() {
 275
 276         $data = $this->generate_data(100, 1);
 277         $columns = $this->generate_columns(1);
 278         $headers = $this->generate_headers(1);
 279
 280         $this->expectOutputRegex('/row 0 col 0/');
 281
 282         $this->run_table_test(
 283             $columns,
 284             $headers,
 285             true,
 286             false,
 287             array(),
 288             array(),
 289             $data,
 290             10
 291         );
 292     }
 293
 294     public function test_empty_rows() {
 295
 296         $data = $this->generate_data(1, 5);
 297         $columns = $this->generate_columns(5);
 298         $headers = $this->generate_headers(5);
 299
 300         // Test that we have at least 5 columns generated for each empty row.
 301         $this->expectOutputRegex('/emptyrow.*r9_c4/');
 302
 303         $this->run_table_test(
 304             $columns,
 305             $headers,
 306             true,
 307             false,
 308             array(),
 309             array(),
 310             $data,
 311             10
 312         );
 313     }
 314
 315     public function test_5_cols() {
 316
 317         $data = $this->generate_data(100, 5);
 318         $columns = $this->generate_columns(5);
 319         $headers = $this->generate_headers(5);
 320
 321         $this->expectOutputRegex('/row 0 col 0/');
 322
 323         $this->run_table_test(
 324             $columns,
 325             $headers,
 326             true,
 327             false,
 328             array(),
 329             array(),
 330             $data,
 331             10
 332         );
 333     }
 334
 335     public function test_50_cols() {
 336
 337         $data = $this->generate_data(100, 50);
 338         $columns = $this->generate_columns(50);
 339         $headers = $this->generate_headers(50);
 340
 341         $this->expectOutputRegex('/row 0 col 0/');
 342
 343         $this->run_table_test(
 344             $columns,
 345             $headers,
 346             true,
 347             false,
 348             array(),
 349             array(),
 350             $data,
 351             10
 352         );
 353     }
 354
 355     public function test_get_row_html() {
 356         $data = $this->generate_data(1, 5);
 357         $columns = $this->generate_columns(5);
 358         $headers = $this->generate_headers(5);
 359         $data = array_keys(array_flip($data[0]));
 360
 361         $table = new flexible_table('tablelib_test');
 362         $table->define_columns($columns);
 363         $table->define_headers($headers);
 364         $table->define_baseurl('/invalid.php');
 365
 366         $row = $table->get_row_html($data);
 367         $this->assertRegExp('/row 0 col 0/', $row);
 368         $this->assertRegExp('/<tr class=""/', $row);
 369         $this->assertRegExp('/<td class="cell c0"/', $row);
 370     }
 371
 372     public function test_persistent_table() {
 373         global $SESSION;
 374
 375         $data = $this->generate_data(5, 5);
 376         $columns = $this->generate_columns(5);
 377         $headers = $this->generate_headers(5);
 378
 379         // Testing without persistence first to verify that the results are different.
 380         $table1 = new flexible_table('tablelib_test');
 381         $table1->define_columns($columns);
 382         $table1->define_headers($headers);
 383         $table1->define_baseurl('/invalid.php');
 384
 385         $table1->sortable(true);
 386         $table1->collapsible(true);
 387
 388         $table1->is_persistent(false);
 389         $_GET['thide'] = 'column0';
 390         $_GET['tsort'] = 'column1';
 391         $_GET['tifirst'] = 'A';
 392         $_GET['tilast'] = 'Z';
 393
 394         foreach ($data as $row) {
 395             $table1->add_data_keyed($row);
 396         }
 397         $table1->setup();
 398
 399         // Clear session data between each new table.
 400         unset($SESSION->flextable);
 401
 402         $table2 = new flexible_table('tablelib_test');
 403         $table2->define_columns($columns);
 404         $table2->define_headers($headers);
 405         $table2->define_baseurl('/invalid.php');
 406
 407         $table2->sortable(true);
 408         $table2->collapsible(true);
 409
 410         $table2->is_persistent(false);
 411         unset($_GET);
 412
 413         foreach ($data as $row) {
 414             $table2->add_data_keyed($row);
 415         }
 416         $table2->setup();
 417
 418         $this->assertNotEquals($table1, $table2);
 419
 420         unset($SESSION->flextable);
 421
 422         // Now testing with persistence to check that the tables are the same.
 423         $table3 = new flexible_table('tablelib_test');
 424         $table3->define_columns($columns);
 425         $table3->define_headers($headers);
 426         $table3->define_baseurl('/invalid.php');
 427
 428         $table3->sortable(true);
 429         $table3->collapsible(true);
 430
 431         $table3->is_persistent(true);
 432         $_GET['thide'] = 'column0';
 433         $_GET['tsort'] = 'column1';
 434         $_GET['tifirst'] = 'A';
 435         $_GET['tilast'] = 'Z';
 436
 437         foreach ($data as $row) {
 438             $table3->add_data_keyed($row);
 439         }
 440         $table3->setup();
 441
 442         unset($SESSION->flextable);
 443
 444         $table4 = new flexible_table('tablelib_test');
 445         $table4->define_columns($columns);
 446         $table4->define_headers($headers);
 447         $table4->define_baseurl('/invalid.php');
 448
 449         $table4->sortable(true);
 450         $table4->collapsible(true);
 451
 452         $table4->is_persistent(true);
 453         unset($_GET);
 454
 455         foreach ($data as $row) {
 456             $table4->add_data_keyed($row);
 457         }
 458         $table4->setup();
 459
 460         $this->assertEquals($table3, $table4);
 461
 462         unset($SESSION->flextable);
 463
 464         // Finally, another test with no persistence, but without clearing the session data.
 465         $table5 = new flexible_table('tablelib_test');
 466         $table5->define_columns($columns);
 467         $table5->define_headers($headers);
 468         $table5->define_baseurl('/invalid.php');
 469
 470         $table5->sortable(true);
 471         $table5->collapsible(true);
 472
 473         $table5->is_persistent(true);
 474         $_GET['thide'] = 'column0';
 475         $_GET['tsort'] = 'column1';
 476         $_GET['tifirst'] = 'A';
 477         $_GET['tilast'] = 'Z';
 478
 479         foreach ($data as $row) {
 480             $table5->add_data_keyed($row);
 481         }
 482         $table5->setup();
 483
 484         $table6 = new flexible_table('tablelib_test');
 485         $table6->define_columns($columns);
 486         $table6->define_headers($headers);
 487         $table6->define_baseurl('/invalid.php');
 488
 489         $table6->sortable(true);
 490         $table6->collapsible(true);
 491
 492         $table6->is_persistent(true);
 493         unset($_GET);
 494
 495         foreach ($data as $row) {
 496             $table6->add_data_keyed($row);
 497         }
 498         $table6->setup();
 499
 500         $this->assertEquals($table5, $table6);
 501     }
 502
 503     /**
 504      * Helper method for preparing tables instances in {@link self::test_can_be_reset()}.
 505      *
 506      * @param string $tableid
 507      * @return testable_flexible_table
 508      */
 509     protected function prepare_table_for_reset_test($tableid) {
 510         global $SESSION;
 511
 512         unset($SESSION->flextable[$tableid]);
 513
 514         $data = $this->generate_data(25, 3);
 515         $columns = array('column0', 'column1', 'column2');
 516         $headers = $this->generate_headers(3);
 517
 518         $table = new testable_flexible_table($tableid);
 519         $table->define_baseurl('/invalid.php');
 520         $table->define_columns($columns);
 521         $table->define_headers($headers);
 522         $table->collapsible(true);
 523         $table->is_persistent(false);
 524
 525         return $table;
 526     }
 527
 528     public function test_can_be_reset() {
 529
 530         // Table in its default state (as if seen for the first time), nothing to reset.
 531         $table = $this->prepare_table_for_reset_test(uniqid('tablelib_test_'));
 532         $table->setup();
 533         $this->assertFalse($table->can_be_reset());
 534
 535         // Table in its default state with default sorting defined, nothing to reset.
 536         $table = $this->prepare_table_for_reset_test(uniqid('tablelib_test_'));
 537         $table->sortable(true, 'column1', SORT_DESC);
 538         $table->setup();
 539         $this->assertFalse($table->can_be_reset());
 540
 541         // Table explicitly sorted by the default column (reverses the order), can be reset.
 542         $table = $this->prepare_table_for_reset_test(uniqid('tablelib_test_'));
 543         $table->sortable(true, 'column1', SORT_DESC);
 544         $_GET['tsort'] = 'column1';
 545         $table->setup();
 546         unset($_GET['tsort']);
 547         $this->assertTrue($table->can_be_reset());
 548
 549         // Table explicitly sorted twice by the default column (puts back to default order), nothing to reset.
 550         $table = $this->prepare_table_for_reset_test(uniqid('tablelib_test_'));
 551         $table->sortable(true, 'column1', SORT_DESC);
 552         $_GET['tsort'] = 'column1';
 553         $table->setup();
 554         $table->setup(); // Set up again to simulate the second page request.
 555         unset($_GET['tsort']);
 556         $this->assertFalse($table->can_be_reset());
 557
 558         // Table sorted by other than default column, can be reset.
 559         $table = $this->prepare_table_for_reset_test(uniqid('tablelib_test_'));
 560         $table->sortable(true, 'column1', SORT_DESC);
 561         $_GET['tsort'] = 'column2';
 562         $table->setup();
 563         unset($_GET['tsort']);
 564         $this->assertTrue($table->can_be_reset());
 565
 566         // Table sorted by the default column after another sorting previously selected.
 567         // This leads to different ORDER BY than just having a single sort defined, can be reset.
 568         $table = $this->prepare_table_for_reset_test(uniqid('tablelib_test_'));
 569         $table->sortable(true, 'column1', SORT_DESC);
 570         $_GET['tsort'] = 'column0';
 571         $table->setup();
 572         $_GET['tsort'] = 'column1';
 573         $table->setup();
 574         unset($_GET['tsort']);
 575         $this->assertTrue($table->can_be_reset());
 576
 577         // Table having some column collapsed, can be reset.
 578         $table = $this->prepare_table_for_reset_test(uniqid('tablelib_test_'));
 579         $_GET['thide'] = 'column2';
 580         $table->setup();
 581         unset($_GET['thide']);
 582         $this->assertTrue($table->can_be_reset());
 583
 584         // Table having some column explicitly expanded, nothing to reset.
 585         $table = $this->prepare_table_for_reset_test(uniqid('tablelib_test_'));
 586         $_GET['tshow'] = 'column2';
 587         $table->setup();
 588         unset($_GET['tshow']);
 589         $this->assertFalse($table->can_be_reset());
 590
 591         // Table after expanding a collapsed column, nothing to reset.
 592         $table = $this->prepare_table_for_reset_test(uniqid('tablelib_test_'));
 593         $_GET['thide'] = 'column0';
 594         $table->setup();
 595         $_GET['tshow'] = 'column0';
 596         $table->setup();
 597         unset($_GET['thide']);
 598         unset($_GET['tshow']);
 599         $this->assertFalse($table->can_be_reset());
 600
 601         // Table with some name filtering enabled, can be reset.
 602         $table = $this->prepare_table_for_reset_test(uniqid('tablelib_test_'));
 603         $_GET['tifirst'] = 'A';
 604         $table->setup();
 605         unset($_GET['tifirst']);
 606         $this->assertTrue($table->can_be_reset());
 607     }
 608 }