func (s *CmdSuite) TestMainSuccess(c *gc.C) {
ctx := cmdtesting.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 *removeSuite) TestError(c *gc.C) {
s.setFailure("failed!")
ctx := cmdtesting.Context(c)
err := s.subcommand.Run(ctx)
c.Check(errors.Cause(err), gc.ErrorMatches, "failed!")
}
func (s *CmdSuite) TestMainRunSilentError(c *gc.C) {
ctx := cmdtesting.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 *HelpCommandSuite) TestRegisterSuperAliasHelp(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujutest",
})
sub := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "bar",
UsagePrefix: "jujutest",
Purpose: "bar functions",
})
jc.Register(sub)
sub.Register(&simple{name: "foo"})
jc.RegisterSuperAlias("bar-foo", "bar", "foo", nil)
for _, test := range []struct {
args []string
}{
{
args: []string{"bar", "foo", "--help"},
}, {
args: []string{"bar", "help", "foo"},
}, {
args: []string{"help", "bar-foo"},
}, {
args: []string{"bar-foo", "--help"},
},
} {
c.Logf("args: %v", test.args)
ctx := cmdtesting.Context(c)
code := cmd.Main(jc, ctx, test.args)
c.Check(code, gc.Equals, 0)
help := "Usage: jujutest bar foo\n\nSummary:\nto be simple\n"
c.Check(cmdtesting.Stdout(ctx), gc.Equals, help)
}
}
func (s *SuperCommandSuite) TestNotifyRun(c *gc.C) {
notifyTests := []struct {
usagePrefix string
name string
expectName string
}{
{"juju", "juju", "juju"},
{"something", "else", "something else"},
{"", "juju", "juju"},
{"", "myapp", "myapp"},
}
for i, test := range notifyTests {
c.Logf("test %d. %q %q", i, test.usagePrefix, test.name)
notifyName := ""
sc := cmd.NewSuperCommand(cmd.SuperCommandParams{
UsagePrefix: test.usagePrefix,
Name: test.name,
NotifyRun: func(name string) {
notifyName = name
},
})
sc.Register(&TestCommand{Name: "blah"})
ctx := cmdtesting.Context(c)
code := cmd.Main(sc, ctx, []string{"blah", "--option", "error"})
c.Assert(bufferString(ctx.Stderr), gc.Matches, "")
c.Assert(code, gc.Equals, 1)
c.Assert(notifyName, gc.Equals, test.expectName)
}
}
func (s *uploadSuite) TestFileMissing(c *gc.C) {
s.setSuccess()
ctx := cmdtesting.Context(c)
err := s.subcommand.Run(ctx)
c.Check(os.IsNotExist(errors.Cause(err)), jc.IsTrue)
}
func (s *CmdSuite) TestUnknownOutputFormat(c *gc.C) {
ctx := cmdtesting.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 *SuperCommandSuite) TestDescription(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest", Purpose: "blow up the death star"})
jc.Register(&TestCommand{Name: "blah"})
ctx := cmdtesting.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 *LogSuite) TestStderr(c *gc.C) {
l := &cmd.Log{ShowLog: true, Config: "<root>=INFO"}
ctx := cmdtesting.Context(c)
err := l.Start(ctx)
c.Assert(err, gc.IsNil)
logger.Infof("hello")
c.Assert(cmdtesting.Stderr(ctx), gc.Matches, `^.* INFO .* hello\n`)
}
func (s *CmdSuite) TestContextSetenv(c *gc.C) {
ctx := cmdtesting.Context(c)
before := ctx.Env["foo"]
ctx.Setenv("foo", "bar")
after := ctx.Env["foo"]
c.Check(before, gc.Equals, "")
c.Check(after, gc.Equals, "bar")
}
func (s *SuperCommandSuite) TestHelpWithPrefix(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest", UsagePrefix: "juju"})
jc.Register(&TestCommand{Name: "blah"})
ctx := cmdtesting.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 *HelpCommandSuite) TestAlias(c *gc.C) {
super := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "super"})
super.Register(&TestCommand{Name: "blah", Aliases: []string{"alias"}})
ctx := cmdtesting.Context(c)
code := cmd.Main(super, ctx, []string{"help", "alias"})
c.Assert(code, gc.Equals, 0)
stripped := strings.Replace(bufferString(ctx.Stdout), "\n", "", -1)
c.Assert(stripped, gc.Matches, "Usage: super blah .*Aliases: alias")
}
func (s *infoSuite) TestOkay(c *gc.C) {
s.setSuccess()
ctx := cmdtesting.Context(c)
err := s.subcommand.Run(ctx)
c.Check(err, jc.ErrorIsNil)
out := MetaResultString
s.checkStd(c, ctx, out, "")
}
func (s *listSuite) TestOkay(c *gc.C) {
s.setSuccess()
ctx := cmdtesting.Context(c)
ctx, err := testing.RunCommand(c, s.subcommand, []string{"--verbose"}...)
c.Assert(err, jc.ErrorIsNil)
out := MetaResultString
s.checkStd(c, ctx, out, "")
}
func (s *CmdSuite) TestStdin(c *gc.C) {
const phrase = "Do you, Juju?"
ctx := cmdtesting.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 := cmdtesting.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 *LogSuite) TestShowLogSetsLogLevel(c *gc.C) {
l := &cmd.Log{ShowLog: true}
ctx := cmdtesting.Context(c)
err := l.Start(ctx)
c.Assert(err, gc.IsNil)
c.Assert(loggo.GetLogger("").LogLevel(), gc.Equals, loggo.INFO)
c.Assert(cmdtesting.Stderr(ctx), gc.Equals, "")
c.Assert(cmdtesting.Stdout(ctx), gc.Equals, "")
}
func (s *createSuite) TestDefaultDownload(c *gc.C) {
s.setDownload()
ctx := cmdtesting.Context(c)
err := s.subcommand.Run(ctx)
c.Assert(err, jc.ErrorIsNil)
s.checkDownload(c, ctx)
c.Check(s.filename, gc.Not(gc.Equals), "")
c.Check(s.subcommand.Filename, gc.Equals, backups.NotSet)
}
func (s *CmdSuite) TestContextGetenv(c *gc.C) {
ctx := cmdtesting.Context(c)
ctx.Env = make(map[string]string)
before := ctx.Getenv("foo")
ctx.Env["foo"] = "bar"
after := ctx.Getenv("foo")
c.Check(before, gc.Equals, "")
c.Check(after, gc.Equals, "bar")
}
func (s *CmdSuite) TestMainInitError(c *gc.C) {
for _, t := range initErrorTests {
ctx := cmdtesting.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 *downloadSuite) TestOkay(c *gc.C) {
s.setSuccess()
ctx := cmdtesting.Context(c)
err := s.subcommand.Run(ctx)
c.Check(err, jc.ErrorIsNil)
s.filename = "juju-backup-" + s.metaresult.ID + ".tar.gz"
s.checkStd(c, ctx, s.filename+"\n", "")
s.checkArchive(c)
}
func (s *removeSuite) TestOkay(c *gc.C) {
s.setSuccess()
s.subcommand.ID = "spam"
ctx := cmdtesting.Context(c)
err := s.subcommand.Run(ctx)
c.Check(err, jc.ErrorIsNil)
out := "successfully removed: spam\n"
s.checkStd(c, ctx, out, "")
}
func (s *SuperCommandSuite) TestRegisterDeprecated(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujutest",
})
// Test that calling with a nil command will not panic
jc.RegisterDeprecated(nil, nil)
jc.RegisterDeprecated(&simpleAlias{simple{name: "test-non-dep"}}, nil)
jc.RegisterDeprecated(&simpleAlias{simple{name: "test-dep"}}, deprecate{replacement: "test-dep-new"})
jc.RegisterDeprecated(&simpleAlias{simple{name: "test-ob"}}, deprecate{obsolete: true})
badCall := func() {
jc.RegisterDeprecated(&simpleAlias{simple{name: "test-dep"}}, deprecate{replacement: "test-dep-new"})
}
c.Assert(badCall, gc.PanicMatches, `command already registered: "test-dep"`)
for _, test := range []struct {
args []string
stdout string
stderr string
code int
}{
{
args: []string{"test-non-dep", "arg"},
stdout: "test-non-dep arg\n",
}, {
args: []string{"test-non-dep-alias", "arg"},
stdout: "test-non-dep arg\n",
}, {
args: []string{"test-dep", "arg"},
stdout: "test-dep arg\n",
stderr: "WARNING: \"test-dep\" is deprecated, please use \"test-dep-new\"\n",
}, {
args: []string{"test-dep-alias", "arg"},
stdout: "test-dep arg\n",
stderr: "WARNING: \"test-dep-alias\" is deprecated, please use \"test-dep-new\"\n",
}, {
args: []string{"test-ob", "arg"},
stderr: "error: unrecognized command: jujutest test-ob\n",
code: 2,
}, {
args: []string{"test-ob-alias", "arg"},
stderr: "error: unrecognized command: jujutest test-ob-alias\n",
code: 2,
},
} {
ctx := cmdtesting.Context(c)
code := cmd.Main(jc, ctx, test.args)
c.Check(code, gc.Equals, test.code)
c.Check(cmdtesting.Stderr(ctx), gc.Equals, test.stderr)
c.Check(cmdtesting.Stdout(ctx), gc.Equals, test.stdout)
}
}
func (s *LogSuite) TestOutputDebugForcesQuiet(c *gc.C) {
l := &cmd.Log{Verbose: true, Debug: true}
ctx := cmdtesting.Context(c)
err := l.Start(ctx)
c.Assert(err, gc.IsNil)
ctx.Infof("Writing info output")
ctx.Verbosef("Writing verbose output")
c.Assert(cmdtesting.Stderr(ctx), gc.Matches, `^.*INFO .* Writing info output\n.*INFO .*Writing verbose output\n.*`)
}
func (s *LogSuite) TestOutputQuiet(c *gc.C) {
l := &cmd.Log{Quiet: true}
ctx := cmdtesting.Context(c)
err := l.Start(ctx)
c.Assert(err, gc.IsNil)
ctx.Infof("Writing info output")
ctx.Verbosef("Writing verbose output")
c.Assert(cmdtesting.Stderr(ctx), gc.Equals, "")
}
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 := cmdtesting.Context(c)
code := cmd.Main(NewSuperWithCallback(callback), ctx, []string{"foo"})
c.Assert(code, gc.Equals, 1)
c.Assert(cmdtesting.Stdout(ctx), gc.Equals, "")
c.Assert(cmdtesting.Stderr(ctx), gc.Equals, "ERROR command not found \"foo\"\n")
}
func (s *createSuite) TestFilename(c *gc.C) {
client := s.setDownload()
s.subcommand.Filename = "backup.tgz"
ctx := cmdtesting.Context(c)
err := s.subcommand.Run(ctx)
c.Assert(err, jc.ErrorIsNil)
client.Check(c, s.metaresult.ID, "", "Create", "Download")
s.checkDownload(c, ctx)
c.Check(s.subcommand.Filename, gc.Equals, s.filename)
}
func (s *downloadSuite) TestFilename(c *gc.C) {
s.setSuccess()
s.subcommand.Filename = "backup.tar.gz"
ctx := cmdtesting.Context(c)
err := s.subcommand.Run(ctx)
c.Check(err, jc.ErrorIsNil)
s.filename = "backup.tar.gz"
s.checkStd(c, ctx, s.filename+"\n", "")
s.checkArchive(c)
}
func (s *LogSuite) TestErrorAndWarningLoggingToStderr(c *gc.C) {
// Error and warning go to stderr even with ShowLog=false
l := &cmd.Log{Config: "<root>=INFO", ShowLog: false}
ctx := cmdtesting.Context(c)
err := l.Start(ctx)
c.Assert(err, gc.IsNil)
logger.Warningf("a warning")
logger.Errorf("an error")
logger.Infof("an info")
c.Assert(cmdtesting.Stderr(ctx), gc.Matches, `^.*WARNING a warning\n.*ERROR an error\n.*`)
c.Assert(cmdtesting.Stdout(ctx), gc.Equals, "")
}
func (s *LogSuite) TestLoggingToFileAndStderr(c *gc.C) {
l := &cmd.Log{Path: "foo.log", Config: "<root>=INFO", ShowLog: true}
ctx := cmdtesting.Context(c)
err := l.Start(ctx)
c.Assert(err, gc.IsNil)
logger.Infof("hello")
content, err := ioutil.ReadFile(filepath.Join(ctx.Dir, "foo.log"))
c.Assert(err, gc.IsNil)
c.Assert(string(content), gc.Matches, `^.* INFO .* hello\n`)
c.Assert(cmdtesting.Stderr(ctx), gc.Matches, `^.* INFO .* hello\n`)
c.Assert(cmdtesting.Stdout(ctx), gc.Equals, "")
}