Update

api_test.go

@@ -9,107 +9,102 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-// MockSimpleEventStore for testing API endpoints
-type MockSimpleEventStore struct {
+// MockSimpleEventStore for API testing
+type MockAPIEventStore struct {
 	events  []Event
 	items   map[string]map[string]interface{}
 	nextSeq int
 }
 
-func NewMockSimpleEventStore() *MockSimpleEventStore {
-	return &MockSimpleEventStore{
+func NewMockAPIEventStore() *MockAPIEventStore {
+	return &MockAPIEventStore{
 		events:  []Event{},
 		items:   make(map[string]map[string]interface{}),
 		nextSeq: 1,
 	}
 }
 
-func (m *MockSimpleEventStore) GetLatestEvent() (*Event, error) {
+func (m *MockAPIEventStore) GetLatestEvent() (*Event, error) {
 	if len(m.events) == 0 {
 		return nil, nil
 	}
 	return &m.events[len(m.events)-1], nil
 }
 
-func (m *MockSimpleEventStore) ProcessEvent(incomingEvent *Event) (*Event, error) {
-	// Simulate event processing
+func (m *MockAPIEventStore) ProcessEvent(incomingEvent *Event) (*Event, error) {
 	event := &Event{
 		Seq:        m.nextSeq,
-		Hash:       "mock_hash_" + string(rune(m.nextSeq)),
+		Hash:       "mock_hash_" + string(rune(m.nextSeq+'0')),
 		ItemID:     incomingEvent.ItemID,
-		EventID:    "mock_event_" + string(rune(m.nextSeq)),
+		EventID:    "mock_event_" + string(rune(m.nextSeq+'0')),
 		Collection: incomingEvent.Collection,
-		Patches:    incomingEvent.Patches,
+		Operation:  incomingEvent.Operation,
+		Path:       incomingEvent.Path,
+		Value:      incomingEvent.Value,
+		From:       incomingEvent.From,
 		Timestamp:  time.Now(),
 	}
 
 	m.events = append(m.events, *event)
 	m.nextSeq++
 
-	// Apply patches to items
-	key := event.Collection + ":" + event.ItemID
-	if m.items[key] == nil {
-		m.items[key] = map[string]interface{}{
-			"id":         event.ItemID,
-			"created_at": event.Timestamp,
-		}
+	// Apply operation to items for testing
+	itemKey := incomingEvent.Collection + ":" + incomingEvent.ItemID
+	if m.items[itemKey] == nil {
+		m.items[itemKey] = map[string]interface{}{"id": incomingEvent.ItemID}
 	}
 
-	patcher := &JSONPatcher{}
-	updated, err := patcher.ApplyPatches(m.items[key], event.Patches)
-	if err != nil {
-		return nil, err
+	// Simple mock application of JSON Patch operations
+	switch incomingEvent.Operation {
+	case "add", "replace":
+		field := incomingEvent.Path[1:] // remove leading "/"
+		m.items[itemKey][field] = incomingEvent.Value
+	case "remove":
+		field := incomingEvent.Path[1:]
+		delete(m.items[itemKey], field)
 	}
 
-	updated["updated_at"] = event.Timestamp
-	m.items[key] = updated
-
 	return event, nil
 }
 
-func (m *MockSimpleEventStore) GetEventsSince(seq int) ([]Event, error) {
-	var result []Event
+func (m *MockAPIEventStore) GetEventsSince(seq int) ([]Event, error) {
+	var events []Event
 	for _, event := range m.events {
 		if event.Seq > seq {
-			result = append(result, event)
+			events = append(events, event)
 		}
 	}
-	return result, nil
+	return events, nil
 }
 
-func (m *MockSimpleEventStore) GetAllItems(collection string) ([]map[string]interface{}, error) {
-	var result []map[string]interface{}
+func (m *MockAPIEventStore) GetAllItems(collection string) ([]map[string]interface{}, error) {
+	var items []map[string]interface{}
 	for key, item := range m.items {
-		if len(key) > len(collection) && key[:len(collection)] == collection {
-			// Check if item is not deleted
-			if deletedAt, exists := item["deleted_at"]; !exists || deletedAt == nil {
-				result = append(result, item)
+		if len(key) >= len(collection) && key[:len(collection)] == collection {
+			// Skip soft-deleted items
+			if deletedAt, exists := item["deleted_at"]; !exists || deletedAt == "" {
+				items = append(items, item)
 			}
 		}
 	}
-	return result, nil
+	return items, nil
 }
 
-func (m *MockSimpleEventStore) ValidateSync(clientSeq int, clientHash string) (bool, error) {
-	if clientSeq == 0 {
-		return false, nil
+func (m *MockAPIEventStore) ValidateSync(seq int, hash string) (bool, error) {
+	if len(m.events) == 0 {
+		return seq == 0 && hash == "", nil
 	}
-
-	for _, event := range m.events {
-		if event.Seq == clientSeq {
-			return event.Hash == clientHash, nil
-		}
-	}
-
-	return false, nil // Event not found
+	latest := m.events[len(m.events)-1]
+	return latest.Seq == seq && latest.Hash == hash, nil
 }
 
-func setupTestRouter(eventStore *MockSimpleEventStore) http.Handler {
+func createTestRouter(eventStore *MockAPIEventStore) *http.ServeMux {
 	mux := http.NewServeMux()
 
-	// JSON Patch endpoint
+	// PATCH endpoint for single operations
 	mux.HandleFunc("PATCH /api/collections/{collection}/items/{itemId}", func(w http.ResponseWriter, r *http.Request) {
 		collection := r.PathValue("collection")
 		itemID := r.PathValue("itemId")
@@ -119,16 +114,24 @@ func setupTestRouter(eventStore *MockSimpleEventStore) http.Handler {
 			return
 		}
 
-		var patches []PatchOperation
-		if err := json.NewDecoder(r.Body).Decode(&patches); err != nil {
-			http.Error(w, "Failed to parse JSON Patch data", http.StatusBadRequest)
+		var operation struct {
+			Op    string `json:"op"`
+			Path  string `json:"path"`
+			Value string `json:"value"`
+			From  string `json:"from"`
+		}
+		if err := json.NewDecoder(r.Body).Decode(&operation); err != nil {
+			http.Error(w, "Failed to parse operation data", http.StatusBadRequest)
 			return
 		}
 
 		incomingEvent := &Event{
 			ItemID:     itemID,
 			Collection: collection,
-			Patches:    patches,
+			Operation:  operation.Op,
+			Path:       operation.Path,
+			Value:      operation.Value,
+			From:       operation.From,
 		}
 
 		processedEvent, err := eventStore.ProcessEvent(incomingEvent)
@@ -141,7 +144,7 @@ func setupTestRouter(eventStore *MockSimpleEventStore) http.Handler {
 		json.NewEncoder(w).Encode(processedEvent)
 	})
 
-	// Legacy POST endpoint
+	// POST endpoint for legacy events
 	mux.HandleFunc("POST /api/events", func(w http.ResponseWriter, r *http.Request) {
 		var incomingEvent Event
 		if err := json.NewDecoder(r.Body).Decode(&incomingEvent); err != nil {
@@ -149,8 +152,8 @@ func setupTestRouter(eventStore *MockSimpleEventStore) http.Handler {
 			return
 		}
 
-		if incomingEvent.ItemID == "" || incomingEvent.Collection == "" || len(incomingEvent.Patches) == 0 {
-			http.Error(w, "Missing required fields: item_id, collection, patches", http.StatusBadRequest)
+		if incomingEvent.ItemID == "" || incomingEvent.Collection == "" || incomingEvent.Operation == "" {
+			http.Error(w, "Missing required fields: item_id, collection, operation", http.StatusBadRequest)
 			return
 		}
 
@@ -179,30 +182,17 @@ func setupTestRouter(eventStore *MockSimpleEventStore) http.Handler {
 			return
 		}
 
-		var response SyncResponse
-
-		if !isValid {
-			events, err := eventStore.GetEventsSince(0)
-			if err != nil {
-				http.Error(w, "Failed to get events", http.StatusInternalServerError)
-				return
-			}
-			response.Events = events
-			response.FullSync = true
-		} else {
 		events, err := eventStore.GetEventsSince(syncReq.LastSeq)
 		if err != nil {
 			http.Error(w, "Failed to get events", http.StatusInternalServerError)
 			return
 		}
-			response.Events = events
-			response.FullSync = false
-		}
 
-		latestEvent, err := eventStore.GetLatestEvent()
-		if err != nil {
-			http.Error(w, "Failed to get latest event", http.StatusInternalServerError)
-			return
+		latestEvent, _ := eventStore.GetLatestEvent()
+
+		response := SyncResponse{
+			Events:   events,
+			FullSync: !isValid,
 		}
 
 		if latestEvent != nil {
@@ -217,10 +207,6 @@ func setupTestRouter(eventStore *MockSimpleEventStore) http.Handler {
 	// Get items endpoint
 	mux.HandleFunc("GET /api/items/{collection}", func(w http.ResponseWriter, r *http.Request) {
 		collection := r.PathValue("collection")
-		if collection == "" {
-			http.Error(w, "Collection name required", http.StatusBadRequest)
-			return
-		}
 
 		items, err := eventStore.GetAllItems(collection)
 		if err != nil {
@@ -228,19 +214,25 @@ func setupTestRouter(eventStore *MockSimpleEventStore) http.Handler {
 			return
 		}
 
+		response := map[string]interface{}{"items": items}
 		w.Header().Set("Content-Type", "application/json")
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"items": items,
-		})
+		json.NewEncoder(w).Encode(response)
 	})
 
-	// Get state endpoint
-	mux.HandleFunc("GET /api/state", func(w http.ResponseWriter, r *http.Request) {
-		latestEvent, err := eventStore.GetLatestEvent()
-		if err != nil {
-			http.Error(w, "Failed to get latest event", http.StatusInternalServerError)
-			return
+	// Health endpoint
+	mux.HandleFunc("GET /api/health", func(w http.ResponseWriter, r *http.Request) {
+		response := map[string]interface{}{
+			"message": "API is healthy.",
+			"code":    200,
+			"data":    map[string]interface{}{},
 		}
+		w.Header().Set("Content-Type", "application/json")
+		json.NewEncoder(w).Encode(response)
+	})
+
+	// State endpoint
+	mux.HandleFunc("GET /api/state", func(w http.ResponseWriter, r *http.Request) {
+		latestEvent, _ := eventStore.GetLatestEvent()
 
 		response := map[string]interface{}{
 			"seq":  0,
@@ -260,117 +252,119 @@ func setupTestRouter(eventStore *MockSimpleEventStore) http.Handler {
 }
 
 func TestAPI_PatchEndpoint_CreateItem(t *testing.T) {
-	eventStore := NewMockSimpleEventStore()
-	router := setupTestRouter(eventStore)
+	mockStore := NewMockAPIEventStore()
+	router := createTestRouter(mockStore)
 
-	patches := []PatchOperation{
-		{Op: "add", Path: "/content", Value: "Test Item"},
-		{Op: "add", Path: "/priority", Value: "high"},
+	operation := map[string]string{
+		"op":    "add",
+		"path":  "/content",
+		"value": "test item content",
 	}
+	body, _ := json.Marshal(operation)
 
-	body, _ := json.Marshal(patches)
-	req := httptest.NewRequest("PATCH", "/api/collections/shopping_items/items/item1", bytes.NewReader(body))
+	req := httptest.NewRequest("PATCH", "/api/collections/shopping_items/items/test123", bytes.NewReader(body))
 	req.Header.Set("Content-Type", "application/json")
-
 	w := httptest.NewRecorder()
+
 	router.ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusOK, w.Code)
 
 	var response Event
 	err := json.NewDecoder(w.Body).Decode(&response)
-	assert.NoError(t, err)
-	assert.Equal(t, "item1", response.ItemID)
+	require.NoError(t, err)
+	assert.Equal(t, "test123", response.ItemID)
 	assert.Equal(t, "shopping_items", response.Collection)
+	assert.Equal(t, "add", response.Operation)
+	assert.Equal(t, "/content", response.Path)
+	assert.Equal(t, "test item content", response.Value)
 	assert.Equal(t, 1, response.Seq)
-	assert.Len(t, response.Patches, 2)
 }
 
 func TestAPI_PatchEndpoint_UpdateItem(t *testing.T) {
-	eventStore := NewMockSimpleEventStore()
-	router := setupTestRouter(eventStore)
+	mockStore := NewMockAPIEventStore()
+	router := createTestRouter(mockStore)
 
-	// First create an item
-	createPatches := []PatchOperation{
-		{Op: "add", Path: "/content", Value: "Original Content"},
+	// Create item first
+	createOp := map[string]string{
+		"op":    "add",
+		"path":  "/content",
+		"value": "original content",
 	}
-	body, _ := json.Marshal(createPatches)
-	req := httptest.NewRequest("PATCH", "/api/collections/shopping_items/items/item1", bytes.NewReader(body))
+	body, _ := json.Marshal(createOp)
+	req := httptest.NewRequest("PATCH", "/api/collections/shopping_items/items/test123", bytes.NewReader(body))
 	req.Header.Set("Content-Type", "application/json")
-
 	w := httptest.NewRecorder()
 	router.ServeHTTP(w, req)
 	assert.Equal(t, http.StatusOK, w.Code)
 
-	// Now update the item
-	updatePatches := []PatchOperation{
-		{Op: "replace", Path: "/content", Value: "Updated Content"},
-		{Op: "add", Path: "/status", Value: "published"},
+	// Update item
+	updateOp := map[string]string{
+		"op":    "replace",
+		"path":  "/content",
+		"value": "updated content",
 	}
-	body, _ = json.Marshal(updatePatches)
-	req = httptest.NewRequest("PATCH", "/api/collections/shopping_items/items/item1", bytes.NewReader(body))
+	body, _ = json.Marshal(updateOp)
+	req = httptest.NewRequest("PATCH", "/api/collections/shopping_items/items/test123", bytes.NewReader(body))
 	req.Header.Set("Content-Type", "application/json")
-
 	w = httptest.NewRecorder()
+
 	router.ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusOK, w.Code)
 
 	var response Event
 	err := json.NewDecoder(w.Body).Decode(&response)
-	assert.NoError(t, err)
-	assert.Equal(t, "item1", response.ItemID)
+	require.NoError(t, err)
+	assert.Equal(t, "test123", response.ItemID)
+	assert.Equal(t, "replace", response.Operation)
+	assert.Equal(t, "/content", response.Path)
+	assert.Equal(t, "updated content", response.Value)
 	assert.Equal(t, 2, response.Seq)
-	assert.Len(t, response.Patches, 2)
 }
 
 func TestAPI_PatchEndpoint_InvalidData(t *testing.T) {
-	eventStore := NewMockSimpleEventStore()
-	router := setupTestRouter(eventStore)
+	mockStore := NewMockAPIEventStore()
+	router := createTestRouter(mockStore)
 
-	// Test with invalid JSON
-	req := httptest.NewRequest("PATCH", "/api/collections/shopping_items/items/item1", bytes.NewReader([]byte("invalid json")))
+	req := httptest.NewRequest("PATCH", "/api/collections/shopping_items/items/test123", bytes.NewReader([]byte("invalid json")))
 	req.Header.Set("Content-Type", "application/json")
-
 	w := httptest.NewRecorder()
+
 	router.ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusBadRequest, w.Code)
 }
 
 func TestAPI_PostEndpoint_LegacyEvent(t *testing.T) {
-	eventStore := NewMockSimpleEventStore()
-	router := setupTestRouter(eventStore)
+	mockStore := NewMockAPIEventStore()
+	router := createTestRouter(mockStore)
 
 	event := Event{
-		ItemID:     "item1",
+		ItemID:     "test123",
 		Collection: "shopping_items",
-		Patches: []PatchOperation{
-			{Op: "add", Path: "/content", Value: "Test Item"},
-		},
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "test content",
 	}
-
 	body, _ := json.Marshal(event)
+
 	req := httptest.NewRequest("POST", "/api/events", bytes.NewReader(body))
 	req.Header.Set("Content-Type", "application/json")
-
 	w := httptest.NewRecorder()
+
 	router.ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusCreated, w.Code)
 
 	var response Event
 	err := json.NewDecoder(w.Body).Decode(&response)
-	assert.NoError(t, err)
-	assert.Equal(t, "item1", response.ItemID)
-	assert.Equal(t, "shopping_items", response.Collection)
-	assert.Equal(t, 1, response.Seq)
+	require.NoError(t, err)
+	assert.Equal(t, "test123", response.ItemID)
+	assert.Equal(t, "add", response.Operation)
 }
 
 func TestAPI_PostEndpoint_MissingFields(t *testing.T) {
-	eventStore := NewMockSimpleEventStore()
-	router := setupTestRouter(eventStore)
-
 	tests := []struct {
 		name  string
 		event Event
@@ -379,33 +373,41 @@ func TestAPI_PostEndpoint_MissingFields(t *testing.T) {
 			name: "missing item_id",
 			event: Event{
 				Collection: "shopping_items",
-				Patches:    []PatchOperation{{Op: "add", Path: "/content", Value: "test"}},
+				Operation:  "add",
+				Path:       "/content",
+				Value:      "test",
 			},
 		},
 		{
 			name: "missing collection",
 			event: Event{
-				ItemID:  "item1",
-				Patches: []PatchOperation{{Op: "add", Path: "/content", Value: "test"}},
+				ItemID:    "test123",
+				Operation: "add",
+				Path:      "/content",
+				Value:     "test",
 			},
 		},
 		{
-			name: "missing patches",
+			name: "missing operation",
 			event: Event{
-				ItemID:     "item1",
+				ItemID:     "test123",
 				Collection: "shopping_items",
-				Patches:    []PatchOperation{},
+				Path:       "/content",
+				Value:      "test",
 			},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			mockStore := NewMockAPIEventStore()
+			router := createTestRouter(mockStore)
+
 			body, _ := json.Marshal(tt.event)
 			req := httptest.NewRequest("POST", "/api/events", bytes.NewReader(body))
 			req.Header.Set("Content-Type", "application/json")
-
 			w := httptest.NewRecorder()
+
 			router.ServeHTTP(w, req)
 
 			assert.Equal(t, http.StatusBadRequest, w.Code)
@@ -414,138 +416,139 @@ func TestAPI_PostEndpoint_MissingFields(t *testing.T) {
 }
 
 func TestAPI_SyncEndpoint_FullSync(t *testing.T) {
-	eventStore := NewMockSimpleEventStore()
-	router := setupTestRouter(eventStore)
+	mockStore := NewMockAPIEventStore()
+	router := createTestRouter(mockStore)
 
-	// Create some events first
-	event1 := Event{
+	// Add some events first
+	event1 := &Event{
 		ItemID:     "item1",
 		Collection: "shopping_items",
-		Patches:    []PatchOperation{{Op: "add", Path: "/content", Value: "Item 1"}},
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "Item 1",
 	}
-	eventStore.ProcessEvent(&event1)
+	mockStore.ProcessEvent(event1)
 
-	event2 := Event{
+	event2 := &Event{
 		ItemID:     "item2",
 		Collection: "shopping_items",
-		Patches:    []PatchOperation{{Op: "add", Path: "/content", Value: "Item 2"}},
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "Item 2",
 	}
-	eventStore.ProcessEvent(&event2)
+	mockStore.ProcessEvent(event2)
 
-	// Request full sync (client starts with seq 0)
+	// Request sync from beginning
 	syncReq := SyncRequest{
 		LastSeq:  0,
 		LastHash: "",
 	}
-
 	body, _ := json.Marshal(syncReq)
+
 	req := httptest.NewRequest("POST", "/api/sync", bytes.NewReader(body))
 	req.Header.Set("Content-Type", "application/json")
-
 	w := httptest.NewRecorder()
+
 	router.ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusOK, w.Code)
 
 	var response SyncResponse
 	err := json.NewDecoder(w.Body).Decode(&response)
-	assert.NoError(t, err)
-	assert.True(t, response.FullSync)
+	require.NoError(t, err)
 	assert.Len(t, response.Events, 2)
 	assert.Equal(t, 2, response.CurrentSeq)
-	assert.NotEmpty(t, response.CurrentHash)
 }
 
 func TestAPI_SyncEndpoint_IncrementalSync(t *testing.T) {
-	eventStore := NewMockSimpleEventStore()
-	router := setupTestRouter(eventStore)
+	mockStore := NewMockAPIEventStore()
+	router := createTestRouter(mockStore)
 
-	// Create some events
-	event1 := Event{
+	// Add some events first
+	event1 := &Event{
 		ItemID:     "item1",
 		Collection: "shopping_items",
-		Patches:    []PatchOperation{{Op: "add", Path: "/content", Value: "Item 1"}},
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "Item 1",
 	}
-	processedEvent1, _ := eventStore.ProcessEvent(&event1)
+	mockStore.ProcessEvent(event1)
 
-	event2 := Event{
+	event2 := &Event{
 		ItemID:     "item2",
 		Collection: "shopping_items",
-		Patches:    []PatchOperation{{Op: "add", Path: "/content", Value: "Item 2"}},
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "Item 2",
 	}
-	eventStore.ProcessEvent(&event2)
+	mockStore.ProcessEvent(event2)
 
-	// Request incremental sync (client has first event)
+	// Request sync from seq 1
 	syncReq := SyncRequest{
-		LastSeq:  processedEvent1.Seq,
-		LastHash: processedEvent1.Hash,
+		LastSeq:  1,
+		LastHash: "mock_hash_1",
 	}
-
 	body, _ := json.Marshal(syncReq)
+
 	req := httptest.NewRequest("POST", "/api/sync", bytes.NewReader(body))
 	req.Header.Set("Content-Type", "application/json")
-
 	w := httptest.NewRecorder()
+
 	router.ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusOK, w.Code)
 
 	var response SyncResponse
 	err := json.NewDecoder(w.Body).Decode(&response)
-	assert.NoError(t, err)
-	assert.False(t, response.FullSync)
-	assert.Len(t, response.Events, 1) // Only the second event
+	require.NoError(t, err)
+	assert.Len(t, response.Events, 1) // Only event 2
 	assert.Equal(t, 2, response.CurrentSeq)
 }
 
 func TestAPI_GetItemsEndpoint(t *testing.T) {
-	eventStore := NewMockSimpleEventStore()
-	router := setupTestRouter(eventStore)
+	mockStore := NewMockAPIEventStore()
+	router := createTestRouter(mockStore)
 
-	// Create some items
-	event1 := Event{
+	// Add some items
+	event1 := &Event{
 		ItemID:     "item1",
 		Collection: "shopping_items",
-		Patches:    []PatchOperation{{Op: "add", Path: "/content", Value: "Item 1"}},
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "Item 1",
 	}
-	eventStore.ProcessEvent(&event1)
+	mockStore.ProcessEvent(event1)
 
-	event2 := Event{
+	event2 := &Event{
 		ItemID:     "item2",
 		Collection: "shopping_items",
-		Patches:    []PatchOperation{{Op: "add", Path: "/content", Value: "Item 2"}},
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "Item 2",
 	}
-	eventStore.ProcessEvent(&event2)
-
-	// Delete one item
-	event3 := Event{
-		ItemID:     "item2",
-		Collection: "shopping_items",
-		Patches:    []PatchOperation{{Op: "add", Path: "/deleted_at", Value: time.Now()}},
-	}
-	eventStore.ProcessEvent(&event3)
+	mockStore.ProcessEvent(event2)
 
 	req := httptest.NewRequest("GET", "/api/items/shopping_items", nil)
-
 	w := httptest.NewRecorder()
+
 	router.ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusOK, w.Code)
 
 	var response map[string]interface{}
 	err := json.NewDecoder(w.Body).Decode(&response)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 
 	items, ok := response["items"].([]interface{})
-	assert.True(t, ok)
-	assert.Len(t, items, 1) // Only non-deleted item
+	require.True(t, ok)
+	assert.Len(t, items, 2)
 }
 
 func TestAPI_GetStateEndpoint(t *testing.T) {
-	eventStore := NewMockSimpleEventStore()
-	router := setupTestRouter(eventStore)
+	mockStore := NewMockAPIEventStore()
+	router := createTestRouter(mockStore)
 
-	// Test with no events
+	// Test empty state
 	req := httptest.NewRequest("GET", "/api/state", nil)
 	w := httptest.NewRecorder()
 	router.ServeHTTP(w, req)
@@ -554,19 +557,21 @@ func TestAPI_GetStateEndpoint(t *testing.T) {
 
 	var response map[string]interface{}
 	err := json.NewDecoder(w.Body).Decode(&response)
-	assert.NoError(t, err)
+	require.NoError(t, err)
 	assert.Equal(t, float64(0), response["seq"])
 	assert.Equal(t, "", response["hash"])
 
-	// Create an event
-	event := Event{
+	// Add an event
+	event := &Event{
 		ItemID:     "item1",
 		Collection: "shopping_items",
-		Patches:    []PatchOperation{{Op: "add", Path: "/content", Value: "Item 1"}},
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "Item 1",
 	}
-	processedEvent, _ := eventStore.ProcessEvent(&event)
+	mockStore.ProcessEvent(event)
 
-	// Test with events
+	// Test state with event
 	req = httptest.NewRequest("GET", "/api/state", nil)
 	w = httptest.NewRecorder()
 	router.ServeHTTP(w, req)
@@ -574,34 +579,49 @@ func TestAPI_GetStateEndpoint(t *testing.T) {
 	assert.Equal(t, http.StatusOK, w.Code)
 
 	err = json.NewDecoder(w.Body).Decode(&response)
-	assert.NoError(t, err)
-	assert.Equal(t, float64(processedEvent.Seq), response["seq"])
-	assert.Equal(t, processedEvent.Hash, response["hash"])
+	require.NoError(t, err)
+	assert.Equal(t, float64(1), response["seq"])
+	assert.NotEmpty(t, response["hash"])
 }
 
 func TestAPI_PathValues(t *testing.T) {
-	eventStore := NewMockSimpleEventStore()
-	router := setupTestRouter(eventStore)
+	mockStore := NewMockAPIEventStore()
+	router := createTestRouter(mockStore)
 
-	// Test with empty collection name (router will handle as empty path value)
-	patches := []PatchOperation{{Op: "add", Path: "/content", Value: "test"}}
-	body, _ := json.Marshal(patches)
-	req := httptest.NewRequest("PATCH", "/api/collections/empty/items/item1", bytes.NewReader(body))
+	tests := []struct {
+		name           string
+		url            string
+		method         string
+		expectedStatus int
+	}{
+		{
+			name:           "valid patch path",
+			url:            "/api/collections/shopping_items/items/test123",
+			method:         "PATCH",
+			expectedStatus: http.StatusOK, // Valid operation should succeed
+		},
+		{
+			name:           "valid get items path",
+			url:            "/api/items/shopping_items",
+			method:         "GET",
+			expectedStatus: http.StatusOK,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var req *http.Request
+			if tt.method == "PATCH" {
+				req = httptest.NewRequest(tt.method, tt.url, bytes.NewReader([]byte("{}")))
 				req.Header.Set("Content-Type", "application/json")
+			} else {
+				req = httptest.NewRequest(tt.method, tt.url, nil)
+			}
 
 			w := httptest.NewRecorder()
 			router.ServeHTTP(w, req)
 
-	// This should work fine - we'll test empty values in the handler
-	assert.Equal(t, http.StatusOK, w.Code)
-
-	// Test empty item ID by using an empty string
-	req = httptest.NewRequest("PATCH", "/api/collections/test/items/", bytes.NewReader(body))
-	req.Header.Set("Content-Type", "application/json")
-
-	w = httptest.NewRecorder()
-	router.ServeHTTP(w, req)
-
-	// This will likely result in 404 due to route not matching
-	assert.True(t, w.Code == http.StatusNotFound || w.Code == http.StatusBadRequest)
+			assert.Equal(t, tt.expectedStatus, w.Code)
+		})
+	}
 }

event_store_test.go

@@ -1,432 +1,407 @@
 package main
 
 import (
-	"encoding/json"
 	"testing"
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestEvent_Serialize(t *testing.T) {
-	timestamp := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)
-
 	tests := []struct {
 		name  string
 		event Event
-		expected string
 	}{
 		{
 			name: "simple event",
 			event: Event{
 				Seq:        1,
-				ItemID:     "item1",
-				EventID:    "event1",
-				Collection: "test",
-				Patches: []PatchOperation{
-					{Op: "add", Path: "/name", Value: "test"},
+				ItemID:     "test123",
+				EventID:    "event-123",
+				Collection: "items",
+				Operation:  "add",
+				Path:       "/content",
+				Value:      "test value",
+				From:       "",
+				Timestamp:  time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),
 			},
-				Timestamp: timestamp,
-			},
-			expected: "seq:1|item_id:item1|event_id:event1|collection:test|patches:[{\"op\":\"add\",\"path\":\"/name\",\"value\":\"test\"}]|timestamp:2024-01-01T12:00:00Z",
 		},
 		{
-			name: "event with multiple patches",
+			name: "event with multiple fields",
 			event: Event{
 				Seq:        2,
-				ItemID:     "item2",
-				EventID:    "event2",
-				Collection: "users",
-				Patches: []PatchOperation{
-					{Op: "add", Path: "/name", Value: "John"},
-					{Op: "add", Path: "/age", Value: 30},
+				ItemID:     "test456",
+				EventID:    "event-456",
+				Collection: "shopping_items",
+				Operation:  "replace",
+				Path:       "/priority",
+				Value:      "high",
+				From:       "/old_priority",
+				Timestamp:  time.Date(2025, 1, 2, 12, 0, 0, 0, time.UTC),
 			},
-				Timestamp: timestamp,
-			},
-			expected: "seq:2|item_id:item2|event_id:event2|collection:users|patches:[{\"op\":\"add\",\"path\":\"/name\",\"value\":\"John\"},{\"op\":\"add\",\"path\":\"/age\",\"value\":30}]|timestamp:2024-01-01T12:00:00Z",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := tt.event.serialize()
-			assert.Equal(t, tt.expected, result)
+			serialized := tt.event.serialize()
+
+			// Check that all fields are present in serialized string
+			assert.Contains(t, serialized, "seq:")
+			assert.Contains(t, serialized, "item_id:")
+			assert.Contains(t, serialized, "event_id:")
+			assert.Contains(t, serialized, "collection:")
+			assert.Contains(t, serialized, "operation:")
+			assert.Contains(t, serialized, "path:")
+			assert.Contains(t, serialized, "value:")
+			assert.Contains(t, serialized, "from:")
+			assert.Contains(t, serialized, "timestamp:")
 		})
 	}
 }
 
 func TestEvent_CalculateHash(t *testing.T) {
-	timestamp := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)
-
-	event := Event{
-		Seq:        1,
-		ItemID:     "item1",
-		EventID:    "event1",
-		Collection: "test",
-		Patches: []PatchOperation{
-			{Op: "add", Path: "/name", Value: "test"},
-		},
-		Timestamp: timestamp,
-	}
-
 	tests := []struct {
 		name     string
+		event    Event
 		prevHash string
-		expected string
 	}{
 		{
 			name: "first event (no previous hash)",
+			event: Event{
+				Seq:        1,
+				ItemID:     "test123",
+				EventID:    "event-123",
+				Collection: "items",
+				Operation:  "add",
+				Path:       "/content",
+				Value:      "test value",
+				Timestamp:  time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),
+			},
 			prevHash: "",
-			expected: "2f8b0b9e2d6c5c3e8a4f5d2c7b1a9e6f4c8d3b2a1e9f7c5a3b8d6e2c9f1a4b7c",
 		},
 		{
 			name: "second event (with previous hash)",
-			prevHash: "previous123",
-			expected: "8a9b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b",
+			event: Event{
+				Seq:        2,
+				ItemID:     "test123",
+				EventID:    "event-124",
+				Collection: "items",
+				Operation:  "replace",
+				Path:       "/content",
+				Value:      "updated value",
+				Timestamp:  time.Date(2025, 1, 1, 1, 0, 0, 0, time.UTC),
+			},
+			prevHash: "previous_hash_123",
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := event.calculateHash(tt.prevHash)
-			// Since hash calculation is deterministic, we just check that it produces a valid hash
-			assert.Len(t, result, 64) // SHA256 produces 64 character hex string
-			assert.NotEmpty(t, result)
+			hash := tt.event.calculateHash(tt.prevHash)
 
-			// Ensure same input produces same hash
-			result2 := event.calculateHash(tt.prevHash)
-			assert.Equal(t, result, result2)
+			// Hash should not be empty
+			assert.NotEmpty(t, hash)
+
+			// Hash should be deterministic
+			hash2 := tt.event.calculateHash(tt.prevHash)
+			assert.Equal(t, hash, hash2)
+
+			// Different previous hash should produce different result
+			if tt.prevHash == "" {
+				differentHash := tt.event.calculateHash("different")
+				assert.NotEqual(t, hash, differentHash)
+			}
 		})
 	}
 }
 
 func TestEvent_CalculateHash_Consistency(t *testing.T) {
-	timestamp := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)
-
-	event1 := Event{
+	event := Event{
 		Seq:        1,
-		ItemID:     "item1",
-		EventID:    "event1",
-		Collection: "test",
-		Patches: []PatchOperation{
-			{Op: "add", Path: "/name", Value: "test"},
-		},
-		Timestamp: timestamp,
+		ItemID:     "test123",
+		EventID:    "event-123",
+		Collection: "items",
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "test value",
+		Timestamp:  time.Date(2025, 1, 1, 0, 0, 0, 0, time.UTC),
 	}
 
-	event2 := Event{
-		Seq:        1,
-		ItemID:     "item1",
-		EventID:    "event1",
-		Collection: "test",
-		Patches: []PatchOperation{
-			{Op: "add", Path: "/name", Value: "test"},
-		},
-		Timestamp: timestamp,
-	}
-
-	// Same events should produce same hash
-	hash1 := event1.calculateHash("prev")
-	hash2 := event2.calculateHash("prev")
+	// Same event should always produce same hash
+	hash1 := event.calculateHash("prev")
+	hash2 := event.calculateHash("prev")
 	assert.Equal(t, hash1, hash2)
 
-	// Different events should produce different hashes
-	event2.ItemID = "item2"
-	hash3 := event2.calculateHash("prev")
+	// Different previous hash should produce different hash
+	hash3 := event.calculateHash("different_prev")
 	assert.NotEqual(t, hash1, hash3)
 }
 
-// Mock for testing event store without actual database
+// Mock Event Store for testing
 type MockEventStore struct {
 	events       []Event
-	items  map[string]map[string]interface{}
+	latestEvent  *Event
+	processError error
+	syncValid    bool
 }
 
-func NewMockEventStore() *MockEventStore {
-	return &MockEventStore{
-		events: []Event{},
-		items:  make(map[string]map[string]interface{}),
+func (m *MockEventStore) ProcessEvent(event *Event) (*Event, error) {
+	if m.processError != nil {
+		return nil, m.processError
 	}
+
+	processedEvent := &Event{
+		Seq:        len(m.events) + 1,
+		Hash:       "mock_hash",
+		ItemID:     event.ItemID,
+		EventID:    "mock_event_id",
+		Collection: event.Collection,
+		Operation:  event.Operation,
+		Path:       event.Path,
+		Value:      event.Value,
+		From:       event.From,
+		Timestamp:  time.Now(),
+	}
+
+	m.events = append(m.events, *processedEvent)
+	m.latestEvent = processedEvent
+	return processedEvent, nil
 }
 
 func (m *MockEventStore) GetLatestEvent() (*Event, error) {
-	if len(m.events) == 0 {
-		return nil, nil
-	}
-	return &m.events[len(m.events)-1], nil
+	return m.latestEvent, nil
 }
 
-func (m *MockEventStore) SaveEvent(event *Event) error {
-	m.events = append(m.events, *event)
-	return nil
+func (m *MockEventStore) GetEventsSince(seq int) ([]Event, error) {
+	var events []Event
+	for _, event := range m.events {
+		if event.Seq > seq {
+			events = append(events, event)
+		}
+	}
+	return events, nil
 }
 
-func (m *MockEventStore) ApplyPatchesToDocument(collection, itemID string, patches []PatchOperation) error {
-	key := collection + ":" + itemID
-
-	if m.items[key] == nil {
-		m.items[key] = map[string]interface{}{
-			"id":         itemID,
-			"created_at": time.Now(),
-		}
-	}
-
-	patcher := &JSONPatcher{}
-	updated, err := patcher.ApplyPatches(m.items[key], patches)
-	if err != nil {
-		return err
-	}
-
-	updated["updated_at"] = time.Now()
-	m.items[key] = updated
-	return nil
+func (m *MockEventStore) ValidateSync(seq int, hash string) (bool, error) {
+	return m.syncValid, nil
 }
 
-func (m *MockEventStore) GetDocument(collection, itemID string) (map[string]interface{}, error) {
-	key := collection + ":" + itemID
-	if doc, exists := m.items[key]; exists {
-		return doc, nil
+func (m *MockEventStore) GetAllItems(collection string) ([]map[string]interface{}, error) {
+	// Mock implementation
+	items := []map[string]interface{}{
+		{"id": "item1", "content": "test item 1"},
+		{"id": "item2", "content": "test item 2"},
 	}
-	return nil, nil
+	return items, nil
 }
 
 func TestEventProcessing_CreateItem(t *testing.T) {
-	mock := NewMockEventStore()
+	mockStore := &MockEventStore{}
 
-	// Create item event
-	patches := []PatchOperation{
-		{Op: "add", Path: "/content", Value: "Test Item"},
-		{Op: "add", Path: "/priority", Value: "high"},
-	}
-
-	// Simulate processing
 	event := &Event{
-		Seq:        1,
-		ItemID:     "item1",
-		EventID:    "event1",
+		ItemID:     "test123",
 		Collection: "shopping_items",
-		Patches:    patches,
-		Timestamp:  time.Now(),
-		Hash:       "hash1",
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "My test item",
 	}
 
-	err := mock.SaveEvent(event)
-	assert.NoError(t, err)
-
-	err = mock.ApplyPatchesToDocument("shopping_items", "item1", patches)
-	assert.NoError(t, err)
-
-	// Verify document was created correctly
-	doc, err := mock.GetDocument("shopping_items", "item1")
-	assert.NoError(t, err)
-	assert.NotNil(t, doc)
-	assert.Equal(t, "item1", doc["id"])
-	assert.Equal(t, "Test Item", doc["content"])
-	assert.Equal(t, "high", doc["priority"])
-	assert.NotNil(t, doc["created_at"])
-	assert.NotNil(t, doc["updated_at"])
+	result, err := mockStore.ProcessEvent(event)
+	require.NoError(t, err)
+	assert.Equal(t, "test123", result.ItemID)
+	assert.Equal(t, "add", result.Operation)
+	assert.Equal(t, "/content", result.Path)
+	assert.Equal(t, "My test item", result.Value)
+	assert.Equal(t, 1, result.Seq)
 }
 
 func TestEventProcessing_UpdateItem(t *testing.T) {
-	mock := NewMockEventStore()
+	mockStore := &MockEventStore{}
 
-	// First create an item
-	createPatches := []PatchOperation{
-		{Op: "add", Path: "/content", Value: "Original Content"},
-		{Op: "add", Path: "/status", Value: "draft"},
+	// Create item first
+	createEvent := &Event{
+		ItemID:     "test123",
+		Collection: "shopping_items",
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "Original content",
+	}
+	_, err := mockStore.ProcessEvent(createEvent)
+	require.NoError(t, err)
+
+	// Update item
+	updateEvent := &Event{
+		ItemID:     "test123",
+		Collection: "shopping_items",
+		Operation:  "replace",
+		Path:       "/content",
+		Value:      "Updated content",
 	}
 
-	err := mock.ApplyPatchesToDocument("shopping_items", "item1", createPatches)
-	assert.NoError(t, err)
-
-	// Now update it
-	updatePatches := []PatchOperation{
-		{Op: "replace", Path: "/content", Value: "Updated Content"},
-		{Op: "replace", Path: "/status", Value: "published"},
-		{Op: "add", Path: "/tags", Value: []interface{}{"updated", "content"}},
-	}
-
-	err = mock.ApplyPatchesToDocument("shopping_items", "item1", updatePatches)
-	assert.NoError(t, err)
-
-	// Verify document was updated correctly
-	doc, err := mock.GetDocument("shopping_items", "item1")
-	assert.NoError(t, err)
-	assert.Equal(t, "Updated Content", doc["content"])
-	assert.Equal(t, "published", doc["status"])
-	assert.Equal(t, []interface{}{"updated", "content"}, doc["tags"])
+	result, err := mockStore.ProcessEvent(updateEvent)
+	require.NoError(t, err)
+	assert.Equal(t, "test123", result.ItemID)
+	assert.Equal(t, "replace", result.Operation)
+	assert.Equal(t, "/content", result.Path)
+	assert.Equal(t, "Updated content", result.Value)
+	assert.Equal(t, 2, result.Seq)
 }
 
 func TestEventProcessing_DeleteItem(t *testing.T) {
-	mock := NewMockEventStore()
+	mockStore := &MockEventStore{}
 
-	// First create an item
-	createPatches := []PatchOperation{
-		{Op: "add", Path: "/content", Value: "To Be Deleted"},
+	// Create item first
+	createEvent := &Event{
+		ItemID:     "test123",
+		Collection: "shopping_items",
+		Operation:  "add",
+		Path:       "/content",
+		Value:      "Test content",
+	}
+	_, err := mockStore.ProcessEvent(createEvent)
+	require.NoError(t, err)
+
+	// Soft delete item
+	deleteEvent := &Event{
+		ItemID:     "test123",
+		Collection: "shopping_items",
+		Operation:  "add",
+		Path:       "/deleted_at",
+		Value:      time.Now().Format(time.RFC3339),
 	}
 
-	err := mock.ApplyPatchesToDocument("shopping_items", "item1", createPatches)
-	assert.NoError(t, err)
-
-	// Now soft delete it
-	deleteTime := time.Now()
-	deletePatches := []PatchOperation{
-		{Op: "add", Path: "/deleted_at", Value: deleteTime},
-	}
-
-	err = mock.ApplyPatchesToDocument("shopping_items", "item1", deletePatches)
-	assert.NoError(t, err)
-
-	// Verify document was soft deleted
-	doc, err := mock.GetDocument("shopping_items", "item1")
-	assert.NoError(t, err)
-	assert.Equal(t, "To Be Deleted", doc["content"])
-	assert.NotNil(t, doc["deleted_at"])
+	result, err := mockStore.ProcessEvent(deleteEvent)
+	require.NoError(t, err)
+	assert.Equal(t, "test123", result.ItemID)
+	assert.Equal(t, "add", result.Operation)
+	assert.Equal(t, "/deleted_at", result.Path)
+	assert.NotEmpty(t, result.Value)
+	assert.Equal(t, 2, result.Seq)
 }
 
 func TestEventProcessing_ComplexOperations(t *testing.T) {
-	mock := NewMockEventStore()
+	mockStore := &MockEventStore{}
 
-	// Create complex item with nested data
-	createPatches := []PatchOperation{
-		{Op: "add", Path: "/title", Value: "Complex Item"},
-		{Op: "add", Path: "/metadata", Value: map[string]interface{}{
-			"version":  1,
-			"category": "test",
-		}},
-		{Op: "add", Path: "/tags", Value: []interface{}{"tag1", "tag2"}},
+	tests := []struct {
+		name      string
+		operation string
+		path      string
+		value     string
+		from      string
+	}{
+		{"add priority", "add", "/priority", "high", ""},
+		{"replace content", "replace", "/content", "new content", ""},
+		{"move field", "move", "/title", "", "/content"},
+		{"copy field", "copy", "/backup_content", "", "/content"},
+		{"remove field", "remove", "/priority", "", ""},
 	}
 
-	err := mock.ApplyPatchesToDocument("items", "complex1", createPatches)
-	assert.NoError(t, err)
-
-	// Perform complex updates
-	updatePatches := []PatchOperation{
-		{Op: "replace", Path: "/title", Value: "Updated Complex Item"},
-		{Op: "replace", Path: "/metadata/version", Value: 2},
-		{Op: "add", Path: "/metadata/author", Value: "John Doe"},
-		{Op: "remove", Path: "/tags/0"}, // Remove first tag (will set to nil in our implementation)
-		{Op: "add", Path: "/description", Value: "A complex item for testing"},
+	for i, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			event := &Event{
+				ItemID:     "test123",
+				Collection: "shopping_items",
+				Operation:  tt.operation,
+				Path:       tt.path,
+				Value:      tt.value,
+				From:       tt.from,
 			}
 
-	err = mock.ApplyPatchesToDocument("items", "complex1", updatePatches)
-	assert.NoError(t, err)
-
-	// Verify complex updates
-	doc, err := mock.GetDocument("items", "complex1")
-	assert.NoError(t, err)
-	assert.Equal(t, "Updated Complex Item", doc["title"])
-	assert.Equal(t, "A complex item for testing", doc["description"])
-
-	metadata := doc["metadata"].(map[string]interface{})
-	assert.Equal(t, 2, metadata["version"]) // Our mock doesn't do JSON unmarshaling
-	assert.Equal(t, "John Doe", metadata["author"])
-
-	tags := doc["tags"].([]interface{})
-	assert.Nil(t, tags[0]) // First tag should be nil (removed)
-	assert.Equal(t, "tag2", tags[1])
+			result, err := mockStore.ProcessEvent(event)
+			require.NoError(t, err)
+			assert.Equal(t, "test123", result.ItemID)
+			assert.Equal(t, tt.operation, result.Operation)
+			assert.Equal(t, tt.path, result.Path)
+			assert.Equal(t, i+1, result.Seq)
+		})
+	}
 }
 
 func TestEventSerialization(t *testing.T) {
 	event := Event{
 		Seq:        42,
-		Hash:       "testhash123",
-		ItemID:     "item123",
-		EventID:    "event456",
+		ItemID:     "item-456",
+		EventID:    "event-789",
 		Collection: "test_collection",
-		Patches: []PatchOperation{
-			{Op: "add", Path: "/name", Value: "Test"},
-			{Op: "replace", Path: "/status", Value: "active"},
-		},
-		Timestamp: time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC),
+		Operation:  "replace",
+		Path:       "/status",
+		Value:      "completed",
+		From:       "/old_status",
+		Timestamp:  time.Date(2025, 3, 15, 14, 30, 0, 0, time.UTC),
 	}
 
-	// Test JSON serialization
-	jsonData, err := json.Marshal(event)
-	assert.NoError(t, err)
-	assert.NotEmpty(t, jsonData)
+	serialized := event.serialize()
 
-	// Test JSON deserialization
-	var deserializedEvent Event
-	err = json.Unmarshal(jsonData, &deserializedEvent)
-	assert.NoError(t, err)
-
-	assert.Equal(t, event.Seq, deserializedEvent.Seq)
-	assert.Equal(t, event.Hash, deserializedEvent.Hash)
-	assert.Equal(t, event.ItemID, deserializedEvent.ItemID)
-	assert.Equal(t, event.EventID, deserializedEvent.EventID)
-	assert.Equal(t, event.Collection, deserializedEvent.Collection)
-	assert.Equal(t, len(event.Patches), len(deserializedEvent.Patches))
-	assert.Equal(t, event.Patches[0].Op, deserializedEvent.Patches[0].Op)
-	assert.Equal(t, event.Patches[0].Path, deserializedEvent.Patches[0].Path)
-	assert.Equal(t, event.Patches[0].Value, deserializedEvent.Patches[0].Value)
+	// Verify all components are present
+	assert.Contains(t, serialized, "seq:42")
+	assert.Contains(t, serialized, "item_id:item-456")
+	assert.Contains(t, serialized, "event_id:event-789")
+	assert.Contains(t, serialized, "collection:test_collection")
+	assert.Contains(t, serialized, "operation:replace")
+	assert.Contains(t, serialized, "path:/status")
+	assert.Contains(t, serialized, "value:completed")
+	assert.Contains(t, serialized, "from:/old_status")
+	assert.Contains(t, serialized, "timestamp:2025-03-15T14:30:00Z")
 }
 
 func TestPatchOperationSerialization(t *testing.T) {
-	patch := PatchOperation{
+	op := PatchOperation{
 		Op:    "add",
-		Path:  "/user/name",
-		Value: "John Doe",
+		Path:  "/test",
+		Value: "test value",
+		From:  "/source",
 	}
 
-	// Test JSON serialization
-	jsonData, err := json.Marshal(patch)
-	assert.NoError(t, err)
-	assert.Contains(t, string(jsonData), "\"op\":\"add\"")
-	assert.Contains(t, string(jsonData), "\"path\":\"/user/name\"")
-	assert.Contains(t, string(jsonData), "\"value\":\"John Doe\"")
-
-	// Test JSON deserialization
-	var deserializedPatch PatchOperation
-	err = json.Unmarshal(jsonData, &deserializedPatch)
-	assert.NoError(t, err)
-	assert.Equal(t, patch.Op, deserializedPatch.Op)
-	assert.Equal(t, patch.Path, deserializedPatch.Path)
-	assert.Equal(t, patch.Value, deserializedPatch.Value)
+	// Test that PatchOperation can be used in JSON operations
+	assert.Equal(t, "add", op.Op)
+	assert.Equal(t, "/test", op.Path)
+	assert.Equal(t, "test value", op.Value)
+	assert.Equal(t, "/source", op.From)
 }
 
 func TestSyncRequest_Response(t *testing.T) {
 	// Test SyncRequest
-	syncReq := SyncRequest{
+	req := SyncRequest{
 		LastSeq:  10,
-		LastHash: "lasthash123",
+		LastHash: "abc123hash",
 	}
 
-	jsonData, err := json.Marshal(syncReq)
-	assert.NoError(t, err)
-
-	var deserializedReq SyncRequest
-	err = json.Unmarshal(jsonData, &deserializedReq)
-	assert.NoError(t, err)
-	assert.Equal(t, syncReq.LastSeq, deserializedReq.LastSeq)
-	assert.Equal(t, syncReq.LastHash, deserializedReq.LastHash)
+	assert.Equal(t, 10, req.LastSeq)
+	assert.Equal(t, "abc123hash", req.LastHash)
 
 	// Test SyncResponse
-	syncResp := SyncResponse{
-		Events: []Event{
+	events := []Event{
 		{
 			Seq:       11,
 			ItemID:    "item1",
-				Collection: "test",
-				Patches: []PatchOperation{
-					{Op: "add", Path: "/name", Value: "test"},
+			Operation: "add",
+			Path:      "/content",
+			Value:     "new item",
 		},
+		{
+			Seq:       12,
+			ItemID:    "item2",
+			Operation: "replace",
+			Path:      "/status",
+			Value:     "updated",
 		},
-		},
-		CurrentSeq:  11,
-		CurrentHash: "currenthash456",
+	}
+
+	resp := SyncResponse{
+		Events:      events,
+		CurrentSeq:  12,
+		CurrentHash: "def456hash",
 		FullSync:    false,
 	}
 
-	jsonData, err = json.Marshal(syncResp)
-	assert.NoError(t, err)
+	assert.Len(t, resp.Events, 2)
+	assert.Equal(t, 12, resp.CurrentSeq)
+	assert.Equal(t, "def456hash", resp.CurrentHash)
+	assert.False(t, resp.FullSync)
 
-	var deserializedResp SyncResponse
-	err = json.Unmarshal(jsonData, &deserializedResp)
-	assert.NoError(t, err)
-	assert.Equal(t, syncResp.CurrentSeq, deserializedResp.CurrentSeq)
-	assert.Equal(t, syncResp.CurrentHash, deserializedResp.CurrentHash)
-	assert.Equal(t, syncResp.FullSync, deserializedResp.FullSync)
-	assert.Len(t, deserializedResp.Events, 1)
-	assert.Equal(t, syncResp.Events[0].Seq, deserializedResp.Events[0].Seq)
+	// Verify event details
+	assert.Equal(t, "add", resp.Events[0].Operation)
+	assert.Equal(t, "replace", resp.Events[1].Operation)
 }

json_patch_test.go

@@ -1,83 +1,92 @@
 package main
 
 import (
-	"reflect"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestJSONPatcher_Add(t *testing.T) {
-	patcher := &JSONPatcher{}
-
 	tests := []struct {
 		name     string
 		doc      map[string]interface{}
-		patches  []PatchOperation
+		patch    PatchOperation
 		expected map[string]interface{}
 		wantErr  bool
 	}{
 		{
 			name: "add simple field",
-			doc:  map[string]interface{}{},
-			patches: []PatchOperation{
-				{Op: "add", Path: "/name", Value: "John"},
+			doc:  map[string]interface{}{"id": "test"},
+			patch: PatchOperation{
+				Op:    "add",
+				Path:  "/content",
+				Value: "test content",
 			},
 			expected: map[string]interface{}{
-				"name": "John",
+				"id":      "test",
+				"content": "test content",
 			},
 			wantErr: false,
 		},
 		{
 			name: "add nested field",
-			doc: map[string]interface{}{
-				"user": map[string]interface{}{},
-			},
-			patches: []PatchOperation{
-				{Op: "add", Path: "/user/name", Value: "Jane"},
+			doc:  map[string]interface{}{"id": "test", "meta": map[string]interface{}{}},
+			patch: PatchOperation{
+				Op:    "add",
+				Path:  "/meta/priority",
+				Value: "high",
 			},
 			expected: map[string]interface{}{
-				"user": map[string]interface{}{
-					"name": "Jane",
-				},
+				"id":   "test",
+				"meta": map[string]interface{}{"priority": "high"},
 			},
 			wantErr: false,
 		},
 		{
 			name: "add to existing field (overwrite)",
-			doc: map[string]interface{}{
-				"name": "Old Name",
-			},
-			patches: []PatchOperation{
-				{Op: "add", Path: "/name", Value: "New Name"},
+			doc:  map[string]interface{}{"id": "test", "content": "old"},
+			patch: PatchOperation{
+				Op:    "add",
+				Path:  "/content",
+				Value: "new",
 			},
 			expected: map[string]interface{}{
-				"name": "New Name",
+				"id":      "test",
+				"content": "new",
 			},
 			wantErr: false,
 		},
 		{
 			name: "add array field",
-			doc:  map[string]interface{}{},
-			patches: []PatchOperation{
-				{Op: "add", Path: "/tags", Value: []interface{}{"tag1", "tag2"}},
+			doc:  map[string]interface{}{"id": "test"},
+			patch: PatchOperation{
+				Op:    "add",
+				Path:  "/tags",
+				Value: []interface{}{"tag1", "tag2"},
 			},
 			expected: map[string]interface{}{
+				"id":   "test",
 				"tags": []interface{}{"tag1", "tag2"},
 			},
 			wantErr: false,
 		},
 		{
 			name: "add complex object",
-			doc:  map[string]interface{}{},
-			patches: []PatchOperation{
-				{Op: "add", Path: "/metadata", Value: map[string]interface{}{
-					"version": "1.0",
-					"active":  true,
-				}},
+			doc:  map[string]interface{}{"id": "test"},
+			patch: PatchOperation{
+				Op:   "add",
+				Path: "/metadata",
+				Value: map[string]interface{}{
+					"created": "2025-01-01",
+					"version": 1,
+				},
 			},
 			expected: map[string]interface{}{
+				"id": "test",
 				"metadata": map[string]interface{}{
-					"version": "1.0",
-					"active":  true,
+					"created": "2025-01-01",
+					"version": 1,
 				},
 			},
 			wantErr: false,
@@ -86,321 +95,340 @@ func TestJSONPatcher_Add(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := patcher.ApplyPatches(tt.doc, tt.patches)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ApplyPatches() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
-				t.Errorf("ApplyPatches() = %v, want %v", result, tt.expected)
+			patcher := &JSONPatcher{}
+			result, err := patcher.ApplyPatches(tt.doc, []PatchOperation{tt.patch})
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
 			}
 		})
 	}
 }
 
 func TestJSONPatcher_Remove(t *testing.T) {
-	patcher := &JSONPatcher{}
-
 	tests := []struct {
 		name     string
 		doc      map[string]interface{}
-		patches  []PatchOperation
+		patch    PatchOperation
 		expected map[string]interface{}
 		wantErr  bool
 	}{
 		{
 			name: "remove simple field",
 			doc: map[string]interface{}{
-				"name": "John",
-				"age":  30,
+				"id":      "test",
+				"content": "test content",
 			},
-			patches: []PatchOperation{
-				{Op: "remove", Path: "/name"},
+			patch: PatchOperation{
+				Op:   "remove",
+				Path: "/content",
 			},
 			expected: map[string]interface{}{
-				"age": 30,
+				"id": "test",
 			},
 			wantErr: false,
 		},
 		{
 			name: "remove nested field",
 			doc: map[string]interface{}{
-				"user": map[string]interface{}{
-					"name": "Jane",
-					"age":  25,
+				"id":   "test",
+				"meta": map[string]interface{}{"priority": "high", "tags": []string{"tag1"}},
 			},
-			},
-			patches: []PatchOperation{
-				{Op: "remove", Path: "/user/name"},
+			patch: PatchOperation{
+				Op:   "remove",
+				Path: "/meta/priority",
 			},
 			expected: map[string]interface{}{
-				"user": map[string]interface{}{
-					"age": 25,
-				},
+				"id":   "test",
+				"meta": map[string]interface{}{"tags": []string{"tag1"}},
 			},
 			wantErr: false,
 		},
 		{
 			name: "remove non-existent field",
 			doc: map[string]interface{}{
-				"name": "John",
+				"id": "test",
 			},
-			patches: []PatchOperation{
-				{Op: "remove", Path: "/age"},
+			patch: PatchOperation{
+				Op:   "remove",
+				Path: "/nonexistent",
+			},
+			expected: map[string]interface{}{
+				"id": "test",
 			},
-			expected: nil,
 			wantErr: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := patcher.ApplyPatches(tt.doc, tt.patches)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ApplyPatches() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
-				t.Errorf("ApplyPatches() = %v, want %v", result, tt.expected)
+			patcher := &JSONPatcher{}
+			result, err := patcher.ApplyPatches(tt.doc, []PatchOperation{tt.patch})
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
 			}
 		})
 	}
 }
 
 func TestJSONPatcher_Replace(t *testing.T) {
-	patcher := &JSONPatcher{}
-
 	tests := []struct {
 		name     string
 		doc      map[string]interface{}
-		patches  []PatchOperation
+		patch    PatchOperation
 		expected map[string]interface{}
 		wantErr  bool
 	}{
 		{
 			name: "replace simple field",
 			doc: map[string]interface{}{
-				"name": "John",
+				"id":      "test",
+				"content": "old content",
 			},
-			patches: []PatchOperation{
-				{Op: "replace", Path: "/name", Value: "Jane"},
+			patch: PatchOperation{
+				Op:    "replace",
+				Path:  "/content",
+				Value: "new content",
 			},
 			expected: map[string]interface{}{
-				"name": "Jane",
+				"id":      "test",
+				"content": "new content",
 			},
 			wantErr: false,
 		},
 		{
 			name: "replace nested field",
 			doc: map[string]interface{}{
-				"user": map[string]interface{}{
-					"name": "John",
+				"id":   "test",
+				"meta": map[string]interface{}{"priority": "low"},
 			},
-			},
-			patches: []PatchOperation{
-				{Op: "replace", Path: "/user/name", Value: "Jane"},
+			patch: PatchOperation{
+				Op:    "replace",
+				Path:  "/meta/priority",
+				Value: "high",
 			},
 			expected: map[string]interface{}{
-				"user": map[string]interface{}{
-					"name": "Jane",
-				},
+				"id":   "test",
+				"meta": map[string]interface{}{"priority": "high"},
 			},
 			wantErr: false,
 		},
 		{
 			name: "replace non-existent field",
 			doc: map[string]interface{}{
-				"name": "John",
+				"id": "test",
 			},
-			patches: []PatchOperation{
-				{Op: "replace", Path: "/age", Value: 30},
+			patch: PatchOperation{
+				Op:    "replace",
+				Path:  "/nonexistent",
+				Value: "value",
+			},
+			expected: map[string]interface{}{
+				"id": "test",
 			},
-			expected: nil,
 			wantErr: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := patcher.ApplyPatches(tt.doc, tt.patches)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ApplyPatches() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
-				t.Errorf("ApplyPatches() = %v, want %v", result, tt.expected)
+			patcher := &JSONPatcher{}
+			result, err := patcher.ApplyPatches(tt.doc, []PatchOperation{tt.patch})
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
 			}
 		})
 	}
 }
 
 func TestJSONPatcher_Test(t *testing.T) {
-	patcher := &JSONPatcher{}
-
 	tests := []struct {
 		name    string
 		doc     map[string]interface{}
-		patches  []PatchOperation
-		expected map[string]interface{}
+		patch   PatchOperation
 		wantErr bool
 	}{
 		{
 			name: "test field success",
 			doc: map[string]interface{}{
-				"name": "John",
+				"id":      "test",
+				"content": "test content",
 			},
-			patches: []PatchOperation{
-				{Op: "test", Path: "/name", Value: "John"},
-			},
-			expected: map[string]interface{}{
-				"name": "John",
+			patch: PatchOperation{
+				Op:    "test",
+				Path:  "/content",
+				Value: "test content",
 			},
 			wantErr: false,
 		},
 		{
 			name: "test field failure",
 			doc: map[string]interface{}{
-				"name": "John",
+				"id":      "test",
+				"content": "test content",
 			},
-			patches: []PatchOperation{
-				{Op: "test", Path: "/name", Value: "Jane"},
+			patch: PatchOperation{
+				Op:    "test",
+				Path:  "/content",
+				Value: "different content",
 			},
-			expected: nil,
 			wantErr: true,
 		},
 		{
 			name: "test non-existent field",
 			doc: map[string]interface{}{
-				"name": "John",
+				"id": "test",
 			},
-			patches: []PatchOperation{
-				{Op: "test", Path: "/age", Value: 30},
+			patch: PatchOperation{
+				Op:    "test",
+				Path:  "/nonexistent",
+				Value: "value",
 			},
-			expected: nil,
 			wantErr: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := patcher.ApplyPatches(tt.doc, tt.patches)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ApplyPatches() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
-				t.Errorf("ApplyPatches() = %v, want %v", result, tt.expected)
+			patcher := &JSONPatcher{}
+			_, err := patcher.ApplyPatches(tt.doc, []PatchOperation{tt.patch})
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
 			}
 		})
 	}
 }
 
 func TestJSONPatcher_Move(t *testing.T) {
-	patcher := &JSONPatcher{}
-
 	tests := []struct {
 		name     string
 		doc      map[string]interface{}
-		patches  []PatchOperation
+		patch    PatchOperation
 		expected map[string]interface{}
 		wantErr  bool
 	}{
 		{
 			name: "move field",
 			doc: map[string]interface{}{
-				"firstName": "John",
-				"lastName":  "Doe",
+				"id":      "test",
+				"content": "test content",
 			},
-			patches: []PatchOperation{
-				{Op: "move", From: "/firstName", Path: "/name"},
+			patch: PatchOperation{
+				Op:   "move",
+				From: "/content",
+				Path: "/title",
 			},
 			expected: map[string]interface{}{
-				"lastName": "Doe",
-				"name":     "John",
+				"id":    "test",
+				"title": "test content",
 			},
 			wantErr: false,
 		},
 		{
 			name: "move non-existent field",
 			doc: map[string]interface{}{
-				"name": "John",
+				"id": "test",
 			},
-			patches: []PatchOperation{
-				{Op: "move", From: "/age", Path: "/userAge"},
+			patch: PatchOperation{
+				Op:   "move",
+				From: "/nonexistent",
+				Path: "/title",
+			},
+			expected: map[string]interface{}{
+				"id": "test",
 			},
-			expected: nil,
 			wantErr: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := patcher.ApplyPatches(tt.doc, tt.patches)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ApplyPatches() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
-				t.Errorf("ApplyPatches() = %v, want %v", result, tt.expected)
+			patcher := &JSONPatcher{}
+			result, err := patcher.ApplyPatches(tt.doc, []PatchOperation{tt.patch})
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
 			}
 		})
 	}
 }
 
 func TestJSONPatcher_Copy(t *testing.T) {
-	patcher := &JSONPatcher{}
-
 	tests := []struct {
 		name     string
 		doc      map[string]interface{}
-		patches  []PatchOperation
+		patch    PatchOperation
 		expected map[string]interface{}
 		wantErr  bool
 	}{
 		{
 			name: "copy field",
 			doc: map[string]interface{}{
-				"name": "John",
+				"id":      "test",
+				"content": "test content",
 			},
-			patches: []PatchOperation{
-				{Op: "copy", From: "/name", Path: "/displayName"},
+			patch: PatchOperation{
+				Op:   "copy",
+				From: "/content",
+				Path: "/title",
 			},
 			expected: map[string]interface{}{
-				"name":        "John",
-				"displayName": "John",
+				"id":      "test",
+				"content": "test content",
+				"title":   "test content",
 			},
 			wantErr: false,
 		},
 		{
 			name: "copy non-existent field",
 			doc: map[string]interface{}{
-				"name": "John",
+				"id": "test",
 			},
-			patches: []PatchOperation{
-				{Op: "copy", From: "/age", Path: "/userAge"},
+			patch: PatchOperation{
+				Op:   "copy",
+				From: "/nonexistent",
+				Path: "/title",
+			},
+			expected: map[string]interface{}{
+				"id": "test",
 			},
-			expected: nil,
 			wantErr: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result, err := patcher.ApplyPatches(tt.doc, tt.patches)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ApplyPatches() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
-				t.Errorf("ApplyPatches() = %v, want %v", result, tt.expected)
+			patcher := &JSONPatcher{}
+			result, err := patcher.ApplyPatches(tt.doc, []PatchOperation{tt.patch})
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
 			}
 		})
 	}
 }
 
 func TestJSONPatcher_Complex(t *testing.T) {
-	patcher := &JSONPatcher{}
-
 	tests := []struct {
 		name     string
 		doc      map[string]interface{}
@@ -410,71 +438,63 @@ func TestJSONPatcher_Complex(t *testing.T) {
 	}{
 		{
 			name: "multiple operations",
-			doc: map[string]interface{}{
-				"name": "John",
-				"age":  30,
-			},
+			doc:  map[string]interface{}{"id": "test"},
 			patches: []PatchOperation{
-				{Op: "replace", Path: "/name", Value: "Jane"},
-				{Op: "add", Path: "/email", Value: "jane@example.com"},
-				{Op: "remove", Path: "/age"},
+				{Op: "add", Path: "/content", Value: "test"},
+				{Op: "add", Path: "/priority", Value: "high"},
+				{Op: "replace", Path: "/content", Value: "updated test"},
 			},
 			expected: map[string]interface{}{
-				"name":  "Jane",
-				"email": "jane@example.com",
+				"id":       "test",
+				"content":  "updated test",
+				"priority": "high",
 			},
 			wantErr: false,
 		},
 		{
 			name: "test then modify",
-			doc: map[string]interface{}{
-				"version": "1.0",
-				"name":    "App",
-			},
+			doc:  map[string]interface{}{"id": "test", "version": 1},
 			patches: []PatchOperation{
-				{Op: "test", Path: "/version", Value: "1.0"},
-				{Op: "replace", Path: "/version", Value: "1.1"},
-				{Op: "add", Path: "/updated", Value: true},
+				{Op: "test", Path: "/version", Value: 1},
+				{Op: "replace", Path: "/version", Value: 2},
 			},
 			expected: map[string]interface{}{
-				"version": "1.1",
-				"name":    "App",
-				"updated": true,
+				"id":      "test",
+				"version": 2,
 			},
 			wantErr: false,
 		},
 		{
 			name: "failed test stops execution",
-			doc: map[string]interface{}{
-				"version": "1.0",
-				"name":    "App",
-			},
+			doc:  map[string]interface{}{"id": "test", "version": 1},
 			patches: []PatchOperation{
-				{Op: "test", Path: "/version", Value: "2.0"}, // This will fail
-				{Op: "replace", Path: "/version", Value: "1.1"},
+				{Op: "test", Path: "/version", Value: 2}, // This should fail
+				{Op: "replace", Path: "/version", Value: 3},
+			},
+			expected: map[string]interface{}{
+				"id":      "test",
+				"version": 1,
 			},
-			expected: nil,
 			wantErr: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			patcher := &JSONPatcher{}
 			result, err := patcher.ApplyPatches(tt.doc, tt.patches)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ApplyPatches() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if !tt.wantErr && !reflect.DeepEqual(result, tt.expected) {
-				t.Errorf("ApplyPatches() = %v, want %v", result, tt.expected)
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expected, result)
 			}
 		})
 	}
 }
 
 func TestJSONPatcher_ParsePath(t *testing.T) {
-	patcher := &JSONPatcher{}
-
 	tests := []struct {
 		name     string
 		path     string
@@ -492,69 +512,62 @@ func TestJSONPatcher_ParsePath(t *testing.T) {
 		},
 		{
 			name:     "simple path",
-			path:     "/name",
-			expected: []string{"name"},
+			path:     "/content",
+			expected: []string{"content"},
 		},
 		{
 			name:     "nested path",
-			path:     "/user/name",
-			expected: []string{"user", "name"},
+			path:     "/meta/priority",
+			expected: []string{"meta", "priority"},
 		},
 		{
 			name:     "path with escaped characters",
-			path:     "/user/first~0name",
-			expected: []string{"user", "first~name"},
+			path:     "/content~1title",
+			expected: []string{"content/title"},
 		},
 		{
 			name:     "path with escaped slash",
-			path:     "/user/first~1name",
-			expected: []string{"user", "first/name"},
+			path:     "/content~0title",
+			expected: []string{"content~title"},
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			patcher := &JSONPatcher{}
 			result := patcher.parsePath(tt.path)
-			if !reflect.DeepEqual(result, tt.expected) {
-				t.Errorf("parsePath() = %v, want %v", result, tt.expected)
-			}
+			assert.Equal(t, tt.expected, result)
 		})
 	}
 }
 
 func TestJSONPatcher_InvalidOperations(t *testing.T) {
-	patcher := &JSONPatcher{}
-
 	tests := []struct {
 		name  string
-		doc     map[string]interface{}
-		patches []PatchOperation
-		wantErr bool
+		patch PatchOperation
 	}{
 		{
 			name: "invalid operation",
-			doc:  map[string]interface{}{},
-			patches: []PatchOperation{
-				{Op: "invalid", Path: "/name", Value: "John"},
+			patch: PatchOperation{
+				Op:   "invalid",
+				Path: "/content",
 			},
-			wantErr: true,
 		},
 		{
 			name: "invalid path format",
-			doc:  map[string]interface{}{},
-			patches: []PatchOperation{
-				{Op: "add", Path: "name", Value: "John"}, // Missing leading slash
+			patch: PatchOperation{
+				Op:   "add",
+				Path: "content", // missing leading slash
 			},
-			wantErr: true,
 		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			_, err := patcher.ApplyPatches(tt.doc, tt.patches)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ApplyPatches() error = %v, wantErr %v", err, tt.wantErr)
-			}
+			patcher := &JSONPatcher{}
+			doc := map[string]interface{}{"id": "test"}
+			_, err := patcher.ApplyPatches(doc, []PatchOperation{tt.patch})
+			assert.Error(t, err)
 		})
 	}
 }