new meta-core api, now redis is not exposed as an "API"

internal/cid/rank_test.go

@@ -0,0 +1,85 @@
+package cid
+
+import "testing"
+
+func TestRank_Ordering(t *testing.T) {
+	cases := []struct {
+		token string
+		want  int
+	}{
+		{"ipfs:bafy", 40},
+		{"sha256:bafk", 30},
+		{"sha3-256:abc", 30},
+		{"btih:def", 20},
+		{"btih-v2:def", 20},
+		{"midhash256:bafk", 10},
+		{"unknown:xyz", 0},
+		{"", 0},
+		{"bare-no-colon", 0},
+	}
+	for _, tc := range cases {
+		if got := Rank(tc.token); got != tc.want {
+			t.Errorf("Rank(%q) = %d, want %d", tc.token, got, tc.want)
+		}
+	}
+}
+
+func TestRank_StrictOrdering(t *testing.T) {
+	// The exact numbers don't matter, but the inequality chain does — this
+	// is what the canonical_cid reconciler relies on.
+	ipfs := Rank("ipfs:x")
+	sha := Rank("sha256:x")
+	btih := Rank("btih:x")
+	mid := Rank("midhash256:x")
+	unknown := Rank("unknown:x")
+
+	if !(ipfs > sha && sha > btih && btih > mid && mid > unknown) {
+		t.Fatalf("rank ordering broken: ipfs=%d sha=%d btih=%d mid=%d unknown=%d",
+			ipfs, sha, btih, mid, unknown)
+	}
+}
+
+func TestAlgorithmOf(t *testing.T) {
+	cases := map[string]string{
+		"ipfs:bafy":       "ipfs",
+		"sha256:bafk":     "sha256",
+		"midhash256:abc":  "midhash256",
+		"":               "",
+		"no-colon":        "",
+		":leading-colon":  "", // empty algo not allowed
+	}
+	for in, want := range cases {
+		if got := AlgorithmOf(in); got != want {
+			t.Errorf("AlgorithmOf(%q) = %q, want %q", in, got, want)
+		}
+	}
+}
+
+func TestToken(t *testing.T) {
+	if got := Token("sha256", "abc"); got != "sha256:abc" {
+		t.Errorf("Token(sha256, abc) = %q", got)
+	}
+	if got := Token("", "abc"); got != "" {
+		t.Errorf("Token with empty algo should return empty, got %q", got)
+	}
+	if got := Token("sha256", ""); got != "" {
+		t.Errorf("Token with empty value should return empty, got %q", got)
+	}
+}
+
+func TestBetter(t *testing.T) {
+	// IPFS beats sha256
+	if got := Better("ipfs:a", "sha256:b"); got != "ipfs:a" {
+		t.Errorf("Better(ipfs, sha256) = %q, want ipfs:a", got)
+	}
+	if got := Better("sha256:b", "ipfs:a"); got != "ipfs:a" {
+		t.Errorf("Better(sha256, ipfs) = %q, want ipfs:a (order shouldn't matter)", got)
+	}
+	// Tie → lexicographically smaller wins, deterministic
+	if got := Better("ipfs:b", "ipfs:a"); got != "ipfs:a" {
+		t.Errorf("Better(ipfs:b, ipfs:a) = %q, want ipfs:a", got)
+	}
+	if got := Better("ipfs:a", "ipfs:b"); got != "ipfs:a" {
+		t.Errorf("Better(ipfs:a, ipfs:b) = %q, want ipfs:a", got)
+	}
+}