Add test suite

phpunit.xml

···
 <?xml version="1.0" encoding="UTF-8"?>
-<phpunit bootstrap="vendor/autoload.php"
-         backupGlobals="false"
-         backupStaticAttributes="false"
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
          colors="true"
-         verbose="true"
-         convertErrorsToExceptions="true"
-         convertNoticesToExceptions="true"
-         convertWarningsToExceptions="true"
-         processIsolation="false"
-         stopOnFailure="false">
+         cacheDirectory=".phpunit.cache">
     <testsuites>
-        <testsuite name="Package">
-            <directory suffix=".php">./tests/</directory>
+        <testsuite name="Parity Test Suite">
+            <directory suffix="Test.php">./tests/</directory>
+            <exclude>./tests/Fixtures/</exclude>
         </testsuite>
     </testsuites>
-    <filter>
-        <whitelist>
+    <source>
+        <include>
             <directory>src/</directory>
-        </whitelist>
-    </filter>
+        </include>
+    </source>
+    <php>
+        <env name="APP_ENV" value="testing"/>
+        <env name="CACHE_DRIVER" value="array"/>
+        <env name="SESSION_DRIVER" value="array"/>
+        <env name="QUEUE_CONNECTION" value="sync"/>
+        <env name="DB_CONNECTION" value="sqlite"/>
+        <env name="DB_DATABASE" value=":memory:"/>
+    </php>
 </phpunit>

tests/Fixtures/SyncableMapper.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Fixtures;
+
+/**
+ * Mapper for SyncableModel (extends TestMapper with different model class).
+ */
+class SyncableMapper extends TestMapper
+{
+    public function modelClass(): string
+    {
+        return SyncableModel::class;
+    }
+}

tests/Fixtures/SyncableModel.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Fixtures;
+
+use SocialDept\AtpParity\Concerns\SyncsWithAtp;
+
+/**
+ * Test model with SyncsWithAtp trait for unit testing.
+ *
+ * Extends TestModel so it gets the same mapper from the registry.
+ */
+class SyncableModel extends TestModel
+{
+    use SyncsWithAtp;
+
+    protected $casts = [
+        'atp_synced_at' => 'datetime',
+    ];
+}

tests/Fixtures/TestMapper.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Fixtures;
+
+use Illuminate\Database\Eloquent\Model;
+use SocialDept\AtpParity\RecordMapper;
+use SocialDept\AtpSchema\Data\Data;
+
+/**
+ * Test mapper for unit testing.
+ */
+class TestMapper extends RecordMapper
+{
+    public function recordClass(): string
+    {
+        return TestRecord::class;
+    }
+
+    public function modelClass(): string
+    {
+        return TestModel::class;
+    }
+
+    protected function recordToAttributes(Data $record): array
+    {
+        return [
+            'content' => $record->text,
+        ];
+    }
+
+    protected function modelToRecordData(Model $model): array
+    {
+        return [
+            'text' => $model->content,
+            'createdAt' => $model->created_at?->toIso8601String(),
+        ];
+    }
+}

tests/Fixtures/TestModel.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Fixtures;
+
+use Illuminate\Database\Eloquent\Model;
+use SocialDept\AtpParity\Concerns\HasAtpRecord;
+
+/**
+ * Test model for unit testing.
+ */
+class TestModel extends Model
+{
+    use HasAtpRecord;
+
+    protected $table = 'test_models';
+
+    protected $guarded = [];
+
+    protected $casts = [
+        'atp_synced_at' => 'datetime',
+    ];
+}

tests/Fixtures/TestRecord.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Fixtures;
+
+use SocialDept\AtpSchema\Data\Data;
+
+/**
+ * Test record for unit testing.
+ */
+class TestRecord extends Data
+{
+    public function __construct(
+        public readonly string $text,
+        public readonly ?string $createdAt = null,
+    ) {}
+
+    public static function getLexicon(): string
+    {
+        return 'app.test.record';
+    }
+
+    public static function fromArray(array $data): static
+    {
+        return new static(
+            text: $data['text'] ?? '',
+            createdAt: $data['createdAt'] ?? null,
+        );
+    }
+
+    public function toArray(): array
+    {
+        return array_filter([
+            'text' => $this->text,
+            'createdAt' => $this->createdAt,
+        ], fn ($v) => $v !== null);
+    }
+}

tests/TestCase.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests;
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+use Orchestra\Testbench\TestCase as Orchestra;
+use SocialDept\AtpClient\AtpClientServiceProvider;
+use SocialDept\AtpParity\ParityServiceProvider;
+use SocialDept\AtpResolver\ResolverServiceProvider;
+use SocialDept\AtpSignals\SignalServiceProvider;
+
+abstract class TestCase extends Orchestra
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->setUpDatabase();
+    }
+
+    protected function getPackageProviders($app): array
+    {
+        return [
+            ResolverServiceProvider::class,
+            AtpClientServiceProvider::class,
+            SignalServiceProvider::class,
+            ParityServiceProvider::class,
+        ];
+    }
+
+    protected function getEnvironmentSetUp($app): void
+    {
+        $app['config']->set('database.default', 'testing');
+        $app['config']->set('database.connections.testing', [
+            'driver' => 'sqlite',
+            'database' => ':memory:',
+            'prefix' => '',
+        ]);
+
+        $app['config']->set('parity.columns.uri', 'atp_uri');
+        $app['config']->set('parity.columns.cid', 'atp_cid');
+    }
+
+    protected function setUpDatabase(): void
+    {
+        Schema::create('test_models', function (Blueprint $table) {
+            $table->id();
+            $table->string('content')->nullable();
+            $table->string('did')->nullable();
+            $table->string('atp_uri')->nullable()->unique();
+            $table->string('atp_cid')->nullable();
+            $table->timestamp('atp_synced_at')->nullable();
+            $table->timestamps();
+        });
+
+        Schema::create('parity_import_states', function (Blueprint $table) {
+            $table->id();
+            $table->string('did');
+            $table->string('collection');
+            $table->string('status')->default('pending');
+            $table->integer('records_synced')->default(0);
+            $table->integer('records_skipped')->default(0);
+            $table->integer('records_failed')->default(0);
+            $table->string('cursor')->nullable();
+            $table->text('error')->nullable();
+            $table->timestamp('started_at')->nullable();
+            $table->timestamp('completed_at')->nullable();
+            $table->timestamps();
+
+            $table->unique(['did', 'collection']);
+        });
+
+        Schema::create('parity_conflicts', function (Blueprint $table) {
+            $table->id();
+            $table->morphs('model');
+            $table->string('uri');
+            $table->string('remote_cid');
+            $table->json('remote_data');
+            $table->string('status')->default('pending');
+            $table->timestamp('resolved_at')->nullable();
+            $table->timestamps();
+        });
+    }
+}

tests/Unit/Concerns/HasAtpRecordTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit\Concerns;
+
+use SocialDept\AtpParity\MapperRegistry;
+use SocialDept\AtpParity\Tests\Fixtures\TestMapper;
+use SocialDept\AtpParity\Tests\Fixtures\TestModel;
+use SocialDept\AtpParity\Tests\Fixtures\TestRecord;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class HasAtpRecordTest extends TestCase
+{
+    public function test_get_atp_uri_returns_uri_from_column(): void
+    {
+        $model = new TestModel(['atp_uri' => 'at://did:plc:test/app.test.record/abc123']);
+
+        $this->assertSame('at://did:plc:test/app.test.record/abc123', $model->getAtpUri());
+    }
+
+    public function test_get_atp_uri_returns_null_when_not_set(): void
+    {
+        $model = new TestModel();
+
+        $this->assertNull($model->getAtpUri());
+    }
+
+    public function test_get_atp_cid_returns_cid_from_column(): void
+    {
+        $model = new TestModel(['atp_cid' => 'bafyreiabc123']);
+
+        $this->assertSame('bafyreiabc123', $model->getAtpCid());
+    }
+
+    public function test_get_atp_cid_returns_null_when_not_set(): void
+    {
+        $model = new TestModel();
+
+        $this->assertNull($model->getAtpCid());
+    }
+
+    public function test_get_atp_did_extracts_did_from_uri(): void
+    {
+        $model = new TestModel(['atp_uri' => 'at://did:plc:z72i7hdynmk6r22z27h6tvur/app.bsky.feed.post/abc123']);
+
+        $this->assertSame('did:plc:z72i7hdynmk6r22z27h6tvur', $model->getAtpDid());
+    }
+
+    public function test_get_atp_did_returns_null_when_no_uri(): void
+    {
+        $model = new TestModel();
+
+        $this->assertNull($model->getAtpDid());
+    }
+
+    public function test_get_atp_did_returns_null_for_malformed_uri(): void
+    {
+        $model = new TestModel(['atp_uri' => 'invalid-uri']);
+
+        $this->assertNull($model->getAtpDid());
+    }
+
+    public function test_get_atp_collection_extracts_collection_from_uri(): void
+    {
+        $model = new TestModel(['atp_uri' => 'at://did:plc:test/app.bsky.feed.post/abc123']);
+
+        $this->assertSame('app.bsky.feed.post', $model->getAtpCollection());
+    }
+
+    public function test_get_atp_collection_returns_null_when_no_uri(): void
+    {
+        $model = new TestModel();
+
+        $this->assertNull($model->getAtpCollection());
+    }
+
+    public function test_get_atp_rkey_extracts_rkey_from_uri(): void
+    {
+        $model = new TestModel(['atp_uri' => 'at://did:plc:test/app.bsky.feed.post/3kj2h4k5j']);
+
+        $this->assertSame('3kj2h4k5j', $model->getAtpRkey());
+    }
+
+    public function test_get_atp_rkey_returns_null_when_no_uri(): void
+    {
+        $model = new TestModel();
+
+        $this->assertNull($model->getAtpRkey());
+    }
+
+    public function test_has_atp_record_returns_true_when_uri_set(): void
+    {
+        $model = new TestModel(['atp_uri' => 'at://did/col/rkey']);
+
+        $this->assertTrue($model->hasAtpRecord());
+    }
+
+    public function test_has_atp_record_returns_false_when_no_uri(): void
+    {
+        $model = new TestModel();
+
+        $this->assertFalse($model->hasAtpRecord());
+    }
+
+    public function test_get_atp_mapper_returns_mapper_when_registered(): void
+    {
+        $registry = app(MapperRegistry::class);
+        $registry->register(new TestMapper());
+
+        $model = new TestModel();
+        $mapper = $model->getAtpMapper();
+
+        $this->assertInstanceOf(TestMapper::class, $mapper);
+    }
+
+    public function test_get_atp_mapper_returns_null_when_not_registered(): void
+    {
+        // Fresh registry without any mappers
+        $this->app->forgetInstance(MapperRegistry::class);
+        $this->app->singleton(MapperRegistry::class);
+
+        $model = new TestModel();
+
+        $this->assertNull($model->getAtpMapper());
+    }
+
+    public function test_to_atp_record_converts_model_to_record(): void
+    {
+        $registry = app(MapperRegistry::class);
+        $registry->register(new TestMapper());
+
+        $model = new TestModel(['content' => 'Hello world']);
+        $record = $model->toAtpRecord();
+
+        $this->assertInstanceOf(TestRecord::class, $record);
+        $this->assertSame('Hello world', $record->text);
+    }
+
+    public function test_to_atp_record_returns_null_when_no_mapper(): void
+    {
+        $this->app->forgetInstance(MapperRegistry::class);
+        $this->app->singleton(MapperRegistry::class);
+
+        $model = new TestModel(['content' => 'Hello']);
+
+        $this->assertNull($model->toAtpRecord());
+    }
+
+    public function test_scope_with_atp_record_filters_synced_models(): void
+    {
+        TestModel::create(['content' => 'Synced', 'atp_uri' => 'at://did/col/rkey1']);
+        TestModel::create(['content' => 'Not synced']);
+        TestModel::create(['content' => 'Also synced', 'atp_uri' => 'at://did/col/rkey2']);
+
+        $synced = TestModel::withAtpRecord()->get();
+
+        $this->assertCount(2, $synced);
+        $this->assertTrue($synced->every(fn ($m) => $m->atp_uri !== null));
+    }
+
+    public function test_scope_without_atp_record_filters_unsynced_models(): void
+    {
+        TestModel::create(['content' => 'Synced', 'atp_uri' => 'at://did/col/rkey']);
+        TestModel::create(['content' => 'Not synced 1']);
+        TestModel::create(['content' => 'Not synced 2']);
+
+        $unsynced = TestModel::withoutAtpRecord()->get();
+
+        $this->assertCount(2, $unsynced);
+        $this->assertTrue($unsynced->every(fn ($m) => $m->atp_uri === null));
+    }
+
+    public function test_scope_where_atp_uri_finds_by_uri(): void
+    {
+        TestModel::create(['content' => 'Target', 'atp_uri' => 'at://did/col/target']);
+        TestModel::create(['content' => 'Other', 'atp_uri' => 'at://did/col/other']);
+
+        $found = TestModel::whereAtpUri('at://did/col/target')->first();
+
+        $this->assertNotNull($found);
+        $this->assertSame('Target', $found->content);
+    }
+
+    public function test_scope_where_atp_uri_returns_null_when_not_found(): void
+    {
+        TestModel::create(['content' => 'Some', 'atp_uri' => 'at://did/col/some']);
+
+        $found = TestModel::whereAtpUri('at://did/col/nonexistent')->first();
+
+        $this->assertNull($found);
+    }
+}

tests/Unit/Concerns/SyncsWithAtpTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit\Concerns;
+
+use Carbon\Carbon;
+use SocialDept\AtpParity\MapperRegistry;
+use SocialDept\AtpParity\Tests\Fixtures\SyncableMapper;
+use SocialDept\AtpParity\Tests\Fixtures\SyncableModel;
+use SocialDept\AtpParity\Tests\Fixtures\TestRecord;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class SyncsWithAtpTest extends TestCase
+{
+    public function test_get_atp_synced_at_column_returns_default(): void
+    {
+        $model = new SyncableModel();
+
+        $this->assertSame('atp_synced_at', $model->getAtpSyncedAtColumn());
+    }
+
+    public function test_get_atp_synced_at_returns_timestamp(): void
+    {
+        $now = Carbon::now();
+        $model = new SyncableModel(['atp_synced_at' => $now]);
+
+        $this->assertEquals($now->toDateTimeString(), $model->getAtpSyncedAt()->toDateTimeString());
+    }
+
+    public function test_get_atp_synced_at_returns_null_when_not_set(): void
+    {
+        $model = new SyncableModel();
+
+        $this->assertNull($model->getAtpSyncedAt());
+    }
+
+    public function test_mark_as_synced_sets_all_attributes(): void
+    {
+        Carbon::setTestNow('2024-01-15 12:00:00');
+
+        $model = new SyncableModel();
+        $model->markAsSynced('at://did/col/rkey', 'cid123');
+
+        $this->assertSame('at://did/col/rkey', $model->atp_uri);
+        $this->assertSame('cid123', $model->atp_cid);
+        $this->assertSame('2024-01-15 12:00:00', $model->atp_synced_at->toDateTimeString());
+
+        Carbon::setTestNow();
+    }
+
+    public function test_has_local_changes_returns_true_when_never_synced(): void
+    {
+        $model = new SyncableModel();
+
+        $this->assertTrue($model->hasLocalChanges());
+    }
+
+    public function test_has_local_changes_returns_false_when_no_updated_at(): void
+    {
+        $model = new SyncableModel([
+            'atp_synced_at' => Carbon::now(),
+        ]);
+
+        $this->assertFalse($model->hasLocalChanges());
+    }
+
+    public function test_has_local_changes_returns_true_when_updated_after_sync(): void
+    {
+        $model = new SyncableModel([
+            'atp_synced_at' => Carbon::parse('2024-01-15 12:00:00'),
+            'updated_at' => Carbon::parse('2024-01-15 13:00:00'),
+        ]);
+
+        $this->assertTrue($model->hasLocalChanges());
+    }
+
+    public function test_has_local_changes_returns_false_when_synced_after_update(): void
+    {
+        $model = new SyncableModel([
+            'updated_at' => Carbon::parse('2024-01-15 12:00:00'),
+            'atp_synced_at' => Carbon::parse('2024-01-15 13:00:00'),
+        ]);
+
+        $this->assertFalse($model->hasLocalChanges());
+    }
+
+    public function test_update_from_record_updates_model_and_sync_timestamp(): void
+    {
+        Carbon::setTestNow('2024-01-15 14:00:00');
+
+        $registry = app(MapperRegistry::class);
+        $registry->register(new SyncableMapper());
+
+        $model = new SyncableModel(['content' => 'Original']);
+        $record = new TestRecord(text: 'From remote');
+
+        $model->updateFromRecord($record, 'at://did/col/rkey', 'newcid');
+
+        $this->assertSame('From remote', $model->content);
+        $this->assertSame('at://did/col/rkey', $model->atp_uri);
+        $this->assertSame('newcid', $model->atp_cid);
+        $this->assertSame('2024-01-15 14:00:00', $model->atp_synced_at->toDateTimeString());
+
+        Carbon::setTestNow();
+    }
+
+    public function test_update_from_record_does_nothing_without_mapper(): void
+    {
+        $this->app->forgetInstance(MapperRegistry::class);
+        $this->app->singleton(MapperRegistry::class);
+
+        $model = new SyncableModel(['content' => 'Original']);
+        $record = new TestRecord(text: 'From remote');
+
+        $model->updateFromRecord($record, 'at://did/col/rkey', 'cid');
+
+        $this->assertSame('Original', $model->content);
+    }
+
+    public function test_inherits_has_atp_record_methods(): void
+    {
+        $model = new SyncableModel(['atp_uri' => 'at://did:plc:test/app.test.record/rkey']);
+
+        $this->assertTrue($model->hasAtpRecord());
+        $this->assertSame('did:plc:test', $model->getAtpDid());
+        $this->assertSame('app.test.record', $model->getAtpCollection());
+        $this->assertSame('rkey', $model->getAtpRkey());
+    }
+}

tests/Unit/Import/ImportResultTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit\Import;
+
+use SocialDept\AtpParity\Import\ImportResult;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class ImportResultTest extends TestCase
+{
+    public function test_success_creates_completed_result(): void
+    {
+        $result = ImportResult::success(
+            did: 'did:plc:test123',
+            collection: 'app.bsky.feed.post',
+            synced: 50,
+            skipped: 5,
+            failed: 2
+        );
+
+        $this->assertTrue($result->isSuccess());
+        $this->assertFalse($result->isPartial());
+        $this->assertFalse($result->isFailed());
+        $this->assertTrue($result->completed);
+        $this->assertNull($result->error);
+        $this->assertSame(50, $result->recordsSynced);
+        $this->assertSame(5, $result->recordsSkipped);
+        $this->assertSame(2, $result->recordsFailed);
+    }
+
+    public function test_partial_creates_incomplete_result(): void
+    {
+        $result = ImportResult::partial(
+            did: 'did:plc:test123',
+            collection: 'app.bsky.feed.post',
+            synced: 100,
+            cursor: 'abc123'
+        );
+
+        $this->assertFalse($result->isSuccess());
+        $this->assertTrue($result->isPartial());
+        $this->assertFalse($result->isFailed());
+        $this->assertFalse($result->completed);
+        $this->assertSame('abc123', $result->cursor);
+        $this->assertNull($result->error);
+    }
+
+    public function test_failed_creates_error_result(): void
+    {
+        $result = ImportResult::failed(
+            did: 'did:plc:test123',
+            collection: 'app.bsky.feed.post',
+            error: 'Connection failed'
+        );
+
+        $this->assertFalse($result->isSuccess());
+        $this->assertFalse($result->isPartial()); // no records synced
+        $this->assertTrue($result->isFailed());
+        $this->assertSame('Connection failed', $result->error);
+    }
+
+    public function test_failed_with_partial_progress(): void
+    {
+        $result = ImportResult::failed(
+            did: 'did:plc:test123',
+            collection: 'app.bsky.feed.post',
+            error: 'Connection lost',
+            synced: 50,
+            cursor: 'xyz789'
+        );
+
+        $this->assertTrue($result->isFailed());
+        $this->assertTrue($result->isPartial()); // has synced records
+        $this->assertSame(50, $result->recordsSynced);
+        $this->assertSame('xyz789', $result->cursor);
+    }
+
+    public function test_total_processed_sums_all_records(): void
+    {
+        $result = ImportResult::success(
+            did: 'did:plc:test123',
+            collection: 'app.bsky.feed.post',
+            synced: 50,
+            skipped: 10,
+            failed: 5
+        );
+
+        $this->assertSame(65, $result->totalProcessed());
+    }
+
+    public function test_aggregate_combines_multiple_results(): void
+    {
+        $results = [
+            ImportResult::success('did:plc:test', 'app.bsky.feed.post', synced: 50),
+            ImportResult::success('did:plc:test', 'app.bsky.feed.like', synced: 100, failed: 5),
+        ];
+
+        $aggregate = ImportResult::aggregate('did:plc:test', $results);
+
+        $this->assertTrue($aggregate->isSuccess());
+        $this->assertSame('*', $aggregate->collection);
+        $this->assertSame(150, $aggregate->recordsSynced);
+        $this->assertSame(5, $aggregate->recordsFailed);
+        $this->assertNull($aggregate->error);
+    }
+
+    public function test_aggregate_marks_incomplete_when_any_incomplete(): void
+    {
+        $results = [
+            ImportResult::success('did:plc:test', 'app.bsky.feed.post', synced: 50),
+            ImportResult::partial('did:plc:test', 'app.bsky.feed.like', synced: 100, cursor: 'abc'),
+        ];
+
+        $aggregate = ImportResult::aggregate('did:plc:test', $results);
+
+        $this->assertFalse($aggregate->completed);
+    }
+
+    public function test_aggregate_combines_errors(): void
+    {
+        $results = [
+            ImportResult::failed('did:plc:test', 'app.bsky.feed.post', error: 'Error 1'),
+            ImportResult::failed('did:plc:test', 'app.bsky.feed.like', error: 'Error 2'),
+        ];
+
+        $aggregate = ImportResult::aggregate('did:plc:test', $results);
+
+        $this->assertTrue($aggregate->isFailed());
+        $this->assertStringContainsString('app.bsky.feed.post: Error 1', $aggregate->error);
+        $this->assertStringContainsString('app.bsky.feed.like: Error 2', $aggregate->error);
+    }
+
+    public function test_aggregate_with_empty_array(): void
+    {
+        $aggregate = ImportResult::aggregate('did:plc:test', []);
+
+        $this->assertTrue($aggregate->completed);
+        $this->assertSame(0, $aggregate->recordsSynced);
+    }
+}

tests/Unit/Import/ImportServiceTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit\Import;
+
+use Illuminate\Support\Facades\Event;
+use Mockery;
+use SocialDept\AtpParity\Events\ImportCompleted;
+use SocialDept\AtpParity\Events\ImportFailed;
+use SocialDept\AtpParity\Events\ImportProgress;
+use SocialDept\AtpParity\Events\ImportStarted;
+use SocialDept\AtpParity\Import\ImportService;
+use SocialDept\AtpParity\Import\ImportState;
+use SocialDept\AtpParity\MapperRegistry;
+use SocialDept\AtpParity\Tests\Fixtures\TestMapper;
+use SocialDept\AtpParity\Tests\Fixtures\TestModel;
+use SocialDept\AtpParity\Tests\TestCase;
+use SocialDept\AtpResolver\Facades\Resolver;
+
+class ImportServiceTest extends TestCase
+{
+    private ImportService $service;
+
+    private MapperRegistry $registry;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->registry = new MapperRegistry();
+        $this->registry->register(new TestMapper());
+
+        $this->service = new ImportService($this->registry);
+
+        Event::fake();
+    }
+
+    public function test_import_user_collection_returns_failed_when_no_mapper(): void
+    {
+        $this->app->forgetInstance(MapperRegistry::class);
+        $emptyRegistry = new MapperRegistry();
+        $service = new ImportService($emptyRegistry);
+
+        $result = $service->importUserCollection('did:plc:test', 'unknown.collection');
+
+        $this->assertTrue($result->isFailed());
+        $this->assertStringContainsString('No mapper registered', $result->error);
+    }
+
+    public function test_import_user_collection_fails_when_pds_not_resolved(): void
+    {
+        Resolver::shouldReceive('resolvePds')
+            ->with('did:plc:test')
+            ->andReturnNull();
+
+        $result = $this->service->importUserCollection('did:plc:test', 'app.test.record');
+
+        $this->assertTrue($result->isFailed());
+        $this->assertStringContainsString('Could not resolve PDS', $result->error);
+        Event::assertDispatched(ImportFailed::class);
+    }
+
+    /**
+     * @group integration
+     */
+    public function test_import_user_collection_imports_records(): void
+    {
+        $this->markTestSkipped('Requires integration test with real or mock ATP client - AtpClient has typed properties that prevent mocking');
+    }
+
+    /**
+     * @group integration
+     */
+    public function test_import_dispatches_events(): void
+    {
+        $this->markTestSkipped('Requires integration test with real or mock ATP client - AtpClient has typed properties that prevent mocking');
+    }
+
+    /**
+     * @group integration
+     */
+    public function test_import_calls_progress_callback(): void
+    {
+        $this->markTestSkipped('Requires integration test with real or mock ATP client - AtpClient has typed properties that prevent mocking');
+    }
+
+    /**
+     * @group integration
+     */
+    public function test_import_user_imports_multiple_collections(): void
+    {
+        $this->markTestSkipped('Requires integration test with real or mock ATP client - AtpClient has typed properties that prevent mocking');
+    }
+
+    public function test_get_status_returns_import_state(): void
+    {
+        ImportState::create([
+            'did' => 'did:plc:test',
+            'collection' => 'app.test.record',
+            'status' => 'completed',
+            'records_synced' => 50,
+        ]);
+
+        $state = $this->service->getStatus('did:plc:test', 'app.test.record');
+
+        $this->assertNotNull($state);
+        $this->assertSame('completed', $state->status);
+        $this->assertSame(50, $state->records_synced);
+    }
+
+    public function test_get_status_returns_null_when_not_found(): void
+    {
+        $state = $this->service->getStatus('did:plc:unknown', 'unknown');
+
+        $this->assertNull($state);
+    }
+
+    public function test_is_imported_returns_true_when_completed(): void
+    {
+        ImportState::create([
+            'did' => 'did:plc:test',
+            'collection' => 'app.test.record',
+            'status' => 'completed',
+        ]);
+
+        $this->assertTrue($this->service->isImported('did:plc:test', 'app.test.record'));
+    }
+
+    public function test_is_imported_returns_false_when_not_started(): void
+    {
+        $this->assertFalse($this->service->isImported('did:plc:test', 'app.test.record'));
+    }
+
+    public function test_reset_deletes_import_state(): void
+    {
+        ImportState::create([
+            'did' => 'did:plc:test',
+            'collection' => 'app.test.record',
+            'status' => 'completed',
+        ]);
+
+        $this->service->reset('did:plc:test', 'app.test.record');
+
+        $this->assertNull($this->service->getStatus('did:plc:test', 'app.test.record'));
+    }
+
+    public function test_import_skips_already_completed(): void
+    {
+        ImportState::create([
+            'did' => 'did:plc:test',
+            'collection' => 'app.test.record',
+            'status' => 'completed',
+            'records_synced' => 100,
+        ]);
+
+        // No mocking needed - should return cached result
+        $result = $this->service->importUserCollection('did:plc:test', 'app.test.record');
+
+        $this->assertTrue($result->completed);
+        $this->assertSame(100, $result->recordsSynced);
+    }
+
+    /**
+     * @group integration
+     */
+    public function test_import_handles_record_failures_gracefully(): void
+    {
+        $this->markTestSkipped('Requires integration test with real or mock ATP client - AtpClient has typed properties that prevent mocking');
+    }
+}

tests/Unit/MapperRegistryTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit;
+
+use SocialDept\AtpParity\MapperRegistry;
+use SocialDept\AtpParity\Tests\Fixtures\TestMapper;
+use SocialDept\AtpParity\Tests\Fixtures\TestModel;
+use SocialDept\AtpParity\Tests\Fixtures\TestRecord;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class MapperRegistryTest extends TestCase
+{
+    private MapperRegistry $registry;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->registry = new MapperRegistry();
+    }
+
+    public function test_register_adds_mapper_to_all_indices(): void
+    {
+        $mapper = new TestMapper();
+
+        $this->registry->register($mapper);
+
+        $this->assertSame($mapper, $this->registry->forRecord(TestRecord::class));
+        $this->assertSame($mapper, $this->registry->forModel(TestModel::class));
+        $this->assertSame($mapper, $this->registry->forLexicon('app.test.record'));
+    }
+
+    public function test_for_record_returns_null_for_unregistered_class(): void
+    {
+        $result = $this->registry->forRecord('NonExistent\\Record');
+
+        $this->assertNull($result);
+    }
+
+    public function test_for_model_returns_null_for_unregistered_class(): void
+    {
+        $result = $this->registry->forModel('NonExistent\\Model');
+
+        $this->assertNull($result);
+    }
+
+    public function test_for_lexicon_returns_null_for_unregistered_nsid(): void
+    {
+        $result = $this->registry->forLexicon('app.unknown.record');
+
+        $this->assertNull($result);
+    }
+
+    public function test_has_lexicon_returns_true_when_registered(): void
+    {
+        $this->registry->register(new TestMapper());
+
+        $this->assertTrue($this->registry->hasLexicon('app.test.record'));
+    }
+
+    public function test_has_lexicon_returns_false_when_not_registered(): void
+    {
+        $this->assertFalse($this->registry->hasLexicon('app.unknown.record'));
+    }
+
+    public function test_lexicons_returns_all_registered_nsids(): void
+    {
+        $this->registry->register(new TestMapper());
+
+        $lexicons = $this->registry->lexicons();
+
+        $this->assertContains('app.test.record', $lexicons);
+        $this->assertCount(1, $lexicons);
+    }
+
+    public function test_lexicons_returns_empty_array_when_no_mappers_registered(): void
+    {
+        $this->assertEmpty($this->registry->lexicons());
+    }
+
+    public function test_all_returns_all_registered_mappers(): void
+    {
+        $mapper = new TestMapper();
+        $this->registry->register($mapper);
+
+        $all = $this->registry->all();
+
+        $this->assertCount(1, $all);
+        $this->assertSame($mapper, $all[0]);
+    }
+
+    public function test_all_returns_empty_array_when_no_mappers_registered(): void
+    {
+        $this->assertEmpty($this->registry->all());
+    }
+
+    public function test_registering_same_mapper_twice_overwrites(): void
+    {
+        $mapper1 = new TestMapper();
+        $mapper2 = new TestMapper();
+
+        $this->registry->register($mapper1);
+        $this->registry->register($mapper2);
+
+        $this->assertSame($mapper2, $this->registry->forRecord(TestRecord::class));
+        $this->assertCount(1, $this->registry->all());
+    }
+}

tests/Unit/Publish/PublishResultTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit\Publish;
+
+use SocialDept\AtpParity\Publish\PublishResult;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class PublishResultTest extends TestCase
+{
+    public function test_success_creates_successful_result(): void
+    {
+        $result = PublishResult::success(
+            uri: 'at://did:plc:test/app.bsky.feed.post/abc123',
+            cid: 'bafyreiabc123'
+        );
+
+        $this->assertTrue($result->isSuccess());
+        $this->assertFalse($result->isFailed());
+        $this->assertSame('at://did:plc:test/app.bsky.feed.post/abc123', $result->uri);
+        $this->assertSame('bafyreiabc123', $result->cid);
+        $this->assertNull($result->error);
+    }
+
+    public function test_failed_creates_failed_result(): void
+    {
+        $result = PublishResult::failed('Authentication required');
+
+        $this->assertFalse($result->isSuccess());
+        $this->assertTrue($result->isFailed());
+        $this->assertNull($result->uri);
+        $this->assertNull($result->cid);
+        $this->assertSame('Authentication required', $result->error);
+    }
+
+    public function test_is_success_returns_correct_boolean(): void
+    {
+        $success = new PublishResult(success: true);
+        $failure = new PublishResult(success: false);
+
+        $this->assertTrue($success->isSuccess());
+        $this->assertFalse($failure->isSuccess());
+    }
+
+    public function test_is_failed_returns_correct_boolean(): void
+    {
+        $success = new PublishResult(success: true);
+        $failure = new PublishResult(success: false);
+
+        $this->assertFalse($success->isFailed());
+        $this->assertTrue($failure->isFailed());
+    }
+
+    public function test_success_result_properties_are_accessible(): void
+    {
+        $result = PublishResult::success('at://did/col/rkey', 'cid123');
+
+        $this->assertTrue($result->success);
+        $this->assertSame('at://did/col/rkey', $result->uri);
+        $this->assertSame('cid123', $result->cid);
+    }
+
+    public function test_failed_result_error_is_accessible(): void
+    {
+        $result = PublishResult::failed('Something went wrong');
+
+        $this->assertFalse($result->success);
+        $this->assertSame('Something went wrong', $result->error);
+    }
+}

tests/Unit/Publish/PublishServiceTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit\Publish;
+
+use Illuminate\Support\Facades\Event;
+use Mockery;
+use SocialDept\AtpParity\Events\RecordPublished;
+use SocialDept\AtpParity\Events\RecordUnpublished;
+use SocialDept\AtpParity\MapperRegistry;
+use SocialDept\AtpParity\Publish\PublishService;
+use SocialDept\AtpParity\Tests\Fixtures\TestMapper;
+use SocialDept\AtpParity\Tests\Fixtures\TestModel;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class PublishServiceTest extends TestCase
+{
+    private PublishService $service;
+
+    private MapperRegistry $registry;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->registry = new MapperRegistry();
+        $this->registry->register(new TestMapper());
+
+        $this->service = new PublishService($this->registry);
+
+        Event::fake();
+    }
+
+    public function test_publish_fails_when_no_did_available(): void
+    {
+        $model = new TestModel(['content' => 'Test']);
+
+        $result = $this->service->publish($model);
+
+        $this->assertTrue($result->isFailed());
+        $this->assertStringContainsString('No DID', $result->error);
+    }
+
+    public function test_publish_uses_did_from_model_column(): void
+    {
+        $model = new TestModel([
+            'content' => 'Test',
+            'did' => 'did:plc:test123',
+        ]);
+
+        $this->mockAtpClient('did:plc:test123', 'at://did:plc:test123/app.test.record/abc', 'cid123');
+
+        $result = $this->service->publish($model);
+
+        $this->assertTrue($result->isSuccess());
+        $this->assertSame('at://did:plc:test123/app.test.record/abc', $result->uri);
+    }
+
+    public function test_publish_as_creates_record_with_specified_did(): void
+    {
+        $model = new TestModel(['content' => 'Hello world']);
+
+        $this->mockAtpClient('did:plc:specified', 'at://did:plc:specified/app.test.record/xyz', 'newcid');
+
+        $result = $this->service->publishAs('did:plc:specified', $model);
+
+        $this->assertTrue($result->isSuccess());
+        $this->assertSame('at://did:plc:specified/app.test.record/xyz', $result->uri);
+        $this->assertSame('newcid', $result->cid);
+    }
+
+    public function test_publish_as_updates_model_metadata(): void
+    {
+        $model = TestModel::create(['content' => 'Test']);
+
+        $this->mockAtpClient('did:plc:test', 'at://did:plc:test/app.test.record/rkey', 'cid');
+
+        $this->service->publishAs('did:plc:test', $model);
+
+        $model->refresh();
+        $this->assertSame('at://did:plc:test/app.test.record/rkey', $model->atp_uri);
+        $this->assertSame('cid', $model->atp_cid);
+    }
+
+    public function test_publish_dispatches_record_published_event(): void
+    {
+        $model = new TestModel(['content' => 'Test', 'did' => 'did:plc:test']);
+
+        $this->mockAtpClient('did:plc:test', 'at://did/col/rkey', 'cid');
+
+        $this->service->publish($model);
+
+        Event::assertDispatched(RecordPublished::class);
+    }
+
+    public function test_publish_redirects_to_update_when_already_published(): void
+    {
+        $model = TestModel::create([
+            'content' => 'Existing',
+            'atp_uri' => 'at://did:plc:test/app.test.record/existing',
+            'atp_cid' => 'oldcid',
+        ]);
+
+        $this->mockAtpClientForUpdate('did:plc:test', 'at://did:plc:test/app.test.record/existing', 'newcid');
+
+        $result = $this->service->publishAs('did:plc:test', $model);
+
+        $this->assertTrue($result->isSuccess());
+    }
+
+    public function test_update_fails_when_not_published(): void
+    {
+        $model = new TestModel(['content' => 'Not published']);
+
+        $result = $this->service->update($model);
+
+        $this->assertTrue($result->isFailed());
+        $this->assertStringContainsString('not been published', $result->error);
+    }
+
+    public function test_update_calls_put_record(): void
+    {
+        $model = TestModel::create([
+            'content' => 'Updated content',
+            'atp_uri' => 'at://did:plc:test/app.test.record/rkey123',
+            'atp_cid' => 'oldcid',
+        ]);
+
+        $this->mockAtpClientForUpdate('did:plc:test', 'at://did:plc:test/app.test.record/rkey123', 'updatedcid');
+
+        $result = $this->service->update($model);
+
+        $this->assertTrue($result->isSuccess());
+        $this->assertSame('updatedcid', $result->cid);
+    }
+
+    public function test_delete_removes_record_and_clears_metadata(): void
+    {
+        $model = TestModel::create([
+            'content' => 'To delete',
+            'atp_uri' => 'at://did:plc:test/app.test.record/todelete',
+            'atp_cid' => 'cid',
+        ]);
+
+        $this->mockAtpClientForDelete('did:plc:test');
+
+        $result = $this->service->delete($model);
+
+        $this->assertTrue($result);
+
+        $model->refresh();
+        $this->assertNull($model->atp_uri);
+        $this->assertNull($model->atp_cid);
+    }
+
+    public function test_delete_dispatches_record_unpublished_event(): void
+    {
+        $model = TestModel::create([
+            'content' => 'To delete',
+            'atp_uri' => 'at://did:plc:test/app.test.record/xyz',
+            'atp_cid' => 'cid',
+        ]);
+
+        $this->mockAtpClientForDelete('did:plc:test');
+
+        $this->service->delete($model);
+
+        Event::assertDispatched(RecordUnpublished::class);
+    }
+
+    public function test_delete_returns_false_when_not_published(): void
+    {
+        $model = new TestModel(['content' => 'Not published']);
+
+        $result = $this->service->delete($model);
+
+        $this->assertFalse($result);
+    }
+
+    public function test_publish_handles_exception_gracefully(): void
+    {
+        $model = new TestModel(['content' => 'Test', 'did' => 'did:plc:test']);
+
+        $this->mockAtpClientWithException('did:plc:test', 'API error occurred');
+
+        $result = $this->service->publish($model);
+
+        $this->assertTrue($result->isFailed());
+        $this->assertSame('API error occurred', $result->error);
+    }
+
+    public function test_update_fails_for_invalid_uri(): void
+    {
+        $model = new TestModel([
+            'content' => 'Test',
+            'atp_uri' => 'invalid-uri-format',
+        ]);
+
+        $result = $this->service->update($model);
+
+        $this->assertTrue($result->isFailed());
+        $this->assertStringContainsString('Invalid AT Protocol URI', $result->error);
+    }
+
+    /**
+     * Mock AtpClient for create operations.
+     */
+    protected function mockAtpClient(string $did, string $returnUri, string $returnCid): void
+    {
+        $response = new \stdClass();
+        $response->uri = $returnUri;
+        $response->cid = $returnCid;
+
+        $repoClient = Mockery::mock();
+        $repoClient->shouldReceive('createRecord')
+            ->andReturn($response);
+
+        // Create client mock with property chain (no typed properties)
+        $atprotoClient = Mockery::mock();
+        $atprotoClient->repo = $repoClient;
+
+        $atpClient = Mockery::mock();
+        $atpClient->atproto = $atprotoClient;
+
+        // Bind a manager mock to the container
+        $manager = Mockery::mock();
+        $manager->shouldReceive('as')
+            ->with($did)
+            ->andReturn($atpClient);
+
+        $this->app->instance('atp-client', $manager);
+    }
+
+    /**
+     * Mock AtpClient for update operations.
+     */
+    protected function mockAtpClientForUpdate(string $did, string $returnUri, string $returnCid): void
+    {
+        $response = new \stdClass();
+        $response->uri = $returnUri;
+        $response->cid = $returnCid;
+
+        $repoClient = Mockery::mock();
+        $repoClient->shouldReceive('putRecord')
+            ->andReturn($response);
+
+        // Create client mock with property chain (no typed properties)
+        $atprotoClient = Mockery::mock();
+        $atprotoClient->repo = $repoClient;
+
+        $atpClient = Mockery::mock();
+        $atpClient->atproto = $atprotoClient;
+
+        // Bind a manager mock to the container
+        $manager = Mockery::mock();
+        $manager->shouldReceive('as')
+            ->with($did)
+            ->andReturn($atpClient);
+
+        $this->app->instance('atp-client', $manager);
+    }
+
+    /**
+     * Mock AtpClient for delete operations.
+     */
+    protected function mockAtpClientForDelete(string $did): void
+    {
+        $repoClient = Mockery::mock();
+        $repoClient->shouldReceive('deleteRecord')
+            ->andReturnNull();
+
+        // Create client mock with property chain (no typed properties)
+        $atprotoClient = Mockery::mock();
+        $atprotoClient->repo = $repoClient;
+
+        $atpClient = Mockery::mock();
+        $atpClient->atproto = $atprotoClient;
+
+        // Bind a manager mock to the container
+        $manager = Mockery::mock();
+        $manager->shouldReceive('as')
+            ->with($did)
+            ->andReturn($atpClient);
+
+        $this->app->instance('atp-client', $manager);
+    }
+
+    /**
+     * Mock AtpClient to throw exception.
+     */
+    protected function mockAtpClientWithException(string $did, string $message): void
+    {
+        $manager = Mockery::mock();
+        $manager->shouldReceive('as')
+            ->with($did)
+            ->andThrow(new \Exception($message));
+
+        $this->app->instance('atp-client', $manager);
+    }
+}

tests/Unit/RecordMapperTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit;
+
+use SocialDept\AtpParity\Tests\Fixtures\TestMapper;
+use SocialDept\AtpParity\Tests\Fixtures\TestModel;
+use SocialDept\AtpParity\Tests\Fixtures\TestRecord;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class RecordMapperTest extends TestCase
+{
+    private TestMapper $mapper;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->mapper = new TestMapper();
+    }
+
+    public function test_record_class_returns_correct_class(): void
+    {
+        $this->assertSame(TestRecord::class, $this->mapper->recordClass());
+    }
+
+    public function test_model_class_returns_correct_class(): void
+    {
+        $this->assertSame(TestModel::class, $this->mapper->modelClass());
+    }
+
+    public function test_lexicon_returns_record_lexicon(): void
+    {
+        $this->assertSame('app.test.record', $this->mapper->lexicon());
+    }
+
+    public function test_to_model_creates_model_with_attributes(): void
+    {
+        $record = new TestRecord(text: 'Hello world');
+
+        $model = $this->mapper->toModel($record);
+
+        $this->assertInstanceOf(TestModel::class, $model);
+        $this->assertSame('Hello world', $model->content);
+        $this->assertFalse($model->exists);
+    }
+
+    public function test_to_model_applies_meta(): void
+    {
+        $record = new TestRecord(text: 'Test');
+        $meta = [
+            'uri' => 'at://did:plc:test/app.test.record/abc123',
+            'cid' => 'bafyreiabc',
+        ];
+
+        $model = $this->mapper->toModel($record, $meta);
+
+        $this->assertSame('at://did:plc:test/app.test.record/abc123', $model->atp_uri);
+        $this->assertSame('bafyreiabc', $model->atp_cid);
+    }
+
+    public function test_to_record_converts_model_to_record(): void
+    {
+        $model = new TestModel(['content' => 'Test content']);
+
+        $record = $this->mapper->toRecord($model);
+
+        $this->assertInstanceOf(TestRecord::class, $record);
+        $this->assertSame('Test content', $record->text);
+    }
+
+    public function test_update_model_fills_model_without_saving(): void
+    {
+        $model = new TestModel(['content' => 'Original']);
+        $model->save();
+        $originalUpdatedAt = $model->updated_at;
+
+        $record = new TestRecord(text: 'Updated');
+
+        $result = $this->mapper->updateModel($model, $record);
+
+        $this->assertSame($model, $result);
+        $this->assertSame('Updated', $model->content);
+        // Model is filled but not saved
+        $this->assertTrue($model->isDirty('content'));
+    }
+
+    public function test_update_model_applies_meta(): void
+    {
+        $model = new TestModel(['content' => 'Original']);
+        $record = new TestRecord(text: 'Updated');
+        $meta = ['uri' => 'at://test/col/rkey', 'cid' => 'cid123'];
+
+        $this->mapper->updateModel($model, $record, $meta);
+
+        $this->assertSame('at://test/col/rkey', $model->atp_uri);
+        $this->assertSame('cid123', $model->atp_cid);
+    }
+
+    public function test_find_by_uri_returns_model_when_exists(): void
+    {
+        $model = TestModel::create([
+            'content' => 'Test',
+            'atp_uri' => 'at://did:plc:test/app.test.record/abc',
+        ]);
+
+        $found = $this->mapper->findByUri('at://did:plc:test/app.test.record/abc');
+
+        $this->assertNotNull($found);
+        $this->assertSame($model->id, $found->id);
+    }
+
+    public function test_find_by_uri_returns_null_when_not_exists(): void
+    {
+        $found = $this->mapper->findByUri('at://nonexistent/col/rkey');
+
+        $this->assertNull($found);
+    }
+
+    public function test_upsert_creates_new_model_when_uri_not_found(): void
+    {
+        $record = new TestRecord(text: 'New record');
+        $meta = [
+            'uri' => 'at://did:plc:test/app.test.record/new123',
+            'cid' => 'bafyrei123',
+        ];
+
+        $model = $this->mapper->upsert($record, $meta);
+
+        $this->assertTrue($model->exists);
+        $this->assertSame('New record', $model->content);
+        $this->assertSame('at://did:plc:test/app.test.record/new123', $model->atp_uri);
+    }
+
+    public function test_upsert_updates_existing_model_when_uri_found(): void
+    {
+        $existing = TestModel::create([
+            'content' => 'Original',
+            'atp_uri' => 'at://did:plc:test/app.test.record/exists',
+            'atp_cid' => 'old_cid',
+        ]);
+
+        $record = new TestRecord(text: 'Updated content');
+        $meta = [
+            'uri' => 'at://did:plc:test/app.test.record/exists',
+            'cid' => 'new_cid',
+        ];
+
+        $model = $this->mapper->upsert($record, $meta);
+
+        $this->assertSame($existing->id, $model->id);
+        $this->assertSame('Updated content', $model->content);
+        $this->assertSame('new_cid', $model->atp_cid);
+    }
+
+    public function test_upsert_without_uri_creates_new_model(): void
+    {
+        $record = new TestRecord(text: 'No URI');
+
+        $model = $this->mapper->upsert($record, []);
+
+        $this->assertTrue($model->exists);
+        $this->assertSame('No URI', $model->content);
+        $this->assertNull($model->atp_uri);
+    }
+
+    public function test_delete_by_uri_deletes_model_when_exists(): void
+    {
+        TestModel::create([
+            'content' => 'To delete',
+            'atp_uri' => 'at://did:plc:test/app.test.record/todelete',
+        ]);
+
+        $result = $this->mapper->deleteByUri('at://did:plc:test/app.test.record/todelete');
+
+        $this->assertTrue($result);
+        $this->assertNull($this->mapper->findByUri('at://did:plc:test/app.test.record/todelete'));
+    }
+
+    public function test_delete_by_uri_returns_false_when_not_exists(): void
+    {
+        $result = $this->mapper->deleteByUri('at://nonexistent/col/rkey');
+
+        $this->assertFalse($result);
+    }
+}

tests/Unit/SchemaMapperTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit;
+
+use SocialDept\AtpParity\Support\SchemaMapper;
+use SocialDept\AtpParity\Tests\Fixtures\TestModel;
+use SocialDept\AtpParity\Tests\Fixtures\TestRecord;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class SchemaMapperTest extends TestCase
+{
+    public function test_record_class_returns_schema_class(): void
+    {
+        $mapper = new SchemaMapper(
+            schemaClass: TestRecord::class,
+            modelClass: TestModel::class,
+            toAttributes: fn () => [],
+            toRecordData: fn () => [],
+        );
+
+        $this->assertSame(TestRecord::class, $mapper->recordClass());
+    }
+
+    public function test_model_class_returns_model_class(): void
+    {
+        $mapper = new SchemaMapper(
+            schemaClass: TestRecord::class,
+            modelClass: TestModel::class,
+            toAttributes: fn () => [],
+            toRecordData: fn () => [],
+        );
+
+        $this->assertSame(TestModel::class, $mapper->modelClass());
+    }
+
+    public function test_lexicon_returns_schema_lexicon(): void
+    {
+        $mapper = new SchemaMapper(
+            schemaClass: TestRecord::class,
+            modelClass: TestModel::class,
+            toAttributes: fn () => [],
+            toRecordData: fn () => [],
+        );
+
+        $this->assertSame('app.test.record', $mapper->lexicon());
+    }
+
+    public function test_to_model_invokes_to_attributes_closure(): void
+    {
+        $closureCalled = false;
+
+        $mapper = new SchemaMapper(
+            schemaClass: TestRecord::class,
+            modelClass: TestModel::class,
+            toAttributes: function (TestRecord $record) use (&$closureCalled) {
+                $closureCalled = true;
+
+                return ['content' => $record->text.'_transformed'];
+            },
+            toRecordData: fn () => [],
+        );
+
+        $record = new TestRecord(text: 'original');
+        $model = $mapper->toModel($record);
+
+        $this->assertTrue($closureCalled);
+        $this->assertSame('original_transformed', $model->content);
+    }
+
+    public function test_to_record_invokes_to_record_data_closure(): void
+    {
+        $closureCalled = false;
+
+        $mapper = new SchemaMapper(
+            schemaClass: TestRecord::class,
+            modelClass: TestModel::class,
+            toAttributes: fn () => [],
+            toRecordData: function (TestModel $model) use (&$closureCalled) {
+                $closureCalled = true;
+
+                return ['text' => strtoupper($model->content)];
+            },
+        );
+
+        $model = new TestModel(['content' => 'hello']);
+        $record = $mapper->toRecord($model);
+
+        $this->assertTrue($closureCalled);
+        $this->assertSame('HELLO', $record->text);
+    }
+
+    public function test_closures_receive_correct_types(): void
+    {
+        $receivedRecordType = null;
+        $receivedModelType = null;
+
+        $mapper = new SchemaMapper(
+            schemaClass: TestRecord::class,
+            modelClass: TestModel::class,
+            toAttributes: function ($record) use (&$receivedRecordType) {
+                $receivedRecordType = get_class($record);
+
+                return ['content' => $record->text];
+            },
+            toRecordData: function ($model) use (&$receivedModelType) {
+                $receivedModelType = get_class($model);
+
+                return ['text' => $model->content];
+            },
+        );
+
+        $mapper->toModel(new TestRecord(text: 'test'));
+        $mapper->toRecord(new TestModel(['content' => 'test']));
+
+        $this->assertSame(TestRecord::class, $receivedRecordType);
+        $this->assertSame(TestModel::class, $receivedModelType);
+    }
+
+    public function test_upsert_works_with_schema_mapper(): void
+    {
+        $mapper = new SchemaMapper(
+            schemaClass: TestRecord::class,
+            modelClass: TestModel::class,
+            toAttributes: fn (TestRecord $r) => ['content' => $r->text],
+            toRecordData: fn (TestModel $m) => ['text' => $m->content],
+        );
+
+        $record = new TestRecord(text: 'schema mapper test');
+        $meta = ['uri' => 'at://test/col/rkey', 'cid' => 'cid123'];
+
+        $model = $mapper->upsert($record, $meta);
+
+        $this->assertTrue($model->exists);
+        $this->assertSame('schema mapper test', $model->content);
+        $this->assertSame('at://test/col/rkey', $model->atp_uri);
+    }
+}

tests/Unit/Sync/ConflictDetectorTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit\Sync;
+
+use Carbon\Carbon;
+use SocialDept\AtpParity\Sync\ConflictDetector;
+use SocialDept\AtpParity\Tests\Fixtures\SyncableModel;
+use SocialDept\AtpParity\Tests\Fixtures\TestModel;
+use SocialDept\AtpParity\Tests\Fixtures\TestRecord;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class ConflictDetectorTest extends TestCase
+{
+    private ConflictDetector $detector;
+
+    protected function setUp(): void
+    {
+        parent::setUp();
+        $this->detector = new ConflictDetector();
+    }
+
+    public function test_no_conflict_when_cid_matches(): void
+    {
+        $model = new TestModel([
+            'atp_cid' => 'samecid123',
+            'atp_synced_at' => Carbon::parse('2024-01-15 12:00:00'),
+            'updated_at' => Carbon::parse('2024-01-15 13:00:00'), // local changes
+        ]);
+        $record = new TestRecord(text: 'Remote content');
+
+        $hasConflict = $this->detector->hasConflict($model, $record, 'samecid123');
+
+        $this->assertFalse($hasConflict);
+    }
+
+    public function test_no_conflict_when_no_local_changes(): void
+    {
+        $model = new TestModel([
+            'atp_cid' => 'oldcid',
+            'atp_synced_at' => Carbon::parse('2024-01-15 13:00:00'),
+            'updated_at' => Carbon::parse('2024-01-15 12:00:00'), // updated before sync
+        ]);
+        $record = new TestRecord(text: 'Remote content');
+
+        $hasConflict = $this->detector->hasConflict($model, $record, 'newcid');
+
+        $this->assertFalse($hasConflict);
+    }
+
+    public function test_conflict_when_cid_differs_and_local_changes(): void
+    {
+        $model = new TestModel([
+            'atp_cid' => 'oldcid',
+            'atp_synced_at' => Carbon::parse('2024-01-15 12:00:00'),
+            'updated_at' => Carbon::parse('2024-01-15 13:00:00'), // local changes
+        ]);
+        $record = new TestRecord(text: 'Remote content');
+
+        $hasConflict = $this->detector->hasConflict($model, $record, 'newcid');
+
+        $this->assertTrue($hasConflict);
+    }
+
+    public function test_conflict_when_never_synced(): void
+    {
+        $model = new TestModel([
+            'atp_cid' => 'cid',
+            // No atp_synced_at means never synced, which implies local changes
+        ]);
+        $record = new TestRecord(text: 'Remote');
+
+        $hasConflict = $this->detector->hasConflict($model, $record, 'differentcid');
+
+        $this->assertTrue($hasConflict);
+    }
+
+    public function test_uses_syncs_with_atp_trait_method(): void
+    {
+        $model = new SyncableModel([
+            'atp_cid' => 'oldcid',
+            'atp_synced_at' => Carbon::parse('2024-01-15 12:00:00'),
+            'updated_at' => Carbon::parse('2024-01-15 13:00:00'),
+        ]);
+        $record = new TestRecord(text: 'Remote');
+
+        $hasConflict = $this->detector->hasConflict($model, $record, 'newcid');
+
+        $this->assertTrue($hasConflict);
+    }
+
+    public function test_no_conflict_when_synced_after_update_with_trait(): void
+    {
+        $model = new SyncableModel([
+            'atp_cid' => 'oldcid',
+            'updated_at' => Carbon::parse('2024-01-15 12:00:00'),
+            'atp_synced_at' => Carbon::parse('2024-01-15 13:00:00'),
+        ]);
+        $record = new TestRecord(text: 'Remote');
+
+        $hasConflict = $this->detector->hasConflict($model, $record, 'newcid');
+
+        $this->assertFalse($hasConflict);
+    }
+
+    public function test_no_conflict_without_updated_at(): void
+    {
+        $model = new TestModel([
+            'atp_cid' => 'cid',
+            'atp_synced_at' => Carbon::now(),
+            // No updated_at
+        ]);
+        $record = new TestRecord(text: 'Remote');
+
+        $hasConflict = $this->detector->hasConflict($model, $record, 'newcid');
+
+        $this->assertFalse($hasConflict);
+    }
+}

tests/Unit/Sync/ConflictResolutionTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit\Sync;
+
+use SocialDept\AtpParity\Sync\ConflictResolution;
+use SocialDept\AtpParity\Sync\PendingConflict;
+use SocialDept\AtpParity\Tests\Fixtures\TestModel;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class ConflictResolutionTest extends TestCase
+{
+    public function test_remote_wins_creates_resolved_resolution(): void
+    {
+        $model = new TestModel();
+
+        $resolution = ConflictResolution::remoteWins($model);
+
+        $this->assertTrue($resolution->isResolved());
+        $this->assertFalse($resolution->isPending());
+        $this->assertSame('remote', $resolution->winner);
+        $this->assertSame($model, $resolution->model);
+        $this->assertNull($resolution->pending);
+    }
+
+    public function test_local_wins_creates_resolved_resolution(): void
+    {
+        $model = new TestModel();
+
+        $resolution = ConflictResolution::localWins($model);
+
+        $this->assertTrue($resolution->isResolved());
+        $this->assertFalse($resolution->isPending());
+        $this->assertSame('local', $resolution->winner);
+        $this->assertSame($model, $resolution->model);
+        $this->assertNull($resolution->pending);
+    }
+
+    public function test_pending_creates_unresolved_resolution(): void
+    {
+        $pending = new PendingConflict();
+
+        $resolution = ConflictResolution::pending($pending);
+
+        $this->assertFalse($resolution->isResolved());
+        $this->assertTrue($resolution->isPending());
+        $this->assertSame('manual', $resolution->winner);
+        $this->assertNull($resolution->model);
+        $this->assertSame($pending, $resolution->pending);
+    }
+
+    public function test_is_resolved_returns_correct_boolean(): void
+    {
+        $resolved = new ConflictResolution(resolved: true, winner: 'remote');
+        $unresolved = new ConflictResolution(resolved: false, winner: 'manual');
+
+        $this->assertTrue($resolved->isResolved());
+        $this->assertFalse($unresolved->isResolved());
+    }
+
+    public function test_is_pending_returns_false_when_no_pending_conflict(): void
+    {
+        $resolution = new ConflictResolution(resolved: false, winner: 'manual');
+
+        $this->assertFalse($resolution->isPending());
+    }
+}

tests/Unit/Sync/ConflictStrategyTest.php

···
+<?php
+
+namespace SocialDept\AtpParity\Tests\Unit\Sync;
+
+use SocialDept\AtpParity\Sync\ConflictStrategy;
+use SocialDept\AtpParity\Tests\TestCase;
+
+class ConflictStrategyTest extends TestCase
+{
+    public function test_remote_wins_has_correct_value(): void
+    {
+        $this->assertSame('remote', ConflictStrategy::RemoteWins->value);
+    }
+
+    public function test_local_wins_has_correct_value(): void
+    {
+        $this->assertSame('local', ConflictStrategy::LocalWins->value);
+    }
+
+    public function test_newest_wins_has_correct_value(): void
+    {
+        $this->assertSame('newest', ConflictStrategy::NewestWins->value);
+    }
+
+    public function test_manual_has_correct_value(): void
+    {
+        $this->assertSame('manual', ConflictStrategy::Manual->value);
+    }
+
+    public function test_from_config_returns_remote_wins_by_default(): void
+    {
+        config()->set('parity.conflicts.strategy', 'remote');
+
+        $strategy = ConflictStrategy::fromConfig();
+
+        $this->assertSame(ConflictStrategy::RemoteWins, $strategy);
+    }
+
+    public function test_from_config_returns_local_wins(): void
+    {
+        config()->set('parity.conflicts.strategy', 'local');
+
+        $strategy = ConflictStrategy::fromConfig();
+
+        $this->assertSame(ConflictStrategy::LocalWins, $strategy);
+    }
+
+    public function test_from_config_returns_newest_wins(): void
+    {
+        config()->set('parity.conflicts.strategy', 'newest');
+
+        $strategy = ConflictStrategy::fromConfig();
+
+        $this->assertSame(ConflictStrategy::NewestWins, $strategy);
+    }
+
+    public function test_from_config_returns_manual(): void
+    {
+        config()->set('parity.conflicts.strategy', 'manual');
+
+        $strategy = ConflictStrategy::fromConfig();
+
+        $this->assertSame(ConflictStrategy::Manual, $strategy);
+    }
+
+    public function test_from_config_defaults_to_remote_wins_for_invalid_value(): void
+    {
+        config()->set('parity.conflicts.strategy', 'invalid');
+
+        $strategy = ConflictStrategy::fromConfig();
+
+        $this->assertSame(ConflictStrategy::RemoteWins, $strategy);
+    }
+
+    public function test_from_config_defaults_to_remote_wins_when_not_set(): void
+    {
+        config()->set('parity.conflicts.strategy', null);
+
+        $strategy = ConflictStrategy::fromConfig();
+
+        $this->assertSame(ConflictStrategy::RemoteWins, $strategy);
+    }
+}