chore: update release_test and publish_test to not use mocks (#3394)

Instead use the fakeLanguage flow for tests.

Fixes #3380

Author: ldetmer

internal/librarian/publish.go

@@ -27,11 +27,6 @@ import (
 	"github.com/urfave/cli/v3"
 )
 
-var (
-	rustPublishCrates  = sidekickrust.PublishCrates
-	rustCargoPreFlight = sidekickrust.CargoPreFlight
-)
-
 func publishCommand() *cli.Command {
 	return &cli.Command{
 		Name:      "publish",
@@ -82,7 +77,7 @@ func publish(ctx context.Context, cfg *config.Config, dryRun bool, skipSemverChe
 	case languageFake:
 		return fakePublish()
 	case languageRust:
-		return rustPublishCrates(ctx, rust.ToSidekickReleaseConfig(cfg.Release), dryRun, skipSemverChecks, lastTag, files)
+		return sidekickrust.PublishCrates(ctx, rust.ToSidekickReleaseConfig(cfg.Release), dryRun, skipSemverChecks, lastTag, files)
 	default:
 		return fmt.Errorf("publish not implemented for %q", cfg.Language)
 	}
@@ -104,7 +99,7 @@ func verifyRequiredTools(ctx context.Context, language string, cfg *config.Relea
 	case languageFake:
 		return nil
 	case languageRust:
-		if err := rustCargoPreFlight(ctx, rust.ToSidekickReleaseConfig(cfg)); err != nil {
+		if err := sidekickrust.CargoPreFlight(ctx, rust.ToSidekickReleaseConfig(cfg)); err != nil {
 			return err
 		}
 	default:

internal/librarian/release.go

@@ -33,11 +33,6 @@ var (
 	errReleaseConfigEmpty    = errors.New("librarian Release.Config field empty")
 )
 
-var (
-	rustReleaseLibrary       = rust.ReleaseLibrary
-	librarianGenerateLibrary = runGenerate
-)
-
 func releaseCommand() *cli.Command {
 	return &cli.Command{
 		Name:      "release",
@@ -147,10 +142,10 @@ func releaseLibrary(ctx context.Context, cfg *config.Config, libConfig *config.L
 	case languageFake:
 		return fakeReleaseLibrary(libConfig)
 	case languageRust:
-		if err := rustReleaseLibrary(libConfig, srcPath); err != nil {
+		if err := rust.ReleaseLibrary(libConfig, srcPath); err != nil {
 			return err
 		}
-		if err := librarianGenerateLibrary(ctx, false, libConfig.Name); err != nil {
+		if err := runGenerate(ctx, false, libConfig.Name); err != nil {
 			return err
 		}
 		return nil

internal/librarian/release_test.go

@@ -15,7 +15,6 @@
 package librarian
 
 import (
-	"context"
 	"errors"
 	"path/filepath"
 	"testing"
@@ -224,52 +223,24 @@ func TestLibraryByName(t *testing.T) {
 	}
 }
 
-func TestReleaseRust(t *testing.T) {
-	origRustReleaseLibrary := rustReleaseLibrary
-	origLibrarianGenerateLibrary := librarianGenerateLibrary
-
-	defer func() {
-		rustReleaseLibrary = origRustReleaseLibrary
-		librarianGenerateLibrary = origLibrarianGenerateLibrary
-	}()
+func TestRelease(t *testing.T) {
 
 	tests := []struct {
-		name               string
-		srcPath            string
-		releaseError       error
-		generateError      error
-		wantReleaseCalled  bool
-		wantGenerateCalled bool
-		wantErr            bool
+		name    string
+		srcPath string
+		version string
 	}{
 		{
-			name:               "library released",
-			srcPath:            "src/storage",
-			wantReleaseCalled:  true,
-			wantGenerateCalled: true,
-		},
-		{
-			name:               "generate error",
-			srcPath:            "src/storage",
-			wantReleaseCalled:  true,
-			wantGenerateCalled: true,
-			generateError:      errors.New("generate error"),
-			wantErr:            true,
-		},
-		{
-			name:               "rust release error",
-			srcPath:            "src/storage",
-			wantReleaseCalled:  true,
-			wantGenerateCalled: false,
-			releaseError:       errors.New("release error"),
-			wantErr:            true,
+			name:    "library released",
+			srcPath: "src/storage",
+			version: "1.2.3",
 		},
 	}
 	testhelper.RequireCommand(t, "git")
-	remoteDir := testhelper.SetupRepoWithChange(t, "v1.0.0")
+	remoteDir := testhelper.SetupRepoWithChange(t, "v1.2.2")
 	testhelper.CloneRepository(t, remoteDir)
 	cfg := &config.Config{
-		Language: languageRust,
+		Language: languageFake,
 		Release: &config.Release{
 			Remote: "origin",
 			Branch: "main",
@@ -278,37 +249,13 @@ func TestReleaseRust(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			var (
-				generateCalled bool
-				releaseCalled  bool
-			)
-			rustReleaseLibrary = func(library *config.Library, srcPath string) error {
-				releaseCalled = true
-				return test.releaseError
-			}
-			librarianGenerateLibrary = func(ctx context.Context, all bool, libraryName string) error {
-				generateCalled = true
-				return test.generateError
-			}
 			libConfg := &config.Library{}
 			err := releaseLibrary(t.Context(), cfg, libConfg, test.srcPath)
-
-			if (err != nil) != test.wantErr {
-				t.Fatalf("releaseLibrary() error = %v, wantErr %v", err, test.wantErr)
-			}
-			if releaseCalled != test.wantReleaseCalled {
-				t.Errorf("releaseCalled = %v, want %v", releaseCalled, test.wantReleaseCalled)
-			}
-			if generateCalled != test.wantGenerateCalled {
-				t.Errorf("generateCalled = %v, want %v", generateCalled, test.wantGenerateCalled)
-			}
-			if test.releaseError != nil && test.releaseError != err {
-				t.Errorf("releaseError= %v, want %v", err, test.releaseError)
-
+			if err != nil {
+				t.Fatalf("releaseLibrary() error = %v", err)
 			}
-			if test.generateError != nil && test.generateError != err {
-				t.Errorf("generateError= %v, want %v", err, test.generateError)
-
+			if libConfg.Version != test.version {
+				t.Errorf("library %q version mismatch: want %q, got %q", libConfg.Name, test.version, libConfg.Version)
 			}
 		})