package options import ( "fmt" "reflect" "regexp" "testing" "time" ) var optsTests = []struct { input []string output Options }{ { []string{"foo=bar", "bar=baz ", "k="}, Options{ "foo": "bar", "bar": "baz", "k": "", }, }, { []string{"Foo=23", "baR", "k=thing with spaces"}, Options{ "foo": "23", "bar": "", "k": "thing with spaces", }, }, { []string{"k=thing with spaces", "k2=more spaces = not evil"}, Options{ "k": "thing with spaces", "k2": "more spaces = not evil", }, }, { []string{"x=1", "foo=bar", "y=2", "foo=bar"}, Options{ "x": "1", "y": "2", "foo": "bar", }, }, } func TestParseOptions(t *testing.T) { for i, test := range optsTests { t.Run(fmt.Sprintf("test-%v", i), func(t *testing.T) { opts, err := Parse(test.input) if err != nil { t.Fatalf("unable to parse options: %v", err) } if !reflect.DeepEqual(opts, test.output) { t.Fatalf("wrong result, want:\n %#v\ngot:\n %#v", test.output, opts) } }) } } var invalidOptsTests = []struct { input []string err string }{ { []string{"=bar", "bar=baz", "k="}, "Fatal: empty key is not a valid option", }, { []string{"x=1", "foo=bar", "y=2", "foo=baz"}, `Fatal: key "foo" present more than once`, }, } func TestParseInvalidOptions(t *testing.T) { for _, test := range invalidOptsTests { t.Run(test.err, func(t *testing.T) { _, err := Parse(test.input) if err == nil { t.Fatalf("expected error (%v) not found, err is nil", test.err) } if err.Error() != test.err { t.Fatalf("expected error %q, got %q", test.err, err.Error()) } }) } } var extractTests = []struct { input Options ns string output Options }{ { input: Options{ "foo.bar:": "baz", "s3.timeout": "10s", "sftp.timeout": "5s", "global": "foobar", }, ns: "s3", output: Options{ "timeout": "10s", }, }, } func TestOptionsExtract(t *testing.T) { for _, test := range extractTests { t.Run(test.ns, func(t *testing.T) { opts := test.input.Extract(test.ns) if !reflect.DeepEqual(opts, test.output) { t.Fatalf("wrong result, want:\n %#v\ngot:\n %#v", test.output, opts) } }) } } // Target is used for Apply() tests type Target struct { Name string `option:"name"` ID int `option:"id"` Timeout time.Duration `option:"timeout"` Other string } var setTests = []struct { input Options output Target }{ { Options{ "name": "foobar", }, Target{ Name: "foobar", }, }, { Options{ "name": "foobar", "id": "1234", }, Target{ Name: "foobar", ID: 1234, }, }, { Options{ "timeout": "10m3s", }, Target{ Timeout: time.Duration(10*time.Minute + 3*time.Second), }, }, } func TestOptionsApply(t *testing.T) { for i, test := range setTests { t.Run(fmt.Sprintf("test-%d", i), func(t *testing.T) { var dst Target err := test.input.Apply("", &dst) if err != nil { t.Fatal(err) } if dst != test.output { t.Fatalf("wrong result, want:\n %#v\ngot:\n %#v", test.output, dst) } }) } } var invalidSetTests = []struct { input Options namespace string err string }{ { Options{ "first_name": "foobar", }, "ns", "Fatal: option ns.first_name is not known", }, { Options{ "id": "foobar", }, "ns", `strconv.ParseInt: parsing "foobar": invalid syntax`, }, { Options{ "timeout": "2134", }, "ns", `time: missing unit in duration "?2134"?`, }, } func TestOptionsApplyInvalid(t *testing.T) { for i, test := range invalidSetTests { t.Run(fmt.Sprintf("test-%d", i), func(t *testing.T) { var dst Target err := test.input.Apply(test.namespace, &dst) if err == nil { t.Fatalf("expected error %v not found", test.err) } matched, err := regexp.MatchString(test.err, err.Error()) if err != nil { t.Fatal(err) } if !matched { t.Fatalf("expected error to match %q, got %q", test.err, err.Error()) } }) } } func TestListOptions(t *testing.T) { var teststruct = struct { Foo string `option:"foo" help:"bar text help"` }{} var tests = []struct { cfg interface{} opts []Help }{ { struct { Foo string `option:"foo" help:"bar text help"` }{}, []Help{ {Name: "foo", Text: "bar text help"}, }, }, { struct { Foo string `option:"foo" help:"bar text help"` Bar string `option:"bar" help:"bar text help"` }{}, []Help{ {Name: "foo", Text: "bar text help"}, {Name: "bar", Text: "bar text help"}, }, }, { struct { Bar string `option:"bar" help:"bar text help"` Foo string `option:"foo" help:"bar text help"` }{}, []Help{ {Name: "bar", Text: "bar text help"}, {Name: "foo", Text: "bar text help"}, }, }, { &teststruct, []Help{ {Name: "foo", Text: "bar text help"}, }, }, } for _, test := range tests { t.Run("", func(t *testing.T) { opts := listOptions(test.cfg) if !reflect.DeepEqual(opts, test.opts) { t.Fatalf("wrong opts, want:\n %v\ngot:\n %v", test.opts, opts) } }) } } func TestAppendAllOptions(t *testing.T) { var tests = []struct { cfgs map[string]interface{} opts []Help }{ { map[string]interface{}{ "local": struct { Foo string `option:"foo" help:"bar text help"` }{}, "sftp": struct { Foo string `option:"foo" help:"bar text help2"` Bar string `option:"bar" help:"bar text help"` }{}, }, []Help{ {Namespace: "local", Name: "foo", Text: "bar text help"}, {Namespace: "sftp", Name: "bar", Text: "bar text help"}, {Namespace: "sftp", Name: "foo", Text: "bar text help2"}, }, }, } for _, test := range tests { t.Run("", func(t *testing.T) { var opts []Help for ns, cfg := range test.cfgs { opts = appendAllOptions(opts, ns, cfg) } if !reflect.DeepEqual(opts, test.opts) { t.Fatalf("wrong list, want:\n %v\ngot:\n %v", test.opts, opts) } }) } }