package generator import ( "bytes" "errors" "io" "regexp" "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestNewUserDialog(t *testing.T) { t.Parallel() type args struct { reader io.Reader props map[string]string } tests := []struct { name string args args wantWriter string }{ { name: "with nil props creates empty map", args: args{ reader: bytes.NewBufferString("test input\n"), props: nil, }, wantWriter: "", }, { name: "with existing props preserves them", args: args{ reader: bytes.NewBufferString("test input\n"), props: map[string]string{ "key1": "value1", "key2": "value2", }, }, wantWriter: "", }, { name: "with empty props map", args: args{ reader: bytes.NewBufferString("test input\n"), props: map[string]string{}, }, wantWriter: "", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() writer := &bytes.Buffer{} got := NewUserDialog(tt.args.reader, writer, tt.args.props) require.NotNil(t, got) assert.NotNil(t, got.scanner) assert.Equal(t, tt.args.reader, got.reader) assert.Equal(t, writer, got.writer) if tt.args.props == nil { assert.NotNil(t, got.props) assert.Empty(t, got.props) } else { assert.Equal(t, tt.args.props, got.props) } assert.Equal(t, tt.wantWriter, writer.String()) }) } } func TestUserDialog_Query(t *testing.T) { t.Parallel() emailRegex := regexp.MustCompile(`^([a-zA-Z0-9._%+-]+)@([a-zA-Z0-9.-]+)\.([a-zA-Z]{2,})$`) ipRegex := regexp.MustCompile(`^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$`) testRegex := regexp.MustCompile(`^test_(\w+)$`) type args struct { prompt string validator *regexp.Regexp key string } tests := []struct { name string ud *UserDialog args args want []string wantErr bool wantOut string }{ { name: "valid email with capture groups", ud: NewUserDialog( bytes.NewBufferString("user@example.com\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter email:", validator: emailRegex, key: "email", }, want: []string{"user@example.com", "user", "example", "com"}, }, { name: "valid IP address with capture groups", ud: NewUserDialog( bytes.NewBufferString("192.168.1.1\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter IP:", validator: ipRegex, key: "ip", }, want: []string{"192.168.1.1", "192", "168", "1", "1"}, }, { name: "invalid input then valid input", ud: NewUserDialog( bytes.NewBufferString("invalid\nuser@example.com\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter email:", validator: emailRegex, key: "email", }, want: []string{"user@example.com", "user", "example", "com"}, wantOut: "invalid format\n\n", }, { name: "using prop value", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, map[string]string{"email": "prop@example.com"}, ), args: args{ prompt: "Enter email:", validator: emailRegex, key: "email", }, want: []string{"prop@example.com", "prop", "example", "com"}, wantOut: "Using prop value prop@example.com for email", }, { name: "invalid prop value falls back to interactive", ud: NewUserDialog( bytes.NewBufferString("valid@example.com\n"), &bytes.Buffer{}, map[string]string{"email": "not-an-email"}, ), args: args{ prompt: "Enter email:", validator: emailRegex, key: "email", }, want: []string{"valid@example.com", "valid", "example", "com"}, wantOut: "Supplied prop value not-an-email is not valid for email: " + "invalid format\nEnter email: ", }, { name: "regex with word capture", ud: NewUserDialog( bytes.NewBufferString("test_hello\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter test:", validator: testRegex, key: "test", }, want: []string{"test_hello", "hello"}, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() got := tt.ud.Query(tt.args.prompt, tt.args.validator, tt.args.key) assert.Equal(t, tt.want, got) if tt.wantOut != "" { writer, ok := tt.ud.writer.(*bytes.Buffer) require.True(t, ok) assert.Contains(t, writer.String(), tt.wantOut) } }) } } func TestUserDialog_QueryAll(t *testing.T) { t.Parallel() // Matches comma-separated words wordRegex := regexp.MustCompile(`\b(\w+)\b`) // Matches email addresses emailRegex := regexp.MustCompile(`([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})`) type args struct { prompt string validator *regexp.Regexp key string maxMatches int } tests := []struct { name string ud *UserDialog args args want [][]string wantOut string }{ { name: "multiple words with max matches", ud: NewUserDialog( bytes.NewBufferString("apple, banana, cherry\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter fruits:", validator: wordRegex, key: "fruits", maxMatches: 3, }, want: [][]string{ {"apple", "apple"}, {"banana", "banana"}, {"cherry", "cherry"}, }, }, { name: "multiple emails with unlimited matches", ud: NewUserDialog( bytes.NewBufferString("user1@test.com, user2@test.com\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter emails:", validator: emailRegex, key: "emails", maxMatches: -1, }, want: [][]string{ {"user1@test.com", "user1@test.com"}, {"user2@test.com", "user2@test.com"}, }, }, { name: "limited matches", ud: NewUserDialog( bytes.NewBufferString("one two three four\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter words:", validator: wordRegex, key: "words", maxMatches: 2, }, want: [][]string{ {"one", "one"}, {"two", "two"}, }, }, { name: "using prop value", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, map[string]string{"items": "a, b, c"}, ), args: args{ prompt: "Enter items:", validator: wordRegex, key: "items", maxMatches: 3, }, want: [][]string{ {"a", "a"}, {"b", "b"}, {"c", "c"}, }, }, { name: "no matches returns nil", ud: NewUserDialog( bytes.NewBufferString("!!!###@@@\nvalid\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter words:", validator: wordRegex, key: "words", maxMatches: 1, }, want: [][]string{{"valid", "valid"}}, wantOut: "invalid format\n\n", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() got := tt.ud.QueryAll(tt.args.prompt, tt.args.validator, tt.args.key, tt.args.maxMatches) assert.Equal(t, tt.want, got) if tt.wantOut != "" { writer, ok := tt.ud.writer.(*bytes.Buffer) require.True(t, ok) assert.Contains(t, writer.String(), tt.wantOut) } }) } } func TestUserDialog_QueryBool(t *testing.T) { t.Parallel() type args struct { prompt string key string } tests := []struct { name string ud *UserDialog args args want bool wantOut string }{ { name: "yes returns true", ud: NewUserDialog( bytes.NewBufferString("yes\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Continue?", key: "continue", }, want: true, }, { name: "y returns true", ud: NewUserDialog( bytes.NewBufferString("y\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Continue?", key: "continue", }, want: true, }, { name: "true returns true", ud: NewUserDialog( bytes.NewBufferString("true\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enable?", key: "enable", }, want: true, }, { name: "1 returns true", ud: NewUserDialog( bytes.NewBufferString("1\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enable?", key: "enable", }, want: true, }, { name: "no returns false", ud: NewUserDialog( bytes.NewBufferString("no\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Skip?", key: "skip", }, want: false, }, { name: "n returns false", ud: NewUserDialog( bytes.NewBufferString("n\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Skip?", key: "skip", }, want: false, }, { name: "false returns false", ud: NewUserDialog( bytes.NewBufferString("false\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Disable?", key: "disable", }, want: false, }, { name: "0 returns false", ud: NewUserDialog( bytes.NewBufferString("0\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Disable?", key: "disable", }, want: false, }, { name: "invalid then valid", ud: NewUserDialog( bytes.NewBufferString("maybe\nyes\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Continue?", key: "continue", }, want: true, wantOut: "answer must be yes or no", }, { name: "using prop value yes", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, map[string]string{"enabled": "yes"}, ), args: args{ prompt: "Enabled?", key: "enabled", }, want: true, }, { name: "using prop value no", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, map[string]string{"disabled": "no"}, ), args: args{ prompt: "Disabled?", key: "disabled", }, want: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() got := tt.ud.QueryBool(tt.args.prompt, tt.args.key) assert.Equal(t, tt.want, got) if tt.wantOut != "" { writer, ok := tt.ud.writer.(*bytes.Buffer) require.True(t, ok) assert.Contains(t, writer.String(), tt.wantOut) } }) } } func TestUserDialog_QueryInt(t *testing.T) { t.Parallel() type args struct { prompt string key string bitSize int } tests := []struct { name string ud *UserDialog args args want int64 wantOut string }{ { name: "decimal positive number", ud: NewUserDialog( bytes.NewBufferString("42\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter number:", key: "number", bitSize: 64, }, want: 42, }, { name: "decimal negative number", ud: NewUserDialog( bytes.NewBufferString("-123\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter number:", key: "number", bitSize: 64, }, want: -123, }, { name: "zero", ud: NewUserDialog( bytes.NewBufferString("0\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter number:", key: "number", bitSize: 64, }, want: 0, }, { name: "hex with 0x prefix", ud: NewUserDialog( bytes.NewBufferString("0xFF\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter hex:", key: "hex", bitSize: 64, }, want: 255, }, { name: "hex with # prefix", ud: NewUserDialog( bytes.NewBufferString("#ffa080\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter color:", key: "color", bitSize: 64, }, want: 0xFFA080, }, { name: "hex lowercase", ud: NewUserDialog( bytes.NewBufferString("0xabc\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter hex:", key: "hex", bitSize: 64, }, want: 2748, }, { name: "invalid then valid", ud: NewUserDialog( bytes.NewBufferString("abc\n100\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter number:", key: "number", bitSize: 64, }, want: 100, wantOut: "not a number\n\n", }, { name: "using prop value", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, map[string]string{"port": "8080"}, ), args: args{ prompt: "Enter port:", key: "port", bitSize: 16, }, want: 8080, }, { name: "with int32 bitSize", ud: NewUserDialog( bytes.NewBufferString("12345\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter number:", key: "number", bitSize: 32, }, want: 12345, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() got := tt.ud.QueryInt(tt.args.prompt, tt.args.key, tt.args.bitSize) assert.Equal(t, tt.want, got) if tt.wantOut != "" { writer, ok := tt.ud.writer.(*bytes.Buffer) require.True(t, ok) assert.Contains(t, writer.String(), tt.wantOut) } }) } } func TestUserDialog_QueryString(t *testing.T) { t.Parallel() noSpacesValidator := func(s string) error { for _, r := range s { if r == ' ' { return errors.New("spaces not allowed") } } return nil } type args struct { prompt string validator func(string) error key string } tests := []struct { name string ud *UserDialog args args want string wantOut string }{ { name: "valid input without validator", ud: NewUserDialog( bytes.NewBufferString("hello\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter name:", validator: nil, key: "name", }, want: "hello", }, { name: "valid input with validator", ud: NewUserDialog( bytes.NewBufferString("testuser\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter username:", validator: noSpacesValidator, key: "username", }, want: "testuser", }, { name: "invalid then valid", ud: NewUserDialog( bytes.NewBufferString("hello world\ngoodbye\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter name:", validator: noSpacesValidator, key: "name", }, want: "goodbye", wantOut: "spaces not allowed\n\n", }, { name: "empty input allowed without validator", ud: NewUserDialog( bytes.NewBufferString("\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter (optional):", validator: nil, key: "optional", }, want: "", }, { name: "using prop value", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, map[string]string{"name": "propvalue"}, ), args: args{ prompt: "Enter name:", validator: nil, key: "name", }, want: "propvalue", wantOut: "Using prop value", }, { name: "invalid prop value falls back to interactive", ud: NewUserDialog( bytes.NewBufferString("validinput\n"), &bytes.Buffer{}, map[string]string{"name": "has space"}, ), args: args{ prompt: "Enter name:", validator: noSpacesValidator, key: "name", }, want: "validinput", wantOut: "is not valid for", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() got := tt.ud.QueryString(tt.args.prompt, tt.args.validator, tt.args.key) assert.Equal(t, tt.want, got) if tt.wantOut != "" { writer, ok := tt.ud.writer.(*bytes.Buffer) require.True(t, ok) assert.Contains(t, writer.String(), tt.wantOut) } }) } } func TestUserDialog_QueryStringPattern(t *testing.T) { t.Parallel() emailRegex := regexp.MustCompile(`^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`) alphaRegex := regexp.MustCompile(`^[a-zA-Z]+$`) digitRegex := regexp.MustCompile(`^\d+$`) type args struct { prompt string validator *regexp.Regexp key string } tests := []struct { name string ud *UserDialog args args want string wantPanic bool wantOut string }{ { name: "valid email", ud: NewUserDialog( bytes.NewBufferString("user@example.com\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter email:", validator: emailRegex, key: "email", }, want: "user@example.com", }, { name: "valid alphabetic", ud: NewUserDialog( bytes.NewBufferString("HelloWorld\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter text:", validator: alphaRegex, key: "text", }, want: "HelloWorld", }, { name: "valid digits", ud: NewUserDialog( bytes.NewBufferString("12345\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter number:", validator: digitRegex, key: "number", }, want: "12345", }, { name: "invalid then valid", ud: NewUserDialog( bytes.NewBufferString("123\nvalidemail@test.com\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter email:", validator: emailRegex, key: "email", }, want: "validemail@test.com", wantOut: "invalid format\n\n", }, { name: "using prop value", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, map[string]string{"email": "prop@test.com"}, ), args: args{ prompt: "Enter email:", validator: emailRegex, key: "email", }, want: "prop@test.com", wantOut: "Using prop value", }, { name: "nil validator panics", ud: NewUserDialog( bytes.NewBufferString("test\n"), &bytes.Buffer{}, nil, ), args: args{ prompt: "Enter value:", validator: nil, key: "value", }, wantPanic: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() if tt.wantPanic { assert.Panics(t, func() { tt.ud.QueryStringPattern(tt.args.prompt, tt.args.validator, tt.args.key) }) return } got := tt.ud.QueryStringPattern(tt.args.prompt, tt.args.validator, tt.args.key) assert.Equal(t, tt.want, got) if tt.wantOut != "" { writer, ok := tt.ud.writer.(*bytes.Buffer) require.True(t, ok) assert.Contains(t, writer.String(), tt.wantOut) } }) } } func TestUserDialog_Write(t *testing.T) { t.Parallel() type args struct { message string v []any } tests := []struct { name string ud *UserDialog args args wantWriter string }{ { name: "simple message", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ message: "Hello, World!", v: nil, }, wantWriter: "Hello, World!", }, { name: "formatted message with string", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ message: "Hello, %s!", v: []any{"Alice"}, }, wantWriter: "Hello, Alice!", }, { name: "formatted message with integer", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ message: "Count: %d", v: []any{42}, }, wantWriter: "Count: 42", }, { name: "formatted message with multiple values", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ message: "Name: %s, Age: %d, Score: %.2f", v: []any{"Bob", 25, 95.5}, }, wantWriter: "Name: Bob, Age: 25, Score: 95.50", }, { name: "empty message", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ message: "", v: nil, }, wantWriter: "", }, { name: "message with special characters", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ message: "Special: %s", v: []any{"!@#$%^&*()"}, }, wantWriter: "Special: !@#$%^&*()", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() tt.ud.Write(tt.args.message, tt.args.v...) writer, ok := tt.ud.writer.(*bytes.Buffer) require.True(t, ok) assert.Equal(t, tt.wantWriter, writer.String()) }) } } func TestUserDialog_Writelnf(t *testing.T) { t.Parallel() type args struct { fmtStr string v []any } tests := []struct { name string ud *UserDialog args args wantWriter string }{ { name: "simple message", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ fmtStr: "Hello, World!", v: nil, }, wantWriter: "Hello, World!\n", }, { name: "formatted message with string", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ fmtStr: "Hello, %s!", v: []any{"Alice"}, }, wantWriter: "Hello, Alice!\n", }, { name: "formatted message with integer", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ fmtStr: "Count: %d", v: []any{42}, }, wantWriter: "Count: 42\n", }, { name: "formatted message with multiple values", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ fmtStr: "Name: %s, Age: %d", v: []any{"Bob", 25}, }, wantWriter: "Name: Bob, Age: 25\n", }, { name: "empty message still adds newline", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ fmtStr: "", v: nil, }, wantWriter: "\n", }, { name: "error message", ud: NewUserDialog( bytes.NewBufferString(""), &bytes.Buffer{}, nil, ), args: args{ fmtStr: "Error: %s", v: []any{"something went wrong"}, }, wantWriter: "Error: something went wrong\n", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() tt.ud.Writelnf(tt.args.fmtStr, tt.args.v...) writer, ok := tt.ud.writer.(*bytes.Buffer) require.True(t, ok) assert.Equal(t, tt.wantWriter, writer.String()) }) } } func TestValidateFormat(t *testing.T) { t.Parallel() type args struct { validator func(string) bool } tests := []struct { name string args args input string wantErr bool wantError error }{ { name: "validator returns true", args: args{ validator: func(s string) bool { return s == "valid" }, }, input: "valid", wantErr: false, }, { name: "validator returns false", args: args{ validator: func(s string) bool { return s == "valid" }, }, input: "invalid", wantErr: true, wantError: errInvalidFormat, }, { name: "validator checks non-empty", args: args{ validator: func(s string) bool { return s != "" }, }, input: "not empty", wantErr: false, }, { name: "validator fails on empty", args: args{ validator: func(s string) bool { return s != "" }, }, input: "", wantErr: true, wantError: errInvalidFormat, }, { name: "validator checks prefix", args: args{ validator: func(s string) bool { return len(s) >= 3 && s[:3] == "pre" }, }, input: "prefix", wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() got := ValidateFormat(tt.args.validator) require.NotNil(t, got) err := got(tt.input) if tt.wantErr { require.Error(t, err) if tt.wantError != nil { require.ErrorIs(t, err, tt.wantError) } } else { require.NoError(t, err) } }) } } //nolint:gosmopolitan // Unicode characters used intentionally for testing rune handling func TestRequired(t *testing.T) { t.Parallel() type args struct { answer string } tests := []struct { name string args args wantErr bool }{ { name: "non-empty string", args: args{answer: "hello"}, wantErr: false, }, { name: "single character", args: args{answer: "a"}, wantErr: false, }, { name: "empty string", args: args{answer: ""}, wantErr: true, }, { name: "whitespace only", args: args{answer: " "}, wantErr: false, }, { name: "string with spaces", args: args{answer: "hello world"}, wantErr: false, }, { name: "special characters", args: args{answer: "!@#$%"}, wantErr: false, }, { name: "numeric string", args: args{answer: "12345"}, wantErr: false, }, { name: "unicode characters", args: args{answer: "Hello 世界"}, wantErr: false, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { t.Parallel() err := Required(tt.args.answer) if tt.wantErr { require.Error(t, err) assert.ErrorIs(t, err, errRequired) } else { require.NoError(t, err) } }) } }