test: expand coverage across readers, writers, cmd, ui, diff and merge

Implements tests/_plans and previously deferred packages; updates plan
README with new coverage numbers.

pkg/readers/pgsql/queries_pure_test.go

@@ -0,0 +1,113 @@
+package pgsql
+
+import (
+	"testing"
+
+	"git.warky.dev/wdevs/relspecgo/pkg/models"
+)
+
+func TestNormalizePostgresDefault(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{"empty", "", ""},
+		{"function", "now()", "now()"},
+		{"nextval passthrough", "nextval('seq'::regclass)", "nextval('seq'::regclass)"},
+		{"number", "42", "42"},
+		{"null cast", "NULL::text", "NULL::text"},
+		{"quoted literal", "'abc'", "abc"},
+		{"quoted with cast", "'abc'::character varying", "abc"},
+		{"escaped quote", "'it''s'::text", "it's"},
+		{"empty literal", "''::text", ""},
+		{"only escaped quotes", "''''", "'"},
+		{"unterminated", "'abc", "abc"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := normalizePostgresDefault(tt.in); got != tt.want {
+				t.Errorf("normalizePostgresDefault(%q) = %q, want %q", tt.in, got, tt.want)
+			}
+		})
+	}
+}
+
+func TestCountHelpers(t *testing.T) {
+	cols := map[string]map[string]*models.Column{
+		"a": {"x": {}, "y": {}},
+		"b": {"z": {}},
+		"c": {},
+	}
+	if got := countColumns(cols); got != 3 {
+		t.Errorf("countColumns = %d, want 3", got)
+	}
+	if got := countColumns(nil); got != 0 {
+		t.Errorf("countColumns(nil) = %d, want 0", got)
+	}
+
+	cons := map[string][]*models.Constraint{"a": {{}, {}}, "b": {{}}}
+	if got := countConstraints(cons); got != 3 {
+		t.Errorf("countConstraints = %d, want 3", got)
+	}
+	if got := countConstraints(nil); got != 0 {
+		t.Errorf("countConstraints(nil) = %d, want 0", got)
+	}
+
+	idx := map[string][]*models.Index{"a": {{}}, "b": {{}, {}, {}}}
+	if got := countIndexes(idx); got != 4 {
+		t.Errorf("countIndexes = %d, want 4", got)
+	}
+	if got := countIndexes(nil); got != 0 {
+		t.Errorf("countIndexes(nil) = %d, want 0", got)
+	}
+}
+
+func TestExtractIndexOperatorClass(t *testing.T) {
+	tests := []struct {
+		name string
+		in   []string
+		want string
+	}{
+		{"none", nil, ""},
+		{"sort modifiers only", []string{"DESC", "NULLS", "LAST"}, ""},
+		{"opclass", []string{"", " Vector_Cosine_Ops "}, "vector_cosine_ops"},
+		{"opclass after ordering", []string{"desc", "gin_trgm_ops"}, "gin_trgm_ops"},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := extractIndexOperatorClass(tt.in); got != tt.want {
+				t.Errorf("got %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestBuildIndexHint(t *testing.T) {
+	tests := []struct {
+		opClass, params, want string
+	}{
+		{"", "", ""},
+		{"vector_cosine_ops", "", "opclass=vector_cosine_ops"},
+		{"", "m=16", "with (m=16)"},
+		{"vector_cosine_ops", "m=16", "opclass=vector_cosine_ops; with (m=16)"},
+	}
+	for _, tt := range tests {
+		if got := buildIndexHint(tt.opClass, tt.params); got != tt.want {
+			t.Errorf("buildIndexHint(%q,%q) = %q, want %q", tt.opClass, tt.params, got, tt.want)
+		}
+	}
+}
+
+func TestNormalizeIndexStorageParams(t *testing.T) {
+	tests := []struct{ in, want string }{
+		{"", ""},
+		{"m='16', ef_construction='64'", "m=16, ef_construction=64"},
+		{"key_field='id'", "key_field='id'"},
+	}
+	for _, tt := range tests {
+		if got := normalizeIndexStorageParams(tt.in); got != tt.want {
+			t.Errorf("normalizeIndexStorageParams(%q) = %q, want %q", tt.in, got, tt.want)
+		}
+	}
+}