get.porter.sh/porter@v1.3.0/pkg/porter/parameters_test.go

package porter

import (
	"context"
	"fmt"
	"sort"
	"testing"

	"get.porter.sh/porter/pkg/cnab"
	"get.porter.sh/porter/pkg/config"
	"get.porter.sh/porter/pkg/printer"
	"get.porter.sh/porter/pkg/secrets"
	"get.porter.sh/porter/pkg/storage"
	"get.porter.sh/porter/pkg/test"
	"get.porter.sh/porter/pkg/yaml"
	"get.porter.sh/porter/tests"
	"github.com/cnabio/cnab-go/bundle"
	"github.com/cnabio/cnab-go/bundle/definition"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestDisplayValuesSort(t *testing.T) {
	v := DisplayValues{
		{Name: "b"},
		{Name: "c"},
		{Name: "a"},
	}

	sort.Sort(v)

	assert.Equal(t, "a", v[0].Name)
	assert.Equal(t, "b", v[1].Name)
	assert.Equal(t, "c", v[2].Name)
}

func TestGenerateParameterSet(t *testing.T) {
	p := NewTestPorter(t)
	defer p.Close()

	p.TestConfig.TestContext.AddTestFile("testdata/bundle.json", "/bundle.json")

	opts := ParameterOptions{
		Silent: true,
	}
	opts.Namespace = "dev"
	opts.Name = "kool-params"
	opts.Labels = []string{"env=dev"}
	opts.CNABFile = "/bundle.json"
	ctx := context.Background()

	err := opts.Validate(ctx, nil, p.Porter)
	require.NoError(t, err, "Validate failed")

	err = p.GenerateParameters(ctx, opts)
	require.NoError(t, err, "no error should have existed")
	creds, err := p.Parameters.GetParameterSet(ctx, opts.Namespace, "kool-params")
	require.NoError(t, err, "expected parameter to have been generated")
	assert.Equal(t, map[string]string{"env": "dev"}, creds.Labels)
}

func TestPorter_ListParameters(t *testing.T) {
	p := NewTestPorter(t)
	defer p.Close()
	ctx := context.Background()
	require.NoError(t, p.TestParameters.InsertParameterSet(ctx, storage.NewParameterSet("", "shared-mysql")))
	require.NoError(t, p.TestParameters.InsertParameterSet(ctx, storage.NewParameterSet("dev", "carolyn-wordpress")))
	require.NoError(t, p.TestParameters.InsertParameterSet(ctx, storage.NewParameterSet("dev", "vaughn-wordpress")))
	require.NoError(t, p.TestParameters.InsertParameterSet(ctx, storage.NewParameterSet("test", "staging-wordpress")))
	require.NoError(t, p.TestParameters.InsertParameterSet(ctx, storage.NewParameterSet("test", "iat-wordpress")))
	require.NoError(t, p.TestParameters.InsertParameterSet(ctx, storage.NewParameterSet("test", "shared-mysql")))

	t.Run("all-namespaces", func(t *testing.T) {
		opts := ListOptions{AllNamespaces: true}
		results, err := p.ListParameters(ctx, opts)
		require.NoError(t, err)
		assert.Len(t, results, 6)
	})

	t.Run("local namespace", func(t *testing.T) {
		opts := ListOptions{Namespace: "dev"}
		results, err := p.ListParameters(ctx, opts)
		require.NoError(t, err)
		assert.Len(t, results, 2)

		opts = ListOptions{Namespace: "test"}
		results, err = p.ListParameters(ctx, opts)
		require.NoError(t, err)
		assert.Len(t, results, 3)
	})

	t.Run("global namespace", func(t *testing.T) {
		opts := ListOptions{Namespace: ""}
		results, err := p.ListParameters(ctx, opts)
		require.NoError(t, err)
		assert.Len(t, results, 1)
	})
}

func Test_loadParameters_paramNotDefined(t *testing.T) {
	t.Parallel()

	r := NewTestPorter(t)
	defer r.Close()

	b := cnab.NewBundle(bundle.Bundle{
		Parameters: map[string]bundle.Parameter{},
	})

	overrides := map[string]string{
		"foo": "bar",
	}

	i := storage.Installation{}
	_, err := r.finalizeParameters(context.Background(), i, b, "action", overrides)
	require.EqualError(t, err, "parameter foo not defined in bundle")
}

func Test_loadParameters_definitionNotDefined(t *testing.T) {
	t.Parallel()

	r := NewTestPorter(t)
	defer r.Close()

	b := cnab.NewBundle(bundle.Bundle{
		Parameters: map[string]bundle.Parameter{
			"foo": {
				Definition: "foo",
			},
		},
	})

	overrides := map[string]string{
		"foo": "bar",
	}

	i := storage.Installation{}
	_, err := r.finalizeParameters(context.Background(), i, b, "action", overrides)
	require.EqualError(t, err, "definition foo not defined in bundle")
}

func Test_loadParameters_applyTo(t *testing.T) {
	t.Parallel()

	r := NewTestPorter(t)
	defer r.Close()

	// Here we set default values, but expect nil/empty
	// values for parameters that do not apply to a given action
	b := cnab.NewBundle(bundle.Bundle{
		Definitions: definition.Definitions{
			"foo": &definition.Schema{
				Type:    "string",
				Default: "default-foo-value",
			},
			"bar": &definition.Schema{
				Type:    "integer",
				Default: "default-bar-value",
			},
			"true": &definition.Schema{
				Type:    "boolean",
				Default: "default-true-value",
			},
		},
		Parameters: map[string]bundle.Parameter{
			"foo": {
				Definition: "foo",
				ApplyTo: []string{
					"action",
				},
			},
			"bar": {
				Definition: "bar",
			},
			"true": {
				Definition: "true",
				ApplyTo: []string{
					"different-action",
				},
			},
		},
	})

	overrides := map[string]string{
		"foo":  "FOO",
		"bar":  "456",
		"true": "false",
	}

	i := storage.Installation{}
	params, err := r.finalizeParameters(context.Background(), i, b, "action", overrides)
	require.NoError(t, err)

	require.Equal(t, "FOO", params["foo"], "expected param 'foo' to be updated")
	require.EqualValues(t, 456, params["bar"], "expected param 'bar' to be updated")
	require.Equal(t, nil, params["true"], "expected param 'true' to be nil as it does not apply")
}

func Test_loadParameters_applyToBundleDefaults(t *testing.T) {
	t.Parallel()

	r := NewTestPorter(t)
	defer r.Close()

	b := cnab.NewBundle(bundle.Bundle{
		Definitions: definition.Definitions{
			"foo": &definition.Schema{
				Type:    "string",
				Default: "foo-default",
			},
		},
		Parameters: map[string]bundle.Parameter{
			"foo": {
				Definition: "foo",
				ApplyTo: []string{
					"different-action",
				},
			},
		},
	})

	i := storage.Installation{}
	params, err := r.finalizeParameters(context.Background(), i, b, "action", nil)
	require.NoError(t, err)

	require.Equal(t, nil, params["foo"], "expected param 'foo' to be nil, regardless of the bundle default, as it does not apply")
}

func Test_loadParameters_requiredButDoesNotApply(t *testing.T) {
	t.Parallel()

	r := NewTestPorter(t)
	defer r.Close()

	b := cnab.NewBundle(bundle.Bundle{
		Definitions: definition.Definitions{
			"foo": &definition.Schema{
				Type: "string",
			},
		},
		Parameters: map[string]bundle.Parameter{
			"foo": {
				Definition: "foo",
				ApplyTo: []string{
					"different-action",
				},
				Required: true,
			},
		},
	})

	i := storage.Installation{}
	params, err := r.finalizeParameters(context.Background(), i, b, "action", nil)
	require.NoError(t, err)

	require.Equal(t, nil, params["foo"], "expected param 'foo' to be nil, regardless of claim value, as it does not apply")
}

func Test_loadParameters_fileParameter(t *testing.T) {
	t.Parallel()

	r := NewTestPorter(t)
	defer r.Close()

	r.TestConfig.TestContext.AddTestFile("testdata/file-param", "/path/to/file")

	b := cnab.NewBundle(bundle.Bundle{
		RequiredExtensions: []string{
			cnab.FileParameterExtensionKey,
		},
		Definitions: definition.Definitions{
			"foo": &definition.Schema{
				Type:            "string",
				ContentEncoding: "base64",
			},
		},
		Parameters: map[string]bundle.Parameter{
			"foo": {
				Definition: "foo",
				Required:   true,
				Destination: &bundle.Location{
					Path: "/tmp/foo",
				},
			},
		},
	})

	overrides := map[string]string{
		"foo": "/path/to/file",
	}

	i := storage.Installation{}
	params, err := r.finalizeParameters(context.Background(), i, b, "action", overrides)
	require.NoError(t, err)

	require.Equal(t, "SGVsbG8gV29ybGQh", params["foo"], "expected param 'foo' to be the base64-encoded file contents")
}

func Test_loadParameters_ParameterSourcePrecedence(t *testing.T) {
	t.Parallel()

	t.Run("nothing present, use default", func(t *testing.T) {
		t.Parallel()

		r := NewTestPorter(t)
		defer r.Close()

		r.TestParameters.AddTestParameters("testdata/paramset.json")
		r.TestParameters.AddSecret("foo_secret", "foo_set")

		r.TestConfig.TestContext.AddTestFile("testdata/bundle-with-param-sources.json", "bundle.json")
		b, err := cnab.LoadBundle(r.Context, "bundle.json")
		require.NoError(t, err, "ProcessBundle failed")

		i := storage.Installation{InstallationSpec: storage.InstallationSpec{Name: "mybun"}}
		params, err := r.finalizeParameters(context.Background(), i, b, cnab.ActionUpgrade, nil)
		require.NoError(t, err)
		assert.Equal(t, "foo_default", params["foo"],
			"expected param 'foo' to have default value")
	})

	t.Run("only override present", func(t *testing.T) {
		t.Parallel()

		r := NewTestPorter(t)
		defer r.Close()

		r.TestParameters.AddTestParameters("testdata/paramset.json")
		r.TestParameters.AddSecret("foo_secret", "foo_set")

		r.TestConfig.TestContext.AddTestFile("testdata/bundle-with-param-sources.json", "bundle.json")
		b, err := cnab.LoadBundle(r.Context, "bundle.json")
		require.NoError(t, err, "ProcessBundle failed")

		overrides := map[string]string{
			"foo": "foo_override",
		}

		i := storage.Installation{InstallationSpec: storage.InstallationSpec{Name: "mybun"}}
		params, err := r.finalizeParameters(context.Background(), i, b, cnab.ActionUpgrade, overrides)
		require.NoError(t, err)
		assert.Equal(t, "foo_override", params["foo"],
			"expected param 'foo' to have override value")
	})

	t.Run("only parameter source present", func(t *testing.T) {
		t.Parallel()

		r := NewTestPorter(t)
		defer r.Close()

		r.TestParameters.AddTestParameters("testdata/paramset.json")
		r.TestParameters.AddSecret("foo_secret", "foo_set")

		r.TestConfig.TestContext.AddTestFile("testdata/bundle-with-param-sources.json", "bundle.json")
		b, err := cnab.LoadBundle(r.Context, "bundle.json")
		require.NoError(t, err, "ProcessBundle failed")

		i := r.TestInstallations.CreateInstallation(storage.NewInstallation("", "mybun"))
		c := r.TestInstallations.CreateRun(i.NewRun(cnab.ActionInstall, b), func(r *storage.Run) { r.Bundle = b.Bundle })
		cr := r.TestInstallations.CreateResult(c.NewResult(cnab.StatusSucceeded))
		r.TestInstallations.CreateOutput(cr.NewOutput("foo", []byte("foo_source")))

		params, err := r.finalizeParameters(context.Background(), i, b, cnab.ActionUpgrade, nil)
		require.NoError(t, err)
		assert.Equal(t, "foo_source", params["foo"],
			"expected param 'foo' to have parameter source value")
	})

	t.Run("override > parameter source", func(t *testing.T) {
		t.Parallel()

		r := NewTestPorter(t)
		defer r.Close()

		r.TestParameters.AddTestParameters("testdata/paramset.json")
		r.TestParameters.AddSecret("foo_secret", "foo_set")

		r.TestConfig.TestContext.AddTestFile("testdata/bundle-with-param-sources.json", "bundle.json")
		b, err := cnab.LoadBundle(r.Context, "bundle.json")
		require.NoError(t, err, "ProcessBundle failed")

		overrides := map[string]string{
			"foo": "foo_override",
		}

		i := r.TestInstallations.CreateInstallation(storage.NewInstallation("", "mybun"))
		c := r.TestInstallations.CreateRun(i.NewRun(cnab.ActionInstall, b))
		cr := r.TestInstallations.CreateResult(c.NewResult(cnab.StatusSucceeded))
		r.TestInstallations.CreateOutput(cr.NewOutput("foo", []byte("foo_source")))

		params, err := r.finalizeParameters(context.Background(), i, b, cnab.ActionUpgrade, overrides)
		require.NoError(t, err)
		assert.Equal(t, "foo_override", params["foo"],
			"expected param 'foo' to have parameter override value")
	})

	t.Run("dependency output without type", func(t *testing.T) {
		t.Parallel()

		r := NewTestPorter(t)
		defer r.Close()

		r.TestParameters.AddTestParameters("testdata/paramset.json")
		r.TestParameters.AddSecret("foo_secret", "foo_set")

		r.TestConfig.TestContext.AddTestFile("testdata/bundle-with-param-sources.json", "bundle.json")
		b, err := cnab.LoadBundle(r.Context, "bundle.json")
		require.NoError(t, err, "ProcessBundle failed")

		i := r.TestInstallations.CreateInstallation(storage.NewInstallation("", "mybun-mysql"))
		c := r.TestInstallations.CreateRun(i.NewRun(cnab.ActionInstall, b), func(r *storage.Run) { r.Bundle = b.Bundle })
		cr := r.TestInstallations.CreateResult(c.NewResult(cnab.StatusSucceeded))
		r.TestInstallations.CreateOutput(cr.NewOutput("connstr", []byte("connstr value")))

		params, err := r.finalizeParameters(context.Background(), i, b, cnab.ActionUpgrade, nil)
		require.NoError(t, err)
		assert.Equal(t, "connstr value", params["connstr"],
			"expected param 'connstr' to have parameter value from the untyped dependency output")
	})

	t.Run("merge parameter values", func(t *testing.T) {
		t.Parallel()

		r := NewTestPorter(t)
		defer r.Close()

		r.TestParameters.AddTestParameters("testdata/paramset.json")
		r.TestParameters.AddSecret("foo_secret", "foo_set")

		r.TestConfig.TestContext.AddTestFile("testdata/bundle-with-param-sources.json", "bundle.json")
		b, err := cnab.LoadBundle(r.Context, "bundle.json")
		require.NoError(t, err, "ProcessBundle failed")

		// foo is set by a user
		// bar is set by a parameter source
		// baz is set by the bundle default
		i := r.TestInstallations.CreateInstallation(storage.NewInstallation("", "mybun"))
		c := r.TestInstallations.CreateRun(i.NewRun(cnab.ActionInstall, b))
		cr := r.TestInstallations.CreateResult(c.NewResult(cnab.StatusSucceeded))
		r.TestInstallations.CreateOutput(cr.NewOutput("foo", []byte("foo_source")))
		r.TestInstallations.CreateOutput(cr.NewOutput("bar", []byte("bar_source")))
		r.TestInstallations.CreateOutput(cr.NewOutput("baz", []byte("baz_source")))

		overrides := map[string]string{"foo": "foo_override"}
		params, err := r.finalizeParameters(context.Background(), i, b, cnab.ActionUpgrade, overrides)
		require.NoError(t, err)
		assert.Equal(t, "foo_override", params["foo"],
			"expected param 'foo' to have parameter override value")
		assert.Equal(t, "bar_source", params["bar"],
			"expected param 'bar' to have parameter source value")
		assert.Equal(t, "baz_default", params["baz"],
			"expected param 'baz' to have bundle default value")
	})
}

func Test_ParameterTypeConversion(t *testing.T) {
	t.Parallel()
	setup := func() (InstallOptions, storage.Installation) {
		bun := cnab.NewBundle(bundle.Bundle{
			Name:          "mybuns",
			Version:       "1.0.0",
			SchemaVersion: "v1.0.0",
			InvocationImages: []bundle.InvocationImage{
				{BaseImage: bundle.BaseImage{Image: "mybuns:latest", ImageType: "docker"}},
			},
			Definitions: definition.Definitions{
				"string":  &definition.Schema{Type: "string"},
				"number":  &definition.Schema{Type: "number"},
				"integer": &definition.Schema{Type: "integer"},
				"boolean": &definition.Schema{Type: "boolean"},
				"array":   &definition.Schema{Type: "array"},
				"object":  &definition.Schema{Type: "object"},
			},
			Parameters: map[string]bundle.Parameter{
				"string":  {Definition: "string", Required: true, Destination: &bundle.Location{Path: "str"}},
				"number":  {Definition: "number", Required: true, Destination: &bundle.Location{Path: "num"}},
				"integer": {Definition: "integer", Required: true, Destination: &bundle.Location{Path: "int"}},
				"boolean": {Definition: "boolean", Required: true, Destination: &bundle.Location{Path: "bool"}},
				"array":   {Definition: "array", Required: true, Destination: &bundle.Location{Path: "arr"}},
				"object":  {Definition: "object", Required: true, Destination: &bundle.Location{Path: "obj"}},
			},
		})

		opts := NewInstallOptions()
		opts.bundleRef = &cnab.BundleReference{Definition: bun}
		i := storage.NewInstallation(opts.Namespace, opts.Name)
		return opts, i
	}

	testcases := []struct {
		name         string
		parameterSet string
		params       []string
	}{
		{
			name: "command line parameters",
			params: []string{
				"string=abc123",
				"number=3.1415",
				"integer=3",
				"boolean=true",
				`array=[1, "a", 3.1415, [2, "b"], {"c": 3}, false]`,
				`object={"items": ["a", "b", "c", 1, 2, 3], "valid": true }`,
			},
		},
		{
			name:         "native parameter set",
			parameterSet: "testdata/paramset-native.json",
		},
		{
			name:         "stringified parameter set",
			parameterSet: "testdata/paramset-stringified.json",
		},
	}

	for _, tc := range testcases {
		tc := tc
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			p := NewTestPorter(t)
			defer p.Close()

			opts, i := setup()
			opts.Params = tc.params
			if tc.parameterSet != "" {
				p.TestParameters.AddTestParameters(tc.parameterSet)
				opts.ParameterSets = []string{"mypset"}
			}

			err := p.applyActionOptionsToInstallation(context.Background(), opts, &i)
			require.NoError(t, err)
			finalParams := opts.GetParameters()

			expectedParams := map[string]interface{}{
				"string":  "abc123",
				"number":  3.1415,
				"integer": 3,
				"boolean": true,
				"array": []interface{}{
					1.0, "a", 3.1415, []interface{}{2.0, "b"}, map[string]interface{}{"c": 3.0}, false,
				},
				"object": map[string]interface{}{
					"items": []interface{}{"a", "b", "c", 1.0, 2.0, 3.0},
					"valid": true,
				},
			}

			for name, expected := range expectedParams {
				actual, ok := finalParams[name]
				require.True(t, ok, "Parameter %s not found", name)
				assert.Equal(t, expected, actual)
			}
		})
	}
}

// This is intended to cover the matrix of cases around parameter value resolution.
// It exercises the matrix for all supported actions.
func Test_Paramapalooza(t *testing.T) {
	testcases := []struct {
		Name            string
		Required        bool
		Provided        bool
		DefaultExists   bool
		AppliesToAction bool
		ExpectedVal     interface{}
		ExpectedErr     string
	}{
		// Are you ready to enter the Matrix?
		{Name: "required, provided, default exists, applies to action",
			Required: true, Provided: true, DefaultExists: true, AppliesToAction: true, ExpectedVal: "my-param-value",
		},
		{"required, provided, default exists, does not apply to action",
			true, true, true, false, nil, "",
		},
		{"required, provided, default does not exist, applies to action",
			true, true, false, true, "my-param-value", "",
		},
		{"required, provided, default does not exist, does not apply to action",
			true, true, false, false, nil, "",
		},
		// As of writing, bundle.ValuesOrDefaults in cnab-go requires a specific override
		// be provided if applicable to an action.
		// Otherwise, it errors out and does not look up/use default in this case.
		{"required, not provided, default exists, applies to action",
			true, false, true, true, nil, "parameter \"my-param\" is required",
		},
		{"required, not provided, default exists, does not apply to action",
			true, false, true, false, nil, "",
		},
		{"required, not provided, default does not exist, applies to action",
			true, false, false, true, nil, "parameter \"my-param\" is required",
		},
		{"required, not provided, default does not exist, does not apply to action",
			true, false, false, false, nil, "",
		},
		{"not required, provided, default exists, applies to action",
			false, true, true, true, "my-param-value", "",
		},
		{"not required, provided, default exists, does not apply to action",
			false, true, true, false, nil, "",
		},
		{"not required, provided, default does not exist, applies to action",
			false, true, false, true, "my-param-value", "",
		},
		{"not required, provided, default does not exist, does not apply to action",
			false, true, false, false, nil, "",
		},
		{"not required, not provided, default exists, applies to action",
			false, false, true, true, "my-param-default", "",
		},
		{"not required, not provided, default exists, does not apply to action",
			false, false, true, false, nil, "",
		},
		{"not required, not provided, default does not exist, applies to action",
			false, false, false, true, nil, "",
		},
		{"not required, not provided, default does not exist, does not apply to action",
			false, false, false, false, nil, "",
		},
	}

	for _, tc := range testcases {
		tc := tc
		t.Run(tc.Name, func(t *testing.T) {
			t.Parallel()
			actions := []string{"install", "upgrade", "uninstall", "zombies"}
			for _, action := range actions {
				t.Run(action, func(t *testing.T) {

					r := NewTestPorter(t)
					defer r.Close()

					bun := cnab.NewBundle(bundle.Bundle{
						Name:          "mybuns",
						Version:       "1.0.0",
						SchemaVersion: "v1.0.0",
						Actions: map[string]bundle.Action{
							"zombies": {
								Modifies: true,
							},
						},
						InvocationImages: []bundle.InvocationImage{
							{
								BaseImage: bundle.BaseImage{
									Image:     "mybuns:latest",
									ImageType: "docker",
								},
							},
						},
						Definitions: definition.Definitions{
							"my-param": &definition.Schema{
								Type: "string",
							},
						},
						Parameters: map[string]bundle.Parameter{
							"my-param": {
								Definition: "my-param",
								Required:   tc.Required,
								Destination: &bundle.Location{
									EnvironmentVariable: "MY_PARAM",
								},
							},
						},
					})

					if tc.DefaultExists {
						bun.Definitions["my-param"].Default = "my-param-default"
					}

					if !tc.AppliesToAction {
						param := bun.Parameters["my-param"]
						param.ApplyTo = []string{"non-applicable-action"}
						bun.Parameters["my-param"] = param
					}

					i := storage.Installation{InstallationSpec: storage.InstallationSpec{Name: "test"}}
					overrides := map[string]string{}
					// If param is provided (via --param/--param-file)
					// it will be attached to args
					if tc.Provided {
						overrides["my-param"] = "my-param-value"
					}

					resolvedParams, err := r.finalizeParameters(context.Background(), i, bun, action, overrides)
					if tc.ExpectedErr != "" {
						require.EqualError(t, err, tc.ExpectedErr)
					} else {
						require.NoError(t, err)
						assert.Equal(t, tc.ExpectedVal, resolvedParams["my-param"])
					}
				})
			}
		})
	}
}

func TestRuntime_ResolveParameterSources(t *testing.T) {
	t.Parallel()

	r := NewTestPorter(t)
	defer r.Close()

	r.TestConfig.TestContext.AddTestFile("testdata/bundle-with-param-sources.json", "bundle.json")
	bun, err := cnab.LoadBundle(r.Context, "bundle.json")
	require.NoError(t, err, "ProcessBundle failed")

	i := r.TestInstallations.CreateInstallation(storage.NewInstallation("", "mybun-mysql"))
	c := r.TestInstallations.CreateRun(i.NewRun(cnab.ActionInstall, bun), func(r *storage.Run) { r.Bundle = bun.Bundle })
	cr := r.TestInstallations.CreateResult(c.NewResult(cnab.StatusSucceeded))
	r.TestInstallations.CreateOutput(cr.NewOutput("connstr", []byte("connstr value")))

	i = r.TestInstallations.CreateInstallation(storage.NewInstallation("", "mybun"))
	c = r.TestInstallations.CreateRun(i.NewRun(cnab.ActionInstall, bun), func(r *storage.Run) { r.Bundle = bun.Bundle })
	cr = r.TestInstallations.CreateResult(c.NewResult(cnab.StatusSucceeded))
	r.TestInstallations.CreateOutput(cr.NewOutput("bar", []byte("bar value")))

	got, err := r.resolveParameterSources(context.Background(), bun, i)
	require.NoError(t, err, "resolveParameterSources failed")

	want := secrets.Set{
		"bar":     "bar value",
		"connstr": "connstr value",
	}
	assert.Equal(t, want, got, "resolved incorrect parameter values")
}

func TestShowParameters_NotFound(t *testing.T) {
	p := NewTestPorter(t)
	defer p.Close()

	opts := ParameterShowOptions{
		PrintOptions: printer.PrintOptions{
			Format: printer.FormatPlaintext,
		},
		Name: "non-existent-param",
	}

	err := p.ShowParameter(context.Background(), opts)
	assert.ErrorIs(t, err, storage.ErrNotFound{})
}

func TestShowParameters_Found(t *testing.T) {
	type ParameterShowTest struct {
		name               string
		format             printer.Format
		expectedOutputFile string
	}

	testcases := []ParameterShowTest{
		{
			name:               "json",
			format:             printer.FormatJson,
			expectedOutputFile: "testdata/parameters/mypset.json",
		},
		{
			name:               "yaml",
			format:             printer.FormatYaml,
			expectedOutputFile: "testdata/parameters/mypset.yaml",
		},
		{
			name:               "plaintext",
			format:             printer.FormatPlaintext,
			expectedOutputFile: "testdata/parameters/mypset.txt",
		},
	}

	for _, tc := range testcases {
		t.Run(tc.name, func(t *testing.T) {
			p := NewTestPorter(t)
			defer p.Close()

			opts := ParameterShowOptions{
				PrintOptions: printer.PrintOptions{
					Format: tc.format,
				},
				Name: "mypset",
			}

			p.TestParameters.AddTestParameters("testdata/paramset.json")

			err := p.ShowParameter(context.Background(), opts)
			require.NoError(t, err, "an error should not have occurred")
			gotOutput := p.TestConfig.TestContext.GetOutput()
			test.CompareGoldenFile(t, tc.expectedOutputFile, gotOutput)
		})
	}
}

func TestPrintParameters(t *testing.T) {
	p := NewTestPorter(t)
	defer p.Close()

	opts := ListOptions{
		PrintOptions: printer.PrintOptions{
			Format: printer.FormatPlaintext,
		},
		Name: "mypset",
	}

	p.TestParameters.AddTestParameters("testdata/paramset.json")

	err := p.PrintParameters(context.Background(), opts)
	require.NoError(t, err, "an error should not have occurred")
	gotOutput := p.TestConfig.TestContext.GetOutput()
	test.CompareGoldenFile(t, "testdata/parameters/mypsettable.txt", gotOutput)

}

func TestParametersCreateOptions_Validate(t *testing.T) {
	testcases := []struct {
		name       string
		args       []string
		outputType string
		wantErr    string
	}{
		{
			name:       "no fileName defined",
			args:       []string{},
			outputType: "",
			wantErr:    "",
		},
		{
			name:       "two positional arguments",
			args:       []string{"parameter-set1", "parameter-set2"},
			outputType: "",
			wantErr:    "only one positional argument may be specified",
		},
		{
			name:       "no file format defined from file extension or output flag",
			args:       []string{"parameter-set"},
			outputType: "",
			wantErr:    "could not detect the file format from the file extension (.txt). Specify the format with --output",
		},
		{
			name:       "different file format",
			args:       []string{"parameter-set.json"},
			outputType: "yaml",
			wantErr:    "",
		},
		{
			name:       "format from output flag",
			args:       []string{"parameters"},
			outputType: "json",
			wantErr:    "",
		},
		{
			name:       "format from file extension",
			args:       []string{"parameter-set.yml"},
			outputType: "",
			wantErr:    "",
		},
	}

	for _, tc := range testcases {
		t.Run(tc.name, func(t *testing.T) {
			opts := ParameterCreateOptions{OutputType: tc.outputType}
			err := opts.Validate(tc.args)
			if tc.wantErr == "" {
				require.NoError(t, err, "no error should have existed")
				return
			}
			assert.Contains(t, err.Error(), tc.wantErr)
		})
	}
}

func TestParametersCreate(t *testing.T) {
	testcases := []struct {
		name       string
		fileName   string
		outputType string
		wantErr    string
	}{
		{
			name:       "valid input: no input defined, will output yaml format to stdout",
			fileName:   "",
			outputType: "",
			wantErr:    "",
		},
		{
			name:       "valid input: output to stdout with format json",
			fileName:   "",
			outputType: "json",
			wantErr:    "",
		},
		{
			name:       "valid input: file format from fileName",
			fileName:   "fileName.json",
			outputType: "",
			wantErr:    "",
		},
		{
			name:       "valid input: file format from outputType",
			fileName:   "fileName",
			outputType: "json",
			wantErr:    "",
		},
		{
			name:       "valid input: different file format from fileName and outputType",
			fileName:   "fileName.yaml",
			outputType: "json",
			wantErr:    "",
		},
		{
			name:       "valid input: same file format in fileName and outputType",
			fileName:   "fileName.json",
			outputType: "json",
			wantErr:    "",
		},
		{
			name:       "invalid input: invalid file format from fileName",
			fileName:   "fileName.txt",
			outputType: "",
			wantErr:    fmt.Sprintf("unsupported format %s. Supported formats are: yaml and json", "txt"),
		},
		{
			name:       "invalid input: invalid file format from outputType",
			fileName:   "fileName",
			outputType: "txt",
			wantErr:    fmt.Sprintf("unsupported format %s. Supported formats are: yaml and json", "txt"),
		},
	}

	for _, tc := range testcases {
		t.Run(tc.name, func(t *testing.T) {
			p := NewTestPorter(t)
			defer p.Close()

			opts := ParameterCreateOptions{FileName: tc.fileName, OutputType: tc.outputType}
			err := p.CreateParameter(opts)
			if tc.wantErr == "" {
				require.NoError(t, err, "no error should have existed")
				return
			}
			assert.Contains(t, err.Error(), tc.wantErr)
		})
	}
}

func TestPorter_ParametersApply(t *testing.T) {
	t.Run("invalid schemaType", func(t *testing.T) {
		// Make sure that we are validating the display parameter set values, and not just the underlying stored parameter set
		ctx := context.Background()
		p := NewTestPorter(t)
		defer p.Close()

		p.AddTestFile("testdata/parameters/mypset.yaml", "mypset.yaml")
		p.TestConfig.TestContext.EditYaml("mypset.yaml", func(yq *yaml.Editor) error {
			return yq.SetValue("schemaType", "invalidthing")
		})

		opts := ApplyOptions{
			Namespace: "altns",
			File:      "mypset.yaml",
		}
		err := p.ParametersApply(ctx, opts)
		tests.RequireErrorContains(t, err, "invalid schemaType")
	})

	t.Run("valid parameter set", func(t *testing.T) {
		ctx := context.Background()
		p := NewTestPorter(t)
		defer p.Close()

		p.AddTestFile("testdata/parameters/mypset.yaml", "mypset.yaml")
		p.TestConfig.TestContext.EditYaml("mypset.yaml", func(yq *yaml.Editor) error {
			return yq.DeleteNode("namespace")
		})

		opts := ApplyOptions{
			Namespace: "altns", // Import into this namespace since one isn't set in the file (we removed it above)
			File:      "mypset.yaml",
		}
		err := p.ParametersApply(ctx, opts)
		require.NoError(t, err, "ParametersApply failed")

		ps, err := p.Parameters.GetParameterSet(ctx, "altns", "mypset")
		require.NoError(t, err, "Failed to retrieve applied parameter set")

		assert.Equal(t, "mypset", ps.Name, "unexpected parameter set name")
		require.Len(t, ps.Parameters, 1, "expected 1 parameter in the set")
		assert.Equal(t, "foo", ps.Parameters[0].Name, "expected the foo parameter mapping defined")
		assert.Equal(t, "secret", ps.Parameters[0].Source.Strategy, "expected the foo parameter mapping to come from a secret")
		assert.Equal(t, "foo_secret", ps.Parameters[0].Source.Hint, "expected the foo parameter mapping to use foo_secret")
	})
}

func TestParameterRemovedFromBundle(t *testing.T) {
	ctx := context.Background()
	p := NewTestPorter(t)
	p.TestConfig.TestContext.AddTestFile("testdata/porter.yaml", "porter.yaml")
	opts := InstallOptions{
		BundleExecutionOptions: &BundleExecutionOptions{
			Driver: "docker",
			BundleReferenceOptions: &BundleReferenceOptions{
				installationOptions: installationOptions{
					BundleDefinitionOptions: BundleDefinitionOptions{
						File: config.Name,
					},
					Name: "MyInstallation",
				},
			},
		},
	}

	installation := storage.NewInstallation(opts.Namespace, opts.Name)
	installation.Parameters.Parameters = make([]secrets.SourceMap, 1)
	installation.Parameters.Parameters[0] = secrets.SourceMap{
		Name: "removedParam",
		Source: secrets.Source{
			Strategy: "value",
			Hint:     "1",
		},
	}

	err := p.applyActionOptionsToInstallation(ctx, opts, &installation)
	require.NoError(t, err)
}

func Test_DependencyParameterOverride(t *testing.T) {
	ctx := context.Background()
	p := NewTestPorter(t)
	p.TestConfig.TestContext.AddTestFile("testdata/porter.yaml", "porter.yaml")
	opts := InstallOptions{
		BundleExecutionOptions: &BundleExecutionOptions{
			Params: []string{
				"dep#first-param=1",
			},
			Driver: "docker",
			BundleReferenceOptions: &BundleReferenceOptions{
				installationOptions: installationOptions{
					BundleDefinitionOptions: BundleDefinitionOptions{
						File: config.Name,
					},
					Name: "MyInstallation",
				},
			},
		},
	}

	installation := storage.NewInstallation(opts.Namespace, opts.Name)
	err := p.applyActionOptionsToInstallation(ctx, opts, &installation)
	require.NoError(t, err)
	assert.Equal(t, opts.depParams["dep#first-param"], "1")
}