github.com/dooferlad/cmd@v0.0.0-20150716022859-3edef806220b/args_test.go (about)

     1  // Copyright 2013 Canonical Ltd.
     2  // Licensed under the LGPLv3, see LICENSE file for details.
     3  
     4  package cmd_test
     5  
     6  import (
     7  	"fmt"
     8  	"io/ioutil"
     9  
    10  	"github.com/juju/testing"
    11  	gc "gopkg.in/check.v1"
    12  	"launchpad.net/gnuflag"
    13  
    14  	"github.com/juju/cmd"
    15  )
    16  
    17  type ArgsSuite struct {
    18  	testing.LoggingSuite
    19  }
    20  
    21  var _ = gc.Suite(&ArgsSuite{})
    22  
    23  func (*ArgsSuite) TestFlagsUsage(c *gc.C) {
    24  	for i, test := range []struct {
    25  		message       string
    26  		defaultValue  []string
    27  		args          []string
    28  		expectedValue []string
    29  	}{{
    30  		message: "nil default and no arg",
    31  	}, {
    32  		message:       "default value and not set by args",
    33  		defaultValue:  []string{"foo", "bar"},
    34  		expectedValue: []string{"foo", "bar"},
    35  	}, {
    36  		message:       "no value set by args",
    37  		args:          []string{"--value", "foo,bar"},
    38  		expectedValue: []string{"foo", "bar"},
    39  	}, {
    40  		message:       "default value and set by args",
    41  		defaultValue:  []string{"omg"},
    42  		args:          []string{"--value", "foo,bar"},
    43  		expectedValue: []string{"foo", "bar"},
    44  	}} {
    45  		c.Log(fmt.Sprintf("%v: %s", i, test.message))
    46  		f := gnuflag.NewFlagSet("test", gnuflag.ContinueOnError)
    47  		f.SetOutput(ioutil.Discard)
    48  		var value []string
    49  		f.Var(cmd.NewStringsValue(test.defaultValue, &value), "value", "help")
    50  		err := f.Parse(false, test.args)
    51  		c.Check(err, gc.IsNil)
    52  		c.Check(value, gc.DeepEquals, test.expectedValue)
    53  	}
    54  }
    55  
    56  func (*ArgsSuite) TestNewStringsValue(c *gc.C) {
    57  	for i, test := range []struct {
    58  		message      string
    59  		defaultValue []string
    60  	}{{
    61  		message: "null default",
    62  	}, {
    63  		message:      "empty default",
    64  		defaultValue: []string{},
    65  	}, {
    66  		message:      "single value",
    67  		defaultValue: []string{"foo"},
    68  	}, {
    69  		message:      "multiple values",
    70  		defaultValue: []string{"foo", "bar", "baz"},
    71  	}} {
    72  		c.Log(fmt.Sprintf("%v: %s", i, test.message))
    73  		var underlyingValue []string
    74  		_ = cmd.NewStringsValue(test.defaultValue, &underlyingValue)
    75  		c.Assert(underlyingValue, gc.DeepEquals, test.defaultValue)
    76  	}
    77  }
    78  
    79  func (*ArgsSuite) TestSet(c *gc.C) {
    80  	for i, test := range []struct {
    81  		message  string
    82  		arg      string
    83  		expected []string
    84  	}{{
    85  		message:  "empty",
    86  		expected: []string{""},
    87  	}, {
    88  		message:  "just whitespace",
    89  		arg:      "   ",
    90  		expected: []string{"   "},
    91  	}, {
    92  		message:  "whitespace and comma",
    93  		arg:      "  ,  ",
    94  		expected: []string{"  ", "  "},
    95  	}, {
    96  		message:  "single value",
    97  		arg:      "foo",
    98  		expected: []string{"foo"},
    99  	}, {
   100  		message:  "single value with comma",
   101  		arg:      "foo,",
   102  		expected: []string{"foo", ""},
   103  	}, {
   104  		message:  "single value with whitespace",
   105  		arg:      " foo ",
   106  		expected: []string{" foo "},
   107  	}, {
   108  		message:  "multiple values",
   109  		arg:      "foo,bar,baz",
   110  		expected: []string{"foo", "bar", "baz"},
   111  	}, {
   112  		message:  "multiple values with spaces",
   113  		arg:      "foo, bar, baz",
   114  		expected: []string{"foo", " bar", " baz"},
   115  	}} {
   116  		c.Log(fmt.Sprintf("%v: %s", i, test.message))
   117  		var result []string
   118  		value := cmd.NewStringsValue(nil, &result)
   119  		error := value.Set(test.arg)
   120  		c.Check(error, gc.IsNil)
   121  		c.Check(result, gc.DeepEquals, test.expected)
   122  	}
   123  }
   124  
   125  func (*ArgsSuite) TestString(c *gc.C) {
   126  	for i, test := range []struct {
   127  		message  string
   128  		target   []string
   129  		expected string
   130  	}{{
   131  		message:  "null",
   132  		expected: "",
   133  	}, {
   134  		message:  "empty",
   135  		target:   []string{},
   136  		expected: "",
   137  	}, {
   138  		message:  "single value",
   139  		target:   []string{"foo"},
   140  		expected: "foo",
   141  	}, {
   142  		message:  "multiple values",
   143  		target:   []string{"foo", "bar", "baz"},
   144  		expected: "foo,bar,baz",
   145  	}} {
   146  		c.Log(fmt.Sprintf("%v: %s", i, test.message))
   147  		var temp []string
   148  		value := cmd.NewStringsValue(test.target, &temp)
   149  		c.Assert(value.String(), gc.Equals, test.expected)
   150  	}
   151  }
   152  
   153  func (*ArgsSuite) TestAppendStringsUsage(c *gc.C) {
   154  	for i, test := range []struct {
   155  		message       string
   156  		args          []string
   157  		expectedValue []string
   158  	}{{
   159  		message: "no args",
   160  	}, {
   161  		message:       "value set by args",
   162  		args:          []string{"--value", "foo", "--value=bar"},
   163  		expectedValue: []string{"foo", "bar"},
   164  	}} {
   165  		c.Log(fmt.Sprintf("%v: %s", i, test.message))
   166  		f := gnuflag.NewFlagSet("test", gnuflag.ContinueOnError)
   167  		f.SetOutput(ioutil.Discard)
   168  		var value []string
   169  		f.Var(cmd.NewAppendStringsValue(&value), "value", "help")
   170  		err := f.Parse(false, test.args)
   171  		c.Check(err, gc.IsNil)
   172  		c.Check(value, gc.DeepEquals, test.expectedValue)
   173  	}
   174  }