lore-engine-poc/workers/encounter-processor/main_test.go

package main

import (
	"strings"
	"testing"
)

// ── parseParticipants ─────────────────────────────────────────────────────────

func TestParseParticipants(t *testing.T) {
	tests := []struct {
		name  string
		input string
		want  []string
	}{
		{
			name:  "three clean names",
			input: "Alice, Bob, Charlie",
			want:  []string{"Alice", "Bob", "Charlie"},
		},
		{
			name:  "extra whitespace is trimmed",
			input: "  Alice  ,  Bob  ",
			want:  []string{"Alice", "Bob"},
		},
		{
			name:  "single participant",
			input: "Gromm The Timeless",
			want:  []string{"Gromm The Timeless"},
		},
		{
			name:  "empty string returns empty slice",
			input: "",
			want:  nil,
		},
		{
			name:  "empty segments are dropped",
			input: "Alice,,Bob",
			want:  []string{"Alice", "Bob"},
		},
		{
			name:  "whitespace-only segment is dropped",
			input: "Alice,   ,Bob",
			want:  []string{"Alice", "Bob"},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := parseParticipants(tt.input)
			if len(got) != len(tt.want) {
				t.Fatalf("parseParticipants(%q) = %v, want %v", tt.input, got, tt.want)
			}
			for i, name := range got {
				if name != tt.want[i] {
					t.Errorf("got[%d] = %q, want %q", i, name, tt.want[i])
				}
			}
		})
	}
}

// ── Cypher constant integrity ─────────────────────────────────────────────────

func TestResolveEntityQueryShape(t *testing.T) {
	if !strings.Contains(resolveEntityQuery, "$name") {
		t.Error("resolveEntityQuery must reference $name parameter")
	}
	if !strings.Contains(resolveEntityQuery, "aliases") {
		t.Error("resolveEntityQuery must check aliases array")
	}
	if !strings.Contains(resolveEntityQuery, "lore_verified") {
		t.Error("resolveEntityQuery must filter on lore_verified")
	}
	if !strings.Contains(resolveEntityQuery, "LIMIT 1") {
		t.Error("resolveEntityQuery must return at most one result")
	}
}

func TestProvisionalCypherSetsFlag(t *testing.T) {
	if !strings.Contains(mergeWitnessedProvisional, "lore_verified") {
		t.Error("mergeWitnessedProvisional must set lore_verified flag")
	}
	if !strings.Contains(mergeLocationProvisional, "lore_verified") {
		t.Error("mergeLocationProvisional must set lore_verified flag")
	}
}

func TestCanonicalCypherUsesMatchNotMerge(t *testing.T) {
	// Canonical writes must MATCH (not MERGE) so they fail loudly if the
	// canonical node was somehow deleted, rather than silently creating a dup.
	if !strings.HasPrefix(strings.TrimSpace(mergeWitnessedCanonical), "MATCH") {
		t.Error("mergeWitnessedCanonical should start with MATCH to avoid silent creation")
	}
	if !strings.HasPrefix(strings.TrimSpace(mergeLocationCanonical), "MATCH") {
		t.Error("mergeLocationCanonical should start with MATCH to avoid silent creation")
	}
}