87 lines
2.4 KiB
Go
87 lines
2.4 KiB
Go
package basic
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// TestRandom_Execute_Normal covers integer range and string generation.
|
|
func TestRandom_Execute_Normal(t *testing.T) {
|
|
t.Parallel()
|
|
r := random{}
|
|
|
|
t.Run("integer in range", func(t *testing.T) {
|
|
t.Parallel()
|
|
for i := 0; i < 200; i++ {
|
|
got, err := run(t, r, map[string]any{"min": 5, "max": 9})
|
|
assertNoErr(t, err)
|
|
v := fieldInt(t, mapResult(t, got), "value")
|
|
if v < 5 || v > 9 {
|
|
t.Fatalf("value %d out of range [5,9]", v)
|
|
}
|
|
}
|
|
})
|
|
|
|
t.Run("string length and charset", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, r, map[string]any{"length": 12, "charset": "ab"})
|
|
assertNoErr(t, err)
|
|
s := fieldString(t, mapResult(t, got), "value")
|
|
if len([]rune(s)) != 12 {
|
|
t.Fatalf("length = %d, want 12", len([]rune(s)))
|
|
}
|
|
if strings.Trim(s, "ab") != "" {
|
|
t.Fatalf("value %q contains characters outside charset", s)
|
|
}
|
|
})
|
|
|
|
t.Run("single value range", func(t *testing.T) {
|
|
t.Parallel()
|
|
got, err := run(t, r, map[string]any{"min": 7, "max": 7})
|
|
assertNoErr(t, err)
|
|
if v := fieldInt(t, mapResult(t, got), "value"); v != 7 {
|
|
t.Fatalf("value = %d, want 7", v)
|
|
}
|
|
})
|
|
}
|
|
|
|
// TestRandom_Execute_Errors covers invalid parameters.
|
|
func TestRandom_Execute_Errors(t *testing.T) {
|
|
t.Parallel()
|
|
r := random{}
|
|
cases := []struct {
|
|
name string
|
|
args map[string]any
|
|
}{
|
|
{name: "no args", args: map[string]any{}},
|
|
{name: "inverted range", args: map[string]any{"min": 10, "max": 2}},
|
|
{name: "min not integer", args: map[string]any{"min": "x", "max": 5}},
|
|
{name: "zero length", args: map[string]any{"length": 0}},
|
|
{name: "negative length", args: map[string]any{"length": -1}},
|
|
{name: "length too big", args: map[string]any{"length": maxRandomLen + 1}},
|
|
{name: "empty charset", args: map[string]any{"length": 4, "charset": ""}},
|
|
{name: "non-string charset", args: map[string]any{"length": 4, "charset": 9}},
|
|
}
|
|
for _, tc := range cases {
|
|
tc := tc
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
t.Parallel()
|
|
_, err := run(t, r, tc.args)
|
|
assertIs(t, err, ErrInvalidArgument)
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestRandom_Schema verifies the JSON Schema contract.
|
|
func TestRandom_Schema(t *testing.T) {
|
|
t.Parallel()
|
|
p, err := random{}.Parameters()
|
|
assertNoErr(t, err)
|
|
props := p["properties"].(map[string]any)
|
|
for _, field := range []string{"min", "max", "length"} {
|
|
if props[field].(map[string]any)["type"] != "integer" {
|
|
t.Fatalf("%s type should be integer", field)
|
|
}
|
|
}
|
|
}
|