286 lines
9.0 KiB
Go
286 lines
9.0 KiB
Go
// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"errors"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"sourcedock.dev/petrbalvin/interpres"
|
|
)
|
|
|
|
func TestRunParsesValidTOML(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
in := bytes.NewReader([]byte(`name = "x"
|
|
port = 8080
|
|
enabled = true
|
|
`))
|
|
if code := Run(nil, in, &stdout, &stderr); code != 0 {
|
|
t.Fatalf("Run returned %d, stderr = %q", code, stderr.String())
|
|
}
|
|
var got map[string]any
|
|
if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
|
|
t.Fatalf("invalid JSON output: %v\n%s", err, stdout.String())
|
|
}
|
|
if name := got["name"].(map[string]any); name["type"] != "string" || name["value"] != "x" {
|
|
t.Errorf("name = %#v", got["name"])
|
|
}
|
|
if port := got["port"].(map[string]any); port["type"] != "integer" || port["value"] != "8080" {
|
|
t.Errorf("port = %#v", got["port"])
|
|
}
|
|
if en := got["enabled"].(map[string]any); en["type"] != "bool" || en["value"] != "true" {
|
|
t.Errorf("enabled = %#v", got["enabled"])
|
|
}
|
|
}
|
|
|
|
func TestRunRejectsInvalidInput(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
in := bytes.NewReader([]byte("v = \n"))
|
|
code := Run(nil, in, &stdout, &stderr)
|
|
if code != 1 {
|
|
t.Errorf("Run returned %d, want 1 (parse error); stderr = %q", code, stderr.String())
|
|
}
|
|
if stdout.Len() != 0 {
|
|
t.Errorf("stdout should be empty on parse error, got %q", stdout.String())
|
|
}
|
|
}
|
|
|
|
func TestRunReadErrorReturnsTwo(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
code := Run(nil, errorReader{}, &stdout, &stderr)
|
|
if code != 2 {
|
|
t.Errorf("Run returned %d, want 2 (read error); stderr = %q", code, stderr.String())
|
|
}
|
|
if !strings.Contains(stderr.String(), "read stdin") {
|
|
t.Errorf("stderr = %q, want it to mention 'read stdin'", stderr.String())
|
|
}
|
|
}
|
|
|
|
// errorReader is an io.Reader that always reports an error.
|
|
type errorReader struct{}
|
|
|
|
func (errorReader) Read(_ []byte) (int, error) { return 0, errors.New("boom") }
|
|
|
|
func TestRunEncodeErrorReturnsTwo(t *testing.T) {
|
|
var stderr bytes.Buffer
|
|
w := errorWriter{}
|
|
in := bytes.NewReader([]byte(`k = "v"` + "\n"))
|
|
code := Run(nil, in, w, &stderr)
|
|
if code != 2 {
|
|
t.Errorf("Run returned %d, want 2 (encode error); stderr = %q", code, stderr.String())
|
|
}
|
|
if !strings.Contains(stderr.String(), "encode") {
|
|
t.Errorf("stderr = %q, want it to mention 'encode'", stderr.String())
|
|
}
|
|
}
|
|
|
|
// errorWriter is an io.Writer that always reports an error.
|
|
type errorWriter struct{}
|
|
|
|
func (errorWriter) Write(_ []byte) (int, error) { return 0, errors.New("boom") }
|
|
|
|
func TestTagHandlesAllScalarTypes(t *testing.T) {
|
|
now := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
|
|
ldt := interpres.LocalDateTime{Time: now}
|
|
ld := interpres.LocalDate{Time: time.Date(2026, 1, 2, 0, 0, 0, 0, time.UTC)}
|
|
lt := interpres.LocalTime{Time: time.Date(0, 1, 1, 3, 4, 5, 0, time.UTC)}
|
|
|
|
cases := []struct {
|
|
name string
|
|
in any
|
|
want map[string]string
|
|
}{
|
|
{"string", "x", map[string]string{"type": "string", "value": "x"}},
|
|
{"bool", true, map[string]string{"type": "bool", "value": "true"}},
|
|
{"bool-false", false, map[string]string{"type": "bool", "value": "false"}},
|
|
{"int64", int64(42), map[string]string{"type": "integer", "value": "42"}},
|
|
{"float", 1.5, map[string]string{"type": "float", "value": "1.5"}},
|
|
{"time", now, map[string]string{"type": "datetime", "value": "2026-01-02T03:04:05Z"}},
|
|
{"ldt", ldt, map[string]string{"type": "datetime-local", "value": "2026-01-02T03:04:05"}},
|
|
{"ld", ld, map[string]string{"type": "date-local", "value": "2026-01-02"}},
|
|
{"lt", lt, map[string]string{"type": "time-local", "value": "03:04:05"}},
|
|
}
|
|
for _, c := range cases {
|
|
got, err := tag(c.in)
|
|
if err != nil {
|
|
t.Errorf("%s: tag returned error %v", c.name, err)
|
|
continue
|
|
}
|
|
m, ok := got.(map[string]string)
|
|
if !ok {
|
|
t.Errorf("%s: tag returned %T, want map[string]string", c.name, got)
|
|
continue
|
|
}
|
|
if m["type"] != c.want["type"] || m["value"] != c.want["value"] {
|
|
t.Errorf("%s: tag = %#v, want %#v", c.name, m, c.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTagRejectsUnsupportedType(t *testing.T) {
|
|
// Channels are not produced by the parser; tag must reject them explicitly.
|
|
var ch chan int
|
|
got, err := tag(ch)
|
|
if err == nil {
|
|
t.Fatalf("expected error for chan int, got value %#v", got)
|
|
}
|
|
if !strings.Contains(err.Error(), "unsupported") {
|
|
t.Errorf("err = %v, want substring 'unsupported'", err)
|
|
}
|
|
if got != nil {
|
|
t.Errorf("got = %#v, want nil", got)
|
|
}
|
|
|
|
// The same applies when an unsupported type is nested inside a table.
|
|
got, err = tag(map[string]any{"x": ch})
|
|
if err == nil {
|
|
t.Fatalf("expected error for nested chan int, got %#v", got)
|
|
}
|
|
}
|
|
|
|
// Exercise the table, array-of-tables, and array shapes so all of tag's
|
|
// switch arms are visited.
|
|
func TestTagHandlesContainers(t *testing.T) {
|
|
tbl := map[string]any{
|
|
"name": "x",
|
|
"items": []any{
|
|
int64(1), int64(2),
|
|
},
|
|
}
|
|
got, err := tag(tbl)
|
|
if err != nil {
|
|
t.Fatalf("tag(tbl) returned error: %v", err)
|
|
}
|
|
m, ok := got.(map[string]any)
|
|
if !ok {
|
|
t.Fatalf("tag returned %T, want map", got)
|
|
}
|
|
name, ok := m["name"].(map[string]string)
|
|
if !ok || name["value"] != "x" {
|
|
t.Errorf("name = %#v", m["name"])
|
|
}
|
|
items, ok := m["items"].([]any)
|
|
if !ok {
|
|
t.Fatalf("items = %T, want []any", m["items"])
|
|
}
|
|
if len(items) != 2 {
|
|
t.Fatalf("len(items) = %d, want 2", len(items))
|
|
}
|
|
for _, raw := range items {
|
|
if _, ok := raw.(map[string]string); !ok {
|
|
t.Errorf("item = %T, want map[string]string", raw)
|
|
}
|
|
}
|
|
|
|
// Direct tests of the array branches.
|
|
if got, err := tag([]any{int64(1)}); err != nil {
|
|
t.Errorf("tag([]any) returned error: %v", err)
|
|
} else if len(got.([]any)) != 1 {
|
|
t.Errorf("[]any tag = %#v", got)
|
|
}
|
|
if got, err := tag([]map[string]any{{"k": "v"}}); err != nil {
|
|
t.Errorf("tag([]map) returned error: %v", err)
|
|
} else if len(got.([]any)) != 1 {
|
|
t.Errorf("[]map[string]any tag = %#v", got)
|
|
}
|
|
}
|
|
|
|
func TestFormatFloatAllBranches(t *testing.T) {
|
|
cases := map[float64]string{
|
|
1.5: "1.5",
|
|
0: "0",
|
|
1e10: "1e+10",
|
|
-2.5e-3: "-0.0025",
|
|
}
|
|
for in, want := range cases {
|
|
if got := formatFloat(in); got != want {
|
|
t.Errorf("formatFloat(%v) = %q, want %q", in, got, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestTaggedHelper(t *testing.T) {
|
|
got := tagged("string", "x")
|
|
if got["type"] != "string" || got["value"] != "x" {
|
|
t.Errorf("tagged = %#v", got)
|
|
}
|
|
}
|
|
|
|
func TestValidateStdinAcceptsValidDocument(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
in := bytes.NewReader([]byte("title = \"ok\"\n"))
|
|
if code := Run([]string{"-validate"}, in, &stdout, &stderr); code != 0 {
|
|
t.Fatalf("Run returned %d, stderr = %q", code, stderr.String())
|
|
}
|
|
if stdout.Len() != 0 || stderr.Len() != 0 {
|
|
t.Fatalf("validate should be quiet on success, stdout %q stderr %q", stdout.String(), stderr.String())
|
|
}
|
|
}
|
|
|
|
func TestValidateStdinRejectsInvalidDocument(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
in := bytes.NewReader([]byte("title = \"unterminated\n"))
|
|
if code := Run([]string{"-validate"}, in, &stdout, &stderr); code != 1 {
|
|
t.Fatalf("Run returned %d, want 1; stderr = %q", code, stderr.String())
|
|
}
|
|
if !strings.Contains(stderr.String(), "<stdin>") || !strings.Contains(stderr.String(), "line 1") {
|
|
t.Fatalf("stderr = %q, want the name and the line", stderr.String())
|
|
}
|
|
if stdout.Len() != 0 {
|
|
t.Fatalf("stdout should stay empty, got %q", stdout.String())
|
|
}
|
|
}
|
|
|
|
func TestValidateFiles(t *testing.T) {
|
|
dir := t.TempDir()
|
|
good := dir + "/good.toml"
|
|
bad := dir + "/bad.toml"
|
|
if err := os.WriteFile(good, []byte("a = 1\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(bad, []byte("a =\n"), 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var stdout, stderr bytes.Buffer
|
|
if code := Run([]string{"-validate", good}, nil, &stdout, &stderr); code != 0 {
|
|
t.Fatalf("one valid file: Run returned %d, stderr = %q", code, stderr.String())
|
|
}
|
|
if code := Run([]string{"-validate", good, bad}, nil, &stdout, &stderr); code != 1 {
|
|
t.Fatalf("valid plus invalid: Run returned %d, want 1; stderr = %q", code, stderr.String())
|
|
}
|
|
if !strings.Contains(stderr.String(), bad) || !strings.Contains(stderr.String(), "line 1") {
|
|
t.Fatalf("stderr = %q, want the file name and the line", stderr.String())
|
|
}
|
|
}
|
|
|
|
func TestValidateMissingFileReturnsTwo(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
if code := Run([]string{"-validate", "no-such-file.toml"}, nil, &stdout, &stderr); code != 2 {
|
|
t.Fatalf("Run returned %d, want 2; stderr = %q", code, stderr.String())
|
|
}
|
|
}
|
|
|
|
func TestAdapterModeRejectsPositionalArgument(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
in := bytes.NewReader([]byte("a = 1\n"))
|
|
if code := Run([]string{"file.toml"}, in, &stdout, &stderr); code != 2 {
|
|
t.Fatalf("Run returned %d, want 2; stderr = %q", code, stderr.String())
|
|
}
|
|
if !strings.Contains(stderr.String(), "-validate") {
|
|
t.Fatalf("stderr = %q, want it to point at -validate", stderr.String())
|
|
}
|
|
}
|
|
|
|
func TestUnknownFlagReturnsTwo(t *testing.T) {
|
|
var stdout, stderr bytes.Buffer
|
|
if code := Run([]string{"-nope"}, nil, &stdout, &stderr); code != 2 {
|
|
t.Fatalf("Run returned %d, want 2; stderr = %q", code, stderr.String())
|
|
}
|
|
}
|