factor a bit

Author: VenelinMartinov

pkg/tests/schema_generation_test.go

@@ -145,7 +145,6 @@ func Test_Generate(t *testing.T) {
 
 	outDir := t.TempDir()
 
-	// Create the output directory.
 	var root afero.Fs
 	if outDir != "" {
 		absOutDir, err := filepath.Abs(outDir)
@@ -240,7 +239,6 @@ func Test_GenerateWithOverlay(t *testing.T) {
 		},
 	}
 
-	// Create the output directory.
 	root := afero.NewMemMapFs()
 
 	err := afero.WriteFile(root, overlayFileName, overlayFileContent, 0o600)

pkg/tfgen/generate.go

@@ -112,7 +112,7 @@ func (l Language) shouldConvertExamples() bool {
 	return false
 }
 
-func aferoDirToBytesMap(fs afero.Fs, dir string) (map[string][]byte, error) {
+func dirToBytesMap(fs afero.Fs, dir string) (map[string][]byte, error) {
 	result := make(map[string][]byte)
 	err := afero.Walk(fs, dir, func(path string, info os.FileInfo, err error) error {
 		if err != nil {
@@ -138,6 +138,27 @@ func aferoDirToBytesMap(fs afero.Fs, dir string) (map[string][]byte, error) {
 	return result, err
 }
 
+func writeBytesMapToDir(fs afero.Fs, dir string, files map[string][]byte) error {
+	err := fs.MkdirAll(dir, 0o755)
+	if err != nil {
+		return pkgerrors.Wrap(err, "failed to create dir")
+	}
+	for name, content := range files {
+		srcDir := filepath.Dir(name)
+		if srcDir != "." {
+			err = fs.MkdirAll(filepath.Join(dir, srcDir), 0o755)
+			if err != nil {
+				return pkgerrors.Wrap(err, "failed to create dir")
+			}
+		}
+		err := afero.WriteFile(fs, filepath.Join(dir, name), content, 0o600)
+		if err != nil {
+			return pkgerrors.Wrap(err, "failed to write file")
+		}
+	}
+	return nil
+}
+
 func runPulumiPackageGenSDK(l Language, pkg *pschema.Package, extraFiles map[string][]byte) (map[string][]byte, error) {
 	var err error
 
@@ -155,7 +176,6 @@ func runPulumiPackageGenSDK(l Language, pkg *pschema.Package, extraFiles map[str
 
 	args := []string{"package", "gen-sdk", "--language", string(l), "--out", outDir}
 
-	// turn extraFiles into a folder with files
 	if len(extraFiles) > 0 {
 		overlayDir, err := afero.TempDir(fs, "", "pulumi-package-gen-sdk-overlays")
 		if err != nil {
@@ -168,28 +188,14 @@ func runPulumiPackageGenSDK(l Language, pkg *pschema.Package, extraFiles map[str
 			}
 		}()
 		dest := filepath.Join(overlayDir, string(l))
-		err = fs.MkdirAll(dest, 0o755)
+		err = writeBytesMapToDir(fs, dest, extraFiles)
 		if err != nil {
-			return nil, pkgerrors.Wrap(err, "failed to create temp dir")
-		}
-		for name, content := range extraFiles {
-			dir := filepath.Dir(name)
-			if dir != "." {
-				err = fs.MkdirAll(filepath.Join(dest, dir), 0o755)
-				if err != nil {
-					return nil, pkgerrors.Wrap(err, "failed to create temp dir")
-				}
-			}
-			err := afero.WriteFile(fs, filepath.Join(dest, name), content, 0o600)
-			if err != nil {
-				return nil, pkgerrors.Wrap(err, "failed to write file")
-			}
+			return nil, pkgerrors.Wrap(err, "failed to write overlay files")
 		}
 
 		args = append(args, "--overlays", overlayDir)
 	}
 
-	// write the schema to a file
 	schemaDir, err := afero.TempDir(fs, "", "schema")
 	if err != nil {
 		return nil, pkgerrors.Wrap(err, "failed to create temp dir")
@@ -216,7 +222,7 @@ func runPulumiPackageGenSDK(l Language, pkg *pschema.Package, extraFiles map[str
 		return nil, pkgerrors.New(string(out) + "\n" + stderr + "\n" + err.Error())
 	}
 
-	return aferoDirToBytesMap(fs, outDir)
+	return dirToBytesMap(fs, outDir)
 }
 
 func (l Language) emitSDK(pkg *pschema.Package, info tfbridge.ProviderInfo, root afero.Fs,

pkg/tfgen/generate_test.go

@@ -685,7 +685,7 @@ func Test_aferoDirToBytesMap(t *testing.T) {
 		err = afero.WriteFile(fs, "/root/dir2/file4.txt", []byte("qux"), 0o600)
 		require.NoError(t, err)
 
-		result, err := aferoDirToBytesMap(fs, "/root")
+		result, err := dirToBytesMap(fs, "/root")
 		require.NoError(t, err)
 
 		expected := map[string][]byte{
@@ -700,13 +700,44 @@ func Test_aferoDirToBytesMap(t *testing.T) {
 	t.Run("empty directory", func(t *testing.T) {
 		err := afero.WriteFile(fs, "/emptydir/.keep", []byte{}, 0o600)
 		require.NoError(t, err)
-		res, err := aferoDirToBytesMap(fs, "/emptydir")
+		res, err := dirToBytesMap(fs, "/emptydir")
 		require.NoError(t, err)
 		require.Equal(t, map[string][]byte{".keep": {}}, res)
 	})
 
 	t.Run("non-existent directory", func(t *testing.T) {
-		_, err := aferoDirToBytesMap(fs, "/doesnotexist")
+		_, err := dirToBytesMap(fs, "/doesnotexist")
 		require.Error(t, err, "file does not exist")
 	})
 }
+
+func Test_writeBytesMapToDir(t *testing.T) {
+	t.Parallel()
+	fs := afero.NewMemMapFs()
+
+	t.Run("happy path", func(t *testing.T) {
+		dir := "/root"
+		files := map[string][]byte{
+			"file1.txt":      []byte("hello world"),
+			"dir1/file2.txt": []byte("foo bar"),
+			"dir1/file3.txt": []byte("baz"),
+			"dir2/file4.txt": []byte("qux"),
+		}
+		err := writeBytesMapToDir(fs, dir, files)
+		require.NoError(t, err)
+		for name, content := range files {
+			actual, err := afero.ReadFile(fs, filepath.Join(dir, name))
+			require.NoError(t, err)
+			require.Equal(t, content, actual)
+		}
+	})
+
+	t.Run("empty map", func(t *testing.T) {
+		dir := "/emptydir"
+		err := writeBytesMapToDir(fs, dir, map[string][]byte{})
+		require.NoError(t, err)
+		exists, err := afero.DirExists(fs, dir)
+		require.NoError(t, err)
+		require.True(t, exists)
+	})
+}