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>
123 lines
3.8 KiB
Go
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")
|
|
}
|
|
}
|