fix: typed write failures, template rollback, parent and term cleanup

WriteFailed maps to lit_write_failed / lit_partial_write (partial writes are
logged with result partial); old template read before the update; row marker
set before wp_update_post; created terms deleted on rollback; parent must be a
readable non-descendant of a hierarchical type; featured image must be
readable; snapshot keeps empty values; meta comparison after sanitize_meta;
follow-up failures (listener, change log) only add warnings.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01At3V6SjwbMe6eMzVGW3Hs7

tests/Unit/Integrations/WordPress/Content/ContentCreateAbilityTest.php

@@ -8,17 +8,21 @@ use Brain\Monkey\Actions;
 use Brain\Monkey\Functions;
 use LIT\MCP\Abilities\Errors;
 use LIT\MCP\Abilities\Rev;
+use LIT\MCP\Abilities\WriteFailed;
 use LIT\MCP\ChangeLog\ChangeLog;
 use LIT\MCP\Integrations\WordPress\Content\ContentCreateAbility;
 use LIT\MCP\Integrations\WordPress\Content\PostWriter;
 use LIT\MCP\Integrations\WordPress\Schema\ContentSchema;
 use LIT\MCP\Tests\Unit\TestCase;
 use Mockery;
+use Mockery\MockInterface;
 use RuntimeException;
 use WP_Post;
 
 final class ContentCreateAbilityTest extends TestCase
 {
+    private const INPUT = ['post_type' => 'lit_person', 'title' => 'Anna', 'fields' => ['role' => 'Leitung']];
+
     private function schema(): ContentSchema
     {
         Functions\when('get_post_type_object')->justReturn((object) ['cap' => (object) ['create_posts' => 'edit_pages']]);
@@ -29,6 +33,38 @@ final class ContentCreateAbilityTest extends TestCase
         return $schema;
     }
 
+    /** @return PostWriter&MockInterface */
+    private function writer(array $warnings = []): PostWriter
+    {
+        $writer = Mockery::mock(PostWriter::class);
+        $writer->allows('prepare')->andReturn(['fields' => ['role' => 'Leitung'], 'terms' => [], 'warnings' => $warnings]);
+        $writer->allows('postData')->andReturn(['post_title' => 'Anna']);
+        Functions\when('get_current_user_id')->justReturn(3);
+
+        return $writer;
+    }
+
+    private function execute(PostWriter $writer, ChangeLog $log): WriteFailed
+    {
+        try {
+            (new ContentCreateAbility($this->schema(), $writer, $log))->execute(self::INPUT);
+        } catch (WriteFailed $e) {
+            return $e;
+        }
+
+        self::fail('WriteFailed expected');
+    }
+
+    private function stubResultLinks(): WP_Post
+    {
+        $post = new WP_Post(['ID' => 42, 'post_title' => 'Anna', 'post_type' => 'lit_person']);
+        Functions\when('get_post')->justReturn($post);
+        Functions\when('get_preview_post_link')->justReturn('https://kunde.de/?p=42&preview=true');
+        Functions\when('get_edit_post_link')->justReturn('https://kunde.de/wp-admin/post.php?post=42&action=edit');
+
+        return $post;
+    }
+
     public function testInvalidInputWritesNothing(): void
     {
         $writer = Mockery::mock(PostWriter::class);
@@ -45,7 +81,7 @@ final class ContentCreateAbilityTest extends TestCase
     {
         $schema = $this->schema();
         $prepared = ['fields' => ['role' => 'Leitung'], 'terms' => [], 'warnings' => ['w']];
-        $input = ['post_type' => 'lit_person', 'title' => 'Anna', 'fields' => ['role' => 'Leitung']];
+        $input = self::INPUT;
         $writer = Mockery::mock(PostWriter::class);
         $writer->allows('prepare')->with('lit_person', $input, true)->andReturn($prepared);
         $writer->allows('postData')->andReturn(['post_title' => 'Anna']);
@@ -58,10 +94,7 @@ final class ContentCreateAbilityTest extends TestCase
             'post_author' => 3,
         ], true)->andReturn(42);
         Actions\expectDone('lit_mcp_after_save')->once()->with(42, 'lit/content-create', $input);
-        $post = new WP_Post(['ID' => 42, 'post_title' => 'Anna', 'post_type' => 'lit_person']);
-        Functions\when('get_post')->justReturn($post);
-        Functions\when('get_preview_post_link')->justReturn('https://kunde.de/?p=42&preview=true');
-        Functions\when('get_edit_post_link')->justReturn('https://kunde.de/wp-admin/post.php?post=42&action=edit');
+        $post = $this->stubResultLinks();
         $log = Mockery::mock(ChangeLog::class);
         $log->expects('record')->with('lit/content-create', 'lit_person', '42', 'Entwurf "Anna" angelegt')->andReturn(7);
 
@@ -75,28 +108,103 @@ final class ContentCreateAbilityTest extends TestCase
         self::assertSame(Rev::ofPost($post), $result['rev']);
     }
 
-    public function testFailingExtrasDeleteTheNewDraftAndNothingIsLogged(): void
+    public function testFailingExtrasDeleteCreatedTermsAndTheNewDraft(): void
     {
-        $schema = $this->schema();
-        $input = ['post_type' => 'lit_person', 'title' => 'Anna', 'fields' => ['role' => 'Leitung']];
-        $writer = Mockery::mock(PostWriter::class);
-        $writer->allows('prepare')->andReturn(['fields' => ['role' => 'Leitung'], 'terms' => [], 'warnings' => []]);
-        $writer->allows('postData')->andReturn(['post_title' => 'Anna']);
+        $writer = $this->writer();
         $writer->expects('writeExtras')->andThrow(new RuntimeException('Pods could not save the fields.'));
-        Functions\when('get_current_user_id')->justReturn(3);
+        $writer->expects('deleteCreatedTerms');
         Functions\when('wp_insert_post')->justReturn(42);
         Functions\expect('wp_delete_post')->once()->with(42, true)->andReturn(new WP_Post(['ID' => 42]));
         Actions\expectDone('lit_mcp_after_save')->never();
         $log = Mockery::mock(ChangeLog::class);
         $log->expects('record')->never();
 
+        $failure = $this->execute($writer, $log);
+
+        self::assertTrue($failure->rolledBack);
+        self::assertStringContainsString('Pods could not save the fields.', $failure->getMessage());
+        self::assertSame('lit_write_failed', $failure->toError()->get_error_code());
+    }
+
+    public function testADraftThatCannotBeDeletedIsAPartialWriteAndLogged(): void
+    {
+        $writer = $this->writer();
+        $writer->expects('writeExtras')->andThrow(new RuntimeException('meta kaputt'));
+        $writer->expects('deleteCreatedTerms');
+        Functions\when('wp_insert_post')->justReturn(42);
+        Functions\when('wp_delete_post')->justReturn(false);
+        $log = Mockery::mock(ChangeLog::class);
+        $log->expects('record')
+            ->with('lit/content-create', 'lit_person', '42', Mockery::type('string'), null, null, 'partial')
+            ->andReturn(9);
+
+        $failure = $this->execute($writer, $log);
+
+        self::assertFalse($failure->rolledBack);
+        self::assertSame(42, $failure->postId);
+        self::assertStringContainsString('Eintrag 42', $failure->toError()->get_error_message());
+    }
+
+    public function testLeftoverCreatedTermsMakeItAPartialWrite(): void
+    {
+        $writer = $this->writer();
+        $writer->expects('writeExtras')->andThrow(new RuntimeException('meta kaputt'));
+        $writer->expects('deleteCreatedTerms')->andThrow(new RuntimeException('term 15 bleibt'));
+        Functions\when('wp_insert_post')->justReturn(42);
+        Functions\when('wp_delete_post')->justReturn(new WP_Post(['ID' => 42]));
+        $log = Mockery::mock(ChangeLog::class);
+        $log->expects('record')->andReturn(9);
+
+        $failure = $this->execute($writer, $log);
+
+        self::assertFalse($failure->rolledBack);
+        self::assertStringContainsString('term 15 bleibt', $failure->getMessage());
+    }
+
+    public function testAnInsertThatThrowsIsAPartialWriteWithoutId(): void
+    {
+        $writer = $this->writer();
+        Functions\when('wp_insert_post')->alias(static function (): never {
+            throw new RuntimeException('save_post hook kaputt');
+        });
+        $log = Mockery::mock(ChangeLog::class);
+        $log->expects('record')
+            ->with('lit/content-create', 'lit_person', '', Mockery::type('string'), null, null, 'partial')
+            ->andReturn(9);
+
+        $failure = $this->execute($writer, $log);
+
+        self::assertFalse($failure->rolledBack);
+        self::assertNull($failure->postId);
+        self::assertSame('lit_partial_write', $failure->toError()->get_error_code());
+    }
+
+    public function testFailuresAfterTheWriteOnlyAddWarnings(): void
+    {
+        $writer = $this->writer(['w']);
+        $writer->allows('writeExtras');
+        Functions\when('wp_insert_post')->justReturn(42);
+        $this->stubResultLinks();
+        Actions\expectDone('lit_mcp_after_save')->once()->whenHappen(static function (): void {
+            throw new RuntimeException('listener kaputt');
+        });
+        $log = Mockery::mock(ChangeLog::class);
+        $log->expects('record')->andThrow(new RuntimeException('db weg'));
+        $file = (string) tempnam(sys_get_temp_dir(), 'lit-mcp-log');
+        $previous = ini_set('error_log', $file);
+
         try {
-            (new ContentCreateAbility($schema, $writer, $log))->execute($input);
-            self::fail('RuntimeException expected');
-        } catch (RuntimeException $e) {
-            self::assertStringContainsString('Pods could not save the fields.', $e->getMessage());
-            self::assertStringContainsString('deleted', $e->getMessage());
+            $result = (new ContentCreateAbility($this->schema(), $writer, $log))->execute(self::INPUT);
+        } finally {
+            ini_set('error_log', (string) $previous);
         }
+
+        self::assertTrue($result['ok']);
+        self::assertNull($result['log_id']);
+        self::assertCount(3, $result['warnings']);
+        self::assertStringContainsString('listener kaputt', (string) file_get_contents($file));
+        self::assertStringContainsString('db weg', (string) file_get_contents($file));
+        unlink($file);
     }
 
     public function testStatusIsNotAnInputAndPermissionNeedsCreateRights(): void

tests/Unit/Integrations/WordPress/Content/ContentUpdateAbilityTest.php

@@ -7,6 +7,7 @@ namespace LIT\MCP\Tests\Unit\Integrations\WordPress\Content;
 use Brain\Monkey\Actions;
 use Brain\Monkey\Functions;
 use LIT\MCP\Abilities\Rev;
+use LIT\MCP\Abilities\WriteFailed;
 use LIT\MCP\ChangeLog\ChangeLog;
 use LIT\MCP\Integrations\WordPress\Content\ContentUpdateAbility;
 use LIT\MCP\Integrations\WordPress\Content\PostWriter;
@@ -142,9 +143,9 @@ final class ContentUpdateAbilityTest extends TestCase
 
     /**
      * @param array<string, mixed> $data
-     * @return array{PostWriter, array<string, mixed>, array<string, mixed>}
+     * @return array{PostWriter&\Mockery\MockInterface, array<string, mixed>}
      */
-    private function failingWriter(array $data): array
+    private function failingWriter(array $data, bool $restoreWorks = true): array
     {
         $input = ['post_id' => 5, 'rev' => Rev::ofPost($this->post), 'title' => 'Unser Team', 'fields' => ['a' => 1]];
         $snapshot = ['fields' => ['a' => 0], 'terms' => []];
@@ -152,66 +153,159 @@ final class ContentUpdateAbilityTest extends TestCase
         $writer->allows('postData')->andReturn($data);
         $writer->allows('prepare')->andReturn(['fields' => ['a' => 1], 'terms' => [], 'warnings' => []]);
         $writer->expects('snapshot')->with(5, 'page', Mockery::type('array'), $input)->andReturn($snapshot);
-        $writer->expects('writeExtras')->andThrow(new RuntimeException('meta kaputt'));
-        $writer->expects('restore')->with(5, 'page', $snapshot);
+        $writer->allows('writeExtras')->andThrow(new RuntimeException('meta kaputt'));
+        $restore = $writer->expects('restore')->with(5, 'page', $snapshot);
+        if (! $restoreWorks) {
+            $restore->andThrow(new RuntimeException('restore kaputt'));
+        }
+        $writer->expects('deleteCreatedTerms');
         Functions\when('wp_save_post_revision')->justReturn(811);
         Functions\when('wp_get_post_revisions')->justReturn([811 => new WP_Post(['ID' => 811])]);
-        Functions\when('get_page_template_slug')->justReturn('');
         Actions\expectDone('lit_mcp_after_save')->never();
 
-        return [$writer, $input, $snapshot];
+        return [$writer, $input];
     }
 
     /** @param array<string, mixed> $input */
-    private function executeExpectingRollback(PostWriter $writer, array $input): void
+    private function executeExpectingFailure(PostWriter $writer, array $input, ?ChangeLog $log = null): WriteFailed
     {
-        $log = Mockery::mock(ChangeLog::class);
-        $log->expects('record')->never();
+        if ($log === null) {
+            $log = Mockery::mock(ChangeLog::class);
+            $log->expects('record')->never();
+        }
 
         try {
             $this->ability($writer, $log)->execute($input);
-            self::fail('RuntimeException expected');
-        } catch (RuntimeException $e) {
+        } catch (WriteFailed $e) {
             self::assertStringContainsString('meta kaputt', $e->getMessage());
-            self::assertStringContainsString('rolled back', $e->getMessage());
+            return $e;
         }
+
+        self::fail('WriteFailed expected');
+    }
+
+    /** @return list<array<string, mixed>> Captured wp_update_post() calls. */
+    private function captureUpdates(array &$updates): void
+    {
+        Functions\when('wp_update_post')->alias(static function (array $data) use (&$updates): int {
+            $updates[] = $data;
+            return 5;
+        });
     }
 
     public function testFailingExtrasRestoreTheRevisionAndTheOldValues(): void
     {
         [$writer, $input] = $this->failingWriter(['post_title' => 'Unser Team', 'post_name' => 'unser-team']);
         $updates = [];
-        Functions\when('wp_update_post')->alias(static function (array $data) use (&$updates): int {
-            $updates[] = $data;
-            return 5;
-        });
+        $this->captureUpdates($updates);
         Functions\when('wp_revisions_enabled')->justReturn(true);
         Functions\expect('wp_restore_post_revision')->once()->with(811, ['post_title'])->andReturn(5);
 
-        $this->executeExpectingRollback($writer, $input);
+        $failure = $this->executeExpectingFailure($writer, $input);
 
+        self::assertTrue($failure->rolledBack);
+        self::assertSame('lit_write_failed', $failure->toError()->get_error_code());
         self::assertSame([
             ['post_title' => 'Unser Team', 'post_name' => 'unser-team', 'ID' => 5],
             ['post_name' => 'team', 'ID' => 5],
         ], $updates);
     }
 
-    public function testWithoutRevisionsTheOldColumnValuesAreWrittenBack(): void
+    public function testWithoutRevisionsTheOldColumnValuesIncludingTheOldTemplateAreWrittenBack(): void
     {
         [$writer, $input] = $this->failingWriter(['post_title' => 'Unser Team', 'page_template' => 'tpl-wide.php']);
+        $template = 'tpl-alt.php';
         $updates = [];
-        Functions\when('wp_update_post')->alias(static function (array $data) use (&$updates): int {
+        Functions\when('get_page_template_slug')->alias(static function () use (&$template): string {
+            return $template;
+        });
+        Functions\when('wp_update_post')->alias(static function (array $data) use (&$updates, &$template): int {
             $updates[] = $data;
+            $template = (string) ($data['page_template'] ?? $template);
             return 5;
         });
         Functions\when('wp_revisions_enabled')->justReturn(false);
         Functions\expect('wp_restore_post_revision')->never();
 
-        $this->executeExpectingRollback($writer, $input);
+        $this->executeExpectingFailure($writer, $input);
 
         self::assertSame([
             ['post_title' => 'Unser Team', 'page_template' => 'tpl-wide.php', 'ID' => 5],
-            ['post_title' => 'Team', 'page_template' => 'default', 'ID' => 5],
+            ['post_title' => 'Team', 'page_template' => 'tpl-alt.php', 'ID' => 5],
         ], $updates);
     }
+
+    public function testAnUpdateThatThrowsStillRestoresTheRow(): void
+    {
+        [$writer, $input] = $this->failingWriter(['post_name' => 'unser-team']);
+        $writer->shouldNotReceive('writeExtras');
+        $updates = [];
+        Functions\when('wp_update_post')->alias(static function (array $data) use (&$updates): int {
+            $updates[] = $data;
+            if (count($updates) === 1) {
+                throw new RuntimeException('meta kaputt im save_post-Hook');
+            }
+            return 5;
+        });
+
+        $failure = $this->executeExpectingFailure($writer, $input);
+
+        self::assertTrue($failure->rolledBack);
+        self::assertSame(['post_name' => 'team', 'ID' => 5], $updates[1]);
+    }
+
+    public function testAnIncompleteRollbackIsAPartialWriteAndLogged(): void
+    {
+        [$writer, $input] = $this->failingWriter(['post_title' => 'Unser Team'], false);
+        $updates = [];
+        $this->captureUpdates($updates);
+        Functions\when('wp_revisions_enabled')->justReturn(false);
+        $log = Mockery::mock(ChangeLog::class);
+        $log->expects('record')
+            ->with('lit/content-update', 'page', '5', Mockery::type('string'), 811, null, 'partial')
+            ->andReturn(12);
+
+        $failure = $this->executeExpectingFailure($writer, $input, $log);
+
+        self::assertFalse($failure->rolledBack);
+        self::assertStringContainsString('restore kaputt', $failure->getMessage());
+        $error = $failure->toError();
+        self::assertSame('lit_partial_write', $error->get_error_code());
+        self::assertSame(5, $error->get_error_data()['post_id']);
+        self::assertSame(811, $error->get_error_data()['revision_id']);
+    }
+
+    public function testFailuresAfterTheWriteOnlyAddWarnings(): void
+    {
+        $input = ['post_id' => 5, 'rev' => Rev::ofPost($this->post), 'title' => 'Unser Team'];
+        $writer = Mockery::mock(PostWriter::class);
+        $writer->allows('postData')->andReturn(['post_title' => 'Unser Team']);
+        $writer->allows('prepare')->andReturn(['fields' => [], 'terms' => [], 'warnings' => []]);
+        $writer->allows('snapshot')->andReturn(['fields' => [], 'terms' => []]);
+        $writer->allows('writeExtras');
+        Functions\when('wp_save_post_revision')->justReturn(811);
+        Functions\when('wp_get_post_revisions')->justReturn([811 => new WP_Post(['ID' => 811])]);
+        Functions\when('wp_update_post')->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 = Mockery::mock(ChangeLog::class);
+        $log->expects('record')->andThrow(new RuntimeException('db weg'));
+        $file = (string) tempnam(sys_get_temp_dir(), 'lit-mcp-log');
+        $previous = ini_set('error_log', $file);
+
+        try {
+            $result = $this->ability($writer, $log)->execute($input);
+        } 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);
+    }
 }

tests/Unit/Integrations/WordPress/Content/PostWriterTest.php

@@ -10,6 +10,7 @@ use LIT\MCP\Integrations\WordPress\Schema\ContentSchema;
 use LIT\MCP\Integrations\WordPress\Schema\FieldDefinition;
 use LIT\MCP\Integrations\WordPress\Schema\FieldSource;
 use LIT\MCP\Integrations\WordPress\Schema\FieldValidator;
+use LIT\MCP\Integrations\WordPress\Schema\RegisteredMetaSource;
 use LIT\MCP\Integrations\WordPress\Schema\TermAssigner;
 use LIT\MCP\Tests\Unit\TestCase;
 use Mockery;
@@ -31,6 +32,9 @@ final class PostWriterTest extends TestCase
         Functions\when('get_object_taxonomies')->justReturn([]);
         Functions\when('post_type_supports')->justReturn(false);
         Functions\when('get_post')->justReturn(new WP_Post(['ID' => 3, 'post_type' => 'post']));
+        Functions\when('is_post_type_hierarchical')->justReturn(true);
+        Functions\when('get_post_ancestors')->justReturn([]);
+        Functions\when('current_user_can')->justReturn(true);
         $schema = Mockery::mock(ContentSchema::class);
         $schema->allows('fields')->andReturn([
             'role' => new FieldDefinition('role', 'Funktion', 'string', 'pods', 'writable', true),
@@ -53,6 +57,53 @@ final class PostWriterTest extends TestCase
         self::assertStringContainsString('tpl-wide.php', $fields['template']);
     }
 
+    private function writerWithoutFields(): PostWriter
+    {
+        Functions\when('get_object_taxonomies')->justReturn([]);
+        $schema = Mockery::mock(ContentSchema::class);
+        $schema->allows('fields')->andReturn([]);
+
+        return new PostWriter($schema, new FieldValidator(), new TermAssigner());
+    }
+
+    /** @param array<string, mixed> $input */
+    private function errorFor(PostWriter $writer, array $input, string $path): string
+    {
+        $result = $writer->prepare('page', $input, false);
+        self::assertFalse(is_array($result), $path . ' should be rejected');
+
+        return (string) $result->get_error_data()['fields'][$path];
+    }
+
+    public function testParentMustBeAReadableNonDescendantEntryOfAHierarchicalType(): void
+    {
+        $writer = $this->writerWithoutFields();
+        Functions\when('get_post')->justReturn(new WP_Post(['ID' => 8, 'post_type' => 'page']));
+        Functions\when('get_post_ancestors')->justReturn([5, 1]);
+        Functions\when('current_user_can')->justReturn(true);
+
+        Functions\when('is_post_type_hierarchical')->justReturn(false);
+        self::assertStringContainsString('hierarchisch', $this->errorFor($writer, ['parent' => 8], 'parent'));
+
+        Functions\when('is_post_type_hierarchical')->justReturn(true);
+        self::assertStringContainsString('selbst', $this->errorFor($writer, ['post_id' => 8, 'parent' => 8], 'parent'));
+        self::assertStringContainsString('untergeordnet', $this->errorFor($writer, ['post_id' => 5, 'parent' => 8], 'parent'));
+        self::assertIsArray($writer->prepare('page', ['post_id' => 9, 'parent' => 8], false));
+
+        Functions\when('current_user_can')->justReturn(false);
+        self::assertStringContainsString('Berechtigung', $this->errorFor($writer, ['parent' => 8], 'parent'));
+    }
+
+    public function testFeaturedImageMustBeReadable(): void
+    {
+        $writer = $this->writerWithoutFields();
+        Functions\when('post_type_supports')->justReturn(true);
+        Functions\when('wp_attachment_is_image')->justReturn(true);
+        Functions\expect('current_user_can')->once()->with('read_post', 9)->andReturn(false);
+
+        self::assertStringContainsString('Berechtigung', $this->errorFor($writer, ['featured_image' => 9], 'featured_image'));
+    }
+
     public function testKnownDefaultAndEmptyTemplatesAreValid(): void
     {
         $this->stubTheme();
@@ -141,7 +192,7 @@ final class PostWriterTest extends TestCase
         $pods->expects('write')->with(5, 'lit_person', ['role' => 'Alt'], $definitions);
         $sample = Mockery::mock(FieldSource::class);
         $sample->allows('read')->with(5, $city)->andReturn('');
-        $sample->expects('write')->with(5, 'lit_person', ['city' => null], $definitions);
+        $sample->expects('write')->with(5, 'lit_person', ['city' => ''], $definitions);
         $schema = Mockery::mock(ContentSchema::class);
         $schema->allows('fields')->andReturn($definitions);
         $schema->allows('sourceOf')->andReturnUsing(static fn (FieldDefinition $f) => $f->source === 'pods' ? $pods : $sample);
@@ -157,7 +208,7 @@ final class PostWriterTest extends TestCase
         );
 
         self::assertSame(
-            ['fields' => ['role' => 'Alt', 'city' => null], 'terms' => ['category' => [2, 3]], 'featured_image' => 7],
+            ['fields' => ['role' => 'Alt', 'city' => ''], 'terms' => ['category' => [2, 3]], 'featured_image' => 7],
             $snapshot
         );
 
@@ -166,6 +217,60 @@ final class PostWriterTest extends TestCase
         $writer->restore(5, 'lit_person', $snapshot);
     }
 
+    public function testSnapshotTellsAbsentMetaFromStoredEmptyValues(): void
+    {
+        $kept = new FieldDefinition('kept', 'kept', 'string', 'meta', 'writable');
+        $absent = new FieldDefinition('absent', 'absent', 'string', 'meta', 'writable');
+        $flag = new FieldDefinition('flag', 'flag', 'boolean', 'pods', 'writable');
+        $pods = Mockery::mock(FieldSource::class);
+        $pods->allows('read')->andReturn(false);
+        $schema = Mockery::mock(ContentSchema::class);
+        $schema->allows('fields')->andReturn(['absent' => $absent, 'flag' => $flag, 'kept' => $kept]);
+        $schema->allows('sourceOf')->andReturnUsing(
+            static fn (FieldDefinition $f) => $f->source === 'pods' ? $pods : new RegisteredMetaSource()
+        );
+        Functions\when('get_post_meta')->justReturn('');
+        Functions\when('metadata_exists')->alias(static fn (string $type, int $id, string $key): bool => $key === 'kept');
+
+        $snapshot = (new PostWriter($schema, new FieldValidator(), new TermAssigner()))->snapshot(
+            5,
+            'lit_person',
+            ['fields' => ['kept' => 'x', 'absent' => 'y', 'flag' => true], 'terms' => [], 'warnings' => []],
+            []
+        );
+
+        self::assertSame(['kept' => '', 'absent' => null, 'flag' => false], $snapshot['fields']);
+    }
+
+    public function testTermsCreatedByWriteExtrasCanBeDeletedAgain(): void
+    {
+        $role = new FieldDefinition('role', 'Funktion', 'string', 'pods', 'writable');
+        $pods = Mockery::mock(FieldSource::class);
+        $pods->allows('write')->andThrow(new RuntimeException('pods kaputt'));
+        $schema = Mockery::mock(ContentSchema::class);
+        $schema->allows('fields')->andReturn(['role' => $role]);
+        $schema->allows('sourceOf')->andReturn($pods);
+        Functions\when('wp_insert_term')->justReturn(['term_id' => 15]);
+        Functions\when('wp_set_object_terms')->justReturn([15]);
+        $writer = new PostWriter($schema, new FieldValidator(), new TermAssigner());
+
+        try {
+            $writer->writeExtras(
+                5,
+                'lit_person',
+                ['fields' => ['role' => 'x'], 'terms' => ['category' => ['Neu']], 'warnings' => []],
+                []
+            );
+            self::fail('RuntimeException expected');
+        } catch (RuntimeException $e) {
+            self::assertSame('pods kaputt', $e->getMessage());
+        }
+
+        Functions\expect('wp_delete_term')->once()->with(15, 'category')->andReturn(true);
+        $writer->deleteCreatedTerms();
+        $writer->deleteCreatedTerms(); // nothing left – no second call
+    }
+
     public function testRestoreTriesEveryStepAndReportsFailures(): void
     {
         $role = new FieldDefinition('role', 'Funktion', 'string', 'pods', 'writable');

tests/Unit/Integrations/WordPress/Schema/RegisteredMetaSourceTest.php

@@ -94,6 +94,7 @@ final class RegisteredMetaSourceTest extends TestCase
     public function testUnchangedValueIsNotAFailure(): void
     {
         $field = new FieldDefinition('count', 'count', 'integer', 'meta', 'writable');
+        Functions\when('sanitize_meta')->returnArg(2);
         Functions\expect('update_post_meta')->once()->with(5, 'count', 3)->andReturn(false);
         Functions\expect('get_post_meta')->once()->with(5, 'count', false)->andReturn(['3']);
 
@@ -101,9 +102,21 @@ final class RegisteredMetaSourceTest extends TestCase
         self::addToAssertionCount(1);
     }
 
+    public function testTheComparisonUsesTheSanitizedValue(): void
+    {
+        $field = new FieldDefinition('slug_meta', 'slug_meta', 'string', 'meta', 'writable');
+        Functions\expect('sanitize_meta')->once()->with('slug_meta', ' Trier ', 'post', 'event')->andReturn('trier');
+        Functions\when('update_post_meta')->justReturn(false);
+        Functions\when('get_post_meta')->justReturn(['trier']);
+
+        (new RegisteredMetaSource())->write(5, 'event', ['slug_meta' => ' Trier '], ['slug_meta' => $field]);
+        self::addToAssertionCount(1);
+    }
+
     public function testFailedUpdateThrows(): void
     {
         $field = new FieldDefinition('count', 'count', 'integer', 'meta', 'writable');
+        Functions\when('sanitize_meta')->returnArg(2);
         Functions\when('update_post_meta')->justReturn(false);
         Functions\when('get_post_meta')->justReturn(['2']);
 

tests/Unit/Integrations/WordPress/Schema/TermAssignerTest.php

@@ -69,7 +69,33 @@ final class TermAssignerTest extends TestCase
         Functions\expect('wp_insert_term')->once()->with('Neu', 'category')->andReturn(['term_id' => 15]);
         Functions\expect('wp_set_object_terms')->once()->with(5, [4, 15], 'category', false)->andReturn([4, 15]);
 
-        (new TermAssigner())->assign(5, ['category' => [4, 'Neu']]);
+        self::assertSame([15 => 'category'], (new TermAssigner())->assign(5, ['category' => [4, 'Neu']]));
+    }
+
+    public function testAFailedAssignmentDeletesTheTermsItCreated(): void
+    {
+        Functions\when('wp_insert_term')->justReturn(['term_id' => 15]);
+        Functions\when('wp_set_object_terms')->justReturn(new WP_Error('x', 'kaputt'));
+        Functions\expect('wp_delete_term')->once()->with(15, 'category')->andReturn(true);
+
+        $this->expectException(RuntimeException::class);
+
+        (new TermAssigner())->assign(5, ['category' => ['Neu']]);
+    }
+
+    public function testDeleteTermsAcceptsAlreadyMissingTermsAndThrowsOnRealFailures(): void
+    {
+        Functions\when('wp_delete_term')->alias(static fn (int $id): mixed => match ($id) {
+            15 => true,
+            16 => false,
+            default => new WP_Error('x', 'kaputt'),
+        });
+        $assigner = new TermAssigner();
+
+        $assigner->deleteTerms([15 => 'category', 16 => 'category']);
+
+        $this->expectException(RuntimeException::class);
+        $assigner->deleteTerms([15 => 'category', 17 => 'post_tag']);
     }
 
     public function testAssignFailureThrows(): void