feat: in verbose mode have mock print all output

internal/app/azldev/app.go

@@ -267,7 +267,7 @@ func (a *App) Execute(args []string) int {
 	//
 	stdioLogger := a.initStdioLogging()
 
-	if err := setEventListener(stdioLogger, a.quiet, envOptions); err != nil {
+	if err := setEventListener(stdioLogger, a.quiet, a.verbose, envOptions); err != nil {
 		slog.Error("Error setting event listener.", "err", err)
 
 		return 1
@@ -384,7 +384,7 @@ func (a *App) reInitLoggingWithLogFile(envOptions *EnvOptions) error {
 		return fmt.Errorf("error re-initializing file logging:\n%w", err)
 	}
 
-	err = setEventListener(logger, a.quiet, envOptions)
+	err = setEventListener(logger, a.quiet, a.verbose, envOptions)
 	if err != nil {
 		return fmt.Errorf("error re-setting event listener:\n%w", err)
 	}
@@ -448,8 +448,8 @@ func (a *App) handlePostInitCallbacks(env *Env) error {
 	return nil
 }
 
-func setEventListener(stdioLogger *slog.Logger, quiet bool, envOptions *EnvOptions) error {
-	eventListener, err := NewEventListener(stdioLogger, quiet)
+func setEventListener(stdioLogger *slog.Logger, quiet, verbose bool, envOptions *EnvOptions) error {
+	eventListener, err := NewEventListener(stdioLogger, quiet, verbose)
 	if err != nil {
 		return fmt.Errorf("error initializing event listener:\n%w", err)
 	}

internal/app/azldev/core/testutils/testenv.go

@@ -98,7 +98,7 @@ func setUpEventListener(t *testing.T, testEnv *TestEnv) {
 
 	testLogHandler := slogassert.New(t, slog.LevelDebug, nil)
 	testEventLogger := slog.New(testLogHandler)
-	testEventListener, err := azldev.NewEventListener(testEventLogger, false)
+	testEventListener, err := azldev.NewEventListener(testEventLogger, false, false)
 	require.NoError(t, err)
 
 	testEnv.EventListener = testEventListener

internal/app/azldev/event.go

@@ -19,6 +19,7 @@ type event struct {
 	name                string
 	spinner             *spinner.Spinner
 	quiet               bool
+	verbose             bool
 
 	lastReportedCompletionRatio float64
 
@@ -50,7 +51,9 @@ func (e *event) End() {
 }
 
 func (e *event) SetLongRunning(longRunningText string) {
-	if e.quiet {
+	// Skip the indeterminate spinner when quiet (no UI) or verbose (the command streams its own
+	// output live, and a spinner would fight with that output).
+	if e.quiet || e.verbose {
 		return
 	}
 

internal/app/azldev/event_test.go

@@ -55,3 +55,16 @@ func TestEvent_QuietModeSkipsLongRunningAndProgressRendering(t *testing.T) {
 	assert.False(t, testEvent.initializedProgressBar)
 	assert.Zero(t, testEvent.lastReportedCompletionRatio)
 }
+
+func TestEvent_VerboseModeSkipsLongRunningSpinner(t *testing.T) {
+	testEvent := &event{
+		verbose: true,
+	}
+
+	stderrOutput := captureStderr(t, func() {
+		testEvent.SetLongRunning("working")
+	})
+
+	assert.Empty(t, stderrOutput)
+	assert.Nil(t, testEvent.spinner)
+}

internal/app/azldev/eventlistener.go

@@ -17,13 +17,14 @@ type appEventListener struct {
 	eventLevel  int
 	eventLogger *slog.Logger
 	quiet       bool
+	verbose     bool
 }
 
 // Ensure [appEventListener] implements [opctx.EventListener].
 var _ opctx.EventListener = &appEventListener{}
 
 // NewEventListener creates a new event listener for the environment.
-func NewEventListener(eventLogger *slog.Logger, quiet bool) (*appEventListener, error) {
+func NewEventListener(eventLogger *slog.Logger, quiet, verbose bool) (*appEventListener, error) {
 	if eventLogger == nil {
 		return nil, errors.New("event logger cannot be nil")
 	}
@@ -32,6 +33,7 @@ func NewEventListener(eventLogger *slog.Logger, quiet bool) (*appEventListener,
 		eventLevel:  0,
 		eventLogger: eventLogger,
 		quiet:       quiet,
+		verbose:     verbose,
 	}, nil
 }
 
@@ -57,6 +59,7 @@ func (el *appEventListener) StartEvent(name string, args ...any) opctx.Event {
 		parentEventListener: el,
 		name:                name,
 		quiet:               el.quiet,
+		verbose:             el.verbose,
 	}
 }
 

internal/rpm/mock/mock.go

@@ -242,9 +242,7 @@ func (r *Runner) InitRoot(ctx context.Context) (err error) {
 		return fmt.Errorf("failed to create external command for mock:\n%w", err)
 	}
 
-	if !r.verbose {
-		extcmd.SetLongRunning("Waiting for mock (initializing build root)...")
-	}
+	extcmd.SetLongRunning("Waiting for mock (initializing build root)...")
 
 	err = extcmd.Run(ctx)
 	if err != nil {
@@ -359,9 +357,7 @@ func (r *Runner) BuildSRPM(
 		return fmt.Errorf("failed to create external command for mock:\n%w", err)
 	}
 
-	if !r.verbose {
-		extcmd.SetLongRunning("Waiting for mock (building SRPM)...")
-	}
+	extcmd.SetLongRunning("Waiting for mock (building SRPM)...")
 
 	// Watch output logs in real-time so we can asynchronously synthesize progress updates.
 	err = addMockCmdListeners(r.eventListener, extcmd, outputDirPath)
@@ -644,7 +640,10 @@ func (r *Runner) ScrubRoot(ctx context.Context) error {
 }
 
 func (r *Runner) getBaseArgs() (args []string) {
-	if !r.verbose {
+	if r.verbose {
+		// Have mock stream its full build output (including build.log) live to the console.
+		args = append(args, "--verbose")
+	} else {
 		args = append(args, "--quiet")
 	}
 

internal/rpm/mock/mock_test.go

@@ -203,6 +203,52 @@ func TestBuildRPM(t *testing.T) {
 	assert.Contains(t, mockCmd, fmt.Sprintf("--define %s %s", macroName, macroValue))
 }
 
+func TestBuildRPM_VerboseArgs(t *testing.T) {
+	t.Run("NonVerbose", func(t *testing.T) {
+		ctx := newTestCtxWithMockPrereqsPresent()
+		ctx.VerboseValue = false
+
+		mockCmd := captureBuildRPMCmd(t, ctx)
+
+		// Non-verbose runs should ask mock to be quiet and must not pass --verbose.
+		assert.Contains(t, mockCmd, "--quiet")
+		assert.NotContains(t, mockCmd, "--verbose")
+	})
+
+	t.Run("Verbose", func(t *testing.T) {
+		ctx := newTestCtxWithMockPrereqsPresent()
+		ctx.VerboseValue = true
+
+		mockCmd := captureBuildRPMCmd(t, ctx)
+
+		// Verbose runs should pass --verbose so mock streams its full output, and must not be quiet.
+		assert.Contains(t, mockCmd, "--verbose")
+		assert.NotContains(t, mockCmd, "--quiet")
+	})
+}
+
+// captureBuildRPMCmd runs a successful BuildRPM and returns the joined mock command line.
+func captureBuildRPMCmd(t *testing.T, ctx *testctx.TestCtx) string {
+	t.Helper()
+
+	var mockCmd string
+
+	ctx.CmdFactory.RunHandler = func(cmd *exec.Cmd) error {
+		mockCmd = strings.Join(cmd.Args, " ")
+
+		require.NoError(t, fileutils.WriteFile(ctx.FS(), testRPMPath, []byte{}, fileperms.PrivateFile))
+
+		return nil
+	}
+
+	runner := mock.NewRunner(ctx, testMockConfigPath)
+
+	err := runner.BuildRPM(ctx, testSRPMPath, testOutputDirPath, mock.RPMBuildOptions{})
+	require.NoError(t, err)
+
+	return mockCmd
+}
+
 func TestBuildRPM_MockFails(t *testing.T) {
 	testError := errors.New("injected mock failure")