SWAMPy

✎ CARVE FLESH

EDITING: file_storage_test.php

<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

namespace core_h5p;

use core_h5p\file_storage;
use core_h5p\local\library\autoloader;
use core_h5p\helper;
use file_archive;
use moodle_exception;
use ReflectionMethod;
use stored_file;
use zip_archive;

/**
 * Test class covering the H5PFileStorage interface implementation.
 *
 * @package    core_h5p
 * @category   test
 * @copyright  2019 Victor Deniz <victor@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 * @runTestsInSeparateProcesses
 * @covers \core_h5p\file_storage
 */
final class file_storage_test extends \advanced_testcase {

/** @var \core_h5p\file_storage H5P file storage instance */
    protected $h5p_file_storage;
    /** @var \file_storage Core Moodle file_storage associated to the H5P file_storage */
    protected $h5p_fs_fs;
    /** @var \context Moodle context of the H5P file_storage */
    protected $h5p_fs_context;
    /** @var string Path to temp directory */
    protected $h5p_tempath;
    /** @var \core_h5p_generator  H5P generator instance */
    protected $h5p_generator;
    /** @var array $files an array used in the cache tests. */
    protected $files = ['scripts' => [], 'styles' => []];
    /** @var int $libraryid an id for the library. */
    protected $libraryid = 1;

protected function setUp(): void {
        parent::setUp();
        $this->resetAfterTest(true);

autoloader::register();

// Fetch generator.
        $generator = \testing_util::get_data_generator();
        $this->h5p_generator = $generator->get_plugin_generator('core_h5p');

// Create file_storage_instance and create H5P temp directory.
        $this->h5p_file_storage = new file_storage();
        $this->h5p_tempath = $this->h5p_file_storage->getTmpPath();
        check_dir_exists($this->h5p_tempath);

// Get value of protected properties.
        $h5p_fs_rc = new \ReflectionClass(file_storage::class);
        $h5p_file_storage_context = $h5p_fs_rc->getProperty('context');
        $this->h5p_fs_context = $h5p_file_storage_context->getValue($this->h5p_file_storage);

$h5p_file_storage_fs = $h5p_fs_rc->getProperty('fs');
        $this->h5p_fs_fs = $h5p_file_storage_fs->getValue($this->h5p_file_storage);
    }

/**
     * Test that given the main directory of a library that all files are saved
     * into the file system.
     */
    public function test_saveLibrary(): void {

$machinename = 'TestLib';
        $majorversion = 1;
        $minorversion = 0;
        [$lib, $files] = $this->h5p_generator->create_library($this->h5p_tempath, $this->libraryid, $machinename, $majorversion,
            $minorversion);

// Now run the API call.
        $this->h5p_file_storage->saveLibrary($lib);

// Check that files are in the Moodle file system.
        $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::LIBRARY_FILEAREA, '1', "/{$machinename}-{$majorversion}.{$minorversion}/", 'library.json');
        $filepath = "/{$machinename}-{$majorversion}.{$minorversion}/";
        $this->assertEquals($filepath, $file->get_filepath());

$file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::LIBRARY_FILEAREA, '1', "/{$machinename}-{$majorversion}.{$minorversion}/scripts/", 'testlib.min.js');
        $jsfilepath = "{$filepath}scripts/";
        $this->assertEquals($jsfilepath, $file->get_filepath());

$file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::LIBRARY_FILEAREA, '1', "/{$machinename}-{$majorversion}.{$minorversion}/styles/", 'testlib.min.css');
        $cssfilepath = "{$filepath}styles/";
        $this->assertEquals($cssfilepath, $file->get_filepath());
    }

/**
     * Test that a content file can be saved.
     */
    public function test_saveContent(): void {

$source = $this->h5p_tempath . '/' . 'content.json';
        $this->h5p_generator->create_file($source);

$this->h5p_file_storage->saveContent($this->h5p_tempath, ['id' => 5]);

$file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::CONTENT_FILEAREA, '5', '/', 'content.json');
        $this->assertEquals(file_storage::CONTENT_FILEAREA, $file->get_filearea());
        $this->assertEquals('content.json', $file->get_filename());
        $this->assertEquals(5, $file->get_itemid());
    }

/**
     * Test that content files located on the file system can be deleted.
     */
    public function test_deleteContent(): void {

$source = $this->h5p_tempath . '/' . 'content.json';
        $this->h5p_generator->create_file($source);

$this->h5p_file_storage->saveContent($this->h5p_tempath, ['id' => 5]);

// Now to delete the record.
        $this->h5p_file_storage->deleteContent(['id' => 5]);
        $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::CONTENT_FILEAREA, '5', '/', 'content.json');
        $this->assertFalse($file);
    }

/**
     * Test that returning a temp path returns what is expected by the h5p library.
     */
    public function test_getTmpPath(): void {

$temparray = explode('/', $this->h5p_tempath);
        $h5pdirectory = array_pop($temparray);
        $this->assertTrue(stripos($h5pdirectory, 'h5p-') === 0);
    }

/**
     * Test that the content files can be exported to a specified location.
     */
    public function test_exportContent(): void {

// Create a file to store.
        $source = $this->h5p_tempath . '/' . 'content.json';
        $this->h5p_generator->create_file($source);

$this->h5p_file_storage->saveContent($this->h5p_tempath, ['id' => 5]);

// Now export it.
        $destinationdirectory = $this->h5p_tempath . '/' . 'testdir';
        check_dir_exists($destinationdirectory);

$this->h5p_file_storage->exportContent(5, $destinationdirectory);
        // Check that there is a file now in that directory.
        $contents = scandir($destinationdirectory);
        $value = array_search('content.json', $contents);
        $this->assertEquals('content.json', $contents[$value]);
    }

/**
     * Test that libraries on the file system can be exported to a specified location.
     */
    public function test_exportLibrary(): void {

// Now run the API call.
        $this->h5p_file_storage->saveLibrary($lib);

$destinationdirectory = $this->h5p_tempath . '/' . 'testdir';
        check_dir_exists($destinationdirectory);

$this->h5p_file_storage->exportLibrary($lib, $destinationdirectory);

$filepath = "/{$machinename}-{$majorversion}.{$minorversion}/";
        // There should be at least three items here (but could be more with . and ..).
        $this->assertFileExists($destinationdirectory . $filepath . 'library.json');
        $this->assertFileExists($destinationdirectory . $filepath . 'scripts/' . 'testlib.min.js');
        $this->assertFileExists($destinationdirectory . $filepath . 'styles/' . 'testlib.min.css');
    }

/**
     * Test that an export file can be saved into the file system.
     */
    public function test_saveExport(): void {

$filename = 'someexportedfile.h5p';
        $source = $this->h5p_tempath . '/' . $filename;
        $this->h5p_generator->create_file($source);

$this->h5p_file_storage->saveExport($source, $filename);

// Check out if the file is there.
        $file =  $this->h5p_fs_fs->get_file ($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::EXPORT_FILEAREA, '0', '/', $filename);
        $this->assertEquals(file_storage::EXPORT_FILEAREA, $file->get_filearea());
    }

/**
     * Test that an exort file can be deleted from the file system.
     * @return [type] [description]
     */
    public function test_deleteExport(): void {

$filename = 'someexportedfile.h5p';
        $source = $this->h5p_tempath . '/' . $filename;
        $this->h5p_generator->create_file($source);

$this->h5p_file_storage->saveExport($source, $filename);

// Time to delete.
        $this->h5p_file_storage->deleteExport($filename);

/**
     * Test to check if an export file already exists on the file system.
     */
    public function test_hasExport(): void {

$filename = 'someexportedfile.h5p';
        $source = $this->h5p_tempath . '/' . $filename;
        $this->h5p_generator->create_file($source);

// Check that it doesn't exist in the file system.
        $this->assertFalse($this->h5p_file_storage->hasExport($filename));

$this->h5p_file_storage->saveExport($source, $filename);
        // Now it should be present.
        $this->assertTrue($this->h5p_file_storage->hasExport($filename));
    }

/**
     * Test that all the library files for an H5P activity can be concatenated into "cache" files. One for js and another for css.
     */
    public function test_cacheAssets(): void {

$basedirectory = $this->h5p_tempath . '/' . 'test-1.0';

$machinename = 'TestLib';
        $majorversion = 1;
        $minorversion = 0;
        [$lib, $libfiles] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
            $minorversion);
        array_push($this->files['scripts'], ...$libfiles['scripts']);
        array_push($this->files['styles'], ...$libfiles['styles']);

// Now run the API call.
        $this->h5p_file_storage->saveLibrary($lib);

// Second library.
        $basedirectory = $this->h5p_tempath . '/' . 'supertest-2.4';

$this->libraryid++;
        $machinename = 'SuperTest';
        $majorversion = 2;
        $minorversion = 4;
        [$lib, $libfiles] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
            $minorversion);
        array_push($this->files['scripts'], ...$libfiles['scripts']);
        array_push($this->files['styles'], ...$libfiles['styles']);

$this->h5p_file_storage->saveLibrary($lib);

$this->assertCount(2, $this->files['scripts']);
        $this->assertCount(2, $this->files['styles']);

$key = 'testhashkey';

$this->h5p_file_storage->cacheAssets($this->files, $key);
        $this->assertCount(1, $this->files['scripts']);
        $this->assertCount(1, $this->files['styles']);

$expectedfile = '/' . file_storage::CACHED_ASSETS_FILEAREA . '/' . $key . '.js';
        $this->assertEquals($expectedfile, $this->files['scripts'][0]->path);
        $expectedfile = '/' . file_storage::CACHED_ASSETS_FILEAREA . '/' . $key . '.css';
        $this->assertEquals($expectedfile, $this->files['styles'][0]->path);
    }

/**
     * Test that cached files can be retrieved via a key.
     */
    public function test_getCachedAssets(): void {

$basedirectory = $this->h5p_tempath . '/' . 'test-1.0';

// Now run the API call.
        $this->h5p_file_storage->saveLibrary($lib);

// Second library.
        $basedirectory = $this->h5p_tempath . '/' . 'supertest-2.4';

$this->h5p_file_storage->saveLibrary($lib);

$this->assertCount(2, $this->files['scripts']);
        $this->assertCount(2, $this->files['styles']);

$key = 'testhashkey';

$this->h5p_file_storage->cacheAssets($this->files, $key);

$testarray = $this->h5p_file_storage->getCachedAssets($key);
        $this->assertCount(1, $testarray['scripts']);
        $this->assertCount(1, $testarray['styles']);
        $expectedfile = '/' . file_storage::CACHED_ASSETS_FILEAREA . '/' . $key . '.js';
        $this->assertEquals($expectedfile, $testarray['scripts'][0]->path);
        $expectedfile = '/' . file_storage::CACHED_ASSETS_FILEAREA . '/' . $key . '.css';
        $this->assertEquals($expectedfile, $testarray['styles'][0]->path);
    }

/**
     * Test that cache files in the files system can be removed.
     */
    public function test_deleteCachedAssets(): void {
        $basedirectory = $this->h5p_tempath . '/' . 'test-1.0';

// Now run the API call.
        $this->h5p_file_storage->saveLibrary($lib);

// Second library.
        $basedirectory = $this->h5p_tempath . '/' . 'supertest-2.4';

$this->h5p_file_storage->saveLibrary($lib);

$this->assertCount(2, $this->files['scripts']);
        $this->assertCount(2, $this->files['styles']);

$key = 'testhashkey';

$this->h5p_file_storage->cacheAssets($this->files, $key);

$testarray = $this->h5p_file_storage->getCachedAssets($key);
        $this->assertCount(1, $testarray['scripts']);
        $this->assertCount(1, $testarray['styles']);

// Time to delete.
        $this->h5p_file_storage->deleteCachedAssets([$key]);
        $testarray = $this->h5p_file_storage->getCachedAssets($key);
        $this->assertNull($testarray);
    }

/**
     * Retrieve content from a file given a specific path.
     */
    public function test_getContent(): void {
        $basedirectory = $this->h5p_tempath . '/' . 'test-1.0';

// Now run the API call.
        $this->h5p_file_storage->saveLibrary($lib);

$content = $this->h5p_file_storage->getContent($this->files['scripts'][0]->path);
        // The file content is created based on the file system path (\core_h5p_generator::create_file).
        $expectedcontent = hash("md5", $basedirectory. '/' . 'scripts' . '/' . 'testlib.min.js');

$this->assertEquals($expectedcontent, $content);
    }

/**
     * Test that an upgrade script can be found on the file system.
     */
    public function test_getUpgradeScript(): void {
        // Upload an upgrade file.
        $machinename = 'TestLib';
        $majorversion = 3;
        $minorversion = 1;
        $filepath = '/' . "{$machinename}-{$majorversion}.{$minorversion}" . '/';
        $fs = get_file_storage();
        $filerecord = [
            'contextid' => \context_system::instance()->id,
            'component' => file_storage::COMPONENT,
            'filearea' => file_storage::LIBRARY_FILEAREA,
            'itemid' => 15,
            'filepath' => $filepath,
            'filename' => 'upgrade.js'
        ];
        $filestorage = new file_storage();
        $fs->create_file_from_string($filerecord, 'test string info');
        $expectedfilepath = '/' . file_storage::LIBRARY_FILEAREA . $filepath . 'upgrade.js';
        $this->assertEquals($expectedfilepath, $filestorage->getUpgradeScript($machinename, $majorversion, $minorversion));
        $this->assertNull($filestorage->getUpgradeScript($machinename, $majorversion, 7));
    }

/**
     * Test that information from a source can be saved to the specified path.
     * The zip file has the following contents
     * - h5ptest
     * |- content
     * |     |- content.json
     * |- testFont
     * |     |- testfont.min.css
     * |- testJavaScript
     * |     |- testscript.min.js
     * |- h5p.json
     */
    public function test_saveFileFromZip(): void {

$ziparchive = new zip_archive();
        $path = self::get_fixture_path(__NAMESPACE__, 'h5ptest.zip');
        $result = $ziparchive->open($path, file_archive::OPEN);

$files = $ziparchive->list_files();
        foreach ($files as $file) {
            if (!$file->is_directory) {
                $stream = $ziparchive->get_stream($file->index);
                $items = explode('/', $file->pathname);
                array_shift($items);
                $path = implode('/', $items);
                $this->h5p_file_storage->saveFileFromZip($this->h5p_tempath, $path, $stream);
                $filestocheck[] = $path;
            }
        }
        $ziparchive->close();

foreach ($filestocheck as $filetocheck) {
            $pathtocheck = $this->h5p_tempath .'/'. $filetocheck;
            $this->assertFileExists($pathtocheck);
        }
    }

/**
     * Test that a library is fully deleted from the file system
     */
    public function test_delete_library(): void {

$basedirectory = $this->h5p_tempath . '/' . 'test-1.0';

$machinename = 'TestLib';
        $majorversion = 1;
        $minorversion = 0;
        [$lib, $files] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
            $minorversion);

// Now run the API call.
        $this->h5p_file_storage->saveLibrary($lib);

// Save a second library to ensure we aren't deleting all libraries, but just the one specified.
        $basedirectory = $this->h5p_tempath . '/' . 'awesomelib-2.1';

$this->libraryid++;
        $machinename = 'AwesomeLib';
        $majorversion = 2;
        $minorversion = 1;
        [$lib2, $files2] = $this->h5p_generator->create_library($basedirectory, $this->libraryid, $machinename, $majorversion,
            $minorversion);

// Now run the API call.
        $this->h5p_file_storage->saveLibrary($lib2);

$files =  $this->h5p_fs_fs->get_area_files($this->h5p_fs_context->id, file_storage::COMPONENT,
                file_storage::LIBRARY_FILEAREA);
        $this->assertCount(14, $files);

$this->h5p_file_storage->delete_library($lib);

// Let's look at the records.
        $files =  $this->h5p_fs_fs->get_area_files($this->h5p_fs_context->id, file_storage::COMPONENT,
                file_storage::LIBRARY_FILEAREA);
        $this->assertCount(7, $files);

// Check that the db count is still the same after setting the libraryId to false.
        $lib['libraryId'] = false;
        $this->h5p_file_storage->delete_library($lib);

$files =  $this->h5p_fs_fs->get_area_files($this->h5p_fs_context->id, file_storage::COMPONENT,
                file_storage::LIBRARY_FILEAREA);
        $this->assertCount(7, $files);
    }

/**
     * Test get_icon_url() function behaviour.
     *
     * @dataProvider get_icon_url_provider
     * @param  string  $filename  The name of the H5P file to load.
     * @param  bool    $expected  Whether the icon should exist or not.
     */
    public function test_get_icon_url(string $filename, bool $expected): void {
        global $DB;

$this->resetAfterTest();
        $factory = new \core_h5p\factory();

$admin = get_admin();

// Prepare a valid .H5P file.
        $path = self::get_fixture_path(__NAMESPACE__, $filename);

// Libraries can be updated when the file has been created by admin, even when the current user is not the admin.
        $this->setUser($admin);
        $file = helper::create_fake_stored_file_from_path($path, (int)$admin->id);
        $factory->get_framework()->set_file($file);
        $config = (object)[
            'frame' => 1,
            'export' => 1,
            'embed' => 0,
            'copyright' => 0,
        ];

$h5pid = helper::save_h5p($factory, $file, $config);
        $h5p = $DB->get_record('h5p', ['id' => $h5pid]);
        $h5plib = $DB->get_record('h5p_libraries', ['id' => $h5p->mainlibraryid]);
        $iconurl = $this->h5p_file_storage->get_icon_url(
            $h5plib->id,
            $h5plib->machinename,
            $h5plib->majorversion,
            $h5plib->minorversion
        );
        if ($expected) {
            $this->assertStringContainsString(file_storage::ICON_FILENAME, $iconurl);
        } else {
            $this->assertFalse($iconurl);
        }
    }

/**
     * Data provider for test_get_icon_url().
     *
     * @return array
     */
    public static function get_icon_url_provider(): array {
        return [
            'Icon included' => [
                'filltheblanks.h5p',
                true,
            ],
            'Icon not included' => [
                'greeting-card.h5p',
                false,
            ],
        ];
    }

/**
     * Test the private method get_file, a wrapper for getting an H5P content file.
     */
    public function test_get_file(): void {

$this->setAdminUser();
        $file = 'img/fake.png';
        $h5pcontentid = 3;

// Add a file to a H5P content.
        $this->h5p_generator->create_content_file($file, file_storage::CONTENT_FILEAREA, $h5pcontentid);

// Set get_file method accessibility.
        $method = new ReflectionMethod(file_storage::class, 'get_file');

$contentfile = $method->invoke(new file_storage(), file_storage::CONTENT_FILEAREA, $h5pcontentid, $file);

// Check that it returns an instance of store_file.
        $this->assertInstanceOf('stored_file', $contentfile);

// Add a file to editor.
        $this->h5p_generator->create_content_file($file, 'draft', $h5pcontentid);

$editorfile = $method->invoke(new file_storage(), 'draft', $h5pcontentid, $file);

// Check that it returns an instance of store_file.
        $this->assertInstanceOf('stored_file', $editorfile);
    }

/**
     * Test that a single file is added to Moodle files.
     */
    public function test_move_file(): void {

// Create temp folder.
        $tempfolder = make_request_directory(false);

// Create H5P content folder.
        $filepath = '/img/';
        $filename = 'fake.png';
        $h5pcontentfolder = $tempfolder . '/fakeH5Pcontent/content' . $filepath;
        if (!check_dir_exists($h5pcontentfolder, true, true)) {
            throw new moodle_exception('error_creating_temp_dir', 'error', $h5pcontentfolder);
        }

$file = $h5pcontentfolder . $filename;
        touch($file);

$h5pcontentid = 3;

// Check the file doesn't exist in Moodle files.
        $this->assertFalse($this->h5p_fs_fs->file_exists($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::CONTENT_FILEAREA, $h5pcontentid, $filepath, $filename));

// Set get_file method accessibility.
        $method = new ReflectionMethod(file_storage::class, 'move_file');

$method->invoke(new file_storage(), $file, $h5pcontentid);

// Check the file exist in Moodle files.
        $this->assertTrue($this->h5p_fs_fs->file_exists($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::CONTENT_FILEAREA, $h5pcontentid, $filepath, $filename));
    }

/**
     * Test that a file is copied from another H5P content or the H5P editor.
     *
     * @return void
     */
    public function test_cloneContentFile(): void {

$admin = get_admin();
        $usercontext = \context_user::instance($admin->id);
        $this->setUser($admin);
        // Upload a file to the editor.
        $file = 'images/fake.jpg';
        $filepath = '/'.dirname($file).'/';
        $filename = basename($file);

$content = 'abcd';

$filerecord = array(
            'contextid' => $usercontext->id,
            'component' => 'user',
            'filearea'  => 'draft',
            'itemid'    => 0,
            'filepath'  => $filepath,
            'filename'  => $filename,
        );

$this->h5p_fs_fs->create_file_from_string($filerecord, $content);

// Target H5P content, where the file will be cloned.
        $targetcontent = new \stdClass();
        $targetcontent->id = 999;

// Check the file doesn't exists before cloning.
        $this->assertFalse($this->h5p_fs_fs->get_file($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::CONTENT_FILEAREA, $targetcontent->id, $filepath, $filename));

// Copy file from the editor.
        $this->h5p_file_storage->cloneContentFile($file, 'editor', $targetcontent);

// Check the file exists after cloning.
        $this->assertInstanceOf(\stored_file::class, $this->h5p_fs_fs->get_file($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::CONTENT_FILEAREA, $targetcontent->id, $filepath, $filename));

// Simulate that an H5P content, with id $sourcecontentid, has a file.
        $file = 'images/fake2.jpg';
        $filepath = '/'.dirname($file).'/';
        $filename = basename($file);

$sourcecontentid = 111;
        $filerecord['contextid'] = $this->h5p_fs_context->id;
        $filerecord['component'] = file_storage::COMPONENT;
        $filerecord['filearea'] = file_storage::CONTENT_FILEAREA;
        $filerecord['itemid'] = $sourcecontentid;
        $filerecord['filepath'] = $filepath;
        $filerecord['filename'] = $filename;

$this->h5p_fs_fs->create_file_from_string($filerecord, $content);

// Copy file from another H5P content.
        $this->h5p_file_storage->cloneContentFile($file, $sourcecontentid, $targetcontent);

/**
     * Test that a given file exists in an H5P content.
     *
     * @return void
     */
    public function test_getContentFile(): void {

$file = 'img/fake.png';
        $contentid = 3;

// Add a file to a H5P content.
        $this->h5p_generator->create_content_file($file, file_storage::CONTENT_FILEAREA, $contentid);

// Get an existing file id.
        $fileid = $this->h5p_file_storage->getContentFile($file, $contentid);
        $this->assertNotNull($fileid);

// Try to get a nonexistent file.
        $fileid = $this->h5p_file_storage->getContentFile($file, 5);
        $this->assertNull($fileid);
    }

/**
     * Tests that the content folder of an H5P content is imported in the Moodle filesystem.
     */
    public function test_moveContentDiretory(): void {

// Create temp folder.
        $tempfolder = make_request_directory(false);

// Create H5P content folder.
        $h5pcontentfolder = $tempfolder . '/fakeH5Pcontent';
        $contentfolder = $h5pcontentfolder . '/content';
        if (!check_dir_exists($contentfolder, true, true)) {
            throw new moodle_exception('error_creating_temp_dir', 'error', $contentfolder);
        }

// Add content.json file.
        touch($contentfolder . 'content.json');

// Create several folders and files inside content folder.
        $filesexpected = array();
        $numfolders = random_int(2, 5);
        for ($numfolder = 1; $numfolder < $numfolders; $numfolder++) {
            $foldername = '/folder' . $numfolder;
            $newfolder = $contentfolder . $foldername;
            if (!check_dir_exists($newfolder, true, true)) {
                throw new moodle_exception('error_creating_temp_dir', 'error', $newfolder);
            }
            $numfiles = random_int(2, 5);
            for ($numfile = 1; $numfile < $numfiles; $numfile++) {
                $filename = '/file' . $numfile . '.ext';
                touch($newfolder . $filename);
                $filesexpected[] = $foldername . $filename;
            }
        }

$targeth5pcontentid = 111;
        $this->h5p_file_storage->moveContentDirectory($h5pcontentfolder, $targeth5pcontentid);

// Get database records.
        $files = $this->h5p_fs_fs->get_area_files(
            $this->h5p_fs_context->id,
            file_storage::COMPONENT,
            file_storage::CONTENT_FILEAREA,
            $targeth5pcontentid,
            'filepath, filename',
            false
        );

$filepaths = array_map(static function(stored_file $file): string {
            return $file->get_filepath() . $file->get_filename();
        }, $files);

// Check that created files match with database records.
        $this->assertEquals($filesexpected, array_values($filepaths));
    }

/**
     * Test that an H5P content file is removed.
     */
    public function test_removeContentFile(): void {

$file = 'img/fake.png';
        $filepath = '/' . dirname($file) . '/';
        $filename = basename($file);
        $h5pcontentid = 3;

// Add a file to a H5P content.
        $this->h5p_generator->create_content_file($file, file_storage::CONTENT_FILEAREA, $h5pcontentid);

// Check the file exists.
        $this->assertTrue($this->h5p_fs_fs->file_exists($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::CONTENT_FILEAREA, $h5pcontentid, $filepath, $filename));

$this->h5p_file_storage->removeContentFile($file, $h5pcontentid);

// Check the file doesn't exists.
        $this->assertFalse($this->h5p_fs_fs->file_exists($this->h5p_fs_context->id, file_storage::COMPONENT,
            file_storage::CONTENT_FILEAREA, $h5pcontentid, $filepath, $filename));
    }

/**
     * Test H5P custom styles generation.
     */
    public function test_generate_custom_styles(): void {
        \set_config('h5pcustomcss', '.debug { color: #fab; }', 'core_h5p');
        $h5pfsrc = new \ReflectionClass(file_storage::class);
        $customcssfilename = $h5pfsrc->getConstant('CUSTOM_CSS_FILENAME');

// Test 'h5pcustomcss' with data.
        file_storage::generate_custom_styles();

$this->assertTrue($this->h5p_fs_fs->file_exists(
            \context_system::instance()->id,
            file_storage::COMPONENT,
            file_storage::CSS_FILEAREA,
            0,
            '/',
            $customcssfilename)
        );

$cssfile = $this->h5p_fs_fs->get_file(
            \context_system::instance()->id,
            file_storage::COMPONENT,
            file_storage::CSS_FILEAREA,
            0,
            '/',
            $customcssfilename
        );
        $this->assertInstanceOf('stored_file', $cssfile);

$csscontents = $cssfile->get_content();
        $this->assertEquals($csscontents, '.debug { color: #fab; }');

// Test 'h5pcustomcss' without data.
        \set_config('h5pcustomcss', '', 'core_h5p');
        file_storage::generate_custom_styles();
        $this->assertFalse($this->h5p_fs_fs->file_exists(
            \context_system::instance()->id,
            file_storage::COMPONENT,
            file_storage::CSS_FILEAREA,
            0,
            '/',
            $customcssfilename)
        );
    }

/**
     * Test H5P custom styles retrieval.
     */
    public function test_get_custom_styles(): void {
        global $CFG;
        $css = '.debug { color: #fab; }';
        $cssurl = $CFG->wwwroot . '/pluginfile.php/1/core_h5p/css/custom_h5p.css';
        \set_config('h5pcustomcss', $css, 'core_h5p');
        $h5pfsrc = new \ReflectionClass(file_storage::class);
        $customcssfilename = $h5pfsrc->getConstant('CUSTOM_CSS_FILENAME');

// Normal operation without data.
        \set_config('h5pcustomcss', '', 'core_h5p');
        file_storage::generate_custom_styles();
        $style = file_storage::get_custom_styles();
        $this->assertNull($style);

// Normal operation with data.
        \set_config('h5pcustomcss', $css, 'core_h5p');
        file_storage::generate_custom_styles();
        $style = file_storage::get_custom_styles();

$this->assertNotEmpty($style);
        $this->assertEquals($style['cssurl']->out(), $cssurl);
        $this->assertEquals($style['cssversion'], md5($css));

// No CSS set when there is a file.
        \set_config('h5pcustomcss', '', 'core_h5p');
        try {
            $style = file_storage::get_custom_styles();
            $this->fail('moodle_exception for when there is no CSS and yet there is a file, was not thrown');
        } catch (\moodle_exception $me) {
            $this->assertEquals(
                'The H5P \'h5pcustomcss\' setting is empty and yet the custom CSS file \''.$customcssfilename.'\' exists.',
                $me->errorcode
            );
        }
        \set_config('h5pcustomcss', $css, 'core_h5p'); // Reset for next assertion.

// No CSS file when there is CSS.
        $cssfile = $this->h5p_fs_fs->get_file(
            \context_system::instance()->id,
            file_storage::COMPONENT,
            file_storage::CSS_FILEAREA,
            0,
            '/',
            $customcssfilename
        );
        $cssfile->delete();
        try {
            $style = file_storage::get_custom_styles();
            $this->fail('moodle_exception for when there is CSS and yet there is a file, was not thrown');
        } catch (\moodle_exception $me) {
            $this->assertEquals(
                'The H5P custom CSS file \''.$customcssfilename.
                '\' does not exist and yet there is CSS in the \'h5pcustomcss\' setting.',
                $me->errorcode
            );
        }
    }
}

CANCEL

Name	Type	Size	Modified	Actions
↩ ..	DIR	—	—
📁 behat/	DIR	—	2026-02-11 01:44
📁 event/	DIR	—	2026-02-11 01:44
📁 external/	DIR	—	2026-02-11 01:44
📁 fixtures/	DIR	—	2026-02-11 01:44
📁 generator/	DIR	—	2026-02-11 01:44
📁 local/	DIR	—	2026-02-11 01:44
📄 api_test.php	PHP	46.5 KB	2026-02-11 01:44	EDIT
📄 editor_ajax_test.php	PHP	10.5 KB	2026-02-11 01:44	EDIT
📄 editor_framework_test.php	PHP	15 KB	2026-02-11 01:44	EDIT
📄 editor_test.php	PHP	8.7 KB	2026-02-11 01:44	EDIT
📄 file_storage_test.php	PHP	36.1 KB	2026-02-11 01:44	EDIT
📄 framework_test.php	PHP	92.3 KB	2026-02-11 01:44	EDIT
📄 generator_test.php	PHP	23.4 KB	2026-02-11 01:44	EDIT
📄 h5p_core_test.php	PHP	7.9 KB	2026-02-11 01:44	EDIT
📄 helper_test.php	PHP	18.4 KB	2026-02-11 01:44	EDIT