feat(tools/basic): 内置基础工具（calculator(注入安全)/datetime/random/text/json/markdown）+ 批量注册

plugins/tools/basic/json_test.go

@@ -0,0 +1,119 @@
+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")
+	}
+}