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

namespace communication_matrix;

use communication_matrix\local\command;
use communication_matrix\local\spec\v1p7;
use communication_matrix\local\spec\features;
use communication_matrix\tests\fixtures\mocked_matrix_client;
use core\http_client;
use GuzzleHttp\Handler\MockHandler;
use GuzzleHttp\HandlerStack;
use GuzzleHttp\Middleware;
use GuzzleHttp\Psr7\Response;
use moodle_exception;

defined('MOODLE_INTERNAL') || die();
require_once(__DIR__ . '/matrix_client_test_trait.php');

/**
 * Tests for the matrix_client class.
 *
 * @package    communication_matrix
 * @category   test
 * @copyright  2023 Andrew Lyons <andrew@nicols.co.uk>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 * @covers \communication_matrix\matrix_client
 * @coversDefaultClass \communication_matrix\matrix_client
 */
class matrix_client_test extends \advanced_testcase {
    use matrix_client_test_trait;

    /**
     * Data provider for valid calls to ::instance.
     * @return array
     */
    public static function instance_provider(): array {
        $testcases = [
            'Standard versions' => [
                null,
                v1p7::class,
            ],
        ];

        // Remove a couple of versions.
        $versions = self::get_current_versions();
        array_pop($versions);
        array_pop($versions);

        $testcases['Older server'] = [
            $versions,
            array_key_last($versions),
        ];

        // Limited version compatibility, including newer than we support now.
        $testcases['Newer versions with crossover'] = [
            [
                'v1.6',
                'v1.7',
                'v7.9',
            ],
            \communication_matrix\local\spec\v1p7::class,
        ];

        return $testcases;
    }

    /**
     * Test that the instance method returns a valid instance for the given versions.
     *
     * @dataProvider instance_provider
     * @param array|null $versions
     * @param string $expectedversion
     */
    public function test_instance(
        ?array $versions,
        string $expectedversion,
    ): void {
        // Create a mock and queue two responses.

        $mock = new MockHandler([
            $this->get_mocked_version_response($versions),
        ]);
        $handlerstack = HandlerStack::create($mock);
        $container = [];
        $history = Middleware::history($container);
        $handlerstack->push($history);
        $client = new http_client(['handler' => $handlerstack]);
        mocked_matrix_client::set_client($client);

        $instance = mocked_matrix_client::instance(
            'https://example.com',
            'testtoken',
        );

        $this->assertInstanceOf(matrix_client::class, $instance);

        // Only the version API has been called.
        $this->assertCount(1, $container);
        $request = reset($container);
        $this->assertEquals('/_matrix/client/versions', $request['request']->getUri()->getPath());

        // The client should be a v1p7 client as that is the highest compatible version.
        $this->assertInstanceOf($expectedversion, $instance);
    }

    /**
     * Test that the instance method returns a valid instance for the given versions.
     */
    public function test_instance_cached(): void {
        $mock = new MockHandler([
            $this->get_mocked_version_response(),
            $this->get_mocked_version_response(),
        ]);
        $handlerstack = HandlerStack::create($mock);
        $container = [];
        $history = Middleware::history($container);
        $handlerstack->push($history);
        $client = new http_client(['handler' => $handlerstack]);
        mocked_matrix_client::set_client($client);

        $instance = mocked_matrix_client::instance('https://example.com', 'testtoken');

        $this->assertInstanceOf(matrix_client::class, $instance);

        // Only the version API has been called.
        $this->assertCount(1, $container);

        // Call the API again. It should not lead to additional fetches.
        $instance = mocked_matrix_client::instance('https://example.com', 'testtoken');
        $instance = mocked_matrix_client::instance('https://example.com', 'testtoken');
        $this->assertCount(1, $container);

        // But a different endpoint will.
        $instance = mocked_matrix_client::instance('https://example.org', 'testtoken');
        $this->assertCount(2, $container);
    }

    /**
     * Test that the instance method throws an appropriate exception if no support is found.
     */
    public function test_instance_no_support(): void {
        // Create a mock and queue two responses.

        $mock = new MockHandler([
            $this->get_mocked_version_response(['v99.9']),
        ]);
        $handlerstack = HandlerStack::create($mock);
        $container = [];
        $history = Middleware::history($container);
        $handlerstack->push($history);
        $client = new http_client(['handler' => $handlerstack]);
        mocked_matrix_client::set_client($client);

        $this->expectException(moodle_exception::class);
        $this->expectExceptionMessage('No supported Matrix API versions found.');

        mocked_matrix_client::instance(
            'https://example.com',
            'testtoken',
        );
    }

    /**
     * Test the feature implementation check methods.
     *
     * @covers ::implements_feature
     * @covers ::get_supported_versions
     * @dataProvider implements_feature_provider
     * @param string $version
     * @param array|string $features
     * @param bool $expected
     */
    public function test_implements_feature(
        string $version,
        array|string $features,
        bool $expected,
    ): void {
        $instance = $this->get_mocked_instance_for_version($version);
        $this->assertEquals($expected, $instance->implements_feature($features));
    }

    /**
     * Test the feature implementation requirement methods.
     *
     * @covers ::implements_feature
     * @covers ::get_supported_versions
     * @covers ::require_feature
     * @dataProvider implements_feature_provider
     * @param string $version
     * @param array|string $features
     * @param bool $expected
     */
    public function test_require_feature(
        string $version,
        array|string $features,
        bool $expected,
    ): void {
        $instance = $this->get_mocked_instance_for_version($version);

        if ($expected) {
            $this->assertEmpty($instance->require_feature($features));
        } else {
            $this->expectException('moodle_exception');
            $instance->require_feature($features);
        }
    }

    /**
     * Test the feature implementation requirement methods for a require all.
     *
     * @covers ::implements_feature
     * @covers ::get_supported_versions
     * @covers ::require_feature
     * @covers ::require_features
     * @dataProvider require_features_provider
     * @param string $version
     * @param array|string $features
     * @param bool $expected
     */
    public function test_require_features(
        string $version,
        array|string $features,
        bool $expected,
    ): void {
        $instance = $this->get_mocked_instance_for_version($version);

        if ($expected) {
            $this->assertEmpty($instance->require_features($features));
        } else {
            $this->expectException('moodle_exception');
            $instance->require_features($features);
        }
    }

    /**
     * Data provider for feature implementation check tests.
     *
     * @return array
     */
    public static function implements_feature_provider(): array {
        return [
            'Basic supported feature' => [
                'v1.7',
                features\matrix\media_create_v1::class,
                true,
            ],
            'Basic unsupported feature' => [
                'v1.6',
                features\matrix\media_create_v1::class,
                false,
            ],
            '[supported] as array' => [
                'v1.6',
                [features\matrix\create_room_v3::class],
                true,
            ],
            '[supported, supported] as array' => [
                'v1.6',
                [
                    features\matrix\create_room_v3::class,
                    features\matrix\update_room_avatar_v3::class,
                ],
                true,
            ],
            '[unsupported] as array' => [
                'v1.6',
                [
                    features\matrix\media_create_v1::class,
                ],
                false,
            ],
            '[unsupported, supported] as array' => [
                'v1.6',
                [
                    features\matrix\media_create_v1::class,
                    features\matrix\update_room_avatar_v3::class,
                ],
                true,
            ],
        ];
    }

    /**
     * Data provider for feature implementation check tests.
     *
     * @return array
     */
    public static function require_features_provider(): array {
        // We'll just add to the standard testcases.
        $testcases = array_map(static function (array $testcase): array {
            $testcase[1] = [$testcase[1]];
            return $testcase;
        }, self::implements_feature_provider());

        $testcases['Require many supported features'] = [
            'v1.6',
            [
                features\matrix\create_room_v3::class,
                features\matrix\update_room_avatar_v3::class,
            ],
            true,
        ];

        $testcases['Require many including an unsupported feature'] = [
            'v1.6',
            [
                features\matrix\create_room_v3::class,
                features\matrix\media_create_v1::class,
            ],
            false,
        ];

        $testcases['Require many including an unsupported feature which has an alternate'] = [
            'v1.6',
            [
                features\matrix\create_room_v3::class,
                [
                    features\matrix\media_create_v1::class,
                    features\matrix\update_room_avatar_v3::class,
                ],
            ],
            true,
        ];

        return $testcases;
    }

    /**
     * Test the get_version method.
     *
     * @param string $version
     * @param string $expectedversion
     * @dataProvider get_version_provider
     * @covers ::get_version
     * @covers ::get_version_from_classname
     */
    public function test_get_version(
        string $version,
        string $expectedversion,
    ): void {
        $instance = $this->get_mocked_instance_for_version($version);
        $this->assertEquals($expectedversion, $instance->get_version());
    }

    /**
     * Data provider for get_version tests.
     *
     * @return array
     */
    public static function get_version_provider(): array {
        return [
            ['v1.1', '1.1'],
            ['v1.7', '1.7'],
        ];
    }

    /**
     * Tests the meets_version method.
     *
     * @param string $version The version of the API to test against
     * @param string $testversion The version to test
     * @param bool $expected Whether the version meets the requirement
     * @dataProvider meets_version_provider
     * @covers ::meets_version
     */
    public function test_meets_version(
        string $version,
        string $testversion,
        bool $expected,
    ): void {
        $instance = $this->get_mocked_instance_for_version($version);
        $this->assertEquals($expected, $instance->meets_version($testversion));
    }

    /**
     * Tests the requires_version method.
     *
     * @param string $version The version of the API to test against
     * @param string $testversion The version to test
     * @param bool $expected Whether the version meets the requirement
     * @dataProvider meets_version_provider
     * @covers ::requires_version
     */
    public function test_requires_version(
        string $version,
        string $testversion,
        bool $expected,
    ): void {
        $instance = $this->get_mocked_instance_for_version($version);

        if ($expected) {
            $this->assertEmpty($instance->requires_version($testversion));
        } else {
            $this->expectException('moodle_exception');
            $instance->requires_version($testversion);
        }
    }

    /**
     * Data provider for meets_version tests.
     *
     * @return array
     */
    public static function meets_version_provider(): array {
        return [
            'Same version' => ['v1.1', '1.1', true],
            'Same version latest' => ['v1.7', '1.7', true],
            'Newer version rejected' => ['v1.1', '1.7', false],
            'Older version accepted' => ['v1.7', '1.1', true],
        ];
    }

    /**
     * Test the execute method with a command.
     *
     * @covers ::execute
     */
    public function test_command_is_executed(): void {
        $historycontainer = [];
        $mock = new MockHandler();

        $instance = $this->get_mocked_instance_for_version('v1.6', $historycontainer, $mock);
        $command = new command(
            $instance,
            method: 'GET',
            endpoint: 'test/endpoint',
            params: [
                'test' => 'test',
            ],
        );

        $mock->append(new Response(200));

        $rc = new \ReflectionClass($instance);
        $rcm = $rc->getMethod('execute');
        $result = $rcm->invoke($instance, $command);

        $this->assertEquals(200, $result->getStatusCode());
        $this->assertCount(1, $historycontainer);
        $request = array_shift($historycontainer);
        $this->assertEquals('GET', $request['request']->getMethod());
        $this->assertEquals('/test/endpoint', $request['request']->getUri()->getPath());
    }
}