func (s *RelationListSuite) TestRelationListHelp(c *gc.C) {
template := `
usage: relation-list [options]
purpose: list relation units
options:
--format (= smart)
specify output format (json|smart|yaml)
-o, --output (= "")
specify an output file
-r, --relation (= %s)
specify a relation by id
%s`[1:]
for relid, t := range map[int]struct {
usage, doc string
}{
-1: {"", "\n-r must be specified when not in a relation hook\n"},
0: {"peer0:0", ""},
} {
c.Logf("test relid %d", relid)
hctx, _ := s.newHookContext(relid, "")
com, err := jujuc.NewCommand(hctx, cmdString("relation-list"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
expect := fmt.Sprintf(template, t.usage, t.doc)
c.Assert(bufferString(ctx.Stdout), gc.Equals, expect)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
}
func (s *statusGetSuite) TestHelp(c *gc.C) {
hctx := s.GetStatusHookContext(c)
com, err := jujuc.NewCommand(hctx, cmdString("status-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
expectedHelp := "" +
"Usage: status-get [options] [--include-data] [--service]\n" +
"\n" +
"Summary:\n" +
"print status information\n" +
"\n" +
"Options:\n" +
"--format (= smart)\n" +
" Specify output format (json|smart|yaml)\n" +
"--include-data (= false)\n" +
" print all status data\n" +
"-o, --output (= \"\")\n" +
" Specify an output file\n" +
"--service (= false)\n" +
" print status for all units of this service if this unit is the leader\n" +
"\n" +
"Details:\n" +
"By default, only the status value is printed.\n" +
"If the --include-data flag is passed, the associated data are printed also.\n"
c.Assert(bufferString(ctx.Stdout), gc.Equals, expectedHelp)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *statusSetSuite) TestHelp(c *gc.C) {
hctx := s.GetStatusHookContext(c)
com, err := jujuc.NewCommand(hctx, cmdString("status-set"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
expectedHelp := "" +
"Usage: status-set [options] <maintenance | blocked | waiting | active> [message]\n" +
"\n" +
"Summary:\n" +
"set status information\n" +
"\n" +
"Options:\n" +
"--service (= false)\n" +
" set this status for the service to which the unit belongs if the unit is the leader\n" +
"\n" +
"Details:\n" +
"Sets the workload status of the charm. Message is optional.\n" +
"The \"last updated\" attribute of the status is set, even if the\n" +
"status and message are the same as what's already set.\n"
c.Assert(bufferString(ctx.Stdout), gc.Equals, expectedHelp)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *RelationListSuite) TestRelationList(c *gc.C) {
for i, t := range relationListTests {
c.Logf("test %d: %s", i, t.summary)
hctx, info := s.newHookContext(t.relid, "")
info.setRelations(0, t.members0)
info.setRelations(1, t.members1)
c.Logf("%#v %#v", info.rels[t.relid], t.members1)
com, err := jujuc.NewCommand(hctx, cmdString("relation-list"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, t.args)
c.Logf(bufferString(ctx.Stderr))
c.Assert(code, gc.Equals, t.code)
if code == 0 {
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
expect := t.out
if expect != "" {
expect = expect + "\n"
}
c.Assert(bufferString(ctx.Stdout), gc.Equals, expect)
} else {
c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
expect := fmt.Sprintf(`(.|\n)*error: %s\n`, t.out)
c.Assert(bufferString(ctx.Stderr), gc.Matches, expect)
}
}
}
func (s *storageGetSuite) TestHelp(c *gc.C) {
hctx, _ := s.newHookContext()
com, err := jujuc.NewCommand(hctx, cmdString("storage-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, `Usage: storage-get [options] [<key>]
Summary:
print information for storage instance with specified id
Options:
--format (= smart)
Specify output format (json|smart|yaml)
-o, --output (= "")
Specify an output file
-s (= data/0)
specify a storage instance by id
Details:
When no <key> is supplied, all keys values are printed.
`)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *storageListSuite) TestHelp(c *gc.C) {
hctx := s.newHookContext()
com, err := jujuc.NewCommand(hctx, cmdString("storage-list"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, `Usage: storage-list [options] [<storage-name>]
Summary:
list storage attached to the unit
Options:
--format (= smart)
Specify output format (json|smart|yaml)
-o, --output (= "")
Specify an output file
Details:
storage-list will list the names of all storage instances
attached to the unit. These names can be passed to storage-get
via the "-s" flag to query the storage attributes.
A storage name may be specified, in which case only storage
instances for that named storage will be returned.
`)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *OpenedPortsSuite) TestBadArgs(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, cmdString("opened-ports"))
c.Assert(err, jc.ErrorIsNil)
err = testing.InitCommand(com, []string{"foo"})
c.Assert(err, gc.ErrorMatches, `unrecognized args: \["foo"\]`)
}
func (s *RelationSetSuite) TestRun(c *gc.C) {
hctx, info := s.newHookContext(0, "")
for i, t := range relationSetRunTests {
c.Logf("test %d", i)
pristine := jujuctesting.Settings{"pristine": "untouched"}
info.rels[0].Units["u/0"] = pristine
basic := jujuctesting.Settings{"base": "value"}
info.rels[1].Units["u/0"] = basic
// Run the command.
com, err := jujuc.NewCommand(hctx, cmdString("relation-set"))
c.Assert(err, jc.ErrorIsNil)
rset := com.(*jujuc.RelationSetCommand)
rset.RelationId = 1
rset.Settings = t.change
ctx := testing.Context(c)
err = com.Run(ctx)
c.Assert(err, jc.ErrorIsNil)
// Check changes.
c.Assert(info.rels[0].Units["u/0"], gc.DeepEquals, pristine)
c.Assert(info.rels[1].Units["u/0"], gc.DeepEquals, t.expect)
}
}
func (s *RelationIdsSuite) TestHelp(c *gc.C) {
template := `
usage: %s
purpose: list all relation ids with the given relation name
options:
--format (= smart)
specify output format (json|smart|yaml)
-o, --output (= "")
specify an output file
%s`[1:]
for relid, t := range map[int]struct {
usage, doc string
}{
-1: {"relation-ids [options] <name>", ""},
0: {"relation-ids [options] [<name>]", "\nCurrent default relation name is \"x\".\n"},
3: {"relation-ids [options] [<name>]", "\nCurrent default relation name is \"y\".\n"},
} {
c.Logf("relid %d", relid)
hctx, _ := s.newHookContext(relid, "")
com, err := jujuc.NewCommand(hctx, cmdString("relation-ids"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
expect := fmt.Sprintf(template, t.usage, t.doc)
c.Assert(bufferString(ctx.Stdout), gc.Equals, expect)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
}
func (s *ActionGetSuite) TestHelp(c *gc.C) {
hctx := &actionGetContext{}
com, err := jujuc.NewCommand(hctx, cmdString("action-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, `Usage: action-get [options] [<key>[.<key>.<key>...]]
Summary:
get action parameters
Options:
--format (= smart)
Specify output format (json|smart|yaml)
-o, --output (= "")
Specify an output file
Details:
action-get will print the value of the parameter at the given key, serialized
as YAML. If multiple keys are passed, action-get will recurse into the param
map as needed.
`)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *statusGetSuite) TestServiceStatus(c *gc.C) {
expected := map[string]interface{}{
"service-status": map[interface{}]interface{}{
"status-data": map[interface{}]interface{}{},
"units": map[interface{}]interface{}{
"": map[interface{}]interface{}{
"message": "this is a unit status",
"status": "active",
"status-data": map[interface{}]interface{}{},
},
},
"message": "this is a service status",
"status": "active"},
}
hctx := s.GetStatusHookContext(c)
setFakeServiceStatus(hctx)
com, err := jujuc.NewCommand(hctx, cmdString("status-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--format", "json", "--include-data", "--service"})
c.Assert(code, gc.Equals, 0)
var out map[string]interface{}
c.Assert(goyaml.Unmarshal(bufferBytes(ctx.Stdout), &out), gc.IsNil)
c.Assert(out, gc.DeepEquals, expected)
}
func (s *statusGetSuite) TestOutputFormatJustStatus(c *gc.C) {
for i, t := range statusGetTests {
c.Logf("test %d: %#v", i, t.args)
hctx := s.GetStatusHookContext(c)
setFakeStatus(hctx)
com, err := jujuc.NewCommand(hctx, cmdString("status-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, t.args)
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
var out interface{}
var outMap map[string]interface{}
switch t.format {
case formatYaml:
c.Check(goyaml.Unmarshal(bufferBytes(ctx.Stdout), &outMap), gc.IsNil)
out = outMap
case formatJson:
c.Check(json.Unmarshal(bufferBytes(ctx.Stdout), &outMap), gc.IsNil)
out = outMap
default:
out = string(bufferBytes(ctx.Stdout))
}
c.Check(out, gc.DeepEquals, t.out)
}
}
func (s *ConfigGetSuite) TestHelp(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, cmdString("config-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, `Usage: config-get [options] [<key>]
Summary:
print service configuration
Options:
-a, --all (= false)
print all keys
--format (= smart)
Specify output format (json|smart|yaml)
-o, --output (= "")
Specify an output file
Details:
When no <key> is supplied, all keys with values or defaults are printed. If
--all is set, all known keys are printed; those without defaults or values are
reported as null. <key> and --all are mutually exclusive.
`)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *ActionSetSuite) TestHelp(c *gc.C) {
hctx := &actionSettingContext{}
com, err := jujuc.NewCommand(hctx, cmdString("action-set"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, `usage: action-set <key>=<value> [<key>=<value> ...]
purpose: set action results
action-set adds the given values to the results map of the Action. This map
is returned to the user after the completion of the Action. Keys must start
and end with lowercase alphanumeric, and contain only lowercase alphanumeric,
hyphens and periods.
Example usage:
action-set outfile.size=10G
action-set foo.bar=2
action-set foo.baz.val=3
action-set foo.bar.zab=4
action-set foo.baz=1
will yield:
outfile:
size: "10G"
foo:
bar:
zab: "4"
baz: "1"
`)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *OpenedPortsSuite) runCommand(c *gc.C, hctx *Context, args ...string) (stdout, stderr string) {
com, err := jujuc.NewCommand(hctx, cmdString("opened-ports"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, args)
c.Assert(code, gc.Equals, 0)
return bufferString(ctx.Stdout), bufferString(ctx.Stderr)
}
func (s *ApplicationVersionSetSuite) createCommand(c *gc.C, err error) (*Context, cmd.Command) {
hctx := s.GetHookContext(c, -1, "")
s.Stub.SetErrors(err)
com, err := jujuc.NewCommand(hctx, cmdString("application-version-set"))
c.Assert(err, jc.ErrorIsNil)
return hctx, com
}
func (s *JujuRebootSuite) TestRebootInActions(c *gc.C) {
jujucCtx := &actionGetContext{}
com, err := jujuc.NewCommand(jujucCtx, cmdString("juju-reboot"))
c.Assert(err, jc.ErrorIsNil)
cmdCtx := testing.Context(c)
code := cmd.Main(com, cmdCtx, nil)
c.Check(code, gc.Equals, 1)
c.Assert(testing.Stderr(cmdCtx), gc.Equals, "error: juju-reboot is not supported when running an action.\n")
}
func (s *ConfigGetSuite) TestAllPlusKey(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, cmdString("config-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--all", "--format", "json", "monsters"})
c.Assert(code, gc.Equals, 2)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "error: cannot use argument --all together with key \"monsters\"\n")
}
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 *ActionFailSuite) TestNonActionSetActionFailedFails(c *gc.C) {
hctx := &nonActionFailContext{}
com, err := jujuc.NewCommand(hctx, cmdString("action-fail"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"oops"})
c.Check(code, gc.Equals, 1)
c.Check(bufferString(ctx.Stderr), gc.Equals, "error: not running an action\n")
c.Check(bufferString(ctx.Stdout), gc.Equals, "")
}
func (s *PortsSuite) TestHelp(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
open, err := jujuc.NewCommand(hctx, cmdString("open-port"))
c.Assert(err, jc.ErrorIsNil)
flags := testing.NewFlagSet()
c.Assert(string(open.Info().Help(flags)), gc.Equals, `
usage: open-port <port>[/<protocol>] or <from>-<to>[/<protocol>]
purpose: register a port or range to open
The port range will only be open while the service is exposed.
`[1:])
close, err := jujuc.NewCommand(hctx, cmdString("close-port"))
c.Assert(err, jc.ErrorIsNil)
c.Assert(string(close.Info().Help(flags)), gc.Equals, `
usage: close-port <port>[/<protocol>] or <from>-<to>[/<protocol>]
purpose: ensure a port or range is always closed
`[1:])
}
func (s *ActionGetSuite) TestNonActionRunFail(c *gc.C) {
hctx := &nonActionContext{}
com, err := jujuc.NewCommand(hctx, cmdString("action-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{})
c.Check(code, gc.Equals, 1)
c.Check(bufferString(ctx.Stdout), gc.Equals, "")
expect := fmt.Sprintf(`(\n)*error: %s\n`, "ActionParams queried from non-Action hook context")
c.Check(bufferString(ctx.Stderr), gc.Matches, expect)
}
func (s *PortsSuite) TestBadArgs(c *gc.C) {
for _, name := range []string{"open-port", "close-port"} {
for _, t := range badPortsTests {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, cmdString(name))
c.Assert(err, jc.ErrorIsNil)
err = testing.InitCommand(com, t.args)
c.Assert(err, gc.ErrorMatches, t.err)
}
}
}
func (s *RelationSetSuite) TestRunDeprecationWarning(c *gc.C) {
hctx, _ := s.newHookContext(0, "")
com, _ := jujuc.NewCommand(hctx, cmdString("relation-set"))
// The rel= is needed to make this a valid command.
ctx, err := testing.RunCommand(c, com, "--format", "foo", "rel=")
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stdout(ctx), gc.Equals, "")
c.Assert(testing.Stderr(ctx), gc.Equals, "--format flag deprecated for command \"relation-set\"")
}
func (s *ActionSetSuite) TestActionSetOnNonActionContextFails(c *gc.C) {
hctx := &nonActionSettingContext{}
com, err := jujuc.NewCommand(hctx, cmdString("action-set"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"oops=nope"})
c.Check(code, gc.Equals, 1)
c.Check(bufferString(ctx.Stdout), gc.Equals, "")
expect := fmt.Sprintf(`(\n)*error: %s\n`, "not running an action")
c.Check(bufferString(ctx.Stderr), gc.Matches, expect)
}
func (s *JujuRebootSuite) TestJujuRebootCommand(c *gc.C) {
var jujuRebootTests = []struct {
summary string
hctx *Context
args []string
code int
priority jujuc.RebootPriority
}{{
summary: "test reboot priority defaulting to RebootAfterHook",
hctx: &Context{shouldError: false, rebootPriority: jujuc.RebootSkip},
args: []string{},
code: 0,
priority: jujuc.RebootAfterHook,
}, {
summary: "test reboot priority being set to RebootNow",
hctx: &Context{shouldError: false, rebootPriority: jujuc.RebootSkip},
args: []string{"--now"},
code: 0,
priority: jujuc.RebootNow,
}, {
summary: "test a failed running of juju-reboot",
hctx: &Context{shouldError: true, rebootPriority: jujuc.RebootSkip},
args: []string{},
code: 1,
priority: jujuc.RebootAfterHook,
}, {
summary: "test a failed running with parameter provided",
hctx: &Context{shouldError: true, rebootPriority: jujuc.RebootSkip},
args: []string{"--now"},
code: 1,
priority: jujuc.RebootNow,
}, {
summary: "test invalid args provided",
hctx: &Context{shouldError: false, rebootPriority: jujuc.RebootSkip},
args: []string{"--way", "--too", "--many", "--args"},
code: 2,
priority: jujuc.RebootSkip,
}}
for i, t := range jujuRebootTests {
c.Logf("Test %d: %s", i, t.summary)
hctx := s.newHookContext(c)
hctx.shouldError = t.hctx.shouldError
hctx.rebootPriority = t.hctx.rebootPriority
com, err := jujuc.NewCommand(hctx, cmdString("juju-reboot"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, t.args)
c.Check(code, gc.Equals, t.code)
c.Check(hctx.rebootPriority, gc.Equals, t.priority)
}
}
func (s *ConfigGetSuite) TestOutputFormatKey(c *gc.C) {
for i, t := range configGetKeyTests {
c.Logf("test %d: %#v", i, t.args)
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, cmdString("config-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, t.args)
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
c.Assert(bufferString(ctx.Stdout), gc.Matches, t.out)
}
}
func (s *ConfigGetSuite) TestOutputPath(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, cmdString("config-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--output", "some-file", "monsters"})
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
content, err := ioutil.ReadFile(filepath.Join(ctx.Dir, "some-file"))
c.Assert(err, jc.ErrorIsNil)
c.Assert(string(content), gc.Equals, "False\n")
}
func (s *AddMetricSuite) TestHelp(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, cmdString("add-metric"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, `
usage: add-metric key1=value1 [key2=value2 ...]
purpose: send metrics
`[1:])
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *RelationGetSuite) TestOutputPath(c *gc.C) {
hctx, _ := s.newHookContext(1, "m/0")
com, err := jujuc.NewCommand(hctx, cmdString("relation-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--output", "some-file", "pew"})
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
content, err := ioutil.ReadFile(filepath.Join(ctx.Dir, "some-file"))
c.Assert(err, jc.ErrorIsNil)
c.Assert(string(content), gc.Equals, "pew\npew\n\n")
}
