func opClientModelSet(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
args := map[string]interface{}{"some-key": "some-value"}
err := modelconfig.NewClient(st).ModelSet(args)
if err != nil {
return func() {}, err
}
return func() {
args["some-key"] = nil
modelconfig.NewClient(st).ModelSet(args)
}, nil
}
func opClientModelGet(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
_, err := modelconfig.NewClient(st).ModelGet()
if err != nil {
return func() {}, err
}
return func() {}, nil
}
func (s *modelconfigSuite) TestModelGetWithMetadata(c *gc.C) {
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, result interface{},
) error {
c.Check(objType, gc.Equals, "ModelConfig")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "ModelGet")
c.Check(a, gc.IsNil)
c.Assert(result, gc.FitsTypeOf, ¶ms.ModelConfigResults{})
results := result.(*params.ModelConfigResults)
results.Config = map[string]params.ConfigValue{
"foo": {"bar", "model"},
}
return nil
},
)
client := modelconfig.NewClient(apiCaller)
result, err := client.ModelGetWithMetadata()
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, jc.DeepEquals, config.ConfigValues{
"foo": {"bar", "model"},
})
}
func (s *modelconfigSuite) TestModelSet(c *gc.C) {
called := false
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, result interface{},
) error {
c.Check(objType, gc.Equals, "ModelConfig")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "ModelSet")
c.Check(a, jc.DeepEquals, params.ModelSet{
Config: map[string]interface{}{
"some-name": "value",
"other-name": true,
},
})
called = true
return nil
},
)
client := modelconfig.NewClient(apiCaller)
err := client.ModelSet(map[string]interface{}{
"some-name": "value",
"other-name": true,
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(called, jc.IsTrue)
}
func NewDeployCommandWithDefaultAPI(steps []DeployStep) cmd.Command {
deployCmd := &DeployCommand{Steps: steps}
cmd := modelcmd.Wrap(deployCmd)
deployCmd.NewAPIRoot = func() (DeployAPI, error) {
apiRoot, err := deployCmd.ModelCommandBase.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
bakeryClient, err := deployCmd.BakeryClient()
if err != nil {
return nil, errors.Trace(err)
}
cstoreClient := newCharmStoreClient(bakeryClient).WithChannel(deployCmd.Channel)
adapter := &deployAPIAdapter{
Connection: apiRoot,
apiClient: &apiClient{Client: apiRoot.Client()},
charmsClient: &charmsClient{Client: apicharms.NewClient(apiRoot)},
applicationClient: &applicationClient{Client: application.NewClient(apiRoot)},
modelConfigClient: &modelConfigClient{Client: modelconfig.NewClient(apiRoot)},
charmstoreClient: &charmstoreClient{Client: cstoreClient},
annotationsClient: &annotationsClient{Client: annotations.NewClient(apiRoot)},
charmRepoClient: &charmRepoClient{CharmStore: charmrepo.NewCharmStoreFromClient(cstoreClient)},
}
return adapter, nil
}
return cmd
}
// getAPI returns the API. This allows passing in a test configCommandAPI
// implementation.
func (c *configCommand) getAPI() (configCommandAPI, error) {
if c.api != nil {
return c.api, nil
}
api, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Annotate(err, "opening API connection")
}
client := modelconfig.NewClient(api)
return client, nil
}
func (c *addCommand) getModelConfigAPI() (ModelConfigAPI, error) {
if c.modelConfigAPI != nil {
return c.modelConfigAPI, nil
}
api, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Annotate(err, "opening API connection")
}
return modelconfig.NewClient(api), nil
}
func opClientSetModelAgentVersion(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
attrs, err := modelconfig.NewClient(st).ModelGet()
if err != nil {
return func() {}, err
}
ver := version.Number{Major: 1, Minor: 2, Patch: 3}
err = st.Client().SetModelAgentVersion(ver)
if err != nil {
return func() {}, err
}
return func() {
oldAgentVersion, found := attrs["agent-version"]
if found {
versionString := oldAgentVersion.(string)
st.Client().SetModelAgentVersion(version.MustParse(versionString))
}
}, nil
}
func (s *modelconfigSuite) TestModelUnset(c *gc.C) {
called := false
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, result interface{},
) error {
c.Check(objType, gc.Equals, "ModelConfig")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "ModelUnset")
c.Check(a, jc.DeepEquals, params.ModelUnset{
Keys: []string{"foo", "bar"},
})
called = true
return nil
},
)
client := modelconfig.NewClient(apiCaller)
err := client.ModelUnset("foo", "bar")
c.Assert(err, jc.ErrorIsNil)
c.Assert(called, jc.IsTrue)
}
func (s *RemoveCharmStoreCharmsSuite) SetUpTest(c *gc.C) {
s.charmStoreSuite.SetUpTest(c)
s.ctx = testing.Context(c)
s.stub = &jutesting.Stub{}
s.budgetAPIClient = &mockBudgetAPIClient{Stub: s.stub}
s.PatchValue(&getBudgetAPIClient, func(*httpbakery.Client) budgetAPIClient { return s.budgetAPIClient })
testcharms.UploadCharm(c, s.client, "cs:quantal/metered-1", "metered")
deployCmd := &DeployCommand{}
cmd := modelcmd.Wrap(deployCmd)
deployCmd.NewAPIRoot = func() (DeployAPI, error) {
apiRoot, err := deployCmd.ModelCommandBase.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
bakeryClient, err := deployCmd.BakeryClient()
if err != nil {
return nil, errors.Trace(err)
}
cstoreClient := newCharmStoreClient(bakeryClient).WithChannel(deployCmd.Channel)
return &deployAPIAdapter{
Connection: apiRoot,
apiClient: &apiClient{Client: apiRoot.Client()},
charmsClient: &charmsClient{Client: charms.NewClient(apiRoot)},
applicationClient: &applicationClient{Client: application.NewClient(apiRoot)},
modelConfigClient: &modelConfigClient{Client: modelconfig.NewClient(apiRoot)},
charmstoreClient: &charmstoreClient{Client: cstoreClient},
annotationsClient: &annotationsClient{Client: annotations.NewClient(apiRoot)},
charmRepoClient: &charmRepoClient{CharmStore: charmrepo.NewCharmStoreFromClient(cstoreClient)},
}, nil
}
_, err := testing.RunCommand(c, cmd, "cs:quantal/metered-1")
c.Assert(err, jc.ErrorIsNil)
}
// NewUpgradeCharmCommand returns a command which upgrades application's charm.
func NewUpgradeCharmCommand() cmd.Command {
cmd := &upgradeCharmCommand{
DeployResources: resourceadapters.DeployResources,
ResolveCharm: resolveCharm,
NewCharmAdder: newCharmAdder,
NewCharmClient: func(conn api.Connection) CharmClient {
return charms.NewClient(conn)
},
NewCharmUpgradeClient: func(conn api.Connection) CharmUpgradeClient {
return application.NewClient(conn)
},
NewModelConfigGetter: func(conn api.Connection) ModelConfigGetter {
return modelconfig.NewClient(conn)
},
NewResourceLister: func(conn api.Connection) (ResourceLister, error) {
resclient, err := resourceadapters.NewAPIClient(conn)
if err != nil {
return nil, err
}
return resclient, nil
},
}
return modelcmd.Wrap(cmd)
}
type controllerAPI interface {
ModelConfig() (map[string]interface{}, error)
Close() error
}
var getUpgradeJujuAPI = func(c *upgradeJujuCommand) (upgradeJujuAPI, error) {
return c.NewAPIClient()
}
var getModelConfigAPI = func(c *upgradeJujuCommand) (modelConfigAPI, error) {
api, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return modelconfig.NewClient(api), nil
}
var getControllerAPI = func(c *upgradeJujuCommand) (controllerAPI, error) {
api, err := c.NewControllerAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return controller.NewClient(api), nil
}
// Run changes the version proposed for the juju envtools.
func (c *upgradeJujuCommand) Run(ctx *cmd.Context) (err error) {
client, err := getUpgradeJujuAPI(c)
if err != nil {
