SWAMPy

✎ CARVE FLESH

EDITING: converter_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/>.

/**
 * PHPUnit tests for fileconverter API.
 *
 * @package    core_files
 * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
defined('MOODLE_INTERNAL') || die();

global $CFG;

use core_files\conversion;
use core_files\converter;

/**
     * Get a testable mock of the abstract files_converter class.
     *
     * @param   array   $mockedmethods A list of methods you intend to override
     *                  If no methods are specified, only abstract functions are mocked.
     * @return  \core_files\converter
     */
    protected function get_testable_mock($mockedmethods = []) {
        $converter = $this->getMockBuilder(\core_files\converter::class)
            ->onlyMethods($mockedmethods)
            ->getMockForAbstractClass();

return $converter;
    }

/**
     * Get a testable mock of the conversion.
     *
     * @param   array   $mockedmethods A list of methods you intend to override
     * @return  \core_files\conversion
     */
    protected function get_testable_conversion($mockedmethods = []) {
        $conversion = $this->getMockBuilder(\core_files\conversion::class)
            ->onlyMethods($mockedmethods)
            ->setConstructorArgs([0, (object) []])
            ->getMock();

return $conversion;
    }

/**
     * Get a testable mock of the abstract files_converter class.
     *
     * @param   array   $mockedmethods A list of methods you intend to override
     *                  If no methods are specified, only abstract functions are mocked.
     * @return  \core_files\converter_interface
     */
    protected function get_mocked_converter($mockedmethods = []) {
        $converter = $this->getMockBuilder(\core_files\converter_interface::class)
            ->onlyMethods($mockedmethods)
            ->getMockForAbstractClass();

return $converter;
    }

/**
     * Helper to create a stored file objectw with the given supplied content.
     *
     * @param   string  $filecontent The content of the mocked file
     * @param   string  $filename The file name to use in the stored_file
     * @param   array   $mockedmethods A list of methods you intend to override
     *                  If no methods are specified, only abstract functions are mocked.
     * @return  stored_file
     */
    protected function get_stored_file($filecontent = 'content', $filename = null, $filerecord = [], $mockedmethods = []) {
        global $CFG;

$contenthash = sha1($filecontent);
        if (empty($filename)) {
            $filename = $contenthash;
        }

$filerecord['contenthash'] = $contenthash;
        $filerecord['filesize'] = strlen($filecontent);
        $filerecord['filename'] = $filename;
        $filerecord['id'] = 42;

$file = $this->getMockBuilder(stored_file::class)
            ->onlyMethods($mockedmethods)
            ->setConstructorArgs([get_file_storage(), (object) $filerecord])
            ->getMock();

return $file;
    }

/**
     * Helper to create a stored file object with the given supplied content.
     *
     * @param   string $filecontent The content of the mocked file
     * @param   string $filename The file name to use in the stored_file
     * @param   string $filerecord Any overrides to the filerecord
     * @return  stored_file
     */
    protected function create_stored_file($filecontent = 'content', $filename = 'testfile.txt', $filerecord = []) {
        $filerecord = array_merge([
                'contextid' => context_system::instance()->id,
                'component' => 'core',
                'filearea'  => 'unittest',
                'itemid'    => 0,
                'filepath'  => '/',
                'filename'  => $filename,
            ], $filerecord);

$fs = get_file_storage();
        $file = $fs->create_file_from_string($filerecord, $filecontent);

return $file;
    }

/**
     * Get a mock of the file_storage API.
     *
     * @param   array   $mockedmethods A list of methods you intend to override
     * @return  file_storage
     */
    protected function get_file_storage_mock($mockedmethods = []) {
        $fs = $this->getMockBuilder(\file_storage::class)
            ->onlyMethods($mockedmethods)
            ->disableOriginalConstructor()
            ->getMock();

return $fs;
    }

/**
     * Test the start_conversion function.
     */
    public function test_start_conversion_existing_single(): void {
        $this->resetAfterTest();

$sourcefile = $this->create_stored_file();

$first = new conversion(0, (object) [
                'sourcefileid' => $sourcefile->get_id(),
                'targetformat' => 'pdf',
            ]);
        $first->create();

$converter = $this->get_testable_mock(['poll_conversion']);
        $conversion = $converter->start_conversion($sourcefile, 'pdf', false);

// The old conversions should still be present and match the one returned.
        $this->assertEquals($first->get('id'), $conversion->get('id'));
    }

/**
     * Test the start_conversion function.
     */
    public function test_start_conversion_existing_multiple(): void {
        $this->resetAfterTest();

$sourcefile = $this->create_stored_file();

$first = new conversion(0, (object) [
                'sourcefileid' => $sourcefile->get_id(),
                'targetformat' => 'pdf',
            ]);
        $first->create();

$second = new conversion(0, (object) [
                'sourcefileid' => $sourcefile->get_id(),
                'targetformat' => 'pdf',
            ]);
        $second->create();

$converter = $this->get_testable_mock(['poll_conversion']);
        $conversion = $converter->start_conversion($sourcefile, 'pdf', false);

// The old conversions should have been removed.
        $this->assertFalse(conversion::get_record(['id' => $first->get('id')]));
        $this->assertFalse(conversion::get_record(['id' => $second->get('id')]));
    }

/**
     * Test the start_conversion function.
     */
    public function test_start_conversion_no_existing(): void {
        $this->resetAfterTest();

$sourcefile = $this->create_stored_file();

$converter = $this->get_testable_mock(['poll_conversion']);
        $conversion = $converter->start_conversion($sourcefile, 'pdf', false);

$this->assertInstanceOf(\core_files\conversion::class, $conversion);
    }

/**
     * Test the get_document_converter_classes function with no enabled plugins.
     */
    public function test_get_document_converter_classes_no_plugins(): void {
        $converter = $this->get_testable_mock(['get_enabled_plugins']);
        $converter->method('get_enabled_plugins')->willReturn([]);

$method = new ReflectionMethod(\core_files\converter::class, 'get_document_converter_classes');
        $result = $method->invokeArgs($converter, ['docx', 'pdf']);
        $this->assertEmpty($result);
    }

/**
     * Test the get_document_converter_classes function when no class was found.
     */
    public function test_get_document_converter_classes_plugin_class_not_found(): void {
        $converter = $this->get_testable_mock(['get_enabled_plugins']);
        $converter->method('get_enabled_plugins')->willReturn([
                'noplugin' => '\not\a\real\plugin',
            ]);

/**
     * Test the get_document_converter_classes function when the returned classes do not meet requirements.
     */
    public function test_get_document_converter_classes_plugin_class_requirements_not_met(): void {
        $plugin = $this->getMockBuilder(\core_file_converter_requirements_not_met::class)
            ->onlyMethods([])
            ->getMock();

$converter = $this->get_testable_mock(['get_enabled_plugins']);
        $converter->method('get_enabled_plugins')->willReturn([
                'test_plugin' => get_class($plugin),
            ]);

/**
     * Test the get_document_converter_classes function when the returned classes do not meet requirements.
     */
    public function test_get_document_converter_classes_plugin_class_met_not_supported(): void {
        $plugin = $this->getMockBuilder(\core_file_converter_type_not_supported::class)
            ->onlyMethods([])
            ->getMock();

$converter = $this->get_testable_mock(['get_enabled_plugins']);
        $converter->method('get_enabled_plugins')->willReturn([
                'test_plugin' => get_class($plugin),
            ]);

/**
     * Test the get_document_converter_classes function when the returned classes do not meet requirements.
     */
    public function test_get_document_converter_classes_plugin_class_met_and_supported(): void {
        $plugin = $this->getMockBuilder(\core_file_converter_type_supported::class)
            ->onlyMethods([])
            ->getMock();
        $classname = get_class($plugin);

$converter = $this->get_testable_mock(['get_enabled_plugins']);
        $converter->method('get_enabled_plugins')->willReturn([
                'test_plugin' => $classname,
            ]);

/**
     * Test the can_convert_storedfile_to function with a directory.
     */
    public function test_can_convert_storedfile_to_directory(): void {
        $converter = $this->get_testable_mock();

// A file with filename '.' is a directory.
        $file = $this->get_stored_file('', '.');

$this->assertFalse($converter->can_convert_storedfile_to($file, 'target'));
    }

/**
     * Test the can_convert_storedfile_to function with an empty file.
     */
    public function test_can_convert_storedfile_to_emptyfile(): void {
        $converter = $this->get_testable_mock();

// A file with filename '.' is a directory.
        $file = $this->get_stored_file('');

$this->assertFalse($converter->can_convert_storedfile_to($file, 'target'));
    }

/**
     * Test the can_convert_storedfile_to function with a file with indistinguished mimetype.
     */
    public function test_can_convert_storedfile_to_no_mimetype(): void {
        $converter = $this->get_testable_mock();

// A file with filename '.' is a directory.
        $file = $this->get_stored_file('example content', 'example', [
                'mimetype' => null,
            ]);

$this->assertFalse($converter->can_convert_storedfile_to($file, 'target'));
    }

/**
     * Test the can_convert_storedfile_to function with a file with a known mimetype and extension.
     */
    public function test_can_convert_storedfile_to_docx(): void {
        $returnvalue = (object) [];

$converter = $this->get_testable_mock([
                'can_convert_format_to'
            ]);

$types = \core_filetypes::get_types();

$file = $this->get_stored_file('example content', 'example.docx', [
                'mimetype' => $types['docx']['type'],
            ]);

$converter->expects($this->once())
            ->method('can_convert_format_to')
            ->willReturn($returnvalue);

$result = $converter->can_convert_storedfile_to($file, 'target');
        $this->assertEquals($returnvalue, $result);
    }

/**
     * Test the can_convert_format_to function.
     */
    public function test_can_convert_format_to_found(): void {
        $converter = $this->get_testable_mock(['get_document_converter_classes']);

$mock = $this->get_mocked_converter();

$converter->method('get_document_converter_classes')
            ->willReturn([$mock]);

$result = $converter->can_convert_format_to('from', 'to');
        $this->assertTrue($result);
    }

/**
     * Test the can_convert_format_to function.
     */
    public function test_can_convert_format_to_not_found(): void {
        $converter = $this->get_testable_mock(['get_document_converter_classes']);

$converter->method('get_document_converter_classes')
            ->willReturn([]);

$result = $converter->can_convert_format_to('from', 'to');
        $this->assertFalse($result);
    }

/**
     * Test the can_convert_storedfile_to function with an empty file.
     */
    public function test_poll_conversion_in_progress(): void {
        $this->resetAfterTest();

$converter = $this->get_testable_mock([
                'get_document_converter_classes',
                'get_next_converter',
            ]);

$converter->method('get_document_converter_classes')->willReturn([]);
        $converter->method('get_next_converter')->willReturn(false);
        $file = $this->create_stored_file('example content', 'example', [
                'mimetype' => null,
            ]);

$conversion = $this->get_testable_conversion([
                'get_converter_instance',
            ]);
        $conversion->set_sourcefile($file);
        $conversion->set('targetformat', 'target');
        $conversion->set('status', conversion::STATUS_IN_PROGRESS);
        $conversion->create();

$converterinstance = $this->get_mocked_converter([
                'poll_conversion_status',
            ]);
        $converterinstance->expects($this->once())
            ->method('poll_conversion_status');
        $conversion->method('get_converter_instance')->willReturn($converterinstance);

$converter->poll_conversion($conversion);

$this->assertEquals(conversion::STATUS_IN_PROGRESS, $conversion->get('status'));
    }

/**
     * Test poll_conversion with an in-progress conversion where we are
     * unable to instantiate the converter instance.
     */
    public function test_poll_conversion_in_progress_fail(): void {
        $this->resetAfterTest();

$converter = $this->get_testable_mock([
                'get_document_converter_classes',
                'get_next_converter',
            ]);

$conversion->method('get_converter_instance')->willReturn(false);

$converter->poll_conversion($conversion);

$this->assertEquals(conversion::STATUS_FAILED, $conversion->get('status'));
    }

/**
     * Test the can_convert_storedfile_to function with an empty file.
     */
    public function test_poll_conversion_none_supported(): void {
        $this->resetAfterTest();

$converter = $this->get_testable_mock([
                'get_document_converter_classes',
                'get_next_converter',
            ]);

$conversion = new conversion(0, (object) [
            'sourcefileid' => $file->get_id(),
            'targetformat' => 'target',
        ]);
        $conversion->create();

$converter->poll_conversion($conversion);

$this->assertEquals(conversion::STATUS_FAILED, $conversion->get('status'));
    }

/**
     * Test the can_convert_storedfile_to function with an empty file.
     */
    public function test_poll_conversion_pick_first(): void {
        $this->resetAfterTest();

$converterinstance = $this->get_mocked_converter([
                'start_document_conversion',
                'poll_conversion_status',
            ]);
        $converter = $this->get_testable_mock([
                'get_document_converter_classes',
                'get_next_converter',
            ]);

$converter->method('get_document_converter_classes')->willReturn([]);
        $converter->method('get_next_converter')->willReturn(get_class($converterinstance));
        $file = $this->create_stored_file('example content', 'example', [
                'mimetype' => null,
            ]);

$conversion->method('get_converter_instance')->willReturn($converterinstance);

$converterinstance->expects($this->once())
            ->method('start_document_conversion');
        $converterinstance->expects($this->never())
            ->method('poll_conversion_status');

$converter->poll_conversion($conversion);

$this->assertEquals(conversion::STATUS_IN_PROGRESS, $conversion->get('status'));
    }

/**
     * Test the can_convert_storedfile_to function with an empty file.
     */
    public function test_poll_conversion_pick_subsequent(): void {
        $this->resetAfterTest();

$converterinstance = $this->get_mocked_converter([
                'start_document_conversion',
                'poll_conversion_status',
            ]);
        $converterinstance2 = $this->get_mocked_converter([
                'start_document_conversion',
                'poll_conversion_status',
            ]);
        $converter = $this->get_testable_mock([
                'get_document_converter_classes',
                'get_next_converter',
            ]);

$converter->method('get_document_converter_classes')->willReturn([]);
        $getinvocations = $this->any();
        $converter
            ->expects($getinvocations)
            ->method('get_next_converter')
            ->willReturnCallback(fn (): string => match (self::getInvocationCount($getinvocations)) {
                1 => get_class($converterinstance),
                default => get_class($converterinstance2),
            });

$file = $this->create_stored_file('example content', 'example', [
                'mimetype' => null,
            ]);

$conversion = $this->get_testable_conversion([
                'get_converter_instance',
                'get_status',
            ]);
        $conversion->set_sourcefile($file);
        $conversion->set('targetformat', 'target');
        $conversion->set('status', conversion::STATUS_PENDING);
        $conversion->create();

$statusinvocations = $this->atLeast(4);
        $conversion
            ->expects($statusinvocations)
            ->method('get_status')
            ->willReturnCallback(fn (): int => match (self::getInvocationCount($statusinvocations)) {
                // Initial status check.
                1 => conversion::STATUS_PENDING,
                // Second check to make sure it's still pending after polling.
                2 => conversion::STATUS_PENDING,
                // First one fails.
                3 => conversion::STATUS_FAILED,
                // Second one succeeds.
                4 => conversion::STATUS_COMPLETE,
                // And the final result checked in this unit test.
                default => conversion::STATUS_COMPLETE,
            });

$instanceinvocations = $this->any();
        $conversion
            ->expects($instanceinvocations)
            ->method('get_converter_instance')
            ->willReturnCallback(fn (): object => match (self::getInvocationCount($instanceinvocations)) {
                1 => $converterinstance,
                default => $converterinstance2,
            });

$converterinstance->expects($this->once())
            ->method('start_document_conversion');
        $converterinstance->expects($this->never())
            ->method('poll_conversion_status');
        $converterinstance2->expects($this->once())
            ->method('start_document_conversion');
        $converterinstance2->expects($this->never())
            ->method('poll_conversion_status');

$converter->poll_conversion($conversion);

$this->assertEquals(conversion::STATUS_COMPLETE, $conversion->get('status'));
    }

/**
     * Test the start_conversion with a single converter which succeeds.
     */
    public function test_start_conversion_one_supported_success(): void {
        $this->resetAfterTest();

$converter = $this->get_testable_mock([
                'get_document_converter_classes',
            ]);

$converter->method('get_document_converter_classes')
            ->willReturn([\core_file_converter_type_successful::class]);

$file = $this->create_stored_file('example content', 'example', [
                'mimetype' => null,
            ]);

$conversion = $converter->start_conversion($file, 'target');

$this->assertEquals(conversion::STATUS_COMPLETE, $conversion->get('status'));
    }

/**
     * Test the start_conversion with a single converter which failes.
     */
    public function test_start_conversion_one_supported_failure(): void {
        $this->resetAfterTest();

$converter = $this->get_testable_mock([
                'get_document_converter_classes',
            ]);

$mock = $this->get_mocked_converter(['start_document_conversion']);
        $converter->method('get_document_converter_classes')
            ->willReturn([\core_file_converter_type_failed::class]);

$file = $this->create_stored_file('example content', 'example', [
                'mimetype' => null,
            ]);

$conversion = $converter->start_conversion($file, 'target');

$this->assertEquals(conversion::STATUS_FAILED, $conversion->get('status'));
    }

/**
     * Test the start_conversion with two converters - fail, then succeed.
     */
    public function test_start_conversion_two_supported(): void {
        $this->resetAfterTest();

$converter = $this->get_testable_mock([
                'get_document_converter_classes',
            ]);

$mock = $this->get_mocked_converter(['start_document_conversion']);
        $converter->method('get_document_converter_classes')
            ->willReturn([
                \core_file_converter_type_failed::class,
                \core_file_converter_type_successful::class,
            ]);

$file = $this->create_stored_file('example content', 'example', [
                'mimetype' => null,
            ]);

$conversion = $converter->start_conversion($file, 'target');

$this->assertEquals(conversion::STATUS_COMPLETE, $conversion->get('status'));
    }

/**
     * Ensure that get_next_converter returns false when no converters are available.
     */
    public function test_get_next_converter_no_converters(): void {
        $rcm = new \ReflectionMethod(converter::class, 'get_next_converter');

$converter = new \core_files\converter();
        $result = $rcm->invoke($converter, [], null);
        $this->assertFalse($result);
    }

/**
     * Ensure that get_next_converter returns false when already on the
     * only converter.
     */
    public function test_get_next_converter_only_converters(): void {
        $rcm = new \ReflectionMethod(converter::class, 'get_next_converter');

$converter = new converter();
        $result = $rcm->invoke($converter, ['example'], 'example');
        $this->assertFalse($result);
    }

/**
     * Ensure that get_next_converter returns false when already on the
     * last converter.
     */
    public function test_get_next_converter_last_converters(): void {
        $rcm = new \ReflectionMethod(converter::class, 'get_next_converter');

$converter = new converter();
        $result = $rcm->invoke($converter, ['foo', 'example'], 'example');
        $this->assertFalse($result);
    }

/**
     * Ensure that get_next_converter returns the next vlaue when in a
     * current converter.
     */
    public function test_get_next_converter_middle_converters(): void {
        $rcm = new \ReflectionMethod(converter::class, 'get_next_converter');

$converter = new converter();
        $result = $rcm->invoke($converter, ['foo', 'bar', 'baz', 'example'], 'bar');
        $this->assertEquals('baz', $result);
    }
    /**
     *
     * Ensure that get_next_converter returns the next vlaue when in a
     * current converter.
     */
    public function test_get_next_converter_first(): void {
        $rcm = new \ReflectionMethod(converter::class, 'get_next_converter');

$converter = new converter();
        $result = $rcm->invoke($converter, ['foo', 'bar', 'baz', 'example']);
        $this->assertEquals('foo', $result);
    }
}

class core_file_converter_requirements_base implements \core_files\converter_interface {

/**
     * Whether the plugin is configured and requirements are met.
     *
     * @return  bool
     */
    public static function are_requirements_met() {
        return false;
    }

/**
     * Convert a document to a new format and return a conversion object relating to the conversion in progress.
     *
     * @param   conversion $conversion The file to be converted
     * @return  conversion
     */
    public function start_document_conversion(conversion $conversion) {
    }

/**
     * Poll an existing conversion for status update.
     *
     * @param   conversion $conversion The file to be converted
     * @return  conversion
     */
    public function poll_conversion_status(conversion $conversion) {
    }

/**
     * Whether a file conversion can be completed using this converter.
     *
     * @param   string $from The source type
     * @param   string $to The destination type
     * @return  bool
     */
    public static function supports($from, $to) {
        return false;
    }

/**
     * A list of the supported conversions.
     *
     * @return  string
     */
    public function get_supported_conversions() {
        return [];
    }

}

/**
 * Test class for converter support with requirements are not met.
 *
 * @package    core_files
 * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class core_file_converter_requirements_not_met extends core_file_converter_requirements_base {
}

/**
 * Test class for converter support with requirements met and conversion not supported.
 *
 * @package    core_files
 * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class core_file_converter_type_not_supported extends core_file_converter_requirements_base {

/**
     * Whether the plugin is configured and requirements are met.
     *
     * @return  bool
     */
    public static function are_requirements_met() {
        return true;
    }
}

/**
 * Test class for converter support with requirements met and conversion supported.
 *
 * @package    core_files
 * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class core_file_converter_type_supported extends core_file_converter_requirements_base {

/**
     * Whether the plugin is configured and requirements are met.
     *
     * @return  bool
     */
    public static function are_requirements_met() {
        return true;
    }

/**
 * Test class for converter support with requirements met and successful conversion.
 *
 * @package    core_files
 * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class core_file_converter_type_successful extends core_file_converter_requirements_base {

return $conversion;
    }

/**
 * Test class for converter support with requirements met and failed conversion.
 *
 * @package    core_files
 * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class core_file_converter_type_failed extends core_file_converter_requirements_base {

/**
     * Whether the plugin is configured and requirements are met.
     *
     * @return  bool
     */
    public static function are_requirements_met() {
        return true;
    }

return $conversion;
    }

CANCEL

Name	Type	Size	Modified	Actions
↩ ..	DIR	—	—
📁 behat/	DIR	—	2026-02-11 01:44
📁 classes/	DIR	—	2026-02-11 01:44
📁 external/	DIR	—	2026-02-11 01:44
📁 fixtures/	DIR	—	2026-02-11 01:44
📁 hook/	DIR	—	2026-02-11 01:44
📁 local/	DIR	—	2026-02-11 01:44
📁 privacy/	DIR	—	2026-02-11 01:44
📁 redactor/	DIR	—	2026-02-11 01:44
📁 reportbuilder/	DIR	—	2026-02-11 01:44
📁 task/	DIR	—	2026-02-11 01:44
📄 archive_writer_test.php	PHP	1.7 KB	2026-02-11 01:44	EDIT
📄 conversion_test.php	PHP	17.7 KB	2026-02-11 01:44	EDIT
📄 converter_test.php	PHP	31.3 KB	2026-02-11 01:44	EDIT
📄 externallib_test.php	PHP	17 KB	2026-02-11 01:44	EDIT