code review

kyaml/runfn/runfn.go

@@ -91,8 +91,8 @@ type RunFns struct {
 	// User username used to run the application in container,
 	User runtimeutil.ContainerUser
 
-	// Envs are environment variables that will be exported to container
-	Envs runtimeutil.ContainerEnvs
+	// Env contains environment variables that will be exported to container
+	Env runtimeutil.ContainerEnv
 }
 
 // Execute runs the command
@@ -272,14 +272,14 @@ func (r RunFns) getFunctionsFromFunctions() ([]kio.Filter, error) {
 	return r.getFunctionFilters(true, r.Functions...)
 }
 
-// mergeContainerEnvs will merge the envs specified by command line (imperative) and config
+// mergeContainerEnv will merge the envs specified by command line (imperative) and config
 // file (declarative). If they have same key, the imperative value will be respected.
-func (r RunFns) mergeContainerEnvs(envs runtimeutil.ContainerEnvs) runtimeutil.ContainerEnvs {
-	for key, value := range r.Envs.EnvsMap {
+func (r RunFns) mergeContainerEnv(envs runtimeutil.ContainerEnv) runtimeutil.ContainerEnv {
+	for key, value := range r.Env.EnvVars {
 		envs.AddKeyValue(key, value)
 	}
 
-	for _, key := range r.Envs.ExportKeys {
+	for _, key := range r.Env.VarsToExport {
 		envs.AddKey(key)
 	}
 
@@ -303,7 +303,7 @@ func (r RunFns) getFunctionFilters(global bool, fns ...*yaml.RNode) (
 		if !r.User.IsEmpty() {
 			spec.Container.User = r.User
 		}
-		spec.Container.Envs = r.mergeContainerEnvs(spec.Container.Envs)
+		spec.Container.Env = r.mergeContainerEnv(spec.Container.Env)
 
 		c, err := r.functionFilterProvider(*spec, api)
 		if err != nil {
@@ -412,7 +412,7 @@ func (r *RunFns) ffp(spec runtimeutil.FunctionSpec, api *yaml.RNode) (kio.Filter
 			Network:       spec.Container.Network,
 			StorageMounts: r.StorageMounts,
 			User:          spec.Container.User,
-			Envs:          spec.Container.Envs,
+			Env:           spec.Container.Env,
 		})
 		cf := &c
 		cf.Exec.FunctionConfig = api

kyaml/runfn/runfn_test.go

@@ -987,102 +987,55 @@ func getFilterProvider(t *testing.T) func(runtimeutil.FunctionSpec, *yaml.RNode)
 	}
 }
 
-func TestRunfns_mergeContainerEnvs(t *testing.T) {
+func TestRunfns_mergeContainerEnv(t *testing.T) {
 	testcases := []struct {
 		name      string
 		instance  RunFns
-		inputEnvs runtimeutil.ContainerEnvs
-		expect    runtimeutil.ContainerEnvs
+		inputEnvs runtimeutil.ContainerEnv
+		expect    runtimeutil.ContainerEnv
 	}{
 		{
 			name:      "all empty",
 			instance:  RunFns{},
-			inputEnvs: runtimeutil.NewContainerEnvs(),
-			expect:    runtimeutil.NewContainerEnvs(),
+			inputEnvs: *runtimeutil.NewContainerEnv(),
+			expect:    *runtimeutil.NewContainerEnv(),
 		},
 		{
-			name:     "empty command line envs",
-			instance: RunFns{},
-			inputEnvs: runtimeutil.ContainerEnvs{
-				EnvsMap: map[string]string{
-					"foo": "bar",
-				},
-			},
-			expect: runtimeutil.ContainerEnvs{
-				EnvsMap: map[string]string{
-					"foo": "bar",
-				},
-			},
+			name:      "empty command line envs",
+			instance:  RunFns{},
+			inputEnvs: *runtimeutil.NewContainerEnvFromStringSlice([]string{"foo=bar"}),
+			expect:    *runtimeutil.NewContainerEnvFromStringSlice([]string{"foo=bar"}),
 		},
 		{
 			name: "empty declarative envs",
 			instance: RunFns{
-				Envs: runtimeutil.ContainerEnvs{
-					EnvsMap: map[string]string{
-						"foo": "bar",
-					},
-				},
-			},
-			inputEnvs: runtimeutil.NewContainerEnvs(),
-			expect: runtimeutil.ContainerEnvs{
-				EnvsMap: map[string]string{
-					"foo": "bar",
-				},
+				Env: *runtimeutil.NewContainerEnvFromStringSlice([]string{"foo=bar"}),
 			},
+			inputEnvs: *runtimeutil.NewContainerEnv(),
+			expect:    *runtimeutil.NewContainerEnvFromStringSlice([]string{"foo=bar"}),
 		},
 		{
 			name: "same key",
 			instance: RunFns{
-				Envs: runtimeutil.ContainerEnvs{
-					EnvsMap: map[string]string{
-						"foo": "bar",
-					},
-					ExportKeys: []string{"foo"},
-				},
-			},
-			inputEnvs: runtimeutil.ContainerEnvs{
-				EnvsMap: map[string]string{
-					"foo": "bar1",
-				},
-				ExportKeys: []string{"bar"},
-			},
-			expect: runtimeutil.ContainerEnvs{
-				EnvsMap: map[string]string{
-					"foo": "bar",
-				},
-				ExportKeys: []string{"bar", "foo"},
+				Env: *runtimeutil.NewContainerEnvFromStringSlice([]string{"foo=bar", "foo"}),
 			},
+			inputEnvs: *runtimeutil.NewContainerEnvFromStringSlice([]string{"foo=bar1", "bar"}),
+			expect:    *runtimeutil.NewContainerEnvFromStringSlice([]string{"foo=bar", "bar", "foo"}),
 		},
 		{
 			name: "same exported key",
 			instance: RunFns{
-				Envs: runtimeutil.ContainerEnvs{
-					EnvsMap: map[string]string{
-						"foo": "bar",
-					},
-					ExportKeys: []string{"foo"},
-				},
-			},
-			inputEnvs: runtimeutil.ContainerEnvs{
-				EnvsMap: map[string]string{
-					"foo1": "bar1",
-				},
-				ExportKeys: []string{"foo"},
-			},
-			expect: runtimeutil.ContainerEnvs{
-				EnvsMap: map[string]string{
-					"foo":  "bar",
-					"foo1": "bar1",
-				},
-				ExportKeys: []string{"foo"},
+				Env: *runtimeutil.NewContainerEnvFromStringSlice([]string{"foo=bar", "foo"}),
 			},
+			inputEnvs: *runtimeutil.NewContainerEnvFromStringSlice([]string{"foo1=bar1", "foo"}),
+			expect:    *runtimeutil.NewContainerEnvFromStringSlice([]string{"foo=bar", "foo1=bar1", "foo"}),
 		},
 	}
 
 	for i := range testcases {
 		tc := testcases[i]
 		t.Run(tc.name, func(t *testing.T) {
-			envs := tc.instance.mergeContainerEnvs(tc.inputEnvs)
+			envs := tc.instance.mergeContainerEnv(tc.inputEnvs)
 			assert.Equal(t, tc.expect.GetDockerFlags(), envs.GetDockerFlags())
 		})
 	}