ini_test.go

package flags

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"os"
	"reflect"
	"strings"
	"testing"
)

func TestWriteIni(t *testing.T) {
	oldEnv := EnvSnapshot()
	defer oldEnv.Restore()
	os.Setenv("ENV_DEFAULT", "env-def")

	var tests = []struct {
		args     []string
		options  IniOptions
		expected string
	}{
		{
			[]string{"-vv", "--intmap=a:2", "--intmap", "b:3", "filename", "0", "3.14", "command"},
			IniDefault,
			`[Application Options]
; Show verbose debug information
verbose = true
verbose = true

; Test env-default1 value
EnvDefault1 = env-def

; Test env-default2 value
EnvDefault2 = env-def

[Other Options]
; A map from string to int
int-map = a:2
int-map = b:3

`,
		},
		{
			[]string{"-vv", "--intmap=a:2", "--intmap", "b:3", "filename", "0", "3.14", "command"},
			IniDefault | IniIncludeDefaults,
			`[Application Options]
; Show verbose debug information
verbose = true
verbose = true

; A slice of pointers to string
; PtrSlice =

EmptyDescription = false

; Test default value
Default = "Some\nvalue"

; Test default array value
DefaultArray = Some value
DefaultArray = "Other\tvalue"

; Testdefault map value
DefaultMap = another:value
DefaultMap = some:value

; Test env-default1 value
EnvDefault1 = env-def

; Test env-default2 value
EnvDefault2 = env-def

; Option with named argument
OptionWithArgName =

; Option with choices
OptionWithChoices =

; Option only available in ini
only-ini =

[Other Options]
; A slice of strings
StringSlice = some
StringSlice = value

; A map from string to int
int-map = a:2
int-map = b:3

[Subgroup]
; This is a subgroup option
Opt =

; Not hidden inside group
NotHiddenInsideGroup =

[Subsubgroup]
; This is a subsubgroup option
Opt =

[command]
; Use for extra verbosity
; ExtraVerbose =

`,
		},
		{
			[]string{"filename", "0", "3.14", "command"},
			IniDefault | IniIncludeDefaults | IniCommentDefaults,
			`[Application Options]
; Show verbose debug information
; verbose =

; A slice of pointers to string
; PtrSlice =

; EmptyDescription = false

; Test default value
; Default = "Some\nvalue"

; Test default array value
; DefaultArray = Some value
; DefaultArray = "Other\tvalue"

; Testdefault map value
; DefaultMap = another:value
; DefaultMap = some:value

; Test env-default1 value
EnvDefault1 = env-def

; Test env-default2 value
EnvDefault2 = env-def

; Option with named argument
; OptionWithArgName =

; Option with choices
; OptionWithChoices =

; Option only available in ini
; only-ini =

[Other Options]
; A slice of strings
; StringSlice = some
; StringSlice = value

; A map from string to int
; int-map = a:1

[Subgroup]
; This is a subgroup option
; Opt =

; Not hidden inside group
; NotHiddenInsideGroup =

[Subsubgroup]
; This is a subsubgroup option
; Opt =

[command]
; Use for extra verbosity
; ExtraVerbose =

`,
		},
		{
			[]string{"--default=New value", "--default-array=New value", "--default-map=new:value", "filename", "0", "3.14", "command"},
			IniDefault | IniIncludeDefaults | IniCommentDefaults,
			`[Application Options]
; Show verbose debug information
; verbose =

; A slice of pointers to string
; PtrSlice =

; EmptyDescription = false

; Test default value
Default = New value

; Test default array value
DefaultArray = New value

; Testdefault map value
DefaultMap = new:value

; Test env-default1 value
EnvDefault1 = env-def

; Test env-default2 value
EnvDefault2 = env-def

; Option with named argument
; OptionWithArgName =

; Option with choices
; OptionWithChoices =

; Option only available in ini
; only-ini =

[Other Options]
; A slice of strings
; StringSlice = some
; StringSlice = value

; A map from string to int
; int-map = a:1

[Subgroup]
; This is a subgroup option
; Opt =

; Not hidden inside group
; NotHiddenInsideGroup =

[Subsubgroup]
; This is a subsubgroup option
; Opt =

[command]
; Use for extra verbosity
; ExtraVerbose =

`,
		},
	}

	for _, test := range tests {
		var opts helpOptions

		p := NewNamedParser("TestIni", Default)
		p.AddGroup("Application Options", "The application options", &opts)

		_, _, _, err := p.ParseCommandLine(test.args)

		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}

		inip := NewIniParser(p)

		var b bytes.Buffer
		inip.Write(&b, test.options)

		got := b.String()
		expected := test.expected

		msg := fmt.Sprintf("with arguments %+v and ini options %b", test.args, test.options)
		assertDiff(t, got, expected, msg)
	}
}

func TestReadIni_flagEquivalent(t *testing.T) {
	type options struct {
		Opt1 bool `long:"opt1"`

		Group1 struct {
			Opt2 bool `long:"opt2"`
		} `group:"group1"`

		Group2 struct {
			Opt3 bool `long:"opt3"`
		} `group:"group2" namespace:"ns1"`

		Cmd1 struct {
			Opt4 bool `long:"opt4"`
			Opt5 bool `long:"foo.opt5"`

			Group1 struct {
				Opt6 bool `long:"opt6"`
				Opt7 bool `long:"foo.opt7"`
			} `group:"group1"`

			Group2 struct {
				Opt8 bool `long:"opt8"`
			} `group:"group2" namespace:"ns1"`
		} `command:"cmd1"`
	}

	a := `
opt1=true

[group1]
opt2=true

[group2]
ns1.opt3=true

[cmd1]
opt4=true
foo.opt5=true

[cmd1.group1]
opt6=true
foo.opt7=true

[cmd1.group2]
ns1.opt8=true
`
	b := `
opt1=true
opt2=true
ns1.opt3=true

[cmd1]
opt4=true
foo.opt5=true
opt6=true
foo.opt7=true
ns1.opt8=true
`

	parse := func(readIni string) (opts options, writeIni string) {
		p := NewNamedParser("TestIni", Default)
		p.AddGroup("Application Options", "The application options", &opts)

		inip := NewIniParser(p)
		_, _, err := inip.Parse(strings.NewReader(readIni))

		if err != nil {
			t.Fatalf("Unexpected error: %s\n\nFile:\n%s", err, readIni)
		}

		var b bytes.Buffer
		inip.Write(&b, Default)

		return opts, b.String()
	}

	aOpt, aIni := parse(a)
	bOpt, bIni := parse(b)

	assertDiff(t, aIni, bIni, "")
	if !reflect.DeepEqual(aOpt, bOpt) {
		t.Errorf("not equal")
	}
}

func TestReadIni(t *testing.T) {
	var opts helpOptions
	tests := []struct {
		name                      string
		ini                       string
		expectedValueOfDefaultOpt string
	}{
		{
			"Single Application Options section",
			`
; Show verbose debug information
verbose = true
verbose = true

DefaultMap = another:"value\n1"
DefaultMap = some:value 2

[Application Options]
; A slice of pointers to string
; PtrSlice =

; Test default value
Default = "New\nvalue"

; Test env-default1 value
EnvDefault1 = New value

[Other Options]
# A slice of strings
StringSlice = "some\nvalue"
StringSlice = another value

; A map from string to int
int-map = a:2
int-map = b:3

`, "New\nvalue",
		}, {
			"Multiple Application Options sections",
			`
; Show verbose debug information
verbose = true
verbose = true

DefaultMap = another:"value\n1"
DefaultMap = some:value 2

[Application Options]
; A slice of pointers to string
; PtrSlice =

 ;Second Application Options Section
[Application Options]
; Test env-default1 value
EnvDefault1 = New value

[Other Options]
# A slice of strings
StringSlice = "some\nvalue"
StringSlice = another value

; A map from string to int
int-map = a:2
int-map = b:3

`, "Some\nvalue",
		},
	}

	for _, test := range tests {
		p := NewNamedParser("TestIni", Default)
		p.AddGroup("Application Options", "The application options", &opts)

		inip := NewIniParser(p)

		b := strings.NewReader(test.ini)
		_, _, err := inip.Parse(b)

		if err != nil {
			t.Fatalf("Unexpected error: %s", err)
		}

		assertBoolArray(t, opts.Verbose, []bool{true, true})

		if v := map[string]string{"another": "value\n1", "some": "value 2"}; !reflect.DeepEqual(opts.DefaultMap, v) {
			t.Fatalf("Expected %#v for DefaultMap but got %#v", v, opts.DefaultMap)
		}

		assertString(t, opts.Default, test.expectedValueOfDefaultOpt)

		assertString(t, opts.EnvDefault1, "New value")

		assertStringArray(t, opts.Other.StringSlice, []string{"some\nvalue", "another value"})

		if v, ok := opts.Other.IntMap["a"]; !ok {
			t.Errorf("Expected \"a\" in Other.IntMap")
		} else if v != 2 {
			t.Errorf("Expected Other.IntMap[\"a\"] = 2, but got %v", v)
		}

		if v, ok := opts.Other.IntMap["b"]; !ok {
			t.Errorf("Expected \"b\" in Other.IntMap")
		} else if v != 3 {
			t.Errorf("Expected Other.IntMap[\"b\"] = 3, but got %v", v)
		}
	}
}

type testCmd struct{}
type testCmdFlags struct {
	Senders     int    `long:"senders" description:"Number of parallel senders" default:"10"`
	Destination string `long:"destination" description:"Destination address to send messages" default:"localhost:8080"`
	SrcPort     uint   `long:"source-port" description:"Source port for msgs" default:"24"`
}

func (opt *testCmdFlags) Validate(_ []string) error {
	// Ensures default was used
	if opt.Senders <= 0 {
		return fmt.Errorf("senders must be positive")
	}
	if len(opt.Destination) == 0 {
		return fmt.Errorf("destination must be specified")
	}
	if opt.SrcPort == 0 {
		return fmt.Errorf("source port must be specified")
	}
	return nil
}
func (opt *testCmdFlags) Help() string {
	return "Help for testCmdFlags"
}
func (opt *testCmd) NewFlags() any {
	return new(testCmdFlags)
}
func TestZCommanderIni(t *testing.T) {
	type applicationOptions struct {
		Verbose []bool `long:"verbose" description:"Show verbose debug information"`
	}
	var appOpts applicationOptions
	var module testCmd

	p := NewNamedParser("TestIni", Default)
	p.AddGroup("Application Options", "The application options", &appOpts)
	p.AddCommand("scan", "scan module", "A mock scanner module", &module)

	inip := NewIniParser(p)

	inic := `
; Show verbose debug information
[Application Options]
verbose = true
verbose = true


[scan]
senders = 20
destination = example.com:9090

`
	b := strings.NewReader(inic)
	registeredCmds, registeredFlags, err := inip.Parse(b)

	if err != nil {
		t.Fatalf("Unexpected error: %s", err)
	}

	assertBoolArray(t, appOpts.Verbose, []bool{true, true})
	if registeredCmds[0] != "scan" {
		t.Fatalf("Expected registered command = scan, but got %s", registeredCmds[0])
	}
	flags, ok := registeredFlags[0].(*testCmdFlags)
	if !ok {
		t.Fatalf("Expected registered flags to be of type *testCmdFlags")
	}
	if flags.Senders != 20 {
		t.Fatalf("Expected senders = 20, but got %d", flags.Senders)
	}
	if flags.Destination != "example.com:9090" {
		t.Fatalf("Expected destination = example.com:9090, but got %s", flags.Destination)
	}

	// We didn't set this, so just checking that default was preserved
	if flags.SrcPort != 24 {
		t.Fatalf("Expected source-port = 24, but got %d", flags.SrcPort)
	}
}

func TestReadAndWriteIni(t *testing.T) {
	var tests = []struct {
		options IniOptions
		read    string
		write   string
	}{
		{
			IniIncludeComments,
			`[Application Options]
; Show verbose debug information
verbose = true
verbose = true

; Test default value
Default = "quote me"

; Test default array value
DefaultArray = 1
DefaultArray = "2"
DefaultArray = 3

; Test env-default1 value
EnvDefault1 = env-def

; Test env-default2 value
EnvDefault2 = env-def

[Other Options]
; A map from string to int
int-map = a:2
int-map = b:"3"

`,
			`[Application Options]
; Show verbose debug information
verbose = true
verbose = true

; Test default value
Default = "quote me"

; Test default array value
DefaultArray = 1
DefaultArray = 2
DefaultArray = 3

; Test env-default1 value
EnvDefault1 = env-def

; Test env-default2 value
EnvDefault2 = env-def

[Other Options]
; A map from string to int
int-map = a:2
int-map = b:3

`,
		},
		{
			IniIncludeComments,
			`[Application Options]
; Show verbose debug information
verbose = true
verbose = true

; Test default value
Default = "quote me"

; Test default array value
DefaultArray = "1"
DefaultArray = "2"
DefaultArray = "3"

; Testdefault map value
; DefaultMap =

; Test env-default1 value
EnvDefault1 = env-def

; Test env-default2 value
EnvDefault2 = env-def

[Other Options]
; A slice of strings
; StringSlice =

; A map from string to int
int-map = a:"2"
int-map = b:"3"

`,
			`[Application Options]
; Show verbose debug information
verbose = true
verbose = true

; Test default value
Default = "quote me"

; Test default array value
DefaultArray = "1"
DefaultArray = "2"
DefaultArray = "3"

; Test env-default1 value
EnvDefault1 = env-def

; Test env-default2 value
EnvDefault2 = env-def

[Other Options]
; A map from string to int
int-map = a:"2"
int-map = b:"3"

`,
		},
	}

	for _, test := range tests {
		var opts helpOptions

		p := NewNamedParser("TestIni", Default)
		p.AddGroup("Application Options", "The application options", &opts)

		inip := NewIniParser(p)

		read := strings.NewReader(test.read)
		_, _, err := inip.Parse(read)
		if err != nil {
			t.Fatalf("Unexpected error: %s", err)
		}

		var write bytes.Buffer
		inip.Write(&write, test.options)

		got := write.String()

		msg := fmt.Sprintf("with ini options %b", test.options)
		assertDiff(t, got, test.write, msg)
	}
}

func TestReadIniWrongQuoting(t *testing.T) {
	var tests = []struct {
		iniFile    string
		lineNumber uint
	}{
		{
			iniFile:    `Default = "New\nvalue`,
			lineNumber: 1,
		},
		{
			iniFile:    `StringSlice = "New\nvalue`,
			lineNumber: 1,
		},
		{
			iniFile: `StringSlice = "New\nvalue"
			StringSlice = "Second\nvalue`,
			lineNumber: 2,
		},
		{
			iniFile:    `DefaultMap = some:"value`,
			lineNumber: 1,
		},
		{
			iniFile: `DefaultMap = some:value
			DefaultMap = another:"value`,
			lineNumber: 2,
		},
	}

	for _, test := range tests {
		var opts helpOptions

		p := NewNamedParser("TestIni", Default)
		p.AddGroup("Application Options", "The application options", &opts)

		inip := NewIniParser(p)

		inic := test.iniFile

		b := strings.NewReader(inic)
		_, _, err := inip.Parse(b)

		if err == nil {
			t.Fatalf("Expect error")
		}

		iniError := err.(*IniError)

		if iniError.LineNumber != test.lineNumber {
			t.Fatalf("Expect error on line %d", test.lineNumber)
		}
	}
}

func TestIniCommands(t *testing.T) {
	var opts struct {
		Value string `short:"v" long:"value"`

		Add struct {
			Name int `short:"n" long:"name" ini-name:"AliasName"`

			Other struct {
				O string `short:"o" long:"other"`
			} `group:"Other Options"`
		} `command:"add"`
	}

	p := NewNamedParser("TestIni", Default)
	p.AddGroup("Application Options", "The application options", &opts)

	inip := NewIniParser(p)

	inic := `[Application Options]
value = some value

[add]
AliasName = 5

[add.Other Options]
other = subgroup

`

	b := strings.NewReader(inic)
	_, _, err := inip.Parse(b)

	if err != nil {
		t.Fatalf("Unexpected error: %s", err)
	}

	assertString(t, opts.Value, "some value")

	if opts.Add.Name != 5 {
		t.Errorf("Expected opts.Add.Name to be 5, but got %v", opts.Add.Name)
	}

	assertString(t, opts.Add.Other.O, "subgroup")

	// Test writing it back
	buf := &bytes.Buffer{}

	inip.Write(buf, IniDefault)

	assertDiff(t, buf.String(), inic, "ini contents")
}

func TestIniNoIni(t *testing.T) {
	var opts struct {
		NoValue string `short:"n" long:"novalue" no-ini:"yes"`
		Value   string `short:"v" long:"value"`
	}

	p := NewNamedParser("TestIni", Default)
	p.AddGroup("Application Options", "The application options", &opts)

	inip := NewIniParser(p)

	// read INI
	inic := `[Application Options]
novalue = some value
value = some other value
`

	b := strings.NewReader(inic)
	_, _, err := inip.Parse(b)

	if err == nil {
		t.Fatalf("Expected error")
	}

	iniError := err.(*IniError)

	if v := uint(2); iniError.LineNumber != v {
		t.Errorf("Expected opts.Add.Name to be %d, but got %d", v, iniError.LineNumber)
	}

	if v := "unknown option: novalue"; iniError.Message != v {
		t.Errorf("Expected opts.Add.Name to be %s, but got %s", v, iniError.Message)
	}

	// write INI
	opts.NoValue = "some value"
	opts.Value = "some other value"

	file, err := ioutil.TempFile("", "")
	if err != nil {
		t.Fatalf("Cannot create temporary file: %s", err)
	}
	defer os.Remove(file.Name())

	err = inip.WriteFile(file.Name(), IniIncludeDefaults)
	if err != nil {
		t.Fatalf("Could not write ini file: %s", err)
	}

	found, err := ioutil.ReadFile(file.Name())
	if err != nil {
		t.Fatalf("Could not read written ini file: %s", err)
	}

	expected := "[Application Options]\nValue = some other value\n\n"

	assertDiff(t, string(found), expected, "ini content")
}

func TestIniParse(t *testing.T) {
	file, err := ioutil.TempFile("", "")
	if err != nil {
		t.Fatalf("Cannot create temporary file: %s", err)
	}
	defer os.Remove(file.Name())

	_, err = file.WriteString("value = 123")
	if err != nil {
		t.Fatalf("Cannot write to temporary file: %s", err)
	}

	file.Close()

	var opts struct {
		Value int `long:"value"`
	}

	_, _, err = IniParse(file.Name(), &opts)
	if err != nil {
		t.Fatalf("Could not parse ini: %s", err)
	}

	if opts.Value != 123 {
		t.Fatalf("Expected Value to be \"123\" but was \"%d\"", opts.Value)
	}
}

func TestIniCliOverrides(t *testing.T) {
	file, err := ioutil.TempFile("", "")

	if err != nil {
		t.Fatalf("Cannot create temporary file: %s", err)
	}

	defer os.Remove(file.Name())

	_, err = file.WriteString("values = 123\n")
	_, err = file.WriteString("values = 456\n")

	if err != nil {
		t.Fatalf("Cannot write to temporary file: %s", err)
	}

	file.Close()

	var opts struct {
		Values []int `long:"values"`
	}

	p := NewParser(&opts, Default)
	_, _, err = NewIniParser(p).ParseFile(file.Name())

	if err != nil {
		t.Fatalf("Could not parse ini: %s", err)
	}

	_, _, _, err = p.ParseCommandLine([]string{"--values", "111", "--values", "222"})

	if err != nil {
		t.Fatalf("Failed to parse arguments: %s", err)
	}

	if len(opts.Values) != 2 {
		t.Fatalf("Expected Values to contain two elements, but got %d", len(opts.Values))
	}

	if opts.Values[0] != 111 {
		t.Fatalf("Expected Values[0] to be 111, but got '%d'", opts.Values[0])
	}

	if opts.Values[1] != 222 {
		t.Fatalf("Expected Values[1] to be 222, but got '%d'", opts.Values[1])
	}
}

func TestIniOverrides(t *testing.T) {
	file, err := ioutil.TempFile("", "")

	if err != nil {
		t.Fatalf("Cannot create temporary file: %s", err)
	}

	defer os.Remove(file.Name())

	_, err = file.WriteString("value-with-default = \"ini-value\"\n")
	_, err = file.WriteString("value-with-default-override-cli = \"ini-value\"\n")

	if err != nil {
		t.Fatalf("Cannot write to temporary file: %s", err)
	}

	file.Close()

	var opts struct {
		ValueWithDefault            string `long:"value-with-default" default:"value"`
		ValueWithDefaultOverrideCli string `long:"value-with-default-override-cli" default:"value"`
	}

	p := NewParser(&opts, Default)
	_, _, err = NewIniParser(p).ParseFile(file.Name())

	if err != nil {
		t.Fatalf("Could not parse ini: %s", err)
	}

	_, _, _, err = p.ParseCommandLine([]string{"--value-with-default-override-cli", "cli-value"})

	if err != nil {
		t.Fatalf("Failed to parse arguments: %s", err)
	}

	assertString(t, opts.ValueWithDefault, "ini-value")
	assertString(t, opts.ValueWithDefaultOverrideCli, "cli-value")
}

func TestIniRequired(t *testing.T) {
	var opts struct {
		Required string               `short:"r" required:"yes" description:"required"`
		Config   func(s string) error `long:"config" default:"no-ini-file" no-ini:"true"`
	}

	p := NewParser(&opts, Default)

	opts.Config = func(s string) error {
		inip := NewIniParser(p)
		inip.ParseAsDefaults = true
		_, _, err := inip.Parse(strings.NewReader("Required = ini-value\n"))
		return err
	}

	_, _, _, err := p.ParseCommandLine([]string{"-r", "cli-value"})

	if err != nil {
		t.Fatalf("Failed to parse arguments: %s", err)
	}

	assertString(t, opts.Required, "cli-value")
}

func TestWriteFile(t *testing.T) {
	file, err := ioutil.TempFile("", "")
	if err != nil {
		t.Fatalf("Cannot create temporary file: %s", err)
	}
	defer os.Remove(file.Name())

	var opts struct {
		Value int `long:"value"`
	}

	opts.Value = 123

	p := NewParser(&opts, Default)
	ini := NewIniParser(p)

	err = ini.WriteFile(file.Name(), IniIncludeDefaults)
	if err != nil {
		t.Fatalf("Could not write ini file: %s", err)
	}

	found, err := ioutil.ReadFile(file.Name())
	if err != nil {
		t.Fatalf("Could not read written ini file: %s", err)
	}

	expected := "[Application Options]\nValue = 123\n\n"

	assertDiff(t, string(found), expected, "ini content")
}

func TestOverwriteRequiredOptions(t *testing.T) {
	var tests = []struct {
		args     []string
		expected []string
	}{
		{
			args: []string{"--value", "from CLI"},
			expected: []string{
				"from CLI",
				"from default",
			},
		},
		{
			args: []string{"--value", "from CLI", "--default", "from CLI"},
			expected: []string{
				"from CLI",
				"from CLI",
			},
		},
		{
			args: []string{"--config", "no file name"},
			expected: []string{
				"from INI",
				"from INI",
			},
		},
		{
			args: []string{"--value", "from CLI before", "--default", "from CLI before", "--config", "no file name"},
			expected: []string{
				"from INI",
				"from INI",
			},
		},
		{
			args: []string{"--value", "from CLI before", "--default", "from CLI before", "--config", "no file name", "--value", "from CLI after", "--default", "from CLI after"},
			expected: []string{
				"from CLI after",
				"from CLI after",
			},
		},
	}

	for _, test := range tests {
		var opts struct {
			Config  func(s string) error `long:"config" no-ini:"true"`
			Value   string               `long:"value" required:"true"`
			Default string               `long:"default" required:"true" default:"from default"`
		}

		p := NewParser(&opts, Default)

		opts.Config = func(s string) error {
			ini := NewIniParser(p)

			_, _, err := ini.Parse(bytes.NewBufferString("value = from INI\ndefault = from INI"))
			return err
		}

		_, _, _, err := p.ParseCommandLine(test.args)
		if err != nil {
			t.Fatalf("Unexpected error %s with args %+v", err, test.args)
		}

		if opts.Value != test.expected[0] {
			t.Fatalf("Expected Value to be \"%s\" but was \"%s\" with args %+v", test.expected[0], opts.Value, test.args)
		}

		if opts.Default != test.expected[1] {
			t.Fatalf("Expected Default to be \"%s\" but was \"%s\" with args %+v", test.expected[1], opts.Default, test.args)
		}
	}
}

func TestIniOverwriteOptions(t *testing.T) {
	var tests = []struct {
		args     []string
		expected string
		toggled  bool
	}{
		{
			args:     []string{},
			expected: "from default",
		},
		{
			args:     []string{"--value", "from CLI"},
			expected: "from CLI",
		},
		{
			args:     []string{"--config", "no file name"},
			expected: "from INI",
			toggled:  true,
		},
		{
			args:     []string{"--value", "from CLI before", "--config", "no file name"},
			expected: "from CLI before",
			toggled:  true,
		},
		{
			args:     []string{"--config", "no file name", "--value", "from CLI after"},
			expected: "from CLI after",
			toggled:  true,
		},
		{
			args:     []string{"--toggle"},
			toggled:  true,
			expected: "from default",
		},
	}

	for _, test := range tests {
		var opts struct {
			Config string `long:"config" no-ini:"true"`
			Value  string `long:"value" default:"from default"`
			Toggle bool   `long:"toggle"`
		}

		p := NewParser(&opts, Default)

		_, _, _, err := p.ParseCommandLine(test.args)
		if err != nil {
			t.Fatalf("Unexpected error %s with args %+v", err, test.args)
		}

		if opts.Config != "" {
			inip := NewIniParser(p)
			inip.ParseAsDefaults = true

			_, _, err = inip.Parse(bytes.NewBufferString("value = from INI\ntoggle = true"))
			if err != nil {
				t.Fatalf("Unexpected error %s with args %+v", err, test.args)
			}
		}

		if opts.Value != test.expected {
			t.Fatalf("Expected Value to be \"%s\" but was \"%s\" with args %+v", test.expected, opts.Value, test.args)
		}

		if opts.Toggle != test.toggled {
			t.Fatalf("Expected Toggle to be \"%v\" but was \"%v\" with args %+v", test.toggled, opts.Toggle, test.args)
		}

	}
}