github.com/toolvox/utilgo@v0.0.5/pkg/cli/lexer/tokenize_flags_test.go (about)

     1  package lexer_test
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/require"
     9  
    10  	"github.com/toolvox/utilgo/pkg/cli/lexer"
    11  )
    12  
    13  var tests = []struct {
    14  	args            string
    15  	boolFlags       []string
    16  	expectedActions []string
    17  	expectedFlags   map[string]string
    18  }{
    19  	/*0*/ {args: "x", expectedFlags: map[string]string{}},
    20  	/*1*/ {args: "x -", expectedFlags: map[string]string{}},
    21  	/*2*/ {args: "x --", expectedFlags: map[string]string{}},
    22  	/*3*/ {args: "x ---", expectedFlags: map[string]string{}},
    23  	/*4*/ {args: "x --=", expectedFlags: map[string]string{}},
    24  	/*5*/ {args: "x --==", expectedFlags: map[string]string{}},
    25  
    26  	/*6*/ {args: "x", boolFlags: []string{"a"},
    27  		expectedFlags: map[string]string{"a": "false"}},
    28  	/*7*/ {args: "x a",
    29  		expectedActions: []string{"a"},
    30  		expectedFlags:   map[string]string{}},
    31  	/*8*/ {args: "x -a",
    32  		expectedFlags: map[string]string{"a": ""}},
    33  	/*9*/ {args: "x -a", boolFlags: []string{"a"},
    34  		expectedFlags: map[string]string{"a": "true"}},
    35  
    36  	/*10*/ {args: "x --a", boolFlags: []string{"a"},
    37  		expectedFlags: map[string]string{"a": "true"}},
    38  	/*11*/ {args: "x ---a", boolFlags: []string{"a"},
    39  		expectedFlags: map[string]string{"a": "true"}},
    40  	/*12*/ {args: "x --a=", boolFlags: []string{"a"},
    41  		expectedFlags: map[string]string{"a": "false"}},
    42  	/*13*/ {args: "x --a==", boolFlags: []string{"a"},
    43  		expectedFlags: map[string]string{"a": "="}},
    44  	/*14*/ {args: "x --a===", boolFlags: []string{"a"},
    45  		expectedFlags: map[string]string{"a": "=="}},
    46  
    47  	/*15*/ {
    48  		args:            "x a b",
    49  		boolFlags:       []string{},
    50  		expectedActions: []string{"a", "b"},
    51  		expectedFlags:   map[string]string{},
    52  	},
    53  	/*16*/ {
    54  		args:            "x -a b",
    55  		boolFlags:       []string{},
    56  		expectedActions: []string{},
    57  		expectedFlags:   map[string]string{"a": "b"},
    58  	},
    59  	/*17*/ {
    60  		args:            "x -a b",
    61  		boolFlags:       []string{"a"},
    62  		expectedActions: []string{"b"},
    63  		expectedFlags:   map[string]string{"a": "true"},
    64  	},
    65  	/*18*/ {
    66  		args:            "x -a b",
    67  		boolFlags:       []string{"b"},
    68  		expectedActions: []string{},
    69  		expectedFlags:   map[string]string{"a": "b", "b": "false"},
    70  	},
    71  	/*19*/ {
    72  		args:            "x -a b",
    73  		boolFlags:       []string{"a", "b"},
    74  		expectedActions: []string{"b"},
    75  		expectedFlags:   map[string]string{"a": "true", "b": "false"},
    76  	},
    77  	/*20*/ {
    78  		args:            "x -a=b",
    79  		boolFlags:       []string{},
    80  		expectedActions: []string{},
    81  		expectedFlags:   map[string]string{"a": "b"},
    82  	},
    83  	/*21*/ {
    84  		args:            "x -a=b",
    85  		boolFlags:       []string{"a"},
    86  		expectedActions: []string{},
    87  		expectedFlags:   map[string]string{"a": "b"},
    88  	},
    89  	/*22*/ {
    90  		args:            "x -a=b",
    91  		boolFlags:       []string{"b"},
    92  		expectedActions: []string{},
    93  		expectedFlags:   map[string]string{"a": "b", "b": "false"},
    94  	},
    95  	/*23*/ {
    96  		args:            "x -a=b",
    97  		boolFlags:       []string{"b", "a"},
    98  		expectedActions: []string{},
    99  		expectedFlags:   map[string]string{"a": "b", "b": "false"},
   100  	},
   101  	/*24*/ {
   102  		args:            "x -a= b",
   103  		boolFlags:       []string{"a"},
   104  		expectedActions: []string{"b"},
   105  		expectedFlags:   map[string]string{"a": "false"},
   106  	},
   107  	/*25*/ {
   108  		args:            "x -a== b",
   109  		boolFlags:       []string{"a"},
   110  		expectedActions: []string{"b"},
   111  		expectedFlags:   map[string]string{"a": "="},
   112  	},
   113  	/*26*/ {
   114  		args:            "x -a== b",
   115  		boolFlags:       []string{},
   116  		expectedActions: []string{"b"},
   117  		expectedFlags:   map[string]string{"a": "="},
   118  	},
   119  	/*27*/ {
   120  		args:            "x =a- --b=== ---c=d e --f g -h --i==---j k",
   121  		boolFlags:       []string{"b", "h"},
   122  		expectedActions: []string{"=a-", "e", "k"},
   123  		expectedFlags: map[string]string{
   124  			"b": "==",
   125  			"c": "d",
   126  			"f": "g",
   127  			"h": "true",
   128  			"i": "=---j",
   129  		},
   130  	},
   131  }
   132  
   133  func Test_TokenizeFlags(t *testing.T) {
   134  	t.Run("Sanity", func(t *testing.T) {
   135  		for ti, tt := range tests {
   136  			t.Run(fmt.Sprintf("%d_%s", ti, tt.args), func(t *testing.T) {
   137  				must := require.New(t)
   138  				must.NotPanics(func() {
   139  					testTokenizer := lexer.NewFlagTokenizer(tt.boolFlags...)
   140  					must.NotNil(testTokenizer)
   141  
   142  					testTokenizer.TokenizeFlags(strings.Split(tt.args, " "))
   143  
   144  					must.NotNil(testTokenizer.Actions)
   145  					// must.Len(testTokenizer.Actions, len(tt.expectedActions))
   146  					must.ElementsMatch(tt.expectedActions, testTokenizer.Actions[1:])
   147  
   148  					must.NotNil(testTokenizer.Tokenized)
   149  					// must.Len(testTokenizer.Tokenized, len(tt.expectedFlags))
   150  					must.Equal(tt.expectedFlags, testTokenizer.Tokenized)
   151  				})
   152  			})
   153  		}
   154  	})
   155  }