kustomize/api/internal/localizer/localizer_test.go

// Copyright 2022 The Kubernetes Authors.
// SPDX-License-Identifier: Apache-2.0

package localizer_test

import (
	"fmt"
	"io/fs"
	"path/filepath"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	. "sigs.k8s.io/kustomize/api/internal/localizer"
	"sigs.k8s.io/kustomize/kyaml/filesys"
)

const (
	podConfiguration = `apiVersion: v1
kind: Pod
metadata:
  name: pod
spec:
  containers:
  - name: nginx
    image: nginx:1.14.2
    ports:
    - containerPort: 80`

	replacementTransformerWithPath = `apiVersion: builtin
kind: ReplacementTransformer
metadata:
  name: replacement
replacements:
- path: replacement.yaml
- source:
    fieldPath: metadata.[name=my-pod]
    group: apps
    namespace: test
    version: v1
  targets:
  - fieldPaths:
    - spec.containers.0.name
    select:
      name: another-pod
`

	replacements = `
- source:
    name: src
    fieldPath: path
    options:
      delimiter: '='
      index: 1
  targets:
  - select:
      kind: Pod
    reject:
      version: v1
    fieldPaths:
    - metadata.annotations.config\.kubernetes\.io/local-config
    - sequence.*
- source:
    kind: Deployment
    fieldPath: sequence.-
  targets:
  - select:
      namespace: my
    fieldPaths:
    - path
    options:
      delimiter: '='
      index: 0
`

	valuesFile = `minecraftServer:
  difficulty: peaceful
`
)

func makeMemoryFs(t *testing.T) filesys.FileSystem {
	t.Helper()
	req := require.New(t)

	fSys := filesys.MakeFsInMemory()
	req.NoError(fSys.MkdirAll("/a/b"))
	req.NoError(fSys.WriteFile("/a/pod.yaml", []byte(podConfiguration)))

	dirChain := "/alpha/beta/gamma/delta"
	req.NoError(fSys.MkdirAll(dirChain))
	req.NoError(fSys.WriteFile(filepath.Join(dirChain, "deployment.yaml"), []byte("deployment configuration")))
	req.NoError(fSys.Mkdir("/alpha/beta/say"))
	return fSys
}

func addFiles(t *testing.T, fSys filesys.FileSystem, parentDir string, files map[string]string) {
	t.Helper()

	// in-memory file system makes all necessary dirs when writing files
	for file, content := range files {
		require.NoError(t, fSys.WriteFile(filepath.Join(parentDir, file), []byte(content)))
	}
}

func checkRun(t *testing.T, fSys filesys.FileSystem, target, scope, dst string) {
	t.Helper()

	actualDst, err := Run(target, scope, dst, fSys)
	require.NoError(t, err)
	require.Equal(t, dst, actualDst)
}

func makeFileSystems(t *testing.T, target string, files map[string]string) (expected filesys.FileSystem, actual filesys.FileSystem) {
	t.Helper()

	copies := make([]filesys.FileSystem, 2)
	for i := range copies {
		copies[i] = makeMemoryFs(t)
		addFiles(t, copies[i], target, files)
	}
	return copies[0], copies[1]
}

func checkFSys(t *testing.T, fSysExpected filesys.FileSystem, fSysActual filesys.FileSystem) {
	t.Helper()

	assert.Equal(t, fSysExpected, fSysActual)
	if t.Failed() {
		reportFSysDiff(t, fSysExpected, fSysActual)
	}
}

func reportFSysDiff(t *testing.T, fSysExpected filesys.FileSystem, fSysActual filesys.FileSystem) {
	t.Helper()

	visited := make(map[string]struct{})
	err := fSysActual.Walk("/", func(path string, info fs.FileInfo, err error) error {
		require.NoError(t, err)
		visited[path] = struct{}{}

		if info.IsDir() {
			assert.Truef(t, fSysExpected.IsDir(path), "unexpected directory %q", path)
		} else {
			actualContent, readErr := fSysActual.ReadFile(path)
			require.NoError(t, readErr)
			expectedContent, findErr := fSysExpected.ReadFile(path)
			require.NoErrorf(t, findErr, "unexpected file %q", path)
			if findErr == nil {
				assert.Equal(t, string(expectedContent), string(actualContent))
			}
		}
		return nil
	})
	require.NoError(t, err)

	err = fSysExpected.Walk("/", func(path string, info fs.FileInfo, err error) error {
		require.NoError(t, err)

		_, exists := visited[path]
		assert.Truef(t, exists, "expected path %q not found", path)
		return nil
	})
	require.NoError(t, err)
}

func checkLocalizeInTargetSuccess(t *testing.T, files map[string]string) {
	t.Helper()

	fSys := makeMemoryFs(t)
	addFiles(t, fSys, "/a", files)

	checkRun(t, fSys, "/a", "/", "/dst")
	fSysExpected := makeMemoryFs(t)
	addFiles(t, fSysExpected, "/a", files)
	addFiles(t, fSysExpected, "/dst/a", files)
	checkFSys(t, fSysExpected, fSys)
}

func TestTargetIsScope(t *testing.T) {
	kustomization := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
namePrefix: my-
`,
	}
	fSysExpected, fSysActual := makeFileSystems(t, "/a", kustomization)

	checkRun(t, fSysActual, "/a", "/a", "/a/b/dst")
	addFiles(t, fSysExpected, "/a/b/dst", kustomization)
	checkFSys(t, fSysExpected, fSysActual)
}

func TestTargetNestedInScope(t *testing.T) {
	kustomization := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
patches:
- patch: |-
    - op: replace
      path: /some/existing/path
      value: new value
  target:
    kind: Deployment
    labelSelector: env=dev
`,
	}
	fSysExpected, fSysActual := makeFileSystems(t, "/a/b", kustomization)

	checkRun(t, fSysActual, "/a/b", "/", "/a/b/dst")
	addFiles(t, fSysExpected, "/a/b/dst/a/b", kustomization)
	checkFSys(t, fSysExpected, fSysActual)
}

func TestLoadKustomizationName(t *testing.T) {
	kustomization := map[string]string{
		"Kustomization": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
labels:
- pairs:
    label-one: value-one
    label-two: value-two
`,
	}
	checkLocalizeInTargetSuccess(t, kustomization)
}

func TestLoadGVKNN(t *testing.T) {
	for name, kustomization := range map[string]string{
		"missing": `namePrefix: my-
`,
		"wrong": `kind: NotChecked
`,
	} {
		t.Run(name, func(t *testing.T) {
			files := map[string]string{
				"kustomization.yaml": kustomization,
			}
			checkLocalizeInTargetSuccess(t, files)
		})
	}
}

func TestLoadLegacyFields(t *testing.T) {
	kustomization := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
commonLabels:
  app: bingo
imageTags:
- name: postgres
  newName: my-registry/my-postgres
  newTag: v1
kind: Kustomization
`,
	}
	checkLocalizeInTargetSuccess(t, kustomization)
}

func TestLoadUnknownKustFields(t *testing.T) {
	fSysExpected, fSysTest := makeFileSystems(t, "/a", map[string]string{
		"kustomization.yaml": `namePrefix: valid
suffix: invalid`,
	})

	_, err := Run("/a", "", "", fSysTest)
	require.EqualError(t, err,
		`unable to localize target "/a": invalid Kustomization: json: unknown field "suffix"`)

	checkFSys(t, fSysExpected, fSysTest)
}

func TestLocalizeFileName(t *testing.T) {
	for name, path := range map[string]string{
		"nested_directories":                  "a/b/c/d/patch.yaml",
		"localize_dir_name_when_no_remote":    LocalizeDir,
		"in_localize_dir_name_when_no_remote": fmt.Sprintf("%s/patch.yaml", LocalizeDir),
		"no_file_extension":                   "patch",
		"kustomization_name":                  "a/kustomization.yaml",
	} {
		t.Run(name, func(t *testing.T) {
			kustAndPatch := map[string]string{
				"kustomization.yaml": fmt.Sprintf(`apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
patches:
- path: %s
`, path),
				path: podConfiguration,
			}
			checkLocalizeInTargetSuccess(t, kustAndPatch)
		})
	}
}

func TestLocalizeFileCleaned(t *testing.T) {
	kustAndPatch := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
patches:
- path: ../gamma/../../../alpha/beta/./gamma/patch.yaml
- path: /alpha/beta/../beta/./gamma/patch2.yaml
`,
		"patch.yaml":  podConfiguration,
		"patch2.yaml": podConfiguration,
	}
	expected, actual := makeFileSystems(t, "/alpha/beta/gamma", kustAndPatch)

	checkRun(t, actual, "/alpha/beta/gamma", "/", "/localized-gamma")
	addFiles(t, expected, "/localized-gamma/alpha/beta/gamma", map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
patches:
- path: patch.yaml
- path: patch2.yaml
`,
		"patch.yaml":  podConfiguration,
		"patch2.yaml": podConfiguration,
	})
	checkFSys(t, expected, actual)
}

func TestLocalizeUnreferencedIgnored(t *testing.T) {
	targetAndUnreferenced := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
configMapGenerator:
- envs:
  - env
  name: referenced-file
kind: Kustomization
`,
		"env":               "APPLE=orange",
		"env.properties":    "USERNAME=password",
		"dir/resource.yaml": podConfiguration,
	}
	expected, actual := makeFileSystems(t, "/alpha/beta", targetAndUnreferenced)

	checkRun(t, actual, "/alpha/beta", "/alpha", "/beta")
	addFiles(t, expected, "/beta/beta", map[string]string{
		"kustomization.yaml": targetAndUnreferenced["kustomization.yaml"],
		"env":                targetAndUnreferenced["env"],
	})
	checkFSys(t, expected, actual)
}

func TestLocalizePatches(t *testing.T) {
	kustAndPatch := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
patches:
- patch: |-
    apiVersion: v1
    kind: Deployment
    metadata:
      labels:
        app.kubernetes.io/version: 1.21.0
      name: dummy-app
  target:
    labelSelector: app.kubernetes.io/name=nginx
- options:
    allowNameChange: true
  path: patch.yaml
`,
		"patch.yaml": podConfiguration,
	}
	checkLocalizeInTargetSuccess(t, kustAndPatch)
}

func TestLocalizeOpenAPI(t *testing.T) {
	type testCase struct {
		name  string
		files map[string]string
	}
	for _, test := range []testCase{
		{
			name: "no_path",
			files: map[string]string{
				"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
openapi:
  version: v1.20.4
`,
			},
		},
		{
			name: "path",
			files: map[string]string{
				"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
openapi:
  path: openapi.json
`,
				"openapi.json": `{
  "definitions": {
    "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": {
      "properties": {
        "name": {
          "type": "string"
        }
      },
      "type": "object"
    }
  }
}`,
			},
		},
	} {
		t.Run(test.name, func(t *testing.T) {
			checkLocalizeInTargetSuccess(t, test.files)
		})
	}
}

func TestLocalizeConfigurations(t *testing.T) {
	kustAndConfigs := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
configurations:
- commonLabels.yaml
- namePrefix.yaml
kind: Kustomization
`,
		"commonLabels.yaml": `commonLabels:
- path: new/path
  create: true`,
		"namePrefix.yaml": `namePrefix:
- version: v1
  path: metadata/name
- group: custom
  path: metadata/name`,
	}
	checkLocalizeInTargetSuccess(t, kustAndConfigs)
}

func TestLocalizeCrds(t *testing.T) {
	kustAndCrds := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
crds:
- crd1.yaml
- crd2.yaml
kind: Kustomization
`,
		"crd1.yaml": `apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: controller.stable.example.com`,
		"crd2.yaml": `apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
  name: crontabs.stable.example.com
scope: Cluster`,
	}
	checkLocalizeInTargetSuccess(t, kustAndCrds)
}

func TestLocalizePatchesJson(t *testing.T) {
	kustAndPatches := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
patchesJson6902:
- path: patch.yaml
  target:
    annotationSelector: zone=west
    name: pod
    version: v1
- patch: '[{"op": "add", "path": "/new/path", "value": "value"}]'
  target:
    group: apps
    kind: Pod
- path: patch.json
  target:
    namespace: my
`,
		"patch.yaml": `- op: add
  path: /some/new/path
  value: value
- op: replace
  path: /some/existing/path
  value: new value`,
		"patch.json": ` [
   {"op": "copy", "from": "/here", "path": "/there"},
   {"op": "remove", "path": "/some/existing/path"},
 ]`,
	}
	checkLocalizeInTargetSuccess(t, kustAndPatches)
}

func TestLocalizePatchesSM(t *testing.T) {
	kustAndPatches := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
patchesStrategicMerge:
- |-
  apiVersion: v1
  kind: ConfigMap
  metadata:
    name: map
  data:
  - APPLE: orange
- patch.yaml
`,
		"patch.yaml": podConfiguration,
	}
	checkLocalizeInTargetSuccess(t, kustAndPatches)
}

func TestLocalizeReplacements(t *testing.T) {
	kustAndReplacement := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
replacements:
- path: replacement.yaml
- source:
    fieldPath: path.0
    name: map
  targets:
  - fieldPaths:
    - path
    select:
      name: my-map
`,
		"replacement.yaml": replacements,
	}
	checkLocalizeInTargetSuccess(t, kustAndReplacement)
}

func TestLocalizeConfigMapGenerator(t *testing.T) {
	kustAndData := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
configMapGenerator:
- env: single.env
  envs:
  - standard.env
  namespace: my
  options:
    immutable: true
- behavior: merge
  files:
  - key.properties
  literals:
  - PEAR=pineapple
kind: Kustomization
metadata:
  name: test
`,
		"single.env": `MAY=contain
MORE=than
ONE=pair`,
		"standard.env": `SIZE=0.1
IS_GLOBAL=true`,
		"key.properties": "value",
	}
	checkLocalizeInTargetSuccess(t, kustAndData)
}

func TestLocalizeSecretGenerator(t *testing.T) {
	kustAndData := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
secretGenerator:
- behavior: create
  files:
  - key=b/value.properties
  - b/value
  name: secret
- envs:
  - crt
  - key
  type: kubernetes.io/tls
- literals:
  - APPLE=orange
  - PLUM=pluot
  name: no-files
- env: more-fruit
`,
		"crt":                "tls.crt=LS0tLS1CRUd...0tLQo=",
		"key":                "tls.key=LS0tLS1CRUd...0tLQo=",
		"more-fruit":         "GRAPE=lime",
		"b/value.properties": "value",
		"b/value":            "value",
	}
	checkLocalizeInTargetSuccess(t, kustAndData)
}

func TestLocalizeFileNoFile(t *testing.T) {
	kustAndPatch := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
patches:
- path: name-DNE.yaml
`,
	}
	expected, actual := makeFileSystems(t, "/a/b", kustAndPatch)

	_, err := Run("/a/b", "", "/dst", actual)
	require.EqualError(t, err, `unable to localize target "/a/b": unable to localize patches: invalid file reference: '/a/b/name-DNE.yaml' doesn't exist`)

	checkFSys(t, expected, actual)
}

func TestLocalizePluginsInlineAndFile(t *testing.T) {
	for _, test := range []struct {
		name  string
		files map[string]string
	}{
		{
			name: "generators",
			files: map[string]string{
				"kustomization.yaml": `generators:
- generator.yaml
- |
  apiVersion: builtin
  env: second.properties
  kind: ConfigMapGenerator
  metadata:
    name: inline
`,
				"generator.yaml": `apiVersion: builtin
env: first.properties
kind: ConfigMapGenerator
metadata:
  name: file
`,
				"first.properties":  "APPLE=orange",
				"second.properties": "BANANA=pear",
			},
		},
		{
			name: "transformers",
			files: map[string]string{
				"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
transformers:
- |
  apiVersion: builtin
  kind: PatchTransformer
  metadata:
    name: inline
  path: patchSM-one.yaml
- patch.yaml
`,
				"patch.yaml": `apiVersion: builtin
kind: PatchTransformer
metadata:
  name: file
path: patchSM-two.yaml
`,
				"patchSM-one.yaml": podConfiguration,
				"patchSM-two.yaml": podConfiguration,
			},
		},
		{
			name: "validators",
			files: map[string]string{
				"kustomization.yaml": `validators:
- |
  apiVersion: builtin
  kind: ReplacementTransformer
  metadata:
    name: inline
  replacements:
  - path: first.yaml
- second.yaml
`,
				"first.yaml":       replacementTransformerWithPath,
				"second.yaml":      replacementTransformerWithPath,
				"replacement.yaml": replacements,
			},
		},
	} {
		t.Run(test.name, func(t *testing.T) {
			checkLocalizeInTargetSuccess(t, test.files)
		})
	}
}

func TestLocalizeMultiplePluginsInEntry(t *testing.T) {
	kustAndPlugins := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
transformers:
- |
  apiVersion: builtin
  kind: PatchTransformer
  metadata:
    name: one
  path: patchSM-one.yaml
  ---
  apiVersion: builtin
  kind: PatchTransformer
  metadata:
    name: two
  path: patchSM-two.yaml
`,
		"patchSM-one.yaml": podConfiguration,
		"patchSM-two.yaml": podConfiguration,
	}
	checkLocalizeInTargetSuccess(t, kustAndPlugins)
}

func TestLocalizeCleanedPathInPath(t *testing.T) {
	const patchf = `apiVersion: builtin
kind: PatchTransformer
metadata:
  name: cleaned-path
path: %s
`
	kustAndPlugins := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
transformers:
- patch.yaml
`,
		"patch.yaml":   fmt.Sprintf(patchf, "../a/patchSM.yaml"),
		"patchSM.yaml": podConfiguration,
	}
	expected, actual := makeFileSystems(t, "/a", kustAndPlugins)

	checkRun(t, actual, "/a", "/a", "/dst")
	addFiles(t, expected, "/dst", map[string]string{
		"kustomization.yaml": kustAndPlugins["kustomization.yaml"],
		"patch.yaml":         fmt.Sprintf(patchf, "patchSM.yaml"),
		"patchSM.yaml":       kustAndPlugins["patchSM.yaml"],
	})
	checkFSys(t, expected, actual)
}

func TestLocalizeGeneratorsConfigMap(t *testing.T) {
	files := map[string]string{
		"kustomization.yaml": `generators:
- configMapGenerator
`,
		"configMapGenerator": `apiVersion: builtin
behavior: create
env: one.env
envs:
- two.env
- three.env
files:
- four.properties
- key=five.properties
kind: ConfigMapGenerator
metadata:
  name: custom-generator
options:
  disableNameSuffix: true
`,
		"one.env":         "key1=value1",
		"two.env":         "key2=value2",
		"three.env":       "key3=value3",
		"four.properties": "key4=value4",
		"five.properties": "key5=value5",
	}
	checkLocalizeInTargetSuccess(t, files)
}

func TestLocalizeGeneratorsSecret(t *testing.T) {
	files := map[string]string{
		"kustomization.yaml": `generators:
- secretGenerator
`,
		"secretGenerator": `apiVersion: builtin
env: one.env
envs:
- two.env
- three.env
files:
- four.properties
- key=five.properties
kind: SecretGenerator
literals:
- key6=value6
metadata:
  name: custom-generator
`,
		"one.env":         "key1=value1",
		"two.env":         "key2=value2",
		"three.env":       "key3=value3",
		"four.properties": "key4=value4",
		"five.properties": "key5=value5",
	}
	checkLocalizeInTargetSuccess(t, files)
}

func TestLocalizeTransformersPatch(t *testing.T) {
	kustAndPatches := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
transformers:
- |
  apiVersion: builtin
  kind: PatchTransformer
  metadata:
    name: no-path
  patch: '[{"op": "add", "path": "/path", "value": "value"}]'
  target:
    name: pod
- patch.yaml
`,
		"patch.yaml": `apiVersion: builtin
kind: PatchTransformer
metadata:
  name: path
path: patchSM.yaml
`,
		"patchSM.yaml": podConfiguration,
	}
	checkLocalizeInTargetSuccess(t, kustAndPatches)
}

func TestLocalizeTransformersPatchJson(t *testing.T) {
	kustAndPatches := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
transformers:
- patch.yaml
`,
		"patch.yaml": `apiVersion: builtin
kind: PatchJson6902Transformer
metadata:
  name: path
path: nested-patch.yaml
target:
  name: pod
  namespace: test
---
apiVersion: builtin
jsonOp: |-
  op: replace
  path: /path
  value: new value
kind: PatchJson6902Transformer
metadata:
  name: patch6902
target:
  name: deployment
`,
		"nested-patch.yaml": ` [
   {"op": "copy", "from": "/existing/path", "path": "/another/path"},
 ]
`,
	}
	checkLocalizeInTargetSuccess(t, kustAndPatches)
}

func TestLocalizeTransformersPatchSM(t *testing.T) {
	kustAndPatches := map[string]string{
		"kustomization.yaml": `transformers:
- patch.yaml
`,
		"patch.yaml": `apiVersion: builtin
kind: PatchStrategicMergeTransformer
metadata:
  name: path
paths:
- nested-patch.yaml
- |-
  apiVersion: v1
  kind: Pod
  metadata:
    name: my-pod
`,
		"nested-patch.yaml": podConfiguration,
	}
	checkLocalizeInTargetSuccess(t, kustAndPatches)
}

func TestLocalizeTransformersReplacement(t *testing.T) {
	kustAndReplacements := map[string]string{
		"kustomization.yaml": `transformers:
- replacement-transformer.yaml
`,
		"replacement-transformer.yaml": replacementTransformerWithPath,
		"replacement.yaml":             replacements,
	}
	checkLocalizeInTargetSuccess(t, kustAndReplacements)
}

func TestLocalizePluginsNoPaths(t *testing.T) {
	kustAndPlugins := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
transformers:
- |
  apiVersion: different
  kind: MyTransformer
  metadata:
    name: still-copied
  path: /nothing/special
- prefix.yaml
`,
		"prefix.yaml": `apiVersion: builtin
kind: PrefixTransformer
metadata:
  name: other-built-ins-still-copied
prefix: copy
`,
	}
	checkLocalizeInTargetSuccess(t, kustAndPlugins)
}

func TestLocalizeValidators(t *testing.T) {
	kustAndPlugin := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
validators:
- replacement-no-change.yaml
`,
		"replacement-no-change.yaml": replacementTransformerWithPath,
		"replacement.yaml":           replacements,
	}
	checkLocalizeInTargetSuccess(t, kustAndPlugin)
}

func TestLocalizeBuiltinPlugins_SequenceScalarEquivalence(t *testing.T) {
	kustomization := map[string]string{
		"kustomization.yaml": `transformers:
- |
  apiVersion: builtin
  kind: PatchTransformer
  metadata:
    name: path-should-be-scalar-but-accept-sequence
  path:
  - patchSM.yaml
`,
		"patchSM.yaml": podConfiguration,
	}
	checkLocalizeInTargetSuccess(t, kustomization)
}

func TestLocalizeBuiltinPlugins_NotResource(t *testing.T) {
	type testCase struct {
		name         string
		files        map[string]string
		errPrefix    string
		inlineErrMsg string
		fileErrMsg   string
	}
	for _, test := range []testCase{
		{
			name: "bad_inline_resource",
			files: map[string]string{
				"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
generators:
- |
  apiVersion: builtin
  kind: ConfigMapGenerator
kind: Kustomization
`,
			},
			errPrefix:    `unable to load generators entry: unable to load resource entry "apiVersion: builtin\nkind: ConfigMapGenerator\n"`,
			inlineErrMsg: `missing metadata.name in object {{builtin ConfigMapGenerator} {{ } map[] map[]}}`,
			fileErrMsg: `invalid file reference: '/apiVersion: builtin
kind: ConfigMapGenerator
' doesn't exist`,
		},
		{
			name: "bad_file_resource",
			files: map[string]string{
				"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
transformers:
- plugin.yaml
`,
				"plugin.yaml": `apiVersion: builtin
metadata:
  name: PatchTransformer
`,
			},
			errPrefix:    `unable to load transformers entry: unable to load resource entry "plugin.yaml"`,
			inlineErrMsg: `missing Resource metadata`,
			fileErrMsg:   `missing kind in object {{builtin } {{PatchTransformer } map[] map[]}}`,
		},
	} {
		t.Run(test.name, func(t *testing.T) {
			expected, actual := makeFileSystems(t, "/", test.files)

			_, err := Run("/", "", "/dst", actual)

			var actualErr ResourceLoadError
			require.ErrorAs(t, err, &actualErr)
			require.EqualError(t, actualErr.InlineError, test.inlineErrMsg)
			require.EqualError(t, actualErr.FileError, test.fileErrMsg)

			require.EqualError(t, err, fmt.Sprintf(`unable to localize target "/": %s: when parsing as inline received error: %s
when parsing as filepath received error: %s`, test.errPrefix, test.inlineErrMsg, test.fileErrMsg))

			checkFSys(t, expected, actual)
		})
	}
}

func TestLocalizeBuiltinPlugins_Errors(t *testing.T) {
	for name, test := range map[string]struct {
		files        map[string]string
		fieldSpecErr string
		locErr       string
	}{
		"file_dne": {
			files: map[string]string{
				"kustomization.yaml": `transformers:
- |
  apiVersion: builtin
  kind: PatchTransformer
  metadata:
    name: file-does-not-exist
  path: patchSM.yaml
`,
			},
			fieldSpecErr: "considering field 'path' of object PatchTransformer.builtin.[noGrp]/file-does-not-exist.[noNs]",
			locErr:       "invalid file reference: '/a/patchSM.yaml' doesn't exist",
		},
		"not_sequence_or_scalar": {
			files: map[string]string{
				"kustomization.yaml": `transformers:
- |
  apiVersion: builtin
  kind: PatchTransformer
  metadata:
    name: path-node-has-wrong-kind
  path:
    mappingNode: patchSM.yaml
`,
				"patchSM.yaml": podConfiguration,
			},
			fieldSpecErr: "considering field 'path' of object PatchTransformer.builtin.[noGrp]/path-node-has-wrong-kind.[noNs]",
			locErr:       "expected sequence or scalar node",
		},
	} {
		t.Run(name, func(t *testing.T) {
			expected, actual := makeFileSystems(t, "/a", test.files)
			_, err := Run("/a", "", "/dst", actual)
			const errPrefix = `unable to localize target "/a"`
			require.EqualError(t, err, fmt.Sprintf(
				"%s: %s: %s", errPrefix, test.fieldSpecErr, test.locErr))
			checkFSys(t, expected, actual)
		})
	}
}

func TestLocalizeDirInTarget(t *testing.T) {
	type testCase struct {
		name  string
		files map[string]string
	}
	for _, tc := range []testCase{
		{
			name: "multi_nested_child",
			files: map[string]string{
				"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
components:
- delta/epsilon
kind: Kustomization
`,
				"delta/epsilon/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1alpha1
kind: Component
namespace: kustomize-namespace
`,
			},
		},
		{
			name: "recursive",
			files: map[string]string{
				"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
components:
- delta
kind: Kustomization
`,
				"delta/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1alpha1
components:
- epsilon
kind: Component
`,
				"delta/epsilon/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1alpha1
kind: Component
namespace: kustomize-namespace
`,
			},
		},
		{
			name: "file_in_dir",
			files: map[string]string{
				"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
components:
- delta
kind: Kustomization
`,
				"delta/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1alpha1
kind: Component
patches:
- path: patch.yaml
`,
				"delta/patch.yaml": podConfiguration,
			},
		},
		{
			name: "multiple_calls",
			files: map[string]string{
				"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
components:
- delta
- delta/epsilon
kind: Kustomization
`,
				"delta/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1alpha1
kind: Component
namespace: kustomize-namespace
`,
				"delta/epsilon/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1alpha1
buildMetadata:
- managedByLabel
kind: Component
`,
			},
		},
		{
			name: "localize_directory_name_when_no_remote",
			files: map[string]string{
				"kustomization.yaml": fmt.Sprintf(`apiVersion: kustomize.config.k8s.io/v1beta1
components:
- %s
kind: Kustomization
`, LocalizeDir),
				fmt.Sprintf("%s/kustomization.yaml", LocalizeDir): `apiVersion: kustomize.config.k8s.io/v1alpha1
kind: Component
namespace: kustomize-namespace
`,
			},
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			checkLocalizeInTargetSuccess(t, tc.files)
		})
	}
}

func TestLocalizeDirCleanedSibling(t *testing.T) {
	kustAndComponents := map[string]string{
		// This test checks that winding paths that might traverse through directories
		// outside of scope, which will not be present at destination, are cleaned.
		"beta/gamma/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
components:
- delta/../../../../a/b/../../alpha/beta/sibling
kind: Kustomization`,
		"beta/sibling/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1alpha1
kind: Component
namespace: kustomize-namespace
`,
	}
	expected, actual := makeFileSystems(t, "/alpha", kustAndComponents)

	checkRun(t, actual, "/alpha/beta/gamma", "/alpha", "/alpha/beta/dst")
	cleanedFiles := map[string]string{
		"beta/gamma/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
components:
- ../sibling
kind: Kustomization
`,
		"beta/sibling/kustomization.yaml": kustAndComponents["beta/sibling/kustomization.yaml"],
	}
	addFiles(t, expected, "/alpha/beta/dst", cleanedFiles)
	checkFSys(t, expected, actual)
}

func TestLocalizeBases(t *testing.T) {
	kustAndBases := map[string]string{
		"kustomization.yaml": `bases:
- b
- c/d
`,
		"b/kustomization.yaml": `kind: Kustomization
`,
		"c/d/kustomization.yaml": `kind: Kustomization
`,
	}
	checkLocalizeInTargetSuccess(t, kustAndBases)
}

func TestLocalizeComponents(t *testing.T) {
	kustAndComponents := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
components:
- a
- alpha
kind: Kustomization
`,
		"a/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1alpha1
kind: Component
namePrefix: my-
`,
		"alpha/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1alpha1
kind: Component
nameSuffix: -test
`,
	}
	checkLocalizeInTargetSuccess(t, kustAndComponents)
}

func TestLocalizeResources(t *testing.T) {
	kustAndResources := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- pod.yaml
- /a/b/pod2.yaml
- ../../alpha
`,
		"pod.yaml":  podConfiguration,
		"pod2.yaml": podConfiguration,
		"../../alpha/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
namePrefix: my-
`,
	}

	// Absolute path of `/a/b/pod2.yaml` is expected to be converted to a path
	// relative to the kustomization root.
	expectedKustAndResources := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- pod.yaml
- pod2.yaml
- ../../alpha
`,
		"pod.yaml":  podConfiguration,
		"pod2.yaml": podConfiguration,
		"../../alpha/kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
namePrefix: my-
`,
	}

	expectedFs, actualFs := makeFileSystems(t, "/a/b", kustAndResources)

	checkRun(t, actualFs, "/a/b", "/", "/localized-b")
	addFiles(t, expectedFs, "/localized-b/a/b", expectedKustAndResources)
	checkFSys(t, expectedFs, actualFs)
}

func TestLocalizePathError(t *testing.T) {
	kustAndResources := map[string]string{
		"kustomization.yaml": `apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
- b
`,
	}
	expected, actual := makeFileSystems(t, "/a", kustAndResources)

	_, err := Run("/a", "/", "", actual)

	const expectedFileErr = `invalid file reference: '/a/b' must resolve to a file`
	const expectedRootErr = `unable to localize root "b": unable to find one of 'kustomization.yaml', 'kustomization.yml' or 'Kustomization' in directory '/a/b'`
	var actualErr PathLocalizeError
	require.ErrorAs(t, err, &actualErr)
	require.Equal(t, "b", actualErr.Path)
	require.EqualError(t, actualErr.FileError, expectedFileErr)
	require.EqualError(t, actualErr.RootError, expectedRootErr)

	const expectedErrPrefix = `unable to localize target "/a": unable to localize resources entry`
	require.EqualError(t, err, fmt.Sprintf(`%s: could not localize path "b" as file: %s; could not localize path "b" as directory: %s`,
		expectedErrPrefix, expectedFileErr, expectedRootErr))

	checkFSys(t, expected, actual)
}

func TestLocalizeHelmChartInflationGenerator(t *testing.T) {
	helmKust := map[string]string{
		"kustomization.yaml": `helmChartInflationGenerator:
- chartName: nothing-to-localize
  chartRepoUrl: https://itzg.github.io/warcraft-server-charts
  releaseName: moria
- chartName: localize-values
  values: minecraftValues.yaml
  valuesLocal:
    minecraftServer:
      eula: true
  valuesMerge: replace
- chartHome: home
  chartName: copy-chartHome
`,
		"minecraftValues.yaml":               valuesFile,
		"charts/localize-values/values.yaml": valuesFile,
		"home/copy-chartHome/values.yaml":    valuesFile,
	}
	checkLocalizeInTargetSuccess(t, helmKust)
}

func TestLocalizeHelmCharts(t *testing.T) {
	for _, test := range []struct {
		name  string
		files map[string]string
	}{
		{
			name: "charts_only",
			files: map[string]string{
				"kustomization.yaml": `helmCharts:
- name: nothing-to-localize
  repo: https://helm.releases.hashicorp.com
  version: 1.0.0
- includeCRDs: true
  name: localize-valuesFile
  valuesFile: file
- additionalValuesFiles:
  - another
  - third
`,
				"file":                                   valuesFile,
				"another":                                valuesFile,
				"third":                                  valuesFile,
				"charts/nothing-to-localize/values.yaml": valuesFile,
				"charts/localize-valuesFile/values.yaml": valuesFile,
			},
		},
		{
			name: "charts_globals_no_home",
			files: map[string]string{
				"kustomization.yaml": `helmCharts:
- name: default
helmGlobals:
  configHome: .
`,
				"charts/default/values.yaml": valuesFile,
			},
		},
		{
			name: "home_only",
			files: map[string]string{
				"kustomization.yaml": `helmGlobals:
  chartHome: home
`,
				"home/name/values.yaml": valuesFile,
			},
		},
	} {
		t.Run(test.name, func(t *testing.T) {
			checkLocalizeInTargetSuccess(t, test.files)
		})
	}
}

func TestLocalizeHelmChartsNoDefault(t *testing.T) {
	files := map[string]string{
		"kustomization.yaml": `helmGlobals:
  chartHome: home
`,
		"home/name/values.yaml":   valuesFile,
		"charts/name/values.yaml": valuesFile,
	}
	expected, actual := makeFileSystems(t, "/a", files)

	checkRun(t, actual, "/a", "/a", "/dst")
	addFiles(t, expected, "/dst", map[string]string{
		"kustomization.yaml":    files["kustomization.yaml"],
		"home/name/values.yaml": valuesFile,
	})
	checkFSys(t, expected, actual)
}

func TestCopyChartHomeSimple(t *testing.T) {
	for _, test := range []struct {
		name  string
		files map[string]string
	}{
		{
			name: "does_not_exist",
			files: map[string]string{
				"kustomization.yaml": `helmGlobals:
  chartHome: untar-dir
`,
			},
		},
		{
			name: "chart_home_structure",
			files: map[string]string{
				"kustomization.yaml": `helmGlobals:
  chartHome: home
`,
				"home/minecraft-3.1.3.tgz": "blah",
				"home/terraform-1.0.0.tgz": "la",
				"home/minecraft/Chart.yaml": `annotations:
  artifacthub.io/links: |
  - name: source
    url: https://minecraft.net/
`,
				"home/terraform/Chart.yaml": `description: Minecraft server
`,
			},
		},
	} {
		t.Run(test.name, func(t *testing.T) {
			checkLocalizeInTargetSuccess(t, test.files)
		})
	}
}

func TestCopyChartHomeChanges(t *testing.T) {
	for name, test := range map[string]struct {
		files       map[string]string
		copiedFiles map[string]string
	}{
		"clean_does_not_exist": {
			files: map[string]string{
				"kustomization.yaml": `helmGlobals:
  chartHome: ../b/home
`,
			},
			copiedFiles: map[string]string{
				"kustomization.yaml": `helmGlobals:
  chartHome: home
`,
			},
		},
		"clean_default": {
			files: map[string]string{
				"kustomization.yaml": `helmGlobals:
  chartHome: ../b/charts
`,
				"charts/name/values.yaml": valuesFile,
			},
			copiedFiles: map[string]string{
				"kustomization.yaml": `helmGlobals:
  chartHome: charts
`,
				"charts/name/values.yaml": valuesFile,
			},
		},
		"not_copied": {
			files: map[string]string{
				"kustomization.yaml": `helmCharts:
- name: name
  valuesFile: home/name/values.yaml
helmGlobals:
  chartHome: home
`,
				"home/name/values.yaml":      valuesFile,
				"home/name/many-other-files": "other contents",
			},
			copiedFiles: map[string]string{
				"kustomization.yaml": `helmCharts:
- name: name
  valuesFile: home/name/values.yaml
helmGlobals:
  chartHome: home
`,
				"home/name/values.yaml": valuesFile,
			},
		},
		"does_not_exist_exits_scope": {
			files: map[string]string{
				"kustomization.yaml": `helmGlobals:
  chartHome: ../home
`,
				"../../home/will-exist-at-dst/values.yaml": valuesFile,
			},
			copiedFiles: map[string]string{
				"kustomization.yaml": `helmGlobals:
  chartHome: ../home
`,
			},
		},
	} {
		t.Run(name, func(t *testing.T) {
			expected, actual := makeFileSystems(t, "/a/b", test.files)

			checkRun(t, actual, "/a/b", "/a/b", "/dst")
			addFiles(t, expected, "/dst", test.copiedFiles)
			checkFSys(t, expected, actual)
		})
	}
}

func TestCopyChartHomeEmpty(t *testing.T) {
	kustomization := map[string]string{
		"kustomization.yaml": `helmGlobals:
  chartHome: home
`,
	}
	expected, actual := makeFileSystems(t, "/a", kustomization)
	require.NoError(t, actual.Mkdir("/a/home"))
	require.NoError(t, expected.Mkdir("/a/home"))

	checkRun(t, actual, "/a", "/a", "/dst")
	addFiles(t, expected, "/dst", kustomization)
	require.NoError(t, expected.Mkdir("/dst/home"))
	checkFSys(t, expected, actual)
}

func TestCopyChartHomeError(t *testing.T) {
	for name, test := range map[string]struct {
		err   string
		files map[string]string
	}{
		"absolute": {
			err: `unable to copy helmGlobals: absolute path "/a/b/home" not handled in alpha`,
			files: map[string]string{
				"a/b/kustomization.yaml": `helmGlobals:
  chartHome: /a/b/home
`,
				"a/b/home/name/values.yaml": valuesFile,
			},
		},
		"file": {
			err: `unable to copy helmGlobals: unable to copy home "home": invalid chart home: invalid root reference: must build at directory: '/a/b/home': file is not directory`,
			files: map[string]string{
				"a/b/kustomization.yaml": `helmGlobals:
  chartHome: home
`,
				"a/b/home": valuesFile,
			},
		},
		"scope": {
			err: `unable to copy helmGlobals: unable to copy home "../../alpha/home": invalid chart home: root "/alpha/home" outside localize scope "/a"`,
			files: map[string]string{
				"a/b/kustomization.yaml": `helmGlobals:
  chartHome: ../../alpha/home
`,
				"alpha/home/values.yaml": valuesFile,
			},
		},
	} {
		t.Run(name, func(t *testing.T) {
			expected, actual := makeFileSystems(t, "/", test.files)

			_, err := Run("/a/b", "/a", "/dst", actual)
			const prefix = `unable to localize target "/a/b"`
			require.EqualError(t, err, fmt.Sprintf("%s: %s", prefix, test.err))

			checkFSys(t, expected, actual)
		})
	}
}

func TestLocalizeGeneratorsHelm(t *testing.T) {
	files := map[string]string{
		"kustomization.yaml": `generators:
- default.yaml
- explicit.yaml
`,
		"default.yaml": `apiVersion: builtin
kind: HelmChartInflationGenerator
metadata:
  name: no-explicit-references
name: minecraft
releaseName: moria
repo: https://itzg.github.io/minecraft-server-charts
version: 3.1.3
`,
		"explicit.yaml": `additionalValuesFiles:
- time.yaml
- life.yaml
- light.yaml
apiVersion: builtin
chartHome: home
kind: HelmChartInflationGenerator
metadata:
  name: explicit-references
name: mapleStory
valuesFile: mapleValues.yaml
`,
		"time.yaml":                    valuesFile,
		"life.yaml":                    valuesFile,
		"light.yaml":                   valuesFile,
		"mapleValues.yaml":             valuesFile,
		"home/mapleStory/values.yaml":  valuesFile,
		"charts/minecraft/values.yaml": valuesFile,
	}
	checkLocalizeInTargetSuccess(t, files)
}

func TestLocalizeGeneratorsNoHelm(t *testing.T) {
	files := map[string]string{
		"kustomization.yaml": `generators:
- configMap.yaml
`,
		"configMap.yaml": `apiVersion: builtin
kind: ConfigMapGenerator
literals:
- APPLE=orange
metadata:
  name: not-helm-shouldn't-copy-default-helm-chart-home
`,
		"charts/minecraft/values.yaml": valuesFile,
	}
	expected, actual := makeFileSystems(t, "/a", files)

	checkRun(t, actual, "/a", "/a", "/dst")
	addFiles(t, expected, "/dst", map[string]string{
		"kustomization.yaml": files["kustomization.yaml"],
		"configMap.yaml":     files["configMap.yaml"],
	})
	checkFSys(t, expected, actual)
}

func TestLocalizeEmpty(t *testing.T) {
	for name, kustomization := range map[string]string{
		"file": `configurations:
- ""
`,
		"root": `bases:
- ""
`,
		"resource": `resources:
- ""
`,
		"generator_file_src": `configMapGenerator:
- files:
  - ""
`,
		"patchesStrategicMerge": `patchesStrategicMerge:
- ""
`,
		"custom_transformers": `transformers:
- ""
`,
		"custom_transformer_field": `transformers:
- |
  apiVersion: builtin
  kind: PatchStrategicMergeTransformer
  metadata:
    name: empty
  paths:
  - ""
`,
	} {
		t.Run(name, func(t *testing.T) {
			checkLocalizeInTargetSuccess(t, map[string]string{
				"kustomization.yaml": kustomization,
			})
		})
	}
}