Merge branch 'MDL-60057-master' of git://github.com/lameze/moodle
[moodle.git] / files / tests / converter_test.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * PHPUnit tests for fileconverter API.
20  *
21  * @package    core_files
22  * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
25 defined('MOODLE_INTERNAL') || die();
27 global $CFG;
29 use core_files\conversion;
30 use core_files\converter;
32 /**
33  * PHPUnit tests for fileconverter API.
34  *
35  * @package    core_files
36  * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
37  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
38  */
39 class core_files_converter_testcase extends advanced_testcase {
41     /**
42      * Get a testable mock of the abstract files_converter class.
43      *
44      * @param   array   $mockedmethods A list of methods you intend to override
45      *                  If no methods are specified, only abstract functions are mocked.
46      * @return  \core_files\converter
47      */
48     protected function get_testable_mock($mockedmethods = []) {
49         $converter = $this->getMockBuilder(\core_files\converter::class)
50             ->setMethods($mockedmethods)
51             ->getMockForAbstractClass();
53         return $converter;
54     }
56     /**
57      * Get a testable mock of the conversion.
58      *
59      * @param   array   $mockedmethods A list of methods you intend to override
60      * @return  \core_files\conversion
61      */
62     protected function get_testable_conversion($mockedmethods = []) {
63         $conversion = $this->getMockBuilder(\core_files\conversion::class)
64             ->setMethods($mockedmethods)
65             ->setConstructorArgs([0, (object) []])
66             ->getMock();
68         return $conversion;
69     }
71     /**
72      * Get a testable mock of the abstract files_converter class.
73      *
74      * @param   array   $mockedmethods A list of methods you intend to override
75      *                  If no methods are specified, only abstract functions are mocked.
76      * @return  \core_files\converter_interface
77      */
78     protected function get_mocked_converter($mockedmethods = []) {
79         $converter = $this->getMockBuilder(\core_files\converter_interface::class)
80             ->setMethods($mockedmethods)
81             ->getMockForAbstractClass();
83         return $converter;
84     }
86     /**
87      * Helper to create a stored file objectw with the given supplied content.
88      *
89      * @param   string  $filecontent The content of the mocked file
90      * @param   string  $filename The file name to use in the stored_file
91      * @param   array   $mockedmethods A list of methods you intend to override
92      *                  If no methods are specified, only abstract functions are mocked.
93      * @return  stored_file
94      */
95     protected function get_stored_file($filecontent = 'content', $filename = null, $filerecord = [], $mockedmethods = null) {
96         global $CFG;
98         $contenthash = sha1($filecontent);
99         if (empty($filename)) {
100             $filename = $contenthash;
101         }
103         $filerecord['contenthash'] = $contenthash;
104         $filerecord['filesize'] = strlen($filecontent);
105         $filerecord['filename'] = $filename;
106         $filerecord['id'] = 42;
108         $file = $this->getMockBuilder(stored_file::class)
109             ->setMethods($mockedmethods)
110             ->setConstructorArgs([get_file_storage(), (object) $filerecord])
111             ->getMock();
113         return $file;
114     }
116     /**
117      * Helper to create a stored file object with the given supplied content.
118      *
119      * @param   string $filecontent The content of the mocked file
120      * @param   string $filename The file name to use in the stored_file
121      * @param   string $filerecord Any overrides to the filerecord
122      * @return  stored_file
123      */
124     protected function create_stored_file($filecontent = 'content', $filename = 'testfile.txt', $filerecord = []) {
125         $filerecord = array_merge([
126                 'contextid' => context_system::instance()->id,
127                 'component' => 'core',
128                 'filearea'  => 'unittest',
129                 'itemid'    => 0,
130                 'filepath'  => '/',
131                 'filename'  => $filename,
132             ], $filerecord);
134         $fs = get_file_storage();
135         $file = $fs->create_file_from_string($filerecord, $filecontent);
137         return $file;
138     }
140     /**
141      * Get a mock of the file_storage API.
142      *
143      * @param   array   $mockedmethods A list of methods you intend to override
144      * @return  file_storage
145      */
146     protected function get_file_storage_mock($mockedmethods = []) {
147         $fs = $this->getMockBuilder(\file_storage::class)
148             ->setMethods($mockedmethods)
149             ->disableOriginalConstructor()
150             ->getMock();
152         return $fs;
153     }
155     /**
156      * Test the start_conversion function.
157      */
158     public function test_start_conversion_existing_single() {
159         $this->resetAfterTest();
161         $sourcefile = $this->create_stored_file();
163         $first = new conversion(0, (object) [
164                 'sourcefileid' => $sourcefile->get_id(),
165                 'targetformat' => 'pdf',
166             ]);
167         $first->create();
169         $converter = $this->get_testable_mock(['poll_conversion']);
170         $conversion = $converter->start_conversion($sourcefile, 'pdf', false);
172         // The old conversions should still be present and match the one returned.
173         $this->assertEquals($first->get('id'), $conversion->get('id'));
174     }
176     /**
177      * Test the start_conversion function.
178      */
179     public function test_start_conversion_existing_multiple() {
180         $this->resetAfterTest();
182         $sourcefile = $this->create_stored_file();
184         $first = new conversion(0, (object) [
185                 'sourcefileid' => $sourcefile->get_id(),
186                 'targetformat' => 'pdf',
187             ]);
188         $first->create();
190         $second = new conversion(0, (object) [
191                 'sourcefileid' => $sourcefile->get_id(),
192                 'targetformat' => 'pdf',
193             ]);
194         $second->create();
196         $converter = $this->get_testable_mock(['poll_conversion']);
197         $conversion = $converter->start_conversion($sourcefile, 'pdf', false);
199         // The old conversions should have been removed.
200         $this->assertFalse(conversion::get_record(['id' => $first->get('id')]));
201         $this->assertFalse(conversion::get_record(['id' => $second->get('id')]));
202     }
204     /**
205      * Test the start_conversion function.
206      */
207     public function test_start_conversion_no_existing() {
208         $this->resetAfterTest();
210         $sourcefile = $this->create_stored_file();
212         $converter = $this->get_testable_mock(['poll_conversion']);
213         $conversion = $converter->start_conversion($sourcefile, 'pdf', false);
215         $this->assertInstanceOf(\core_files\conversion::class, $conversion);
216     }
218     /**
219      * Test the get_document_converter_classes function with no enabled plugins.
220      */
221     public function test_get_document_converter_classes_no_plugins() {
222         $converter = $this->get_testable_mock(['get_enabled_plugins']);
223         $converter->method('get_enabled_plugins')->willReturn([]);
225         $method = new ReflectionMethod(\core_files\converter::class, 'get_document_converter_classes');
226         $method->setAccessible(true);
227         $result = $method->invokeArgs($converter, ['docx', 'pdf']);
228         $this->assertEmpty($result);
229     }
231     /**
232      * Test the get_document_converter_classes function when no class was found.
233      */
234     public function test_get_document_converter_classes_plugin_class_not_found() {
235         $converter = $this->get_testable_mock(['get_enabled_plugins']);
236         $converter->method('get_enabled_plugins')->willReturn([
237                 'noplugin' => '\not\a\real\plugin',
238             ]);
240         $method = new ReflectionMethod(\core_files\converter::class, 'get_document_converter_classes');
241         $method->setAccessible(true);
242         $result = $method->invokeArgs($converter, ['docx', 'pdf']);
243         $this->assertEmpty($result);
244     }
246     /**
247      * Test the get_document_converter_classes function when the returned classes do not meet requirements.
248      */
249     public function test_get_document_converter_classes_plugin_class_requirements_not_met() {
250         $plugin = $this->getMockBuilder(\core_file_converter_requirements_not_met_test::class)
251             ->setMethods()
252             ->getMock();
254         $converter = $this->get_testable_mock(['get_enabled_plugins']);
255         $converter->method('get_enabled_plugins')->willReturn([
256                 'test_plugin' => get_class($plugin),
257             ]);
259         $method = new ReflectionMethod(\core_files\converter::class, 'get_document_converter_classes');
260         $method->setAccessible(true);
261         $result = $method->invokeArgs($converter, ['docx', 'pdf']);
262         $this->assertEmpty($result);
263     }
265     /**
266      * Test the get_document_converter_classes function when the returned classes do not meet requirements.
267      */
268     public function test_get_document_converter_classes_plugin_class_met_not_supported() {
269         $plugin = $this->getMockBuilder(\core_file_converter_type_not_supported_test::class)
270             ->setMethods()
271             ->getMock();
273         $converter = $this->get_testable_mock(['get_enabled_plugins']);
274         $converter->method('get_enabled_plugins')->willReturn([
275                 'test_plugin' => get_class($plugin),
276             ]);
278         $method = new ReflectionMethod(\core_files\converter::class, 'get_document_converter_classes');
279         $method->setAccessible(true);
280         $result = $method->invokeArgs($converter, ['docx', 'pdf']);
281         $this->assertEmpty($result);
282     }
284     /**
285      * Test the get_document_converter_classes function when the returned classes do not meet requirements.
286      */
287     public function test_get_document_converter_classes_plugin_class_met_and_supported() {
288         $plugin = $this->getMockBuilder(\core_file_converter_type_supported_test::class)
289             ->setMethods()
290             ->getMock();
291         $classname = get_class($plugin);
293         $converter = $this->get_testable_mock(['get_enabled_plugins']);
294         $converter->method('get_enabled_plugins')->willReturn([
295                 'test_plugin' => $classname,
296             ]);
298         $method = new ReflectionMethod(\core_files\converter::class, 'get_document_converter_classes');
299         $method->setAccessible(true);
300         $result = $method->invokeArgs($converter, ['docx', 'pdf']);
301         $this->assertCount(1, $result);
302         $this->assertNotFalse(array_search($classname, $result));
303     }
305     /**
306      * Test the can_convert_storedfile_to function with a directory.
307      */
308     public function test_can_convert_storedfile_to_directory() {
309         $converter = $this->get_testable_mock();
311         // A file with filename '.' is a directory.
312         $file = $this->get_stored_file('', '.');
314         $this->assertFalse($converter->can_convert_storedfile_to($file, 'target'));
315     }
317     /**
318      * Test the can_convert_storedfile_to function with an empty file.
319      */
320     public function test_can_convert_storedfile_to_emptyfile() {
321         $converter = $this->get_testable_mock();
323         // A file with filename '.' is a directory.
324         $file = $this->get_stored_file('');
326         $this->assertFalse($converter->can_convert_storedfile_to($file, 'target'));
327     }
329     /**
330      * Test the can_convert_storedfile_to function with a file with indistinguished mimetype.
331      */
332     public function test_can_convert_storedfile_to_no_mimetype() {
333         $converter = $this->get_testable_mock();
335         // A file with filename '.' is a directory.
336         $file = $this->get_stored_file('example content', 'example', [
337                 'mimetype' => null,
338             ]);
340         $this->assertFalse($converter->can_convert_storedfile_to($file, 'target'));
341     }
343     /**
344      * Test the can_convert_storedfile_to function with a file with indistinguished mimetype.
345      */
346     public function test_can_convert_storedfile_to_docx() {
347         $returnvalue = (object) [];
349         $converter = $this->get_testable_mock([
350                 'can_convert_format_to'
351             ]);
353         $types = \core_filetypes::get_types();
355         // A file with filename '.' is a directory.
356         $file = $this->get_stored_file('example content', 'example', [
357                 'mimetype' => $types['docx']['type'],
358             ]);
360         $converter->expects($this->once())
361             ->method('can_convert_format_to')
362             ->willReturn($returnvalue);
364         $result = $converter->can_convert_storedfile_to($file, 'target');
365         $this->assertEquals($returnvalue, $result);
366     }
369     /**
370      * Test the can_convert_format_to function.
371      */
372     public function test_can_convert_format_to_found() {
373         $converter = $this->get_testable_mock(['get_document_converter_classes']);
375         $mock = $this->get_mocked_converter();
377         $converter->method('get_document_converter_classes')
378             ->willReturn([$mock]);
380         $result = $converter->can_convert_format_to('from', 'to');
381         $this->assertTrue($result);
382     }
384     /**
385      * Test the can_convert_format_to function.
386      */
387     public function test_can_convert_format_to_not_found() {
388         $converter = $this->get_testable_mock(['get_document_converter_classes']);
390         $converter->method('get_document_converter_classes')
391             ->willReturn([]);
393         $result = $converter->can_convert_format_to('from', 'to');
394         $this->assertFalse($result);
395     }
397     /**
398      * Test the can_convert_storedfile_to function with an empty file.
399      */
400     public function test_poll_conversion_in_progress() {
401         $this->resetAfterTest();
403         $converter = $this->get_testable_mock([
404                 'get_document_converter_classes',
405                 'get_next_converter',
406             ]);
408         $converter->method('get_document_converter_classes')->willReturn([]);
409         $converter->method('get_next_converter')->willReturn(false);
410         $file = $this->create_stored_file('example content', 'example', [
411                 'mimetype' => null,
412             ]);
414         $conversion = $this->get_testable_conversion([
415                 'get_converter_instance',
416             ]);
417         $conversion->set_sourcefile($file);
418         $conversion->set('targetformat', 'target');
419         $conversion->set('status', conversion::STATUS_IN_PROGRESS);
420         $conversion->create();
422         $converterinstance = $this->get_mocked_converter([
423                 'poll_conversion_status',
424             ]);
425         $converterinstance->expects($this->once())
426             ->method('poll_conversion_status');
427         $conversion->method('get_converter_instance')->willReturn($converterinstance);
429         $converter->poll_conversion($conversion);
431         $this->assertEquals(conversion::STATUS_IN_PROGRESS, $conversion->get('status'));
432     }
434     /**
435      * Test poll_conversion with an in-progress conversion where we are
436      * unable to instantiate the converter instance.
437      */
438     public function test_poll_conversion_in_progress_fail() {
439         $this->resetAfterTest();
441         $converter = $this->get_testable_mock([
442                 'get_document_converter_classes',
443                 'get_next_converter',
444             ]);
446         $converter->method('get_document_converter_classes')->willReturn([]);
447         $converter->method('get_next_converter')->willReturn(false);
448         $file = $this->create_stored_file('example content', 'example', [
449                 'mimetype' => null,
450             ]);
452         $conversion = $this->get_testable_conversion([
453                 'get_converter_instance',
454             ]);
455         $conversion->set_sourcefile($file);
456         $conversion->set('targetformat', 'target');
457         $conversion->set('status', conversion::STATUS_IN_PROGRESS);
458         $conversion->create();
460         $conversion->method('get_converter_instance')->willReturn(false);
462         $converter->poll_conversion($conversion);
464         $this->assertEquals(conversion::STATUS_FAILED, $conversion->get('status'));
465     }
467     /**
468      * Test the can_convert_storedfile_to function with an empty file.
469      */
470     public function test_poll_conversion_none_supported() {
471         $this->resetAfterTest();
473         $converter = $this->get_testable_mock([
474                 'get_document_converter_classes',
475                 'get_next_converter',
476             ]);
478         $converter->method('get_document_converter_classes')->willReturn([]);
479         $converter->method('get_next_converter')->willReturn(false);
480         $file = $this->create_stored_file('example content', 'example', [
481                 'mimetype' => null,
482             ]);
484         $conversion = new conversion(0, (object) [
485             'sourcefileid' => $file->get_id(),
486             'targetformat' => 'target',
487         ]);
488         $conversion->create();
490         $converter->poll_conversion($conversion);
492         $this->assertEquals(conversion::STATUS_FAILED, $conversion->get('status'));
493     }
495     /**
496      * Test the can_convert_storedfile_to function with an empty file.
497      */
498     public function test_poll_conversion_pick_first() {
499         $this->resetAfterTest();
501         $converterinstance = $this->get_mocked_converter([
502                 'start_document_conversion',
503                 'poll_conversion_status',
504             ]);
505         $converter = $this->get_testable_mock([
506                 'get_document_converter_classes',
507                 'get_next_converter',
508             ]);
510         $converter->method('get_document_converter_classes')->willReturn([]);
511         $converter->method('get_next_converter')->willReturn(get_class($converterinstance));
512         $file = $this->create_stored_file('example content', 'example', [
513                 'mimetype' => null,
514             ]);
516         $conversion = $this->get_testable_conversion([
517                 'get_converter_instance',
518             ]);
519         $conversion->set_sourcefile($file);
520         $conversion->set('targetformat', 'target');
521         $conversion->set('status', conversion::STATUS_PENDING);
522         $conversion->create();
524         $conversion->method('get_converter_instance')->willReturn($converterinstance);
526         $converterinstance->expects($this->once())
527             ->method('start_document_conversion');
528         $converterinstance->expects($this->never())
529             ->method('poll_conversion_status');
531         $converter->poll_conversion($conversion);
533         $this->assertEquals(conversion::STATUS_IN_PROGRESS, $conversion->get('status'));
534     }
536     /**
537      * Test the can_convert_storedfile_to function with an empty file.
538      */
539     public function test_poll_conversion_pick_subsequent() {
540         $this->resetAfterTest();
542         $converterinstance = $this->get_mocked_converter([
543                 'start_document_conversion',
544                 'poll_conversion_status',
545             ]);
546         $converterinstance2 = $this->get_mocked_converter([
547                 'start_document_conversion',
548                 'poll_conversion_status',
549             ]);
550         $converter = $this->get_testable_mock([
551                 'get_document_converter_classes',
552                 'get_next_converter',
553             ]);
555         $converter->method('get_document_converter_classes')->willReturn([]);
556         $converter->method('get_next_converter')
557             ->will($this->onConsecutiveCalls(
558                 get_class($converterinstance),
559                 get_class($converterinstance2)
560             ));
562         $file = $this->create_stored_file('example content', 'example', [
563                 'mimetype' => null,
564             ]);
566         $conversion = $this->get_testable_conversion([
567                 'get_converter_instance',
568                 'get_status',
569             ]);
570         $conversion->set_sourcefile($file);
571         $conversion->set('targetformat', 'target');
572         $conversion->set('status', conversion::STATUS_PENDING);
573         $conversion->create();
575         $conversion->method('get_status')
576             ->will($this->onConsecutiveCalls(
577                 // Initial status check.
578                 conversion::STATUS_PENDING,
579                 // Second check to make sure it's still pending after polling.
580                 conversion::STATUS_PENDING,
581                 // First one fails.
582                 conversion::STATUS_FAILED,
583                 // Second one succeeds.
584                 conversion::STATUS_COMPLETE,
585                 // And the final result checked in this unit test.
586                 conversion::STATUS_COMPLETE
587             ));
589         $conversion->method('get_converter_instance')
590             ->will($this->onConsecutiveCalls(
591                 $converterinstance,
592                 $converterinstance2
593             ));
595         $converterinstance->expects($this->once())
596             ->method('start_document_conversion');
597         $converterinstance->expects($this->never())
598             ->method('poll_conversion_status');
599         $converterinstance2->expects($this->once())
600             ->method('start_document_conversion');
601         $converterinstance2->expects($this->never())
602             ->method('poll_conversion_status');
604         $converter->poll_conversion($conversion);
606         $this->assertEquals(conversion::STATUS_COMPLETE, $conversion->get('status'));
607     }
609     /**
610      * Test the start_conversion with a single converter which succeeds.
611      */
612     public function test_start_conversion_one_supported_success() {
613         $this->resetAfterTest();
615         $converter = $this->get_testable_mock([
616                 'get_document_converter_classes',
617             ]);
619         $converter->method('get_document_converter_classes')
620             ->willReturn([\core_file_converter_type_successful::class]);
622         $file = $this->create_stored_file('example content', 'example', [
623                 'mimetype' => null,
624             ]);
626         $conversion = $converter->start_conversion($file, 'target');
628         $this->assertEquals(conversion::STATUS_COMPLETE, $conversion->get('status'));
629     }
631     /**
632      * Test the start_conversion with a single converter which failes.
633      */
634     public function test_start_conversion_one_supported_failure() {
635         $this->resetAfterTest();
637         $converter = $this->get_testable_mock([
638                 'get_document_converter_classes',
639             ]);
641         $mock = $this->get_mocked_converter(['start_document_conversion']);
642         $converter->method('get_document_converter_classes')
643             ->willReturn([\core_file_converter_type_failed::class]);
645         $file = $this->create_stored_file('example content', 'example', [
646                 'mimetype' => null,
647             ]);
649         $conversion = $converter->start_conversion($file, 'target');
651         $this->assertEquals(conversion::STATUS_FAILED, $conversion->get('status'));
652     }
654     /**
655      * Test the start_conversion with two converters - fail, then succeed.
656      */
657     public function test_start_conversion_two_supported() {
658         $this->resetAfterTest();
660         $converter = $this->get_testable_mock([
661                 'get_document_converter_classes',
662             ]);
664         $mock = $this->get_mocked_converter(['start_document_conversion']);
665         $converter->method('get_document_converter_classes')
666             ->willReturn([
667                 \core_file_converter_type_failed::class,
668                 \core_file_converter_type_successful::class,
669             ]);
671         $file = $this->create_stored_file('example content', 'example', [
672                 'mimetype' => null,
673             ]);
675         $conversion = $converter->start_conversion($file, 'target');
677         $this->assertEquals(conversion::STATUS_COMPLETE, $conversion->get('status'));
678     }
680     /**
681      * Ensure that get_next_converter returns false when no converters are available.
682      */
683     public function test_get_next_converter_no_converters() {
684         $rcm = new \ReflectionMethod(converter::class, 'get_next_converter');
685         $rcm->setAccessible(true);
687         $converter = new \core_files\converter();
688         $result = $rcm->invoke($converter, [], null);
689         $this->assertFalse($result);
690     }
692     /**
693      * Ensure that get_next_converter returns false when already on the
694      * only converter.
695      */
696     public function test_get_next_converter_only_converters() {
697         $rcm = new \ReflectionMethod(converter::class, 'get_next_converter');
698         $rcm->setAccessible(true);
700         $converter = new converter();
701         $result = $rcm->invoke($converter, ['example'], 'example');
702         $this->assertFalse($result);
703     }
705     /**
706      * Ensure that get_next_converter returns false when already on the
707      * last converter.
708      */
709     public function test_get_next_converter_last_converters() {
710         $rcm = new \ReflectionMethod(converter::class, 'get_next_converter');
711         $rcm->setAccessible(true);
713         $converter = new converter();
714         $result = $rcm->invoke($converter, ['foo', 'example'], 'example');
715         $this->assertFalse($result);
716     }
718     /**
719      * Ensure that get_next_converter returns the next vlaue when in a
720      * current converter.
721      */
722     public function test_get_next_converter_middle_converters() {
723         $rcm = new \ReflectionMethod(converter::class, 'get_next_converter');
724         $rcm->setAccessible(true);
726         $converter = new converter();
727         $result = $rcm->invoke($converter, ['foo', 'bar', 'baz', 'example'], 'bar');
728         $this->assertEquals('baz', $result);
729     }
730     /**
731      *
732      * Ensure that get_next_converter returns the next vlaue when in a
733      * current converter.
734      */
735     public function test_get_next_converter_first() {
736         $rcm = new \ReflectionMethod(converter::class, 'get_next_converter');
737         $rcm->setAccessible(true);
739         $converter = new converter();
740         $result = $rcm->invoke($converter, ['foo', 'bar', 'baz', 'example']);
741         $this->assertEquals('foo', $result);
742     }
745 class core_file_converter_requirements_test_base implements \core_files\converter_interface {
747     /**
748      * Whether the plugin is configured and requirements are met.
749      *
750      * @return  bool
751      */
752     public static function are_requirements_met() {
753         return false;
754     }
756     /**
757      * Convert a document to a new format and return a conversion object relating to the conversion in progress.
758      *
759      * @param   conversion $conversion The file to be converted
760      * @return  conversion
761      */
762     public function start_document_conversion(conversion $conversion) {
763     }
765     /**
766      * Poll an existing conversion for status update.
767      *
768      * @param   conversion $conversion The file to be converted
769      * @return  conversion
770      */
771     public function poll_conversion_status(conversion $conversion) {
772     }
774     /**
775      * Whether a file conversion can be completed using this converter.
776      *
777      * @param   string $from The source type
778      * @param   string $to The destination type
779      * @return  bool
780      */
781     public static function supports($from, $to) {
782         return false;
783     }
785     /**
786      * A list of the supported conversions.
787      *
788      * @return  string
789      */
790     public function  get_supported_conversions() {
791         return [];
792     }
796 /**
797  * Test class for converter support with requirements are not met.
798  *
799  * @package    core_files
800  * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
801  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
802  */
803 class core_file_converter_requirements_not_met_test extends core_file_converter_requirements_test_base {
806 /**
807  * Test class for converter support with requirements met and conversion not supported.
808  *
809  * @package    core_files
810  * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
811  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
812  */
813 class core_file_converter_type_not_supported_test extends core_file_converter_requirements_test_base {
815     /**
816      * Whether the plugin is configured and requirements are met.
817      *
818      * @return  bool
819      */
820     public static function are_requirements_met() {
821         return true;
822     }
825 /**
826  * Test class for converter support with requirements met and conversion supported.
827  *
828  * @package    core_files
829  * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
830  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
831  */
832 class core_file_converter_type_supported_test extends core_file_converter_requirements_test_base {
834     /**
835      * Whether the plugin is configured and requirements are met.
836      *
837      * @return  bool
838      */
839     public static function are_requirements_met() {
840         return true;
841     }
843     /**
844      * Whether a file conversion can be completed using this converter.
845      *
846      * @param   string $from The source type
847      * @param   string $to The destination type
848      * @return  bool
849      */
850     public static function supports($from, $to) {
851         return true;
852     }
855 /**
856  * Test class for converter support with requirements met and successful conversion.
857  *
858  * @package    core_files
859  * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
860  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
861  */
862 class core_file_converter_type_successful extends core_file_converter_requirements_test_base {
864     /**
865      * Convert a document to a new format and return a conversion object relating to the conversion in progress.
866      *
867      * @param   conversion $conversion The file to be converted
868      * @return  conversion
869      */
870     public function start_document_conversion(conversion $conversion) {
871         $conversion->set('status', conversion::STATUS_COMPLETE);
873         return $conversion;
874     }
876     /**
877      * Whether a file conversion can be completed using this converter.
878      *
879      * @param   string $from The source type
880      * @param   string $to The destination type
881      * @return  bool
882      */
883     public static function supports($from, $to) {
884         return true;
885     }
888 /**
889  * Test class for converter support with requirements met and failed conversion.
890  *
891  * @package    core_files
892  * @copyright  2017 Andrew nicols <andrew@nicols.co.uk>
893  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
894  */
895 class core_file_converter_type_failed extends core_file_converter_requirements_test_base {
897     /**
898      * Whether the plugin is configured and requirements are met.
899      *
900      * @return  bool
901      */
902     public static function are_requirements_met() {
903         return true;
904     }
906     /**
907      * Convert a document to a new format and return a conversion object relating to the conversion in progress.
908      *
909      * @param   conversion $conversion The file to be converted
910      * @return  conversion
911      */
912     public function start_document_conversion(conversion $conversion) {
913         $conversion->set('status', conversion::STATUS_FAILED);
915         return $conversion;
916     }
918     /**
919      * Whether a file conversion can be completed using this converter.
920      *
921      * @param   string $from The source type
922      * @param   string $to The destination type
923      * @return  bool
924      */
925     public static function supports($from, $to) {
926         return true;
927     }