commandkit/report_value_test.go

package commandkit

import (
	"bytes"
	"encoding/json"
	"reflect"
	"strings"
	"testing"

	"go.yaml.in/yaml/v4"
)

type reportJSONValue struct{}

func (reportJSONValue) MarshalJSON() ([]byte, error) {
	return []byte(`{"selected":123456789012345678901234567890,"text":"false"}`), nil
}

func TestNormalizeReport(t *testing.T) {
	value := struct {
		Visible any    `json:"visible"`
		Hidden  string `json:"-"`
		Empty   string `json:"empty,omitempty"`
	}{Visible: reportJSONValue{}, Hidden: "secret"}
	got, err := normalizeReport(value)
	if err != nil {
		t.Fatal(err)
	}
	want := map[string]any{"visible": map[string]any{
		"selected": json.Number("123456789012345678901234567890"),
		"text":     "false",
	}}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("got %#v, want %#v", got, want)
	}
	if _, err := normalizeReport(make(chan int)); err == nil {
		t.Fatal("unsupported value should fail")
	}
}

func TestYAMLReportValues(t *testing.T) {
	input := `large: !!int 123456789012345678901234567890
hex: 0xff
fraction: .125
text: "false"
redacted: "[REDACTED]"
zero: 0
no: false
nothing: null
empty_map: {}
empty_list: []
items: [one, "2", null]
`
	got, err := DecodeYAMLReport(strings.NewReader(input))
	if err != nil {
		t.Fatal(err)
	}
	want := map[string]any{
		"large": json.Number("123456789012345678901234567890"),
		"hex":   json.Number("255"), "fraction": json.Number("0.125"),
		"text": "false", "redacted": "[REDACTED]", "zero": json.Number("0"),
		"no": false, "nothing": nil, "empty_map": map[string]any{},
		"empty_list": []any{}, "items": []any{"one", "2", nil},
	}
	if !reflect.DeepEqual(got, want) {
		t.Fatalf("got %#v, want %#v", got, want)
	}
	node, err := reportYAMLNode(got)
	if err != nil {
		t.Fatal(err)
	}
	data, err := yaml.Marshal(node)
	if err != nil {
		t.Fatal(err)
	}
	roundtrip, err := DecodeYAMLReport(bytes.NewReader(data))
	if err != nil {
		t.Fatalf("decode %s: %v", data, err)
	}
	if !reflect.DeepEqual(roundtrip, want) {
		t.Fatalf("roundtrip %s: got %#v, want %#v", data, roundtrip, want)
	}
}

func TestDecodeYAMLReportRejectsUnsupportedValues(t *testing.T) {
	for _, input := range []string{"1: value", "a: .inf", "a: !custom value", "a: 1\n---\nb: 2", "a: &a [*a]", "a: 1\na: 2"} {
		t.Run(input, func(t *testing.T) {
			if _, err := DecodeYAMLReport(strings.NewReader(input)); err == nil {
				t.Fatal("expected conversion error")
			}
		})
	}
}

func TestYAMLReportLargeNumericScalars(t *testing.T) {
	for _, tc := range []struct{ input, want string }{
		{"!!float 1e9999", "1e9999"}, {"!!int 0x100000000000000000000", "1208925819614629174706176"},
		{"!!float +01.2500e+9999", "1.2500e+9999"},
	} {
		t.Run(tc.input, func(t *testing.T) {
			got, err := DecodeYAMLReport(strings.NewReader(tc.input))
			if err != nil || got != json.Number(tc.want) {
				t.Fatalf("got %#v, %v; want %s", got, err, tc.want)
			}
		})
	}
	for _, input := range []string{`1e9999`, `"1e9999"`, `!!str 1e9999`, `.`, `hello`} {
		got, err := DecodeYAMLReport(strings.NewReader(input))
		if err != nil {
			t.Fatal(err)
		}
		if _, ok := got.(string); !ok {
			t.Fatalf("%q became %#v", input, got)
		}
	}
}

func TestReportYAMLNodePreservesNumericLookingStrings(t *testing.T) {
	value := map[string]any{"1e9999": "0x100000000000000000000", "number": json.Number("1e9999")}
	node, err := reportYAMLNode(value)
	if err != nil {
		t.Fatal(err)
	}
	data, err := yaml.Marshal(node)
	if err != nil {
		t.Fatal(err)
	}
	got, err := DecodeYAMLReport(bytes.NewReader(data))
	if err != nil {
		t.Fatalf("%s: %v", data, err)
	}
	if !reflect.DeepEqual(got, value) {
		t.Fatalf("%s: got %#v, want %#v", data, got, value)
	}
}

func TestDecodeYAMLReportPreservesPlainNativeStrings(t *testing.T) {
	// Native ConfigKit safe output can contain an unquoted numeric-looking string
	// when the YAML resolver considers the token outside the numeric range.
	value, err := DecodeYAMLReport(strings.NewReader(`1e400: 1e400
quoted: "1e400"
explicit: !!str 1e400
number: !!float 1e400
`))
	if err != nil {
		t.Fatal(err)
	}
	want := map[string]any{"1e400": "1e400", "quoted": "1e400", "explicit": "1e400", "number": json.Number("1e400")}
	if !reflect.DeepEqual(value, want) {
		t.Fatalf("decoded=%#v want=%#v", value, want)
	}
	for _, format := range []Format{FormatJSON, FormatYAML} {
		var output bytes.Buffer
		if err := RenderReport(&output, Report{Value: value}, format); err != nil {
			t.Fatal(err)
		}
		var got any
		if format == FormatJSON {
			decoder := json.NewDecoder(&output)
			decoder.UseNumber()
			err = decoder.Decode(&got)
		} else {
			got, err = DecodeYAMLReport(&output)
		}
		if err != nil || !reflect.DeepEqual(got, want) {
			t.Fatalf("format %v: got=%#v err=%v", format, got, err)
		}
	}
}