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>
112 lines
3.0 KiB
Go
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)
|
|
}
|
|
}
|
|
}
|