From 2114e877babb7544bb3923a976486b0481558e51 Mon Sep 17 00:00:00 2001 From: bryanl Date: Fri, 6 Apr 2018 10:05:23 -0400 Subject: [PATCH] Set/unset param globals Signed-off-by: bryanl --- actions/param_delete.go | 22 +++-- actions/param_delete_test.go | 25 ++++++ actions/param_set.go | 35 +++++--- actions/param_set_test.go | 28 ++++++ cmd/param_delete.go | 20 +++-- cmd/param_set.go | 25 ++++-- cmd/param_set_test.go | 19 ++++ pkg/env/params.go | 78 ++++++++++++++++ pkg/env/params_test.go | 22 +++++ pkg/env/testdata/add-global.libsonnet | 3 + pkg/env/testdata/globals.libsonnet | 3 + pkg/env/testdata/remove-global.libsonnet | 2 + pkg/env/util_test.go | 3 + pkg/params/env_globals_set.go | 87 ++++++++++++++++++ pkg/params/env_globals_set_test.go | 57 ++++++++++++ pkg/params/env_globals_unset.go | 89 +++++++++++++++++++ pkg/params/env_globals_unset_test.go | 54 +++++++++++ pkg/params/params.go | 18 ++-- pkg/params/params_test.go | 4 +- .../env/globals/set-global/in.libsonnet | 1 + .../env/globals/set-global/out.libsonnet | 3 + .../env/globals/unset-global/in.libsonnet | 3 + .../env/globals/unset-global/out.libsonnet | 2 + 23 files changed, 558 insertions(+), 45 deletions(-) create mode 100644 pkg/env/testdata/add-global.libsonnet create mode 100644 pkg/env/testdata/globals.libsonnet create mode 100644 pkg/env/testdata/remove-global.libsonnet create mode 100644 pkg/params/env_globals_set.go create mode 100644 pkg/params/env_globals_set_test.go create mode 100644 pkg/params/env_globals_unset.go create mode 100644 pkg/params/env_globals_unset_test.go create mode 100644 pkg/params/testdata/env/globals/set-global/in.libsonnet create mode 100644 pkg/params/testdata/env/globals/set-global/out.libsonnet create mode 100644 pkg/params/testdata/env/globals/unset-global/in.libsonnet create mode 100644 pkg/params/testdata/env/globals/unset-global/out.libsonnet diff --git a/actions/param_delete.go b/actions/param_delete.go index ca0821d7..decec6f7 100644 --- a/actions/param_delete.go +++ b/actions/param_delete.go @@ -26,6 +26,7 @@ import ( type getModuleFn func(ksApp app.App, moduleName string) (component.Module, error) type deleteEnvFn func(ksApp app.App, envName, componentName, paramName string) error +type deleteEnvGlobalFn func(a app.App, envName, paramName string) error // RunParamDelete runs `param set` func RunParamDelete(m map[string]interface{}) error { @@ -46,9 +47,10 @@ type ParamDelete struct { global bool envName string - deleteEnvFn deleteEnvFn - getModuleFn getModuleFn - resolvePathFn func(a app.App, path string) (component.Module, component.Component, error) + deleteEnvFn deleteEnvFn + deleteEnvGlobalFn deleteEnvGlobalFn + getModuleFn getModuleFn + resolvePathFn func(a app.App, path string) (component.Module, component.Component, error) } // NewParamDelete creates an instance of ParamDelete. @@ -57,15 +59,16 @@ func NewParamDelete(m map[string]interface{}) (*ParamDelete, error) { pd := &ParamDelete{ app: ol.loadApp(), - name: ol.loadString(OptionName), + name: ol.loadOptionalString(OptionName), rawPath: ol.loadString(OptionPath), global: ol.loadOptionalBool(OptionGlobal), envName: ol.loadOptionalString(OptionEnvName), index: ol.loadOptionalInt(OptionIndex), - deleteEnvFn: env.DeleteParam, - resolvePathFn: component.ResolvePath, - getModuleFn: component.GetModule, + deleteEnvFn: env.DeleteParam, + deleteEnvGlobalFn: env.UnsetGlobalParams, + resolvePathFn: component.ResolvePath, + getModuleFn: component.GetModule, } if ol.err != nil { @@ -82,7 +85,10 @@ func NewParamDelete(m map[string]interface{}) (*ParamDelete, error) { // Run runs the action. func (pd *ParamDelete) Run() error { if pd.envName != "" { - return pd.deleteEnvFn(pd.app, pd.envName, pd.name, pd.rawPath) + if pd.name != "" { + return pd.deleteEnvFn(pd.app, pd.envName, pd.name, pd.rawPath) + } + return pd.deleteEnvGlobalFn(pd.app, pd.envName, pd.rawPath) } path := strings.Split(pd.rawPath, ".") diff --git a/actions/param_delete_test.go b/actions/param_delete_test.go index c2fe01e7..ffd7cc2a 100644 --- a/actions/param_delete_test.go +++ b/actions/param_delete_test.go @@ -133,3 +133,28 @@ func TestParamDelete_env(t *testing.T) { require.NoError(t, err) }) } + +func TestParamDelete_env_global(t *testing.T) { + withApp(t, func(appMock *amocks.App) { + path := "replicas" + + in := map[string]interface{}{ + OptionApp: appMock, + OptionPath: path, + OptionEnvName: "default", + } + + a, err := NewParamDelete(in) + require.NoError(t, err) + + envDelete := func(ksApp app.App, envName, pName string) error { + assert.Equal(t, "default", envName) + assert.Equal(t, "replicas", pName) + return nil + } + a.deleteEnvGlobalFn = envDelete + + err = a.Run() + require.NoError(t, err) + }) +} diff --git a/actions/param_set.go b/actions/param_set.go index 24d8c9b6..1b694745 100644 --- a/actions/param_set.go +++ b/actions/param_set.go @@ -16,7 +16,6 @@ package actions import ( - "strconv" "strings" "github.com/ksonnet/ksonnet/component" @@ -47,9 +46,10 @@ type ParamSet struct { global bool envName string - getModuleFn getModuleFn - resolvePathFn func(a app.App, path string) (component.Module, component.Component, error) - setEnvFn func(ksApp app.App, envName, name, pName, value string) error + getModuleFn getModuleFn + resolvePathFn func(a app.App, path string) (component.Module, component.Component, error) + setEnvFn func(ksApp app.App, envName, name, pName, value string) error + setGlobalEnvFn func(ksApp app.App, envName, pName, value string) error } // NewParamSet creates an instance of ParamSet. @@ -58,16 +58,17 @@ func NewParamSet(m map[string]interface{}) (*ParamSet, error) { ps := &ParamSet{ app: ol.loadApp(), - name: ol.loadString(OptionName), + name: ol.loadOptionalString(OptionName), rawPath: ol.loadString(OptionPath), rawValue: ol.loadString(OptionValue), global: ol.loadOptionalBool(OptionGlobal), envName: ol.loadOptionalString(OptionEnvName), index: ol.loadOptionalInt(OptionIndex), - getModuleFn: component.GetModule, - resolvePathFn: component.ResolvePath, - setEnvFn: setEnv, + getModuleFn: component.GetModule, + resolvePathFn: component.ResolvePath, + setEnvFn: setEnv, + setGlobalEnvFn: setGlobalEnv, } if ol.err != nil { @@ -88,13 +89,11 @@ func (ps *ParamSet) Run() error { return errors.Wrap(err, "value is invalid") } - evaluatedValue := ps.rawValue - if _, ok := value.(string); ok { - evaluatedValue = strconv.Quote(ps.rawValue) - } - if ps.envName != "" { - return ps.setEnvFn(ps.app, ps.envName, ps.name, ps.rawPath, evaluatedValue) + if ps.name != "" { + return ps.setEnvFn(ps.app, ps.envName, ps.name, ps.rawPath, ps.rawValue) + } + return ps.setGlobalEnvFn(ps.app, ps.envName, ps.rawPath, ps.rawValue) } path := strings.Split(ps.rawPath, ".") @@ -147,3 +146,11 @@ func setEnv(ksApp app.App, envName, name, pName, value string) error { return env.SetParams(envName, name, p, spc) } + +func setGlobalEnv(ksApp app.App, envName, pName, value string) error { + p := mp.Params{ + pName: value, + } + + return env.SetGlobalParams(ksApp, envName, p) +} diff --git a/actions/param_set_test.go b/actions/param_set_test.go index c32163de..14c6be63 100644 --- a/actions/param_set_test.go +++ b/actions/param_set_test.go @@ -142,3 +142,31 @@ func TestParamSet_env(t *testing.T) { require.NoError(t, err) }) } + +func TestParamSet_envGlobal(t *testing.T) { + withApp(t, func(appMock *amocks.App) { + path := "replicas" + value := "3" + + in := map[string]interface{}{ + OptionApp: appMock, + OptionPath: path, + OptionValue: value, + OptionEnvName: "default", + } + + a, err := NewParamSet(in) + require.NoError(t, err) + + envSetter := func(ksApp app.App, envName, pName, value string) error { + assert.Equal(t, "default", envName) + assert.Equal(t, "replicas", pName) + assert.Equal(t, "3", value) + return nil + } + a.setGlobalEnvFn = envSetter + + err = a.Run() + require.NoError(t, err) + }) +} diff --git a/cmd/param_delete.go b/cmd/param_delete.go index d09db6d2..a3364196 100644 --- a/cmd/param_delete.go +++ b/cmd/param_delete.go @@ -16,9 +16,8 @@ package cmd import ( - "fmt" - "github.com/ksonnet/ksonnet/actions" + "github.com/pkg/errors" "github.com/spf13/cobra" "github.com/spf13/viper" ) @@ -32,14 +31,23 @@ var paramDeleteCmd = &cobra.Command{ Use: "delete ", Short: paramShortDesc["delete"], RunE: func(cmd *cobra.Command, args []string) error { - if len(args) != 2 { - return fmt.Errorf("'param delete' takes exactly two arguments, (1) the name of the component, and the key") + var name string + var path string + + switch len(args) { + default: + return errors.New("invalid arguments for 'param delete'") + case 2: + name = args[0] + path = args[1] + case 1: + path = args[0] } m := map[string]interface{}{ actions.OptionApp: ka, - actions.OptionName: args[0], - actions.OptionPath: args[1], + actions.OptionName: name, + actions.OptionPath: path, actions.OptionEnvName: viper.GetString(vParamDeleteEnv), actions.OptionIndex: viper.GetInt(vParamDeleteIndex), } diff --git a/cmd/param_set.go b/cmd/param_set.go index 1a715f1e..73a59b34 100644 --- a/cmd/param_set.go +++ b/cmd/param_set.go @@ -16,9 +16,8 @@ package cmd import ( - "fmt" - "github.com/ksonnet/ksonnet/actions" + "github.com/pkg/errors" "github.com/spf13/cobra" "github.com/spf13/viper" ) @@ -32,15 +31,27 @@ var paramSetCmd = &cobra.Command{ Use: "set ", Short: paramShortDesc["set"], RunE: func(cmd *cobra.Command, args []string) error { - if len(args) != 3 { - return fmt.Errorf("'param set' takes exactly three arguments, (1) the name of the component, in addition to (2) the key and (3) value of the parameter") + var name string + var path string + var value string + + switch len(args) { + default: + return errors.New("invalid arguments for 'param set'") + case 3: + name = args[0] + path = args[1] + value = args[2] + case 2: + path = args[0] + value = args[1] } m := map[string]interface{}{ actions.OptionApp: ka, - actions.OptionName: args[0], - actions.OptionPath: args[1], - actions.OptionValue: args[2], + actions.OptionName: name, + actions.OptionPath: path, + actions.OptionValue: value, actions.OptionEnvName: viper.GetString(vParamSetEnv), actions.OptionIndex: viper.GetInt(vParamSetIndex), } diff --git a/cmd/param_set_test.go b/cmd/param_set_test.go index c002e404..66db1ac9 100644 --- a/cmd/param_set_test.go +++ b/cmd/param_set_test.go @@ -36,6 +36,25 @@ func Test_paramSetCmd(t *testing.T) { actions.OptionIndex: 0, }, }, + { + name: "set env global", + args: []string{"param", "set", "param-name", "param-value", "--env", "default"}, + action: actionParamSet, + expected: map[string]interface{}{ + actions.OptionApp: ka, + actions.OptionName: "", + actions.OptionPath: "param-name", + actions.OptionValue: "param-value", + actions.OptionEnvName: "default", + actions.OptionIndex: 0, + }, + }, + { + name: "invalid arguments", + args: []string{"param", "set"}, + action: actionParamSet, + isErr: true, + }, } runTestCmd(t, cases) diff --git a/pkg/env/params.go b/pkg/env/params.go index dc3a2485..9b9fc8f2 100644 --- a/pkg/env/params.go +++ b/pkg/env/params.go @@ -24,6 +24,84 @@ import ( "github.com/spf13/afero" ) +// SetGlobalParams sets global params for an environment. +func SetGlobalParams(a app.App, envName string, p param.Params) error { + if err := ensureEnvExists(a, envName); err != nil { + return err + } + + path := envPath(a, envName, globalsFileName) + + exists, err := afero.Exists(a.Fs(), path) + if err != nil { + return err + } + + if !exists { + if err = afero.WriteFile(a.Fs(), path, []byte("{\n}"), app.DefaultFilePermissions); err != nil { + return err + } + } + + text, err := afero.ReadFile(a.Fs(), path) + if err != nil { + return err + } + + egs := params.NewEnvGlobalsSet() + updated, err := egs.Set(string(text), p) + if err != nil { + return err + } + + err = afero.WriteFile(a.Fs(), path, []byte(updated), app.DefaultFilePermissions) + if err != nil { + return err + } + + log.WithField("environment-name", envName). + Debug("Set global parameters") + return nil +} + +// UnsetGlobalParams un-sets global param for an environment. +func UnsetGlobalParams(a app.App, envName, paramName string) error { + if err := ensureEnvExists(a, envName); err != nil { + return err + } + + path := envPath(a, envName, globalsFileName) + + exists, err := afero.Exists(a.Fs(), path) + if err != nil { + return err + } + + if !exists { + return nil + } + + text, err := afero.ReadFile(a.Fs(), path) + if err != nil { + return err + } + + egu := params.NewEnvGlobalsUnset() + updated, err := egu.Unset(paramName, string(text)) + if err != nil { + return err + } + + err = afero.WriteFile(a.Fs(), path, []byte(updated), app.DefaultFilePermissions) + if err != nil { + return err + } + + log.WithField("environment-name", envName). + Debug("Set global parameters") + return nil +} + // SetParamsConfig is config items for setting environment params. type SetParamsConfig struct { App app.App diff --git a/pkg/env/params_test.go b/pkg/env/params_test.go index e5768414..4a9c5a7c 100644 --- a/pkg/env/params_test.go +++ b/pkg/env/params_test.go @@ -25,6 +25,28 @@ import ( "github.com/stretchr/testify/require" ) +func TestSetGlobalParams(t *testing.T) { + withEnv(t, func(appMock *mocks.App, fs afero.Fs) { + p := params.Params{ + "foo": "bar", + } + + err := SetGlobalParams(appMock, "env1", p) + require.NoError(t, err) + + compareOutput(t, fs, "add-global.libsonnet", "/environments/env1/globals.libsonnet") + }) +} + +func TestUnsetGlobalParams(t *testing.T) { + withEnv(t, func(appMock *mocks.App, fs afero.Fs) { + err := UnsetGlobalParams(appMock, "env1", "foo") + require.NoError(t, err) + + compareOutput(t, fs, "remove-global.libsonnet", "/environments/env1/globals.libsonnet") + }) +} + func TestSetParams(t *testing.T) { withEnv(t, func(appMock *mocks.App, fs afero.Fs) { config := SetParamsConfig{ diff --git a/pkg/env/testdata/add-global.libsonnet b/pkg/env/testdata/add-global.libsonnet new file mode 100644 index 00000000..5f11c2be --- /dev/null +++ b/pkg/env/testdata/add-global.libsonnet @@ -0,0 +1,3 @@ +{ + foo: "bar", +} \ No newline at end of file diff --git a/pkg/env/testdata/globals.libsonnet b/pkg/env/testdata/globals.libsonnet new file mode 100644 index 00000000..5f11c2be --- /dev/null +++ b/pkg/env/testdata/globals.libsonnet @@ -0,0 +1,3 @@ +{ + foo: "bar", +} \ No newline at end of file diff --git a/pkg/env/testdata/remove-global.libsonnet b/pkg/env/testdata/remove-global.libsonnet new file mode 100644 index 00000000..7a73a41b --- /dev/null +++ b/pkg/env/testdata/remove-global.libsonnet @@ -0,0 +1,2 @@ +{ +} \ No newline at end of file diff --git a/pkg/env/util_test.go b/pkg/env/util_test.go index f5a65ad2..521a5a46 100644 --- a/pkg/env/util_test.go +++ b/pkg/env/util_test.go @@ -66,6 +66,9 @@ func withEnv(t *testing.T, fn func(*mocks.App, afero.Fs)) { paramsPath := filepath.Join(path, "params.libsonnet") stageFile(t, fs, "params.libsonnet", paramsPath) + + globalsPath := filepath.Join(path, "globals.libsonnet") + stageFile(t, fs, "globals.libsonnet", globalsPath) } componentParamsPath := filepath.Join("/", "components", "params.libsonnet") diff --git a/pkg/params/env_globals_set.go b/pkg/params/env_globals_set.go new file mode 100644 index 00000000..a204be3c --- /dev/null +++ b/pkg/params/env_globals_set.go @@ -0,0 +1,87 @@ +// Copyright 2018 The ksonnet authors +// +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package params + +import ( + "bytes" + + "github.com/ksonnet/ksonnet-lib/ksonnet-gen/astext" + nm "github.com/ksonnet/ksonnet-lib/ksonnet-gen/nodemaker" + "github.com/ksonnet/ksonnet/metadata/params" + "github.com/ksonnet/ksonnet/pkg/util/jsonnet" + "github.com/pkg/errors" + "github.com/sirupsen/logrus" +) + +// EnvGlobalsSet sets environment globals. +type EnvGlobalsSet struct { +} + +// NewEnvGlobalsSet creates an instance of EnvGlobalsSet. +func NewEnvGlobalsSet() *EnvGlobalsSet { + egs := &EnvGlobalsSet{} + return egs +} + +// Set sets params in environment globals files. +func (egs *EnvGlobalsSet) Set(snippet string, p params.Params) (string, error) { + logger := logrus.WithFields(logrus.Fields{}) + logger.Info("setting environment globals") + + n, err := jsonnet.ParseNode("globals.libsonnet", snippet) + if err != nil { + return "", err + } + + obj, err := componentParams(n, "") + if err != nil { + return "", err + } + + if err = egs.setParams(obj, p); err != nil { + return "", errors.Wrap(err, "delete entry") + } + + // root node should be a local if not, return an error + var buf bytes.Buffer + if err = jsonnetPrinterFn(&buf, n); err != nil { + return "", errors.Wrap(err, "unable to update snippet") + } + + return buf.String(), nil +} + +func (egs *EnvGlobalsSet) setParams(obj *astext.Object, p params.Params) error { + for key := range p { + decoded, err := DecodeValue(p[key]) + if err != nil { + return err + } + + value, err := nm.ValueToNoder(decoded) + if err != nil { + return err + } + + path := []string{key} + if err = jsonnetSetFn(obj, path, value.Node()); err != nil { + return err + } + + } + + return nil +} diff --git a/pkg/params/env_globals_set_test.go b/pkg/params/env_globals_set_test.go new file mode 100644 index 00000000..323f1876 --- /dev/null +++ b/pkg/params/env_globals_set_test.go @@ -0,0 +1,57 @@ +// Copyright 2018 The ksonnet authors +// +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package params + +import ( + "path/filepath" + "testing" + + "github.com/ksonnet/ksonnet/metadata/params" + "github.com/ksonnet/ksonnet/pkg/util/test" + "github.com/stretchr/testify/require" +) + +func TestEnvGlobalsSet(t *testing.T) { + cases := []struct { + name string + input string + output string + params params.Params + }{ + { + name: "in general", + input: filepath.Join("env", "globals", "set-global", "in.libsonnet"), + output: filepath.Join("env", "globals", "set-global", "out.libsonnet"), + params: params.Params{ + "group": "dev", + }, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + snippet := test.ReadTestData(t, tc.input) + + egs := NewEnvGlobalsSet() + + got, err := egs.Set(snippet, tc.params) + require.NoError(t, err) + + expected := test.ReadTestData(t, tc.output) + require.Equal(t, expected, got) + }) + } +} diff --git a/pkg/params/env_globals_unset.go b/pkg/params/env_globals_unset.go new file mode 100644 index 00000000..3e88a136 --- /dev/null +++ b/pkg/params/env_globals_unset.go @@ -0,0 +1,89 @@ +// Copyright 2018 The ksonnet authors +// +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package params + +import ( + "bytes" + + "github.com/ksonnet/ksonnet-lib/ksonnet-gen/astext" + "github.com/ksonnet/ksonnet/pkg/util/jsonnet" + "github.com/pkg/errors" + "github.com/sirupsen/logrus" +) + +// EnvGlobalsUnset un-sets global environment params. +type EnvGlobalsUnset struct { +} + +// NewEnvGlobalsUnset creates an instance of EnvGlobalsUnset. +func NewEnvGlobalsUnset() *EnvGlobalsUnset { + egu := &EnvGlobalsUnset{} + return egu +} + +// Unset un-sets globals. +func (epu *EnvGlobalsUnset) Unset(paramName, snippet string) (string, error) { + if paramName == "" { + return "", errors.New("global name was blank") + } + + logger := logrus.WithFields(logrus.Fields{}) + logger.WithField("name", paramName).Info("removing environment global") + + n, err := jsonnet.ParseNode("params.libsonnet", snippet) + if err != nil { + return "", err + } + + obj, err := componentParams(n, "") + if err != nil { + return "", err + } + + if err = epu.unsetEntry(obj, paramName); err != nil { + return "", errors.Wrap(err, "delete entry") + } + + var buf bytes.Buffer + if err = jsonnetPrinterFn(&buf, n); err != nil { + return "", errors.Wrap(err, "unable to update snippet") + } + + return buf.String(), nil +} + +func (epu *EnvGlobalsUnset) unsetEntry(obj *astext.Object, paramName string) error { + match := -1 + + var id string + var err error + for i := range obj.Fields { + id, err = jsonnet.FieldID(obj.Fields[i]) + if err != nil { + return err + } + + if id == paramName { + match = i + } + } + + if match >= 0 { + obj.Fields = append(obj.Fields[:match], obj.Fields[match+1:]...) + } + + return nil +} diff --git a/pkg/params/env_globals_unset_test.go b/pkg/params/env_globals_unset_test.go new file mode 100644 index 00000000..379899b1 --- /dev/null +++ b/pkg/params/env_globals_unset_test.go @@ -0,0 +1,54 @@ +// Copyright 2018 The ksonnet authors +// +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package params + +import ( + "path/filepath" + "testing" + + "github.com/ksonnet/ksonnet/pkg/util/test" + "github.com/stretchr/testify/require" +) + +func TestEnvGlobalsUnset(t *testing.T) { + cases := []struct { + name string + input string + output string + paramName string + }{ + { + name: "in general", + input: filepath.Join("env", "globals", "unset-global", "in.libsonnet"), + output: filepath.Join("env", "globals", "unset-global", "out.libsonnet"), + paramName: "group", + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + snippet := test.ReadTestData(t, tc.input) + + egu := NewEnvGlobalsUnset() + + got, err := egu.Unset(tc.paramName, snippet) + require.NoError(t, err) + + expected := test.ReadTestData(t, tc.output) + require.Equal(t, expected, got) + }) + } +} diff --git a/pkg/params/params.go b/pkg/params/params.go index f9056234..e1fa31e8 100644 --- a/pkg/params/params.go +++ b/pkg/params/params.go @@ -145,7 +145,6 @@ func ToMap(componentName, src, root string) (map[string]interface{}, error) { return nil, err } - // child, err := jsonnetFindObjectFn(obj, path) m, err := convertObjectToMapFn(componentObject) if err != nil { return nil, err @@ -294,15 +293,18 @@ func mergeMaps(m1 map[string]interface{}, m2 map[string]interface{}, path []stri func componentParams(node ast.Node, componentName string) (*astext.Object, error) { switch t := node.(type) { default: - return nil, errors.New("unknown params format") + return nil, errors.Errorf("unknown params format: %T", t) case *astext.Object: - path := []string{"components", componentName} - if componentName == "" { - // NOTE: this is module params, so return global - path = []string{"global"} - } + if len(componentName) > 0 { + path := []string{"components", componentName} + if componentName == "" { + // NOTE: this is module params, so return global + path = []string{"global"} + } - return jsonnetFindObjectFn(t, path) + return jsonnetFindObjectFn(t, path) + } + return t, nil case *ast.Local: root, ok := node.(*ast.Local) if !ok { diff --git a/pkg/params/params_test.go b/pkg/params/params_test.go index bf6f7b1f..7b13bc48 100644 --- a/pkg/params/params_test.go +++ b/pkg/params/params_test.go @@ -379,10 +379,10 @@ func TestToMap(t *testing.T) { isErr: true, }, { - name: "unable to find object in params", + name: "unable to convert object to map", paramsData: test.ReadTestData(t, "nested-params.libsonnet"), init: func() { - jsonnetFindObjectFn = func(*astext.Object, []string) (*astext.Object, error) { + convertObjectToMapFn = func(*astext.Object) (map[string]interface{}, error) { return nil, errors.New("failed") } }, diff --git a/pkg/params/testdata/env/globals/set-global/in.libsonnet b/pkg/params/testdata/env/globals/set-global/in.libsonnet new file mode 100644 index 00000000..9e26dfee --- /dev/null +++ b/pkg/params/testdata/env/globals/set-global/in.libsonnet @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/pkg/params/testdata/env/globals/set-global/out.libsonnet b/pkg/params/testdata/env/globals/set-global/out.libsonnet new file mode 100644 index 00000000..48ec06e3 --- /dev/null +++ b/pkg/params/testdata/env/globals/set-global/out.libsonnet @@ -0,0 +1,3 @@ +{ + group: "dev", +} \ No newline at end of file diff --git a/pkg/params/testdata/env/globals/unset-global/in.libsonnet b/pkg/params/testdata/env/globals/unset-global/in.libsonnet new file mode 100644 index 00000000..48ec06e3 --- /dev/null +++ b/pkg/params/testdata/env/globals/unset-global/in.libsonnet @@ -0,0 +1,3 @@ +{ + group: "dev", +} \ No newline at end of file diff --git a/pkg/params/testdata/env/globals/unset-global/out.libsonnet b/pkg/params/testdata/env/globals/unset-global/out.libsonnet new file mode 100644 index 00000000..7a73a41b --- /dev/null +++ b/pkg/params/testdata/env/globals/unset-global/out.libsonnet @@ -0,0 +1,2 @@ +{ +} \ No newline at end of file