feat(codegen): add file.SetMode

Adds a new `file.SetMode` function for setting the mode of the currently
rendered file.

Also added a new `RenderTemplate` helper for simple "run command, check
modifications" tests. This will be expanded on later. Converted some
tests to use this helper and added some new basic tests using it.

Author: jaredallard

.mise.lock

@@ -38,94 +38,68 @@ var generatedBlockIndentTemplate string
 var fakeGeneratedBlockIndentFile string
 
 func TestSingleFileRender(t *testing.T) {
-	log := slogext.NewTestLogger(t)
-	fs, err := testmemfs.WithManifest("name: testing\n")
-	assert.NilError(t, err, "failed to testmemfs.WithManifest")
-	m, err := modulestest.NewWithFS(t.Context(), "testing", fs)
-	assert.NilError(t, err, "failed to NewWithFS")
-
-	tpl, err := NewTemplate(m, "virtual-file.tpl", 0o644, time.Now(), []byte("hello world!"), log, nil)
-	assert.NilError(t, err, "failed to create basic template")
-
-	sm := &configuration.Manifest{Name: "testing"}
-
-	st := NewStencil(sm, nil, []*modules.Module{m}, log, false)
-	err = tpl.Render(st, NewValues(t.Context(), sm, nil))
-	assert.NilError(t, err, "expected Render() to not fail")
+	tpl := RenderTemplate(t, nil, nil, "hello world!")
+	assert.Equal(t, len(tpl.Files), 1, "expected exactly one file to be rendered")
 	assert.Equal(t, tpl.Files[0].String(), "hello world!", "expected Render() to modify first created file")
 }
 
 func TestMultiFileRender(t *testing.T) {
-	log := slogext.NewTestLogger(t)
-	fs, err := testmemfs.WithManifest("name: testing\narguments:\n  commands:\n    type: list")
-	assert.NilError(t, err, "failed to testmemfs.WithManifest")
-	m, err := modulestest.NewWithFS(t.Context(), "testing", fs)
-	assert.NilError(t, err, "failed to NewWithFS")
-
-	tpl, err := NewTemplate(m, "multi-file.tpl", 0o644,
-		time.Now(), []byte(multiFileTemplate), log, nil)
-	assert.NilError(t, err, "failed to create template")
-
-	sm := &configuration.Manifest{Name: "testing", Arguments: map[string]any{
-		"commands": []string{"hello", "world", "command"},
-	}}
-
-	st := NewStencil(sm, nil, []*modules.Module{m}, log, false)
-	err = tpl.Render(st, NewValues(t.Context(), sm, nil))
-	assert.NilError(t, err, "expected Render() to not fail")
+	tpl := RenderTemplate(t,
+		&configuration.Manifest{
+			Arguments: map[string]any{
+				"commands": []string{"hello", "world", "command"},
+			},
+		},
+		&configuration.TemplateRepositoryManifest{
+			Arguments: map[string]configuration.Argument{
+				"commands": {},
+			},
+		}, multiFileTemplate,
+	)
 	assert.Equal(t, len(tpl.Files), 3, "expected Render() to create 3 files")
 
 	for i, f := range tpl.Files {
-		assert.Equal(t, f.String(), "command", "rendered template %d contents differred", i)
+		assert.Equal(t, f.String(), "command", "rendered template %d contents differed", i)
 	}
 }
 
 func TestMultiFileWithInputRender(t *testing.T) {
-	log := slogext.NewTestLogger(t)
-	fs, err := testmemfs.WithManifest("name: testing\narguments:\n  commands:\n    type: list")
-	assert.NilError(t, err, "failed to testmemfs.WithManifest")
-	m, err := modulestest.NewWithFS(t.Context(), "testing", fs)
-	assert.NilError(t, err, "failed to NewWithFS")
-
-	tpl, err := NewTemplate(m, "multi-file-input.tpl", 0o644,
-		time.Now(), []byte(multiFileInputTemplate), log, nil)
-	assert.NilError(t, err, "failed to create template")
-
-	sm := &configuration.Manifest{Name: "testing", Arguments: map[string]any{
-		"commands": []string{"hello", "world", "command"},
-	}}
+	mf := &configuration.Manifest{
+		Arguments: map[string]any{
+			"commands": []string{"hello", "world", "command"},
+		},
+	}
 
-	st := NewStencil(sm, nil, []*modules.Module{m}, log, false)
-	err = tpl.Render(st, NewValues(t.Context(), sm, nil))
-	assert.NilError(t, err, "expected Render() to not fail")
+	tpl := RenderTemplate(t,
+		mf,
+		&configuration.TemplateRepositoryManifest{
+			Arguments: map[string]configuration.Argument{
+				"commands": {},
+			},
+		}, multiFileInputTemplate,
+	)
 	assert.Equal(t, len(tpl.Files), 3, "expected Render() to create 3 files")
 
 	for i, f := range tpl.Files {
-		assert.Equal(t, (sm.Arguments["commands"].([]string))[i], f.String(), "rendered template %d contents differred", i)
+		assert.Equal(t, f.String(), mf.Arguments["commands"].([]string)[i], "rendered template %d contents differed", i)
 	}
 }
 
 func TestIncludeArgumentPassthrough(t *testing.T) {
-	log := slogext.NewTestLogger(t)
-	fs, err := testmemfs.WithManifest("name: testing\narguments:\n  commands:\n    type: list")
-	assert.NilError(t, err, "failed to testmemfs.WithManifest")
-	m, err := modulestest.NewWithFS(t.Context(), "testing", fs)
-	assert.NilError(t, err, "failed to NewWithFS")
-
-	tpl, err := NewTemplate(m, "apply-template-passthrough.tpl", 0o644,
-		time.Now(), []byte(includePassthroughTemplate), log, nil)
-	assert.NilError(t, err, "failed to create template")
-
-	sm := &configuration.Manifest{Name: "testing", Arguments: map[string]any{
-		"commands": []string{"hello", "world", "command"},
-	}}
-
-	st := NewStencil(sm, nil, []*modules.Module{m}, log, false)
-	err = tpl.Render(st, NewValues(t.Context(), sm, nil))
-	assert.NilError(t, err, "expected Render() to not fail")
+	tpl := RenderTemplate(t,
+		&configuration.Manifest{
+			Arguments: map[string]any{
+				"commands": []string{"hello", "world", "command"},
+			},
+		},
+		&configuration.TemplateRepositoryManifest{
+			Arguments: map[string]configuration.Argument{
+				"commands": {},
+			},
+		}, includePassthroughTemplate,
+	)
 	assert.Equal(t, len(tpl.Files), 1, "expected Render() to create 1 files")
-
-	assert.Equal(t, "testing", tpl.Files[0].String(), "rendered template contents differed")
+	assert.Equal(t, t.Name(), tpl.Files[0].String(), "rendered template contents differed")
 }
 
 func TestGeneratedBlock(t *testing.T) {

internal/codegen/template_test.go

@@ -0,0 +1,70 @@
+// Copyright (C) 2025 stencil contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//         http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
+
+// Description: Contains high-level abstractions for testing template
+// rendering.
+
+package codegen
+
+import (
+	"testing"
+	"time"
+
+	"go.rgst.io/stencil/v2/internal/modules"
+	"go.rgst.io/stencil/v2/internal/modules/modulestest"
+	"go.rgst.io/stencil/v2/pkg/configuration"
+	"go.rgst.io/stencil/v2/pkg/slogext"
+	"gotest.tools/v3/assert"
+)
+
+// RenderTemplate creates a template with the provided contents,
+// executes it, and returns the post-rendered [Template].
+//
+// TODO(jaredallard): This shouldn't be exposed outside of tests, but
+// right now we'd need a decently large test refactor so here it is.
+func RenderTemplate(
+	t *testing.T,
+	mf *configuration.Manifest,
+	trmf *configuration.TemplateRepositoryManifest,
+	contents string,
+) *Template {
+	log := slogext.NewTestLogger(t)
+
+	if mf == nil {
+		mf = &configuration.Manifest{}
+	}
+	if mf.Name == "" {
+		mf.Name = t.Name()
+	}
+
+	if trmf == nil {
+		trmf = &configuration.TemplateRepositoryManifest{}
+	}
+	if trmf.Name == "" {
+		trmf.Name = t.Name() + "Module"
+	}
+
+	m, err := modulestest.NewModuleFromTemplates(trmf)
+	assert.NilError(t, err, "expected module creation to not fail")
+
+	tpl, err := NewTemplate(m, "test.tpl", 0o755, time.Now(), []byte(contents), log, &NewTemplateOpts{})
+	assert.NilError(t, err, "expected template creation to not fail")
+
+	st := NewStencil(mf, nil, []*modules.Module{m}, log, false)
+	assert.NilError(t, tpl.Render(st, NewValues(t.Context(), mf, []*modules.Module{m})), "expected render to not fail")
+
+	return tpl
+}

internal/codegen/templatetest_test.go

@@ -1,4 +1,18 @@
-// Copyright 2022 Outreach Corporation. All Rights Reserved.
+// Copyright (C) 2025 stencil contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//         http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// SPDX-License-Identifier: Apache-2.0
 
 // Description: This file implements the file struct passed to
 // templates in Stencil.
@@ -245,3 +259,11 @@ func (f *TplFile) MigrateTo(path string) (out string, err error) {
 
 	return "", nil
 }
+
+// SetMode sets the provided mode on the current output file.
+//
+//	{{- file.SetMode 0o755 }}
+func (f *TplFile) SetMode(mode os.FileMode) (string, error) {
+	f.f.mode = mode
+	return "", nil
+}

internal/codegen/tpl_file.go

@@ -1,6 +1,7 @@
 package codegen
 
 import (
+	"bytes"
 	"os"
 	"path"
 	"testing"
@@ -269,3 +270,23 @@ func TestTplFile_RemoveAll(t *testing.T) {
 	_, err = os.Stat("test/test2.go")
 	assert.ErrorContains(t, err, "no such file")
 }
+
+func TestTplFile_SetMode(t *testing.T) {
+	tpl := RenderTemplate(t, nil, nil, `{{- file.SetMode 0o777 }}`)
+	assert.Equal(t, tpl.Files[0].Mode(), os.FileMode(0o777), "expected file mode to be 0o777")
+}
+
+func TestTplFile_SetPath(t *testing.T) {
+	tpl := RenderTemplate(t, nil, nil, `{{- file.SetPath "xyz" }}`)
+	assert.Equal(t, tpl.Files[0].path, "xyz", "expected file path to be xyz")
+}
+
+func TestTplFile_SetContents(t *testing.T) {
+	tpl := RenderTemplate(t, nil, nil, `{{- file.SetContents "xyz" }}`)
+	assert.Assert(t, bytes.Equal(tpl.Files[0].contents, []byte("xyz")), "expected file contents to be xyz")
+}
+
+func TestTplFile_Static(t *testing.T) {
+	tpl := RenderTemplate(t, nil, nil, `{{- file.Static }}`)
+	assert.Equal(t, tpl.Files[0].Skipped, false, "expected file to not be skipped when doesn't exist")
+}