github.com/cli/cli@v1.14.1-0.20210902173923-1af6a669e342/pkg/cmd/config/set/set_test.go (about)

     1  package set
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  
     7  	"github.com/cli/cli/internal/config"
     8  	"github.com/cli/cli/pkg/cmdutil"
     9  	"github.com/cli/cli/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  			f := &cmdutil.Factory{
    50  				Config: func() (config.Config, error) {
    51  					return config.ConfigStub{}, nil
    52  				},
    53  			}
    54  
    55  			argv, err := shlex.Split(tt.input)
    56  			assert.NoError(t, err)
    57  
    58  			var gotOpts *SetOptions
    59  			cmd := NewCmdConfigSet(f, func(opts *SetOptions) error {
    60  				gotOpts = opts
    61  				return nil
    62  			})
    63  			cmd.Flags().BoolP("help", "x", false, "")
    64  
    65  			cmd.SetArgs(argv)
    66  			cmd.SetIn(&bytes.Buffer{})
    67  			cmd.SetOut(&bytes.Buffer{})
    68  			cmd.SetErr(&bytes.Buffer{})
    69  
    70  			_, err = cmd.ExecuteC()
    71  			if tt.wantsErr {
    72  				assert.Error(t, err)
    73  				return
    74  			}
    75  
    76  			assert.NoError(t, err)
    77  			assert.Equal(t, tt.output.Hostname, gotOpts.Hostname)
    78  			assert.Equal(t, tt.output.Key, gotOpts.Key)
    79  			assert.Equal(t, tt.output.Value, gotOpts.Value)
    80  		})
    81  	}
    82  }
    83  
    84  func Test_setRun(t *testing.T) {
    85  	tests := []struct {
    86  		name          string
    87  		input         *SetOptions
    88  		expectedValue string
    89  		stdout        string
    90  		stderr        string
    91  		wantsErr      bool
    92  		errMsg        string
    93  	}{
    94  		{
    95  			name: "set key value",
    96  			input: &SetOptions{
    97  				Config: config.ConfigStub{},
    98  				Key:    "editor",
    99  				Value:  "vim",
   100  			},
   101  			expectedValue: "vim",
   102  		},
   103  		{
   104  			name: "set key value scoped by host",
   105  			input: &SetOptions{
   106  				Config:   config.ConfigStub{},
   107  				Hostname: "github.com",
   108  				Key:      "editor",
   109  				Value:    "vim",
   110  			},
   111  			expectedValue: "vim",
   112  		},
   113  		{
   114  			name: "set unknown key",
   115  			input: &SetOptions{
   116  				Config: config.ConfigStub{},
   117  				Key:    "unknownKey",
   118  				Value:  "someValue",
   119  			},
   120  			expectedValue: "someValue",
   121  			stderr:        "! warning: 'unknownKey' is not a known configuration key\n",
   122  		},
   123  		{
   124  			name: "set invalid value",
   125  			input: &SetOptions{
   126  				Config: config.ConfigStub{},
   127  				Key:    "git_protocol",
   128  				Value:  "invalid",
   129  			},
   130  			wantsErr: true,
   131  			errMsg:   "failed to set \"git_protocol\" to \"invalid\": valid values are 'https', 'ssh'",
   132  		},
   133  	}
   134  	for _, tt := range tests {
   135  		io, _, stdout, stderr := iostreams.Test()
   136  		tt.input.IO = io
   137  
   138  		t.Run(tt.name, func(t *testing.T) {
   139  			err := setRun(tt.input)
   140  			if tt.wantsErr {
   141  				assert.EqualError(t, err, tt.errMsg)
   142  				return
   143  			}
   144  			assert.NoError(t, err)
   145  			assert.Equal(t, tt.stdout, stdout.String())
   146  			assert.Equal(t, tt.stderr, stderr.String())
   147  
   148  			val, err := tt.input.Config.Get(tt.input.Hostname, tt.input.Key)
   149  			assert.NoError(t, err)
   150  			assert.Equal(t, tt.expectedValue, val)
   151  
   152  			val, err = tt.input.Config.Get("", "_written")
   153  			assert.NoError(t, err)
   154  			assert.Equal(t, "true", val)
   155  		})
   156  	}
   157  }