fix(librarian): subcommands now process args correctly (#1826)

Fixes: #1819

Author: codyoss

internal/librarian/librarian.go

@@ -55,12 +55,11 @@ func Run(ctx context.Context, arg ...string) error {
 		CmdLibrarian.Flags.Usage()
 		return fmt.Errorf("command not specified")
 	}
-	cmd, err := CmdLibrarian.Lookup(arg[0])
+	cmd, arg, err := lookupCommand(CmdLibrarian, arg)
 	if err != nil {
-		CmdLibrarian.Flags.Usage()
 		return err
 	}
-	if err := cmd.Parse(arg[1:]); err != nil {
+	if err := cmd.Parse(arg); err != nil {
 		// We expect that if cmd.Parse fails, it will already
 		// have printed out a command-specific usage error,
 		// so we don't need to display the general usage.
@@ -76,6 +75,24 @@ func Run(ctx context.Context, arg ...string) error {
 	return cmd.Run(ctx, cmd.Config)
 }
 
+// lookupCommand recursively looks up the command specified by the given arguments.
+// It returns the command, the remaining arguments, and an error if the command
+// is not found.
+func lookupCommand(cmd *cli.Command, args []string) (*cli.Command, []string, error) {
+	if len(args) == 0 {
+		return cmd, nil, nil
+	}
+	subcommand, err := cmd.Lookup(args[0])
+	if err != nil {
+		cmd.Flags.Usage()
+		return nil, nil, err
+	}
+	if len(subcommand.Commands) > 0 {
+		return lookupCommand(subcommand, args[1:])
+	}
+	return subcommand, args[1:], nil
+}
+
 // GitHubClient is an abstraction over the GitHub client.
 type GitHubClient interface {
 	GetRawContent(ctx context.Context, path, ref string) ([]byte, error)

internal/librarian/librarian_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/go-git/go-git/v5"
 	"github.com/go-git/go-git/v5/plumbing/object"
 
+	"github.com/googleapis/librarian/internal/cli"
 	"github.com/googleapis/librarian/internal/config"
 	"github.com/googleapis/librarian/internal/gitrepo"
 	"gopkg.in/yaml.v3"
@@ -239,3 +240,113 @@ type pathAndMessage struct {
 	path    string
 	message string
 }
+
+func TestLookupCommand(t *testing.T) {
+	sub1sub1 := &cli.Command{
+		Short:     "sub1sub1 does something",
+		UsageLine: "sub1sub1",
+		Long:      "sub1sub1 does something",
+	}
+	sub1 := &cli.Command{
+		Short:     "sub1 does something",
+		UsageLine: "sub1",
+		Long:      "sub1 does something",
+		Commands:  []*cli.Command{sub1sub1},
+	}
+	sub2 := &cli.Command{
+		Short:     "sub2 does something",
+		UsageLine: "sub2",
+		Long:      "sub2 does something",
+	}
+	root := &cli.Command{
+		Short:     "root does something",
+		UsageLine: "root",
+		Long:      "root does something",
+		Commands: []*cli.Command{
+			sub1,
+			sub2,
+		},
+	}
+	root.Init()
+	sub1.Init()
+	sub2.Init()
+	sub1sub1.Init()
+
+	testCases := []struct {
+		name     string
+		cmd      *cli.Command
+		args     []string
+		wantCmd  *cli.Command
+		wantArgs []string
+		wantErr  bool
+	}{
+		{
+			name:    "no args",
+			cmd:     root,
+			args:    []string{},
+			wantCmd: root,
+		},
+		{
+			name:    "find sub1",
+			cmd:     root,
+			args:    []string{"sub1"},
+			wantCmd: sub1,
+		},
+		{
+			name:     "find sub2",
+			cmd:      root,
+			args:     []string{"sub2"},
+			wantCmd:  sub2,
+			wantArgs: []string{},
+		},
+		{
+			name:     "find sub1sub1",
+			cmd:      root,
+			args:     []string{"sub1", "sub1sub1"},
+			wantCmd:  sub1sub1,
+			wantArgs: []string{},
+		},
+		{
+			name:     "find sub1sub1 with args",
+			cmd:      root,
+			args:     []string{"sub1", "sub1sub1", "arg1"},
+			wantCmd:  sub1sub1,
+			wantArgs: []string{"arg1"},
+		},
+		{
+			name:    "unknown command",
+			cmd:     root,
+			args:    []string{"unknown"},
+			wantErr: true,
+		},
+		{
+			name:    "unknown subcommand",
+			cmd:     root,
+			args:    []string{"sub1", "unknown"},
+			wantErr: true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			gotCmd, gotArgs, err := lookupCommand(tc.cmd, tc.args)
+			if (err != nil) != tc.wantErr {
+				t.Errorf("lookupCommand() error = %v, wantErr %v", err, tc.wantErr)
+				return
+			}
+			if gotCmd != tc.wantCmd {
+				var gotName, wantName string
+				if gotCmd != nil {
+					gotName = gotCmd.Name()
+				}
+				if tc.wantCmd != nil {
+					wantName = tc.wantCmd.Name()
+				}
+				t.Errorf("lookupCommand() gotCmd.Name() = %q, want %q", gotName, wantName)
+			}
+			if diff := cmp.Diff(tc.wantArgs, gotArgs); diff != "" {
+				t.Errorf("lookupCommand() args mismatch (-want +got):\n%s", diff)
+			}
+		})
+	}
+}

internal/librarian/release.go

@@ -27,7 +27,7 @@ var cmdRelease = &cli.Command{
 
 func init() {
 	cmdRelease.Init()
-	CmdLibrarian.Commands = append(CmdLibrarian.Commands,
+	cmdRelease.Commands = append(cmdRelease.Commands,
 		cmdInit,
 		cmdTagAndRelease,
 	)