<?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;
/**
* 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
*/
final class converter_test extends advanced_testcase {
/**
* 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',
]);
$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 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),
]);
$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 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),
]);
$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 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,
]);
$method = new ReflectionMethod(\core_files\converter::class, 'get_document_converter_classes');
$result = $method->invokeArgs($converter, ['docx', 'pdf']);
$this->assertCount(1, $result);
$this->assertNotFalse(array_search($classname, $result));
}
/**
* 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',
]);
$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();
$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',
]);
$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 = 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 = $this->get_testable_conversion([
'get_converter_instance',
]);
$conversion->set_sourcefile($file);
$conversion->set('targetformat', 'target');
$conversion->set('status', conversion::STATUS_PENDING);
$conversion->create();
$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;
}
/**
* 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 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 {
/**
* 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) {
$conversion->set('status', conversion::STATUS_COMPLETE);
return $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 true;
}
}
/**
* 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;
}
/**
* 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) {
$conversion->set('status', conversion::STATUS_FAILED);
return $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 true;
}
}