120 lines
3.7 KiB
Go
120 lines
3.7 KiB
Go
package basic
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
// TestJson_Execute_Normal covers parse, format, validate and stringify.
|
|
func TestJson_Execute_Normal(t *testing.T) {
|
|
t.Parallel()
|
|
tool := jsonTool{}
|
|
|
|
t.Run("parse", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "parse", "value": `{"a":1,"b":[true,null,"s"]}`})
|
|
assertNoErr(t, err)
|
|
m := mapResult(t, got)
|
|
obj := m["result"].(map[string]any)
|
|
if obj["a"] != float64(1) {
|
|
t.Fatalf("a = %v, want 1", obj["a"])
|
|
}
|
|
if !reflect.DeepEqual(obj["b"], []any{true, nil, "s"}) {
|
|
t.Fatalf("b = %v, want [true nil s]", obj["b"])
|
|
}
|
|
})
|
|
|
|
t.Run("string value parse", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "parse", "value": `"hi"`})
|
|
assertNoErr(t, err)
|
|
if fieldString(t, mapResult(t, got), "result") != "hi" {
|
|
t.Fatalf("result should be hi")
|
|
}
|
|
})
|
|
|
|
t.Run("format", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "format", "value": `{"x":1}`})
|
|
assertNoErr(t, err)
|
|
m := mapResult(t, got)
|
|
if want := "{\n \"x\": 1\n}"; fieldString(t, m, "result") != want {
|
|
t.Fatalf("result = %q, want %q", m["result"], want)
|
|
}
|
|
})
|
|
|
|
t.Run("validate valid", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "validate", "value": `{"a":[1,2]}`})
|
|
assertNoErr(t, err)
|
|
if !fieldBool(t, mapResult(t, got), "valid") {
|
|
t.Fatalf("valid should be true")
|
|
}
|
|
})
|
|
|
|
t.Run("validate invalid", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "validate", "value": `{broken`})
|
|
assertNoErr(t, err)
|
|
if fieldBool(t, mapResult(t, got), "valid") {
|
|
t.Fatalf("valid should be false")
|
|
}
|
|
})
|
|
|
|
t.Run("stringify", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, tool, map[string]any{"operation": "stringify", "value": map[string]any{"x": 1}})
|
|
assertNoErr(t, err)
|
|
m := mapResult(t, got)
|
|
if want := "{\n \"x\": 1\n}"; fieldString(t, m, "result") != want {
|
|
t.Fatalf("result = %q, want %q", m["result"], want)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestJson_Execute_Errors covers invalid inputs and unsupported operations.
|
|
func TestJson_Execute_Errors(t *testing.T) {
|
|
t.Parallel()
|
|
tool := jsonTool{}
|
|
cases := []struct {
|
|
name string
|
|
args map[string]any
|
|
target error
|
|
}{
|
|
{name: "invalid parse", args: map[string]any{"operation": "parse", "value": `{bad`}, target: nil},
|
|
{name: "parse non-string", args: map[string]any{"operation": "parse", "value": 42}, target: ErrInvalidArgument},
|
|
{name: "invalid format", args: map[string]any{"operation": "format", "value": `{bad`}, target: nil},
|
|
{name: "validate non-string", args: map[string]any{"operation": "validate", "value": true}, target: ErrInvalidArgument},
|
|
{name: "unknown operation", args: map[string]any{"operation": "csv", "value": "{}"}, target: ErrUnsupported},
|
|
{name: "missing value", args: map[string]any{"operation": "stringify"}, target: ErrInvalidArgument},
|
|
{name: "missing operation", args: map[string]any{}, target: ErrInvalidArgument},
|
|
}
|
|
for _, tc := range cases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
_, err := run(t, tool, tc.args)
|
|
if err == nil {
|
|
t.Fatalf("want error, got nil")
|
|
}
|
|
if tc.target != nil {
|
|
assertIs(t, err, tc.target)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestJson_Schema verifies required operation.
|
|
func TestJson_Schema(t *testing.T) {
|
|
t.Parallel()
|
|
p, err := jsonTool{}.Parameters()
|
|
assertNoErr(t, err)
|
|
reqs := p["required"].([]any)
|
|
if len(reqs) != 1 || reqs[0] != "operation" {
|
|
t.Fatalf("required = %v, want [operation]", reqs)
|
|
}
|
|
if _, ok := p["properties"].(map[string]any)["value"]; !ok {
|
|
t.Fatalf("schema should include a value property")
|
|
}
|
|
}
|