github.com/dooferlad/cmd@v0.0.0-20150716022859-3edef806220b/help_test.go (about) 1 // Copyright 2012-2015 Canonical Ltd. 2 // Licensed under the LGPLv3, see LICENCE file for details. 3 4 package cmd_test 5 6 import ( 7 "strings" 8 9 "github.com/juju/loggo" 10 gitjujutesting "github.com/juju/testing" 11 jc "github.com/juju/testing/checkers" 12 gc "gopkg.in/check.v1" 13 14 "github.com/juju/cmd" 15 "github.com/juju/cmd/cmdtesting" 16 ) 17 18 type HelpCommandSuite struct { 19 gitjujutesting.IsolationSuite 20 } 21 22 var _ = gc.Suite(&HelpCommandSuite{}) 23 24 func (s *HelpCommandSuite) SetUpTest(c *gc.C) { 25 s.IsolationSuite.SetUpTest(c) 26 loggo.GetLogger("juju.cmd").SetLogLevel(loggo.DEBUG) 27 } 28 29 func (s *HelpCommandSuite) assertStdOutMatches(c *gc.C, ctx *cmd.Context, match string) { 30 stripped := strings.Replace(cmdtesting.Stdout(ctx), "\n", "", -1) 31 c.Assert(stripped, gc.Matches, match) 32 } 33 34 func (s *HelpCommandSuite) TestHelpOutput(c *gc.C) { 35 for i, test := range []struct { 36 message string 37 args []string 38 usagePrefix string 39 helpMatch string 40 errMatch string 41 }{ 42 { 43 message: "no args shows help", 44 helpMatch: "usage: jujutest .*", 45 }, { 46 message: "usage prefix with help command", 47 args: []string{"help"}, 48 usagePrefix: "juju", 49 helpMatch: "usage: juju jujutest .*", 50 }, { 51 message: "usage prefix with help flag", 52 args: []string{"--help"}, 53 usagePrefix: "juju", 54 helpMatch: "usage: juju jujutest .*", 55 }, { 56 message: "help arg usage", 57 args: []string{"blah", "--help"}, 58 helpMatch: "usage: jujutest blah.*blah-doc.*", 59 }, { 60 message: "usage prefix with help command", 61 args: []string{"help", "blah"}, 62 usagePrefix: "juju", 63 helpMatch: "usage: juju jujutest blah .*", 64 }, { 65 message: "usage prefix with help flag", 66 args: []string{"blah", "--help"}, 67 usagePrefix: "juju", 68 helpMatch: "usage: juju jujutest blah .*", 69 }, { 70 message: "too many args", 71 args: []string{"help", "blah", "blah"}, 72 errMatch: `extra arguments to command help: \["blah"\]`, 73 }, 74 } { 75 supername := "jujutest" 76 super := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: supername, UsagePrefix: test.usagePrefix}) 77 super.Register(&TestCommand{Name: "blah"}) 78 c.Logf("%d: %s, %q", i, test.message, strings.Join(append([]string{supername}, test.args...), " ")) 79 80 ctx, err := cmdtesting.RunCommand(c, super, test.args...) 81 if test.errMatch == "" { 82 c.Assert(err, jc.ErrorIsNil) 83 s.assertStdOutMatches(c, ctx, test.helpMatch) 84 85 } else { 86 c.Assert(err, gc.ErrorMatches, test.errMatch) 87 } 88 } 89 } 90 91 func (s *HelpCommandSuite) TestHelpBasics(c *gc.C) { 92 super := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "jujutest"}) 93 super.Register(&TestCommand{Name: "blah"}) 94 super.AddHelpTopic("basics", "short", "long help basics") 95 96 ctx, err := cmdtesting.RunCommand(c, super) 97 c.Assert(err, jc.ErrorIsNil) 98 s.assertStdOutMatches(c, ctx, "long help basics") 99 } 100 101 func (s *HelpCommandSuite) TestMultipleSuperCommands(c *gc.C) { 102 level1 := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "level1"}) 103 level2 := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "level2", UsagePrefix: "level1"}) 104 level1.Register(level2) 105 level3 := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "level3", UsagePrefix: "level1 level2"}) 106 level2.Register(level3) 107 level3.Register(&TestCommand{Name: "blah"}) 108 109 ctx, err := cmdtesting.RunCommand(c, level1, "help", "level2", "level3", "blah") 110 c.Assert(err, jc.ErrorIsNil) 111 s.assertStdOutMatches(c, ctx, "usage: level1 level2 level3 blah.*blah-doc.*") 112 113 _, err = cmdtesting.RunCommand(c, level1, "help", "level2", "missing", "blah") 114 c.Assert(err, gc.ErrorMatches, `subcommand "missing" not found`) 115 } 116 117 func (s *HelpCommandSuite) TestAlias(c *gc.C) { 118 super := cmd.NewSuperCommand(cmd.SuperCommandParams{Name: "super"}) 119 super.Register(&TestCommand{Name: "blah", Aliases: []string{"alias"}}) 120 ctx := cmdtesting.Context(c) 121 code := cmd.Main(super, ctx, []string{"help", "alias"}) 122 c.Assert(code, gc.Equals, 0) 123 stripped := strings.Replace(bufferString(ctx.Stdout), "\n", "", -1) 124 c.Assert(stripped, gc.Matches, "usage: super blah .*aliases: alias") 125 } 126 127 func (s *HelpCommandSuite) TestRegisterSuperAliasHelp(c *gc.C) { 128 jc := cmd.NewSuperCommand(cmd.SuperCommandParams{ 129 Name: "jujutest", 130 }) 131 sub := cmd.NewSuperCommand(cmd.SuperCommandParams{ 132 Name: "bar", 133 UsagePrefix: "jujutest", 134 Purpose: "bar functions", 135 }) 136 jc.Register(sub) 137 sub.Register(&simple{name: "foo"}) 138 139 jc.RegisterSuperAlias("bar-foo", "bar", "foo", nil) 140 141 for _, test := range []struct { 142 args []string 143 }{ 144 { 145 args: []string{"bar", "foo", "--help"}, 146 }, { 147 args: []string{"bar", "help", "foo"}, 148 }, { 149 args: []string{"help", "bar-foo"}, 150 }, { 151 args: []string{"bar-foo", "--help"}, 152 }, 153 } { 154 c.Logf("args: %v", test.args) 155 ctx := cmdtesting.Context(c) 156 code := cmd.Main(jc, ctx, test.args) 157 c.Check(code, gc.Equals, 0) 158 help := "usage: jujutest bar foo\npurpose: to be simple\n" 159 c.Check(cmdtesting.Stdout(ctx), gc.Equals, help) 160 } 161 }