Files
archer/internal/cli/import_test.go
T
voidandClaude Sonnet 4.6 366d61ca25 Add archer import and allow date-mode bulk delete
archer import replays a sealed archive into an existing table: shard
selection (`--select`), SHA-256 pre-verification, idempotent modes
(`ignore`/`insert`/`replace`), and both LOAD DATA and batched-INSERT
engines. It reads manifest.jsonl strictly so corruption is reported
instead of skipped, and supports --dry-run, --allow-partial, and
per-shard workers.

--bulk-delete no longer rejects --shard-by date. Range deletion now
derives its bounds from the chunk's actual keys (date scanners rewrite
LastKey into a resumption cursor) and keeps safe-auto-increment
semantics by excluding the current max key. A startup warning documents
the monotonic-shard-column assumption.

Also splits CLI/format/sharding/progress/safety reference docs out of
the README, and adds the corresponding OpenSpec change artifacts.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-11-08 21:14:23 +08:00

123 lines
3.8 KiB
Go

package cli
import (
"bytes"
"strings"
"testing"
)
func importArgs(extra ...string) []string {
args := []string{"--file", "archive", "--dest", "u:p@tcp(127.0.0.1:3306)/db"}
return append(args, extra...)
}
func parseImport(t *testing.T, args ...string) *ImportConfig {
t.Helper()
c, err := ParseImport(args, &bytes.Buffer{})
if err != nil {
t.Fatalf("parse %v: %v", args, err)
}
return c
}
func TestImportDefaults(t *testing.T) {
c := parseImport(t, importArgs()...)
if err := c.Validate(); err != nil {
t.Fatal(err)
}
if c.Mode != "ignore" || c.Engine != "load" || c.Verify != "pre" || c.Workers != 1 {
t.Fatalf("bad defaults: %+v", c)
}
if c.Charset != "utf8mb4" || c.Progress.Mode != ProgressAuto {
t.Fatalf("bad defaults: %+v", c)
}
if len(c.Selectors) != 1 || c.Selectors[0].Kind != "all" {
t.Fatalf("default selector = %+v", c.Selectors)
}
}
func TestImportRequired(t *testing.T) {
c := parseImport(t, "--dest", "u:p@tcp(h:3306)/db")
if err := c.Validate(); err == nil || !strings.Contains(err.Error(), "--file") {
t.Fatalf("got %v", err)
}
c = parseImport(t, "--file", "archive")
if err := c.Validate(); err == nil || !strings.Contains(err.Error(), "--dest") {
t.Fatalf("got %v", err)
}
c = parseImport(t, "--file", "archive", "--dest", "u:p@tcp(h:3306)/")
if err := c.Validate(); err == nil || !strings.Contains(err.Error(), "database name") {
t.Fatalf("got %v", err)
}
}
func TestImportRejectsExportFlags(t *testing.T) {
for _, arg := range []string{"--source", "--where", "--purge", "--table", "--format", "--replace"} {
_, err := ParseImport(append(importArgs(), arg, "x"), &bytes.Buffer{})
if err == nil {
t.Fatalf("%s: expected an error", arg)
}
if !strings.Contains(err.Error(), "archive (export) mode") {
t.Fatalf("%s: got %v", arg, err)
}
}
}
func TestImportRejectsUnknownFlag(t *testing.T) {
if _, err := ParseImport(append(importArgs(), "--bogus", "1"), &bytes.Buffer{}); err == nil {
t.Fatal("expected unknown flag error")
}
}
func TestImportInvalidValues(t *testing.T) {
cases := []struct {
extra []string
want string
}{
{[]string{"--mode", "merge"}, "--mode"},
{[]string{"--engine", "bulk"}, "--engine"},
{[]string{"--verify", "after"}, "--verify"},
{[]string{"--workers", "0"}, "--workers"},
{[]string{"--charset", "utf8; drop"}, "--charset"},
{[]string{"--select", "seq:5-2"}, "--select"},
{[]string{"--select", "date:2025-01-31..2025-01-01"}, "--select"},
{[]string{"--select", "bogus:1"}, "--select"},
}
for _, tc := range cases {
c := parseImport(t, importArgs(tc.extra...)...)
if err := c.Validate(); err == nil || !strings.Contains(err.Error(), tc.want) {
t.Fatalf("%v: got %v", tc.extra, err)
}
}
}
func TestImportMappingConflict(t *testing.T) {
c := parseImport(t, importArgs("--columns", "id,title", "--assume-all-columns")...)
if err := c.Validate(); err == nil || !strings.Contains(err.Error(), "mutually exclusive") {
t.Fatalf("got %v", err)
}
}
func TestImportSelectAllCannotCombine(t *testing.T) {
c := parseImport(t, importArgs("--select", "all", "--select", "seq:1-2")...)
if err := c.Validate(); err == nil || !strings.Contains(err.Error(), "cannot be combined") {
t.Fatalf("got %v", err)
}
}
func TestImportRepeatedSelect(t *testing.T) {
c := parseImport(t, importArgs("--select", "seq:1-2", "--select", "pk:10-20", "--select", "date:2025-01-01..2025-01-02")...)
if err := c.Validate(); err != nil {
t.Fatal(err)
}
if len(c.Selectors) != 3 || c.Selectors[0].Kind != "seq" || c.Selectors[1].Kind != "pk" || c.Selectors[2].Kind != "date" {
t.Fatalf("selectors = %+v", c.Selectors)
}
}
func TestImportUnexpectedPositional(t *testing.T) {
if _, err := ParseImport(append(importArgs(), "stray"), &bytes.Buffer{}); err == nil {
t.Fatal("expected an error for a positional argument")
}
}