func (s *CmdSuite) TestMainSuccess(c *gc.C) {
ctx := testing.Context(c)
result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{"--option", "success!"})
c.Assert(result, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, "success!\n")
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *CmdSuite) TestUnknownOutputFormat(c *gc.C) {
ctx := testing.Context(c)
result := cmd.Main(&OutputCommand{}, ctx, []string{"--format", "cuneiform"})
c.Check(result, gc.Equals, 2)
c.Check(bufferString(ctx.Stdout), gc.Equals, "")
c.Check(bufferString(ctx.Stderr), gc.Matches, ".*: unknown format \"cuneiform\"\n")
}
func (s *CmdSuite) TestMainRunSilentError(c *gc.C) {
ctx := testing.Context(c)
result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{"--option", "silent-error"})
c.Assert(result, gc.Equals, 1)
c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *SuperCommandSuite) TestDescription(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest", Purpose: "blow up the death star"})
jc.Register(&TestCommand{Name: "blah"})
ctx := testing.Context(c)
code := cmd.Main(jc, ctx, []string{"blah", "--description"})
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, "blow up the death star\n")
}
func (s *SuperCommandSuite) TestHelpWithPrefix(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest", UsagePrefix: "juju"})
jc.Register(&TestCommand{Name: "blah"})
ctx := testing.Context(c)
code := cmd.Main(jc, ctx, []string{"blah", "--help"})
c.Assert(code, gc.Equals, 0)
stripped := strings.Replace(bufferString(ctx.Stdout), "\n", "", -1)
c.Assert(stripped, gc.Matches, ".*usage: juju jujutest blah.*blah-doc.*")
}
func (s *CmdSuite) TestStdin(c *gc.C) {
const phrase = "Do you, Juju?"
ctx := testing.Context(c)
ctx.Stdin = bytes.NewBuffer([]byte(phrase))
result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{"--option", "echo"})
c.Assert(result, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, phrase)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *CmdSuite) TestMainHelp(c *gc.C) {
for _, arg := range []string{"-h", "--help"} {
ctx := testing.Context(c)
result := cmd.Main(&TestCommand{Name: "verb"}, ctx, []string{arg})
c.Assert(result, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, fullHelp)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
}
func (s *CmdSuite) TestMainInitError(c *gc.C) {
for _, t := range initErrorTests {
ctx := testing.Context(c)
result := cmd.Main(t.c, ctx, []string{"--unknown"})
c.Assert(result, gc.Equals, 2)
c.Assert(bufferString(ctx.Stdout), gc.Equals, "")
expected := "error: flag provided but not defined: --unknown\n"
c.Assert(bufferString(ctx.Stderr), gc.Equals, expected)
}
}
func (s *SuperCommandSuite) TestMissingCallbackErrors(c *gc.C) {
callback := func(ctx *cmd.Context, subcommand string, args []string) error {
return fmt.Errorf("command not found %q", subcommand)
}
ctx := testing.Context(c)
code := cmd.Main(NewSuperWithCallback(callback), ctx, []string{"foo"})
c.Assert(code, gc.Equals, 1)
c.Assert(testing.Stdout(ctx), gc.Equals, "")
c.Assert(testing.Stderr(ctx), gc.Equals, "ERROR command not found \"foo\"\n")
}
func (s *SuperCommandSuite) TestVersionFlag(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujutest",
Purpose: "to be purposeful",
Doc: "doc\nblah\ndoc",
})
testVersionFlagCommand := &testVersionFlagCommand{}
jc.Register(&cmd.VersionCommand{})
jc.Register(testVersionFlagCommand)
var stdout, stderr bytes.Buffer
ctx := &cmd.Context{
Stdout: &stdout,
Stderr: &stderr,
}
// baseline: juju version
code := cmd.Main(jc, ctx, []string{"version"})
c.Check(code, gc.Equals, 0)
baselineStderr := stderr.String()
baselineStdout := stdout.String()
stderr.Reset()
stdout.Reset()
// juju --version output should match that of juju version.
code = cmd.Main(jc, ctx, []string{"--version"})
c.Check(code, gc.Equals, 0)
c.Assert(stderr.String(), gc.Equals, baselineStderr)
c.Assert(stdout.String(), gc.Equals, baselineStdout)
stderr.Reset()
stdout.Reset()
// juju test --version should update testVersionFlagCommand.version,
// and there should be no output. The --version flag on the 'test'
// subcommand has a different type to the "juju --version" flag.
code = cmd.Main(jc, ctx, []string{"test", "--version=abc.123"})
c.Check(code, gc.Equals, 0)
c.Assert(stderr.String(), gc.Equals, "")
c.Assert(stdout.String(), gc.Equals, "")
c.Assert(testVersionFlagCommand.version, gc.Equals, "abc.123")
}
func (s *SuperCommandSuite) TestMissingCallbackContextWiredIn(c *gc.C) {
callback := func(ctx *cmd.Context, subcommand string, args []string) error {
fmt.Fprintf(ctx.Stdout, "this is std out")
fmt.Fprintf(ctx.Stderr, "this is std err")
return nil
}
ctx := testing.Context(c)
code := cmd.Main(NewSuperWithCallback(callback), ctx, []string{"foo", "bar", "baz", "--debug"})
c.Assert(code, gc.Equals, 0)
c.Assert(testing.Stdout(ctx), gc.Equals, "this is std out")
c.Assert(testing.Stderr(ctx), gc.Equals, "this is std err")
}
func (s *CmdSuite) TestOutputFormat(c *gc.C) {
for format, tests := range outputTests {
c.Logf("format %s", format)
var args []string
if format != "" {
args = []string{"--format", format}
}
for i, t := range tests {
c.Logf(" test %d", i)
ctx := testing.Context(c)
result := cmd.Main(&OutputCommand{value: t.value}, ctx, args)
c.Check(result, gc.Equals, 0)
c.Check(bufferString(ctx.Stdout), gc.Equals, t.output)
c.Check(bufferString(ctx.Stderr), gc.Equals, "")
}
}
}
func (s *SuperCommandSuite) TestMissingCallback(c *gc.C) {
var calledName string
var calledArgs []string
callback := func(ctx *cmd.Context, subcommand string, args []string) error {
calledName = subcommand
calledArgs = args
return nil
}
code := cmd.Main(
NewSuperWithCallback(callback),
testing.Context(c),
[]string{"foo", "bar", "baz", "--debug"})
c.Assert(code, gc.Equals, 0)
c.Assert(calledName, gc.Equals, "foo")
c.Assert(calledArgs, gc.DeepEquals, []string{"bar", "baz", "--debug"})
}
func (s *SuperCommandSuite) TestSupercommandAliases(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujutest",
UsagePrefix: "juju",
})
sub := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jubar",
UsagePrefix: "juju jujutest",
Aliases: []string{"jubaz", "jubing"},
})
info := sub.Info()
c.Check(info.Aliases, gc.DeepEquals, []string{"jubaz", "jubing"})
jc.Register(sub)
for _, name := range []string{"jubar", "jubaz", "jubing"} {
c.Logf("testing command name %q", name)
ctx := testing.Context(c)
code := cmd.Main(jc, ctx, []string{name, "--help"})
c.Assert(code, gc.Equals, 0)
stripped := strings.Replace(bufferString(ctx.Stdout), "\n", "", -1)
c.Assert(stripped, gc.Matches, ".*usage: juju jujutest jubar.*aliases: jubaz, jubing")
}
}
func (s *SuperCommandSuite) TestLogging(c *gc.C) {
s.PatchValue(&version.Current, version.MustParseBinary("1.2.3.4-plan9-mips"))
s.PatchValue(&version.Compiler, "llgo")
loggingTests := []struct {
usagePrefix, name string
pattern string
}{
{"juju", "juju", `^.* running juju \[1.2.3.4-plan9-mips llgo\]
.* ERROR .* BAM!
`},
{"something", "else", `^.* running something else \[1.2.3.4-plan9-mips llgo\]
.* ERROR .* BAM!
`},
{"", "juju", `^.* running juju \[1.2.3.4-plan9-mips llgo\]
.* ERROR .* BAM!
`},
{"", "myapp", `^.* running myapp \[1.2.3.4-plan9-mips llgo\]
.* ERROR .* BAM!
`},
{"same", "same", `^.* running same \[1.2.3.4-plan9-mips llgo\]
.* ERROR .* BAM!
`},
}
for _, test := range loggingTests {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{
UsagePrefix: test.usagePrefix,
Name: test.name,
Log: &cmd.Log{},
})
jc.Register(&TestCommand{Name: "blah"})
ctx := testing.Context(c)
code := cmd.Main(jc, ctx, []string{"blah", "--option", "error", "--debug"})
c.Assert(code, gc.Equals, 1)
c.Assert(bufferString(ctx.Stderr), gc.Matches, test.pattern)
}
}
// Py juju allowed both --format json and --format=json. This test verifies that juju is
// being built against a version of the gnuflag library (rev 14 or above) that supports
// this argument format.
// LP #1059921
func (s *CmdSuite) TestFormatAlternativeSyntax(c *gc.C) {
ctx := testing.Context(c)
result := cmd.Main(&OutputCommand{}, ctx, []string{"--format=json"})
c.Assert(result, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, "null\n")
}