func (s *cmdMetricsCommandSuite) TestUnits(c *gc.C) { meteredCharm := s.Factory.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "local:quantal/metered"}) meteredService := s.Factory.MakeApplication(c, &factory.ApplicationParams{Charm: meteredCharm}) unit := s.Factory.MakeUnit(c, &factory.UnitParams{Application: meteredService, SetCharmURL: true}) unit2 := s.Factory.MakeUnit(c, &factory.UnitParams{Application: meteredService, SetCharmURL: true}) newTime1 := time.Now().Round(time.Second) newTime2 := newTime1.Add(time.Second) metricA := state.Metric{"pings", "5", newTime1} metricB := state.Metric{"pings", "10.5", newTime2} s.Factory.MakeMetric(c, &factory.MetricParams{Unit: unit, Metrics: []state.Metric{metricA}}) s.Factory.MakeMetric(c, &factory.MetricParams{Unit: unit2, Metrics: []state.Metric{metricA, metricB}}) ctx, err := coretesting.RunCommand(c, metricsdebug.New(), "metered/1") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, formatTabular(metric{ Unit: unit2.Name(), Timestamp: newTime2, Metric: "pings", Value: "10.5", }), ) ctx, err = coretesting.RunCommand(c, metricsdebug.New(), "metered/0") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, formatTabular(metric{ Unit: unit.Name(), Timestamp: newTime1, Metric: "pings", Value: "5", }), ) }
func (s *listAgreementsSuite) TestGetUsersAgreementsWithTermOwner(c *gc.C) { ctx, err := cmdtesting.RunCommand(c, listagreements.NewListAgreementsCommand()) c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, `[] `) c.Assert(s.client.called, jc.IsTrue) s.client.setError("well, this is embarassing") ctx, err = cmdtesting.RunCommand(c, listagreements.NewListAgreementsCommand()) c.Assert(err, gc.ErrorMatches, "failed to list user agreements: well, this is embarassing") c.Assert(s.client.called, jc.IsTrue) agreements := []terms.AgreementResponse{{ User: "******", Owner: "owner", Term: "test-term", Revision: 1, CreatedOn: time.Date(2015, 12, 25, 0, 0, 0, 0, time.UTC), }} s.client.setAgreements(agreements) ctx, err = cmdtesting.RunCommand(c, listagreements.NewListAgreementsCommand()) c.Assert(err, jc.ErrorIsNil) c.Assert(ctx, gc.NotNil) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, expectedListAgreementsJSONOutputWithOwner) c.Assert(s.client.called, jc.IsTrue) ctx, err = cmdtesting.RunCommand(c, listagreements.NewListAgreementsCommand(), "--format", "yaml") c.Assert(err, jc.ErrorIsNil) c.Assert(ctx, gc.NotNil) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, "- user: test-user\n owner: owner\n term: test-term\n revision: 1\n createdon: 2015-12-25T00:00:00Z\n") c.Assert(s.client.called, jc.IsTrue) }
func (s *metricsSuite) TestYAMLFormat(c *gc.C) { s.client.metrics = []params.MetricResult{{ Unit: "unit-metered-0", Key: "pings", Value: "5.0", Time: time.Date(2016, 8, 22, 12, 02, 03, 0, time.UTC), }, { Unit: "unit-metered-0", Key: "pongs", Value: "15.0", Time: time.Date(2016, 8, 22, 12, 02, 04, 0, time.UTC), }} ctx, err := coretesting.RunCommand(c, metricsdebug.New(), "metered", "--format", "yaml") c.Assert(err, jc.ErrorIsNil) s.client.CheckCall(c, 0, "GetMetrics", []string{"application-metered"}) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, `- unit: unit-metered-0 timestamp: 2016-08-22T12:02:03Z metric: pings value: "5.0" - unit: unit-metered-0 timestamp: 2016-08-22T12:02:04Z metric: pongs value: "15.0" `) }
func (s *allocateSuite) TestAllocate(c *gc.C) { s.mockAPI.resp = "allocation updated" ctx, err := s.run(c, "name:100", "db") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), jc.DeepEquals, "allocation updated\n") s.mockAPI.CheckCall(c, 0, "CreateAllocation", "name", "100", "model-uuid", []string{"db"}) }
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 *updateAllocationSuite) TestUpdateAllocation(c *gc.C) { s.mockAPI.resp = "name budget set to 5" ctx, err := s.run(c, "name", "5") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), jc.DeepEquals, "name budget set to 5\n") s.mockAPI.CheckCall(c, 0, "UpdateAllocation", "model-uuid", "name", "5") }
func (s *listBudgetsSuite) TestListBudgetsOutputNoBudgets(c *gc.C) { s.mockAPI.result = &budget.ListBudgetsResponse{ Budgets: budget.BudgetSummaries{}, Total: budget.BudgetTotals{ Limit: "0", Allocated: "0", Available: "0", Unallocated: "0", Consumed: "0", }, Credit: "0", } expected := "" + "BUDGET \tMONTHLY\tALLOCATED\tAVAILABLE\tSPENT\n" + "TOTAL \t 0\t 0\t 0\t 0\n" + " \t \t \t \t \n" + "Credit limit:\t 0\t \t \t \n" listBudgets := listbudgets.NewListBudgetsCommand() ctx, err := cmdtesting.RunCommand(c, listBudgets) c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), jc.DeepEquals, expected) s.mockAPI.CheckCallNames(c, "ListBudgets") }
func (s *DebugMetricsCommandSuite) TestUnitJsonOutput(c *gc.C) { meteredCharm := s.Factory.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "local:quantal/metered"}) meteredService := s.Factory.MakeService(c, &factory.ServiceParams{Charm: meteredCharm}) unit := s.Factory.MakeUnit(c, &factory.UnitParams{Service: meteredService, SetCharmURL: true}) newTime := time.Now().Round(time.Second) metricA := state.Metric{"pings", "5", newTime} metricB := state.Metric{"pings", "10.5", newTime} s.Factory.MakeMetric(c, &factory.MetricParams{Unit: unit, Metrics: []state.Metric{metricA}}) s.Factory.MakeMetric(c, &factory.MetricParams{Unit: unit, Metrics: []state.Metric{metricA, metricB}}) outputTime := newTime.Format(time.RFC3339) expectedOutput := fmt.Sprintf(`[ { "time": "%v", "key": "pings", "value": "5" }, { "time": "%v", "key": "pings", "value": "5" }, { "time": "%v", "key": "pings", "value": "10.5" } ]`, outputTime, outputTime, outputTime) ctx, err := coretesting.RunCommand(c, metricsdebug.New(), "metered/0", "--json") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, expectedOutput) }
func (s *DebugMetricsCommandSuite) TestNoMetrics(c *gc.C) { meteredCharm := s.Factory.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "local:quantal/metered"}) meteredService := s.Factory.MakeService(c, &factory.ServiceParams{Charm: meteredCharm}) s.Factory.MakeUnit(c, &factory.UnitParams{Service: meteredService, SetCharmURL: true}) ctx, err := coretesting.RunCommand(c, metricsdebug.New(), "metered", "-n", "2") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, "") }
func (s *allocateSuite) TestAllocate(c *gc.C) { s.mockAPI.resp = "allocation updated" alloc := allocate.NewAllocateCommand() ctx, err := cmdtesting.RunCommand(c, alloc, "name:100", "db") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), jc.DeepEquals, "allocation updated") s.mockAPI.CheckCall(c, 0, "CreateAllocation", "name", "100", "env-uuid", []string{"db"}) }
func (s *listBudgetsSuite) TestListBudgetsNoOutput(c *gc.C) { listBudgets := listbudgets.NewListBudgetsCommand() ctx, err := cmdtesting.RunCommand(c, listBudgets) c.Assert(err, gc.ErrorMatches, `no budget information available`) c.Assert(cmdtesting.Stdout(ctx), jc.DeepEquals, ``) s.mockAPI.CheckCallNames(c, "ListBudgets") }
func (s *updateAllocationSuite) TestUpdateAllocation(c *gc.C) { s.mockAPI.resp = "name budget set to 5" set := updateallocation.NewUpdateAllocationCommand() ctx, err := cmdtesting.RunCommand(c, set, "name", "5") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), jc.DeepEquals, "name budget set to 5") s.mockAPI.CheckCall(c, 0, "UpdateAllocation", "env-uuid", "name", "5") }
func (s *setBudgetSuite) TestSetBudget(c *gc.C) { s.mockAPI.resp = "name budget set to 5" set := setbudget.NewSetBudgetCommand() ctx, err := cmdtesting.RunCommand(c, set, "name", "5") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), jc.DeepEquals, "name budget set to 5\n") s.mockAPI.CheckCall(c, 0, "SetBudget", "name", "5") }
func (s *createBudgetSuite) TestCreateBudget(c *gc.C) { s.mockAPI.resp = "name budget set to 5" createCmd := createbudget.NewCreateBudgetCommand() ctx, err := cmdtesting.RunCommand(c, createCmd, "name", "5") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), jc.DeepEquals, "name budget set to 5") s.mockAPI.CheckCall(c, 0, "CreateBudget", "name", "5") }
func (s *listBudgetsSuite) TestListBudgetsOutput(c *gc.C) { s.mockAPI.result = &budget.ListBudgetsResponse{ Budgets: budget.BudgetSummaries{ budget.BudgetSummary{ Owner: "bob", Budget: "personal", Limit: "50", Allocated: "30", Unallocated: "20", Available: "45", Consumed: "5", }, budget.BudgetSummary{ Owner: "bob", Budget: "work", Limit: "200", Allocated: "100", Unallocated: "100", Available: "150", Consumed: "50", }, budget.BudgetSummary{ Owner: "bob", Budget: "team", Limit: "50", Allocated: "10", Unallocated: "40", Available: "40", Consumed: "10", }, }, Total: budget.BudgetTotals{ Limit: "300", Allocated: "140", Available: "235", Unallocated: "160", Consumed: "65", }, Credit: "400", } // Expected command output. Make sure budgets are sorted alphabetically. expected := "" + "BUDGET \tMONTHLY\tALLOCATED\tAVAILABLE\tSPENT\n" + "personal \t 50\t 30\t 45\t 5\n" + "team \t 50\t 10\t 40\t 10\n" + "work \t 200\t 100\t 150\t 50\n" + "TOTAL \t 300\t 140\t 235\t 65\n" + " \t \t \t \t \n" + "Credit limit:\t 400\t \t \t \n" listBudgets := listbudgets.NewListBudgetsCommand() ctx, err := cmdtesting.RunCommand(c, listBudgets) c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), jc.DeepEquals, expected) s.mockAPI.CheckCallNames(c, "ListBudgets") }
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 *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 *agreeSuite) TestAgreementNothingToSign(c *gc.C) { jujutesting.PatchValue(agree.UserAnswer, func() (string, error) { return "y", nil }) s.client.user = "******" s.client.setUnsignedTerms([]terms.GetTermsResponse{}) ctx, err := cmdtesting.RunCommand(c, agree.NewAgreeCommand(), "test-term/1") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, `Already agreed `) }
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 *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 *metricsSuite) TestDefaultTabulatFormat(c *gc.C) { s.client.metrics = []params.MetricResult{{ Unit: "unit-metered-0", Key: "pings", Value: "5.0", Time: time.Date(2016, 8, 22, 12, 02, 03, 0, time.UTC), }, { Unit: "unit-metered-0", Key: "pongs", Value: "15.0", Time: time.Date(2016, 8, 22, 12, 02, 04, 0, time.UTC), }} ctx, err := coretesting.RunCommand(c, metricsdebug.New(), "metered/0") c.Assert(err, jc.ErrorIsNil) s.client.CheckCall(c, 0, "GetMetrics", []string{"unit-metered-0"}) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, `UNIT TIMESTAMP METRIC VALUE unit-metered-0 2016-08-22T12:02:03Z pings 5.0 unit-metered-0 2016-08-22T12:02:04Z pongs 15.0 `) }
func (s *DebugMetricsCommandSuite) TestUnits(c *gc.C) { meteredCharm := s.Factory.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "local:quantal/metered"}) meteredService := s.Factory.MakeService(c, &factory.ServiceParams{Charm: meteredCharm}) unit := s.Factory.MakeUnit(c, &factory.UnitParams{Service: meteredService, SetCharmURL: true}) unit2 := s.Factory.MakeUnit(c, &factory.UnitParams{Service: meteredService, SetCharmURL: true}) newTime := time.Now().Round(time.Second) metricA := state.Metric{"pings", "5", newTime} metricB := state.Metric{"pings", "10.5", newTime} s.Factory.MakeMetric(c, &factory.MetricParams{Unit: unit, Metrics: []state.Metric{metricA}}) s.Factory.MakeMetric(c, &factory.MetricParams{Unit: unit2, Metrics: []state.Metric{metricA, metricB}}) outputTime := newTime.Format(time.RFC3339) expectedOutput := bytes.Buffer{} tw := tabwriter.NewWriter(&expectedOutput, 0, 1, 1, ' ', 0) fmt.Fprintf(tw, "TIME\tMETRIC\tVALUE\n") fmt.Fprintf(tw, "%v\tpings\t5\n", outputTime) fmt.Fprintf(tw, "%v\tpings\t10.5\n", outputTime) tw.Flush() ctx, err := coretesting.RunCommand(c, metricsdebug.New(), "metered/1") c.Assert(err, jc.ErrorIsNil) c.Assert(cmdtesting.Stdout(ctx), gc.Equals, expectedOutput.String()) }
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) } }
func (s *showBudgetSuite) TestShowBudgetCommand(c *gc.C) { tests := []struct { about string args []string err string budget string apierr string resolveerr string output string }{{ about: "missing argument", err: `missing arguments`, }, { about: "unknown arguments", args: []string{"my-special-budget", "extra", "arguments"}, err: `unrecognized args: \["extra" "arguments"\]`, }, { about: "api error", args: []string{"personal"}, apierr: "well, this is embarrassing", err: "failed to retrieve the budget: well, this is embarrassing", }, { about: "all ok", args: []string{"personal"}, budget: "personal", output: "" + "MODEL \tSERVICES \tSPENT\tALLOCATED\tBY \tUSAGE\n" + "model.joe \tmysql \t 200\t 1200\tuser.joe \t 42%\n" + " \twordpress\t 300\t \t \n" + "model.jess \tlandscape\t 600\t 1000\tuser.jess\t 60%\n" + "uuid3 \tmysql \t 10\t 100\tuser.bob \t 10%\n" + " \t \t \t \t \n" + "TOTAL \t \t 1110\t 2300\t \t 48%\n" + "BUDGET \t \t \t 4000\t \n" + "UNALLOCATED\t \t \t 1700\t \n", }, { about: "all ok", args: []string{"personal"}, budget: "personal", resolveerr: "test error", output: "" + "MODEL \tSERVICES \tSPENT\tALLOCATED\tBY \tUSAGE\n" + "uuid1 \tmysql \t 200\t 1200\tuser.joe \t 42%\n" + " \twordpress\t 300\t \t \n" + "uuid2 \tlandscape\t 600\t 1000\tuser.jess\t 60%\n" + "uuid3 \tmysql \t 10\t 100\tuser.bob \t 10%\n" + " \t \t \t \t \n" + "TOTAL \t \t 1110\t 2300\t \t 48%\n" + "BUDGET \t \t \t 4000\t \n" + "UNALLOCATED\t \t \t 1700\t \n", }, } for i, test := range tests { c.Logf("running test %d: %v", i, test.about) s.mockAPI.ResetCalls() errs := []error{} if test.apierr != "" { errs = append(errs, errors.New(test.apierr)) } else { errs = append(errs, nil) } if test.resolveerr != "" { errs = append(errs, errors.New(test.resolveerr)) } else { errs = append(errs, nil) } s.mockAPI.SetErrors(errs...) showBudget := showbudget.NewShowBudgetCommand() ctx, err := cmdtesting.RunCommand(c, showBudget, test.args...) if test.err == "" { c.Assert(err, jc.ErrorIsNil) s.stub.CheckCalls(c, []testing.StubCall{ {"GetBudget", []interface{}{test.budget}}, {"ModelInfo", []interface{}{[]names.ModelTag{names.NewModelTag("uuid1"), names.NewModelTag("uuid2"), names.NewModelTag("uuid3")}}}, }) output := cmdtesting.Stdout(ctx) c.Assert(output, gc.Equals, test.output) } else { c.Assert(err, gc.ErrorMatches, test.err) } } }
func (s *agreeSuite) TestAgreement(c *gc.C) { var answer string jujutesting.PatchValue(agree.UserAnswer, func() (string, error) { return answer, nil }) s.client.user = "******" s.client.setUnsignedTerms([]terms.GetTermsResponse{{ Name: "test-term", Revision: 1, Content: testTerms, }}) tests := []struct { about string args []string err string stdout string answer string apiCalls []jujutesting.StubCall }{{ about: "everything works", args: []string{"test-term/1", "--yes"}, stdout: "Agreed to revision 1 of test-term for Juju users\n", apiCalls: []jujutesting.StubCall{{FuncName: "SaveAgreement", Args: []interface{}{&terms.SaveAgreements{Agreements: []terms.SaveAgreement{{TermName: "test-term", TermRevision: 1}}}}}}, }, { about: "everything works with owner term", args: []string{"owner/test-term/1", "--yes"}, stdout: "Agreed to revision 1 of test-term for Juju users\n", apiCalls: []jujutesting.StubCall{{FuncName: "SaveAgreement", Args: []interface{}{&terms.SaveAgreements{Agreements: []terms.SaveAgreement{{TermOwner: "owner", TermName: "test-term", TermRevision: 1}}}}}}, }, { about: "cannot parse revision number", args: []string{"test-term/abc"}, err: "invalid term format: strconv.ParseInt: parsing \"abc\": invalid syntax", }, { about: "missing arguments", args: []string{}, err: "missing arguments", }, { about: "everything works - user accepts", args: []string{"test-term/1"}, answer: "y", stdout: ` === test-term/1: 0001-01-01 00:00:00 +0000 UTC === Test Terms ======== Do you agree to the displayed terms? (Y/n): Agreed to revision 1 of test-term for Juju users `, apiCalls: []jujutesting.StubCall{{ FuncName: "GetUnunsignedTerms", Args: []interface{}{ &terms.CheckAgreementsRequest{Terms: []string{"test-term/1"}}, }, }, { FuncName: "SaveAgreement", Args: []interface{}{ &terms.SaveAgreements{Agreements: []terms.SaveAgreement{{TermName: "test-term", TermRevision: 1}}}, }, }}, }, { about: "everything works - user refuses", args: []string{"test-term/1"}, answer: "n", stdout: ` === test-term/1: 0001-01-01 00:00:00 +0000 UTC === Test Terms ======== Do you agree to the displayed terms? (Y/n): You didn't agree to the presented terms. `, apiCalls: []jujutesting.StubCall{{ FuncName: "GetUnunsignedTerms", Args: []interface{}{ &terms.CheckAgreementsRequest{Terms: []string{"test-term/1"}}, }, }}, }, { about: "must not accept 0 revision", args: []string{"test-term/0", "--yes"}, err: `must specify a valid term revision "test-term/0"`, }, { about: "user accepts, multiple terms", args: []string{"test-term/1", "test-term/2"}, answer: "y", stdout: ` === test-term/1: 0001-01-01 00:00:00 +0000 UTC === Test Terms ======== Do you agree to the displayed terms? (Y/n): Agreed to revision 1 of test-term for Juju users `, apiCalls: []jujutesting.StubCall{ { FuncName: "GetUnunsignedTerms", Args: []interface{}{ &terms.CheckAgreementsRequest{Terms: []string{"test-term/1", "test-term/2"}}, }, }, { FuncName: "SaveAgreement", Args: []interface{}{ &terms.SaveAgreements{Agreements: []terms.SaveAgreement{ {TermName: "test-term", TermRevision: 1}, }}, }, }}, }, { about: "valid then unknown arguments", args: []string{"test-term/1", "unknown", "arguments"}, err: `must specify a valid term revision "unknown"`, }, { about: "user accepts all the terms", args: []string{"test-term/1", "test-term/2", "--yes"}, stdout: `Agreed to revision 1 of test-term for Juju users Agreed to revision 2 of test-term for Juju users `, apiCalls: []jujutesting.StubCall{ {FuncName: "SaveAgreement", Args: []interface{}{&terms.SaveAgreements{ Agreements: []terms.SaveAgreement{ {TermName: "test-term", TermRevision: 1}, {TermName: "test-term", TermRevision: 2}, }}}}}, }, } for i, test := range tests { s.client.ResetCalls() c.Logf("running test %d: %s", i, test.about) if test.answer != "" { answer = test.answer } ctx, err := cmdtesting.RunCommand(c, agree.NewAgreeCommand(), test.args...) if test.err != "" { c.Assert(err, gc.ErrorMatches, test.err) } else { c.Assert(err, jc.ErrorIsNil) } if ctx != nil { c.Assert(cmdtesting.Stdout(ctx), gc.Equals, test.stdout) } if len(test.apiCalls) > 0 { s.client.CheckCalls(c, test.apiCalls) } } }
func (s *HelpCommandSuite) assertStdOutMatches(c *gc.C, ctx *cmd.Context, match string) { stripped := strings.Replace(cmdtesting.Stdout(ctx), "\n", "", -1) c.Assert(stripped, gc.Matches, match) }