Resolve "Deprecate Providers package in favor of Worker"

services/data_service/internal/domain/identifier_test.go

@@ -0,0 +1,141 @@
+package domain
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestNewIdentifier_CanonicalAndValidation(t *testing.T) {
+	t.Run("canonical ordering and formatting", func(t *testing.T) {
+		id, err := NewIdentifier("ns", map[string]map[string]string{
+			"b": {"y": "2", "x": "1"},
+			"a": {},
+		})
+		if err != nil {
+			t.Fatalf("unexpected err: %v", err)
+		}
+		got := id.Key()
+		want := "ns::a[].b[x=1;y=2]"
+		if got != want {
+			t.Fatalf("key mismatch\ngot:  %q\nwant: %q", got, want)
+		}
+	})
+
+	t.Run("trim whitespace and validate", func(t *testing.T) {
+		id, err := NewIdentifier(" ns ", map[string]map[string]string{
+			" tag ": {" k ": " v "},
+		})
+		if err != nil {
+			t.Fatalf("unexpected err: %v", err)
+		}
+		if id.Key() != "ns::tag[k=v]" {
+			t.Fatalf("unexpected canonical: %q", id.Key())
+		}
+	})
+
+	t.Run("reject bad namespace", func(t *testing.T) {
+		cases := []string{"", "a:b", "a[b]"}
+		for _, ns := range cases {
+			if _, err := NewIdentifier(ns, nil); err == nil {
+				t.Fatalf("expected error for ns=%q", ns)
+			}
+		}
+	})
+
+	t.Run("reject bad tag names", func(t *testing.T) {
+		for _, name := range []string{"", "bad.", "bad[", "bad]", "a:b"} {
+			_, err := NewIdentifier("ns", map[string]map[string]string{
+				name: {},
+			})
+			if err == nil {
+				t.Fatalf("expected error for tag name %q", name)
+			}
+		}
+	})
+
+	t.Run("reject bad param keys and values", func(t *testing.T) {
+		badKeys := []string{"", "k;", "k[", "k]", "k="}
+		for _, k := range badKeys {
+			if _, err := NewIdentifier("ns", map[string]map[string]string{
+				"t": {k: "ok"},
+			}); err == nil {
+				t.Fatalf("expected error for bad key %q", k)
+			}
+		}
+		for _, v := range []string{"bad;", "bad[", "bad]", "a=b"} {
+			if _, err := NewIdentifier("ns", map[string]map[string]string{
+				"t": {"k": v},
+			}); err == nil {
+				t.Fatalf("expected error for bad value %q", v)
+			}
+		}
+	})
+}
+
+func TestIdentifier_Parse_RoundTripAndTolerance(t *testing.T) {
+	t.Run("round trip from constructor", func(t *testing.T) {
+		id, err := NewIdentifier("ns", map[string]map[string]string{
+			"a": {},
+			"b": {"x": "1", "y": "2"},
+		})
+		if err != nil {
+			t.Fatal(err)
+		}
+		ns, tags, err := id.Parse()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if ns != "ns" {
+			t.Fatalf("ns: got %q", ns)
+		}
+		want := map[string]map[string]string{"a": {}, "b": {"x": "1", "y": "2"}}
+		if !reflect.DeepEqual(tags, want) {
+			t.Fatalf("tags mismatch\ngot:  %#v\nwant: %#v", tags, want)
+		}
+	})
+
+	t.Run("parse bare tag as empty params", func(t *testing.T) {
+		id := NewIdentifierFromRaw("ns::a.b[]")
+		_, tags, err := id.Parse()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(tags["a"]) != 0 || len(tags["b"]) != 0 {
+			t.Fatalf("expected empty params, got %#v", tags)
+		}
+	})
+
+	t.Run("first token wins on duplicate tags and params", func(t *testing.T) {
+		id := NewIdentifierFromRaw("ns::t[x=1;y=2].t[x=9].u[k=1;k=2]")
+		_, tags, err := id.Parse()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if tags["t"]["x"] != "1" || tags["t"]["y"] != "2" {
+			t.Fatalf("first tag should win, got %#v", tags["t"])
+		}
+		if tags["u"]["k"] != "1" {
+			t.Fatalf("first param key should win, got %#v", tags["u"])
+		}
+	})
+
+	t.Run("reject malformed", func(t *testing.T) {
+		bads := []string{
+			"", "no_ns", "ns:onecolon", "::missingns::tag[]", "ns::tag[", "ns::tag]", "ns::[]",
+			"ns::tag[]junk", "ns::tag[x=1;y]", "ns::tag[=1]", "ns::tag[ x=1 ]", // spaces inside keys are rejected
+		}
+		for _, s := range bads {
+			_, _, err := NewIdentifierFromRaw(s).Parse()
+			if err == nil {
+				t.Fatalf("expected parse error for %q", s)
+			}
+		}
+	})
+}
+
+func TestIdentifier_NewThenParse_ForbidsColonInTagName(t *testing.T) {
+	_, err := NewIdentifier("ns", map[string]map[string]string{"a:b": {}})
+	if err == nil {
+		t.Fatal("expected error due to ':' in tag name")
+	}
+}