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 *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 *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 *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, "")
}
func (s *LogSuite) TestAbsPathLog(c *gc.C) {
path := filepath.Join(c.MkDir(), "foo.log")
l := &cmd.Log{Path: path, 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.Equals, "")
content, err := ioutil.ReadFile(path)
c.Assert(err, gc.IsNil)
c.Assert(string(content), gc.Matches, `^.* INFO .* hello\n`)
}
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 := cmdtesting.Context(c)
code := cmd.Main(NewSuperWithCallback(callback), ctx, []string{"foo", "bar", "baz", "--debug"})
c.Assert(code, gc.Equals, 0)
c.Assert(cmdtesting.Stdout(ctx), gc.Equals, "this is std out")
c.Assert(cmdtesting.Stderr(ctx), gc.Equals, "this is std err")
}
func (s *LogSuite) TestOutputDefaultLogsVerbose(c *gc.C) {
l := &cmd.Log{Path: "foo.log", Config: "<root>=INFO"}
ctx := cmdtesting.Context(c)
err := l.Start(ctx)
c.Assert(err, gc.IsNil)
ctx.Infof("Writing info output")
ctx.Verbosef("Writing verbose output")
content, err := ioutil.ReadFile(filepath.Join(ctx.Dir, "foo.log"))
c.Assert(err, gc.IsNil)
c.Assert(cmdtesting.Stderr(ctx), gc.Equals, "Writing info output\n")
c.Assert(string(content), gc.Matches, `^.*INFO .*Writing verbose output\n.*`)
}
func (s *SuperCommandSuite) TestRegisterAlias(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujutest",
})
jc.Register(&simple{name: "test"})
jc.RegisterAlias("foo", "test", nil)
jc.RegisterAlias("bar", "test", deprecate{replacement: "test"})
jc.RegisterAlias("baz", "test", deprecate{obsolete: true})
c.Assert(
func() { jc.RegisterAlias("omg", "unknown", nil) },
gc.PanicMatches, `"unknown" not found when registering alias`)
info := jc.Info()
// NOTE: deprecated `bar` not shown in commands.
c.Assert(info.Doc, gc.Equals, `commands:
foo - alias for 'test'
help - show help on a command or other topic
test - to be simple`)
for _, test := range []struct {
name string
stdout string
stderr string
code int
}{
{
name: "test",
stdout: "test arg\n",
}, {
name: "foo",
stdout: "test arg\n",
}, {
name: "bar",
stdout: "test arg\n",
stderr: "WARNING: \"bar\" is deprecated, please use \"test\"\n",
}, {
name: "baz",
stderr: "error: unrecognized command: jujutest baz\n",
code: 2,
},
} {
ctx := cmdtesting.Context(c)
code := cmd.Main(jc, ctx, []string{test.name, "arg"})
c.Check(code, gc.Equals, test.code)
c.Check(cmdtesting.Stdout(ctx), gc.Equals, test.stdout)
c.Check(cmdtesting.Stderr(ctx), gc.Equals, test.stderr)
}
}
func (s *SuperCommandSuite) TestRegisterSuperAlias(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujutest",
})
jc.Register(&simple{name: "test"})
sub := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "bar",
UsagePrefix: "jujutest",
Purpose: "bar functions",
})
jc.Register(sub)
sub.Register(&simple{name: "foo"})
c.Assert(
func() { jc.RegisterSuperAlias("bar-foo", "unknown", "foo", nil) },
gc.PanicMatches, `"unknown" not found when registering alias`)
c.Assert(
func() { jc.RegisterSuperAlias("bar-foo", "test", "foo", nil) },
gc.PanicMatches, `"test" is not a SuperCommand`)
c.Assert(
func() { jc.RegisterSuperAlias("bar-foo", "bar", "unknown", nil) },
gc.PanicMatches, `"unknown" not found as a command in "bar"`)
jc.RegisterSuperAlias("bar-foo", "bar", "foo", nil)
jc.RegisterSuperAlias("bar-dep", "bar", "foo", deprecate{replacement: "bar foo"})
jc.RegisterSuperAlias("bar-ob", "bar", "foo", deprecate{obsolete: true})
info := jc.Info()
// NOTE: deprecated `bar` not shown in commands.
c.Assert(info.Doc, gc.Equals, `commands:
bar - bar functions
bar-foo - alias for 'bar foo'
help - show help on a command or other topic
test - to be simple`)
for _, test := range []struct {
args []string
stdout string
stderr string
code int
}{
{
args: []string{"bar", "foo", "arg"},
stdout: "foo arg\n",
}, {
args: []string{"bar-foo", "arg"},
stdout: "foo arg\n",
}, {
args: []string{"bar-dep", "arg"},
stdout: "foo arg\n",
stderr: "WARNING: \"bar-dep\" is deprecated, please use \"bar foo\"\n",
}, {
args: []string{"bar-ob", "arg"},
stderr: "error: unrecognized command: jujutest bar-ob\n",
code: 2,
},
} {
ctx := cmdtesting.Context(c)
code := cmd.Main(jc, ctx, test.args)
c.Check(code, gc.Equals, test.code)
c.Check(cmdtesting.Stdout(ctx), gc.Equals, test.stdout)
c.Check(cmdtesting.Stderr(ctx), gc.Equals, test.stderr)
}
}