func (s *JujuLogSuite) TestLogInitMissingMessage(c *gc.C) {
com := s.newJujuLogCommand(c)
testing.TestInit(c, com, []string{"-l", "FATAL"}, "no message specified")
com = s.newJujuLogCommand(c)
testing.TestInit(c, com, []string{"--log-level", "FATAL"}, "no message specified")
}
func (s *JujuLogSuite) TestLogInitMissingLevel(c *gc.C) {
com := s.newJujuLogCommand(c)
testing.TestInit(c, com, []string{"-l"}, "flag needs an argument.*")
com = s.newJujuLogCommand(c)
testing.TestInit(c, com, []string{"--log-level"}, "flag needs an argument.*")
}
func (*RunSuite) TestTimeoutArgParsing(c *gc.C) {
for i, test := range []struct {
message string
args []string
errMatch string
timeout time.Duration
}{{
message: "default time",
args: []string{"--all", "sudo reboot"},
timeout: 5 * time.Minute,
}, {
message: "invalid time",
args: []string{"--timeout=foo", "--all", "sudo reboot"},
errMatch: `invalid value "foo" for flag --timeout: time: invalid duration foo`,
}, {
message: "two hours",
args: []string{"--timeout=2h", "--all", "sudo reboot"},
timeout: 2 * time.Hour,
}, {
message: "3 minutes 30 seconds",
args: []string{"--timeout=3m30s", "--all", "sudo reboot"},
timeout: (3 * time.Minute) + (30 * time.Second),
}} {
c.Log(fmt.Sprintf("%v: %s", i, test.message))
cmd := &runCommand{}
runCmd := modelcmd.Wrap(cmd)
testing.TestInit(c, runCmd, test.args, test.errMatch)
if test.errMatch == "" {
c.Check(cmd.timeout, gc.Equals, test.timeout)
}
}
}
func (s *statusSetSuite) TestStatusSetInit(c *gc.C) {
for i, t := range statusSetInitTests {
c.Logf("test %d: %#v", i, t.args)
hctx := s.GetStatusHookContext(c)
com, err := jujuc.NewCommand(hctx, cmdString("status-set"))
c.Assert(err, jc.ErrorIsNil)
testing.TestInit(c, com, t.args, t.err)
}
}
func (s *SetEnvironmentSuite) TestInit(c *gc.C) {
for _, t := range setEnvInitTests {
command := &SetEnvironmentCommand{}
testing.TestInit(c, envcmd.Wrap(command), t.args, t.err)
if t.expected != nil {
c.Assert(command.values, gc.DeepEquals, t.expected)
}
}
}
func (s *storageAddSuite) TestStorageAddInit(c *gc.C) {
tests := []tstData{
{[]string{}, 1, "storage add requires a storage directive"},
{[]string{"data=-676"}, 1, `.*cannot parse count: count must be gre.*`},
{[]string{"data="}, 1, ".*storage constraints require at least one.*"},
{[]string{"data=pool"}, 1, `.*only count can be specified for "data".*`},
{[]string{"data=pool,1M"}, 1, `.*only count can be specified for "data".*`},
{[]string{"data=1M"}, 1, `.*only count can be specified for "data".*`},
{[]string{"data=2,1M"}, 1, `.*only count can be specified for "data".*`},
{[]string{"cache", "data=2,1M"}, 1, `.*only count can be specified for "data".*`},
}
for i, t := range tests {
c.Logf("test %d: %#v", i, t.args)
com := s.getStorageUnitAddCommand(c)
testing.TestInit(c, com, t.args, t.err)
}
}
func (*RunSuite) TestTargetArgParsing(c *gc.C) {
for i, test := range []struct {
message string
args []string
all bool
machines []string
units []string
services []string
commands string
errMatch string
}{{
message: "no args",
errMatch: "no commands specified",
}, {
message: "no target",
args: []string{"sudo reboot"},
errMatch: "You must specify a target, either through --all, --machine, --service or --unit",
}, {
message: "too many args",
args: []string{"--all", "sudo reboot", "oops"},
errMatch: `unrecognized args: \["oops"\]`,
}, {
message: "command to all machines",
args: []string{"--all", "sudo reboot"},
all: true,
commands: "sudo reboot",
}, {
message: "all and defined machines",
args: []string{"--all", "--machine=1,2", "sudo reboot"},
errMatch: `You cannot specify --all and individual machines`,
}, {
message: "command to machines 1, 2, and 1/kvm/0",
args: []string{"--machine=1,2,1/kvm/0", "sudo reboot"},
commands: "sudo reboot",
machines: []string{"1", "2", "1/kvm/0"},
}, {
message: "bad machine names",
args: []string{"--machine=foo,machine-2", "sudo reboot"},
errMatch: "" +
"The following run targets are not valid:\n" +
" \"foo\" is not a valid machine id\n" +
" \"machine-2\" is not a valid machine id",
}, {
message: "all and defined services",
args: []string{"--all", "--service=wordpress,mysql", "sudo reboot"},
errMatch: `You cannot specify --all and individual services`,
}, {
message: "command to services wordpress and mysql",
args: []string{"--service=wordpress,mysql", "sudo reboot"},
commands: "sudo reboot",
services: []string{"wordpress", "mysql"},
}, {
message: "bad service names",
args: []string{"--service", "foo,2,foo/0", "sudo reboot"},
errMatch: "" +
"The following run targets are not valid:\n" +
" \"2\" is not a valid service name\n" +
" \"foo/0\" is not a valid service name",
}, {
message: "all and defined units",
args: []string{"--all", "--unit=wordpress/0,mysql/1", "sudo reboot"},
errMatch: `You cannot specify --all and individual units`,
}, {
message: "command to valid units",
args: []string{"--unit=wordpress/0,wordpress/1,mysql/0", "sudo reboot"},
commands: "sudo reboot",
units: []string{"wordpress/0", "wordpress/1", "mysql/0"},
}, {
message: "bad unit names",
args: []string{"--unit", "foo,2,foo/0", "sudo reboot"},
errMatch: "" +
"The following run targets are not valid:\n" +
" \"foo\" is not a valid unit name\n" +
" \"2\" is not a valid unit name",
}, {
message: "command to mixed valid targets",
args: []string{"--machine=0", "--unit=wordpress/0,wordpress/1", "--service=mysql", "sudo reboot"},
commands: "sudo reboot",
machines: []string{"0"},
services: []string{"mysql"},
units: []string{"wordpress/0", "wordpress/1"},
}} {
c.Log(fmt.Sprintf("%v: %s", i, test.message))
cmd := &runCommand{}
runCmd := modelcmd.Wrap(cmd)
testing.TestInit(c, runCmd, test.args, test.errMatch)
if test.errMatch == "" {
c.Check(cmd.all, gc.Equals, test.all)
c.Check(cmd.machines, gc.DeepEquals, test.machines)
c.Check(cmd.services, gc.DeepEquals, test.services)
c.Check(cmd.units, gc.DeepEquals, test.units)
c.Check(cmd.commands, gc.Equals, test.commands)
}
}
}
func (s *ConfigGetSuite) TestUnknownArg(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, cmdString("config-get"))
c.Assert(err, jc.ErrorIsNil)
testing.TestInit(c, com, []string{"multiple", "keys"}, `unrecognized args: \["keys"\]`)
}
func (s *JujuLogSuite) TestRequiresMessage(c *gc.C) {
com := s.newJujuLogCommand(c)
testing.TestInit(c, com, nil, "no message specified")
}