[Summary view]

Differences Between: [Versions 39 and 310]

   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   * Testing the H5P H5PFileStorage interface implementation.
  19   *
  20   * @package    core_h5p
  21   * @category   test
  22   * @copyright  2019 Victor Deniz <victor@moodle.com>
  23   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  24   */
  25  
  26  namespace core_h5p\local\tests;
  27  
  28  use core_h5p\file_storage;
  29  use core_h5p\local\library\autoloader;
  30  use core_h5p\helper;
  31  use file_archive;
  32  use moodle_exception;
  33  use ReflectionMethod;
  34  use zip_archive;
  35  
  36  defined('MOODLE_INTERNAL') || die();
  37  
  38  /**
  39   * Test class covering the H5PFileStorage interface implementation.
  40   *
  41   * @package    core_h5p
  42   * @copyright  2019 Victor Deniz <victor@moodle.com>
  43   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  44   * @runTestsInSeparateProcesses
  45   */
  46  class h5p_file_storage_testcase extends \advanced_testcase {
  47  
  48      /** @var \core_h5p\file_storage H5P file storage instance */
  49      protected $h5p_file_storage;
  50      /** @var \file_storage Core Moodle file_storage associated to the H5P file_storage */
  51      protected $h5p_fs_fs;
  52      /** @var \context Moodle context of the H5P file_storage */
  53      protected $h5p_fs_context;
  54      /** @var string Path to temp directory */
  55      protected $h5p_tempath;
  56      /** @var \core_h5p_generator  H5P generator instance */
  57      protected $h5p_generator;
  58      /** @var array $files an array used in the cache tests. */
  59      protected $files = ['scripts' => [], 'styles' => []];
  60      /** @var int $libraryid an id for the library. */
  61      protected $libraryid = 1;
  62  
  63      protected function setUp() {
  64          parent::setUp();
  65          $this->resetAfterTest(true);
  66  
  67          autoloader::register();
  68  
  69          // Fetch generator.
  70          $generator = \testing_util::get_data_generator();
  71          $this->h5p_generator = $generator->get_plugin_generator('core_h5p');
  72  
  73          // Create file_storage_instance and create H5P temp directory.
  74          $this->h5p_file_storage = new file_storage();
  75          $this->h5p_tempath = $this->h5p_file_storage->getTmpPath();
  76          check_dir_exists($this->h5p_tempath);
  77  
  78          // Get value of protected properties.
  79          $h5p_fs_rc = new \ReflectionClass(file_storage::class);
  80          $h5p_file_storage_context = $h5p_fs_rc->getProperty('context');
  81          $h5p_file_storage_context->setAccessible(true);
  82          $this->h5p_fs_context = $h5p_file_storage_context->getValue($this->h5p_file_storage);
  83  
  84          $h5p_file_storage_fs = $h5p_fs_rc->getProperty('fs');
  85          $h5p_file_storage_fs->setAccessible(true);
  86          $this->h5p_fs_fs = $h5p_file_storage_fs->getValue($this->h5p_file_storage);
  87      }
  88  
  89      /**
  90       * Test that given the main directory of a library that all files are saved
  91       * into the file system.
  92       */
  93      public function test_saveLibrary(): void {
  94  
  95          $machinename = 'TestLib';
  96          $majorversion = 1;
  97          $minorversion = 0;
  98          [$lib, $files] = $this->h5p_generator->create_library($this->h5p_tempath, $this->libraryid, $machinename, $majorversion,
  99              $minorversion);
 100  
 101          // Now run the API call.
 102          $this->h5p_file_storage->saveLibrary($lib);
 103  
 104          // Check that files are in the Moodle file system.
 105          $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
 106              file_storage::LIBRARY_FILEAREA, '1', "/{$machinename}-{$majorversion}.{$minorversion}/", 'library.json');
 107          $filepath = "/{$machinename}-{$majorversion}.{$minorversion}/";
 108          $this->assertEquals($filepath, $file->get_filepath());
 109  
 110          $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
 111              file_storage::LIBRARY_FILEAREA, '1', "/{$machinename}-{$majorversion}.{$minorversion}/scripts/", 'testlib.min.js');
 112          $jsfilepath = "{$filepath}scripts/";
 113          $this->assertEquals($jsfilepath, $file->get_filepath());
 114  
 115          $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
 116              file_storage::LIBRARY_FILEAREA, '1', "/{$machinename}-{$majorversion}.{$minorversion}/styles/", 'testlib.min.css');
 117          $cssfilepath = "{$filepath}styles/";
 118          $this->assertEquals($cssfilepath, $file->get_filepath());
 119      }
 120  
 121      /**
 122       * Test that a content file can be saved.
 123       */
 124      public function test_saveContent(): void {
 125  
 126          $source = $this->h5p_tempath . '/' . 'content.json';
 127          $this->h5p_generator->create_file($source);
 128  
 129          $this->h5p_file_storage->saveContent($this->h5p_tempath, ['id' => 5]);
 130  
 131          $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
 132              file_storage::CONTENT_FILEAREA, '5', '/', 'content.json');
 133          $this->assertEquals(file_storage::CONTENT_FILEAREA, $file->get_filearea());
 134          $this->assertEquals('content.json', $file->get_filename());
 135          $this->assertEquals(5, $file->get_itemid());
 136      }
 137  
 138      /**
 139       * Test that content files located on the file system can be deleted.
 140       */
 141      public function test_deleteContent(): void {
 142  
 143          $source = $this->h5p_tempath . '/' . 'content.json';
 144          $this->h5p_generator->create_file($source);
 145  
 146          $this->h5p_file_storage->saveContent($this->h5p_tempath, ['id' => 5]);
 147  
 148          $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
 149              file_storage::CONTENT_FILEAREA, '5', '/', 'content.json');
 150          $this->assertEquals('content.json', $file->get_filename());
 151  
 152          // Now to delete the record.
 153          $this->h5p_file_storage->deleteContent(['id' => 5]);
 154          $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
 155              file_storage::CONTENT_FILEAREA, '5', '/', 'content.json');
 156          $this->assertFalse($file);
 157      }
 158  
 159      /**
 160       * Test that returning a temp path returns what is expected by the h5p library.
 161       */
 162      public function test_getTmpPath(): void {
 163  
 164          $temparray = explode('/', $this->h5p_tempath);
 165          $h5pdirectory = array_pop($temparray);
 166          $this->assertTrue(stripos($h5pdirectory, 'h5p-') === 0);
 167      }
 168  
 169      /**
 170       * Test that the content files can be exported to a specified location.
 171       */
 172      public function test_exportContent(): void {
 173  
 174          // Create a file to store.
 175          $source = $this->h5p_tempath . '/' . 'content.json';
 176          $this->h5p_generator->create_file($source);
 177  
 178          $this->h5p_file_storage->saveContent($this->h5p_tempath, ['id' => 5]);
 179  
 180          $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
 181              file_storage::CONTENT_FILEAREA, '5', '/', 'content.json');
 182          $this->assertEquals('content.json', $file->get_filename());
 183  
 184          // Now export it.
 185          $destinationdirectory = $this->h5p_tempath . '/' . 'testdir';
 186          check_dir_exists($destinationdirectory);
 187  
 188          $this->h5p_file_storage->exportContent(5, $destinationdirectory);
 189          // Check that there is a file now in that directory.
 190          $contents = scandir($destinationdirectory);
 191          $value = array_search('content.json', $contents);
 192          $this->assertEquals('content.json', $contents[$value]);
 193      }
 194  
 195      /**
 196       * Test that libraries on the file system can be exported to a specified location.
 197       */
 198      public function test_exportLibrary(): void {
 199  
 200          $machinename = 'TestLib';
 201          $majorversion = 1;
 202          $minorversion = 0;
 203          [$lib, $files] = $this->h5p_generator->create_library($this->h5p_tempath, $this->libraryid, $machinename, $majorversion,
 204          $minorversion);
 205  
 206          // Now run the API call.
 207          $this->h5p_file_storage->saveLibrary($lib);
 208  
 209          $destinationdirectory = $this->h5p_tempath . '/' . 'testdir';
 210          check_dir_exists($destinationdirectory);
 211  
 212          $this->h5p_file_storage->exportLibrary($lib, $destinationdirectory);
 213  
 214          $filepath = "/{$machinename}-{$majorversion}.{$minorversion}/";
 215          // There should be at least three items here (but could be more with . and ..).
 216          $this->assertFileExists($destinationdirectory . $filepath . 'library.json');
 217          $this->assertFileExists($destinationdirectory . $filepath . 'scripts/' . 'testlib.min.js');
 218          $this->assertFileExists($destinationdirectory . $filepath . 'styles/' . 'testlib.min.css');
 219      }
 220  
 221      /**
 222       * Test that an export file can be saved into the file system.
 223       */
 224      public function test_saveExport(): void {
 225  
 226          $filename = 'someexportedfile.h5p';
 227          $source = $this->h5p_tempath . '/' . $filename;
 228          $this->h5p_generator->create_file($source);
 229  
 230          $this->h5p_file_storage->saveExport($source, $filename);
 231  
 232          // Check out if the file is there.
 233          $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
 234              file_storage::EXPORT_FILEAREA, '0', '/', $filename);
 235          $this->assertEquals(file_storage::EXPORT_FILEAREA, $file->get_filearea());
 236      }
 237  
 238      /**
 239       * Test that an exort file can be deleted from the file system.
 240       * @return [type] [description]
 241       */
 242      public function test_deleteExport(): void {
 243  
 244          $filename = 'someexportedfile.h5p';
 245          $source = $this->h5p_tempath . '/' . $filename;
 246          $this->h5p_generator->create_file($source);
 247  
 248          $this->h5p_file_storage->saveExport($source, $filename);
 249  
 250          // Check out if the file is there.
 251          $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
 252              file_storage::EXPORT_FILEAREA, '0', '/', $filename);
 253          $this->assertEquals(file_storage::EXPORT_FILEAREA, $file->get_filearea());
 254  
 255          // Time to delete.
 256          $this->h5p_file_storage->deleteExport($filename);
 257  
 258          // Check out if the file is there.
 259          $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
 260              file_storage::EXPORT_FILEAREA, '0', '/', $filename);
 261          $this->assertFalse($file);
 262      }
 263  
 264      /**
 265       * Test to check if an export file already exists on the file system.
 266       */
 267      public function test_hasExport(): void {
 268  
 269          $filename = 'someexportedfile.h5p';
 270          $source = $this->h5p_tempath . '/' . $filename;
 271          $this->h5p_generator->create_file($source);
 272  
 273          // Check that it doesn't exist in the file system.
 274          $this->assertFalse($this->h5p_file_storage->hasExport($filename));
 275  
 276          $this->h5p_file_storage->saveExport($source, $filename);
 277          // Now it should be present.
 278          $this->assertTrue($this->h5p_file_storage->hasExport($filename));
 279      }
 280  
 281      /**
 282       * Test that all the library files for an H5P activity can be concatenated into "cache" files. One for js and another for css.
 283       */
 284      public function test_cacheAssets(): void {
 285  
 286          $basedirectory = $this->h5p_tempath . '/' . 'test-1.0';
 287  
 288          $machinename = 'TestLib';
 289          $majorversion = 1;
 290          $minorversion = 0;
 291          [$lib, $libfiles] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
 292              $minorversion);
 293          array_push($this->files['scripts'], ...$libfiles['scripts']);
 294          array_push($this->files['styles'], ...$libfiles['styles']);
 295  
 296          // Now run the API call.
 297          $this->h5p_file_storage->saveLibrary($lib);
 298  
 299          // Second library.
 300          $basedirectory = $this->h5p_tempath . '/' . 'supertest-2.4';
 301  
 302          $this->libraryid++;
 303          $machinename = 'SuperTest';
 304          $majorversion = 2;
 305          $minorversion = 4;
 306          [$lib, $libfiles] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
 307              $minorversion);
 308          array_push($this->files['scripts'], ...$libfiles['scripts']);
 309          array_push($this->files['styles'], ...$libfiles['styles']);
 310  
 311          $this->h5p_file_storage->saveLibrary($lib);
 312  
 313          $this->assertCount(2, $this->files['scripts']);
 314          $this->assertCount(2, $this->files['styles']);
 315  
 316          $key = 'testhashkey';
 317  
 318          $this->h5p_file_storage->cacheAssets($this->files, $key);
 319          $this->assertCount(1, $this->files['scripts']);
 320          $this->assertCount(1, $this->files['styles']);
 321  
 322  
 323          $expectedfile = '/' . file_storage::CACHED_ASSETS_FILEAREA . '/' . $key . '.js';
 324          $this->assertEquals($expectedfile, $this->files['scripts'][0]->path);
 325          $expectedfile = '/' . file_storage::CACHED_ASSETS_FILEAREA . '/' . $key . '.css';
 326          $this->assertEquals($expectedfile, $this->files['styles'][0]->path);
 327      }
 328  
 329      /**
 330       * Test that cached files can be retrieved via a key.
 331       */
 332      public function test_getCachedAssets() {
 333  
 334          $basedirectory = $this->h5p_tempath . '/' . 'test-1.0';
 335  
 336          $machinename = 'TestLib';
 337          $majorversion = 1;
 338          $minorversion = 0;
 339          [$lib, $libfiles] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
 340              $minorversion);
 341          array_push($this->files['scripts'], ...$libfiles['scripts']);
 342          array_push($this->files['styles'], ...$libfiles['styles']);
 343  
 344          // Now run the API call.
 345          $this->h5p_file_storage->saveLibrary($lib);
 346  
 347          // Second library.
 348          $basedirectory = $this->h5p_tempath . '/' . 'supertest-2.4';
 349  
 350          $this->libraryid++;
 351          $machinename = 'SuperTest';
 352          $majorversion = 2;
 353          $minorversion = 4;
 354          [$lib, $libfiles] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
 355              $minorversion);
 356          array_push($this->files['scripts'], ...$libfiles['scripts']);
 357          array_push($this->files['styles'], ...$libfiles['styles']);
 358  
 359          $this->h5p_file_storage->saveLibrary($lib);
 360  
 361          $this->assertCount(2, $this->files['scripts']);
 362          $this->assertCount(2, $this->files['styles']);
 363  
 364          $key = 'testhashkey';
 365  
 366          $this->h5p_file_storage->cacheAssets($this->files, $key);
 367  
 368          $testarray = $this->h5p_file_storage->getCachedAssets($key);
 369          $this->assertCount(1, $testarray['scripts']);
 370          $this->assertCount(1, $testarray['styles']);
 371          $expectedfile = '/' . file_storage::CACHED_ASSETS_FILEAREA . '/' . $key . '.js';
 372          $this->assertEquals($expectedfile, $testarray['scripts'][0]->path);
 373          $expectedfile = '/' . file_storage::CACHED_ASSETS_FILEAREA . '/' . $key . '.css';
 374          $this->assertEquals($expectedfile, $testarray['styles'][0]->path);
 375      }
 376  
 377      /**
 378       * Test that cache files in the files system can be removed.
 379       */
 380      public function test_deleteCachedAssets(): void {
 381          $basedirectory = $this->h5p_tempath . '/' . 'test-1.0';
 382  
 383          $machinename = 'TestLib';
 384          $majorversion = 1;
 385          $minorversion = 0;
 386          [$lib, $libfiles] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
 387              $minorversion);
 388          array_push($this->files['scripts'], ...$libfiles['scripts']);
 389          array_push($this->files['styles'], ...$libfiles['styles']);
 390  
 391          // Now run the API call.
 392          $this->h5p_file_storage->saveLibrary($lib);
 393  
 394          // Second library.
 395          $basedirectory = $this->h5p_tempath . '/' . 'supertest-2.4';
 396  
 397          $this->libraryid++;
 398          $machinename = 'SuperTest';
 399          $majorversion = 2;
 400          $minorversion = 4;
 401          [$lib, $libfiles] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
 402              $minorversion);
 403          array_push($this->files['scripts'], ...$libfiles['scripts']);
 404          array_push($this->files['styles'], ...$libfiles['styles']);
 405  
 406          $this->h5p_file_storage->saveLibrary($lib);
 407  
 408          $this->assertCount(2, $this->files['scripts']);
 409          $this->assertCount(2, $this->files['styles']);
 410  
 411          $key = 'testhashkey';
 412  
 413          $this->h5p_file_storage->cacheAssets($this->files, $key);
 414  
 415          $testarray = $this->h5p_file_storage->getCachedAssets($key);
 416          $this->assertCount(1, $testarray['scripts']);
 417          $this->assertCount(1, $testarray['styles']);
 418  
 419          // Time to delete.
 420          $this->h5p_file_storage->deleteCachedAssets([$key]);
 421          $testarray = $this->h5p_file_storage->getCachedAssets($key);
 422          $this->assertNull($testarray);
 423      }
 424  
 425      /**
 426       * Retrieve content from a file given a specific path.
 427       */
 428      public function test_getContent() {
 429          $basedirectory = $this->h5p_tempath . '/' . 'test-1.0';
 430  
 431          $machinename = 'TestLib';
 432          $majorversion = 1;
 433          $minorversion = 0;
 434          [$lib, $libfiles] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
 435              $minorversion);
 436          array_push($this->files['scripts'], ...$libfiles['scripts']);
 437          array_push($this->files['styles'], ...$libfiles['styles']);
 438  
 439          // Now run the API call.
 440          $this->h5p_file_storage->saveLibrary($lib);
 441  
 442          $content = $this->h5p_file_storage->getContent($this->files['scripts'][0]->path);
 443          // The file content is created based on the file system path (\core_h5p_generator::create_file).
 444          $expectedcontent = hash("md5", $basedirectory. '/' . 'scripts' . '/' . 'testlib.min.js');
 445  
 446          $this->assertEquals($expectedcontent, $content);
 447      }
 448  
 449      /**
 450       * Test that an upgrade script can be found on the file system.
 451       */
 452      public function test_getUpgradeScript() {
 453          // Upload an upgrade file.
 454          $machinename = 'TestLib';
 455          $majorversion = 3;
 456          $minorversion = 1;
 457          $filepath = '/' . "{$machinename}-{$majorversion}.{$minorversion}" . '/';
 458          $fs = get_file_storage();
 459          $filerecord = [
 460              'contextid' => \context_system::instance()->id,
 461              'component' => file_storage::COMPONENT,
 462              'filearea' => file_storage::LIBRARY_FILEAREA,
 463              'itemid' => 15,
 464              'filepath' => $filepath,
 465              'filename' => 'upgrade.js'
 466          ];
 467          $filestorage = new file_storage();
 468          $fs->create_file_from_string($filerecord, 'test string info');
 469          $expectedfilepath = '/' . file_storage::LIBRARY_FILEAREA . $filepath . 'upgrade.js';
 470          $this->assertEquals($expectedfilepath, $filestorage->getUpgradeScript($machinename, $majorversion, $minorversion));
 471          $this->assertNull($filestorage->getUpgradeScript($machinename, $majorversion, 7));
 472      }
 473  
 474      /**
 475       * Test that information from a source can be saved to the specified path.
 476       * The zip file has the following contents
 477       * - h5ptest
 478       * |- content
 479       * |     |- content.json
 480       * |- testFont
 481       * |     |- testfont.min.css
 482       * |- testJavaScript
 483       * |     |- testscript.min.js
 484       * |- h5p.json
 485       */
 486      public function test_saveFileFromZip() {
 487  
 488          $ziparchive = new zip_archive();
 489          $path = __DIR__ . '/fixtures/h5ptest.zip';
 490          $result = $ziparchive->open($path, file_archive::OPEN);
 491  
 492          $files = $ziparchive->list_files();
 493          foreach ($files as $file) {
 494              if (!$file->is_directory) {
 495                  $stream = $ziparchive->get_stream($file->index);
 496                  $items = explode('/', $file->pathname);
 497                  array_shift($items);
 498                  $path = implode('/', $items);
 499                  $this->h5p_file_storage->saveFileFromZip($this->h5p_tempath, $path, $stream);
 500                  $filestocheck[] = $path;
 501              }
 502          }
 503          $ziparchive->close();
 504  
 505          foreach ($filestocheck as $filetocheck) {
 506              $pathtocheck = $this->h5p_tempath .'/'. $filetocheck;
 507              $this->assertFileExists($pathtocheck);
 508          }
 509      }
 510  
 511      /**
 512       * Test that a library is fully deleted from the file system
 513       */
 514      public function test_delete_library() {
 515  
 516          $basedirectory = $this->h5p_tempath . '/' . 'test-1.0';
 517  
 518          $machinename = 'TestLib';
 519          $majorversion = 1;
 520          $minorversion = 0;
 521          [$lib, $files] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
 522              $minorversion);
 523  
 524          // Now run the API call.
 525          $this->h5p_file_storage->saveLibrary($lib);
 526  
 527          // Save a second library to ensure we aren't deleting all libraries, but just the one specified.
 528          $basedirectory = $this->h5p_tempath . '/' . 'awesomelib-2.1';
 529  
 530          $this->libraryid++;
 531          $machinename = 'AwesomeLib';
 532          $majorversion = 2;
 533          $minorversion = 1;
 534          [$lib2, $files2] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
 535              $minorversion);
 536  
 537          // Now run the API call.
 538          $this->h5p_file_storage->saveLibrary($lib2);
 539  
 540          $files =  $this->h5p_fs_fs->get_area_files($this->h5p_fs_context->id, file_storage::COMPONENT,
 541                  file_storage::LIBRARY_FILEAREA);
 542          $this->assertCount(14, $files);
 543  
 544          $this->h5p_file_storage->delete_library($lib);
 545  
 546          // Let's look at the records.
 547          $files =  $this->h5p_fs_fs->get_area_files($this->h5p_fs_context->id, file_storage::COMPONENT,
 548                  file_storage::LIBRARY_FILEAREA);
 549          $this->assertCount(7, $files);
 550  
 551          // Check that the db count is still the same after setting the libraryId to false.
 552          $lib['libraryId'] = false;
 553          $this->h5p_file_storage->delete_library($lib);
 554  
 555          $files =  $this->h5p_fs_fs->get_area_files($this->h5p_fs_context->id, file_storage::COMPONENT,
 556                  file_storage::LIBRARY_FILEAREA);
 557          $this->assertCount(7, $files);
 558      }
 559  
 560      /**
 561       * Test get_icon_url() function behaviour.
 562       *
 563       * @dataProvider get_icon_url_provider
 564       * @param  string  $filename  The name of the H5P file to load.
 565       * @param  bool    $expected  Whether the icon should exist or not.
 566       */
 567      public function test_get_icon_url(string $filename, bool $expected): void {
 568          global $DB;
 569  
 570          $this->resetAfterTest();
 571          $factory = new \core_h5p\factory();
 572  
 573          $admin = get_admin();
 574  
 575          // Prepare a valid .H5P file.
 576          $path = __DIR__ . '/fixtures/'.$filename;
 577  
 578          // Libraries can be updated when the file has been created by admin, even when the current user is not the admin.
 579          $this->setUser($admin);
 580          $file = helper::create_fake_stored_file_from_path($path, (int)$admin->id);
 581          $factory->get_framework()->set_file($file);
 582          $config = (object)[
 583              'frame' => 1,
 584              'export' => 1,
 585              'embed' => 0,
 586              'copyright' => 0,
 587          ];
 588  
 589          $h5pid = helper::save_h5p($factory, $file, $config);
 590          $h5p = $DB->get_record('h5p', ['id' => $h5pid]);
 591          $h5plib = $DB->get_record('h5p_libraries', ['id' => $h5p->mainlibraryid]);
 592          $iconurl = $this->h5p_file_storage->get_icon_url(
 593              $h5plib->id,
 594              $h5plib->machinename,
 595              $h5plib->majorversion,
 596              $h5plib->minorversion
 597          );
 598          if ($expected) {
 599              $this->assertContains(file_storage::ICON_FILENAME, $iconurl);
 600          } else {
 601              $this->assertFalse($iconurl);
 602          }
 603      }
 604  
 605      /**
 606       * Data provider for test_get_icon_url().
 607       *
 608       * @return array
 609       */
 610      public function get_icon_url_provider(): array {
 611          return [
 612              'Icon included' => [
 613                  'filltheblanks.h5p',
 614                  true,
 615              ],
 616              'Icon not included' => [
 617                  'greeting-card-887.h5p',
 618                  false,
 619              ],
 620          ];
 621      }
 622  
 623      /**
 624       * Test the private method get_file, a wrapper for getting an H5P content file.
 625       */
 626      public function test_get_file(): void {
 627  
 628          $this->setAdminUser();
 629          $file = 'img/fake.png';
 630          $h5pcontentid = 3;
 631  
 632          // Add a file to a H5P content.
 633          $this->h5p_generator->create_content_file($file, file_storage::CONTENT_FILEAREA, $h5pcontentid);
 634  
 635          // Set get_file method accessibility.
 636          $method = new ReflectionMethod(file_storage::class, 'get_file');
 637          $method->setAccessible(true);
 638  
 639          $contentfile = $method->invoke(new file_storage(), file_storage::CONTENT_FILEAREA, $h5pcontentid, $file);
 640  
 641          // Check that it returns an instance of store_file.
 642          $this->assertInstanceOf('stored_file', $contentfile);
 643  
 644          // Add a file to editor.
 645          $this->h5p_generator->create_content_file($file, 'draft', $h5pcontentid);
 646  
 647          $editorfile = $method->invoke(new file_storage(), 'draft', $h5pcontentid, $file);
 648  
 649          // Check that it returns an instance of store_file.
 650          $this->assertInstanceOf('stored_file', $editorfile);
 651      }
 652  
 653      /**
 654       * Test that a single file is added to Moodle files.
 655       */
 656      public function test_move_file(): void {
 657  
 658          // Create temp folder.
 659          $tempfolder = make_request_directory(false);
 660  
 661          // Create H5P content folder.
 662          $filepath = '/img/';
 663          $filename = 'fake.png';
 664          $h5pcontentfolder = $tempfolder . '/fakeH5Pcontent/content' . $filepath;
 665          if (!check_dir_exists($h5pcontentfolder, true, true)) {
 666              throw new moodle_exception('error_creating_temp_dir', 'error', $h5pcontentfolder);
 667          }
 668  
 669          $file = $h5pcontentfolder . $filename;
 670          touch($file);
 671  
 672          $h5pcontentid = 3;
 673  
 674          // Check the file doesn't exist in Moodle files.
 675          $this->assertFalse($this->h5p_fs_fs->file_exists($this->h5p_fs_context->id, file_storage::COMPONENT,
 676              file_storage::CONTENT_FILEAREA, $h5pcontentid, $filepath, $filename));
 677  
 678          // Set get_file method accessibility.
 679          $method = new ReflectionMethod(file_storage::class, 'move_file');
 680          $method->setAccessible(true);
 681  
 682          $method->invoke(new file_storage(), $file, $h5pcontentid);
 683  
 684          // Check the file exist in Moodle files.
 685          $this->assertTrue($this->h5p_fs_fs->file_exists($this->h5p_fs_context->id, file_storage::COMPONENT,
 686              file_storage::CONTENT_FILEAREA, $h5pcontentid, $filepath, $filename));
 687      }
 688  
 689      /**
 690       * Test that a file is copied from another H5P content or the H5P editor.
 691       *
 692       * @return void
 693       */
 694      public function test_cloneContentFile(): void {
 695  
 696          $admin = get_admin();
 697          $usercontext = \context_user::instance($admin->id);
 698          $this->setUser($admin);
 699          // Upload a file to the editor.
 700          $file = 'images/fake.jpg';
 701          $filepath = '/'.dirname($file).'/';
 702          $filename = basename($file);
 703  
 704          $content = 'abcd';
 705  
 706          $filerecord = array(
 707              'contextid' => $usercontext->id,
 708              'component' => 'user',
 709              'filearea'  => 'draft',
 710              'itemid'    => 0,
 711              'filepath'  => $filepath,
 712              'filename'  => $filename,
 713          );
 714  
 715          $this->h5p_fs_fs->create_file_from_string($filerecord, $content);
 716  
 717          // Target H5P content, where the file will be cloned.
 718          $targetcontent = new \stdClass();
 719          $targetcontent->id = 999;
 720  
 721          // Check the file doesn't exists before cloning.
 722          $this->assertFalse($this->h5p_fs_fs->get_file($this->h5p_fs_context->id, file_storage::COMPONENT,
 723              file_storage::CONTENT_FILEAREA, $targetcontent->id, $filepath, $filename));
 724  
 725          // Copy file from the editor.
 726          $this->h5p_file_storage->cloneContentFile($file, 'editor', $targetcontent);
 727  
 728          // Check the file exists after cloning.
 729          $this->assertInstanceOf(\stored_file::class, $this->h5p_fs_fs->get_file($this->h5p_fs_context->id, file_storage::COMPONENT,
 730              file_storage::CONTENT_FILEAREA, $targetcontent->id, $filepath, $filename));
 731  
 732          // Simulate that an H5P content, with id $sourcecontentid, has a file.
 733          $file = 'images/fake2.jpg';
 734          $filepath = '/'.dirname($file).'/';
 735          $filename = basename($file);
 736  
 737          $sourcecontentid = 111;
 738          $filerecord['contextid'] = $this->h5p_fs_context->id;
 739          $filerecord['component'] = file_storage::COMPONENT;
 740          $filerecord['filearea'] = file_storage::CONTENT_FILEAREA;
 741          $filerecord['itemid'] = $sourcecontentid;
 742          $filerecord['filepath'] = $filepath;
 743          $filerecord['filename'] = $filename;
 744  
 745          $this->h5p_fs_fs->create_file_from_string($filerecord, $content);
 746  
 747          // Check the file doesn't exists before cloning.
 748          $this->assertFalse($this->h5p_fs_fs->get_file($this->h5p_fs_context->id, file_storage::COMPONENT,
 749              file_storage::CONTENT_FILEAREA, $targetcontent->id, $filepath, $filename));
 750  
 751          // Copy file from another H5P content.
 752          $this->h5p_file_storage->cloneContentFile($file, $sourcecontentid, $targetcontent);
 753  
 754          // Check the file exists after cloning.
 755          $this->assertInstanceOf(\stored_file::class, $this->h5p_fs_fs->get_file($this->h5p_fs_context->id, file_storage::COMPONENT,
 756              file_storage::CONTENT_FILEAREA, $targetcontent->id, $filepath, $filename));
 757      }
 758  
 759      /**
 760       * Test that a given file exists in an H5P content.
 761       *
 762       * @return void
 763       */
 764      public function test_getContentFile(): void {
 765  
 766          $file = 'img/fake.png';
 767          $contentid = 3;
 768  
 769          // Add a file to a H5P content.
 770          $this->h5p_generator->create_content_file($file, file_storage::CONTENT_FILEAREA, $contentid);
 771  
 772          // Get an existing file id.
 773          $fileid = $this->h5p_file_storage->getContentFile($file, $contentid);
 774          $this->assertNotNull($fileid);
 775  
 776          // Try to get a nonexistent file.
 777          $fileid = $this->h5p_file_storage->getContentFile($file, 5);
 778          $this->assertNull($fileid);
 779      }
 780  
 781      /**
 782       * Tests that the content folder of an H5P content is imported in the Moodle filesystem.
 783       */
 784      public function test_moveContentDiretory(): void {
 785          global $DB;
 786  
 787          // Create temp folder.
 788          $tempfolder = make_request_directory(false);
 789  
 790          // Create H5P content folder.
 791          $h5pcontentfolder = $tempfolder . '/fakeH5Pcontent';
 792          $contentfolder = $h5pcontentfolder . '/content';
 793          if (!check_dir_exists($contentfolder, true, true)) {
 794              throw new moodle_exception('error_creating_temp_dir', 'error', $contentfolder);
 795          }
 796  
 797          // Add content.json file.
 798          touch($contentfolder . 'content.json');
 799  
 800          // Create several folders and files inside content folder.
 801          $filesexpected = array();
 802          $numfolders = random_int(2, 5);
 803          for ($numfolder = 1; $numfolder < $numfolders; $numfolder++) {
 804              $foldername = '/folder' . $numfolder;
 805              $newfolder = $contentfolder . $foldername;
 806              if (!check_dir_exists($newfolder, true, true)) {
 807                  throw new moodle_exception('error_creating_temp_dir', 'error', $newfolder);
 808              }
 809              $numfiles = random_int(2, 5);
 810              for ($numfile = 1; $numfile < $numfiles; $numfile++) {
 811                  $filename = '/file' . $numfile . '.ext';
 812                  touch($newfolder . $filename);
 813                  $filesexpected[] = $foldername . $filename;
 814              }
 815          }
 816  
 817          $targeth5pcontentid = 111;
 818          $this->h5p_file_storage->moveContentDirectory($h5pcontentfolder, $targeth5pcontentid);
 819  
 820          // Get database records.
 821          $sql = "SELECT concat(filepath, filename)
 822                    FROM {files}
 823                   WHERE filearea = :filearea AND itemid = :itemid AND component = :component AND filename != '.'";
 824          $params = [
 825              'component' => file_storage::COMPONENT,
 826              'filearea' => file_storage::CONTENT_FILEAREA,
 827              'itemid' => $targeth5pcontentid
 828          ];
 829          $filesdb = $DB->get_fieldset_sql($sql, $params);
 830          sort($filesdb);
 831  
 832          // Check that created files match with database records.
 833          $this->assertEquals($filesexpected, $filesdb);
 834      }
 835  
 836      /**
 837       * Test that an H5P content file is removed.
 838       */
 839      public function test_removeContentFile(): void {
 840  
 841          $file = 'img/fake.png';
 842          $filepath = '/' . dirname($file) . '/';
 843          $filename = basename($file);
 844          $h5pcontentid = 3;
 845  
 846          // Add a file to a H5P content.
 847          $this->h5p_generator->create_content_file($file, file_storage::CONTENT_FILEAREA, $h5pcontentid);
 848  
 849          // Check the file exists.
 850          $this->assertTrue($this->h5p_fs_fs->file_exists($this->h5p_fs_context->id, file_storage::COMPONENT,
 851              file_storage::CONTENT_FILEAREA, $h5pcontentid, $filepath, $filename));
 852  
 853          $this->h5p_file_storage->removeContentFile($file, $h5pcontentid);
 854  
 855          // Check the file doesn't exists.
 856          $this->assertFalse($this->h5p_fs_fs->file_exists($this->h5p_fs_context->id, file_storage::COMPONENT,
 857              file_storage::CONTENT_FILEAREA, $h5pcontentid, $filepath, $filename));
 858      }
 859  }