feat: draft copies and replace-with-copy

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01At3V6SjwbMe6eMzVGW3Hs7
2026-09-25 23:27:07 +02:00
parent 346619d6da
commit 4fed69cf65
8 changed files with 1215 additions and 0 deletions
@@ -0,0 +1,217 @@
+<?php
+
+declare(strict_types=1);
+
+namespace LIT\MCP\Tests\Unit\Integrations\WordPress\Status;
+
+use Brain\Monkey\Functions;
+use LIT\MCP\Abilities\Rev;
+use LIT\MCP\Abilities\WriteFailed;
+use LIT\MCP\ChangeLog\ChangeLog;
+use LIT\MCP\Integrations\WordPress\Schema\ContentSchema;
+use LIT\MCP\Integrations\WordPress\Status\PostCloner;
+use LIT\MCP\Integrations\WordPress\Status\PostReplaceWithCopyAbility;
+use LIT\MCP\Tests\Unit\TestCase;
+use Mockery;
+use RuntimeException;
+use WP_Post;
+
+final class PostReplaceWithCopyAbilityTest extends TestCase
+{
+    private const SNAPSHOT = ['post' => ['post_title' => 'Team'], 'meta' => [], 'terms' => []];
+
+    private WP_Post $original;
+    private WP_Post $copy;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->original = new WP_Post(['ID' => 5, 'post_type' => 'page', 'post_title' => 'Team', 'post_status' => 'publish']);
+        $this->copy = new WP_Post(['ID' => 77, 'post_type' => 'page', 'post_title' => 'Team (Kopie)', 'post_status' => 'draft']);
+        Functions\when('get_post')->alias(fn (int $id) => $id === 5 ? $this->original : $this->copy);
+        Functions\when('current_user_can')->justReturn(true);
+        Functions\when('get_post_meta')->justReturn('5');
+        Functions\when('get_permalink')->justReturn('https://kunde.de/team/');
+        Functions\when('get_edit_post_link')->justReturn('https://kunde.de/wp-admin/post.php?post=5&action=edit');
+    }
+
+    private function ability(PostCloner $cloner, ChangeLog $log, bool $trash = true): PostReplaceWithCopyAbility
+    {
+        $schema = Mockery::mock(ContentSchema::class);
+        $schema->allows('isManaged')->andReturn(true);
+
+        return new PostReplaceWithCopyAbility($schema, $cloner, $log, static fn (): bool => $trash);
+    }
+
+    /** @return array<string, mixed> */
+    private function input(array $extra = []): array
+    {
+        return array_merge(
+            ['original_id' => 5, 'copy_id' => 77, 'rev' => Rev::ofPost($this->original), 'confirm' => true],
+            $extra
+        );
+    }
+
+    private function revisionAt900(): void
+    {
+        Functions\when('wp_save_post_revision')->justReturn(900);
+        Functions\when('wp_get_post_revisions')->justReturn([900 => new WP_Post(['ID' => 900])]);
+    }
+
+    public function testRequiresConfirmation(): void
+    {
+        $cloner = Mockery::mock(PostCloner::class);
+        $cloner->expects('replace')->never();
+
+        $result = $this->ability($cloner, Mockery::mock(ChangeLog::class))
+            ->execute(['original_id' => 5, 'copy_id' => 77, 'rev' => Rev::ofPost($this->original)]);
+
+        self::assertSame('lit_confirm_required', $result->get_error_code());
+    }
+
+    public function testCopyMustStemFromTheOriginal(): void
+    {
+        Functions\when('get_post_meta')->justReturn('12');
+        $cloner = Mockery::mock(PostCloner::class);
+        $cloner->expects('replace')->never();
+
+        $result = $this->ability($cloner, Mockery::mock(ChangeLog::class))->execute($this->input());
+
+        self::assertSame('lit_validation_failed', $result->get_error_code());
+    }
+
+    public function testATrashedCopyIsRefused(): void
+    {
+        $this->copy->post_status = 'trash';
+        $cloner = Mockery::mock(PostCloner::class);
+        $cloner->expects('replace')->never();
+
+        $result = $this->ability($cloner, Mockery::mock(ChangeLog::class))->execute($this->input());
+
+        self::assertSame('lit_validation_failed', $result->get_error_code());
+    }
+
+    public function testAStaleRevOfTheOriginalIsRefused(): void
+    {
+        $cloner = Mockery::mock(PostCloner::class);
+        $cloner->expects('replace')->never();
+        Functions\expect('wp_save_post_revision')->never();
+
+        $result = $this->ability($cloner, Mockery::mock(ChangeLog::class))->execute($this->input(['rev' => 'veraltet']));
+
+        self::assertSame('lit_rev_mismatch', $result->get_error_code());
+    }
+
+    public function testDisabledTrashIsRefusedBeforeAnyChange(): void
+    {
+        $cloner = Mockery::mock(PostCloner::class);
+        $cloner->expects('replace')->never();
+
+        $result = $this->ability($cloner, Mockery::mock(ChangeLog::class), false)->execute($this->input());
+
+        self::assertSame('lit_unsupported', $result->get_error_code());
+    }
+
+    public function testRevisionThenReplaceThenTrashTheCopy(): void
+    {
+        $order = [];
+        Functions\expect('wp_save_post_revision')->once()->with(5)->andReturnUsing(static function () use (&$order) {
+            $order[] = 'revision';
+            return 900;
+        });
+        Functions\when('wp_get_post_revisions')->justReturn([900 => new WP_Post(['ID' => 900])]);
+        $cloner = Mockery::mock(PostCloner::class);
+        $cloner->expects('snapshot')->with($this->original)->andReturnUsing(static function () use (&$order): array {
+            $order[] = 'snapshot';
+            return self::SNAPSHOT;
+        });
+        $cloner->expects('replace')->with($this->original, $this->copy)->andReturnUsing(static function () use (&$order): void {
+            $order[] = 'replace';
+        });
+        $cloner->expects('restore')->never();
+        Functions\expect('wp_trash_post')->once()->with(77)->andReturnUsing(static function () use (&$order): WP_Post {
+            $order[] = 'trash';
+            return new WP_Post(['ID' => 77]);
+        });
+        $log = Mockery::mock(ChangeLog::class);
+        $log->expects('record')->with('lit/post-replace-with-copy', 'page', '5', Mockery::type('string'), 900)->andReturn(11);
+
+        $result = $this->ability($cloner, $log)->execute($this->input());
+
+        self::assertSame(['snapshot', 'revision', 'replace', 'trash'], $order);
+        self::assertSame(900, $result['revision_id']);
+        self::assertSame(11, $result['log_id']);
+        self::assertSame(Rev::ofPost($this->original), $result['rev']);
+        self::assertSame(['replaced', 'trashed'], array_column($result['changed'], 'action'));
+        self::assertSame([], $result['warnings']);
+    }
+
+    public function testAFailedTrashOfTheCopyIsAWarningOnly(): void
+    {
+        $this->revisionAt900();
+        $cloner = Mockery::mock(PostCloner::class);
+        $cloner->allows('snapshot')->andReturn(self::SNAPSHOT);
+        $cloner->expects('replace');
+        Functions\when('wp_trash_post')->justReturn(false);
+        $log = Mockery::mock(ChangeLog::class);
+        $log->allows('record')->andReturn(11);
+
+        $result = $this->ability($cloner, $log)->execute($this->input());
+
+        self::assertTrue($result['ok']);
+        self::assertSame(['replaced'], array_column($result['changed'], 'action'));
+        self::assertSame(['Kopie 77 konnte nicht in den Papierkorb gelegt werden'], $result['warnings']);
+    }
+
+    public function testAFailedReplaceRestoresTheOriginal(): void
+    {
+        $this->revisionAt900();
+        $cloner = Mockery::mock(PostCloner::class);
+        $cloner->allows('snapshot')->andReturn(self::SNAPSHOT);
+        $cloner->expects('replace')->andThrow(new RuntimeException('meta kaputt'));
+        $cloner->expects('restore')->with($this->original, self::SNAPSHOT);
+        Functions\expect('wp_trash_post')->never();
+
+        try {
+            $this->ability($cloner, Mockery::mock(ChangeLog::class))->execute($this->input());
+            self::fail('WriteFailed expected');
+        } catch (WriteFailed $e) {
+            self::assertTrue($e->rolledBack);
+            self::assertSame('lit_write_failed', $e->toError()->get_error_code());
+        }
+    }
+
+    public function testAnIncompleteRestoreIsAPartialWrite(): void
+    {
+        $this->revisionAt900();
+        $cloner = Mockery::mock(PostCloner::class);
+        $cloner->allows('snapshot')->andReturn(self::SNAPSHOT);
+        $cloner->expects('replace')->andThrow(new RuntimeException('meta kaputt'));
+        $cloner->expects('restore')->andThrow(new RuntimeException('Restore incomplete: terms'));
+        Functions\expect('wp_trash_post')->never();
+        $log = Mockery::mock(ChangeLog::class);
+        $log->expects('record')
+            ->with('lit/post-replace-with-copy', 'page', '5', Mockery::type('string'), 900, null, 'partial')
+            ->andReturn(12);
+
+        try {
+            $this->ability($cloner, $log)->execute($this->input());
+            self::fail('WriteFailed expected');
+        } catch (WriteFailed $e) {
+            self::assertFalse($e->rolledBack);
+            self::assertSame(5, $e->postId);
+            self::assertSame(900, $e->revisionId);
+            self::assertSame('lit_partial_write', $e->toError()->get_error_code());
+        }
+    }
+
+    public function testRequiresRevAndIsDestructive(): void
+    {
+        $ability = $this->ability(Mockery::mock(PostCloner::class), Mockery::mock(ChangeLog::class));
+
+        self::assertContains('rev', $ability->inputSchema()['required']);
+        self::assertTrue($ability->annotations()['destructive']);
+        self::assertFalse($ability->annotations()['idempotent']);
+        self::assertFalse($ability->isDirect());
+    }
+}