525 lines
15 KiB
Go
525 lines
15 KiB
Go
// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package interpres
|
|
|
|
import (
|
|
"net"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type targetNested struct {
|
|
X int `toml:"x"`
|
|
Y string `toml:"y"`
|
|
}
|
|
|
|
type targetCfg struct {
|
|
Num int `toml:"num"`
|
|
Small uint8 `toml:"small"`
|
|
Tags []string `toml:"tags"`
|
|
Lims map[string]any `toml:"lims"`
|
|
Tab targetNested `toml:"tab"`
|
|
Arr []targetNested `toml:"arr"`
|
|
Other string `toml:"other"`
|
|
}
|
|
|
|
// TestTargetedStrictFindings pins the strict findings of the targeted parse
|
|
// to the tree decode's own texts, paths included. Every case here was first
|
|
// surfaced by FuzzTargetedDecode.
|
|
func TestTargetedStrictFindings(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
doc string
|
|
want string
|
|
}{
|
|
{
|
|
name: "unknown key in a header table",
|
|
doc: "[tab]\nother = \"o\"\n",
|
|
want: `interpres: tab: unknown field "other" for interpres.targetNested`,
|
|
},
|
|
{
|
|
name: "unknown nested header without the parent header",
|
|
doc: "[tab.nested]\nx = 1\n",
|
|
want: `interpres: tab: unknown field "nested" for interpres.targetNested`,
|
|
},
|
|
{
|
|
name: "unknown key in an array-of-tables element",
|
|
doc: "[[arr]]\nother = \"o\"\n",
|
|
want: `interpres: arr[0]: unknown field "other" for interpres.targetNested`,
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
var cfg targetCfg
|
|
err := Unmarshal([]byte(tt.doc), &cfg, RejectUnknownFields(true))
|
|
if err == nil {
|
|
t.Fatalf("no error, want %q", tt.want)
|
|
}
|
|
if err.Error() != tt.want {
|
|
t.Errorf("message = %q, want %q", err.Error(), tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestTargetedParseErrors pins the parse-stage errors the targeted skeleton
|
|
// raises, whose texts and lines are the tree parser's own.
|
|
func TestTargetedParseErrors(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
doc string
|
|
want string
|
|
}{
|
|
{
|
|
name: "header on an assigned scalar",
|
|
doc: "zz = 1\n[zz]\nx = 4\n",
|
|
want: "interpres: line 2: key \"zz\" is not a table",
|
|
},
|
|
{
|
|
name: "dotted key on an assigned scalar",
|
|
doc: "zz = 1\nzz.x = 2\n",
|
|
want: "interpres: line 2: key \"zz\" is not a table",
|
|
},
|
|
{
|
|
name: "duplicate unknown keys",
|
|
doc: "zz = 1\nzz = 2\n",
|
|
want: "interpres: line 2: duplicate key \"zz\"",
|
|
},
|
|
{
|
|
name: "duplicate inside an unknown table",
|
|
doc: "[zz]\nk = 1\nk = 2\n",
|
|
want: "interpres: line 3: duplicate key \"k\"",
|
|
},
|
|
{
|
|
name: "duplicate across a sink's dotted keys",
|
|
doc: "[zz]\na.b = 1\na.b = 2\n",
|
|
want: "interpres: line 3: duplicate key \"b\"",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
var cfg targetCfg
|
|
err := Unmarshal([]byte(tt.doc), &cfg)
|
|
if err == nil {
|
|
t.Fatalf("no error, want %q", tt.want)
|
|
}
|
|
if err.Error() != tt.want {
|
|
t.Errorf("message = %q, want %q", err.Error(), tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestTargetedSilentShapes covers the documents the targeted parse accepts
|
|
// with the values the tree decode gives.
|
|
func TestTargetedSilentShapes(t *testing.T) {
|
|
t.Run("dotted key after an unknown nested header", func(t *testing.T) {
|
|
// [tab.nested] is unknown and sinks; tab.x then lands in tab, and the
|
|
// sink's own x is a different key, the tree's shape exactly.
|
|
var cfg, ref targetCfg
|
|
in := []byte("[tab]\nx = 1\n[tab.nested]\n")
|
|
if err := Unmarshal(in, &cfg); err != nil {
|
|
t.Fatalf("decode: %v", err)
|
|
}
|
|
if err := treeDecodeInto(in, &ref); err != nil {
|
|
t.Fatalf("reference: %v", err)
|
|
}
|
|
if !reflect.DeepEqual(cfg, ref) {
|
|
t.Errorf("values disagree: targeted %+v, tree %+v", cfg, ref)
|
|
}
|
|
if cfg.Tab.X != 1 {
|
|
t.Errorf("tab.x = %d, want 1", cfg.Tab.X)
|
|
}
|
|
})
|
|
t.Run("unknown keys are ignored without strict", func(t *testing.T) {
|
|
var cfg, ref targetCfg
|
|
in := []byte("num = 5\nz1 = 1\n[zz]\nk = 1\n")
|
|
if err := Unmarshal(in, &cfg); err != nil {
|
|
t.Fatalf("decode: %v", err)
|
|
}
|
|
if err := treeDecodeInto(in, &ref); err != nil {
|
|
t.Fatalf("reference: %v", err)
|
|
}
|
|
if !reflect.DeepEqual(cfg, ref) {
|
|
t.Errorf("values disagree: targeted %+v, tree %+v", cfg, ref)
|
|
}
|
|
if cfg.Num != 5 {
|
|
t.Errorf("num = %d, want 5", cfg.Num)
|
|
}
|
|
})
|
|
t.Run("an inline table into a map field", func(t *testing.T) {
|
|
var cfg targetCfg
|
|
in := []byte("lims = { cpu = 4, deep = { a = true } }\n")
|
|
if err := Unmarshal(in, &cfg); err != nil {
|
|
t.Fatalf("decode: %v", err)
|
|
}
|
|
if cfg.Lims["cpu"] != int64(4) {
|
|
t.Errorf("lims = %v", cfg.Lims)
|
|
}
|
|
})
|
|
t.Run("an overflow falls back to the decode error", func(t *testing.T) {
|
|
var cfg targetCfg
|
|
err := Unmarshal([]byte("small = 300\n"), &cfg)
|
|
want := "interpres: small: integer 300 overflows uint8"
|
|
if err == nil || err.Error() != want {
|
|
t.Errorf("err = %v, want %q", err, want)
|
|
}
|
|
})
|
|
t.Run("too many array-of-tables elements falls back", func(t *testing.T) {
|
|
type Item struct {
|
|
N int `toml:"n"`
|
|
}
|
|
var cfg struct {
|
|
Items [2]Item `toml:"items"`
|
|
}
|
|
err := Unmarshal([]byte("[[items]]\nn = 1\n[[items]]\nn = 2\n[[items]]\nn = 3\n"), &cfg)
|
|
want := "interpres: items: cannot assign 3 elements to [2]interpres.Item"
|
|
if err == nil || err.Error() != want {
|
|
t.Errorf("err = %v, want %q", err, want)
|
|
}
|
|
})
|
|
t.Run("a UseNumber tree keeps literals in the targeted path", func(t *testing.T) {
|
|
var cfg struct {
|
|
Rate Number `toml:"rate"`
|
|
}
|
|
if err := Unmarshal([]byte("rate = 1_000\n"), &cfg, NumbersAsLiterals(true)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Rate != "1_000" {
|
|
t.Errorf("rate = %q, want 1_000", cfg.Rate)
|
|
}
|
|
})
|
|
t.Run("dotted keys fill a map field", func(t *testing.T) {
|
|
var cfg targetCfg
|
|
in := []byte("lims.a.b = true\nlims.c = 3\n")
|
|
if err := Unmarshal(in, &cfg); err != nil {
|
|
t.Fatalf("decode: %v", err)
|
|
}
|
|
if cfg.Lims["c"] != int64(3) {
|
|
t.Errorf("lims = %v", cfg.Lims)
|
|
}
|
|
})
|
|
t.Run("an inline table cannot be extended", func(t *testing.T) {
|
|
var cfg targetCfg
|
|
in := []byte("lims = { a = 1 }\n[lims.deep]\nb = 2\n")
|
|
err := Unmarshal(in, &cfg)
|
|
if err == nil || !strings.Contains(err.Error(), "cannot extend inline table") {
|
|
t.Errorf("err = %v, want the inline-table extension error", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestTargetedShapesMatrix walks a document per destination shape, both
|
|
// through the targeted path and the tree reference, so the two agree on
|
|
// every branch the skeleton carries.
|
|
func TestTargetedShapesMatrix(t *testing.T) {
|
|
docs := []string{
|
|
// Scalars of every kind, arrays, maps, tables, arrays of tables.
|
|
"num = 7\nflt = 1.25\nstr = \"s\"\nflag = false\nsmall = 9\ntags = [\"a\"]\nlims = { a = 1 }\n\n[tab]\nx = 1\ny = \"t\"\n\n[[arr]]\nx = 2\ny = \"u\"\n\n[[arr]]\nx = 3\ny = \"v\"\n",
|
|
// Dotted keys through nested tables and maps.
|
|
"tab.x = 1\ntab.y = \"s\"\nlims.a.b = true\nlims.c = 3\nnum = 2\n",
|
|
// Inline tables nested in arrays, mixed value arrays.
|
|
"lims = { a = { b = 1 } }\ntags = []\nother = \"o\"\n",
|
|
// A sub-table of an array of tables, then a second element.
|
|
"[[arr]]\nx = 1\n[arr.nested]\ny = \"n\"\n[[arr]]\ny = \"m\"\n",
|
|
// Negative and signed numbers, exponents, radix forms into floats.
|
|
"flt = -3.5e2\nnum = -42\nflt = +1.0\n",
|
|
// A quoted key and a defined-string-shaped value.
|
|
"\"quoted key\" = 1\nstr = \"multi\"\n",
|
|
}
|
|
for i, doc := range docs {
|
|
var ref, tgt targetCfg
|
|
refErr := treeDecodeInto([]byte(doc), &ref)
|
|
tgtErr := Unmarshal([]byte(doc), &tgt)
|
|
if (refErr == nil) != (tgtErr == nil) {
|
|
t.Errorf("doc %d: error presence disagrees: tree %v, targeted %v", i, refErr, tgtErr)
|
|
continue
|
|
}
|
|
if refErr != nil {
|
|
continue
|
|
}
|
|
if !reflect.DeepEqual(ref, tgt) {
|
|
t.Errorf("doc %d: values disagree:\ntree: %#v\ntargeted: %#v", i, ref, tgt)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestTargetedFallbackContracts pins the documents that must fall back and
|
|
// produce the tree decode's exact error.
|
|
func TestTargetedFallbackContracts(t *testing.T) {
|
|
type Item struct {
|
|
N int `toml:"n"`
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
doc string
|
|
want string
|
|
}{
|
|
{
|
|
name: "uint8 overflow",
|
|
doc: "small = 300\n",
|
|
want: "interpres: small: integer 300 overflows uint8",
|
|
},
|
|
{
|
|
name: "negative into uint",
|
|
doc: "small = -1\n",
|
|
want: "interpres: small: cannot assign negative -1 to uint8",
|
|
},
|
|
{
|
|
name: "a table into a scalar",
|
|
doc: "num = { a = 1 }\n",
|
|
want: "interpres: num: cannot assign table to int",
|
|
},
|
|
{
|
|
name: "an integer into a string field",
|
|
doc: "other = 5\n",
|
|
want: "interpres: other: cannot assign integer to string",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
var cfg targetCfg
|
|
err := Unmarshal([]byte(tt.doc), &cfg)
|
|
if err == nil || err.Error() != tt.want {
|
|
t.Errorf("err = %v, want %q", err, tt.want)
|
|
}
|
|
})
|
|
}
|
|
_ = Item{}
|
|
}
|
|
|
|
// TestTargetedHeaderOnAssignedScalar pins the parse error a header raises
|
|
// when the key already holds a scalar, before any fallback can happen.
|
|
func TestTargetedHeaderOnAssignedScalarArray(t *testing.T) {
|
|
var cfg targetCfg
|
|
in := []byte("arr = []\n[[arr]]\nx = 1\n")
|
|
err := Unmarshal(in, &cfg)
|
|
want := "interpres: line 2: key \"arr\" is not an array of tables"
|
|
if err == nil || err.Error() != want {
|
|
t.Errorf("err = %v, want %q", err, want)
|
|
}
|
|
}
|
|
|
|
// TestTargetedBranchParity walks the fallback branches of the targeted
|
|
// skeleton: every document here takes the tree path on a rerun, and must
|
|
// carry the tree decode's exact error text.
|
|
func TestTargetedBranchParity(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
doc string
|
|
want string
|
|
}{
|
|
{
|
|
name: "a header over a value array",
|
|
doc: "tags = [\"x\"]\n[tags]\na = 1\n",
|
|
want: "interpres: line 2: key \"tags\" is not a table",
|
|
},
|
|
{
|
|
name: "an array header over a value array",
|
|
doc: "tags = [\"x\"]\n[[tags]]\na = 1\n",
|
|
want: "interpres: line 2: key \"tags\" is not an array of tables",
|
|
},
|
|
{
|
|
name: "an array header over a datetime field",
|
|
doc: "when = 1979-05-27T07:32:00Z\n[[when]]\nx = 1\n",
|
|
want: "interpres: line 2: key \"when\" is not an array of tables",
|
|
},
|
|
{
|
|
name: "a boolean into a string field",
|
|
doc: "other = true\n",
|
|
want: "interpres: other: cannot assign bool to string",
|
|
},
|
|
{
|
|
name: "a leading-zero integer",
|
|
doc: "num = 01\n",
|
|
want: "interpres: line 1: leading zeros are not allowed in numbers",
|
|
},
|
|
{
|
|
name: "an int64-overflowing integer",
|
|
doc: "num = 99999999999999999999\n",
|
|
want: "interpres: line 1: integer \"99999999999999999999\" out of range",
|
|
},
|
|
{
|
|
name: "a malformed boolean",
|
|
doc: "flag = tru\n",
|
|
want: "interpres: line 1: invalid value",
|
|
},
|
|
{
|
|
name: "a negative number into an unsigned field",
|
|
doc: "small = -5\n",
|
|
want: "interpres: small: cannot assign negative -5 to uint8",
|
|
},
|
|
{
|
|
name: "an integer into a string field via the generic path",
|
|
doc: "other = 5\n",
|
|
want: "interpres: other: cannot assign integer to string",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
var cfg targetCfg
|
|
err := Unmarshal([]byte(tt.doc), &cfg, RejectUnknownFields(true))
|
|
if tt.want == "" {
|
|
if err != nil {
|
|
t.Fatalf("err = %v, want nil", err)
|
|
}
|
|
return
|
|
}
|
|
if err == nil || err.Error() != tt.want {
|
|
t.Errorf("err = %v, want %q", err, tt.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestTargetedDecodeHookFields keeps the custom decode hooks of scalar-typed
|
|
// fields working in the targeted path.
|
|
func TestTargetedDecodeHookFields(t *testing.T) {
|
|
type Cfg struct {
|
|
IP net.IP `toml:"ip"`
|
|
Dur time.Duration `toml:"dur"`
|
|
Unm *scalarUnmarshaler `toml:"unm"`
|
|
}
|
|
var cfg Cfg
|
|
in := []byte("ip = \"192.0.2.1\"\ndur = \"1h30m\"\nunm = \"hello\"\n")
|
|
if err := Unmarshal(in, &cfg); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.IP.String() != "192.0.2.1" {
|
|
t.Errorf("ip = %v", cfg.IP)
|
|
}
|
|
if cfg.Dur != 90*time.Minute {
|
|
t.Errorf("dur = %v", cfg.Dur)
|
|
}
|
|
if cfg.Unm == nil || cfg.Unm.val != "hello" {
|
|
t.Errorf("unm = %+v", cfg.Unm)
|
|
}
|
|
}
|
|
|
|
// TestTargetedOddShapes pins the fallback and value shapes the matrix does
|
|
// not reach: space-separated date-times, non-string map keys and repeated
|
|
// dotted map keys.
|
|
func TestTargetedOddShapes(t *testing.T) {
|
|
t.Run("a space-separated date-time", func(t *testing.T) {
|
|
type Cfg struct {
|
|
When time.Time `toml:"when"`
|
|
}
|
|
var cfg, ref Cfg
|
|
doc := []byte("when = 1979-05-27 07:32:00Z\n")
|
|
if err := Unmarshal(doc, &cfg); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := treeDecodeInto(doc, &ref); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !cfg.When.Equal(ref.When) {
|
|
t.Errorf("when = %v, want %v", cfg.When, ref.When)
|
|
}
|
|
})
|
|
t.Run("a map with a non-string key falls back", func(t *testing.T) {
|
|
type Cfg struct {
|
|
M map[int]string `toml:"m"`
|
|
}
|
|
var cfg, ref Cfg
|
|
doc := []byte("m = { a = 1 }\n")
|
|
err := Unmarshal(doc, &cfg)
|
|
refErr := treeDecodeInto(doc, &ref)
|
|
if err == nil || refErr == nil {
|
|
t.Fatalf("err = %v, refErr = %v, want both to fail", err, refErr)
|
|
}
|
|
if err.Error() != refErr.Error() {
|
|
t.Errorf("errors disagree: targeted %q, tree %q", err, refErr)
|
|
}
|
|
})
|
|
t.Run("a repeated dotted map key is a duplicate", func(t *testing.T) {
|
|
var cfg targetCfg
|
|
doc := []byte("lims.a.b = 1\nlims.a.b = 2\n")
|
|
err := Unmarshal(doc, &cfg)
|
|
want := "interpres: line 2: duplicate key \"b\""
|
|
if err == nil || err.Error() != want {
|
|
t.Errorf("err = %v, want %q", err, want)
|
|
}
|
|
})
|
|
t.Run("an underscored integer takes the token path", func(t *testing.T) {
|
|
var cfg targetCfg
|
|
doc := []byte("num = 1_000\n")
|
|
if err := Unmarshal(doc, &cfg); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Num != 1000 {
|
|
t.Errorf("num = %d, want 1000", cfg.Num)
|
|
}
|
|
})
|
|
t.Run("an 18-digit integer takes the fast path", func(t *testing.T) {
|
|
var cfg struct {
|
|
Big int64 `toml:"big"`
|
|
}
|
|
doc := []byte("big = 999999999999999999\n")
|
|
if err := Unmarshal(doc, &cfg); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.Big != 999999999999999999 {
|
|
t.Errorf("big = %d", cfg.Big)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestTargetedMapTableShapes covers the map-entry branches of the targeted
|
|
// skeleton: entries that become tables, entries that refuse them, and the
|
|
// duplicate checks across them.
|
|
func TestTargetedMapTableShapes(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
doc string
|
|
want string
|
|
}{
|
|
{
|
|
name: "a header opens a map entry table",
|
|
doc: "lims.c = 1\n[lims.d]\nk = 1\n",
|
|
want: "",
|
|
},
|
|
{
|
|
name: "a header over an assigned map entry",
|
|
doc: "lims.a = 1\n[lims.a]\nk = 1\n",
|
|
want: "interpres: line 2: key \"a\" is not a table",
|
|
},
|
|
{
|
|
name: "a dotted key over an assigned map entry",
|
|
doc: "lims.a = 1\nlims.a.b = 2\n",
|
|
want: "interpres: line 2: key \"a\" is not a table",
|
|
},
|
|
{
|
|
name: "a duplicate plain map entry",
|
|
doc: "lims.a = 1\nlims.a = 2\n",
|
|
want: "interpres: line 2: duplicate key \"a\"",
|
|
},
|
|
{
|
|
name: "an array of tables inside a map entry",
|
|
doc: "lims.c = 1\n[[lims.items]]\nk = 1\n",
|
|
want: "",
|
|
},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
var cfg, ref targetCfg
|
|
err := Unmarshal([]byte(tt.doc), &cfg)
|
|
refErr := treeDecodeInto([]byte(tt.doc), &ref)
|
|
if (err == nil) != (refErr == nil) {
|
|
t.Fatalf("error presence disagrees: tree %v, targeted %v", refErr, err)
|
|
}
|
|
if err != nil {
|
|
if err.Error() != refErr.Error() {
|
|
t.Fatalf("errors disagree:\ntree: %v\ntargeted: %v", refErr, err)
|
|
}
|
|
return
|
|
}
|
|
if !reflect.DeepEqual(cfg, ref) {
|
|
t.Errorf("values disagree: targeted %+v, tree %+v", cfg, ref)
|
|
}
|
|
})
|
|
}
|
|
}
|