github.com/googollee/clic@v0.1.5/source/file_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 TestFile(t *testing.T) {
    12  	tests := []struct {
    13  		name                   string
    14  		options                []FileOption
    15  		wantHelp               string
    16  		args                   []string
    17  		wantA1, wantA2, wantA3 string
    18  	}{
    19  		{
    20  			name:     "FromValue",
    21  			options:  []FileOption{},
    22  			wantHelp: "  -config string\n    \tthe path of the config file\n",
    23  			args:     []string{"-config", "./testdata/valid.json"},
    24  			wantA1:   "123",
    25  			wantA2:   "abc",
    26  			wantA3:   "xyz",
    27  		},
    28  		{
    29  			name:     "FromDefault",
    30  			options:  []FileOption{},
    31  			wantHelp: "  -config string\n    \tthe path of the config file\n",
    32  			args:     []string{"-config", "./testdata/empty.json"},
    33  			wantA1:   "a1",
    34  			wantA2:   "a2",
    35  			wantA3:   "a3",
    36  		},
    37  		{
    38  			name:     "WithFlagFormat",
    39  			options:  []FileOption{FileFormat(JSON{}), FilePathFlag("c")},
    40  			wantHelp: "  -c string\n    \tthe path of the config file\n",
    41  			args:     []string{"-c", "./testdata/valid.json"},
    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  			src := File(tc.options...)
    52  			a1, a2, a3 = "a1", "a2", "a3"
    53  
    54  			if err := src.Register(fset, fields); err != nil {
    55  				t.Fatalf("src.Prepare(fields) returns error: %v", err)
    56  			}
    57  
    58  			var output bytes.Buffer
    59  			fset.SetOutput(&output)
    60  			fset.PrintDefaults()
    61  
    62  			if diff := cmp.Diff(output.String(), tc.wantHelp); diff != "" {
    63  				t.Errorf("output diff: (-got, +want)\n%s", diff)
    64  			}
    65  
    66  			if err := fset.Parse(tc.args); err != nil {
    67  				t.Fatalf("fset.Parse() error: %v", err)
    68  			}
    69  
    70  			if err := src.Parse(t.Context(), tc.args); err != nil {
    71  				t.Fatalf("src.Parse() should return no error, which is not: %v", err)
    72  			}
    73  
    74  			if got, want := a1, tc.wantA1; got != want {
    75  				t.Errorf("after src.Parse(), a1 = %q, want: %q", got, want)
    76  			}
    77  			if got, want := a2, tc.wantA2; got != want {
    78  				t.Errorf("after src.Parse(), a2 = %q, want: %q", got, want)
    79  			}
    80  			if got, want := a3, tc.wantA3; got != want {
    81  				t.Errorf("after src.Parse(), a3 = %q, want: %q", got, want)
    82  			}
    83  		})
    84  	}
    85  
    86  	t.Run("InvalidFile", func(t *testing.T) {
    87  		fset := flag.NewFlagSet("", flag.ContinueOnError)
    88  		src := File()
    89  
    90  		var output bytes.Buffer
    91  		fset.SetOutput(&output)
    92  		t.Logf("output:\n%s", output.String())
    93  
    94  		if err := src.Register(fset, fields); err != nil {
    95  			t.Fatalf("src.Prepare(fields) returns error: %v", err)
    96  		}
    97  
    98  		args := []string{"-config", "testdata/not_exist.json"}
    99  		if err := fset.Parse(args); err != nil {
   100  			t.Fatalf("fset.Parse() error: %v", err)
   101  		}
   102  
   103  		if err := src.Parse(t.Context(), args); err == nil {
   104  			t.Fatalf("src.Parse() error: %v, want an error", err)
   105  		}
   106  	})
   107  
   108  	t.Run("EmptyConfigFile", func(t *testing.T) {
   109  		fset := flag.NewFlagSet("", flag.ContinueOnError)
   110  		src := File()
   111  
   112  		if err := src.Register(fset, fields); err != nil {
   113  			t.Fatalf("src.Prepare(fields) returns error: %v", err)
   114  		}
   115  
   116  		args := []string{"-config", ""}
   117  		if err := fset.Parse(args); err != nil {
   118  			t.Fatalf("fset.Parse() error: %v", err)
   119  		}
   120  
   121  		if err := src.Parse(t.Context(), args); err != nil {
   122  			t.Fatalf("src.Parse() = %v, want no error", err)
   123  		}
   124  	})
   125  
   126  	t.Run("InvalidFlag", func(t *testing.T) {
   127  		fset := flag.NewFlagSet("", flag.ContinueOnError)
   128  		src := File()
   129  
   130  		if err := src.Register(fset, fields); err != nil {
   131  			t.Fatalf("src.Prepare(fields) returns error: %v", err)
   132  		}
   133  
   134  		args := []string{"-nonexist_flag", ""}
   135  		if err := fset.Parse(args); err == nil {
   136  			t.Fatalf("fset.Parse() = nil, want an error")
   137  		}
   138  
   139  		if err := src.Parse(t.Context(), args); err != nil {
   140  			t.Fatalf("src.Parse() = %v, want no error", err)
   141  		}
   142  	})
   143  }
   144  
   145  func TestFileError(t *testing.T) {
   146  	tests := []struct {
   147  		name    string
   148  		options []FileOption
   149  	}{
   150  		{"EmptyCodec", []FileOption{FileFormat(nil)}},
   151  		{"EmptyPathFlag", []FileOption{FilePathFlag("")}},
   152  	}
   153  
   154  	for _, tc := range tests {
   155  		t.Run(tc.name, func(t *testing.T) {
   156  			fset := flag.NewFlagSet("", flag.ContinueOnError)
   157  			src := File(tc.options...)
   158  			err := src.Error()
   159  			if err == nil {
   160  				t.Errorf("src().Error() want an error, which is not")
   161  			}
   162  
   163  			errPrepare := src.Register(fset, fields)
   164  			if err != errPrepare {
   165  				t.Errorf("src().Prepare() = %v, src().Error() = %v, they should be same", errPrepare, err)
   166  			}
   167  
   168  			args := []string{}
   169  			if err := fset.Parse(args); err != nil {
   170  				t.Fatalf("fset.Parse() error: %v", err)
   171  			}
   172  
   173  			errParse := src.Parse(t.Context(), args)
   174  			if err != errPrepare {
   175  				t.Errorf("src().Parse() = %v, src().Error() = %v, they should be same", errParse, err)
   176  			}
   177  		})
   178  	}
   179  }