Proyectos de Subversion Moodle

<?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/>.

declare(strict_types=1);

namespace core\content\export\exportable_items;

use advanced_testcase;

use context;

use context_system;

use core\content\export\zipwriter;

use core\content\export\exported_item;

use moodle_url;

use stdClass;

/**

 * Unit tests for the `exportable_filearea` export item class.

 *

 * @package     core

 * @category    test

 * @copyright   2020 Andrew Nicols <andrew@nicols.co.uk>

 * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 * @covers      \core\content\export\exportable_items\exportable_filearea

 */

final class exportable_filearea_test extends advanced_testcase {

    /**

     * Ensure that the the exportable_filearea does not fetch files when none exist.

     */

    public function test_no_files(): void {

        $exportable = new exportable_filearea(

            context_system::instance(),

            'fake',

            'Some fake filearea',

            'filearea',

            1

        );

        $this->assertInstanceOf(exportable_filearea::class, $exportable);

    }

    /**

     * Ensure that the exportable_filearea returns all stored_file items for only the specified itemid, but those which

     * are not included in the archive receive a pluginfile URL.

     */

    public function test_specified_itemid_excluded_from_zip(): void {

        $this->resetAfterTest(true);

        // Setup for test.

        $user = $this->getDataGenerator()->create_user();

        $context = context_system::instance();

        $component = 'fake';

        $filearea = 'myfirstfilearea';

        $files1 = $this->create_files(context_system::instance(), $component, $filearea, 1);

        $files2 = $this->create_files(context_system::instance(), $component, $filearea, 2);

        $files3 = $this->create_files(context_system::instance(), $component, $filearea, 3);

        $otherfiles2 = $this->create_files(context_system::instance(), $component, "other{$filearea}", 2);

        $exportable = new exportable_filearea(

            $context,

            $component,

            'Some filearea description',

            $filearea,

            2

        );

        // There is only one exportable.

        $this->assertInstanceOf(exportable_filearea::class, $exportable);

        $file2 = reset($files2);

        $item = $this->assert_exportable_matches_file($component, $user, $context, $filearea, '', $files2, false, $exportable);

        $this->assertCount(count($files2), $item->get_all_files());

        $comparisonurl = new moodle_url('/tokenpluginfile.php/');

        foreach ($item->get_all_files() as $url) {

            $this->assertStringStartsWith($comparisonurl->out(false), $url->filepath);

        }

    }

    /**

     * Ensure that the exportable_filearea returns all stored_file items for only the specified itemid.

     */

    public function test_specified_itemid(): void {

        $this->resetAfterTest(true);

        // Setup for test.

        $user = $this->getDataGenerator()->create_user();

        $context = context_system::instance();

        $component = 'fake';

        $filearea = 'myfirstfilearea';

        $files1 = $this->create_files(context_system::instance(), $component, $filearea, 1);

        $files2 = $this->create_files(context_system::instance(), $component, $filearea, 2);

        $files3 = $this->create_files(context_system::instance(), $component, $filearea, 3);

        $otherfiles2 = $this->create_files(context_system::instance(), $component, "other{$filearea}", 2);

        $exportable = new exportable_filearea(

            $context,

            $component,

            'Some filearea description',

            $filearea,

            2

        );

        // There is only one exportable.

        $this->assertInstanceOf(exportable_filearea::class, $exportable);

        $file2 = reset($files2);

        $item = $this->assert_exportable_matches_file($component, $user, $context, $filearea, '', $files2, true, $exportable);

        $this->assertCount(count($files2), $item->get_all_files());

    }

    /**

     * Ensure that the exportable_filearea returns all stored_files into the correct file location.

     */

    public function test_in_subdir(): void {

        $this->resetAfterTest(true);

        // Setup for test.

        $user = $this->getDataGenerator()->create_user();

        $context = context_system::instance();

        $component = 'fake';

        $filearea = 'myfirstfilearea';

        $subdir = 'a/path/to/my/subdir';

        $files1 = $this->create_files(context_system::instance(), $component, $filearea, 1);

        $files2 = $this->create_files(context_system::instance(), $component, $filearea, 2);

        $files3 = $this->create_files(context_system::instance(), $component, $filearea, 3);

        $exportable = new exportable_filearea(

            $context,

            $component,

            'Some filearea description',

            $filearea,

            2,

            2,

            $subdir

        );

        // There is only one exportable.

        $this->assertInstanceOf(exportable_filearea::class, $exportable);

        $item = $this->assert_exportable_matches_file($component, $user, $context, $filearea, $subdir, $files2, true, $exportable);

        $this->assertCount(count($files2), $item->get_all_files());

    }

    /**

     * Create files for use in testing.

     *

     * @param   context $context

     * @param   string $component

     * @param   string $filearea

     * @param   int $itemid

     * @param   int $count

     * @return  filearea[]

     */

    protected function create_files(context $context, string $component, string $filearea, int $itemid, int $count = 1): array {

        $fs = get_file_storage();

        $files = [];

        for ($i = 0; $i < $count; $i++) {

            $filepath = '/';

            for ($j = 0; $j < $i; $j++) {

                $filepath .= "{$j}/";

            }

            $files[] = $fs->create_file_from_string(

                (object) [

                    'contextid' => $context->id,

                    'component' => $component,

                    'filearea' => $filearea,

                    'filepath' => $filepath,

                    'filename' => "file.txt",

                    'itemid' => $itemid,

                ],

                "File content: {$i}"

            );

        }

        return $files;

    }

    /**

     * Assert that the supplied expotable matches the supplied file.

     *

     * @param   string $component

     * @param   stdClass $user

     * @param   context $context

     * @param   string $filearea

     * @param   string $subdir

     * @param   stored_file[] $expectedfiles

     * @param   bool $addfilestozip Whether to allow files to be added to the archive

     * @param   exportable_filearea $exportable

     * @return  exported_item

     */

    protected function assert_exportable_matches_file(

        string $component,

        stdClass $user,

        context $context,

        string $filearea,

        string $subdir,

        array $expectedfiles,

        bool $addfilestozip,

        exportable_filearea $exportable

    ): exported_item {

        $archive = $this->getMockBuilder(zipwriter::class)

            ->setConstructorArgs([$this->getMockBuilder(\ZipStream\ZipStream::class)->getmock()])

            ->onlyMethods([

                'add_file_from_stored_file',

                'is_file_in_archive',

            ])

            ->getMock();

        $archive->expects($this->any())

            ->method('is_file_in_archive')

            ->willReturn($addfilestozip);

        $storedfileargs = [];

        foreach ($expectedfiles as $file) {

            $filepathinzip = $subdir . '/' . $file->get_filearea() . '/' . $file->get_filepath() . $file->get_filename();

            $filepathinzip = ltrim(preg_replace('#/+#', '/', $filepathinzip), '/');

            $storedfileargs[] = [

                $context,

                $filepathinzip,

                $file,

            ];

        }

        $invocations = $this->exactly(count($expectedfiles));

        $archive->expects($invocations)

            ->method('add_file_from_stored_file')

            ->willReturnCallback(function (...$args) use ($invocations, $storedfileargs) {

                $this->assertEquals($storedfileargs[self::getInvocationCount($invocations) - 1], $args);

            });

        return $exportable->add_to_archive($archive);

    }

}