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 *HelpCommandSuite) TestMultipleSuperCommands(c *gc.C) {
level1 := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "level1"})
level2 := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "level2", UsagePrefix: "level1"})
level1.Register(level2)
level3 := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "level3", UsagePrefix: "level1 level2"})
level2.Register(level3)
level3.Register(&TestCommand{Name: "blah"})
ctx, err := cmdtesting.RunCommand(c, level1, "help", "level2", "level3", "blah")
c.Assert(err, jc.ErrorIsNil)
s.assertStdOutMatches(c, ctx, "Usage: level1 level2 level3 blah.*blah-doc.*")
_, err = cmdtesting.RunCommand(c, level1, "help", "level2", "missing", "blah")
c.Assert(err, gc.ErrorMatches, `subcommand "missing" not found`)
}
// Main registers subcommands for the juju-metadata executable, and hands over control
// to the cmd package. This function is not redundant with main, because it
// provides an entry point for testing with arbitrary command line arguments.
func Main(args []string) {
ctx, err := cmd.DefaultContext()
if err != nil {
fmt.Fprintf(os.Stderr, "error: %v\n", err)
os.Exit(2)
}
if err := juju.InitJujuHome(); err != nil {
fmt.Fprintf(os.Stderr, "error: %s\n", err)
os.Exit(2)
}
metadatacmd := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "metadata",
UsagePrefix: "juju",
Doc: metadataDoc,
Purpose: "tools for generating and validating image and tools metadata",
Log: &cmd.Log{}})
metadatacmd.Register(envcmd.Wrap(&ValidateImageMetadataCommand{}))
metadatacmd.Register(envcmd.Wrap(&ImageMetadataCommand{}))
metadatacmd.Register(envcmd.Wrap(&ToolsMetadataCommand{}))
metadatacmd.Register(envcmd.Wrap(&ValidateToolsMetadataCommand{}))
metadatacmd.Register(&SignMetadataCommand{})
metadatacmd.Register(envcmd.Wrap(&ListImagesCommand{}))
metadatacmd.Register(envcmd.Wrap(&AddImageMetadataCommand{}))
os.Exit(cmd.Main(metadatacmd, ctx, args[1:]))
}
func (s *SuperCommandSuite) TestInfo(c *gc.C) {
commandsDoc := `commands:
flapbabble - flapbabble the juju
flip - flip the juju`
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujutest",
Purpose: "to be purposeful",
Doc: "doc\nblah\ndoc",
})
info := jc.Info()
c.Assert(info.Name, gc.Equals, "jujutest")
c.Assert(info.Purpose, gc.Equals, "to be purposeful")
// info doc starts with the jc.Doc and ends with the help command
c.Assert(info.Doc, gc.Matches, jc.Doc+"(.|\n)*")
c.Assert(info.Doc, gc.Matches, "(.|\n)*"+helpCommandsText)
jc.Register(&TestCommand{Name: "flip"})
jc.Register(&TestCommand{Name: "flapbabble"})
info = jc.Info()
c.Assert(info.Doc, gc.Matches, jc.Doc+"\n\n"+commandsDoc+helpText)
jc.Doc = ""
info = jc.Info()
c.Assert(info.Doc, gc.Matches, commandsDoc+helpText)
}
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 NewSuperWithCallback(callback func(*cmd.Context, string, []string) error) cmd.Command {
return cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "jujutest",
Log: &cmd.Log{},
MissingCallback: callback,
})
}
func (s *SuperCommandSuite) TestDispatch(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest"})
info := jc.Info()
c.Assert(info.Name, gc.Equals, "jujutest")
c.Assert(info.Args, gc.Equals, "<command> ...")
c.Assert(info.Doc, gc.Matches, helpCommandsText)
jc, _, err := initDefenestrate([]string{"discombobulate"})
c.Assert(err, gc.ErrorMatches, "unrecognized command: jujutest discombobulate")
info = jc.Info()
c.Assert(info.Name, gc.Equals, "jujutest")
c.Assert(info.Args, gc.Equals, "<command> ...")
c.Assert(info.Doc, gc.Matches, "commands:\n defenestrate - defenestrate the juju"+helpText)
jc, tc, err := initDefenestrate([]string{"defenestrate"})
c.Assert(err, gc.IsNil)
c.Assert(tc.Option, gc.Equals, "")
info = jc.Info()
c.Assert(info.Name, gc.Equals, "jujutest defenestrate")
c.Assert(info.Args, gc.Equals, "<something>")
c.Assert(info.Doc, gc.Equals, "defenestrate-doc")
_, tc, err = initDefenestrate([]string{"defenestrate", "--option", "firmly"})
c.Assert(err, gc.IsNil)
c.Assert(tc.Option, gc.Equals, "firmly")
_, tc, err = initDefenestrate([]string{"defenestrate", "gibberish"})
c.Assert(err, gc.ErrorMatches, `unrecognized args: \["gibberish"\]`)
// --description must be used on it's own.
_, _, err = initDefenestrate([]string{"--description", "defenestrate"})
c.Assert(err, gc.ErrorMatches, `unrecognized args: \["defenestrate"\]`)
}
func (s *SSHSuite) TestSSHCommand(c *gc.C) {
m := s.makeMachines(3, c, true)
ch := testcharms.Repo.CharmDir("dummy")
curl := charm.MustParseURL(
fmt.Sprintf("local:quantal/%s-%d", ch.Meta().Name, ch.Revision()),
)
info := state.CharmInfo{
Charm: ch,
ID: curl,
StoragePath: "dummy-path",
SHA256: "dummy-1-sha256",
}
dummy, err := s.State.AddCharm(info)
c.Assert(err, jc.ErrorIsNil)
srv := s.AddTestingService(c, "mysql", dummy)
s.addUnit(srv, m[0], c)
srv = s.AddTestingService(c, "mongodb", dummy)
s.addUnit(srv, m[1], c)
s.addUnit(srv, m[2], c)
for i, t := range sshTests {
c.Logf("test %d: %s -> %s", i, t.about, t.args)
ctx := coretesting.Context(c)
jujucmd := cmd.NewSuperCommand(cmd.SuperCommandParams{})
jujucmd.Register(newSSHCommand())
code := cmd.Main(jujucmd, ctx, t.args)
c.Check(code, gc.Equals, 0)
c.Check(ctx.Stderr.(*bytes.Buffer).String(), gc.Equals, "")
c.Check(strings.TrimRight(ctx.Stdout.(*bytes.Buffer).String(), "\r\n"), gc.Equals, t.result)
}
}
func (s *SSHSuite) TestSSHCommand(c *gc.C) {
m := s.makeMachines(3, c, true)
ch := charmtesting.Charms.Dir("dummy")
curl := charm.MustParseURL(
fmt.Sprintf("local:quantal/%s-%d", ch.Meta().Name, ch.Revision()),
)
bundleURL, err := url.Parse("http://bundles.testing.invalid/dummy-1")
c.Assert(err, gc.IsNil)
dummy, err := s.State.AddCharm(ch, curl, bundleURL, "dummy-1-sha256")
c.Assert(err, gc.IsNil)
srv := s.AddTestingService(c, "mysql", dummy)
s.addUnit(srv, m[0], c)
srv = s.AddTestingService(c, "mongodb", dummy)
s.addUnit(srv, m[1], c)
s.addUnit(srv, m[2], c)
for i, t := range sshTests {
c.Logf("test %d: %s -> %s\n", i, t.about, t.args)
ctx := coretesting.Context(c)
jujucmd := cmd.NewSuperCommand(cmd.SuperCommandParams{})
jujucmd.Register(envcmd.Wrap(&SSHCommand{}))
code := cmd.Main(jujucmd, ctx, t.args)
c.Check(code, gc.Equals, 0)
c.Check(ctx.Stderr.(*bytes.Buffer).String(), gc.Equals, "")
c.Check(ctx.Stdout.(*bytes.Buffer).String(), gc.Equals, t.result)
}
}
func (s *SuperCommandSuite) TestRegister(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest"})
jc.Register(&TestCommand{Name: "flip"})
jc.Register(&TestCommand{Name: "flap"})
badCall := func() { jc.Register(&TestCommand{Name: "flap"}) }
c.Assert(badCall, gc.PanicMatches, "command already registered: flap")
}
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")
}
// NewSuperCommand is like cmd.NewSuperCommand but
// it adds juju-specific functionality:
// - The default logging configuration is taken from the environment;
// - The version is configured to the current juju version;
// - The command emits a log message when a command runs.
func NewSuperCommand(p cmd.SuperCommandParams) *cmd.SuperCommand {
p.Log = &cmd.Log{
DefaultConfig: os.Getenv(osenv.JujuLoggingConfigEnvKey),
}
p.Version = version.Current.String()
p.NotifyRun = runNotifier
return cmd.NewSuperCommand(p)
}
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 *HelpCommandSuite) TestHelpBasics(c *gc.C) {
super := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest"})
super.Register(&TestCommand{Name: "blah"})
super.AddHelpTopic("basics", "short", "long help basics")
ctx, err := cmdtesting.RunCommand(c, super)
c.Assert(err, jc.ErrorIsNil)
s.assertStdOutMatches(c, ctx, "long help basics")
}
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) TestHelpOutput(c *gc.C) {
for i, test := range []struct {
message string
args []string
usagePrefix string
helpMatch string
errMatch string
}{
{
message: "no args shows help",
helpMatch: "Usage: jujutest .*",
}, {
message: "usage prefix with help command",
args: []string{"help"},
usagePrefix: "juju",
helpMatch: "Usage: juju jujutest .*",
}, {
message: "usage prefix with help flag",
args: []string{"--help"},
usagePrefix: "juju",
helpMatch: "Usage: juju jujutest .*",
}, {
message: "help arg usage",
args: []string{"blah", "--help"},
helpMatch: "Usage: jujutest blah.*blah-doc.*",
}, {
message: "usage prefix with help command",
args: []string{"help", "blah"},
usagePrefix: "juju",
helpMatch: "Usage: juju jujutest blah .*",
}, {
message: "usage prefix with help flag",
args: []string{"blah", "--help"},
usagePrefix: "juju",
helpMatch: "Usage: juju jujutest blah .*",
}, {
message: "too many args",
args: []string{"help", "blah", "blah"},
errMatch: `extra arguments to command help: \["blah"\]`,
},
} {
supername := "jujutest"
super := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: supername, UsagePrefix: test.usagePrefix})
super.Register(&TestCommand{Name: "blah"})
c.Logf("%d: %s, %q", i, test.message, strings.Join(append([]string{supername}, test.args...), " "))
ctx, err := cmdtesting.RunCommand(c, super, test.args...)
if test.errMatch == "" {
c.Assert(err, jc.ErrorIsNil)
s.assertStdOutMatches(c, ctx, test.helpMatch)
} else {
c.Assert(err, gc.ErrorMatches, test.errMatch)
}
}
}
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)
}
}
// NewSuperCommand creates the user supercommand and registers the subcommands
// that it supports.
func NewSuperCommand() cmd.Command {
usercmd := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "cached-images",
Doc: cachedimagesCommandDoc,
UsagePrefix: "juju",
Purpose: cachedImagesCommandPurpose,
})
usercmd.Register(newDeleteCommand())
usercmd.Register(newListCommand())
return usercmd
}
// NewSuperCommand creates the user supercommand and registers the subcommands
// that it supports.
func NewSuperCommand() cmd.Command {
machineCmd := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "machine",
Doc: machineCommandDoc,
UsagePrefix: "juju",
Purpose: machineCommandPurpose,
})
machineCmd.Register(envcmd.Wrap(&AddCommand{}))
machineCmd.Register(envcmd.Wrap(&RemoveCommand{}))
return machineCmd
}
func (s *SuperCommandSuite) TestRegisterAlias(c *gc.C) {
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest"})
jc.Register(&TestCommand{Name: "flip", Aliases: []string{"flap", "flop"}})
info := jc.Info()
c.Assert(info.Doc, gc.Equals, `commands:
flap - alias for flip
flip - flip the juju
flop - alias for flip
help - show help on a command or other topic`)
}
func (s *SuperCommandSuite) TestLogging(c *gc.C) {
sc := cmd.NewSuperCommand(cmd.SuperCommandParams{
UsagePrefix: "juju",
Name: "command",
Log: &cmd.Log{},
})
sc.Register(&TestCommand{Name: "blah"})
ctx := cmdtesting.Context(c)
code := cmd.Main(sc, ctx, []string{"blah", "--option", "error", "--debug"})
c.Assert(code, gc.Equals, 1)
c.Assert(bufferString(ctx.Stderr), gc.Matches, `^.* ERROR .* BAM!\n`)
}
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 := cmdtesting.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 *SSHSuite) TestSSHCommandEnvironProxySSH(c *gc.C) {
s.makeMachines(1, c, true)
// Setting proxy-ssh=false in the environment overrides --proxy.
err := s.State.UpdateEnvironConfig(map[string]interface{}{"proxy-ssh": false}, nil, nil)
c.Assert(err, gc.IsNil)
ctx := coretesting.Context(c)
jujucmd := cmd.NewSuperCommand(cmd.SuperCommandParams{})
jujucmd.Register(&SSHCommand{})
code := cmd.Main(jujucmd, ctx, []string{"ssh", "0"})
c.Check(code, gc.Equals, 0)
c.Check(ctx.Stderr.(*bytes.Buffer).String(), gc.Equals, "")
c.Check(ctx.Stdout.(*bytes.Buffer).String(), gc.Equals, sshArgsNoProxy+"[email protected]\n")
}
func (s *SSHSuite) TestSSHCommandEnvironProxySSH(c *gc.C) {
s.makeMachines(1, c, true)
// Setting proxy-ssh=true in the environment overrides --proxy.
err := s.State.UpdateModelConfig(map[string]interface{}{"proxy-ssh": true}, nil, nil)
c.Assert(err, jc.ErrorIsNil)
ctx := coretesting.Context(c)
jujucmd := cmd.NewSuperCommand(cmd.SuperCommandParams{})
jujucmd.Register(newSSHCommand())
code := cmd.Main(jujucmd, ctx, []string{"ssh", "0"})
c.Check(code, gc.Equals, 0)
c.Check(ctx.Stderr.(*bytes.Buffer).String(), gc.Equals, "")
c.Check(strings.TrimRight(ctx.Stdout.(*bytes.Buffer).String(), "\r\n"), gc.Equals, sshArgsWithProxy+"*****@*****.**")
}
func initDefenestrateWithAliases(c *gc.C, args []string) (*cmd.SuperCommand, *TestCommand, error) {
dir := c.MkDir()
filename := filepath.Join(dir, "aliases")
err := ioutil.WriteFile(filename, []byte(`
def = defenestrate
be-firm = defenestrate --option firmly
other = missing
`), 0644)
c.Assert(err, gc.IsNil)
jc := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest", UserAliasesFilename: filename})
tc := &TestCommand{Name: "defenestrate"}
jc.Register(tc)
return jc, tc, cmdtesting.InitCommand(jc, args)
}
func NewUserCommand() cmd.Command {
usercmd := &UserCommand{
SuperCommand: cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "user",
Doc: userCommandDoc,
UsagePrefix: "juju",
Purpose: userCommandPurpose,
}),
}
// Define each subcommand in a separate "user_FOO.go" source file
// (with tests in user_FOO_test.go) and wire in here.
usercmd.Register(envcmd.Wrap(&UserAddCommand{}))
return usercmd
}
// NewSuperCommand returns a new action super-command.
func NewSuperCommand() cmd.Command {
actionCmd := cmd.NewSuperCommand(
cmd.SuperCommandParams{
Name: "action",
Doc: actionDoc,
UsagePrefix: "juju",
Purpose: actionPurpose,
})
actionCmd.Register(envcmd.Wrap(&DefinedCommand{}))
actionCmd.Register(envcmd.Wrap(&DoCommand{}))
actionCmd.Register(envcmd.Wrap(&FetchCommand{}))
actionCmd.Register(envcmd.Wrap(&StatusCommand{}))
return actionCmd
}
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)
}
}
// NewSuperCommand creates the user supercommand and registers the subcommands
// that it supports.
func NewSuperCommand() cmd.Command {
usercmd := cmd.NewSuperCommand(cmd.SuperCommandParams{
Name: "user",
Doc: userCommandDoc,
UsagePrefix: "juju",
Purpose: userCommandPurpose,
})
usercmd.Register(envcmd.Wrap(&AddCommand{}))
usercmd.Register(envcmd.Wrap(&ChangePasswordCommand{}))
usercmd.Register(envcmd.Wrap(&InfoCommand{}))
usercmd.Register(envcmd.Wrap(&DisableCommand{}))
usercmd.Register(envcmd.Wrap(&EnableCommand{}))
usercmd.Register(envcmd.Wrap(&ListCommand{}))
return usercmd
}
// NewSuperCommand creates the storage supercommand and
// registers the subcommands that it supports.
func NewSuperCommand() cmd.Command {
storagecmd := cmd.NewSuperCommand(
cmd.SuperCommandParams{
Name: "storage",
Doc: storageCmdDoc,
UsagePrefix: "juju",
Purpose: storageCmdPurpose,
})
storagecmd.Register(envcmd.Wrap(&ShowCommand{}))
storagecmd.Register(envcmd.Wrap(&ListCommand{}))
storagecmd.Register(envcmd.Wrap(&AddCommand{}))
storagecmd.Register(NewPoolSuperCommand())
storagecmd.Register(NewVolumeSuperCommand())
return storagecmd
}