// RegisterAll registers all romulus commands with the
// provided command registry.
func RegisterAll(r commandRegister) {
r.Register(agree.NewAgreeCommand())
r.Register(allocate.NewAllocateCommand())
r.Register(createbudget.NewCreateBudgetCommand())
r.Register(listbudgets.NewListBudgetsCommand())
r.Register(listplans.NewListPlansCommand())
r.Register(setbudget.NewSetBudgetCommand())
r.Register(setplan.NewSetPlanCommand())
r.Register(showbudget.NewShowBudgetCommand())
r.Register(updateallocation.NewUpdateAllocationCommand())
}
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
`)
}
// RegisterAll registers all romulus commands with the
// provided command registry.
func RegisterAll(r commandRegister) {
register := func(c cmd.Command) {
switch c := c.(type) {
case modelcmd.ModelCommand:
r.Register(modelcmd.Wrap(c))
case modelcmd.CommandBase:
r.Register(modelcmd.WrapBase(c))
default:
r.Register(c)
}
}
register(agree.NewAgreeCommand())
register(listagreements.NewListAgreementsCommand())
register(allocate.NewAllocateCommand())
register(listbudgets.NewListBudgetsCommand())
register(createbudget.NewCreateBudgetCommand())
register(listplans.NewListPlansCommand())
register(setbudget.NewSetBudgetCommand())
register(setplan.NewSetPlanCommand())
register(showbudget.NewShowBudgetCommand())
register(updateallocation.NewUpdateAllocationCommand())
}
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)
}
}
}