func TestStringValue(t *testing.T) { t.Run("NewStringValue()", func(t *testing.T) { expected := "Hello, World!" actual := parameters.NewStringValue(&expected) assert.Equal(t, expected, actual.String()) }) t.Run("Set()", func(t *testing.T) { t.Run("should not error for valid values", func(t *testing.T) { var value parameters.StringValue valid := []string{ "Hello", "World", "Hello, World!", "3.14", "http://www.google.co.uk/", } for _, item := range valid { err := value.Set(item) assert.OK(t, err) } }) t.Run("should modify the string that it references", func(t *testing.T) { ref := "Hello" value := parameters.NewStringValue(&ref) assert.Equal(t, "Hello", ref) value.Set("World") assert.Equal(t, "World", ref) }) }) t.Run("String()", func(t *testing.T) { inOut := map[string]string{ "Hello": "Hello", "World": "World", "hello": "hello", "world": "world", } for in, expected := range inOut { value := new(parameters.StringValue) value.Set(in) actual := value.String() assert.Equal(t, expected, actual) } }) }
func main() { application := console.NewApplication("eidolon/console", "0.1.0") application.Logo = ` # ### ## ######## ### ####### ####### ### ####### ### ## ### ## ## ### ## #### ## ####### ### ### ## ## ## ### ## ## ####### ### ### ### ## ## ## ### ## ## ### ### ####### ### ###### ##### ####### ##### ### ## # ` application.AddCommand(console.Command{ Name: "greet:example", Description: "Greet's the given user, or the world.", Help: "You don't have to specify a name.", Configure: func(definition *console.Definition) { definition.AddOption( parameters.NewStringValue(&name), "-n, --name=NAME", "Provide a name for the greeting.", ) definition.AddArgument( parameters.NewIntValue(&favNum), "FAVOURITE_NUMBER", "Provide your favourite number.", ) }, Execute: func(input *console.Input, output *console.Output) error { output.Printf("Hello, %s!\n", name) output.Printf("Your favourite number is %d.\n", favNum) return nil }, }) code := application.Run(os.Args[1:]) os.Exit(code) }
func TestDescribeCommand(t *testing.T) { t.Run("should return command usage information", func(t *testing.T) { application := console.NewApplication("eidolon/console", "1.2.3+testing") command := console.Command{ Name: "test", } result := console.DescribeCommand(application, &command) assert.True(t, strings.Contains(result, "USAGE:"), "Expected usage information.") }) t.Run("should include the command name", func(t *testing.T) { application := console.NewApplication("eidolon/console", "1.2.3+testing") command := console.Command{ Name: "test-command-name", } result := console.DescribeCommand(application, &command) assert.True(t, strings.Contains(result, "test-command-name"), "Expected command name.") }) t.Run("should show the command description", func(t *testing.T) { description := "This is the test-command-name description." application := console.NewApplication("eidolon/console", "1.2.3+testing") command := console.Command{ Name: "test-command-name", Description: description, } result := console.DescribeCommand(application, &command) assert.True(t, strings.Contains(result, description), "Expected command description.") }) t.Run("should return command help if there is some", func(t *testing.T) { help := "This is some help for the test-command-name command." application := console.NewApplication("eidolon/console", "1.2.3+testing") command := console.Command{ Name: "test-command-name", Help: help, } result := console.DescribeCommand(application, &command) assert.True(t, strings.Contains(result, "HELP:"), "Expected command help header.") assert.True(t, strings.Contains(result, help), "Expected command help.") }) t.Run("should show arguments if there are any", func(t *testing.T) { var s1 string var s2 string application := console.NewApplication("eidolon/console", "1.2.3+testing") command := console.Command{ Name: "test-command-name", Configure: func(definition *console.Definition) { definition.AddArgument(parameters.NewStringValue(&s1), "STRING_ARG_S1", "") definition.AddArgument(parameters.NewStringValue(&s2), "STRING_ARG_S2", "") }, } result := console.DescribeCommand(application, &command) assert.True(t, strings.Contains(result, "STRING_ARG_S1"), "Expected argument name.") assert.True(t, strings.Contains(result, "STRING_ARG_S2"), "Expected argument name.") }) t.Run("should show optional arguments wrapped in brackets", func(t *testing.T) { var s1 string var s2 string application := console.NewApplication("eidolon/console", "1.2.3+testing") command := console.Command{ Name: "test-command-name", Configure: func(definition *console.Definition) { definition.AddArgument(parameters.NewStringValue(&s1), "[STRING_ARG_S1]", "") definition.AddArgument(parameters.NewStringValue(&s2), "[STRING_ARG_S2]", "") }, } result := console.DescribeCommand(application, &command) assert.True(t, strings.Contains(result, "[STRING_ARG_S1]"), "Expected argument name.") assert.True(t, strings.Contains(result, "[STRING_ARG_S2]"), "Expected argument name.") }) t.Run("should show that there are options if there are any", func(t *testing.T) { var s1 string var s2 string application := console.NewApplication("eidolon/console", "1.2.3+testing") application.Configure = func(definition *console.Definition) { definition.AddOption(parameters.NewStringValue(&s1), "--s1=VALUE", "") } command := console.Command{ Name: "test-command-name", Configure: func(definition *console.Definition) { definition.AddOption(parameters.NewStringValue(&s2), "--s2=VALUE", "") }, } result := console.DescribeCommand(application, &command) assert.True(t, strings.Contains(result, "[OPTIONS...]"), "Expected options.") }) }
func TestDescribeApplication(t *testing.T) { t.Run("should show the application logo if there is one", func(t *testing.T) { application := console.NewApplication("eidolon/console", "1.2.3+testing") application.Logo = "Eidolon Console\n" result := console.DescribeApplication(application) assert.True(t, strings.Contains(result, application.Logo), "Expected application logo.") }) t.Run("should show the application name", func(t *testing.T) { application := console.NewApplication("eidolon/console", "1.2.3+testing") result := console.DescribeApplication(application) assert.True(t, strings.Contains(result, application.Name), "Expected application name.") }) t.Run("should show the application version", func(t *testing.T) { application := console.NewApplication("eidolon/console", "1.2.3+testing") result := console.DescribeApplication(application) assert.True(t, strings.Contains(result, application.Version), "Expected application version.") }) t.Run("should show the application usage", func(t *testing.T) { application := console.NewApplication("eidolon/console", "1.2.3+testing") application.UsageName = "eidolon_console_binary" usage := application.UsageName + " COMMAND [OPTIONS...] [ARGUMENTS...]" result := console.DescribeApplication(application) assert.True(t, strings.Contains(result, "USAGE:"), "Expected application usage title.") assert.True(t, strings.Contains(result, usage), "Expected application usage.") }) t.Run("should show the application options if there are any", func(t *testing.T) { var s1 string application := console.NewApplication("eidolon/console", "1.2.3+testing") application.Configure = func(definition *console.Definition) { definition.AddOption(parameters.NewStringValue(&s1), "--s1", "S1 option for testing.") } result := console.DescribeApplication(application) assert.True(t, strings.Contains(result, "OPTIONS:"), "Expected application options title.") assert.True(t, strings.Contains(result, "-h"), "Expected application options.") assert.True(t, strings.Contains(result, "--help"), "Expected application options.") assert.True(t, strings.Contains(result, "--s1"), "Expected application options.") }) t.Run("should show the application commands if there are any", func(t *testing.T) { application := console.NewApplication("eidolon/console", "1.2.3+testing") application.AddCommands([]console.Command{ { Name: "foo-cmd", }, { Name: "bar-cmd", }, }) result := console.DescribeApplication(application) assert.True(t, strings.Contains(result, "COMMANDS:"), "Expected application commands title.") assert.True(t, strings.Contains(result, "foo-cmd"), "Expected application commands.") assert.True(t, strings.Contains(result, "bar-cmd"), "Expected application commands.") }) t.Run("should not show the commands title if there are no commands", func(t *testing.T) { application := console.NewApplication("eidolon/console", "1.2.3+testing") application.Logo = "Eidolon Console\n" result := console.DescribeApplication(application) assert.False(t, strings.Contains(result, "COMMANDS:"), "Expected no commands title.") }) t.Run("should show the application help if there is any", func(t *testing.T) { help := "This is some application help right here. Lorem ipsum dolor sit amet." application := console.NewApplication("eidolon/console", "1.2.3+testing") application.Help = help result := console.DescribeApplication(application) assert.True(t, strings.Contains(result, "HELP:"), "Expected help title.") assert.True(t, strings.Contains(result, help), "Expected help.") }) t.Run("should not show the help title if there is no application help", func(t *testing.T) { application := console.NewApplication("eidolon/console", "1.2.3+testing") application.Logo = "Eidolon Console\n" result := console.DescribeApplication(application) assert.False(t, strings.Contains(result, "HELP:"), "Expected no help title.") }) }
func TestMapInput(t *testing.T) { createInput := func(params []string) *console.Input { return console.ParseInput(params) } t.Run("should map arguments to their reference values", func(t *testing.T) { var s1 string var s2 string assert.Equal(t, "", s1) assert.Equal(t, "", s2) input := createInput([]string{"hello", "world"}) definition := console.NewDefinition() definition.AddArgument(parameters.NewStringValue(&s1), "S1", "") definition.AddArgument(parameters.NewStringValue(&s2), "S2", "") err := console.MapInput(definition, input) assert.OK(t, err) assert.Equal(t, "hello", s1) assert.Equal(t, "world", s2) }) t.Run("should error parsing arguments with invalid values", func(t *testing.T) { var i1 int assert.Equal(t, 0, i1) input := createInput([]string{"foo"}) definition := console.NewDefinition() definition.AddArgument(parameters.NewIntValue(&i1), "I1", "") err := console.MapInput(definition, input) assert.NotOK(t, err) }) t.Run("should error when required arguments are missing from input", func(t *testing.T) { var s1 string var s2 string assert.Equal(t, "", s1) assert.Equal(t, "", s2) input := createInput([]string{"foo"}) definition := console.NewDefinition() definition.AddArgument(parameters.NewStringValue(&s1), "S1", "") definition.AddArgument(parameters.NewStringValue(&s1), "S2", "") err := console.MapInput(definition, input) assert.NotOK(t, err) }) t.Run("should not error when optional arguments are missing from input", func(t *testing.T) { var s1 string var s2 string assert.Equal(t, "", s1) assert.Equal(t, "", s2) input := createInput([]string{"foo"}) definition := console.NewDefinition() definition.AddArgument(parameters.NewStringValue(&s1), "S1", "") definition.AddArgument(parameters.NewStringValue(&s1), "[S2]", "") err := console.MapInput(definition, input) assert.OK(t, err) assert.Equal(t, "foo", s1) assert.Equal(t, "", s2) }) t.Run("should map short options to their reference values", func(t *testing.T) { var s1 string var s2 string assert.Equal(t, "", s1) assert.Equal(t, "", s2) input := createInput([]string{"-a=foo", "-b=bar"}) definition := console.NewDefinition() definition.AddOption(parameters.NewStringValue(&s1), "-a=S1", "") definition.AddOption(parameters.NewStringValue(&s2), "-b=S2", "") err := console.MapInput(definition, input) assert.OK(t, err) assert.Equal(t, "foo", s1) assert.Equal(t, "bar", s2) }) t.Run("should map long options to their reference values", func(t *testing.T) { var s1 string var s2 string assert.Equal(t, "", s1) assert.Equal(t, "", s2) input := createInput([]string{"--foo=bar", "--baz=qux"}) definition := console.NewDefinition() definition.AddOption(parameters.NewStringValue(&s1), "--foo=S1", "") definition.AddOption(parameters.NewStringValue(&s2), "--baz=S2", "") err := console.MapInput(definition, input) assert.OK(t, err) assert.Equal(t, "bar", s1) assert.Equal(t, "qux", s2) }) t.Run("should ignore options that don't exist in the definition", func(t *testing.T) { var s2 string input := createInput([]string{"--foo=bar"}) definition := console.NewDefinition() definition.AddOption(parameters.NewStringValue(&s2), "--baz=S2", "") err := console.MapInput(definition, input) assert.OK(t, err) }) t.Run("should error parsing an option that requires a value with no value", func(t *testing.T) { var s1 string input := createInput([]string{"--foo"}) definition := console.NewDefinition() definition.AddOption(parameters.NewStringValue(&s1), "--foo=s1", "") err := console.MapInput(definition, input) assert.NotOK(t, err) }) t.Run("should not error parsing an option that doesn't require a value", func(t *testing.T) { var s1 string input := createInput([]string{"--foo"}) definition := console.NewDefinition() definition.AddOption(parameters.NewStringValue(&s1), "--foo=s1", "") err := console.MapInput(definition, input) assert.NotOK(t, err) }) t.Run("should set flag option values where applicable", func(t *testing.T) { var b1 bool assert.Equal(t, false, b1) input := createInput([]string{"--foo"}) definition := console.NewDefinition() definition.AddOption(parameters.NewBoolValue(&b1), "--foo", "") err := console.MapInput(definition, input) assert.OK(t, err) assert.Equal(t, true, b1) }) t.Run("should error parsing options with invalid values", func(t *testing.T) { var i1 int assert.Equal(t, 0, i1) input := createInput([]string{"--foo=hello"}) definition := console.NewDefinition() definition.AddOption(parameters.NewIntValue(&i1), "--foo=I1", "") err := console.MapInput(definition, input) assert.NotOK(t, err) }) }
func TestApplication(t *testing.T) { createApplication := func(writer io.Writer) *console.Application { application := console.NewApplication("eidolon/console", "1.2.3.+testing") application.Writer = writer return application } createTestCommand := func(a *string, b *int) console.Command { return console.Command{ Name: "test", Configure: func(definition *console.Definition) { definition.AddArgument(parameters.NewStringValue(a), "STRINGARG", "") definition.AddOption(parameters.NewIntValue(b), "--int-opt=VALUE", "") }, Execute: func(input *console.Input, output *console.Output) error { output.Printf("STRINGARG = %s", *a) output.Printf("--int-opt = %v", *b) return nil }, } } t.Run("Run()", func(t *testing.T) { t.Run("should return exit code 2 if no command was asked for", func(t *testing.T) { writer := bytes.Buffer{} application := createApplication(&writer) code := application.Run([]string{}) assert.Equal(t, 100, code) }) t.Run("should return exit code 2 if no command was found", func(t *testing.T) { writer := bytes.Buffer{} application := createApplication(&writer) code := application.Run([]string{"foo"}) assert.Equal(t, 100, code) }) t.Run("should return exit code 100 if the help flag is set", func(t *testing.T) { writer := bytes.Buffer{} application := createApplication(&writer) code := application.Run([]string{"--help"}) assert.Equal(t, 100, code) }) t.Run("should show application help if the help flag is set", func(t *testing.T) { writer := bytes.Buffer{} application := createApplication(&writer) application.Run([]string{"--help"}) output := writer.String() containsUsage := strings.Contains(output, "USAGE:") containsArguments := strings.Contains(output, "ARGUMENTS:") containsOptions := strings.Contains(output, "OPTIONS:") containsHelp := containsUsage && containsOptions && !containsArguments assert.True(t, containsHelp, "Expected help output.") }) t.Run("should show command help if the help flag is set when running a command", func(t *testing.T) { var a string var b int writer := bytes.Buffer{} application := createApplication(&writer) application.AddCommand(createTestCommand(&a, &b)) application.Run([]string{"test", "--help"}) output := writer.String() containsUsage := strings.Contains(output, "USAGE:") containsArguments := strings.Contains(output, "ARGUMENTS:") containsOptions := strings.Contains(output, "OPTIONS:") containsHelp := containsUsage && containsOptions && containsArguments assert.True(t, containsHelp, "Expected help output.") }) t.Run("should return exit code 0 if a command was found, and ran OK", func(t *testing.T) { var a string var b int writer := bytes.Buffer{} application := createApplication(&writer) application.AddCommand(createTestCommand(&a, &b)) code := application.Run([]string{"test", "aval", "--int-opt=384"}) assert.Equal(t, 0, code) }) t.Run("should return exit code 101 if mapping input fails", func(t *testing.T) { var a string var b int writer := bytes.Buffer{} application := createApplication(&writer) application.AddCommand(createTestCommand(&a, &b)) code := application.Run([]string{"test", "aval", "--int-opt=hello"}) assert.Equal(t, 101, code) }) t.Run("should return exit code 102 if the command execution fails", func(t *testing.T) { writer := bytes.Buffer{} application := createApplication(&writer) application.AddCommand(console.Command{ Name: "test", Execute: func(input *console.Input, output *console.Output) error { return errors.New("Testing errors") }, }) code := application.Run([]string{"test", "aval", "--int-opt=hello"}) assert.Equal(t, 102, code) }) t.Run("should configure the application definition", func(t *testing.T) { var a string var b int var foo string writer := bytes.Buffer{} application := createApplication(&writer) application.Configure = func(definition *console.Definition) { definition.AddOption(parameters.NewStringValue(&foo), "--foo=FOO", "") } application.AddCommand(createTestCommand(&a, &b)) application.Run([]string{"test", "aval", "--foo=bar"}) assert.Equal(t, "bar", foo) }) }) t.Run("AddCommands()", func(t *testing.T) { t.Run("should work when adding 1 command", func(t *testing.T) { writer := bytes.Buffer{} application := createApplication(&writer) assert.Equal(t, 0, len(application.Commands)) application.AddCommands([]console.Command{ { Name: "test1", }, }) assert.Equal(t, 1, len(application.Commands)) }) t.Run("should work when adding no commands", func(t *testing.T) { writer := bytes.Buffer{} application := createApplication(&writer) assert.Equal(t, 0, len(application.Commands)) application.AddCommands([]console.Command{}) assert.Equal(t, 0, len(application.Commands)) }) t.Run("should work when adding more than 1 command", func(t *testing.T) { writer := bytes.Buffer{} application := createApplication(&writer) assert.Equal(t, 0, len(application.Commands)) application.AddCommands([]console.Command{ { Name: "test1", }, { Name: "test2", }, { Name: "test3", }, }) assert.Equal(t, 3, len(application.Commands)) }) }) t.Run("AddCommand()", func(t *testing.T) { writer := bytes.Buffer{} application := createApplication(&writer) assert.Equal(t, 0, len(application.Commands)) application.AddCommand(console.Command{ Name: "test1", }) assert.Equal(t, 1, len(application.Commands)) }) }
func TestDefinition(t *testing.T) { t.Run("Arguments()", func(t *testing.T) { t.Run("should return an empty slice if no arguments have been added", func(t *testing.T) { definition := console.NewDefinition() assert.True(t, len(definition.Arguments()) == 0, "Arguments() length should be 0") }) t.Run("should return an ordered slice of arguments", func(t *testing.T) { var s1 string var s2 string var s3 string definition := console.NewDefinition() definition.AddArgument(parameters.NewStringValue(&s1), "S1", "") definition.AddArgument(parameters.NewStringValue(&s2), "S2", "") definition.AddArgument(parameters.NewStringValue(&s3), "S3", "") arguments := definition.Arguments() assert.True(t, len(arguments) == 3, "Arguments() length should be 3") assert.Equal(t, "S1", arguments[0].Name) assert.Equal(t, "S2", arguments[1].Name) assert.Equal(t, "S3", arguments[2].Name) }) }) t.Run("Options()", func(t *testing.T) { t.Run("should return an empty slice if no options have been added", func(t *testing.T) { definition := console.NewDefinition() assert.True(t, len(definition.Options()) == 0, "Options() length should be 0") }) t.Run("should return a slice of options", func(t *testing.T) { var s1 string var s2 string var s3 string definition := console.NewDefinition() definition.AddOption(parameters.NewStringValue(&s1), "--s1", "") definition.AddOption(parameters.NewStringValue(&s2), "--s2", "") definition.AddOption(parameters.NewStringValue(&s3), "--s3", "") options := definition.Options() assert.Equal(t, 3, len(options)) }) }) t.Run("AddArgument()", func(t *testing.T) { t.Run("should error if an invalid option specification is given", func(t *testing.T) { defer func() { r := recover() assert.False(t, r == nil, "We should be recovering from a panic.") }() var s1 string definition := console.NewDefinition() definition.AddArgument(parameters.NewStringValue(&s1), "!!! S1", "") }) t.Run("should error if an argument with the same name exists", func(t *testing.T) { defer func() { r := recover() assert.False(t, r == nil, "We should be recovering from a panic.") }() var s1 string var s2 string definition := console.NewDefinition() definition.AddArgument(parameters.NewStringValue(&s1), "S1", "") definition.AddArgument(parameters.NewStringValue(&s2), "S1", "") }) t.Run("should add an argument", func(t *testing.T) { var s1 string definition := console.NewDefinition() assert.Equal(t, 0, len(definition.Arguments())) definition.AddArgument(parameters.NewStringValue(&s1), "S1", "") assert.Equal(t, 1, len(definition.Arguments())) }) }) t.Run("AddOption()", func(t *testing.T) { t.Run("should error if an invalid option specification is given", func(t *testing.T) { defer func() { r := recover() assert.False(t, r == nil, "We should be recovering from a panic.") }() var s1 string definition := console.NewDefinition() definition.AddOption(parameters.NewStringValue(&s1), "!!! S1", "") }) t.Run("should error if an option with the same name exists", func(t *testing.T) { defer func() { r := recover() assert.False(t, r == nil, "We should be recovering from a panic.") }() var s1 string var s2 string definition := console.NewDefinition() definition.AddOption(parameters.NewStringValue(&s1), "--s1", "") definition.AddOption(parameters.NewStringValue(&s2), "--s1", "") }) t.Run("should add an option", func(t *testing.T) { var s1 string definition := console.NewDefinition() assert.Equal(t, 0, len(definition.Options())) definition.AddOption(parameters.NewStringValue(&s1), "--s1", "") assert.Equal(t, 1, len(definition.Options())) }) }) }