From b79401382c80e9a4057cd04e4732f949608b5cdb Mon Sep 17 00:00:00 2001 From: Wayne Starr Date: Fri, 17 May 2024 10:21:51 -0600 Subject: [PATCH 1/6] chore: add unit tests to variables pkg --- src/pkg/variables/templates_test.go | 157 +++++++++++++++++++++++++ src/pkg/variables/testdata/file.txt | 1 + src/pkg/variables/variables_test.go | 170 ++++++++++++++++++++++++++++ 3 files changed, 328 insertions(+) create mode 100644 src/pkg/variables/templates_test.go create mode 100644 src/pkg/variables/testdata/file.txt create mode 100644 src/pkg/variables/variables_test.go diff --git a/src/pkg/variables/templates_test.go b/src/pkg/variables/templates_test.go new file mode 100644 index 0000000000..0f7eaa09ef --- /dev/null +++ b/src/pkg/variables/templates_test.go @@ -0,0 +1,157 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2024-Present Defense Unicorns + +package variables + +import ( + "errors" + "os" + "path/filepath" + "testing" +) + +var start = ` +This is a test file for templating. + + ###PREFIX_VAR_REPLACE_ME### + ###PREFIX_CONST_REPLACE_ME### + ###PREFIX_APP_REPLACE_ME### + ###PREFIX_NON_EXIST### +` +var simple = ` +This is a test file for templating. + + VAR_REPLACED + CONST_REPLACED + APP_REPLACED + ###PREFIX_NON_EXIST### +` +var multiline = ` +This is a test file for templating. + + VAR_REPLACED +VAR_SECOND + CONST_REPLACED +CONST_SECOND + APP_REPLACED +APP_SECOND + ###PREFIX_NON_EXIST### +` +var autoIndent = ` +This is a test file for templating. + + VAR_REPLACED + VAR_SECOND + CONST_REPLACED + CONST_SECOND + APP_REPLACED + APP_SECOND + ###PREFIX_NON_EXIST### +` +var file = ` +This is a test file for templating. + + The contents of this file become the template value + CONSTs Don't Support File + The contents of this file become the template value + ###PREFIX_NON_EXIST### +` + +func TestReplaceTextTemplate(t *testing.T) { + type test struct { + vc VariableConfig + path string + wantErr error + wantContents string + } + + tests := []test{ + { + vc: VariableConfig{setVariableMap: SetVariableMap{}, applicationTemplates: map[string]*TextTemplate{}}, + path: "non-existent.test", + wantErr: errors.New("open non-existent.test: no such file or directory"), + wantContents: start, + }, + { + vc: VariableConfig{ + templatePrefix: "PREFIX", + setVariableMap: SetVariableMap{ + "REPLACE_ME": {Value: "VAR_REPLACED"}, + }, + constants: []Constant{{Name: "REPLACE_ME", Value: "CONST_REPLACED"}}, + applicationTemplates: map[string]*TextTemplate{ + "###PREFIX_APP_REPLACE_ME###": {Value: "APP_REPLACED"}, + }, + }, + wantErr: nil, + wantContents: simple, + }, + { + vc: VariableConfig{ + templatePrefix: "PREFIX", + setVariableMap: SetVariableMap{ + "REPLACE_ME": {Value: "VAR_REPLACED\nVAR_SECOND"}, + }, + constants: []Constant{{Name: "REPLACE_ME", Value: "CONST_REPLACED\nCONST_SECOND"}}, + applicationTemplates: map[string]*TextTemplate{ + "###PREFIX_APP_REPLACE_ME###": {Value: "APP_REPLACED\nAPP_SECOND"}, + }, + }, + wantErr: nil, + wantContents: multiline, + }, + { + vc: VariableConfig{ + templatePrefix: "PREFIX", + setVariableMap: SetVariableMap{ + "REPLACE_ME": {Value: "VAR_REPLACED\nVAR_SECOND", Variable: Variable{AutoIndent: true}}, + }, + constants: []Constant{{Name: "REPLACE_ME", Value: "CONST_REPLACED\nCONST_SECOND", AutoIndent: true}}, + applicationTemplates: map[string]*TextTemplate{ + "###PREFIX_APP_REPLACE_ME###": {Value: "APP_REPLACED\nAPP_SECOND", AutoIndent: true}, + }, + }, + wantErr: nil, + wantContents: autoIndent, + }, + { + vc: VariableConfig{ + templatePrefix: "PREFIX", + setVariableMap: SetVariableMap{ + "REPLACE_ME": {Value: "testdata/file.txt", Variable: Variable{Type: FileVariableType}}, + }, + constants: []Constant{{Name: "REPLACE_ME", Value: "CONSTs Don't Support File"}}, + applicationTemplates: map[string]*TextTemplate{ + "###PREFIX_APP_REPLACE_ME###": {Value: "testdata/file.txt", Type: FileVariableType}, + }, + }, + wantErr: nil, + wantContents: file, + }, + } + + for _, tc := range tests { + tmpDir := t.TempDir() + tc.path = filepath.Join(tmpDir, "templates.test") + + f, _ := os.Create(tc.path) + defer f.Close() + + f.WriteString(start) + + gotErr := tc.vc.ReplaceTextTemplate(tc.path) + if gotErr != nil && tc.wantErr != nil { + if gotErr.Error() != tc.wantErr.Error() { + t.Fatalf("wanted err: %s, got err: %s", tc.wantErr, gotErr) + } + } else if gotErr != nil { + t.Fatalf("got unexpected err: %s", gotErr) + } else { + gotContents, _ := os.ReadFile(tc.path) + if string(gotContents) != tc.wantContents { + t.Fatalf("wanted contents: %s, got contents: %s", tc.wantContents, string(gotContents)) + } + } + + } +} diff --git a/src/pkg/variables/testdata/file.txt b/src/pkg/variables/testdata/file.txt new file mode 100644 index 0000000000..c5710b7a29 --- /dev/null +++ b/src/pkg/variables/testdata/file.txt @@ -0,0 +1 @@ +The contents of this file become the template value \ No newline at end of file diff --git a/src/pkg/variables/variables_test.go b/src/pkg/variables/variables_test.go new file mode 100644 index 0000000000..0bad8626c0 --- /dev/null +++ b/src/pkg/variables/variables_test.go @@ -0,0 +1,170 @@ +// SPDX-License-Identifier: Apache-2.0 +// SPDX-FileCopyrightText: 2024-Present Defense Unicorns + +package variables + +import ( + "errors" + "reflect" + "testing" +) + +func TestPopulateVariables(t *testing.T) { + type test struct { + vc VariableConfig + vars []InteractiveVariable + presets map[string]string + wantErr error + wantVars SetVariableMap + } + + prompt := func(_ InteractiveVariable) (value string, err error) { return "Prompt", nil } + + tests := []test{ + { + vc: VariableConfig{setVariableMap: SetVariableMap{}}, + vars: []InteractiveVariable{{Variable: Variable{Name: "NAME"}}}, + presets: map[string]string{}, + wantErr: nil, + wantVars: SetVariableMap{"NAME": {Variable: Variable{Name: "NAME"}}}, + }, + { + vc: VariableConfig{setVariableMap: SetVariableMap{}}, + vars: []InteractiveVariable{ + {Variable: Variable{Name: "NAME"}, Default: "Default"}, + }, + presets: map[string]string{}, + wantErr: nil, + wantVars: SetVariableMap{ + "NAME": {Variable: Variable{Name: "NAME"}, Value: "Default"}, + }, + }, + { + vc: VariableConfig{setVariableMap: SetVariableMap{}}, + vars: []InteractiveVariable{ + {Variable: Variable{Name: "NAME"}, Default: "Default"}, + }, + presets: map[string]string{"NAME": "Set"}, + wantErr: nil, + wantVars: SetVariableMap{ + "NAME": {Variable: Variable{Name: "NAME"}, Value: "Set"}, + }, + }, + { + vc: VariableConfig{setVariableMap: SetVariableMap{}}, + vars: []InteractiveVariable{ + {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}}, + }, + presets: map[string]string{}, + wantErr: nil, + wantVars: SetVariableMap{ + "NAME": {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}}, + }, + }, + { + vc: VariableConfig{setVariableMap: SetVariableMap{}}, + vars: []InteractiveVariable{ + {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}}, + }, + presets: map[string]string{"NAME": "Set"}, + wantErr: nil, + wantVars: SetVariableMap{ + "NAME": {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}, Value: "Set"}, + }, + }, + { + vc: VariableConfig{setVariableMap: SetVariableMap{}, prompt: prompt}, + vars: []InteractiveVariable{ + {Variable: Variable{Name: "NAME"}, Prompt: true}, + }, + presets: map[string]string{}, + wantErr: nil, + wantVars: SetVariableMap{ + "NAME": {Variable: Variable{Name: "NAME"}, Value: "Prompt"}, + }, + }, + { + vc: VariableConfig{setVariableMap: SetVariableMap{}, prompt: prompt}, + vars: []InteractiveVariable{ + {Variable: Variable{Name: "NAME"}, Default: "Default", Prompt: true}, + }, + presets: map[string]string{}, + wantErr: nil, + wantVars: SetVariableMap{ + "NAME": {Variable: Variable{Name: "NAME"}, Value: "Prompt"}, + }, + }, + { + vc: VariableConfig{setVariableMap: SetVariableMap{}, prompt: prompt}, + vars: []InteractiveVariable{ + {Variable: Variable{Name: "NAME"}, Prompt: true}, + }, + presets: map[string]string{"NAME": "Set"}, + wantErr: nil, + wantVars: SetVariableMap{ + "NAME": {Variable: Variable{Name: "NAME"}, Value: "Set"}, + }, + }, + } + + for _, tc := range tests { + gotErr := tc.vc.PopulateVariables(tc.vars, tc.presets) + if gotErr != nil && tc.wantErr != nil { + if gotErr.Error() != tc.wantErr.Error() { + t.Fatalf("wanted err: %s, got err: %s", tc.wantErr, gotErr) + } + } else if gotErr != nil { + t.Fatalf("got unexpected err: %s", gotErr) + } + + gotVars := tc.vc.GetSetVariables() + + if len(gotVars) != len(tc.wantVars) { + t.Fatalf("wanted vars len: %d, got vars len: %d", len(tc.wantVars), len(gotVars)) + } + + for key := range gotVars { + if !reflect.DeepEqual(gotVars[key], tc.wantVars[key]) { + t.Fatalf("for key %s: wanted var: %v, got var: %v", key, tc.wantVars[key], gotVars[key]) + } + } + } +} + +func TestCheckVariablePattern(t *testing.T) { + type test struct { + vc VariableConfig + name string + pattern string + want error + } + + tests := []test{ + { + vc: VariableConfig{setVariableMap: SetVariableMap{}}, name: "NAME", pattern: "n[a-z]me", + want: errors.New("variable \"NAME\" was not found in the current variable map"), + }, + { + vc: VariableConfig{ + setVariableMap: SetVariableMap{"NAME": &SetVariable{Value: "name"}}, + }, name: "NAME", pattern: "n[^a]me", + want: errors.New("provided value for variable \"NAME\" does not match pattern \"n[^a]me\""), + }, + { + vc: VariableConfig{ + setVariableMap: SetVariableMap{"NAME": &SetVariable{Value: "name"}}, + }, name: "NAME", pattern: "n[a-z]me", want: nil, + }, + } + + for _, tc := range tests { + got := tc.vc.CheckVariablePattern(tc.name, tc.pattern) + if got != nil && tc.want != nil { + if got.Error() != tc.want.Error() { + t.Fatalf("wanted err: %s, got err: %s", tc.want, got) + } + } else if got != nil { + t.Fatalf("got unexpected err: %s", got) + } + } +} From 6d4674bf957d575fed7a654693f75c1b8bd2ea23 Mon Sep 17 00:00:00 2001 From: Wayne Starr Date: Fri, 17 May 2024 10:49:29 -0600 Subject: [PATCH 2/6] fix the var test --- src/pkg/variables/variables_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/pkg/variables/variables_test.go b/src/pkg/variables/variables_test.go index 0bad8626c0..1e94c505d4 100644 --- a/src/pkg/variables/variables_test.go +++ b/src/pkg/variables/variables_test.go @@ -117,7 +117,7 @@ func TestPopulateVariables(t *testing.T) { t.Fatalf("got unexpected err: %s", gotErr) } - gotVars := tc.vc.GetSetVariables() + gotVars := tc.vc.setVariableMap if len(gotVars) != len(tc.wantVars) { t.Fatalf("wanted vars len: %d, got vars len: %d", len(tc.wantVars), len(gotVars)) From 53770f179e0a6d54d2b609fae668d42b90fac060 Mon Sep 17 00:00:00 2001 From: Wayne Starr Date: Fri, 17 May 2024 10:56:35 -0600 Subject: [PATCH 3/6] fix spdx and nil --- src/pkg/variables/templates_test.go | 2 +- src/pkg/variables/variables.go | 10 +++++++--- src/pkg/variables/variables_test.go | 2 +- 3 files changed, 9 insertions(+), 5 deletions(-) diff --git a/src/pkg/variables/templates_test.go b/src/pkg/variables/templates_test.go index 0f7eaa09ef..2e3ffe2292 100644 --- a/src/pkg/variables/templates_test.go +++ b/src/pkg/variables/templates_test.go @@ -1,5 +1,5 @@ // SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2024-Present Defense Unicorns +// SPDX-FileCopyrightText: 2021-Present The Zarf Authors package variables diff --git a/src/pkg/variables/variables.go b/src/pkg/variables/variables.go index cdd3bc4c94..7411116397 100644 --- a/src/pkg/variables/variables.go +++ b/src/pkg/variables/variables.go @@ -76,9 +76,13 @@ func (vc *VariableConfig) SetVariable(name, value string, sensitive bool, autoIn // CheckVariablePattern checks to see if a current variable is set to a value that matches its pattern func (vc *VariableConfig) CheckVariablePattern(name, pattern string) error { - if regexp.MustCompile(pattern).MatchString(vc.setVariableMap[name].Value) { - return nil + if variable, ok := vc.setVariableMap[name]; ok { + if regexp.MustCompile(pattern).MatchString(variable.Value) { + return nil + } + + return fmt.Errorf("provided value for variable %q does not match pattern %q", name, pattern) } - return fmt.Errorf("provided value for variable %q does not match pattern %q", name, pattern) + return fmt.Errorf("variable %q was not found in the current variable map", name) } diff --git a/src/pkg/variables/variables_test.go b/src/pkg/variables/variables_test.go index 1e94c505d4..fcfa0bc5e9 100644 --- a/src/pkg/variables/variables_test.go +++ b/src/pkg/variables/variables_test.go @@ -1,5 +1,5 @@ // SPDX-License-Identifier: Apache-2.0 -// SPDX-FileCopyrightText: 2024-Present Defense Unicorns +// SPDX-FileCopyrightText: 2021-Present The Zarf Authors package variables From a30b14a53ac48b72fc49bd72e8fea51967a9fc1d Mon Sep 17 00:00:00 2001 From: Wayne Starr Date: Mon, 20 May 2024 13:01:14 -0600 Subject: [PATCH 4/6] feedback --- src/pkg/variables/templates_test.go | 41 ++++++------ src/pkg/variables/variables.go | 11 +++- src/pkg/variables/variables_test.go | 99 ++++++++++++++--------------- 3 files changed, 75 insertions(+), 76 deletions(-) diff --git a/src/pkg/variables/templates_test.go b/src/pkg/variables/templates_test.go index 2e3ffe2292..0f22facd3f 100644 --- a/src/pkg/variables/templates_test.go +++ b/src/pkg/variables/templates_test.go @@ -4,10 +4,11 @@ package variables import ( - "errors" "os" "path/filepath" "testing" + + "github.com/stretchr/testify/require" ) var start = ` @@ -61,7 +62,7 @@ func TestReplaceTextTemplate(t *testing.T) { type test struct { vc VariableConfig path string - wantErr error + wantErrMsg string wantContents string } @@ -69,7 +70,7 @@ func TestReplaceTextTemplate(t *testing.T) { { vc: VariableConfig{setVariableMap: SetVariableMap{}, applicationTemplates: map[string]*TextTemplate{}}, path: "non-existent.test", - wantErr: errors.New("open non-existent.test: no such file or directory"), + wantErrMsg: "open non-existent.test: no such file or directory", wantContents: start, }, { @@ -83,7 +84,7 @@ func TestReplaceTextTemplate(t *testing.T) { "###PREFIX_APP_REPLACE_ME###": {Value: "APP_REPLACED"}, }, }, - wantErr: nil, + wantErrMsg: "", wantContents: simple, }, { @@ -97,7 +98,7 @@ func TestReplaceTextTemplate(t *testing.T) { "###PREFIX_APP_REPLACE_ME###": {Value: "APP_REPLACED\nAPP_SECOND"}, }, }, - wantErr: nil, + wantErrMsg: "", wantContents: multiline, }, { @@ -111,7 +112,7 @@ func TestReplaceTextTemplate(t *testing.T) { "###PREFIX_APP_REPLACE_ME###": {Value: "APP_REPLACED\nAPP_SECOND", AutoIndent: true}, }, }, - wantErr: nil, + wantErrMsg: "", wantContents: autoIndent, }, { @@ -125,33 +126,29 @@ func TestReplaceTextTemplate(t *testing.T) { "###PREFIX_APP_REPLACE_ME###": {Value: "testdata/file.txt", Type: FileVariableType}, }, }, - wantErr: nil, + wantErrMsg: "", wantContents: file, }, } for _, tc := range tests { - tmpDir := t.TempDir() - tc.path = filepath.Join(tmpDir, "templates.test") + if tc.path == "" { + tmpDir := t.TempDir() + tc.path = filepath.Join(tmpDir, "templates.test") - f, _ := os.Create(tc.path) - defer f.Close() + f, _ := os.Create(tc.path) + defer f.Close() - f.WriteString(start) + f.WriteString(start) + } gotErr := tc.vc.ReplaceTextTemplate(tc.path) - if gotErr != nil && tc.wantErr != nil { - if gotErr.Error() != tc.wantErr.Error() { - t.Fatalf("wanted err: %s, got err: %s", tc.wantErr, gotErr) - } - } else if gotErr != nil { - t.Fatalf("got unexpected err: %s", gotErr) + if tc.wantErrMsg != "" { + require.EqualError(t, gotErr, tc.wantErrMsg) } else { + require.NoError(t, gotErr) gotContents, _ := os.ReadFile(tc.path) - if string(gotContents) != tc.wantContents { - t.Fatalf("wanted contents: %s, got contents: %s", tc.wantContents, string(gotContents)) - } + require.Equal(t, string(gotContents), tc.wantContents) } - } } diff --git a/src/pkg/variables/variables.go b/src/pkg/variables/variables.go index 7411116397..5658ba0c7e 100644 --- a/src/pkg/variables/variables.go +++ b/src/pkg/variables/variables.go @@ -77,11 +77,16 @@ func (vc *VariableConfig) SetVariable(name, value string, sensitive bool, autoIn // CheckVariablePattern checks to see if a current variable is set to a value that matches its pattern func (vc *VariableConfig) CheckVariablePattern(name, pattern string) error { if variable, ok := vc.setVariableMap[name]; ok { - if regexp.MustCompile(pattern).MatchString(variable.Value) { - return nil + r, err := regexp.Compile(pattern) + if err != nil { + return err + } + + if !r.MatchString(variable.Value) { + return fmt.Errorf("provided value for variable %q does not match pattern %q", name, pattern) } - return fmt.Errorf("provided value for variable %q does not match pattern %q", name, pattern) + return nil } return fmt.Errorf("variable %q was not found in the current variable map", name) diff --git a/src/pkg/variables/variables_test.go b/src/pkg/variables/variables_test.go index fcfa0bc5e9..b88082b00d 100644 --- a/src/pkg/variables/variables_test.go +++ b/src/pkg/variables/variables_test.go @@ -4,37 +4,37 @@ package variables import ( - "errors" - "reflect" "testing" + + "github.com/stretchr/testify/require" ) func TestPopulateVariables(t *testing.T) { type test struct { - vc VariableConfig - vars []InteractiveVariable - presets map[string]string - wantErr error - wantVars SetVariableMap + vc VariableConfig + vars []InteractiveVariable + presets map[string]string + wantErrMsg string + wantVars SetVariableMap } prompt := func(_ InteractiveVariable) (value string, err error) { return "Prompt", nil } tests := []test{ { - vc: VariableConfig{setVariableMap: SetVariableMap{}}, - vars: []InteractiveVariable{{Variable: Variable{Name: "NAME"}}}, - presets: map[string]string{}, - wantErr: nil, - wantVars: SetVariableMap{"NAME": {Variable: Variable{Name: "NAME"}}}, + vc: VariableConfig{setVariableMap: SetVariableMap{}}, + vars: []InteractiveVariable{{Variable: Variable{Name: "NAME"}}}, + presets: map[string]string{}, + wantErrMsg: "", + wantVars: SetVariableMap{"NAME": {Variable: Variable{Name: "NAME"}}}, }, { vc: VariableConfig{setVariableMap: SetVariableMap{}}, vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME"}, Default: "Default"}, }, - presets: map[string]string{}, - wantErr: nil, + presets: map[string]string{}, + wantErrMsg: "", wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME"}, Value: "Default"}, }, @@ -44,8 +44,8 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME"}, Default: "Default"}, }, - presets: map[string]string{"NAME": "Set"}, - wantErr: nil, + presets: map[string]string{"NAME": "Set"}, + wantErrMsg: "", wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME"}, Value: "Set"}, }, @@ -55,8 +55,8 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}}, }, - presets: map[string]string{}, - wantErr: nil, + presets: map[string]string{}, + wantErrMsg: "", wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}}, }, @@ -66,8 +66,8 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}}, }, - presets: map[string]string{"NAME": "Set"}, - wantErr: nil, + presets: map[string]string{"NAME": "Set"}, + wantErrMsg: "", wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}, Value: "Set"}, }, @@ -77,8 +77,8 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME"}, Prompt: true}, }, - presets: map[string]string{}, - wantErr: nil, + presets: map[string]string{}, + wantErrMsg: "", wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME"}, Value: "Prompt"}, }, @@ -88,8 +88,8 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME"}, Default: "Default", Prompt: true}, }, - presets: map[string]string{}, - wantErr: nil, + presets: map[string]string{}, + wantErrMsg: "", wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME"}, Value: "Prompt"}, }, @@ -99,8 +99,8 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME"}, Prompt: true}, }, - presets: map[string]string{"NAME": "Set"}, - wantErr: nil, + presets: map[string]string{"NAME": "Set"}, + wantErrMsg: "", wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME"}, Value: "Set"}, }, @@ -109,62 +109,59 @@ func TestPopulateVariables(t *testing.T) { for _, tc := range tests { gotErr := tc.vc.PopulateVariables(tc.vars, tc.presets) - if gotErr != nil && tc.wantErr != nil { - if gotErr.Error() != tc.wantErr.Error() { - t.Fatalf("wanted err: %s, got err: %s", tc.wantErr, gotErr) - } - } else if gotErr != nil { - t.Fatalf("got unexpected err: %s", gotErr) + if tc.wantErrMsg != "" { + require.EqualError(t, gotErr, tc.wantErrMsg) + } else { + require.NoError(t, gotErr) } gotVars := tc.vc.setVariableMap - if len(gotVars) != len(tc.wantVars) { - t.Fatalf("wanted vars len: %d, got vars len: %d", len(tc.wantVars), len(gotVars)) - } + require.Equal(t, len(gotVars), len(tc.wantVars)) for key := range gotVars { - if !reflect.DeepEqual(gotVars[key], tc.wantVars[key]) { - t.Fatalf("for key %s: wanted var: %v, got var: %v", key, tc.wantVars[key], gotVars[key]) - } + require.Equal(t, gotVars[key], tc.wantVars[key]) } } } func TestCheckVariablePattern(t *testing.T) { type test struct { - vc VariableConfig - name string - pattern string - want error + vc VariableConfig + name string + pattern string + wantErrMsg string } tests := []test{ { vc: VariableConfig{setVariableMap: SetVariableMap{}}, name: "NAME", pattern: "n[a-z]me", - want: errors.New("variable \"NAME\" was not found in the current variable map"), + wantErrMsg: "variable \"NAME\" was not found in the current variable map", }, { vc: VariableConfig{ setVariableMap: SetVariableMap{"NAME": &SetVariable{Value: "name"}}, }, name: "NAME", pattern: "n[^a]me", - want: errors.New("provided value for variable \"NAME\" does not match pattern \"n[^a]me\""), + wantErrMsg: "provided value for variable \"NAME\" does not match pattern \"n[^a]me\"", + }, + { + vc: VariableConfig{ + setVariableMap: SetVariableMap{"NAME": &SetVariable{Value: "name"}}, + }, name: "NAME", pattern: "n[a-z]me", wantErrMsg: "", }, { vc: VariableConfig{ setVariableMap: SetVariableMap{"NAME": &SetVariable{Value: "name"}}, - }, name: "NAME", pattern: "n[a-z]me", want: nil, + }, name: "NAME", pattern: "n[a-z-bad-pattern", wantErrMsg: "error parsing regexp: missing closing ]: `[a-z-bad-pattern`", }, } for _, tc := range tests { got := tc.vc.CheckVariablePattern(tc.name, tc.pattern) - if got != nil && tc.want != nil { - if got.Error() != tc.want.Error() { - t.Fatalf("wanted err: %s, got err: %s", tc.want, got) - } - } else if got != nil { - t.Fatalf("got unexpected err: %s", got) + if tc.wantErrMsg != "" { + require.EqualError(t, got, tc.wantErrMsg) + } else { + require.NoError(t, got) } } } From 575dd007d0ae7948c18cfbbf21fdceed45805fdb Mon Sep 17 00:00:00 2001 From: Wayne Starr Date: Mon, 20 May 2024 14:57:44 -0600 Subject: [PATCH 5/6] fix lint --- Makefile | 2 +- src/pkg/variables/templates_test.go | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Makefile b/Makefile index 5683962afc..38ed3bb603 100644 --- a/Makefile +++ b/Makefile @@ -225,5 +225,5 @@ cve-report: ## Create a CVE report for the current project (must `brew install g @test -d ./build || mkdir ./build go run main.go tools sbom scan . -o json --exclude './site' --exclude './examples' | grype -o template -t hack/grype.tmpl > build/zarf-known-cves.csv -lint-go: ## Run golang-ci-lint to lint the go code (must `brew install golang-ci-lint` first) +lint-go: ## Run golang-ci-lint to lint the go code (must `brew install golangci-lint` first) golangci-lint run diff --git a/src/pkg/variables/templates_test.go b/src/pkg/variables/templates_test.go index 0f22facd3f..1b9d00e4e9 100644 --- a/src/pkg/variables/templates_test.go +++ b/src/pkg/variables/templates_test.go @@ -70,7 +70,7 @@ func TestReplaceTextTemplate(t *testing.T) { { vc: VariableConfig{setVariableMap: SetVariableMap{}, applicationTemplates: map[string]*TextTemplate{}}, path: "non-existent.test", - wantErrMsg: "open non-existent.test: no such file or directory", + wantErrMsg: "open non-existent.test:", wantContents: start, }, { @@ -144,11 +144,11 @@ func TestReplaceTextTemplate(t *testing.T) { gotErr := tc.vc.ReplaceTextTemplate(tc.path) if tc.wantErrMsg != "" { - require.EqualError(t, gotErr, tc.wantErrMsg) + require.Contains(t, gotErr.Error(), tc.wantErrMsg) } else { require.NoError(t, gotErr) gotContents, _ := os.ReadFile(tc.path) - require.Equal(t, string(gotContents), tc.wantContents) + require.Equal(t, tc.wantContents, string(gotContents)) } } } From 8fcc9f79f7bd6245f2a56f88fb2244c03c64c92d Mon Sep 17 00:00:00 2001 From: Wayne Starr Date: Thu, 23 May 2024 09:25:01 -0600 Subject: [PATCH 6/6] feedback --- src/pkg/variables/templates_test.go | 12 +++----- src/pkg/variables/variables.go | 6 ++-- src/pkg/variables/variables_test.go | 44 ++++++++++++----------------- 3 files changed, 25 insertions(+), 37 deletions(-) diff --git a/src/pkg/variables/templates_test.go b/src/pkg/variables/templates_test.go index 1b9d00e4e9..7dfb540029 100644 --- a/src/pkg/variables/templates_test.go +++ b/src/pkg/variables/templates_test.go @@ -62,7 +62,7 @@ func TestReplaceTextTemplate(t *testing.T) { type test struct { vc VariableConfig path string - wantErrMsg string + wantErr bool wantContents string } @@ -70,7 +70,7 @@ func TestReplaceTextTemplate(t *testing.T) { { vc: VariableConfig{setVariableMap: SetVariableMap{}, applicationTemplates: map[string]*TextTemplate{}}, path: "non-existent.test", - wantErrMsg: "open non-existent.test:", + wantErr: true, wantContents: start, }, { @@ -84,7 +84,6 @@ func TestReplaceTextTemplate(t *testing.T) { "###PREFIX_APP_REPLACE_ME###": {Value: "APP_REPLACED"}, }, }, - wantErrMsg: "", wantContents: simple, }, { @@ -98,7 +97,6 @@ func TestReplaceTextTemplate(t *testing.T) { "###PREFIX_APP_REPLACE_ME###": {Value: "APP_REPLACED\nAPP_SECOND"}, }, }, - wantErrMsg: "", wantContents: multiline, }, { @@ -112,7 +110,6 @@ func TestReplaceTextTemplate(t *testing.T) { "###PREFIX_APP_REPLACE_ME###": {Value: "APP_REPLACED\nAPP_SECOND", AutoIndent: true}, }, }, - wantErrMsg: "", wantContents: autoIndent, }, { @@ -126,7 +123,6 @@ func TestReplaceTextTemplate(t *testing.T) { "###PREFIX_APP_REPLACE_ME###": {Value: "testdata/file.txt", Type: FileVariableType}, }, }, - wantErrMsg: "", wantContents: file, }, } @@ -143,8 +139,8 @@ func TestReplaceTextTemplate(t *testing.T) { } gotErr := tc.vc.ReplaceTextTemplate(tc.path) - if tc.wantErrMsg != "" { - require.Contains(t, gotErr.Error(), tc.wantErrMsg) + if tc.wantErr { + require.Error(t, gotErr) } else { require.NoError(t, gotErr) gotContents, _ := os.ReadFile(tc.path) diff --git a/src/pkg/variables/variables.go b/src/pkg/variables/variables.go index 5658ba0c7e..1f2e6a8480 100644 --- a/src/pkg/variables/variables.go +++ b/src/pkg/variables/variables.go @@ -82,11 +82,11 @@ func (vc *VariableConfig) CheckVariablePattern(name, pattern string) error { return err } - if !r.MatchString(variable.Value) { - return fmt.Errorf("provided value for variable %q does not match pattern %q", name, pattern) + if r.MatchString(variable.Value) { + return nil } - return nil + return fmt.Errorf("provided value for variable %q does not match pattern %q", name, pattern) } return fmt.Errorf("variable %q was not found in the current variable map", name) diff --git a/src/pkg/variables/variables_test.go b/src/pkg/variables/variables_test.go index b88082b00d..901fdf4ba9 100644 --- a/src/pkg/variables/variables_test.go +++ b/src/pkg/variables/variables_test.go @@ -11,30 +11,28 @@ import ( func TestPopulateVariables(t *testing.T) { type test struct { - vc VariableConfig - vars []InteractiveVariable - presets map[string]string - wantErrMsg string - wantVars SetVariableMap + vc VariableConfig + vars []InteractiveVariable + presets map[string]string + wantErr bool + wantVars SetVariableMap } prompt := func(_ InteractiveVariable) (value string, err error) { return "Prompt", nil } tests := []test{ { - vc: VariableConfig{setVariableMap: SetVariableMap{}}, - vars: []InteractiveVariable{{Variable: Variable{Name: "NAME"}}}, - presets: map[string]string{}, - wantErrMsg: "", - wantVars: SetVariableMap{"NAME": {Variable: Variable{Name: "NAME"}}}, + vc: VariableConfig{setVariableMap: SetVariableMap{}}, + vars: []InteractiveVariable{{Variable: Variable{Name: "NAME"}}}, + presets: map[string]string{}, + wantVars: SetVariableMap{"NAME": {Variable: Variable{Name: "NAME"}}}, }, { vc: VariableConfig{setVariableMap: SetVariableMap{}}, vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME"}, Default: "Default"}, }, - presets: map[string]string{}, - wantErrMsg: "", + presets: map[string]string{}, wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME"}, Value: "Default"}, }, @@ -44,8 +42,7 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME"}, Default: "Default"}, }, - presets: map[string]string{"NAME": "Set"}, - wantErrMsg: "", + presets: map[string]string{"NAME": "Set"}, wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME"}, Value: "Set"}, }, @@ -55,8 +52,7 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}}, }, - presets: map[string]string{}, - wantErrMsg: "", + presets: map[string]string{}, wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}}, }, @@ -66,8 +62,7 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}}, }, - presets: map[string]string{"NAME": "Set"}, - wantErrMsg: "", + presets: map[string]string{"NAME": "Set"}, wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME", Sensitive: true, AutoIndent: true, Type: FileVariableType}, Value: "Set"}, }, @@ -77,8 +72,7 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME"}, Prompt: true}, }, - presets: map[string]string{}, - wantErrMsg: "", + presets: map[string]string{}, wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME"}, Value: "Prompt"}, }, @@ -88,8 +82,7 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME"}, Default: "Default", Prompt: true}, }, - presets: map[string]string{}, - wantErrMsg: "", + presets: map[string]string{}, wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME"}, Value: "Prompt"}, }, @@ -99,8 +92,7 @@ func TestPopulateVariables(t *testing.T) { vars: []InteractiveVariable{ {Variable: Variable{Name: "NAME"}, Prompt: true}, }, - presets: map[string]string{"NAME": "Set"}, - wantErrMsg: "", + presets: map[string]string{"NAME": "Set"}, wantVars: SetVariableMap{ "NAME": {Variable: Variable{Name: "NAME"}, Value: "Set"}, }, @@ -109,8 +101,8 @@ func TestPopulateVariables(t *testing.T) { for _, tc := range tests { gotErr := tc.vc.PopulateVariables(tc.vars, tc.presets) - if tc.wantErrMsg != "" { - require.EqualError(t, gotErr, tc.wantErrMsg) + if tc.wantErr { + require.Error(t, gotErr) } else { require.NoError(t, gotErr) }