github.com/abdfnx/gh-api@v0.0.0-20210414084727-f5432eec23b8/pkg/cmd/config/set/set_test.go (about)

     1  package set
     2  
     3  import (
     4  	"bytes"
     5  	"testing"
     6  	"github.com/abdfnx/gh-api/internal/config"
     7  	"github.com/abdfnx/gh-api/pkg/cmdutil"
     8  	"github.com/abdfnx/gh-api/pkg/iostreams"
     9  	"github.com/google/shlex"
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestNewCmdConfigSet(t *testing.T) {
    14  	tests := []struct {
    15  		name     string
    16  		input    string
    17  		output   SetOptions
    18  		wantsErr bool
    19  	}{
    20  		{
    21  			name:     "no arguments",
    22  			input:    "",
    23  			output:   SetOptions{},
    24  			wantsErr: true,
    25  		},
    26  		{
    27  			name:     "no value argument",
    28  			input:    "key",
    29  			output:   SetOptions{},
    30  			wantsErr: true,
    31  		},
    32  		{
    33  			name:     "set key value",
    34  			input:    "key value",
    35  			output:   SetOptions{Key: "key", Value: "value"},
    36  			wantsErr: false,
    37  		},
    38  		{
    39  			name:     "set key value with host",
    40  			input:    "key value --host test.com",
    41  			output:   SetOptions{Hostname: "test.com", Key: "key", Value: "value"},
    42  			wantsErr: false,
    43  		},
    44  	}
    45  
    46  	for _, tt := range tests {
    47  		t.Run(tt.name, func(t *testing.T) {
    48  			f := &cmdutil.Factory{
    49  				Config: func() (config.Config, error) {
    50  					return config.ConfigStub{}, nil
    51  				},
    52  			}
    53  
    54  			argv, err := shlex.Split(tt.input)
    55  			assert.NoError(t, err)
    56  
    57  			var gotOpts *SetOptions
    58  			cmd := NewCmdConfigSet(f, func(opts *SetOptions) error {
    59  				gotOpts = opts
    60  				return nil
    61  			})
    62  			cmd.Flags().BoolP("help", "x", false, "")
    63  
    64  			cmd.SetArgs(argv)
    65  			cmd.SetIn(&bytes.Buffer{})
    66  			cmd.SetOut(&bytes.Buffer{})
    67  			cmd.SetErr(&bytes.Buffer{})
    68  
    69  			_, err = cmd.ExecuteC()
    70  			if tt.wantsErr {
    71  				assert.Error(t, err)
    72  				return
    73  			}
    74  
    75  			assert.NoError(t, err)
    76  			assert.Equal(t, tt.output.Hostname, gotOpts.Hostname)
    77  			assert.Equal(t, tt.output.Key, gotOpts.Key)
    78  			assert.Equal(t, tt.output.Value, gotOpts.Value)
    79  		})
    80  	}
    81  }
    82  
    83  func Test_setRun(t *testing.T) {
    84  	tests := []struct {
    85  		name          string
    86  		input         *SetOptions
    87  		expectedValue string
    88  		stdout        string
    89  		stderr        string
    90  		wantsErr      bool
    91  		errMsg        string
    92  	}{
    93  		{
    94  			name: "set key value",
    95  			input: &SetOptions{
    96  				Config: config.ConfigStub{},
    97  				Key:    "editor",
    98  				Value:  "vim",
    99  			},
   100  			expectedValue: "vim",
   101  		},
   102  		{
   103  			name: "set key value scoped by host",
   104  			input: &SetOptions{
   105  				Config:   config.ConfigStub{},
   106  				Hostname: "github.com",
   107  				Key:      "editor",
   108  				Value:    "vim",
   109  			},
   110  			expectedValue: "vim",
   111  		},
   112  		{
   113  			name: "set unknown key",
   114  			input: &SetOptions{
   115  				Config: config.ConfigStub{},
   116  				Key:    "unknownKey",
   117  				Value:  "someValue",
   118  			},
   119  			expectedValue: "someValue",
   120  			stderr:        "! warning: 'unknownKey' is not a known configuration key\n",
   121  		},
   122  		{
   123  			name: "set invalid value",
   124  			input: &SetOptions{
   125  				Config: config.ConfigStub{},
   126  				Key:    "git_protocol",
   127  				Value:  "invalid",
   128  			},
   129  			wantsErr: true,
   130  			errMsg:   "failed to set \"git_protocol\" to \"invalid\": valid values are 'https', 'ssh'",
   131  		},
   132  	}
   133  	for _, tt := range tests {
   134  		io, _, stdout, stderr := iostreams.Test()
   135  		tt.input.IO = io
   136  
   137  		t.Run(tt.name, func(t *testing.T) {
   138  			err := setRun(tt.input)
   139  			if tt.wantsErr {
   140  				assert.EqualError(t, err, tt.errMsg)
   141  				return
   142  			}
   143  			assert.NoError(t, err)
   144  			assert.Equal(t, tt.stdout, stdout.String())
   145  			assert.Equal(t, tt.stderr, stderr.String())
   146  
   147  			val, err := tt.input.Config.Get(tt.input.Hostname, tt.input.Key)
   148  			assert.NoError(t, err)
   149  			assert.Equal(t, tt.expectedValue, val)
   150  
   151  			val, err = tt.input.Config.Get("", "_written")
   152  			assert.NoError(t, err)
   153  			assert.Equal(t, "true", val)
   154  		})
   155  	}
   156  }