github.com/ungtb10d/cli/v2@v2.0.0-20221110210412-98537dd9d6a1/pkg/cmd/config/set/set_test.go (about)

     1  package set
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  
     7  	"github.com/ungtb10d/cli/v2/internal/config"
     8  	"github.com/ungtb10d/cli/v2/pkg/cmdutil"
     9  	"github.com/ungtb10d/cli/v2/pkg/iostreams"
    10  	"github.com/google/shlex"
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  func TestNewCmdConfigSet(t *testing.T) {
    15  	tests := []struct {
    16  		name     string
    17  		input    string
    18  		output   SetOptions
    19  		wantsErr bool
    20  	}{
    21  		{
    22  			name:     "no arguments",
    23  			input:    "",
    24  			output:   SetOptions{},
    25  			wantsErr: true,
    26  		},
    27  		{
    28  			name:     "no value argument",
    29  			input:    "key",
    30  			output:   SetOptions{},
    31  			wantsErr: true,
    32  		},
    33  		{
    34  			name:     "set key value",
    35  			input:    "key value",
    36  			output:   SetOptions{Key: "key", Value: "value"},
    37  			wantsErr: false,
    38  		},
    39  		{
    40  			name:     "set key value with host",
    41  			input:    "key value --host test.com",
    42  			output:   SetOptions{Hostname: "test.com", Key: "key", Value: "value"},
    43  			wantsErr: false,
    44  		},
    45  	}
    46  
    47  	for _, tt := range tests {
    48  		t.Run(tt.name, func(t *testing.T) {
    49  			_ = config.StubWriteConfig(t)
    50  
    51  			f := &cmdutil.Factory{
    52  				Config: func() (config.Config, error) {
    53  					return config.NewBlankConfig(), nil
    54  				},
    55  			}
    56  
    57  			argv, err := shlex.Split(tt.input)
    58  			assert.NoError(t, err)
    59  
    60  			var gotOpts *SetOptions
    61  			cmd := NewCmdConfigSet(f, func(opts *SetOptions) error {
    62  				gotOpts = opts
    63  				return nil
    64  			})
    65  			cmd.Flags().BoolP("help", "x", false, "")
    66  
    67  			cmd.SetArgs(argv)
    68  			cmd.SetIn(&bytes.Buffer{})
    69  			cmd.SetOut(&bytes.Buffer{})
    70  			cmd.SetErr(&bytes.Buffer{})
    71  
    72  			_, err = cmd.ExecuteC()
    73  			if tt.wantsErr {
    74  				assert.Error(t, err)
    75  				return
    76  			}
    77  
    78  			assert.NoError(t, err)
    79  			assert.Equal(t, tt.output.Hostname, gotOpts.Hostname)
    80  			assert.Equal(t, tt.output.Key, gotOpts.Key)
    81  			assert.Equal(t, tt.output.Value, gotOpts.Value)
    82  		})
    83  	}
    84  }
    85  
    86  func Test_setRun(t *testing.T) {
    87  	tests := []struct {
    88  		name          string
    89  		input         *SetOptions
    90  		expectedValue string
    91  		stdout        string
    92  		stderr        string
    93  		wantsErr      bool
    94  		errMsg        string
    95  	}{
    96  		{
    97  			name: "set key value",
    98  			input: &SetOptions{
    99  				Config: config.NewBlankConfig(),
   100  				Key:    "editor",
   101  				Value:  "vim",
   102  			},
   103  			expectedValue: "vim",
   104  		},
   105  		{
   106  			name: "set key value scoped by host",
   107  			input: &SetOptions{
   108  				Config:   config.NewBlankConfig(),
   109  				Hostname: "github.com",
   110  				Key:      "editor",
   111  				Value:    "vim",
   112  			},
   113  			expectedValue: "vim",
   114  		},
   115  		{
   116  			name: "set unknown key",
   117  			input: &SetOptions{
   118  				Config: config.NewBlankConfig(),
   119  				Key:    "unknownKey",
   120  				Value:  "someValue",
   121  			},
   122  			expectedValue: "someValue",
   123  			stderr:        "! warning: 'unknownKey' is not a known configuration key\n",
   124  		},
   125  		{
   126  			name: "set invalid value",
   127  			input: &SetOptions{
   128  				Config: config.NewBlankConfig(),
   129  				Key:    "git_protocol",
   130  				Value:  "invalid",
   131  			},
   132  			wantsErr: true,
   133  			errMsg:   "failed to set \"git_protocol\" to \"invalid\": valid values are 'https', 'ssh'",
   134  		},
   135  	}
   136  	for _, tt := range tests {
   137  		t.Run(tt.name, func(t *testing.T) {
   138  			_ = config.StubWriteConfig(t)
   139  
   140  			ios, _, stdout, stderr := iostreams.Test()
   141  			tt.input.IO = ios
   142  
   143  			err := setRun(tt.input)
   144  			if tt.wantsErr {
   145  				assert.EqualError(t, err, tt.errMsg)
   146  				return
   147  			}
   148  			assert.NoError(t, err)
   149  			assert.Equal(t, tt.stdout, stdout.String())
   150  			assert.Equal(t, tt.stderr, stderr.String())
   151  
   152  			val, err := tt.input.Config.GetOrDefault(tt.input.Hostname, tt.input.Key)
   153  			assert.NoError(t, err)
   154  			assert.Equal(t, tt.expectedValue, val)
   155  		})
   156  	}
   157  }
   158  
   159  func Test_ValidateValue(t *testing.T) {
   160  	err := ValidateValue("git_protocol", "sshpps")
   161  	assert.EqualError(t, err, "invalid value")
   162  
   163  	err = ValidateValue("git_protocol", "ssh")
   164  	assert.NoError(t, err)
   165  
   166  	err = ValidateValue("editor", "vim")
   167  	assert.NoError(t, err)
   168  
   169  	err = ValidateValue("got", "123")
   170  	assert.NoError(t, err)
   171  
   172  	err = ValidateValue("http_unix_socket", "really_anything/is/allowed/and/net.Dial\\(...\\)/will/ultimately/validate")
   173  	assert.NoError(t, err)
   174  }
   175  
   176  func Test_ValidateKey(t *testing.T) {
   177  	err := ValidateKey("invalid")
   178  	assert.EqualError(t, err, "invalid key")
   179  
   180  	err = ValidateKey("git_protocol")
   181  	assert.NoError(t, err)
   182  
   183  	err = ValidateKey("editor")
   184  	assert.NoError(t, err)
   185  
   186  	err = ValidateKey("prompt")
   187  	assert.NoError(t, err)
   188  
   189  	err = ValidateKey("pager")
   190  	assert.NoError(t, err)
   191  
   192  	err = ValidateKey("http_unix_socket")
   193  	assert.NoError(t, err)
   194  
   195  	err = ValidateKey("browser")
   196  	assert.NoError(t, err)
   197  }