Files
archer/internal/schema/date_test.go
T
voidandClaude Sonnet 4.6 bc4a6b504f Initial commit: archer, a Go-native MySQL/MariaDB table archiver
Renamed from arcdb: module path, cmd/archer, internal/archererr,
docs, build scripts and ARCHER_* environment variables.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-11-06 22:12:17 +08:00

112 lines
3.0 KiB
Go

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)
}
}
}