feat(render): add WithSkipLookaside preparer option (#61)

dmcilvaney · web-flow · commit bada177e809f · 2026-04-06T08:17:42.000-07:00
diff --git a/internal/app/azldev/core/sources/sourceprep.go b/internal/app/azldev/core/sources/sourceprep.go
@@ -68,6 +68,19 @@ func WithGitRepo() PreparerOption {
 	}
 }
 
+// WithSkipLookaside returns a [PreparerOption] that skips all lookaside cache
+// downloads during source preparation. This includes both explicit source file
+// downloads ([SourceManager.FetchFiles]) and lookaside extraction during
+// component fetching ([FedoraSourceDownloader.ExtractSourcesFromRepo]).
+// Git-tracked files (spec, patches, scripts, configs) are still fetched from
+// the upstream clone. This is useful for rendering, where only the spec and
+// sidecar files are needed and downloading large source tarballs is unnecessary.
+func WithSkipLookaside() PreparerOption {
+	return func(p *sourcePreparerImpl) {
+		p.skipLookaside = true
+	}
+}
+
 // Standard implementation of the [SourcePreparer] interface.
 type sourcePreparerImpl struct {
 	sourceManager sourceproviders.SourceManager
@@ -78,6 +91,10 @@ type sourcePreparerImpl struct {
 	// withGitRepo, when true, enables dist-git creation by preserving the
 	// upstream .git directory and generating synthetic commit history.
 	withGitRepo bool
+
+	// skipLookaside, when true, skips all lookaside cache downloads during
+	// source preparation. Git-tracked files are still fetched.
+	skipLookaside bool
 }
 
 // NewPreparer creates a new [SourcePreparer] instance. All positional arguments
@@ -126,10 +143,14 @@ func (p *sourcePreparerImpl) PrepareSources(
 	ctx context.Context, component components.Component, outputDir string, applyOverlays bool,
 ) error {
 	// Use the source manager to fetch source files (archives, patches, etc.)
-	err := p.sourceManager.FetchFiles(ctx, component, outputDir)
-	if err != nil {
-		return fmt.Errorf("failed to fetch source files for component %#q:\n%w",
-			component.GetName(), err)
+	// Skip this step when skipLookaside is set — source tarballs are not needed
+	// for rendering and are the most expensive download.
+	if !p.skipLookaside {
+		err := p.sourceManager.FetchFiles(ctx, component, outputDir)
+		if err != nil {
+			return fmt.Errorf("failed to fetch source files for component %#q:\n%w",
+				component.GetName(), err)
+		}
 	}
 
 	// Preserve the upstream .git directory only when dist-git creation is
@@ -140,8 +161,12 @@ func (p *sourcePreparerImpl) PrepareSources(
 		fetchOpts = append(fetchOpts, sourceproviders.WithPreserveGitDir())
 	}
 
+	if p.skipLookaside {
+		fetchOpts = append(fetchOpts, sourceproviders.WithSkipLookaside())
+	}
+
 	// Use the source manager to fetch the component (spec file and sidecar files).
-	err = p.sourceManager.FetchComponent(ctx, component, outputDir, fetchOpts...)
+	err := p.sourceManager.FetchComponent(ctx, component, outputDir, fetchOpts...)
 	if err != nil {
 		return fmt.Errorf("failed to fetch sources for component %#q:\n%w",
 			component.GetName(), err)
diff --git a/internal/app/azldev/core/sources/sourceprep_test.go b/internal/app/azldev/core/sources/sourceprep_test.go
@@ -103,6 +103,69 @@ func TestPrepareSources_SourceManagerError(t *testing.T) {
 	require.ErrorIs(t, err, expectedErr)
 }
 
+func TestPrepareSources_WithSkipLookaside_SkipsFetchFiles(t *testing.T) {
+	const (
+		testSpecName   = "test-component.spec"
+		outputSpecPath = testOutputDir + "/" + testSpecName
+	)
+
+	ctrl := gomock.NewController(t)
+	component := components_testutils.NewMockComponent(ctrl)
+	sourceManager := sourceproviders_test.NewMockSourceManager(ctrl)
+	ctx := testctx.NewCtx()
+
+	component.EXPECT().GetName().AnyTimes().Return("test-component")
+	component.EXPECT().GetConfig().AnyTimes().Return(&projectconfig.ComponentConfig{})
+
+	// FetchFiles must NOT be called when WithSkipLookaside is set.
+	// (No sourceManager.EXPECT().FetchFiles(...) — gomock will fail if it's called.)
+
+	// FetchComponent should still be called, with at least the SkipLookaside option.
+	sourceManager.EXPECT().FetchComponent(gomock.Any(), component, testOutputDir, gomock.Any()).DoAndReturn(
+		func(_ interface{}, _ interface{}, outputDir string, opts ...sourceproviders.FetchComponentOption) error {
+			// At least one option (SkipLookaside) should be passed.
+			assert.NotEmpty(t, opts, "FetchComponent should receive at least one option (SkipLookaside)")
+
+			return fileutils.WriteFile(ctx.FS(), outputSpecPath, []byte("# test spec"), 0o644)
+		},
+	)
+
+	preparer, err := sources.NewPreparer(sourceManager, ctx.FS(), ctx, ctx, sources.WithSkipLookaside())
+	require.NoError(t, err)
+
+	err = preparer.PrepareSources(ctx, component, testOutputDir, true /*applyOverlays?*/)
+	require.NoError(t, err)
+}
+
+func TestPrepareSources_WithoutSkipLookaside_CallsFetchFiles(t *testing.T) {
+	const (
+		testSpecName   = "test-component.spec"
+		outputSpecPath = testOutputDir + "/" + testSpecName
+	)
+
+	ctrl := gomock.NewController(t)
+	component := components_testutils.NewMockComponent(ctrl)
+	sourceManager := sourceproviders_test.NewMockSourceManager(ctrl)
+	ctx := testctx.NewCtx()
+
+	component.EXPECT().GetName().AnyTimes().Return("test-component")
+	component.EXPECT().GetConfig().AnyTimes().Return(&projectconfig.ComponentConfig{})
+
+	// Without WithSkipLookaside, FetchFiles MUST be called.
+	sourceManager.EXPECT().FetchFiles(gomock.Any(), component, testOutputDir).Return(nil)
+	sourceManager.EXPECT().FetchComponent(gomock.Any(), component, testOutputDir, gomock.Any()).DoAndReturn(
+		func(_ interface{}, _ interface{}, outputDir string, _ ...sourceproviders.FetchComponentOption) error {
+			return fileutils.WriteFile(ctx.FS(), outputSpecPath, []byte("# test spec"), 0o644)
+		},
+	)
+
+	preparer, err := sources.NewPreparer(sourceManager, ctx.FS(), ctx, ctx)
+	require.NoError(t, err)
+
+	err = preparer.PrepareSources(ctx, component, testOutputDir, true /*applyOverlays?*/)
+	require.NoError(t, err)
+}
+
 func TestPrepareSources_WritesMacrosFile(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	component := components_testutils.NewMockComponent(ctrl)
diff --git a/internal/providers/sourceproviders/fedorasourceprovider.go b/internal/providers/sourceproviders/fedorasourceprovider.go
@@ -174,11 +174,14 @@ func (g *FedoraSourcesProviderImpl) processClonedRepo(
 
 	// Extract sources from repo (downloads lookaside files into the temp dir).
 	// Files in skipFilenames are not downloaded — they were already fetched by FetchFiles.
-	err := g.downloader.ExtractSourcesFromRepo(
-		ctx, tempDir, upstreamName, g.lookasideBaseURI, skipFilenames,
-	)
-	if err != nil {
-		return fmt.Errorf("failed to extract sources from git repository:\n%w", err)
+	// Skip this step entirely when SkipLookaside is set (e.g., during rendering).
+	if !opts.SkipLookaside {
+		err := g.downloader.ExtractSourcesFromRepo(
+			ctx, tempDir, upstreamName, g.lookasideBaseURI, skipFilenames,
+		)
+		if err != nil {
+			return fmt.Errorf("failed to extract sources from git repository:\n%w", err)
+		}
 	}
 
 	// If the upstream name differs from the component name, rename the spec in temp dir.
diff --git a/internal/providers/sourceproviders/fedorasourceprovider_test.go b/internal/providers/sourceproviders/fedorasourceprovider_test.go
@@ -601,6 +601,57 @@ func TestGetComponentFromGit(t *testing.T) {
 		require.Error(t, err)
 		assert.Contains(t, err.Error(), "failed to rename fetched spec file")
 	})
+
+	t.Run("skip lookaside does not call ExtractSourcesFromRepo", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		mockGitProvider := git_test.NewMockGitProvider(ctrl)
+		mockExtractor := fedorasource_test.NewMockFedoraSourceDownloader(ctrl)
+
+		provider, err := sourceproviders.NewFedoraSourcesProviderImpl(
+			env.FS(),
+			env.DryRunnable,
+			mockGitProvider,
+			mockExtractor,
+			testResolvedDistro(),
+			retry.Disabled(),
+		)
+		require.NoError(t, err)
+
+		mockComponent := components_testutils.NewMockComponent(ctrl)
+		mockComponent.EXPECT().GetName().AnyTimes().Return(testPackageName)
+		mockComponent.EXPECT().GetConfig().AnyTimes().Return(&projectconfig.ComponentConfig{
+			Name: testPackageName,
+		})
+
+		// Git clone creates spec file.
+		mockGitProvider.EXPECT().
+			Clone(gomock.Any(), repoURL, gomock.Any(), gomock.Any()).
+			DoAndReturn(func(ctx context.Context, repoURL, cloneDir string, opts ...git.GitOptions) error {
+				specPath := cloneDir + "/" + testPackageName + ".spec"
+
+				return fileutils.WriteFile(env.FS(), specPath, []byte("Name: "+testPackageName), fileperms.PublicFile)
+			})
+
+		mockGitProvider.EXPECT().
+			GetCurrentCommit(gomock.Any(), gomock.Any()).
+			Return("head123abc", nil)
+
+		mockGitProvider.EXPECT().
+			Checkout(gomock.Any(), gomock.Any(), "head123abc").
+			Return(nil)
+
+		// ExtractSourcesFromRepo must NOT be called — no EXPECT set for it.
+		// gomock will fail if it's called unexpectedly.
+
+		err = provider.GetComponent(context.Background(), mockComponent, destDir, sourceproviders.WithSkipLookaside())
+		require.NoError(t, err)
+
+		// Verify spec file was still copied to destination.
+		specPath := destDir + "/" + testPackageName + ".spec"
+		exists, checkErr := fileutils.Exists(env.FS(), specPath)
+		require.NoError(t, checkErr)
+		assert.True(t, exists, "spec file should exist in destination even with skip-lookaside")
+	})
 }
 
 // testResolvedDistroWithSnapshot returns a [sourceproviders.ResolvedDistro] with the given snapshot time.
diff --git a/internal/providers/sourceproviders/sourcemanager.go b/internal/providers/sourceproviders/sourcemanager.go
@@ -55,6 +55,11 @@ type FetchComponentOptions struct {
 	// in the fetched component sources instead of deleting it. This is required for building
 	// synthetic git history from overlay blame metadata.
 	PreserveGitDir bool
+
+	// SkipLookaside, when true, skips all lookaside cache downloads during component
+	// fetching. Git-tracked files (spec, patches, scripts) are still fetched from the
+	// upstream clone. The sources manifest file remains available for validation.
+	SkipLookaside bool
 }
 
 // FetchComponentOption is a functional option for configuring component fetch behavior.
@@ -68,6 +73,14 @@ func WithPreserveGitDir() FetchComponentOption {
 	}
 }
 
+// WithSkipLookaside returns a [FetchComponentOption] that skips lookaside cache
+// downloads during component fetching. Git-tracked files are still fetched.
+func WithSkipLookaside() FetchComponentOption {
+	return func(o *FetchComponentOptions) {
+		o.SkipLookaside = true
+	}
+}
+
 // resolveFetchComponentOptions applies all functional options and returns the resolved options.
 func resolveFetchComponentOptions(opts []FetchComponentOption) FetchComponentOptions {
 	var resolved FetchComponentOptions
@@ -449,9 +462,11 @@ func (m *sourceManager) FetchComponent(
 
 	sourceType := component.GetConfig().Spec.SourceType
 
+	resolved := resolveFetchComponentOptions(opts)
+
 	switch sourceType {
 	case projectconfig.SpecSourceTypeLocal, projectconfig.SpecSourceTypeUnspecified:
-		return m.fetchLocalComponent(ctx, component, destDirPath)
+		return m.fetchLocalComponent(ctx, component, destDirPath, resolved)
 
 	case projectconfig.SpecSourceTypeUpstream:
 		return m.fetchUpstreamComponent(ctx, component, destDirPath, opts...)
@@ -511,19 +526,22 @@ func (m *sourceManager) resolveUpstreamSourceIdentity(
 }
 
 func (m *sourceManager) fetchLocalComponent(
-	ctx context.Context, component components.Component, destDirPath string,
+	ctx context.Context, component components.Component, destDirPath string, opts FetchComponentOptions,
 ) error {
 	err := FetchLocalComponent(m.dryRunnable, m.eventListener, m.fs, component, destDirPath, false)
 	if err != nil {
 		return fmt.Errorf("failed to fetch local component %#q:\n%w",
 			component.GetName(), err)
 	}
 
-	// Download source files from lookaside cache if available
-	err = m.downloadLookasideSources(ctx, component, destDirPath)
-	if err != nil {
-		return fmt.Errorf("failed to download lookaside sources for component %#q:\n%w",
-			component.GetName(), err)
+	// Download source files from lookaside cache if available.
+	// Skip this step when SkipLookaside is set (e.g., during rendering).
+	if !opts.SkipLookaside {
+		err = m.downloadLookasideSources(ctx, component, destDirPath)
+		if err != nil {
+			return fmt.Errorf("failed to download lookaside sources for component %#q:\n%w",
+				component.GetName(), err)
+		}
 	}
 
 	return nil
diff --git a/internal/providers/sourceproviders/sourcemanager_test.go b/internal/providers/sourceproviders/sourcemanager_test.go
@@ -486,6 +486,56 @@ func TestSourceManager_ResolveSourceIdentity_UpstreamAllProvidersFail(t *testing
 	require.Contains(t, err.Error(), "failed to resolve source identity")
 }
 
+func TestSourceManager_FetchComponent_LocalComponent_WithSkipLookaside(t *testing.T) {
+	env := testutils.NewTestEnv(t)
+	ctrl := gomock.NewController(t)
+	component := components_testutils.NewMockComponent(ctrl)
+	spec := specs_testutils.NewMockComponentSpec(ctrl)
+
+	const (
+		specDir  = "/specs/test-component"
+		specPath = specDir + "/test-component.spec"
+	)
+
+	componentConfig := &projectconfig.ComponentConfig{
+		Spec: projectconfig.SpecSource{
+			SourceType: projectconfig.SpecSourceTypeLocal,
+			Path:       specPath,
+		},
+	}
+
+	component.EXPECT().GetName().AnyTimes().Return("test-component")
+	component.EXPECT().GetConfig().AnyTimes().Return(componentConfig)
+	component.EXPECT().GetSpec().AnyTimes().Return(spec)
+	spec.EXPECT().GetPath().AnyTimes().Return(specPath, nil)
+
+	// Create spec file and a lookaside sources manifest in the source directory.
+	// The sources file references a tarball that would require downloading from
+	// the lookaside cache. If downloadLookasideSources runs despite SkipLookaside,
+	// the download will fail (no real server at example.com) and the test will fail.
+	require.NoError(t, fileutils.WriteFile(env.TestFS, specPath,
+		[]byte("Name: test-component\nVersion: 1.0\n"), fileperms.PrivateFile))
+	require.NoError(t, fileutils.WriteFile(env.TestFS, specDir+"/sources",
+		[]byte("SHA512 (big-source.tar.gz) = abc123def456\n"), fileperms.PrivateFile))
+
+	sourceManager, err := sourceproviders.NewSourceManager(env.Env, testDefaultDistro())
+	require.NoError(t, err)
+
+	// With SkipLookaside, downloadLookasideSources is not called and the fetch succeeds.
+	err = sourceManager.FetchComponent(t.Context(), component, testDestDir, sourceproviders.WithSkipLookaside())
+	require.NoError(t, err)
+
+	// Spec was copied to destination (FetchLocalComponent still ran).
+	specExists, err := fileutils.Exists(env.TestFS, filepath.Join(testDestDir, "test-component.spec"))
+	require.NoError(t, err)
+	assert.True(t, specExists, "spec file should exist in destination")
+
+	// Source tarball was NOT downloaded (lookaside was skipped).
+	tarballExists, err := fileutils.Exists(env.TestFS, filepath.Join(testDestDir, "big-source.tar.gz"))
+	require.NoError(t, err)
+	assert.False(t, tarballExists, "source tarball should not be present when SkipLookaside is set")
+}
+
 func TestSourceManager_ResolveSourceIdentity_UnknownSourceType(t *testing.T) {
 	env := testutils.NewTestEnv(t)
 	ctrl := gomock.NewController(t)
