func (c *HelpToolCommand) Run(ctx *cmd.Context) error {
var hookctx dummyHookContext
if c.tool == "" {
// Ripped from SuperCommand. We could Run() a SuperCommand
// with "help commands", but then the implicit "help" command
// shows up.
names := jujuc.CommandNames()
cmds := make([]cmd.Command, 0, len(names))
longest := 0
for _, name := range names {
if c, err := jujuc.NewCommand(hookctx, name); err == nil {
if len(name) > longest {
longest = len(name)
}
cmds = append(cmds, c)
}
}
for _, c := range cmds {
info := c.Info()
fmt.Fprintf(ctx.Stdout, "%-*s %s\n", longest, info.Name, info.Purpose)
}
} else {
c, err := jujuc.NewCommand(hookctx, c.tool)
if err != nil {
return err
}
info := c.Info()
f := gnuflag.NewFlagSet(info.Name, gnuflag.ContinueOnError)
c.SetFlags(f)
ctx.Stdout.Write(info.Help(f))
}
return nil
}
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 (= %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.GetHookContext(c, relid, "")
com, err := jujuc.NewCommand(hctx, "relation-list")
c.Assert(err, gc.IsNil)
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 *RelationListSuite) TestRelationList(c *gc.C) {
for i, t := range relationListTests {
c.Logf("test %d: %s", i, t.summary)
hctx := s.GetHookContext(c, t.relid, "")
setMembers(hctx.rels[0], t.members0)
setMembers(hctx.rels[1], t.members1)
com, err := jujuc.NewCommand(hctx, "relation-list")
c.Assert(err, gc.IsNil)
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 *ConfigGetSuite) TestAllPlusKey(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, "config-get")
c.Assert(err, gc.IsNil)
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 *PortsSuite) TestHelp(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
open, err := jujuc.NewCommand(hctx, "open-port")
c.Assert(err, gc.IsNil)
flags := testing.NewFlagSet()
c.Assert(string(open.Info().Help(flags)), gc.Equals, `
usage: open-port <port>[/<protocol>]
purpose: register a port to open
The port will only be open while the service is exposed.
`[1:])
close, err := jujuc.NewCommand(hctx, "close-port")
c.Assert(err, gc.IsNil)
c.Assert(string(close.Info().Help(flags)), gc.Equals, `
usage: close-port <port>[/<protocol>]
purpose: ensure a port is always closed
`[1:])
}
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, name)
c.Assert(err, gc.IsNil)
err = testing.InitCommand(com, t.args)
c.Assert(err, gc.ErrorMatches, t.err)
}
}
}
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, "config-get")
c.Assert(err, gc.IsNil)
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 *RelationGetSuite) TestOutputPath(c *gc.C) {
hctx := s.GetHookContext(c, 1, "m/0")
com, err := jujuc.NewCommand(hctx, "relation-get")
c.Assert(err, gc.IsNil)
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, gc.IsNil)
c.Assert(string(content), gc.Equals, "pew\npew\n\n")
}
func (s *PortsSuite) TestOpenCloseDeprecation(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
for _, t := range portsFormatDeprectaionTests {
name := t.cmd[0]
com, err := jujuc.NewCommand(hctx, name)
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, t.cmd[1:])
c.Assert(code, gc.Equals, 0)
c.Assert(testing.Stdout(ctx), gc.Equals, "")
c.Assert(testing.Stderr(ctx), gc.Equals, "--format flag deprecated for command \""+name+"\"")
}
}
func (s *PortsSuite) TestOpenClose(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
for _, t := range portsTests {
com, err := jujuc.NewCommand(hctx, t.cmd[0])
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, t.cmd[1:])
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
c.Assert(hctx.ports, gc.DeepEquals, t.expect)
}
}
func (s *NewCommandSuite) TestNewCommand(c *gc.C) {
ctx := s.GetHookContext(c, 0, "")
for _, t := range newCommandTests {
com, err := jujuc.NewCommand(ctx, t.name)
if t.err == "" {
// At this level, just check basic sanity; commands are tested in
// more detail elsewhere.
c.Assert(err, gc.IsNil)
c.Assert(com.Info().Name, gc.Equals, t.name)
} else {
c.Assert(com, gc.IsNil)
c.Assert(err, gc.ErrorMatches, t.err)
}
}
}
func (s *RelationGetSuite) TestHelp(c *gc.C) {
for i, t := range relationGetHelpTests {
c.Logf("test %d", i)
hctx := s.GetHookContext(c, t.relid, t.unit)
com, err := jujuc.NewCommand(hctx, "relation-get")
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
unitHelp := ""
if t.unit != "" {
unitHelp = fmt.Sprintf("Current default unit id is %q.\n", t.unit)
}
expect := fmt.Sprintf(helpTemplate, t.usage, t.rel, unitHelp)
c.Assert(bufferString(ctx.Stdout), gc.Equals, expect)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
}
func (s *ConfigGetSuite) TestOutputFormatAll(c *gc.C) {
for i, t := range configGetAllTests {
c.Logf("test %d: %#v", i, t.args)
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, "config-get")
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, t.args)
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
out := map[string]interface{}{}
switch t.format {
case formatYaml:
c.Assert(goyaml.Unmarshal(bufferBytes(ctx.Stdout), &out), gc.IsNil)
case formatJson:
c.Assert(json.Unmarshal(bufferBytes(ctx.Stdout), &out), gc.IsNil)
}
c.Assert(out, gc.DeepEquals, t.out)
}
}
func assertLogs(c *gc.C, ctx jujuc.Context, writer *loggo.TestWriter, unitname, badge string) {
msg1 := "the chickens"
msg2 := "are 110% AWESOME"
com, err := jujuc.NewCommand(ctx, "juju-log")
c.Assert(err, gc.IsNil)
for _, t := range []struct {
args []string
level loggo.Level
}{
{
level: loggo.INFO,
}, {
args: []string{"--debug"},
level: loggo.DEBUG,
}, {
args: []string{"--log-level", "TRACE"},
level: loggo.TRACE,
}, {
args: []string{"--log-level", "info"},
level: loggo.INFO,
}, {
args: []string{"--log-level", "WaRnInG"},
level: loggo.WARNING,
}, {
args: []string{"--log-level", "error"},
level: loggo.ERROR,
},
} {
writer.Clear()
c.Assert(err, gc.IsNil)
args := append(t.args, msg1, msg2)
code := cmd.Main(com, &cmd.Context{}, args)
c.Assert(code, gc.Equals, 0)
c.Assert(writer.Log, gc.HasLen, 1)
c.Assert(writer.Log[0].Level, gc.Equals, t.level)
c.Assert(writer.Log[0].Module, gc.Equals, fmt.Sprintf("unit.%s.juju-log", unitname))
c.Assert(writer.Log[0].Message, gc.Equals, fmt.Sprintf("%s%s %s", badge, msg1, msg2))
}
}
func (s *ConfigGetSuite) TestHelp(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, "config-get")
c.Assert(err, gc.IsNil)
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>]
purpose: print service configuration
options:
-a, --all (= false)
print all keys
--format (= smart)
specify output format (json|smart|yaml)
-o, --output (= "")
specify an output file
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 *UnitGetSuite) createCommand(c *gc.C) cmd.Command {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, "unit-get")
c.Assert(err, gc.IsNil)
return com
}
func newJujuLogCommand(c *gc.C) cmd.Command {
ctx := &Context{}
com, err := jujuc.NewCommand(ctx, "juju-log")
c.Assert(err, gc.IsNil)
return com
}
func (s *ConfigGetSuite) TestUnknownArg(c *gc.C) {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, "config-get")
c.Assert(err, gc.IsNil)
testing.TestInit(c, com, []string{"multiple", "keys"}, `unrecognized args: \["keys"\]`)
}
