package schema import ( "testing" "time" "archer/internal/row" ) func TestBucketOfDateTime(t *testing.T) { spec := &ShardSpec{Column: "created_at", Kind: ShardDateTime} loc := time.UTC cases := []struct { raw []byte want string }{ {[]byte("2025-06-01 13:45:00"), "2025-06-01"}, {[]byte("2025-12-31 00:00:00"), "2025-12-31"}, } for _, c := range cases { got, err := BucketOf(row.Value{Raw: c.raw}, spec, loc, "", row.KeyOf("1")) if err != nil || got != c.want { t.Fatalf("%s: got %q err %v want %q", c.raw, got, err, c.want) } } } func TestBucketOfNull(t *testing.T) { spec := &ShardSpec{Column: "c", Kind: ShardDateTime} got, err := BucketOf(row.Value{}, spec, time.UTC, "", row.KeyOf("1")) if err != nil || got != "_null" { t.Fatalf("got %q err %v", got, err) } } func TestBucketOfZeroDate(t *testing.T) { spec := &ShardSpec{Column: "c", Kind: ShardDateTime} if _, err := BucketOf(row.Value{Raw: []byte("0000-00-00 00:00:00")}, spec, time.UTC, "", row.KeyOf("7")); err == nil { t.Fatal("expected zero-date error") } got, err := BucketOf(row.Value{Raw: []byte("0000-00-00 00:00:00")}, spec, time.UTC, "bucket", row.KeyOf("7")) if err != nil || got != "0000-00-00" { t.Fatalf("got %q err %v", got, err) } } func TestBucketOfEpoch(t *testing.T) { loc, err := time.LoadLocation("UTC") if err != nil { t.Fatal(err) } for _, tc := range []struct { unit int64 raw string want string }{ {1, "1717200000", "2024-06-01"}, {1_000, "1717200000000", "2024-06-01"}, {1_000_000, "1717200000000000", "2024-06-01"}, } { spec := &ShardSpec{Column: "ts", Kind: ShardEpoch, Unit: tc.unit} got, err := BucketOf(row.Value{Raw: []byte(tc.raw)}, spec, loc, "", row.KeyOf("1")) if err != nil || got != tc.want { t.Fatalf("unit %d: got %q err %v want %q", tc.unit, got, err, tc.want) } } } func TestBucketLess(t *testing.T) { order := []string{"_null", "0000-00-00", "2024-01-01", "2024-01-02", "2025-01-01"} for i := 0; i+1 < len(order); i++ { if !BucketLess(order[i], order[i+1]) { t.Fatalf("expected %q < %q", order[i], order[i+1]) } if BucketLess(order[i+1], order[i]) { t.Fatalf("expected %q not < %q", order[i+1], order[i]) } } } func TestParseEpochUnit(t *testing.T) { cases := map[string]int64{ "epoch-seconds": 1, "seconds": 1, "epoch-milliseconds": 1_000, "ms": 1_000, "epoch-microseconds": 1_000_000, "us": 1_000_000, } for in, want := range cases { got, err := ParseEpochUnit(in) if err != nil || got != want { t.Fatalf("%s: got %d err %v want %d", in, got, err, want) } } if _, err := ParseEpochUnit(""); err == nil { t.Fatal("empty unit should error") } } func TestEpochRoundTrip(t *testing.T) { loc := time.UTC for _, unit := range []int64{1, 1_000, 1_000_000} { now := time.Date(2024, 6, 1, 12, 30, 15, 0, loc) v := TimeToEpoch(now, unit) back := EpochTime(v, unit, loc) if !back.Equal(now) { t.Fatalf("unit %d: got %s want %s", unit, back, now) } } }