refactor: move defaultconfigs -> test only (#398)

* Moved distro configuration files from `defaultconfigs/content/` to `scenario/testdata/defaultconfigs/`
* Updated test infrastructure to optionally include test default configs via opt-in
* Modified all scenario build tests to use the new test default configs

Author: reubeno

defaultconfigs/content/defaults.toml

@@ -1,8 +1,2 @@
-# Include distro config.
-includes = ["distros/**/*.distro.toml"]
-
-[project]
-default-distro = { name = "azurelinux", version = "3.0" }
-
 [tools.imageCustomizer]
 containerTag = "mcr.microsoft.com/azurelinux/imagecustomizer:0.18.0"

scenario/component_build_test.go

@@ -29,11 +29,15 @@ func TestBuildingLocalComponent(t *testing.T) {
 	}
 
 	// Create a simple project with a simple noarch spec.
+	// Include test default configs to get distro and mock configurations.
 	spec := projecttest.NewSpec(projecttest.WithBuildArch(projecttest.NoArch))
-	project := projecttest.NewDynamicTestProject(projecttest.AddSpec(spec))
+	project := projecttest.NewDynamicTestProject(
+		projecttest.AddSpec(spec),
+		projecttest.UseTestDefaultConfigs(),
+	)
 
-	// Run the build.
-	results := buildtest.NewBuildTest(project, spec.GetName()).Run(t)
+	// Run the build with test default configs copied into the container.
+	results := buildtest.NewBuildTest(project, spec.GetName(), projecttest.WithTestDefaultConfigs()).Run(t)
 
 	// Make sure we got 1 SRPM.
 	srpms := results.GetSRPMs(t)
@@ -69,10 +73,13 @@ func TestBuildingLocalComponentFromCheckedInFiles(t *testing.T) {
 	}
 
 	// Create a simple project with a simple noarch spec.
-	project := projecttest.NewTemplatedTestProject(t, "testdata/simple")
+	// Include test default configs to get distro and mock configurations.
+	project := projecttest.NewTemplatedTestProject(t, "testdata/simple",
+		projecttest.TemplatedUseTestDefaultConfigs(),
+	)
 
-	// Run the build.
-	results := buildtest.NewBuildTest(project, "a").Run(t)
+	// Run the build with test default configs copied into the container.
+	results := buildtest.NewBuildTest(project, "a", projecttest.WithTestDefaultConfigs()).Run(t)
 
 	// Make sure we got 1 SRPM.
 	srpms := results.GetSRPMs(t)
@@ -110,12 +117,14 @@ func TestBuildingUpstreamComponent(t *testing.T) {
 
 	// Create a project with a well-known component available in Fedora; we rely on the
 	// default configuration defaulting to sourcing from upstream.
+	// Include test default configs to get distro and mock configurations.
 	project := projecttest.NewDynamicTestProject(
 		projecttest.AddComponent(&projectconfig.ComponentConfig{Name: testComponentName}),
+		projecttest.UseTestDefaultConfigs(),
 	)
 
-	// Run the build.
-	results := buildtest.NewBuildTest(project, testComponentName).Run(t)
+	// Run the build with test default configs copied into the container.
+	results := buildtest.NewBuildTest(project, testComponentName, projecttest.WithTestDefaultConfigs()).Run(t)
 
 	// Make sure we got 1 SRPM.
 	srpms := results.GetSRPMs(t)

scenario/component_query_test.go

@@ -6,13 +6,9 @@
 package scenario_tests
 
 import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
 	"testing"
 
-	"github.com/gim-home/azldev-preview/scenario/internal/cmdtest"
+	"github.com/gim-home/azldev-preview/scenario/internal/projecttest"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -26,61 +22,35 @@ func TestQueryingAComponent(t *testing.T) {
 		t.Skip("skipping long test")
 	}
 
-	// Write out a simple script that writes a spec file and tries to query it.
-	testScript := `
-set -euxo pipefail
-azldev project init
-ln -s /var/lib/mock build # Ensure the build output dir is writable by mock
+	// Create a simple spec with a known name and version.
+	spec := projecttest.NewSpec(
+		projecttest.WithName("test-component"),
+		projecttest.WithVersion("3.1.4.159"),
+	)
 
-cat <<EOF >test-component.spec
-Name: test-component
-Version: 3.1.4.159
-Release: 1%{?dist}
-Summary: A test component
-License: MIT
+	// Create a simple project with the spec, using test default configs for distro and mock configurations.
+	project := projecttest.NewDynamicTestProject(
+		projecttest.AddSpec(spec),
+		projecttest.UseTestDefaultConfigs(),
+	)
 
-%description
-Test component for, you know, testing.
-EOF
+	// Run the component query command with test default configs copied into the container.
+	results := projecttest.NewProjectTest(
+		project,
+		[]string{"component", "query", spec.GetName()},
+		projecttest.WithTestDefaultConfigs(),
+	).RunInContainer(t)
 
-ls -l -R
-
-azldev component list --all-components
-
-azldev -v component query test-component --output-format json >query-result.json
-`
-
-	// NOTE: We need to run in a privileged container so 'mock' can create its nested root environment.
-	// NOTE: We need to enable networking so 'mock' can download Azure Linux packages to build a root.
-	results, err := cmdtest.NewScenarioTest().
-		WithScript(strings.NewReader(testScript)).
-		InContainer().
-		WithPrivilege().
-		WithNetwork().
-		Run(t)
-
-	require.NoError(t, err)
-	results.AssertZeroExitCode(t)
-
-	// Find the output file.
-	outputFilePath := filepath.Join(results.Workdir, "query-result.json")
-	require.FileExists(t, outputFilePath, "Expected output file to exist")
-
-	// Read it.
-	bytes, err := os.ReadFile(outputFilePath)
-	require.NoError(t, err, "Failed to read output file")
-
-	// Parse it as JSON
-	var output []map[string]interface{}
-	require.NoError(t, json.Unmarshal(bytes, &output))
+	// Get the parsed JSON output.
+	output := results.GetJSONResult()
 
 	// There should just be one component in the output.
 	require.Len(t, output, 1, "Expected one component in the output")
 	componentOutput := output[0]
 
 	// Check for name.
 	require.Contains(t, componentOutput, "Name")
-	assert.Equal(t, componentOutput["Name"], "test-component", "Expected component name to match")
+	assert.Equal(t, spec.GetName(), componentOutput["Name"], "Expected component name to match")
 
 	// Check for EVR structure.
 	require.Contains(t, componentOutput, "Version")
@@ -90,5 +60,5 @@ azldev -v component query test-component --output-format json >query-result.json
 	versionMap, ok := version.(map[string]interface{})
 	require.True(t, ok, "Version field is not a map")
 	require.Contains(t, versionMap, "Version")
-	assert.Equal(t, versionMap["Version"], "3.1.4.159")
+	assert.Equal(t, spec.GetVersion(), versionMap["Version"])
 }

scenario/internal/buildtest/buildtest.go

@@ -27,8 +27,14 @@ type BuildTestResults struct {
 }
 
 // NewBuildTest creates a new [BuildTest] for the specified project and component name.
-func NewBuildTest(project projecttest.TestProject, componentName string) *BuildTest {
-	projectTest := projecttest.NewProjectTest(project, []string{"component", "build", componentName})
+// Optional [projecttest.ProjectTestOption]s can be passed to configure the underlying project test,
+// such as [projecttest.WithTestDefaultConfigs] to include the test default configs.
+func NewBuildTest(
+	project projecttest.TestProject,
+	componentName string,
+	options ...projecttest.ProjectTestOption,
+) *BuildTest {
+	projectTest := projecttest.NewProjectTest(project, []string{"component", "build", componentName}, options...)
 
 	return &BuildTest{
 		inner: projectTest,

scenario/internal/projecttest/dynamictestproject.go

@@ -87,6 +87,18 @@ func AddComponent(componentConfig *projectconfig.ComponentConfig) DynamicTestPro
 	}
 }
 
+// UseTestDefaultConfigs configures the project to include the test default configs.
+// This adds an include directive to the project's azldev.toml that references the test
+// default configs (which must be copied into the container separately using
+// [WithTestDefaultConfigs] on the [ProjectTest]).
+func UseTestDefaultConfigs() DynamicTestProjectOption {
+	return func(p *dynamicTestProject) {
+		// Prepend the test default configs include path so it's loaded first.
+		// Project-specific settings will override it.
+		p.configFile.Includes = append([]string{TestDefaultConfigsIncludePath}, p.configFile.Includes...)
+	}
+}
+
 func (p *dynamicTestProject) addSpecContents(name, specContent string) {
 	// Place specs in their own dir.
 	relativeFilePath := filepath.Join("specs", name, name+".spec")

scenario/internal/projecttest/projecttest.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"testing"
 
@@ -17,21 +18,62 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-const projectSubdir = "project"
+const (
+	projectSubdir = "project"
+
+	// TestDefaultConfigsSubdir is the subdirectory name used for test default configs in the container.
+	TestDefaultConfigsSubdir = "testdefaults"
+
+	// TestDefaultConfigsIncludePath is the relative include path to use from a project's azldev.toml
+	// to include the test default configs. This path is relative to the project directory.
+	TestDefaultConfigsIncludePath = "../" + TestDefaultConfigsSubdir + "/defaults.toml"
+)
+
+// TestDefaultConfigsDir returns the absolute path to the scenario/testdata/defaultconfigs directory.
+// This function uses runtime.Caller to resolve the path relative to this source file's location.
+func TestDefaultConfigsDir() string {
+	// Get the path of this source file.
+	_, thisFile, _, ok := runtime.Caller(0)
+	if !ok {
+		panic("failed to get caller information for TestDefaultConfigsDir")
+	}
+
+	// Navigate from scenario/internal/projecttest/ up to scenario/testdata/defaultconfigs/
+	scenarioDir := filepath.Dir(filepath.Dir(filepath.Dir(thisFile)))
+
+	return filepath.Join(scenarioDir, "testdata", "defaultconfigs")
+}
 
 // ProjectTest represents a runnable, project-oriented test case.
 type ProjectTest struct {
-	project     TestProject
-	commandArgs []string
+	project               TestProject
+	commandArgs           []string
+	useTestDefaultConfigs bool
+}
+
+// ProjectTestOption is a function that can be used to configure a [ProjectTest].
+type ProjectTestOption func(*ProjectTest)
+
+// WithTestDefaultConfigs configures the project test to copy and use the test default configs.
+// When enabled, the test default configs from scenario/testdata/defaultconfigs/ will be
+// copied into the container and made available for the project to include.
+func WithTestDefaultConfigs() ProjectTestOption {
+	return func(p *ProjectTest) {
+		p.useTestDefaultConfigs = true
+	}
 }
 
 // NewProjectTest creates a new [ProjectTest] with the specified project and command arguments.
-func NewProjectTest(project TestProject, commandArgs []string) *ProjectTest {
+func NewProjectTest(project TestProject, commandArgs []string, options ...ProjectTestOption) *ProjectTest {
 	params := &ProjectTest{
 		project:     project,
 		commandArgs: commandArgs,
 	}
 
+	for _, option := range options {
+		option(params)
+	}
+
 	return params
 }
 
@@ -64,9 +106,18 @@ azldev -C project -v %s --output-format json >result.json
 
 	// NOTE: We need to run in a privileged container so 'mock' can create its nested root environment.
 	// NOTE: We need to enable networking so 'mock' can download Azure Linux packages to build a root.
-	results, err := cmdtest.NewScenarioTest().
+	scenarioTest := cmdtest.NewScenarioTest().
 		WithScript(strings.NewReader(testScript)).
-		AddDirRecursive(t, projectSubdir, projectStagingDir).
+		AddDirRecursive(t, projectSubdir, projectStagingDir)
+
+	// If test default configs are requested, copy them into the container as a sibling directory
+	// to the project directory. This allows the project's azldev.toml to include them via a
+	// relative path like "../testdefaults/defaults.toml".
+	if p.useTestDefaultConfigs {
+		scenarioTest.AddDirRecursive(t, TestDefaultConfigsSubdir, TestDefaultConfigsDir())
+	}
+
+	results, err := scenarioTest.
 		InContainer().
 		WithPrivilege().
 		WithNetwork().

scenario/internal/projecttest/templatetestproject.go

@@ -9,16 +9,37 @@ import (
 	"runtime"
 	"testing"
 
+	"github.com/gim-home/azldev-preview/internal/projectconfig"
+	"github.com/gim-home/azldev-preview/internal/utils/fileperms"
 	"github.com/gim-home/azldev-preview/internal/utils/fileutils"
+	"github.com/pelletier/go-toml/v2"
 	"github.com/spf13/afero"
 	"github.com/stretchr/testify/require"
 )
 
+// TemplatedTestProjectOption is a function that can be used to configure a [templatedTestProject].
+type TemplatedTestProjectOption func(*templatedTestProject)
+
 type templatedTestProject struct {
-	templateDir string
+	templateDir           string
+	useTestDefaultConfigs bool
+}
+
+// TemplatedUseTestDefaultConfigs configures the templated project to include the test default configs.
+// This modifies the project's azldev.toml after copying to add an include directive that
+// references the test default configs (which must be copied into the container separately
+// using [WithTestDefaultConfigs] on the [ProjectTest]).
+func TemplatedUseTestDefaultConfigs() TemplatedTestProjectOption {
+	return func(p *templatedTestProject) {
+		p.useTestDefaultConfigs = true
+	}
 }
 
-func NewTemplatedTestProject(t *testing.T, templateDir string) *templatedTestProject {
+func NewTemplatedTestProject(
+	t *testing.T,
+	templateDir string,
+	options ...TemplatedTestProjectOption,
+) *templatedTestProject {
 	t.Helper()
 
 	// Resolve any relative paths.
@@ -34,18 +55,48 @@ func NewTemplatedTestProject(t *testing.T, templateDir string) *templatedTestPro
 		templateDir = filepath.Join(dirPath, templateDir)
 	}
 
-	return &templatedTestProject{
+	project := &templatedTestProject{
 		templateDir: templateDir,
 	}
+
+	for _, option := range options {
+		option(project)
+	}
+
+	return project
 }
 
 func (p *templatedTestProject) Serialize(t *testing.T, projectDir string) {
 	t.Helper()
 
-	// For now, we just copy the template dir to the destination. This could be
-	// extended to apply transformations on the input.
-	err := fileutils.CopyDirRecursive(notDryRun{}, afero.NewOsFs(), p.templateDir, projectDir, fileutils.CopyDirOptions{})
+	osFS := afero.NewOsFs()
+
+	// Copy the template dir to the destination.
+	err := fileutils.CopyDirRecursive(notDryRun{}, osFS, p.templateDir, projectDir, fileutils.CopyDirOptions{})
 	require.NoError(t, err)
+
+	// If test default configs are requested, modify the azldev.toml to include them.
+	if p.useTestDefaultConfigs {
+		configFilePath := filepath.Join(projectDir, projectconfig.DefaultConfigFileName)
+
+		// Read and parse the existing config file.
+		configBytes, err := afero.ReadFile(osFS, configFilePath)
+		require.NoError(t, err, "failed to read config file for test default configs injection")
+
+		var config projectconfig.ConfigFile
+		require.NoError(t, toml.Unmarshal(configBytes, &config),
+			"failed to parse config file for test default configs injection")
+
+		// Prepend the test default configs include path.
+		config.Includes = append([]string{TestDefaultConfigsIncludePath}, config.Includes...)
+
+		// Write back the modified config file.
+		modifiedBytes, err := toml.Marshal(config)
+		require.NoError(t, err, "failed to marshal config file with test default configs")
+
+		require.NoError(t, afero.WriteFile(osFS, configFilePath, modifiedBytes, fileperms.PublicFile),
+			"failed to write config file with test default configs")
+	}
 }
 
 type notDryRun struct{}