Merge lp:~rogpeppe/pyjuju/testing2 into lp:pyjuju/go

[Roger Peppe]

testing toasting2

https://codereview.appspot.com/5554051/

Unmerged revisions

38. By William Reade on 2012-01-18

merge go-add-control-package

=== modified file 'charm/config.go'
--- charm/config.go	2011-12-19 09:59:01 +0000
+++ charm/config.go	2012-01-18 17:42:24 +0000
@@ -1,8 +1,8 @@
 package charm
 
 import (
+	"errors"
 	"fmt"
-	"errors"
 	"io"
 	"io/ioutil"
 	"launchpad.net/goyaml"
 
=== modified file 'cloudinit/cloudinit_test.go'
--- cloudinit/cloudinit_test.go	2011-12-14 12:53:47 +0000
+++ cloudinit/cloudinit_test.go	2012-01-18 17:42:24 +0000
@@ -6,6 +6,7 @@
 	"launchpad.net/juju/go/cloudinit"
 	"testing"
 )
+
 // TODO integration tests, but how?
 
 type S struct{}
 
=== added directory 'control'
=== added file 'control/bootstrap.go'
--- control/bootstrap.go	1970-01-01 00:00:00 +0000
+++ control/bootstrap.go	2012-01-18 17:42:24 +0000
@@ -0,0 +1,28 @@
+package control
+
+import "flag"
+import "fmt"
+
+type BootstrapCommand struct {
+	environment string
+}
+
+var _ Command = (*BootstrapCommand)(nil)
+
+func (c *BootstrapCommand) Parse(args []string) error {
+	fs := flag.NewFlagSet("bootstrap", flag.ExitOnError)
+	fs.StringVar(&c.environment, "e", "", "juju environment to operate in")
+	fs.StringVar(&c.environment, "environment", "", "juju environment to operate in")
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
+	if len(fs.Args()) != 0 {
+		return fmt.Errorf("Unknown args: %s", fs.Args())
+	}
+	return nil
+}
+
+func (c *BootstrapCommand) Run() error {
+	fmt.Println("Running bootstrap in environment ", c.environment)
+	return nil
+}
 
=== added file 'control/command.go'
--- control/command.go	1970-01-01 00:00:00 +0000
+++ control/command.go	2012-01-18 17:42:24 +0000
@@ -0,0 +1,69 @@
+package control
+
+import "fmt"
+import "flag"
+
+type Command interface {
+	Parse(args []string) error
+	Run() error
+}
+
+type JujuCommand struct {
+	logfile string
+	verbose bool
+	subcmds map[string]Command
+	subcmd  Command
+}
+
+func (c *JujuCommand) Logfile() string {
+	return c.logfile
+}
+
+func (c *JujuCommand) Verbose() bool {
+	return c.verbose
+}
+
+func (c *JujuCommand) Register(name string, subcmd Command) error {
+	if c.subcmds == nil {
+		c.subcmds = make(map[string]Command)
+	}
+	_, alreadythere := c.subcmds[name]
+	if alreadythere {
+		return fmt.Errorf("subcommand %s already registered", name)
+	}
+	c.subcmds[name] = subcmd
+	return nil
+}
+
+func (c *JujuCommand) Parse(args []string) error {
+	if len(args) == 0 {
+		return fmt.Errorf("no args to parse")
+	}
+	fs := flag.NewFlagSet(args[0], flag.ExitOnError)
+	fs.StringVar(&c.logfile, "l", "", "where to log to")
+	fs.StringVar(&c.logfile, "log-file", "", "where to log to")
+	fs.BoolVar(&c.verbose, "v", false, "whether to be noisy")
+	fs.BoolVar(&c.verbose, "verbose", false, "whether to be noisy")
+	if err := fs.Parse(args[1:]); err != nil {
+		return err
+	}
+	return c.parseSubcmd(fs.Args())
+}
+
+func (c *JujuCommand) parseSubcmd(args []string) error {
+	if len(args) == 0 {
+		return fmt.Errorf("no subcommand specified")
+	}
+	if c.subcmds == nil {
+		return fmt.Errorf("no subcommands registered")
+	}
+	exists := false
+	if c.subcmd, exists = c.subcmds[args[0]]; !exists {
+		return fmt.Errorf("no %s subcommand registered", args[0])
+	}
+	return c.subcmd.Parse(args[1:])
+}
+
+func (c *JujuCommand) Run() error {
+	return c.subcmd.Run()
+}
 
=== added file 'control/command_test.go'
--- control/command_test.go	1970-01-01 00:00:00 +0000
+++ control/command_test.go	2012-01-18 17:42:24 +0000
@@ -0,0 +1,100 @@
+package control_test
+
+import (
+	"flag"
+	. "launchpad.net/gocheck"
+	"launchpad.net/juju/go/control"
+	"testing"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type CommandSuite struct{}
+
+var _ = Suite(&CommandSuite{})
+
+type testCommand struct {
+	value string
+}
+
+func (c *testCommand) Parse(args []string) error {
+	fs := flag.NewFlagSet("defenestrate", flag.ContinueOnError)
+	fs.StringVar(&c.value, "value", "", "doc")
+	return fs.Parse(args)
+}
+
+func (c *testCommand) Run() error {
+	return nil
+}
+
+func parseEmpty(args []string) (*control.JujuCommand, error) {
+	jc := new(control.JujuCommand)
+	err := jc.Parse(args)
+	return jc, err
+}
+
+func parseDefenestrate(args []string) (*control.JujuCommand, *testCommand, error) {
+	jc := new(control.JujuCommand)
+	tc := new(testCommand)
+	jc.Register("defenestrate", tc)
+	err := jc.Parse(args)
+	return jc, tc, err
+}
+
+func (s *CommandSuite) TestSubcommandDispatch(c *C) {
+	_, err := parseEmpty([]string{"juju"})
+	c.Assert(err, ErrorMatches, `no subcommand specified`)
+
+	_, err = parseEmpty([]string{"juju", "defenstrate"})
+	c.Assert(err, ErrorMatches, `no subcommands registered`)
+
+	_, _, err = parseDefenestrate([]string{"juju", "discombobulate"})
+	c.Assert(err, ErrorMatches, `no discombobulate subcommand registered`)
+
+	_, tc, err := parseDefenestrate([]string{"juju", "defenestrate"})
+	c.Assert(err, IsNil)
+	c.Assert(tc.value, Equals, "")
+
+	_, tc, err = parseDefenestrate([]string{"juju", "defenestrate", "--value", "firmly"})
+	c.Assert(err, IsNil)
+	c.Assert(tc.value, Equals, "firmly")
+
+	_, tc, err = parseDefenestrate([]string{"juju", "defenestrate", "--gibberish", "burble"})
+	c.Assert(err, ErrorMatches, "flag provided but not defined: -gibberish")
+}
+
+func (s *CommandSuite) TestVerbose(c *C) {
+	jc, err := parseEmpty([]string{"juju"})
+	c.Assert(err, ErrorMatches, "no subcommand specified")
+	c.Assert(jc.Verbose(), Equals, false)
+
+	jc, _, err = parseDefenestrate([]string{"juju", "defenestrate"})
+	c.Assert(err, IsNil)
+	c.Assert(jc.Verbose(), Equals, false)
+
+	jc, err = parseEmpty([]string{"juju", "--verbose"})
+	c.Assert(err, ErrorMatches, "no subcommand specified")
+	c.Assert(jc.Verbose(), Equals, true)
+
+	jc, _, err = parseDefenestrate([]string{"juju", "-v", "defenestrate"})
+	c.Assert(err, IsNil)
+	c.Assert(jc.Verbose(), Equals, true)
+}
+
+func (s *CommandSuite) TestLogfile(c *C) {
+	jc, err := parseEmpty([]string{"juju"})
+	c.Assert(err, ErrorMatches, "no subcommand specified")
+	c.Assert(jc.Logfile(), Equals, "")
+
+	jc, _, err = parseDefenestrate([]string{"juju", "defenestrate"})
+	c.Assert(err, IsNil)
+	c.Assert(jc.Logfile(), Equals, "")
+
+	jc, err = parseEmpty([]string{"juju", "-l", "foo"})
+	c.Assert(err, ErrorMatches, "no subcommand specified")
+	c.Assert(jc.Logfile(), Equals, "foo")
+
+	jc, _, err = parseDefenestrate([]string{"juju", "--log-file", "bar", "defenestrate"})
+	c.Assert(err, IsNil)
+	c.Assert(jc.Logfile(), Equals, "bar")
+}