feat(internal/librarian): add -f flag to skip binary version check (#3806)

At the moment, it isn't possible to test librarian using a different
version than is in the librarian.yaml, because the tool always checks if
the binary and librarian.yaml versions match.

The -f flag is added which skips this check.

Fixes #3800

Author: julieqiu

internal/librarian/add.go

@@ -46,7 +46,7 @@ func addCommand() *cli.Command {
 			if len(apis) == 0 {
 				return errMissingAPI
 			}
-			cfg, err := loadConfig()
+			cfg, err := loadConfig(ctx)
 			if err != nil {
 				return err
 			}

internal/librarian/bump.go

@@ -92,7 +92,7 @@ Examples:
 			if all && versionOverride != "" {
 				return errBothVersionAndAllFlag
 			}
-			cfg, err := loadConfig()
+			cfg, err := loadConfig(ctx)
 			if err != nil {
 				return err
 			}

internal/librarian/generate.go

@@ -65,7 +65,7 @@ func generateCommand() *cli.Command {
 			if all && libraryName != "" {
 				return errBothLibraryAndAllFlag
 			}
-			cfg, err := loadConfig()
+			cfg, err := loadConfig(ctx)
 			if err != nil {
 				return err
 			}

internal/librarian/librarian.go

@@ -28,6 +28,8 @@ import (
 // ErrLibraryNotFound is returned when the specified library is not found in config.
 var ErrLibraryNotFound = errors.New("library not found")
 
+type skipVersionCheckKey struct{}
+
 const (
 	librarianConfigPath = "librarian.yaml"
 	languageDart        = "dart"
@@ -43,6 +45,11 @@ func Run(ctx context.Context, args ...string) error {
 		Usage:     "manage Google Cloud client libraries",
 		UsageText: "librarian [command]",
 		Flags: []cli.Flag{
+			&cli.BoolFlag{
+				Name:    "force",
+				Aliases: []string{"f"},
+				Usage:   "skip binary version check",
+			},
 			&cli.BoolFlag{
 				Name:    "verbose",
 				Aliases: []string{"v"},
@@ -51,6 +58,7 @@ func Run(ctx context.Context, args ...string) error {
 		},
 		Before: func(ctx context.Context, cmd *cli.Command) (context.Context, error) {
 			command.Verbose = cmd.Bool("verbose")
+			ctx = context.WithValue(ctx, skipVersionCheckKey{}, cmd.Bool("force"))
 			return ctx, nil
 		},
 		Commands: []*cli.Command{

internal/librarian/publish.go

@@ -54,7 +54,7 @@ func publishCommand() *cli.Command {
 			},
 		},
 		Action: func(ctx context.Context, cmd *cli.Command) error {
-			cfg, err := loadConfig()
+			cfg, err := loadConfig(ctx)
 			if err != nil {
 				return err
 			}

internal/librarian/tidy.go

@@ -38,7 +38,7 @@ func tidyCommand() *cli.Command {
 		Usage:     "format and validate librarian.yaml",
 		UsageText: "librarian tidy [path]",
 		Action: func(ctx context.Context, cmd *cli.Command) error {
-			cfg, err := loadConfig()
+			cfg, err := loadConfig(ctx)
 			if err != nil {
 				return err
 			}

internal/librarian/update.go

@@ -78,7 +78,7 @@ func updateCommand() *cli.Command {
 					return fmt.Errorf("%w: %s", errUnknownSource, source)
 				}
 			}
-			cfg, err := loadConfig()
+			cfg, err := loadConfig(ctx)
 			if err != nil {
 				return err
 			}

internal/librarian/version.go

@@ -15,7 +15,9 @@
 package librarian
 
 import (
+	"context"
 	_ "embed"
+	"errors"
 	"fmt"
 	"runtime/debug"
 	"strings"
@@ -25,6 +27,11 @@ import (
 	"github.com/googleapis/librarian/internal/yaml"
 )
 
+var (
+	errNoConfigVersion = errors.New("librarian.yaml does not specify a version")
+	errVersionMismatch = errors.New("version mismatch")
+)
+
 //go:embed version.txt
 var versionString string
 
@@ -67,31 +74,34 @@ func version(info *debug.BuildInfo) string {
 // loadConfig reads librarian.yaml and verifies that the librarian binary
 // version matches the version specified in the configuration file. It returns
 // the config and an error if the versions do not match. The check is skipped
-// if the binary version is "not available", which occurs during local
-// development without VCS info.
-func loadConfig() (*config.Config, error) {
+// if the -f flag is set or if the binary version is "not available", which
+// occurs during local development without VCS info.
+func loadConfig(ctx context.Context) (*config.Config, error) {
 	cfg, err := yaml.Read[config.Config](librarianConfigPath)
 	if err != nil {
 		return nil, fmt.Errorf("%w: %w", errConfigNotFound, err)
 	}
-	if err := compareVersions(cfg.Version, Version()); err != nil {
-		return nil, err
+	if !skipVersionCheck(ctx) {
+		if err := compareVersions(cfg.Version, Version()); err != nil {
+			return nil, err
+		}
 	}
 	return cfg, nil
 }
 
 func compareVersions(configVersion, binaryVersion string) error {
 	if configVersion == "" {
-		return fmt.Errorf("librarian.yaml does not specify a version")
+		return errNoConfigVersion
 	}
 	// Skip check for local builds, which have no version info.
 	if binaryVersion == versionNotAvailable {
 		return nil
 	}
 	if configVersion != binaryVersion {
-		return fmt.Errorf(`binary version %s does not match librarian.yaml version %s
-	go run github.com/googleapis/librarian/cmd/librarian@%s`,
-			binaryVersion, configVersion, configVersion)
+		return fmt.Errorf(`%w: binary version %s does not match librarian.yaml version %s
+	go run github.com/googleapis/librarian/cmd/librarian@%s
+    or use -f to skip this check`,
+			errVersionMismatch, binaryVersion, configVersion, configVersion)
 	}
 	return nil
 }
@@ -134,3 +144,9 @@ func newPseudoVersion(info *debug.BuildInfo) string {
 	}
 	return buf.String()
 }
+
+// skipVersionCheck returns true if the -f flag was set to skip version checking.
+func skipVersionCheck(ctx context.Context) bool {
+	v, _ := ctx.Value(skipVersionCheckKey{}).(bool)
+	return v
+}

internal/librarian/version_test.go

@@ -15,6 +15,8 @@
 package librarian
 
 import (
+	"context"
+	"errors"
 	"fmt"
 	"runtime/debug"
 	"strings"
@@ -151,3 +153,79 @@ func TestNewPseudoVersion(t *testing.T) {
 		})
 	}
 }
+
+func TestCompareVersions(t *testing.T) {
+	for _, test := range []struct {
+		name          string
+		configVersion string
+		binaryVersion string
+		wantErr       error
+	}{
+		{
+			name:          "matching versions",
+			configVersion: "v1.0.0",
+			binaryVersion: "v1.0.0",
+		},
+		{
+			name:          "mismatched versions",
+			configVersion: "v1.0.0",
+			binaryVersion: "v2.0.0",
+			wantErr:       errVersionMismatch,
+		},
+		{
+			name:          "local build skips check",
+			configVersion: "v1.0.0",
+			binaryVersion: versionNotAvailable,
+		},
+		{
+			name:          "empty config version",
+			configVersion: "",
+			binaryVersion: "v1.0.0",
+			wantErr:       errNoConfigVersion,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			err := compareVersions(test.configVersion, test.binaryVersion)
+			if !errors.Is(err, test.wantErr) {
+				t.Errorf("got %v; want %v", err, test.wantErr)
+			}
+		})
+	}
+}
+
+func TestSkipVersionCheck(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		setKey bool
+		value  bool
+		want   bool
+	}{
+		{
+			name:   "key set to true",
+			setKey: true,
+			value:  true,
+			want:   true,
+		},
+		{
+			name:   "key set to false",
+			setKey: true,
+			value:  false,
+			want:   false,
+		},
+		{
+			name:   "key not set",
+			setKey: false,
+			want:   false,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			ctx := t.Context()
+			if test.setKey {
+				ctx = context.WithValue(ctx, skipVersionCheckKey{}, test.value)
+			}
+			if got := skipVersionCheck(ctx); got != test.want {
+				t.Errorf("got %v; want %v", got, test.want)
+			}
+		})
+	}
+}