fix: Make sure Load is consistent

Load used to load differently files that don't have the same notation,
for example:

```yaml
foo.bar: baz
```

would load differently than

```yaml
foo:
  bar: baz
```

This commit fixes it.

Signed-off-by: Djordje Lukic <djordje.lukic@docker.com>

Author: rumpl

BUILDING.md

@@ -91,7 +91,7 @@ During the automated CI, the unit tests and end-to-end tests are run as
 part of the PR validation. As a developer you can run these tests
 locally by using any of the following `Makefile` targets:
 
-- `make test`: run all non-end-to-end tests
+- `make test-unit`: run all non-end-to-end tests
 - `make test-e2e`: run all end-to-end tests
 
 To execute a specific test or set of tests you can use the `go test`

render/render_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/deislabs/cnab-go/bundle"
 	"github.com/docker/app/types"
+	"github.com/docker/app/types/parameters"
 	composetypes "github.com/docker/cli/cli/compose/types"
 	yaml "gopkg.in/yaml.v2"
 	"gotest.tools/assert"
@@ -232,3 +233,31 @@ func TestServiceImageOverride(t *testing.T) {
 	assert.Check(t, is.Len(c.Services, 1))
 	assert.Check(t, is.Equal(c.Services[0].Image, "test"))
 }
+
+func TestRenderShouldMergeNonUniformParameters(t *testing.T) {
+	metadata := strings.NewReader(validMeta)
+	composeFile := strings.NewReader(`
+version: "3.6"
+services:
+  any:
+    image: none/none
+    environment:
+      SSH_USER: ${ssh.user}
+`)
+	p := strings.NewReader(`
+ssh.user: FILLME
+`)
+	parametersOverride := strings.NewReader(`
+ssh:
+  user: sirtea
+`)
+	app := &types.App{Path: "my-app"}
+	assert.NilError(t, types.Metadata(metadata)(app))
+	assert.NilError(t, types.WithComposes(composeFile)(app))
+	assert.NilError(t, types.WithParameters(p, parametersOverride)(app))
+	params := app.Parameters()
+	assert.Equal(t, len(params), 1)
+	assert.DeepEqual(t, params, parameters.Parameters{
+		"ssh": map[string]interface{}{"user": "sirtea"},
+	})
+}

types/parameters/load.go

@@ -30,13 +30,18 @@ func Load(data []byte, ops ...func(*Options)) (Parameters, error) {
 	if err != nil {
 		return nil, err
 	}
-	parameters := converted.(map[string]interface{})
+	params := converted.(map[string]interface{})
 	if options.prefix != "" {
-		parameters = map[string]interface{}{
-			options.prefix: parameters,
+		params = map[string]interface{}{
+			options.prefix: params,
 		}
 	}
-	return parameters, nil
+	// Make sure params are always loaded expanded
+	expandedParams, err := FromFlatten(flatten(params))
+	if err != nil {
+		return nil, err
+	}
+	return expandedParams, nil
 }
 
 // LoadMultiple loads multiple data in parameters

types/parameters/load_test.go

@@ -43,6 +43,16 @@ baz:
 	}))
 }
 
+func TestLoadSameWithDifferentNotation(t *testing.T) {
+	flatParameters, err := Load([]byte(`foo.bar: baz`))
+	assert.NilError(t, err)
+	expandedParameters, err := Load([]byte(`
+foo:
+  bar: "baz"`))
+	assert.NilError(t, err)
+	assert.Check(t, is.DeepEqual(flatParameters, expandedParameters))
+}
+
 func TestLoadWithPrefix(t *testing.T) {
 	parameters, err := Load([]byte(`
 foo: bar