forked from wrenn/wrenn
pptx704
75b28ed899
Introduces internal/layout package for centralized path construction,
migrates templates from name-based TEXT primary keys to UUID PKs with
team-scoped directories (WRENN_DIR/images/teams/{team_id}/{template_id}).
The built-in minimal template uses sentinel zero UUIDs. Proto messages
carry team_id + template_id alongside deprecated template name field.
Team deletion now cleans up template files across all hosts.
119 lines
2.8 KiB
Go
119 lines
2.8 KiB
Go
package id
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
func TestBase36RoundTrip(t *testing.T) {
|
|
for i := 0; i < 1000; i++ {
|
|
orig := uuid.New()
|
|
encoded := UUIDToBase36(orig)
|
|
|
|
if len(encoded) != base36IDLen {
|
|
t.Fatalf("expected %d chars, got %d: %s", base36IDLen, len(encoded), encoded)
|
|
}
|
|
|
|
decoded, err := base36ToUUID(encoded)
|
|
if err != nil {
|
|
t.Fatalf("decode failed: %v", err)
|
|
}
|
|
|
|
if decoded != orig {
|
|
t.Fatalf("round-trip failed: %v → %s → %v", orig, encoded, decoded)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestBase36ZeroUUID(t *testing.T) {
|
|
var zero [16]byte
|
|
encoded := UUIDToBase36(zero)
|
|
if encoded != "0000000000000000000000000" {
|
|
t.Fatalf("zero UUID should encode to all zeros, got %s", encoded)
|
|
}
|
|
decoded, err := base36ToUUID(encoded)
|
|
if err != nil {
|
|
t.Fatalf("decode failed: %v", err)
|
|
}
|
|
if decoded != zero {
|
|
t.Fatalf("round-trip failed for zero UUID")
|
|
}
|
|
}
|
|
|
|
func TestFormatParseRoundTrip(t *testing.T) {
|
|
id := NewSandboxID()
|
|
formatted := FormatSandboxID(id)
|
|
|
|
if formatted[:3] != "sb-" {
|
|
t.Fatalf("expected sb- prefix, got %s", formatted)
|
|
}
|
|
if len(formatted) != 3+base36IDLen {
|
|
t.Fatalf("expected %d chars total, got %d: %s", 3+base36IDLen, len(formatted), formatted)
|
|
}
|
|
|
|
parsed, err := ParseSandboxID(formatted)
|
|
if err != nil {
|
|
t.Fatalf("parse failed: %v", err)
|
|
}
|
|
if parsed != id {
|
|
t.Fatalf("round-trip failed: %v → %s → %v", id, formatted, parsed)
|
|
}
|
|
}
|
|
|
|
func TestBase36InvalidInput(t *testing.T) {
|
|
// Wrong length.
|
|
if _, err := base36ToUUID("abc"); err == nil {
|
|
t.Fatal("expected error for short input")
|
|
}
|
|
// Invalid character.
|
|
if _, err := base36ToUUID("000000000000000000000000!"); err == nil {
|
|
t.Fatal("expected error for invalid character")
|
|
}
|
|
}
|
|
|
|
func TestPlatformTeamIDFormats(t *testing.T) {
|
|
formatted := FormatTeamID(PlatformTeamID)
|
|
parsed, err := ParseTeamID(formatted)
|
|
if err != nil {
|
|
t.Fatalf("parse failed: %v", err)
|
|
}
|
|
if parsed != PlatformTeamID {
|
|
t.Fatalf("platform team ID round-trip failed")
|
|
}
|
|
}
|
|
|
|
func TestMaxUUID(t *testing.T) {
|
|
max := [16]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}
|
|
encoded := UUIDToBase36(max)
|
|
if len(encoded) != base36IDLen {
|
|
t.Fatalf("max UUID encoding wrong length: %d", len(encoded))
|
|
}
|
|
decoded, err := base36ToUUID(encoded)
|
|
if err != nil {
|
|
t.Fatalf("decode failed: %v", err)
|
|
}
|
|
if decoded != max {
|
|
t.Fatalf("round-trip failed for max UUID")
|
|
}
|
|
}
|
|
|
|
func BenchmarkFormatSandboxID(b *testing.B) {
|
|
id := pgtype.UUID{Bytes: uuid.New(), Valid: true}
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
FormatSandboxID(id)
|
|
}
|
|
}
|
|
|
|
func BenchmarkParseSandboxID(b *testing.B) {
|
|
id := pgtype.UUID{Bytes: uuid.New(), Valid: true}
|
|
s := FormatSandboxID(id)
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
ParseSandboxID(s)
|
|
}
|
|
}
|