From a6502c0888613bd0377a25e43de8ae306c4de4d7 Mon Sep 17 00:00:00 2001 From: bndw Date: Fri, 13 Feb 2026 17:41:13 -0800 Subject: feat: add SQLite storage layer with binary-first event persistence Storage implementation: - Concrete type with constructor (consumer-side interfaces) - Event storage: protobuf + zstd-compressed canonical JSON - Schema: events, deletions, replaceable_events, auth_challenges, rate_limits - WAL mode, STRICT typing, optimized indexes - Methods: StoreEvent, GetEvent, GetEventWithCanonical, DeleteEvent Dependencies: - modernc.org/sqlite v1.45.0 (pure Go SQLite driver) - github.com/klauspost/compress v1.18.4 (zstd compression) 366 lines, 10 tests passing --- internal/storage/events_test.go | 264 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 264 insertions(+) create mode 100644 internal/storage/events_test.go (limited to 'internal/storage/events_test.go') diff --git a/internal/storage/events_test.go b/internal/storage/events_test.go new file mode 100644 index 0000000..4393404 --- /dev/null +++ b/internal/storage/events_test.go @@ -0,0 +1,264 @@ +package storage + +import ( + "context" + "testing" + + pb "northwest.io/nostr-grpc/api/nostr/v1" +) + +func TestStoreEvent(t *testing.T) { + store, err := New(":memory:") + if err != nil { + t.Fatalf("failed to create storage: %v", err) + } + defer store.Close() + + ctx := context.Background() + + // Create test event + event := &pb.Event{ + Id: "test123", + Pubkey: "pubkey123", + CreatedAt: 1234567890, + Kind: 1, + Tags: []*pb.Tag{{Values: []string{"e", "event1"}}}, + Content: "Hello, Nostr!", + Sig: "sig123", + } + + canonicalJSON := []byte(`[0,"pubkey123",1234567890,1,[["e","event1"]],"Hello, Nostr!"]`) + + data := &EventData{ + Event: event, + CanonicalJSON: canonicalJSON, + } + + // Store event + err = store.StoreEvent(ctx, data) + if err != nil { + t.Fatalf("failed to store event: %v", err) + } + + // Verify event was stored + retrieved, err := store.GetEvent(ctx, "test123") + if err != nil { + t.Fatalf("failed to retrieve event: %v", err) + } + + if retrieved.Id != event.Id { + t.Errorf("expected ID %s, got %s", event.Id, retrieved.Id) + } + if retrieved.Content != event.Content { + t.Errorf("expected content %s, got %s", event.Content, retrieved.Content) + } +} + +func TestStoreEventDuplicate(t *testing.T) { + store, err := New(":memory:") + if err != nil { + t.Fatalf("failed to create storage: %v", err) + } + defer store.Close() + + ctx := context.Background() + + event := &pb.Event{ + Id: "duplicate123", + Pubkey: "pubkey123", + CreatedAt: 1234567890, + Kind: 1, + Content: "test", + Sig: "sig123", + } + + data := &EventData{ + Event: event, + CanonicalJSON: []byte(`[0,"pubkey123",1234567890,1,[],"test"]`), + } + + // Store first time + err = store.StoreEvent(ctx, data) + if err != nil { + t.Fatalf("failed to store event first time: %v", err) + } + + // Try to store again + err = store.StoreEvent(ctx, data) + if err != ErrEventExists { + t.Errorf("expected ErrEventExists, got %v", err) + } +} + +func TestGetEvent(t *testing.T) { + store, err := New(":memory:") + if err != nil { + t.Fatalf("failed to create storage: %v", err) + } + defer store.Close() + + ctx := context.Background() + + // Test non-existent event + _, err = store.GetEvent(ctx, "nonexistent") + if err != ErrEventNotFound { + t.Errorf("expected ErrEventNotFound, got %v", err) + } +} + +func TestGetEventWithCanonical(t *testing.T) { + store, err := New(":memory:") + if err != nil { + t.Fatalf("failed to create storage: %v", err) + } + defer store.Close() + + ctx := context.Background() + + canonicalJSON := []byte(`[0,"pubkey123",1234567890,1,[],"test"]`) + + event := &pb.Event{ + Id: "canonical123", + Pubkey: "pubkey123", + CreatedAt: 1234567890, + Kind: 1, + Content: "test", + Sig: "sig123", + } + + data := &EventData{ + Event: event, + CanonicalJSON: canonicalJSON, + } + + err = store.StoreEvent(ctx, data) + if err != nil { + t.Fatalf("failed to store event: %v", err) + } + + // Retrieve with canonical JSON + retrieved, err := store.GetEventWithCanonical(ctx, "canonical123") + if err != nil { + t.Fatalf("failed to retrieve event: %v", err) + } + + if string(retrieved.CanonicalJson) != string(canonicalJSON) { + t.Errorf("canonical JSON mismatch:\nexpected: %s\ngot: %s", + canonicalJSON, retrieved.CanonicalJson) + } +} + +func TestDeleteEvent(t *testing.T) { + store, err := New(":memory:") + if err != nil { + t.Fatalf("failed to create storage: %v", err) + } + defer store.Close() + + ctx := context.Background() + + event := &pb.Event{ + Id: "delete123", + Pubkey: "pubkey123", + CreatedAt: 1234567890, + Kind: 1, + Content: "to be deleted", + Sig: "sig123", + } + + data := &EventData{ + Event: event, + CanonicalJSON: []byte(`[0,"pubkey123",1234567890,1,[],"to be deleted"]`), + } + + // Store event + err = store.StoreEvent(ctx, data) + if err != nil { + t.Fatalf("failed to store event: %v", err) + } + + // Delete event + err = store.DeleteEvent(ctx, "delete123") + if err != nil { + t.Fatalf("failed to delete event: %v", err) + } + + // Verify event is no longer retrievable + _, err = store.GetEvent(ctx, "delete123") + if err != ErrEventNotFound { + t.Errorf("expected ErrEventNotFound after deletion, got %v", err) + } + + // Try deleting non-existent event + err = store.DeleteEvent(ctx, "nonexistent") + if err != ErrEventNotFound { + t.Errorf("expected ErrEventNotFound, got %v", err) + } +} + +func TestCompressDecompressJSON(t *testing.T) { + original := []byte(`{"key":"value","array":[1,2,3],"nested":{"a":"b"}}`) + + compressed, err := compressJSON(original) + if err != nil { + t.Fatalf("compression failed: %v", err) + } + + // Verify compression reduces size (for larger data) + if len(compressed) >= len(original) { + t.Logf("Note: compressed size (%d) >= original (%d) - normal for small data", + len(compressed), len(original)) + } + + decompressed, err := decompressJSON(compressed) + if err != nil { + t.Fatalf("decompression failed: %v", err) + } + + if string(decompressed) != string(original) { + t.Errorf("decompressed data doesn't match original:\nexpected: %s\ngot: %s", + original, decompressed) + } +} + +func TestMarshalTags(t *testing.T) { + tests := []struct { + name string + tags []*pb.Tag + expected string + }{ + { + name: "empty tags", + tags: nil, + expected: "[]", + }, + { + name: "single tag", + tags: []*pb.Tag{ + {Values: []string{"e", "event123"}}, + }, + expected: `[["e","event123"]]`, + }, + { + name: "multiple tags", + tags: []*pb.Tag{ + {Values: []string{"e", "event123", "wss://relay.example.com"}}, + {Values: []string{"p", "pubkey456"}}, + }, + expected: `[["e","event123","wss://relay.example.com"],["p","pubkey456"]]`, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + result, err := marshalTags(tt.tags) + if err != nil { + t.Fatalf("marshalTags failed: %v", err) + } + + if result != tt.expected { + t.Errorf("expected %s, got %s", tt.expected, result) + } + }) + } +} -- cgit v1.2.3