steve/databricks-cli
steve
/
databricks-cli
mirror of https://github.com/databricks/cli.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
databricks-cli/libs/template/file_test.go

90 lines
2.1 KiB
Go
Raw Normal View History

Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
package template
import (
"context"
"io/fs"
"os"
"path/filepath"
"runtime"
"testing"
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
"github.com/databricks/cli/libs/filer"
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
func testInMemoryFile(t *testing.T, ctx context.Context, perm fs.FileMode) {
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
tmpDir := t.TempDir()
f := &inMemoryFile{
perm: perm,
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
relPath: "a/b/c",
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
content: []byte("123"),
}
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
out, err := filer.NewLocalClient(tmpDir)
require.NoError(t, err)
err = f.Write(ctx, out)
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
assert.NoError(t, err)
assertFileContent(t, filepath.Join(tmpDir, "a/b/c"), "123")
assertFilePermissions(t, filepath.Join(tmpDir, "a/b/c"), perm)
}
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
func testCopyFile(t *testing.T, ctx context.Context, perm fs.FileMode) {
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
tmpDir := t.TempDir()
Use `fs.FS` interface to read template (#1910) ## Changes While working on the v2 of #1744, I found that: * Template initialization first copies built-in templates to a temporary directory before initializing them * Reading a template's contents goes through a `filer.Filer` but is hardcoded to a local one This change updates the interface for reading templates to be `fs.FS`. This is compatible with the `embed.FS` type for the built-in templates, so they no longer have to be copied to a temporary directory before being used. The alternative is to use a `filer.Filer` throughout, but this would have required even more plumbing, and we don't need to _read_ templates, including notebooks, from the workspace filesystem (yet?). As part of making `template.Materialize` take an `fs.FS` argument, the logic to match a given argument to a particular built-in template in the `init` command has moved to sit next to its implementation. ## Tests Existing tests pass.
2024-11-20 09:28:35 +00:00
err := os.WriteFile(filepath.Join(tmpDir, "source"), []byte("qwerty"), perm)
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
require.NoError(t, err)
f := &copyFile{
Use `fs.FS` interface to read template (#1910) ## Changes While working on the v2 of #1744, I found that: * Template initialization first copies built-in templates to a temporary directory before initializing them * Reading a template's contents goes through a `filer.Filer` but is hardcoded to a local one This change updates the interface for reading templates to be `fs.FS`. This is compatible with the `embed.FS` type for the built-in templates, so they no longer have to be copied to a temporary directory before being used. The alternative is to use a `filer.Filer` throughout, but this would have required even more plumbing, and we don't need to _read_ templates, including notebooks, from the workspace filesystem (yet?). As part of making `template.Materialize` take an `fs.FS` argument, the logic to match a given argument to a particular built-in template in the `init` command has moved to sit next to its implementation. ## Tests Existing tests pass.
2024-11-20 09:28:35 +00:00
perm: perm,
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
relPath: "a/b/c",
Use `fs.FS` interface to read template (#1910) ## Changes While working on the v2 of #1744, I found that: * Template initialization first copies built-in templates to a temporary directory before initializing them * Reading a template's contents goes through a `filer.Filer` but is hardcoded to a local one This change updates the interface for reading templates to be `fs.FS`. This is compatible with the `embed.FS` type for the built-in templates, so they no longer have to be copied to a temporary directory before being used. The alternative is to use a `filer.Filer` throughout, but this would have required even more plumbing, and we don't need to _read_ templates, including notebooks, from the workspace filesystem (yet?). As part of making `template.Materialize` take an `fs.FS` argument, the logic to match a given argument to a particular built-in template in the `init` command has moved to sit next to its implementation. ## Tests Existing tests pass.
2024-11-20 09:28:35 +00:00
srcFS: os.DirFS(tmpDir),
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
srcPath: "source",
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
}
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
out, err := filer.NewLocalClient(tmpDir)
require.NoError(t, err)
err = f.Write(ctx, out)
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
assert.NoError(t, err)
assertFileContent(t, filepath.Join(tmpDir, "a/b/c"), "qwerty")
assertFilePermissions(t, filepath.Join(tmpDir, "a/b/c"), perm)
}
func TestTemplateInMemoryFilePersistToDisk(t *testing.T) {
if runtime.GOOS == "windows" {
t.SkipNow()
}
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
ctx := context.Background()
testInMemoryFile(t, ctx, 0755)
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
}
func TestTemplateInMemoryFilePersistToDiskForWindows(t *testing.T) {
if runtime.GOOS != "windows" {
t.SkipNow()
}
// we have separate tests for windows because of differences in valid
// fs.FileMode values we can use for different operating systems.
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
ctx := context.Background()
testInMemoryFile(t, ctx, 0666)
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
}
func TestTemplateCopyFilePersistToDisk(t *testing.T) {
if runtime.GOOS == "windows" {
t.SkipNow()
}
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
ctx := context.Background()
testCopyFile(t, ctx, 0644)
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
}
func TestTemplateCopyFilePersistToDiskForWindows(t *testing.T) {
if runtime.GOOS != "windows" {
t.SkipNow()
}
// we have separate tests for windows because of differences in valid
// fs.FileMode values we can use for different operating systems.
Use `filer.Filer` to write template instantiation (#1911) ## Changes Prior to this change, the output directory was part of the `renderer` type and passed down to every `file` it produced. Every file knew its absolute destination path. This is incompatible with the use of a filer, where all operations are automatically anchored to some base path. To make this compatible, this change updates: * the `file` type to only know its own path relative to the instantiation root, * the `renderer` type to no longer require or pass along the output directory, * the `persistToDisk` function to take a context and filer argument, * the `filer.WriteMode` to represent permission bits ## Tests * Existing tests pass. * Manually confirmed template initialization works as expected.
2024-11-20 10:11:31 +00:00
ctx := context.Background()
testCopyFile(t, ctx, 0666)
Only treat files with .tmpl extension as templates (#594) ## Changes In a world before this PR, all files would be treated as `go text templates`, making the content in these files quake in fear since they would be executed (as a template). This PR makes it so that only files with the `.tmpl` extension are understood to be templates. This is useful for avoiding ambiguity in cases like where a binary file could be interpreted as a go text template otherwise. In order to do so, we introduce the `copyFile` struct which does a copy of the source file from the template without loading it into memory. ## Tests Unit tests
2023-08-01 13:43:27 +00:00
}