86 lines
2.3 KiB
Go
86 lines
2.3 KiB
Go
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)
|
|
}
|
|
}
|