WP-LIT-MCP/tests/Unit/Integrations/WordPress/Revisions/RevisionRestoreAbilityTest.php

<?php

declare(strict_types=1);

namespace LIT\MCP\Tests\Unit\Integrations\WordPress\Revisions;

use Brain\Monkey\Actions;
use Brain\Monkey\Functions;
use LIT\MCP\Abilities\Rev;
use LIT\MCP\ChangeLog\ChangeLog;
use LIT\MCP\Integrations\WordPress\Revisions\RevisionRestoreAbility;
use LIT\MCP\Tests\Support\FakeChangeLog;
use LIT\MCP\Tests\Support\SchemaFixture;
use LIT\MCP\Tests\Unit\TestCase;
use RuntimeException;
use WP_Post;

final class RevisionRestoreAbilityTest extends TestCase
{
    private const CURRENT_POST = [
        'ID' => 5,
        'post_type' => 'page',
        'post_title' => 'Team',
        'post_status' => 'publish',
        'post_content' => 'alt',
    ];

    protected function setUp(): void
    {
        parent::setUp();
        Functions\when('get_post')->alias(static fn (int $id) => match ($id) {
            810 => new WP_Post(['ID' => 810, 'post_type' => 'revision', 'post_parent' => 5, 'post_date' => '2026-09-20 10:00:00']),
            5 => new WP_Post(self::CURRENT_POST),
            default => null,
        });
        Functions\when('current_user_can')->justReturn(true);
    }

    private function ability(ChangeLog $log): RevisionRestoreAbility
    {
        $schema = SchemaFixture::managed();

        return new RevisionRestoreAbility($schema, $log);
    }

    private function currentRev(): string
    {
        return Rev::ofPost(new WP_Post(self::CURRENT_POST));
    }

    public function testNonRevisionIdIsNotFound(): void
    {
        self::assertToolError($this->ability(FakeChangeLog::forbidden())->permission(['revision_id' => 5]), 'not_found');
    }

    public function testRequiresConfirmation(): void
    {
        Functions\expect('wp_restore_post_revision')->never();

        $result = $this->ability(FakeChangeLog::forbidden())->execute(['revision_id' => 810]);

        self::assertToolError($result, 'confirm_required');
    }

    public function testOrphanRevisionYieldsValidationErrorOnRevisionIdField(): void
    {
        Functions\when('get_post')->alias(static fn (int $id) => $id === 810
            ? new WP_Post(['ID' => 810, 'post_type' => 'revision', 'post_parent' => 0])
            : null);

        $error = $this->ability(FakeChangeLog::forbidden())
            ->permission(['revision_id' => 810, 'rev' => 'irrelevant', 'confirm' => true]);

        self::assertToolError($error, 'validation_failed');
        self::assertArrayHasKey('revision_id', self::errorFields($error));
    }

    public function testATrashedEntryIsRefused(): void
    {
        Functions\when('get_post')->alias(static fn (int $id) => match ($id) {
            810 => new WP_Post(['ID' => 810, 'post_type' => 'revision', 'post_parent' => 5]),
            5 => new WP_Post(array_merge(self::CURRENT_POST, ['post_status' => 'trash'])),
            default => null,
        });
        Functions\expect('wp_restore_post_revision')->never();

        $error = $this->ability(FakeChangeLog::forbidden())->execute(['revision_id' => 810, 'rev' => 'x', 'confirm' => true]);

        self::assertToolError($error, 'validation_failed');
        self::assertArrayHasKey('revision_id', self::errorFields($error));
    }

    public function testAMissedScheduleIsRefusedBecauseRestoringWouldPublish(): void
    {
        $current = array_merge(self::CURRENT_POST, [
            'post_status' => 'future',
            'post_date_gmt' => gmdate('Y-m-d H:i:s', time() - 600),
        ]);
        Functions\when('get_post')->alias(static fn (int $id) => match ($id) {
            810 => new WP_Post(['ID' => 810, 'post_type' => 'revision', 'post_parent' => 5]),
            5 => new WP_Post($current),
            default => null,
        });
        Functions\expect('wp_save_post_revision')->never();
        Functions\expect('wp_restore_post_revision')->never();

        $error = $this->ability(FakeChangeLog::forbidden())->execute([
            'revision_id' => 810,
            'rev' => Rev::ofPost(new WP_Post($current)),
            'confirm' => true,
        ]);

        self::assertToolError($error, 'validation_failed');
        self::assertStringContainsString('lit-post-publish', $error->get_error_data()['hint']);
    }

    public function testMissingOrStaleRevIsRevMismatch(): void
    {
        Functions\expect('wp_restore_post_revision')->never();

        $result = $this->ability(FakeChangeLog::forbidden())
            ->execute(['revision_id' => 810, 'confirm' => true, 'rev' => 'stale']);

        self::assertToolError($result, 'rev_mismatch');
    }

    public function testSavesTheCurrentStateThenRestores(): void
    {
        $order = [];
        Functions\expect('wp_save_post_revision')->once()->with(5)->andReturnUsing(static function () use (&$order) {
            $order[] = 'backup';
            return 813;
        });
        Functions\when('wp_get_post_revisions')->justReturn([813 => new WP_Post(['ID' => 813])]);
        Functions\expect('wp_restore_post_revision')->once()->with(810)->andReturnUsing(static function () use (&$order): int {
            $order[] = 'restore';
            return 5;
        });
        Functions\when('get_preview_post_link')->justReturn('https://kunde.de/team/');
        Functions\when('get_edit_post_link')->justReturn('https://kunde.de/wp-admin/post.php?post=5&action=edit');
        $log = new FakeChangeLog(12);

        $result = $this->ability($log)->execute([
            'revision_id' => 810,
            'confirm' => true,
            'rev' => $this->currentRev(),
        ]);

        self::assertSame(['backup', 'restore'], $order);
        self::assertSame(813, $result['revision_id']);
        self::assertSame('restored', $result['changed'][0]['action']);
        self::assertStringContainsString('2026-09-20 10:00:00', $result['summary']);
        self::assertStringContainsString('Status unverändert: publish', $result['summary']);
        self::assertSame([], $result['warnings']);
        $log->assertRecorded([
            'ability' => 'lit/revision-restore',
            'object_type' => 'page',
            'object_id' => '5',
            'revision_id' => 813,
        ]);
    }

    public function testRestoreFailureIsWriteFailed(): void
    {
        Functions\when('wp_save_post_revision')->justReturn(813);
        Functions\when('wp_get_post_revisions')->justReturn([813 => new WP_Post(['ID' => 813])]);
        Functions\when('wp_restore_post_revision')->justReturn(false);
        $log = FakeChangeLog::forbidden();

        $result = $this->ability($log)->execute([
            'revision_id' => 810,
            'confirm' => true,
            'rev' => $this->currentRev(),
        ]);

        self::assertToolError($result, 'write_failed');
        self::assertStringNotContainsString('Nichts wurde gespeichert', $result->get_error_message());
        self::assertStringContainsString(
            'Die Änderung wurde nicht gespeichert (Revision 813 bleibt erhalten).',
            $result->get_error_message()
        );
    }

    public function testFailuresAfterTheWriteOnlyAddWarnings(): void
    {
        Functions\when('wp_save_post_revision')->justReturn(813);
        Functions\when('wp_get_post_revisions')->justReturn([813 => new WP_Post(['ID' => 813])]);
        Functions\when('wp_restore_post_revision')->justReturn(5);
        Functions\when('get_preview_post_link')->justReturn('');
        Functions\when('get_edit_post_link')->justReturn('');
        Actions\expectDone('lit_mcp_after_save')->once()->whenHappen(static function (): void {
            throw new RuntimeException('listener kaputt');
        });
        $log = new FakeChangeLog(1, new RuntimeException('db weg'));
        $file = (string) tempnam(sys_get_temp_dir(), 'lit-mcp-log');
        $previous = ini_set('error_log', $file);

        try {
            $result = $this->ability($log)->execute([
                'revision_id' => 810,
                'confirm' => true,
                'rev' => $this->currentRev(),
            ]);
        } finally {
            ini_set('error_log', (string) $previous);
        }

        self::assertTrue($result['ok']);
        self::assertNull($result['log_id']);
        self::assertCount(2, $result['warnings']);
        self::assertStringContainsString('listener kaputt', (string) file_get_contents($file));
        unlink($file);
        $log->assertRecorded([]);
    }
}