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 search_solr;

/**

 * Solr search engine unit tests that can operate using a mock http_client and without creating a

 * search manager instance.

 *

 * These tests can run without the solr PHP extension.

 *

 * All 'realistic' tests of searching (e.g. index something then see if it is found by search)

 * require a real Solr instance for testing and should be placed in {@see engine_test}.

 * Tests that don't rely heavily on the real search functionality, or where we need to simulate

 * multiple different ways of configuring the search infrastructure, or unusual failures in

 * communication, may be better suited for this mock test approach.

 *

 * @package search_solr

 * @category test

 * @copyright 2024 The Open University

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

 * @covers \search_solr\engine

 */

final class mock_engine_test extends \advanced_testcase {

    protected function setUp(): void {

        parent::setUp();

        $this->resetAfterTest();

        // Minimal configuration.

        set_config('server_hostname', 'host.invalid', 'search_solr');

        set_config('indexname', 'myindex', 'search_solr');

        // This is not necessary on my setup but in GitHub Actions, the server_port is set to ''

        // instead of default 8983.

        set_config('server_port', '8983', 'search_solr');

    }

    /**

     * Tests {@see engine::get_server_url}.

     */

    public function test_get_server_url(): void {

        // Basic URL.

        $engine = new engine();

        $this->assertEquals(

            'http://host.invalid:8983/solr/',

            $engine->get_server_url('')->out(false),

        );

        // Same but with specified path.

        $this->assertEquals(

            'http://host.invalid:8983/solr/twiddle',

            $engine->get_server_url('twiddle')->out(false),

        );

        // Slash at start of path will be stripped.

        $this->assertEquals(

            'http://host.invalid:8983/solr/twiddle',

            $engine->get_server_url('/twiddle')->out(false),

        );

        // Turn on https. Due to the way the port setting works, which is bad, this will still have

        // the default not-secure port (even though the 'default' on the setting page will now be

        // shown as 8443, hmm). User has to change it manually.

        set_config('secure', '1', 'search_solr');

        $engine = new engine();

        $this->assertEquals(

            'https://host.invalid:8983/solr/',

            $engine->get_server_url('')->out(false),

        );

        // Change port from default. User has to do this manually when enabling secure.

        set_config('server_port', '8443', 'search_solr');

        $engine = new engine();

        $this->assertEquals(

            'https://host.invalid:8443/solr/',

            $engine->get_server_url('')->out(false),

        );

    }

    /**

     * Tests {@see engine::get_connection_url}.

     */

    public function test_get_connection_url(): void {

        // Basic URL.

        $engine = new engine();

        $this->assertEquals(

            'http://host.invalid:8983/solr/myindex/',

            $engine->get_connection_url('')->out(false),

        );

    }

    /**

     * Tests {@see engine::raw_get_request()} with no auth settings.

     */

    public function test_raw_get_request_no_auth(): void {

        $engine = new engine();

        $response = $this->createStub(\Psr\Http\Message\ResponseInterface::class);

        // When there is no auth, there aren't many options, just timeout.

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willReturn($response);

        $this->assertEquals($response, $engine->raw_get_request('frog'));

        // Timeout can be changed in config.

        set_config('server_timeout', '10', 'search_solr');

        $engine = new engine();

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 10,

                'read_timeout' => 10,

            ],

        )->willReturn($response);

        $this->assertEquals($response, $engine->raw_get_request('frog'));

    }

    /**

     * Tests {@see engine::raw_get_request()} with basic auth settings.

     */

    public function test_raw_get_request_basic_auth(): void {

        set_config('server_username', 'u', 'search_solr');

        set_config('server_password', 'p', 'search_solr');

        $engine = new engine();

        $response = $this->createStub(\Psr\Http\Message\ResponseInterface::class);

        // Basic auth works with an 'auth' option.

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

                'auth' => ['u', 'p'],

            ],

        )->willReturn($response);

        $this->assertEquals($response, $engine->raw_get_request('frog'));

    }

    /**

     * Tests {@see engine::raw_get_request()} with a supplied user certificate.

     */

    public function test_raw_get_request_user_cert(): void {

        set_config('secure', '1', 'search_solr');

        set_config('ssl_cert', '/tmp/cert.pem', 'search_solr');

        $engine = new engine();

        $response = $this->createStub(\Psr\Http\Message\ResponseInterface::class);

        // User cert auth uses the 'cert' parameter, with or without a key.

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'https://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

                'cert' => '/tmp/cert.pem',

            ],

        )->willReturn($response);

        $this->assertEquals($response, $engine->raw_get_request('frog'));

    }

    /**

     * Tests {@see engine::raw_get_request()} with a user key (with or without password).

     */

    public function test_raw_get_request_user_key(): void {

        set_config('secure', '1', 'search_solr');

        set_config('ssl_key', '/tmp/key.pem', 'search_solr');

        $engine = new engine();

        $response = $this->createStub(\Psr\Http\Message\ResponseInterface::class);

        // User cert auth uses the 'cert' parameter, with or without a key.

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'https://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

                'ssl_key' => '/tmp/key.pem',

            ],

        )->willReturn($response);

        $this->assertEquals($response, $engine->raw_get_request('frog'));

        set_config('ssl_keypassword', 'frog', 'search_solr');

        $engine = new engine();

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'https://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

                'ssl_key' => ['/tmp/key.pem', 'frog'],

            ],

        )->willReturn($response);

        $this->assertEquals($response, $engine->raw_get_request('frog'));

    }

    /**

     * Tests {@see engine::raw_get_request()} with a certificate bundle for verifying the server.

     */

    public function test_raw_get_request_certificate_bundle(): void {

        set_config('secure', '1', 'search_solr');

        set_config('ssl_cainfo', '/tmp/allthecerts.pem', 'search_solr');

        $engine = new engine();

        $response = $this->createStub(\Psr\Http\Message\ResponseInterface::class);

        // User cert auth uses the 'cert' parameter, with or without a key.

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'https://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

                'verify' => '/tmp/allthecerts.pem',

            ],

        )->willReturn($response);

        $this->assertEquals($response, $engine->raw_get_request('frog'));

    }

    /**

     * Tests {@see engine::raw_get_request()} with a certificate folder for verifying the server.

     * Guzzle doesn't support a certificate folder (curl does) so this code makes a bundle in the

     * localcache area.

     */

    public function test_raw_get_request_certificate_folder(): void {

        global $CFG;

        // Make a directory full of fake .pem files.

        $temp = make_request_directory();

        file_put_contents($temp . '/0.pem', "PEM0\n");

        file_put_contents($temp . '/1.pem', "PEM1\n");

        file_put_contents($temp . '/2.txt', "TXT2\n");

        set_config('secure', '1', 'search_solr');

        set_config('ssl_capath', $temp, 'search_solr');

        $response = $this->createStub(\Psr\Http\Message\ResponseInterface::class);

        // Party like it's 13 February 2009.

        $time = 1234567890;

        $this->mock_clock_with_frozen($time);

        // User cert auth uses the 'cert' parameter, with or without a key.

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        // The filename is the hash of the capath setting plus current time.

        $combinedfile = $CFG->dataroot .

            '/localcache/search_solr/capath.' .

            sha1($temp) .

            '.1234567890';

        $mockedclient->expects($this->once())->method('get')->with(

            'https://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

                'verify' => $combinedfile,

            ],

        )->willReturn($response);

        $engine = new engine();

        $this->assertEquals($response, $engine->raw_get_request('frog'));

        // Check the file actually is the .pem files concatenated.

        $this->assertEquals("PEM0\n\n\nPEM1\n\n\n", file_get_contents($combinedfile));

        // Let's add another .pem file.

        file_put_contents($temp . '/3.pem', "PEM3\n");

        // 9 minutes 59 seconds later, it will still use the cached version (same file).

        $time += 599;

        $this->mock_clock_with_frozen($time);

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'https://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

                'verify' => $combinedfile,

            ],

        )->willReturn($response);

        $engine = new engine();

        $this->assertEquals($response, $engine->raw_get_request('frog'));

        $this->assertEquals("PEM0\n\n\nPEM1\n\n\n", file_get_contents($combinedfile));

        // 10 minutes later, it will make a new cached version.

        $time += 1;

        $this->mock_clock_with_frozen($time);

        $combinedfile2 = $CFG->dataroot .

            '/localcache/search_solr/capath.' .

            sha1($temp) .

            '.1234568490';

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'https://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

                'verify' => $combinedfile2,

            ],

        )->willReturn($response);

        $engine = new engine();

        $this->assertEquals($response, $engine->raw_get_request('frog'));

        $this->assertEquals("PEM0\n\n\nPEM1\n\n\nPEM3\n\n\n", file_get_contents($combinedfile2));

        // The old file is still there.

        $this->assertEquals("PEM0\n\n\nPEM1\n\n\n", file_get_contents($combinedfile));

        // Go another minute. We're still using the same combined file...

        $time += 60;

        $this->mock_clock_with_frozen($time);

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'https://host.invalid:8983/solr/frog',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

                'verify' => $combinedfile2,

            ],

        )->willReturn($response);

        $engine = new engine();

        $this->assertEquals($response, $engine->raw_get_request('frog'));

        $this->assertEquals("PEM0\n\n\nPEM1\n\n\nPEM3\n\n\n", file_get_contents($combinedfile2));

        // But now it will delete the old one.

        $this->assertFalse(file_exists($combinedfile));

    }

    /**

     * Tests the {@see engine::get_status()} function when there is an exception connecting.

     */

    public function test_get_status_exception_connecting(): void {

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/admin/cores',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willThrowException(new \coding_exception('ex'));

        $engine = new engine();

        $status = $engine->get_status();

        $this->assertFalse($status['connected']);

        $this->assertFalse($status['foundcore']);

        $this->assertEquals(

            'Exception occurred: Coding error detected, it must be fixed by a programmer: ex',

            $status['error'],

        );

        $this->assertInstanceOf(\coding_exception::class, $status['exception']);

    }

    /**

     * Tests the {@see engine::get_status()} function when the server returns 404.

     */

    public function test_get_status_bad_http_status(): void {

        $response = $this->createStub(\Psr\Http\Message\ResponseInterface::class);

        $response->method('getStatusCode')->willReturn(404);

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/admin/cores',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willReturn($response);

        $engine = new engine();

        $status = $engine->get_status();

        $this->assertFalse($status['connected']);

        $this->assertFalse($status['foundcore']);

        $this->assertEquals('Unsuccessful status code: 404', $status['error']);

    }

    /**

     * Creates a mock ResponseInterface with a body containing the specified string.

     *

     * @param string $body Body content

     * @return \Psr\Http\Message\ResponseInterface Interface

     */

    protected function get_fake_response(string $body): \Psr\Http\Message\ResponseInterface {

        $response = $this->createStub(\Psr\Http\Message\ResponseInterface::class);

        $response->method('getStatusCode')->willReturn(200);

        $stream = $this->createStub(\Psr\Http\Message\StreamInterface::class);

        $response->method('getBody')->willReturn($stream);

        $stream->method('getContents')->willReturn($body);

        return $response;

    }

    /**

     * Tests the {@see engine::get_status()} function when the server returns invalid JSON.

     * In real life this would only be likely to happen if the server is down and a load balancer

     * in front of it for some crazy reason interposes a page with status 200.

     */

    public function test_get_status_not_json(): void {

        $response = $this->get_fake_response('notjson');

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/admin/cores',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willReturn($response);

        $engine = new engine();

        $status = $engine->get_status();

        $this->assertFalse($status['connected']);

        $this->assertFalse($status['foundcore']);

        $this->assertEquals('Invalid JSON', $status['error']);

    }

    /**

     * Tests the {@see engine::get_status()} function when the server returns an empty response.

     *

     * This could maybe happen if the server has been configured, but not fully initialised.

     */

    public function test_get_status_no_cores(): void {

        $response = $this->get_fake_response('{}');

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/admin/cores',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willReturn($response);

        $engine = new engine();

        $status = $engine->get_status();

        $this->assertTrue($status['connected']);

        $this->assertFalse($status['foundcore']);

        $this->assertEquals('Unexpected JSON: no core status', $status['error']);

    }

    /**

     * Tests the {@see engine::get_status()} function when the server returns a core without a name

     * we can read.

     *

     * In real usage this should only happen if the Solr REST interface changes unexpectedly.

     */

    public function test_get_status_core_no_name(): void {

        // A core with no name (in its 'name' field, the 'frog' key is ignored).

        $response = $this->get_fake_response('{"status":{"frog":{}}}');

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/admin/cores',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willReturn($response);

        $engine = new engine();

        $status = $engine->get_status();

        $this->assertTrue($status['connected']);

        $this->assertFalse($status['foundcore']);

        $this->assertEquals('Unexpected JSON: core has no name', $status['error']);

    }

    /**

     * Tests the {@see engine::get_status()} function when the server doesn't return status for a

     * core that matches the index name in Moodle config.

     *

     * In real usage this could happen if the index got wiped from search or something.

     */

    public function test_get_status_no_matching_core(): void {

        // Core is not the one we're looking for.

        $response = $this->get_fake_response('{"status":{"frog":{"name":"frog"}}}');

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/admin/cores',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willReturn($response);

        $engine = new engine();

        $status = $engine->get_status();

        $this->assertTrue($status['connected']);

        $this->assertFalse($status['foundcore']);

        $this->assertEquals('Could not find core matching myindex', $status['error']);

    }

    /**

     * Tests the {@see engine::get_status()} function when the server returns a core without index

     * information.

     *

     * In real usage this should only happen if the Solr REST interface changes unexpectedly. There

     * is a parameter to not receive index information, but we don't use it.

     */

    public function test_get_status_core_no_index(): void {

        // Core exists but has no index object.

        $response = $this->get_fake_response('{"status":{"myindex":{"name":"myindex"}}}');

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/admin/cores',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willReturn($response);

        $engine = new engine();

        $status = $engine->get_status();

        $this->assertTrue($status['connected']);

        $this->assertTrue($status['foundcore']);

        $this->assertEquals('Unexpected JSON: core has no index', $status['error']);

    }

    /**

     * Tests the {@see engine::get_status()} function when the server returns index information

     * without size.

     *

     * In real usage this should only happen if the Solr REST interface changes unexpectedly.

     */

    public function test_get_status_core_index_no_size(): void {

        // Core index objects doesn't have a size.

        $response = $this->get_fake_response('{"status":{"myindex":{"name":"myindex","index":{}}}}');

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/admin/cores',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willReturn($response);

        $engine = new engine();

        $status = $engine->get_status();

        $this->assertTrue($status['connected']);

        $this->assertTrue($status['foundcore']);

        $this->assertEquals('Unexpected JSON: core index has no sizeInBytes', $status['error']);

    }

    /**

     * Tests the {@see engine::get_status()} function when all desired data is present, using a

     * single-instance Solr configuration.

     */

    public function test_get_status_success_single_server(): void {

        // Core index complete with size.

        $response = $this->get_fake_response('{"status":{"myindex":{"name":"myindex",' .

            '"index":{"sizeInBytes":123}}}}');

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/admin/cores',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willReturn($response);

        $engine = new engine();

        $status = $engine->get_status();

        $this->assertTrue($status['connected']);

        $this->assertTrue($status['foundcore']);

        $this->assertEquals(123, $status['indexsize']);

    }

    /**

     * Tests the {@see engine::get_status()} function when all desired data is present, using a

     * multiple-instance (SolrCloud) configuration.

     */

    public function test_get_status_success_solr_cloud(): void {

        // Index with size, in cloud replica. These have a different name for each node but a

        // 'collection' field with the original index name.

        $response = $this->get_fake_response('{"status":{"replica1":{"name":"replica1",' .

            '"cloud":{"collection":"myindex"},"index":{"sizeInBytes":123}}}}');

        $mockedclient = $this->createMock(\core\http_client::class);

        \core\di::set(\core\http_client::class, $mockedclient);

        $mockedclient->expects($this->once())->method('get')->with(

            'http://host.invalid:8983/solr/admin/cores',

            [

                'connect_timeout' => 30,

                'read_timeout' => 30,

            ],

        )->willReturn($response);

        $engine = new engine();

        $status = $engine->get_status();

        $this->assertTrue($status['connected']);

        $this->assertTrue($status['foundcore']);

        $this->assertEquals(123, $status['indexsize']);

    }

}