feat(mock): enable overriding mock config options (#485)

Enables an escape-hatch for threading through custom mock config options (e.g., config_opts style) via the azldev component build command-line.

Author: reubeno

internal/app/azldev/cmds/component/build.go

@@ -31,6 +31,10 @@ type ComponentBuildOptions struct {
 
 	LocalRepoPaths           []string
 	LocalRepoWithPublishPath string
+
+	// MockConfigOpts is an optional set of key-value config options that will be passed through
+	// to mock as --config-opts key=value arguments.
+	MockConfigOpts map[string]string
 }
 
 // ComponentBuildResults summarizes the results of building a single component.
@@ -81,6 +85,8 @@ func NewBuildCmd() *cobra.Command {
 		"Paths to local repositories to include during build (can be specified multiple times)")
 	cmd.Flags().StringVar(&options.LocalRepoWithPublishPath, "local-repo-with-publish", "",
 		"Path to local repository to include during build and publish built RPMs to")
+	cmd.Flags().StringToStringVar(&options.MockConfigOpts, "mock-config-opt", nil,
+		"Pass a configuration option through to mock (key=value, can be specified multiple times)")
 
 	// Mark flags as mutually exclusive.
 	cmd.MarkFlagsMutuallyExclusive("srpm-only", "local-repo-with-publish")
@@ -163,7 +169,8 @@ func BuildComponent(
 
 	var buildEnv buildenv.RPMAwareBuildEnv
 
-	buildEnv, err = workdir.MkComponentBuildEnvironment(env, workDirFactory, component.GetConfig(), "build")
+	buildEnv, err = workdir.MkComponentBuildEnvironment(env, workDirFactory, component.GetConfig(), "build",
+		options.MockConfigOpts)
 	if err != nil {
 		return ComponentBuildResults{},
 			fmt.Errorf("failed to create build environment for component %q:\n%w", component.GetName(), err)

internal/app/azldev/cmds/component/build_test.go

@@ -20,6 +20,15 @@ func TestNewBuildCommand(t *testing.T) {
 	}
 }
 
+func TestNewBuildCommand_MockConfigOptFlag(t *testing.T) {
+	cmd := componentcmds.NewBuildCmd()
+
+	// Verify that the --mock-config-opt flag is registered and functional.
+	flag := cmd.Flags().Lookup("mock-config-opt")
+	require.NotNil(t, flag)
+	assert.Equal(t, "mock-config-opt", flag.Name)
+}
+
 func TestRunBuildCommand_NoComponents(t *testing.T) {
 	testEnv := testutils.NewTestEnv(t)
 

internal/app/azldev/core/specs/spec.go

@@ -83,7 +83,7 @@ func (s *componentSpec) Parse() (specInfo *ComponentSpecDetails, err error) {
 
 	// Create a working build environment so we can run rpmspec in the target distro's context
 	// (with all its macros, etc.).
-	buildEnv, err := workdir.MkComponentBuildEnvironment(s.env, workDirFactory, &s.componentConfig, "spec-parse")
+	buildEnv, err := workdir.MkComponentBuildEnvironment(s.env, workDirFactory, &s.componentConfig, "spec-parse", nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create build environment for component %q:\n%w", s.componentConfig.Name, err)
 	}

internal/app/azldev/core/workdir/workdir.go

@@ -81,6 +81,7 @@ func MkComponentBuildEnvironment(
 	factory *Factory,
 	component *projectconfig.ComponentConfig,
 	label string,
+	configOpts map[string]string,
 ) (buildEnv buildenv.RPMAwareBuildEnv, err error) {
 	// Create a work directory for us to place the environment under.
 	workDir, err := factory.Create(component.Name, label)
@@ -103,6 +104,7 @@ func MkComponentBuildEnvironment(
 			Dir:         buildEnvDir,
 			UserCreated: false,
 			Description: fmt.Sprintf("Build: %s (%s)", component.Name, label),
+			ConfigOpts:  configOpts,
 		},
 	)
 	if err != nil {

internal/buildenv/factory.go

@@ -34,4 +34,7 @@ type CreateOptions struct {
 	// Description optionally provides a human-readable description for the purpose of
 	// this environment.
 	Description string
+	// ConfigOpts is an optional set of key-value pairs that will be passed through to the
+	// underlying build environment backend as configuration overrides (e.g., mock's --config-opts).
+	ConfigOpts map[string]string
 }

internal/buildenv/mockroot.go

@@ -43,8 +43,14 @@ func (f *MockRootFactory) CreateRPMAwareEnv(options CreateOptions) (RPMAwareBuil
 // returns a [MockRoot] directly for callers that specifically want to interact with our concrete type.
 func (f *MockRootFactory) CreateMockRoot(options CreateOptions) (*MockRoot, error) {
 	// Create and configure a mock runner using the mock package.
+	runner := mock.NewRunner(f.ctx, f.mockConfigPath)
+
+	if len(options.ConfigOpts) > 0 {
+		runner.WithConfigOpts(options.ConfigOpts)
+	}
+
 	return &MockRoot{
-		mockRunner: mock.NewRunner(f.ctx, f.mockConfigPath),
+		mockRunner: runner,
 	}, nil
 }
 

internal/rpm/mock/mock.go

@@ -12,6 +12,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"sort"
 	"strings"
 
 	"github.com/brunoga/deep"
@@ -60,6 +61,10 @@ type Runner struct {
 	// rootDir is the directory where the mock root will be created. If not set, it defaults to
 	// being created under the baseDir.
 	rootDir string // optional
+
+	// configOpts is an optional set of key-value pairs that will be passed through to mock as
+	// --config-opts key=value arguments, allowing callers to override mock's configuration.
+	configOpts map[string]string
 }
 
 // BuildLogDetails encapsulates details extracted from mock build logs that may be relevant to
@@ -104,6 +109,7 @@ func (r *Runner) Clone() *Runner {
 		noPreClean:     r.noPreClean,
 		baseDir:        r.baseDir,
 		rootDir:        r.rootDir,
+		configOpts:     deep.MustCopy(r.configOpts),
 	}
 }
 
@@ -177,6 +183,19 @@ func (r *Runner) RootDir() string {
 	return r.rootDir
 }
 
+// WithConfigOpts updates the [Runner]'s configuration to set arbitrary config options that will
+// be passed through to mock as --config-opts key=value arguments.
+func (r *Runner) WithConfigOpts(opts map[string]string) *Runner {
+	r.configOpts = opts
+
+	return r
+}
+
+// ConfigOpts retrieves the set of arbitrary config options configured for this [Runner].
+func (r *Runner) ConfigOpts() map[string]string {
+	return r.configOpts
+}
+
 // Retrieves the path to the mock .cfg file used by this [Runner].
 func (r *Runner) ConfigPath() string {
 	return r.mockConfigPath
@@ -624,6 +643,21 @@ func (r *Runner) getBaseArgs() (args []string) {
 		args = append(args, "--rootdir", r.rootDir)
 	}
 
+	// Emit any caller-specified config overrides.
+	if len(r.configOpts) > 0 {
+		// Sort keys for deterministic output.
+		keys := make([]string, 0, len(r.configOpts))
+		for k := range r.configOpts {
+			keys = append(keys, k)
+		}
+
+		sort.Strings(keys)
+
+		for _, k := range keys {
+			args = append(args, "--config-opts", k+"="+r.configOpts[k])
+		}
+	}
+
 	if r.enableNetwork {
 		args = append(args, "--enable-network")
 	}

internal/rpm/mock/mock_test.go

@@ -64,6 +64,7 @@ func TestRunnerDefaults(t *testing.T) {
 	assert.False(t, runner.HasNoPreClean())
 	assert.Empty(t, runner.BaseDir())
 	assert.Empty(t, runner.RootDir())
+	assert.Empty(t, runner.ConfigOpts())
 }
 
 func TestClone(t *testing.T) {
@@ -83,6 +84,7 @@ func TestClone(t *testing.T) {
 	runner.WithRootDir(testRootDir)
 	runner.WithNoPreClean()
 	runner.EnableNetwork()
+	runner.WithConfigOpts(map[string]string{"cleanup_on_success": "True", "cleanup_on_failure": "False"})
 
 	clone := runner.Clone()
 
@@ -93,6 +95,7 @@ func TestClone(t *testing.T) {
 	assert.True(t, clone.HasNoPreClean())
 	assert.Equal(t, testBaseDir, clone.BaseDir())
 	assert.Equal(t, testRootDir, clone.RootDir())
+	assert.Equal(t, map[string]string{"cleanup_on_success": "True", "cleanup_on_failure": "False"}, clone.ConfigOpts())
 }
 
 func TestGetRootPath(t *testing.T) {
@@ -280,3 +283,49 @@ func TestCmdInChroot_EnableNetworking(t *testing.T) {
 	// Look for enable-network arg.
 	assert.Contains(t, cmd.GetArgs(), "--enable-network")
 }
+
+func TestCmdInChroot_ConfigOpts(t *testing.T) {
+	ctx := newTestCtxWithMockPrereqsPresent()
+
+	runner := mock.NewRunner(ctx, testMockConfigPath)
+	runner.WithConfigOpts(map[string]string{"cleanup_on_success": "True", "cleanup_on_failure": "False"})
+	assert.Equal(t, map[string]string{"cleanup_on_success": "True", "cleanup_on_failure": "False"}, runner.ConfigOpts())
+
+	cmd, err := runner.CmdInChroot(ctx, []string{"arg"}, false /*interactive*/)
+	require.NoError(t, err)
+	require.NotNil(t, cmd)
+
+	// Look for config-opts args (keys should be sorted deterministically).
+	cmdArgs := cmd.GetArgs()
+	assert.Contains(t, cmdArgs, "--config-opts")
+	assert.Contains(t, cmdArgs, "cleanup_on_failure=False")
+	assert.Contains(t, cmdArgs, "cleanup_on_success=True")
+}
+
+func TestBuildRPM_WithConfigOpts(t *testing.T) {
+	ctx := newTestCtxWithMockPrereqsPresent()
+	executedCmds := []string{}
+
+	ctx.CmdFactory.RunHandler = func(cmd *exec.Cmd) error {
+		executedCmds = append(executedCmds, strings.Join(cmd.Args, " "))
+
+		require.NoError(t, fileutils.WriteFile(ctx.FS(), testRPMPath, []byte{}, fileperms.PrivateFile))
+
+		return nil
+	}
+
+	runner := mock.NewRunner(ctx, testMockConfigPath)
+	runner.WithConfigOpts(map[string]string{"cleanup_on_success": "True"})
+
+	mockOptions := mock.RPMBuildOptions{}
+
+	err := runner.BuildRPM(ctx, testSRPMPath, testOutputDirPath, mockOptions)
+	require.NoError(t, err)
+
+	// Confirm that mock was invoked once.
+	assert.Len(t, executedCmds, 1)
+
+	// Confirm the config-opts flag was passed through.
+	mockCmd := executedCmds[0]
+	assert.Contains(t, mockCmd, "--config-opts cleanup_on_success=True")
+}