Something went wrong. Try again.
Upload images to your PDS and get instant CDN URLs via images.blue forked from evan.jarrett.net/blup
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279package util
import ( "fmt" "strings" "testing")
// Real IPFS CIDs for testingvar validCIDs = []string{ "bafkreigns2g4c46vrdvj6wlv7jka2binxftkadssvv5mxakqz4vulbfroi", "bafkreigms7evfvvxtsb2azgx64wfqv3xt62elwwt5zjtv2dcgd4idu3erm", "bafkreieedz3pv6onkm5ombpwbx43ytwzff3qgzing5ym45xthlnvku2wha",}
func TestConvertCIDBase32ToBase62(t *testing.T) { tests := []struct { name string input string wantErr bool }{ { name: "valid IPFS CID 1", input: "bafkreigns2g4c46vrdvj6wlv7jka2binxftkadssvv5mxakqz4vulbfroi", wantErr: false, }, { name: "valid IPFS CID 2", input: "bafkreigms7evfvvxtsb2azgx64wfqv3xt62elwwt5zjtv2dcgd4idu3erm", wantErr: false, }, { name: "valid IPFS CID 3", input: "bafkreieedz3pv6onkm5ombpwbx43ytwzff3qgzing5ym45xthlnvku2wha", wantErr: false, }, { name: "empty string", input: "", wantErr: true, }, { name: "invalid characters", input: "invalid123!@#", wantErr: true, }, { name: "only prefix", input: "bafkrei", wantErr: true, }, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result, err := ConvertCIDBase32ToBase62(tt.input)
if tt.wantErr { if err == nil { t.Errorf("ConvertCIDBase32ToBase62() expected error but got %v", result) } return }
if err != nil { t.Errorf("ConvertCIDBase32ToBase62() unexpected error: %v", err) return }
if result == "" { t.Errorf("ConvertCIDBase32ToBase62() returned empty result") }
t.Logf("Converted %s to %s", tt.input, result) }) }}
func TestRoundTripConversionWithRealCIDs(t *testing.T) { for i, originalCID := range validCIDs { t.Run(fmt.Sprintf("real_cid_%d", i+1), func(t *testing.T) { // Convert to base62 base62Result, err := ConvertCIDBase32ToBase62(originalCID) if err != nil { t.Fatalf("Failed to convert to base62: %v", err) }
t.Logf("Original CID: %s", originalCID) t.Logf("Base62: %s", base62Result) t.Logf("Length reduction: %d -> %d chars (%.1f%% reduction)", len(originalCID), len(base62Result), float64(len(originalCID)-len(base62Result))/float64(len(originalCID))*100)
// Convert back to base32 base32Result, err := ConvertCIDBase62ToBase32(base62Result) if err != nil { t.Fatalf("Failed to convert back to base32: %v", err) }
t.Logf("Restored: %s", base32Result)
// Compare (case insensitive since base32 can be uppercase/lowercase) if !strings.EqualFold(originalCID, base32Result) { t.Errorf("Round trip failed:\nOriginal: %s\nBase62: %s\nRestored: %s", originalCID, base62Result, base32Result) } }) }}
func TestIsBase32WithRealCIDs(t *testing.T) { tests := []struct { name string input string expected bool }{ { name: "real CID 1", input: "bafkreigns2g4c46vrdvj6wlv7jka2binxftkadssvv5mxakqz4vulbfroi", expected: true, }, { name: "real CID 2", input: "bafkreigms7evfvvxtsb2azgx64wfqv3xt62elwwt5zjtv2dcgd4idu3erm", expected: true, }, { name: "real CID 3", input: "bafkreieedz3pv6onkm5ombpwbx43ytwzff3qgzing5ym45xthlnvku2wha", expected: true, }, { name: "real CID uppercase", input: strings.ToUpper("bafkreigns2g4c46vrdvj6wlv7jka2binxftkadssvv5mxakqz4vulbfroi"), expected: true, }, { name: "empty string", input: "", expected: false, }, { name: "invalid characters", input: "bafkrei123invalid!@#", expected: false, }, { name: "contains 0 and 1 (invalid in base32)", input: "bafkrei01234567890", expected: false, }, { name: "contains 8 and 9 (invalid in base32)", input: "bafkrei89abcdef", expected: false, }, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { result := IsBase32(tt.input) if result != tt.expected { t.Errorf("IsBase32(%q) = %v, expected %v", tt.input, result, tt.expected) } }) }}
func TestCompressionRatio(t *testing.T) { t.Log("Testing compression ratios with real CIDs:")
var totalOriginalLength, totalBase62Length int
for i, cid := range validCIDs { base62, err := ConvertCIDBase32ToBase62(cid) if err != nil { t.Fatalf("Failed to convert CID %d: %v", i+1, err) }
originalLen := len(cid) base62Len := len(base62) reduction := float64(originalLen-base62Len) / float64(originalLen) * 100
totalOriginalLength += originalLen totalBase62Length += base62Len
t.Logf("CID %d: %d -> %d chars (%.1f%% reduction)", i+1, originalLen, base62Len, reduction) }
overallReduction := float64(totalOriginalLength-totalBase62Length) / float64(totalOriginalLength) * 100 t.Logf("Overall: %d -> %d chars (%.1f%% reduction)", totalOriginalLength, totalBase62Length, overallReduction)}
func TestSpecificCIDConversions(t *testing.T) { // Test each CID individually with detailed logging testCases := []struct { name string cid string }{ {"CID with 'igns2g4c'", "bafkreigns2g4c46vrdvj6wlv7jka2binxftkadssvv5mxakqz4vulbfroi"}, {"CID with 'igms7evf'", "bafkreigms7evfvvxtsb2azgx64wfqv3xt62elwwt5zjtv2dcgd4idu3erm"}, {"CID with 'ieedz3pv'", "bafkreieedz3pv6onkm5ombpwbx43ytwzff3qgzing5ym45xthlnvku2wha"}, }
for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { // Test IsBase32 if !IsBase32(tc.cid) { t.Errorf("IsBase32 failed for %s", tc.cid) }
// Test conversion to base62 base62, err := ConvertCIDBase32ToBase62(tc.cid) if err != nil { t.Fatalf("ConvertCIDBase32ToBase62 failed: %v", err) }
// Test conversion back to base32 restored, err := ConvertCIDBase62ToBase32(base62) if err != nil { t.Fatalf("ConvertCIDBase62ToBase32 failed: %v", err) }
// Verify round trip if !strings.EqualFold(tc.cid, restored) { t.Errorf("Round trip failed for %s", tc.cid) t.Errorf(" Original: %s", tc.cid) t.Errorf(" Base62: %s", base62) t.Errorf(" Restored: %s", restored) } else { t.Logf("✓ Round trip successful") t.Logf(" Original: %s", tc.cid) t.Logf(" Base62: %s", base62) t.Logf(" Restored: %s", restored) } }) }}
// Benchmark with real CIDsfunc BenchmarkConvertRealCIDBase32ToBase62(b *testing.B) { cid := validCIDs[0] // Use first real CID
b.ResetTimer() for i := 0; i < b.N; i++ { _, err := ConvertCIDBase32ToBase62(cid) if err != nil { b.Fatal(err) } }}
func BenchmarkConvertRealCIDBase62ToBase32(b *testing.B) { // Convert real CID to base62 first base62CID, err := ConvertCIDBase32ToBase62(validCIDs[0]) if err != nil { b.Fatal(err) }
b.ResetTimer() for i := 0; i < b.N; i++ { _, err := ConvertCIDBase62ToBase32(base62CID) if err != nil { b.Fatal(err) } }}
func BenchmarkIsBase32RealCID(b *testing.B) { cid := validCIDs[0]
b.ResetTimer() for i := 0; i < b.N; i++ { IsBase32(cid) }}