github.com/googollee/clic@v0.1.5/source/flag_test.go (about)

     1  package source
     2  
     3  import (
     4  	"bytes"
     5  	"flag"
     6  	"testing"
     7  
     8  	"github.com/google/go-cmp/cmp"
     9  )
    10  
    11  func TestFlag(t *testing.T) {
    12  	tests := []struct {
    13  		name                   string
    14  		options                []FlagOption
    15  		wantHelp               string
    16  		args                   []string
    17  		wantA1, wantA2, wantA3 string
    18  	}{
    19  		{
    20  			name:     "FromValue",
    21  			options:  []FlagOption{},
    22  			wantHelp: "  -a1 value\n    \ta1 (default a1)\n  -l1.a2 value\n    \ta2 (default a2)\n  -l2.l3.a3 value\n    \ta3 (default a3)\n",
    23  			args:     []string{"-a1", "123", "-l1.a2", "abc", "-l2.l3.a3", "xyz"},
    24  			wantA1:   "123",
    25  			wantA2:   "abc",
    26  			wantA3:   "xyz",
    27  		},
    28  		{
    29  			name:     "FromDefault",
    30  			options:  []FlagOption{},
    31  			wantHelp: "  -a1 value\n    \ta1 (default a1)\n  -l1.a2 value\n    \ta2 (default a2)\n  -l2.l3.a3 value\n    \ta3 (default a3)\n",
    32  			args:     []string{},
    33  			wantA1:   "a1",
    34  			wantA2:   "a2",
    35  			wantA3:   "a3",
    36  		},
    37  		{
    38  			name:     "WithSplitter",
    39  			options:  []FlagOption{FlagSplitter("_")},
    40  			wantHelp: "  -a1 value\n    \ta1 (default a1)\n  -l1_a2 value\n    \ta2 (default a2)\n  -l2_l3_a3 value\n    \ta3 (default a3)\n",
    41  			args:     []string{"-a1", "123", "-l1_a2", "abc", "-l2_l3_a3", "xyz"},
    42  			wantA1:   "123",
    43  			wantA2:   "abc",
    44  			wantA3:   "xyz",
    45  		},
    46  	}
    47  
    48  	for _, tc := range tests {
    49  		t.Run(tc.name, func(t *testing.T) {
    50  			fset := flag.NewFlagSet("", flag.ContinueOnError)
    51  
    52  			src := Flag(tc.options...)
    53  			a1, a2, a3 = "a1", "a2", "a3"
    54  
    55  			if err := src.Register(fset, fields); err != nil {
    56  				t.Fatalf("src.Prepare(fields) returns error: %v", err)
    57  			}
    58  
    59  			var output bytes.Buffer
    60  			fset.SetOutput(&output)
    61  			fset.PrintDefaults()
    62  
    63  			if diff := cmp.Diff(output.String(), tc.wantHelp); diff != "" {
    64  				t.Errorf("output diff: (-got, +want)\n%s", diff)
    65  			}
    66  
    67  			if err := fset.Parse(tc.args); err != nil {
    68  				t.Fatalf("fset.Parse() error: %v", err)
    69  			}
    70  
    71  			if err := src.Parse(t.Context(), tc.args); err != nil {
    72  				t.Fatalf("src.Parse() should return no error, which is not: %v", err)
    73  			}
    74  
    75  			if got, want := a1, tc.wantA1; got != want {
    76  				t.Errorf("after src.Parse(), a1 = %q, want: %q", got, want)
    77  			}
    78  			if got, want := a2, tc.wantA2; got != want {
    79  				t.Errorf("after src.Parse(), a2 = %q, want: %q", got, want)
    80  			}
    81  			if got, want := a3, tc.wantA3; got != want {
    82  				t.Errorf("after src.Parse(), a3 = %q, want: %q", got, want)
    83  			}
    84  		})
    85  	}
    86  
    87  	t.Run("InvalidValue", func(t *testing.T) {
    88  		fset := flag.NewFlagSet("", flag.ContinueOnError)
    89  		src := Flag()
    90  
    91  		var output bytes.Buffer
    92  		fset.SetOutput(&output)
    93  		t.Logf("output:\n%s", output.String())
    94  
    95  		if err := src.Register(fset, fields); err != nil {
    96  			t.Fatalf("src.Prepare(fields) returns error: %v", err)
    97  		}
    98  
    99  		args := []string{"-flag.a", "123"}
   100  		if err := fset.Parse(args); err == nil {
   101  			t.Fatalf("fset.Parse() is nil, want an error")
   102  		}
   103  
   104  		if err := src.Parse(t.Context(), args); err == nil {
   105  			t.Fatalf("src.Parse() is nil, want an error")
   106  		}
   107  	})
   108  }
   109  
   110  func TestFlagError(t *testing.T) {
   111  	tests := []struct {
   112  		name    string
   113  		options []FlagOption
   114  	}{
   115  		{"EmptySplitter", []FlagOption{FlagSplitter("")}},
   116  	}
   117  
   118  	for _, tc := range tests {
   119  		t.Run(tc.name, func(t *testing.T) {
   120  			fset := flag.NewFlagSet("", flag.ContinueOnError)
   121  			src := Flag(tc.options...)
   122  			err := src.Error()
   123  			if err == nil {
   124  				t.Errorf("src().Error() want an error, which is not")
   125  			}
   126  
   127  			if errRegister := src.Register(fset, fields); err != errRegister {
   128  				t.Errorf("src().Prepare() = %v, src().Error() = %v, they should be same", errRegister, err)
   129  			}
   130  
   131  			args := []string{}
   132  			if err := fset.Parse(args); err != nil {
   133  				t.Fatalf("fset.Parse() error: %v", err)
   134  			}
   135  
   136  			if errParse := src.Parse(t.Context(), args); err != errParse {
   137  				t.Errorf("src().Parse() = %v, src().Error() = %v, they should be same", errParse, err)
   138  			}
   139  		})
   140  	}
   141  }