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

use core\test\message;

use Behat\Gherkin\Node\TableNode;

use Behat\Mink\Exception\ExpectationException;

use Moodle\BehatExtension\Exception\SkippedException;

require_once(__DIR__ . '/../../behat/behat_base.php');

/**

 * Steps definitions to assist with email testing.

 *

 * @package    core

 * @category   test

 * @copyright  Simey Lameze <simey@moodle.com>

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

 */

class behat_email extends behat_base {

    /**

     * Check if email catcher is configured.

     *

     * @return bool

     */

    public static function is_email_catcher_configured(): bool {

        return defined('TEST_EMAILCATCHER_MAIL_SERVER') && defined('TEST_EMAILCATCHER_API_SERVER');

    }

    /**

     * Behat step to check if email catcher is configured.

     *

     * @Given /^an email catcher server is configured$/

     */

    public function email_catcher_is_configured(): void {

        if (!self::is_email_catcher_configured()) {

            throw new SkippedException(

                'The TEST_EMAILCATCHER_MAIL_SERVER and TEST_EMAILCATCHER_API_SERVER constants must be ' .

                'defined in config.php to use the mailcatcher steps.'

            );

        }

    }

    /**

     * Get the email catcher object or thrown a SkippedException if TEST_MAILPIT_SERVER is not defined.

     *

     * @return \core\test\email_catcher|null

     */

    private function get_catcher(): ?\core\test\email_catcher {

        if (self::is_email_catcher_configured()) {

            return new \core\test\mailpit_email_catcher(TEST_EMAILCATCHER_API_SERVER);

        }

        return null;

    }

    /**

     * Clean up the email inbox after each scenario.

     *

     * @AfterScenario @behat_email

     */

    public function reset_after_test(): void {

        $this->get_catcher()?->delete_all();

    }

    /**

     * Get the e-mail address of a user from the step input.

     *

     * This could be an e-mail address, or a username.

     *

     * @param string $input The input from the step.

     * @return string

     */

    private function get_email_address_from_input(string $input): string {

        if (strpos($input, '@') !== false) {

            return $input;

        }

        $user = $this->get_user_by_identifier($input);

        if (!$user) {

            throw new ExpectationException("No user found with identifier {$input}", $this->getSession()->getDriver());

        }

        return $user->email;

    }

    /**

     * Get any message matching the supplied user and subject.

     *

     * @param string $user The user to check for.

     * @param string $subject The subject to check for.

     * @return iterable<message>

     */

    private function get_messages_matching_address_and_subject(

        string $user,

        string $subject,

    ): iterable {

        $address = $this->get_email_address_from_input($user);

        return new \CallbackFilterIterator(

            iterator: $this->get_catcher()->get_messages(showdetails: true),

            callback: function (message $message) use ($address, $subject): bool {

                if (!$message->has_recipient($address)) {

                    return false;

                }

                if (strpos($message->get_subject(), $subject) === false) {

                    return false;

                }

                return true;

            },

        );

    }

    /**

     * Verifies the content of an email sent to a specific user and subject.

     *

     * @Given the email to :user with subject containing :subject should contain :content

     *

     * @param string $user The user to check for.

     * @param string $subject The subject to check for.

     * @param string $content The content to check for.

     */

    public function verify_email_content(string $user, string $subject, string $content): void {

        $messages = $this->get_messages_matching_address_and_subject($user, $subject);

        $count = 0;

        foreach ($messages as $message) {

            $count++;

            $this->validate_data('content', $message, $content);

        }

        if ($count === 0) {

            throw new ExpectationException(

                "No messages found with subject containing {$subject}",

                $this->getSession()->getDriver(),

            );

        }

    }

    /**

     * Custom Behat test to verify the number of emails for a user.

     *

     * @Then user :address should have :count emails

     *

     * @param string $address The user to check for.

     * @param int $expected The number of emails to check for.

     */

    public function verify_email_count(string $address, int $expected): void {

        $address = $this->get_email_address_from_input($address);

        $messages = new \CallbackFilterIterator(

            iterator: $this->get_catcher()->get_messages(),

            callback: fn($message) => $message->has_recipient($address),

        );

        $count = iterator_count($messages);

        if ($count !== $expected) {

            throw new ExpectationException(

                sprintf(

                    'Expected %d messages, but found %d',

                    $expected,

                    $count,

                ),

                $this->getSession(),

            );

        }

    }

    /**

     * Custom Behat test to empty the email inbox.

     *

     * @When I empty the email inbox

     */

    public function empty_email_inbox() {

        $this->get_catcher()->delete_all();

    }

    /**

     * Behat step to send emails.

     *

     * @Given the following emails have been sent:

     *

     * @param TableNode $table The table of emails to send.

     */

    public function the_following_emails_have_been_sent(TableNode $table): void {

        if (!$rows = $table->getRows()) {

            return;

        }

        // Allowed fields.

        $allowedfields = ['to', 'subject', 'message'];

        // Create a map of header to index.

        $headers = array_flip($rows[0]);

        // Remove header row.

        unset($rows[0]);

        // Validate supplied headers.

        foreach ($headers as $header => $index) {

            if (!in_array($header, $allowedfields)) {

                throw new ExpectationException("Invalid header {$header} found in table", $this->getSession()->getDriver());

            }

        }

        foreach ($rows as $row) {

            // Check if the required headers are set in the $headers map.

            $to = isset($headers['to']) ? $row[$headers['to']] : 'userto@example.com';

            $subject = isset($headers['subject']) ? $row[$headers['subject']] : 'Default test subject';

            $message = isset($headers['message']) ? $row[$headers['message']] : 'Default test message';

            // Use no-reply user as dummy user to send emails from.

            $noreplyuser = \core_user::get_user(\core_user::NOREPLY_USER);

            // Create a dummy user to send emails to.

            $emailuserto = new stdClass();

            $emailuserto->id = -99;

            $emailuserto->email = $to;

            $emailuserto->firstname = 'Test';

            $emailuserto->lastname = 'User';

            // Send test email.

            email_to_user($emailuserto, $noreplyuser, $subject, $message);

        }

    }

    /**

     * Validate the emails expected and actual values.

     *

     * @param string $field The field to validate.

     * @param message $message The expected value.

     * @param string $expected The actual value.

     */

    private function validate_data(

        string $field,

        message $message,

        string $expected,

    ): void {

        switch ($field) {

            case 'user':

                $actual = $message->get_recipients();

                foreach ($actual as $recipient) {

                    if ($recipient->get_address() === $expected) {

                        return;

                    }

                }

                throw new ExpectationException(

                    sprintf(

                        'Expected %s %s, but found %s',

                        $expected,

                        $field,

                        $actual,

                    ),

                    $this->getSession(),

                );

            case 'subject':

                $actual = $message->get_subject();

                if (str_contains($expected, $actual)) {

                    return;

                }

                throw new ExpectationException(

                    sprintf(

                        'Expected %s %s, but found %s',

                        $expected,

                        $field,

                        $actual,

                    ),

                    $this->getSession(),

                );

            case 'content':

                if (str_contains($expected, $message->get_body_text())) {

                    return;

                }

                if (str_contains($expected, $message->get_body_html())) {

                    return;

                }

                throw new ExpectationException(

                    sprintf(

                        'Expected %s to contain %s, but it does not. Actual text was:\n%s\nActual HTML content was:\n%s\n',

                        $field,

                        $expected,

                        $message->get_body_text(),

                        $message->get_body_html(),

                    ),

                    $this->getSession(),

                );

            default:

                throw new ExpectationException(

                    sprintf(

                        'Unknown field to validate: %s',

                        $field,

                    ),

                    $this->getSession(),

                );

        }

    }

}