// RunCommand runs a command with the specified args. The returned error
// may come from either the parsing of the args, the command initialisation, or
// the actual running of the command. Access to the resulting output streams
// is provided through the returned context instance.
func RunCommand(c *gc.C, com cmd.Command, args ...string) (*cmd.Context, error) {
if err := InitCommand(com, args); err != nil {
return nil, err
}
var context = Context(c)
return context, com.Run(context)
}
// RunCommandInDir works like RunCommand, but runs with a context that uses dir.
func RunCommandInDir(c *gc.C, com cmd.Command, args []string, dir string) (*cmd.Context, error) {
if err := InitCommand(com, args); err != nil {
return nil, err
}
var context = ContextForDir(c, dir)
return context, com.Run(context)
}
// RunCommand runs the command and returns channels holding the
// command's operations and errors.
func RunCommand(ctx *cmd.Context, com cmd.Command, args ...string) (opc chan dummy.Operation, errc chan error) {
if ctx == nil {
panic("ctx == nil")
}
errc = make(chan error, 1)
opc = make(chan dummy.Operation, 200)
dummy.Listen(opc)
go func() {
defer func() {
// signal that we're done with this ops channel.
dummy.Listen(nil)
// now that dummy is no longer going to send ops on
// this channel, close it to signal to test cases
// that we are done.
close(opc)
}()
if err := coretesting.InitCommand(com, args); err != nil {
errc <- err
return
}
errc <- com.Run(ctx)
}()
return
}
func helpText(command cmd.Command, name string) string {
buff := &bytes.Buffer{}
info := command.Info()
info.Name = name
f := gnuflag.NewFlagSet(info.Name, gnuflag.ContinueOnError)
command.SetFlags(f)
buff.Write(info.Help(f))
return buff.String()
}
func (r *stubRegistry) RegisterDeprecated(subcmd cmd.Command, check cmd.DeprecationCheck) {
r.stub.AddCall("RegisterDeprecated", subcmd, check)
r.stub.NextErr() // pop one off
r.names = append(r.names, subcmd.Info().Name)
for _, name := range subcmd.Info().Aliases {
r.names = append(r.names, name)
}
}
func (r *stubRegistry) Register(subcmd cmd.Command) {
r.stub.AddCall("Register", subcmd)
r.stub.NextErr() // pop one off
r.names = append(r.names, subcmd.Info().Name)
for _, name := range subcmd.Info().Aliases {
r.names = append(r.names, name)
}
}
// RunCommand runs a command with the specified args. The returned error
// may come from either the parsing of the args, the command initialisation, or
// the actual running of the command. Access to the resulting output streams
// is provided through the returned context instance.
func RunCommand(c *gc.C, com cmd.Command, args ...string) (*cmd.Context, error) {
var context = Context(c)
if err := InitCommand(com, args); err != nil {
if err != nil {
fmt.Fprintf(context.Stderr, "error: %v\n", err)
}
return context, err
}
return context, com.Run(context)
}
func (s *BaseActionSuite) checkHelp(c *gc.C, subcmd cmd.Command) {
ctx, err := coretesting.RunCommand(c, s.command, subcmd.Info().Name, "--help")
c.Assert(err, gc.IsNil)
expected := "(?sm).*^usage: juju action " +
regexp.QuoteMeta(subcmd.Info().Name) +
` \[options\] ` + regexp.QuoteMeta(subcmd.Info().Args) + ".+"
c.Check(coretesting.Stdout(ctx), gc.Matches, expected)
expected = "(?sm).*^purpose: " + regexp.QuoteMeta(subcmd.Info().Purpose) + "$.*"
c.Check(coretesting.Stdout(ctx), gc.Matches, expected)
expected = "(?sm).*^" + regexp.QuoteMeta(subcmd.Info().Doc) + "$.*"
c.Check(coretesting.Stdout(ctx), gc.Matches, expected)
}
func runCommand(ctx *cmd.Context, com cmd.Command, args ...string) (opc chan dummy.Operation, errc chan error) {
if ctx == nil {
panic("ctx == nil")
}
errc = make(chan error, 1)
opc = make(chan dummy.Operation, 200)
dummy.Listen(opc)
go func() {
// signal that we're done with this ops channel.
defer dummy.Listen(nil)
err := coretesting.InitCommand(com, args)
if err != nil {
errc <- err
return
}
err = com.Run(ctx)
errc <- err
}()
return
}
// InitCommand will create a new flag set, and call the Command's SetFlags and
// Init methods with the appropriate args.
func InitCommand(c cmd.Command, args []string) error {
f := NewFlagSet()
c.SetFlags(f)
if err := f.Parse(c.AllowInterspersedFlags(), args); err != nil {
return err
}
return c.Init(f.Args())
}
func (s *BaseBackupsSuite) checkHelp(c *gc.C, subcmd cmd.Command) {
ctx, err := jujutesting.RunCommand(c, s.command, subcmd.Info().Name, "--help")
c.Assert(err, gc.IsNil)
var expected string
if subcmd.Info().Args != "" {
expected = "(?sm).*^Usage: juju backups " +
regexp.QuoteMeta(subcmd.Info().Name) +
` \[options\] ` + regexp.QuoteMeta(subcmd.Info().Args) + ".+"
} else {
expected = "(?sm).*^Usage: juju backups " +
regexp.QuoteMeta(subcmd.Info().Name) +
` \[options\].+`
}
c.Check(jujutesting.Stdout(ctx), gc.Matches, expected)
expected = "(?sm).*^Summary:\n" + regexp.QuoteMeta(subcmd.Info().Purpose) + "$.*"
c.Check(jujutesting.Stdout(ctx), gc.Matches, expected)
expected = "(?sm).*^Details:" + regexp.QuoteMeta(subcmd.Info().Doc) + "$.*"
c.Check(jujutesting.Stdout(ctx), gc.Matches, expected)
}
func (m *mockRegister) Register(command cmd.Command) {
m.commands = append(m.commands, command.Info().Name)
}
