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 *RelationSetSuite) TestRun(c *gc.C) {
hctx := s.GetHookContext(c, 0, "")
for i, t := range relationSetRunTests {
c.Logf("test %d", i)
pristine := Settings{"pristine": "untouched"}
hctx.rels[0].units["u/0"] = pristine
basic := Settings{"base": "value"}
hctx.rels[1].units["u/0"] = basic
// Run the command.
com, err := jujuc.NewCommand(hctx, "relation-set")
c.Assert(err, gc.IsNil)
rset := com.(*jujuc.RelationSetCommand)
rset.RelationId = 1
rset.Settings = t.change
ctx := testing.Context(c)
err = com.Run(ctx)
c.Assert(err, gc.IsNil)
// Check changes.
c.Assert(hctx.rels[0].units["u/0"], gc.DeepEquals, pristine)
c.Assert(hctx.rels[1].units["u/0"], gc.DeepEquals, t.expect)
}
}
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 *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 *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.GetHookContext(c, relid, "")
com, err := jujuc.NewCommand(hctx, "relation-ids")
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 *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 *RelationSetSuite) TestRunDeprecationWarning(c *gc.C) {
hctx := s.GetHookContext(c, 0, "")
com, _ := jujuc.NewCommand(hctx, "relation-set")
// The rel= is needed to make this a valid command.
ctx, err := testing.RunCommand(c, com, []string{"--format", "foo", "rel="})
c.Assert(err, gc.IsNil)
c.Assert(testing.Stdout(ctx), gc.Equals, "")
c.Assert(testing.Stderr(ctx), gc.Equals, "--format flag deprecated for command \"relation-set\"")
}
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 (u *Uniter) startJujucServer(context *HookContext) (*jujuc.Server, string, error) {
// Prepare server.
getCmd := func(ctxId, cmdName string) (cmd.Command, error) {
// TODO: switch to long-running server with single context;
// use nonce in place of context id.
if ctxId != context.id {
return nil, fmt.Errorf("expected context id %q, got %q", context.id, ctxId)
}
return jujuc.NewCommand(context, cmdName)
}
socketPath := filepath.Join(u.baseDir, "agent.socket")
// Use abstract namespace so we don't get stale socket files.
socketPath = "@" + socketPath
srv, err := jujuc.NewServer(getCmd, socketPath)
if err != nil {
return nil, "", err
}
go srv.Run()
return srv, socketPath, nil
}
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 (s *RelationSetSuite) TestInit(c *gc.C) {
for i, t := range relationSetInitTests {
c.Logf("test %d", i)
hctx := s.GetHookContext(c, t.ctxrelid, "")
com, err := jujuc.NewCommand(hctx, "relation-set")
c.Assert(err, gc.IsNil)
err = testing.InitCommand(com, t.args)
if t.err == "" {
c.Assert(err, gc.IsNil)
rset := com.(*jujuc.RelationSetCommand)
c.Assert(rset.RelationId, gc.Equals, t.relid)
settings := t.settings
if settings == nil {
settings = map[string]string{}
}
c.Assert(rset.Settings, gc.DeepEquals, settings)
} else {
c.Assert(err, gc.ErrorMatches, t.err)
}
}
}
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 *RelationIdsSuite) TestRelationIds(c *gc.C) {
for i, t := range relationIdsTests {
c.Logf("test %d: %s", i, t.summary)
hctx := s.GetHookContext(c, t.relid, "")
com, err := jujuc.NewCommand(hctx, "relation-ids")
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, t.args)
c.Assert(code, gc.Equals, t.code)
if code == 0 {
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
expect := t.out
if expect != "" {
expect += "\n"
}
c.Assert(bufferString(ctx.Stdout), gc.Equals, expect)
} else {
c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
c.Assert(bufferString(ctx.Stderr), gc.Matches, t.out)
}
}
}
func (s *RelationSetSuite) TestHelp(c *gc.C) {
for i, t := range helpTests {
c.Logf("test %d", i)
hctx := s.GetHookContext(c, t.relid, "")
com, err := jujuc.NewCommand(hctx, "relation-set")
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, fmt.Sprintf(`
usage: relation-set [options] key=value [key=value ...]
purpose: set relation settings
options:
--format (= "")
deprecated format flag
-r (= %s)
specify a relation by id
`[1:], t.expect))
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
}
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 newJujuLogCommand(c *gc.C) cmd.Command {
ctx := &Context{}
com, err := jujuc.NewCommand(ctx, "juju-log")
c.Assert(err, gc.IsNil)
return com
}
func (s *OwnerGetSuite) createCommand(c *gc.C) cmd.Command {
hctx := s.GetHookContext(c, -1, "")
com, err := jujuc.NewCommand(hctx, "owner-get")
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"\]`)
}