test: add test cases for running root command

internal/cmd/interactive.go

@@ -19,11 +19,11 @@ func (c *Interactive) Run(ctx context.Context, command string, params []string)
 	switch command {
 	case "h", "?", "help":
 		err = c.help(ctx, params)
-	case "qstat", "qstats":
+	case "qstat":
 		err = c.qstat(ctx, params)
 	case "dlq":
 		err = c.dlq(ctx, params)
-	case "enqueue-test", "et":
+	case "enqueue-test":
 		err = c.enqueueTest(ctx, params)
 	case "purge":
 		err = c.purge(ctx, params)
@@ -33,7 +33,7 @@ func (c *Interactive) Run(ctx context.Context, command string, params []string)
 		err = c.receive(ctx, params)
 	case "id":
 		err = c.id(ctx, params)
-	case "sys", "system":
+	case "system":
 		err = c.system(ctx, params)
 	case "data":
 		err = c.data(ctx, params)

internal/cmd/root.go

@@ -4,6 +4,7 @@ import (
 	"bufio"
 	"context"
 	"fmt"
+	"io"
 	"os"
 	"strings"
 
@@ -15,10 +16,12 @@ import (
 
 type CommandFactory struct {
 	CreateDynamoMQClient func(ctx context.Context, flags *Flags) (dynamomq.Client[any], aws.Config, error)
+	Stdin                io.Reader
 }
 
 var defaultCommandFactory = CommandFactory{
 	CreateDynamoMQClient: createDynamoMQClient[any],
+	Stdin:                os.Stdin,
 }
 
 var root = defaultCommandFactory.CreateRootCommand(flgs)
@@ -45,7 +48,7 @@ func (f CommandFactory) CreateRootCommand(flgs *Flags) *cobra.Command {
 			fmt.Println("")
 
 			ctx := context.Background()
-			client, cfg, err := createDynamoMQClient[any](ctx, flgs)
+			client, cfg, err := f.CreateDynamoMQClient(ctx, flgs)
 			if err != nil {
 				return fmt.Errorf("... %v\n", err)
 			}
@@ -63,7 +66,7 @@ func (f CommandFactory) CreateRootCommand(flgs *Flags) *cobra.Command {
 			}
 
 			// 1. Create a Scanner using the InputStream available.
-			scanner := bufio.NewScanner(os.Stdin)
+			scanner := bufio.NewScanner(f.Stdin)
 
 			for {
 				// 2. Don't forget to prompt the user
@@ -84,12 +87,13 @@ func (f CommandFactory) CreateRootCommand(flgs *Flags) *cobra.Command {
 					continue
 				}
 
+				var quit bool
 				command, params := parseInput(input)
 				switch command {
 				case "":
 					continue
 				case "quit", "q":
-					return nil
+					quit = true
 				default:
 					// 4. Now, you can do anything with the input string that you need to.
 					// Like, output it to the user.
@@ -98,6 +102,9 @@ func (f CommandFactory) CreateRootCommand(flgs *Flags) *cobra.Command {
 						printError(err)
 					}
 				}
+				if quit {
+					break
+				}
 			}
 			return nil
 		},

internal/cmd/root_test.go

@@ -3,6 +3,8 @@ package cmd_test
 import (
 	"context"
 	"errors"
+	"io"
+	"strings"
 	"testing"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
@@ -13,6 +15,70 @@ import (
 	"github.com/vvatanabe/dynamomq/internal/test"
 )
 
+func TestRunRootCommand(t *testing.T) {
+	type testCase struct {
+		name                 string
+		createDynamoMQClient func(ctx context.Context, flags *cmd.Flags) (dynamomq.Client[any], aws.Config, error)
+		command              io.Reader
+		wantErr              bool
+	}
+	tests := []testCase{
+		{
+			name: "should return error when create dynamomq client failed",
+			createDynamoMQClient: func(ctx context.Context, flags *cmd.Flags) (dynamomq.Client[any], aws.Config, error) {
+				return nil, aws.Config{}, test.ErrorTest
+			},
+			wantErr: true,
+		},
+		{
+			name: "should return nil when send quit command",
+			createDynamoMQClient: func(ctx context.Context, flags *cmd.Flags) (dynamomq.Client[any], aws.Config, error) {
+				return &mock.Client[any]{}, aws.Config{}, nil
+			},
+			command: strings.NewReader("quit\n"),
+		},
+		{
+			name: "should return nil when send whitespace",
+			createDynamoMQClient: func(ctx context.Context, flags *cmd.Flags) (dynamomq.Client[any], aws.Config, error) {
+				return &mock.Client[any]{}, aws.Config{}, nil
+			},
+			command: strings.NewReader(" \n"),
+		},
+		{
+			name: "should return nil when send empty string",
+			createDynamoMQClient: func(ctx context.Context, flags *cmd.Flags) (dynamomq.Client[any], aws.Config, error) {
+				return &mock.Client[any]{}, aws.Config{}, nil
+			},
+			command: strings.NewReader("\n"),
+		},
+		{
+			name: "should return nil when send unknown command",
+			createDynamoMQClient: func(ctx context.Context, flags *cmd.Flags) (dynamomq.Client[any], aws.Config, error) {
+				return &mock.Client[any]{}, aws.Config{}, nil
+			},
+			command: strings.NewReader("foo\n"),
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f := cmd.CommandFactory{
+				CreateDynamoMQClient: tt.createDynamoMQClient,
+				Stdin:                tt.command,
+			}
+			err := f.CreateRootCommand(&cmd.Flags{}).RunE(&cobra.Command{}, []string{})
+			if tt.wantErr {
+				if err == nil {
+					t.Error("RunE() error should not nil")
+				}
+				return
+			}
+			if err != nil {
+				t.Errorf("RunE() error = %v", err)
+			}
+		})
+	}
+}
+
 func testRunAllCommand(t *testing.T, f cmd.CommandFactory, wantErr error) {
 	type testCase struct {
 		name string