func (d *serviceDeployer) newAnnotationsAPIClient() (*apiannotations.Client, error) {
root, err := d.api.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return apiannotations.NewClient(root), nil
}
func (c *DeployCommand) newAnnotationsAPIClient() (*apiannotations.Client, error) {
root, err := c.NewAPIRoot()
if err != nil {
return nil, errors.Trace(err)
}
return apiannotations.NewClient(root), nil
}
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
}
func (s *annotationsMockSuite) TestGetEntitiesAnnotations(c *gc.C) {
var called bool
apiCaller := basetesting.APICallerFunc(
func(
objType string,
version int,
id, request string,
a, response interface{}) error {
called = true
c.Check(objType, gc.Equals, "Annotations")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "Get")
args, ok := a.(params.Entities)
c.Assert(ok, jc.IsTrue)
c.Assert(args.Entities, gc.HasLen, 1)
c.Assert(args.Entities[0], gc.DeepEquals, params.Entity{"charm"})
result := response.(*params.AnnotationsGetResults)
facadeAnnts := map[string]string{
"annotations": "test",
}
entitiesAnnts := params.AnnotationsGetResult{
EntityTag: "charm",
Annotations: facadeAnnts,
}
result.Results = []params.AnnotationsGetResult{entitiesAnnts}
return nil
})
annotationsClient := annotations.NewClient(apiCaller)
found, err := annotationsClient.Get([]string{"charm"})
c.Assert(err, jc.ErrorIsNil)
c.Assert(called, jc.IsTrue)
c.Assert(found, gc.HasLen, 1)
}
func opClientSetAnnotations(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
pairs := map[string]string{"key1": "value1", "key2": "value2"}
setParams := map[string]map[string]string{
"application-wordpress": pairs,
}
_, err := annotations.NewClient(st).Set(setParams)
if err != nil {
return func() {}, err
}
return func() {
pairs := map[string]string{"key1": "", "key2": ""}
setParams := map[string]map[string]string{
"application-wordpress": pairs,
}
annotations.NewClient(st).Set(setParams)
}, nil
}
func opClientGetAnnotations(c *gc.C, st api.Connection, mst *state.State) (func(), error) {
ann, err := annotations.NewClient(st).Get([]string{"application-wordpress"})
if err != nil {
return func() {}, err
}
c.Assert(ann, gc.DeepEquals, []params.AnnotationsGetResult{{
EntityTag: "application-wordpress",
Annotations: map[string]string{},
}})
return func() {}, nil
}
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)
}
func (s *annotationsMockSuite) TestSetEntitiesAnnotation(c *gc.C) {
var called bool
annts := map[string]string{"annotation1": "test"}
annts2 := map[string]string{"annotation2": "test"}
setParams := map[string]map[string]string{
"charmA": annts,
"serviceB": annts2,
}
apiCaller := basetesting.APICallerFunc(
func(objType string,
version int,
id, request string,
a, result interface{},
) error {
called = true
c.Check(objType, gc.Equals, "Annotations")
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, "Set")
args, ok := a.(params.AnnotationsSet)
c.Assert(ok, jc.IsTrue)
for _, aParam := range args.Annotations {
// Since sometimes arrays returned on some
// architectures vary the order within params.AnnotationsSet,
// simply assert that each entity has its own annotations.
// Bug 1409141
c.Assert(aParam.Annotations, gc.DeepEquals, setParams[aParam.EntityTag])
}
return nil
})
annotationsClient := annotations.NewClient(apiCaller)
callErrs, err := annotationsClient.Set(setParams)
c.Assert(err, jc.ErrorIsNil)
c.Assert(callErrs, gc.HasLen, 0)
c.Assert(called, jc.IsTrue)
}
func (s *annotationsSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.annotationsClient = annotations.NewClient(s.APIState)
c.Assert(s.annotationsClient, gc.NotNil)
}