← Back to branch summary

~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

« back to all changes in this revision

Viewing changes to src/github.com/juju/juju/resource/api/server/server_addpending_test.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/juju/resource/api/server/server_addpending_test.go
7
7
        "github.com/juju/errors"
8
8
        jc "github.com/juju/testing/checkers"
9
9
        gc "gopkg.in/check.v1"
 
10
        charmresource "gopkg.in/juju/charm.v6-unstable/resource"
10
11
 
11
12
        "github.com/juju/juju/apiserver/params"
12
13
        "github.com/juju/juju/resource/api"
19
20
        BaseSuite
20
21
}
21
22
 
22
 
func (s *AddPendingResourcesSuite) TestOkay(c *gc.C) {
 
23
func (s *AddPendingResourcesSuite) TestNoURL(c *gc.C) {
23
24
        res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
24
25
        id1 := "some-unique-ID"
25
26
        s.data.ReturnAddPendingResource = id1
26
 
        facade := server.NewFacade(s.data)
 
27
        facade, err := server.NewFacade(s.data, s.newCSClient)
 
28
        c.Assert(err, jc.ErrorIsNil)
27
29
 
28
30
        result, err := facade.AddPendingResources(api.AddPendingResourcesArgs{
29
31
                Entity: params.Entity{
44
46
        })
45
47
}
46
48
 
47
 
func (s *AddPendingResourcesSuite) TestError(c *gc.C) {
 
49
func (s *AddPendingResourcesSuite) TestWithURLUpToDate(c *gc.C) {
 
50
        res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
 
51
        res1.Origin = charmresource.OriginStore
 
52
        res1.Revision = 3
 
53
        apiRes1.Origin = charmresource.OriginStore.String()
 
54
        apiRes1.Revision = 3
 
55
        id1 := "some-unique-ID"
 
56
        s.data.ReturnAddPendingResource = id1
 
57
        s.csClient.ReturnListResources = [][]charmresource.Resource{{
 
58
                res1.Resource,
 
59
        }}
 
60
        facade, err := server.NewFacade(s.data, s.newCSClient)
 
61
        c.Assert(err, jc.ErrorIsNil)
 
62
 
 
63
        result, err := facade.AddPendingResources(api.AddPendingResourcesArgs{
 
64
                Entity: params.Entity{
 
65
                        Tag: "service-a-service",
 
66
                },
 
67
                AddCharmWithAuthorization: params.AddCharmWithAuthorization{
 
68
                        URL: "cs:~a-user/trusty/spam-5",
 
69
                },
 
70
                Resources: []api.CharmResource{
 
71
                        apiRes1.CharmResource,
 
72
                },
 
73
        })
 
74
        c.Assert(err, jc.ErrorIsNil)
 
75
        c.Assert(result.Error, gc.IsNil)
 
76
 
 
77
        s.stub.CheckCallNames(c, "newCSClient", "ListResources", "AddPendingResource")
 
78
        s.stub.CheckCall(c, 2, "AddPendingResource", "a-service", "", res1.Resource, nil)
 
79
        c.Check(result, jc.DeepEquals, api.AddPendingResourcesResult{
 
80
                PendingIDs: []string{
 
81
                        id1,
 
82
                },
 
83
        })
 
84
}
 
85
 
 
86
func (s *AddPendingResourcesSuite) TestWithURLMismatchComplete(c *gc.C) {
 
87
        res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
 
88
        res1.Origin = charmresource.OriginStore
 
89
        res1.Revision = 3
 
90
        apiRes1.Origin = charmresource.OriginStore.String()
 
91
        apiRes1.Revision = 3
 
92
        id1 := "some-unique-ID"
 
93
        s.data.ReturnAddPendingResource = id1
 
94
        csRes := res1 // a copy
 
95
        csRes.Revision = 2
 
96
        s.csClient.ReturnListResources = [][]charmresource.Resource{{
 
97
                csRes.Resource,
 
98
        }}
 
99
        facade, err := server.NewFacade(s.data, s.newCSClient)
 
100
        c.Assert(err, jc.ErrorIsNil)
 
101
 
 
102
        result, err := facade.AddPendingResources(api.AddPendingResourcesArgs{
 
103
                Entity: params.Entity{
 
104
                        Tag: "service-a-service",
 
105
                },
 
106
                AddCharmWithAuthorization: params.AddCharmWithAuthorization{
 
107
                        URL: "cs:~a-user/trusty/spam-5",
 
108
                },
 
109
                Resources: []api.CharmResource{
 
110
                        apiRes1.CharmResource,
 
111
                },
 
112
        })
 
113
        c.Assert(err, jc.ErrorIsNil)
 
114
        c.Assert(result.Error, gc.IsNil)
 
115
 
 
116
        s.stub.CheckCallNames(c, "newCSClient", "ListResources", "AddPendingResource")
 
117
        s.stub.CheckCall(c, 2, "AddPendingResource", "a-service", "", res1.Resource, nil)
 
118
        c.Check(result, jc.DeepEquals, api.AddPendingResourcesResult{
 
119
                PendingIDs: []string{
 
120
                        id1,
 
121
                },
 
122
        })
 
123
}
 
124
 
 
125
func (s *AddPendingResourcesSuite) TestWithURLMismatchIncomplete(c *gc.C) {
 
126
        res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
 
127
        res1.Origin = charmresource.OriginStore
 
128
        res1.Revision = 2
 
129
        apiRes1.Origin = charmresource.OriginStore.String()
 
130
        apiRes1.Revision = 3
 
131
        apiRes1.Fingerprint = nil
 
132
        apiRes1.Size = 0
 
133
        id1 := "some-unique-ID"
 
134
        s.data.ReturnAddPendingResource = id1
 
135
        csRes := res1 // a copy
 
136
        csRes.Revision = 2
 
137
        s.csClient.ReturnListResources = [][]charmresource.Resource{{
 
138
                csRes.Resource,
 
139
        }}
 
140
        expected := charmresource.Resource{
 
141
                Meta:        csRes.Meta,
 
142
                Origin:      charmresource.OriginStore,
 
143
                Revision:    3,
 
144
                Fingerprint: res1.Fingerprint,
 
145
                Size:        res1.Size,
 
146
        }
 
147
        s.csClient.ReturnGetResource = &expected
 
148
        facade, err := server.NewFacade(s.data, s.newCSClient)
 
149
        c.Assert(err, jc.ErrorIsNil)
 
150
 
 
151
        result, err := facade.AddPendingResources(api.AddPendingResourcesArgs{
 
152
                Entity: params.Entity{
 
153
                        Tag: "service-a-service",
 
154
                },
 
155
                AddCharmWithAuthorization: params.AddCharmWithAuthorization{
 
156
                        URL: "cs:~a-user/trusty/spam-5",
 
157
                },
 
158
                Resources: []api.CharmResource{
 
159
                        apiRes1.CharmResource,
 
160
                },
 
161
        })
 
162
        c.Assert(err, jc.ErrorIsNil)
 
163
 
 
164
        s.stub.CheckCallNames(c, "newCSClient", "ListResources", "GetResource", "AddPendingResource")
 
165
        s.stub.CheckCall(c, 3, "AddPendingResource", "a-service", "", expected, nil)
 
166
        c.Check(result, jc.DeepEquals, api.AddPendingResourcesResult{
 
167
                PendingIDs: []string{
 
168
                        id1,
 
169
                },
 
170
        })
 
171
}
 
172
 
 
173
func (s *AddPendingResourcesSuite) TestWithURLNoRevision(c *gc.C) {
 
174
        res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
 
175
        res1.Origin = charmresource.OriginStore
 
176
        res1.Revision = 3
 
177
        res1.Size = 10
 
178
        apiRes1.Origin = charmresource.OriginStore.String()
 
179
        apiRes1.Revision = -1
 
180
        apiRes1.Size = 0
 
181
        apiRes1.Fingerprint = nil
 
182
        id1 := "some-unique-ID"
 
183
        s.data.ReturnAddPendingResource = id1
 
184
        csRes := res1 // a copy
 
185
        csRes.Revision = 3
 
186
        csRes.Size = 10
 
187
        s.csClient.ReturnListResources = [][]charmresource.Resource{{
 
188
                csRes.Resource,
 
189
        }}
 
190
        facade, err := server.NewFacade(s.data, s.newCSClient)
 
191
        c.Assert(err, jc.ErrorIsNil)
 
192
 
 
193
        result, err := facade.AddPendingResources(api.AddPendingResourcesArgs{
 
194
                Entity: params.Entity{
 
195
                        Tag: "service-a-service",
 
196
                },
 
197
                AddCharmWithAuthorization: params.AddCharmWithAuthorization{
 
198
                        URL: "cs:~a-user/trusty/spam-5",
 
199
                },
 
200
                Resources: []api.CharmResource{
 
201
                        apiRes1.CharmResource,
 
202
                },
 
203
        })
 
204
        c.Assert(err, jc.ErrorIsNil)
 
205
        c.Assert(result.Error, gc.IsNil)
 
206
 
 
207
        s.stub.CheckCallNames(c, "newCSClient", "ListResources", "AddPendingResource")
 
208
        s.stub.CheckCall(c, 2, "AddPendingResource", "a-service", "", res1.Resource, nil)
 
209
        c.Check(result, jc.DeepEquals, api.AddPendingResourcesResult{
 
210
                PendingIDs: []string{
 
211
                        id1,
 
212
                },
 
213
        })
 
214
}
 
215
 
 
216
func (s *AddPendingResourcesSuite) TestWithURLUpload(c *gc.C) {
 
217
        res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
 
218
        res1.Origin = charmresource.OriginUpload
 
219
        res1.Revision = 0
 
220
        apiRes1.Origin = charmresource.OriginUpload.String()
 
221
        apiRes1.Revision = 0
 
222
        id1 := "some-unique-ID"
 
223
        s.data.ReturnAddPendingResource = id1
 
224
        csRes := res1 // a copy
 
225
        csRes.Origin = charmresource.OriginStore
 
226
        csRes.Revision = 3
 
227
        s.csClient.ReturnListResources = [][]charmresource.Resource{{
 
228
                csRes.Resource,
 
229
        }}
 
230
        facade, err := server.NewFacade(s.data, s.newCSClient)
 
231
        c.Assert(err, jc.ErrorIsNil)
 
232
 
 
233
        result, err := facade.AddPendingResources(api.AddPendingResourcesArgs{
 
234
                Entity: params.Entity{
 
235
                        Tag: "service-a-service",
 
236
                },
 
237
                AddCharmWithAuthorization: params.AddCharmWithAuthorization{
 
238
                        URL: "cs:~a-user/trusty/spam-5",
 
239
                },
 
240
                Resources: []api.CharmResource{
 
241
                        apiRes1.CharmResource,
 
242
                },
 
243
        })
 
244
        c.Assert(err, jc.ErrorIsNil)
 
245
        c.Assert(result.Error, gc.IsNil)
 
246
 
 
247
        s.stub.CheckCallNames(c, "newCSClient", "ListResources", "AddPendingResource")
 
248
        s.stub.CheckCall(c, 2, "AddPendingResource", "a-service", "", res1.Resource, nil)
 
249
        c.Check(result, jc.DeepEquals, api.AddPendingResourcesResult{
 
250
                PendingIDs: []string{
 
251
                        id1,
 
252
                },
 
253
        })
 
254
}
 
255
 
 
256
// TODO(ericsnow) Once the CS API has ListResources() implemented:
 
257
//func (s *AddPendingResourcesSuite) TestUnknownResource(c *gc.C) {
 
258
//      _, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
 
259
//      apiRes1.Origin = charmresource.OriginStore.String()
 
260
//      facade, err := server.NewFacade(s.data, s.newCSClient)
 
261
//      c.Assert(err, jc.ErrorIsNil)
 
262
//
 
263
//      result, err := facade.AddPendingResources(api.AddPendingResourcesArgs{
 
264
//              Entity: params.Entity{
 
265
//                      Tag: "service-a-service",
 
266
//              },
 
267
//              AddCharmWithAuthorization: params.AddCharmWithAuthorization{
 
268
//                      URL: "cs:~a-user/trusty/spam-5",
 
269
//              },
 
270
//              Resources: []api.CharmResource{
 
271
//                      apiRes1.CharmResource,
 
272
//              },
 
273
//      })
 
274
//      c.Assert(err, jc.ErrorIsNil)
 
275
//
 
276
//      s.stub.CheckCallNames(c, "newCSClient", "ListResources")
 
277
//      c.Check(result, jc.DeepEquals, api.AddPendingResourcesResult{
 
278
//              ErrorResult: params.ErrorResult{Error: &params.Error{
 
279
//                      Message: `charm store resource "spam" not found`,
 
280
//                      Code:    params.CodeNotFound,
 
281
//              }},
 
282
//      })
 
283
//}
 
284
 
 
285
func (s *AddPendingResourcesSuite) TestUnknownResource(c *gc.C) {
 
286
        res1, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
 
287
        res1.Origin = charmresource.OriginStore
 
288
        res1.Revision = 3
 
289
        apiRes1.Origin = charmresource.OriginStore.String()
 
290
        apiRes1.Revision = 3
 
291
        id1 := "some-unique-ID"
 
292
        s.data.ReturnAddPendingResource = id1
 
293
        s.csClient.ReturnListResources = [][]charmresource.Resource{{
 
294
                res1.Resource,
 
295
        }}
 
296
        facade, err := server.NewFacade(s.data, s.newCSClient)
 
297
        c.Assert(err, jc.ErrorIsNil)
 
298
 
 
299
        result, err := facade.AddPendingResources(api.AddPendingResourcesArgs{
 
300
                Entity: params.Entity{
 
301
                        Tag: "service-a-service",
 
302
                },
 
303
                AddCharmWithAuthorization: params.AddCharmWithAuthorization{
 
304
                        URL: "cs:~a-user/trusty/spam-5",
 
305
                },
 
306
                Resources: []api.CharmResource{
 
307
                        apiRes1.CharmResource,
 
308
                },
 
309
        })
 
310
        c.Assert(err, jc.ErrorIsNil)
 
311
 
 
312
        s.stub.CheckCallNames(c, "newCSClient", "ListResources", "AddPendingResource")
 
313
        s.stub.CheckCall(c, 2, "AddPendingResource", "a-service", "", res1.Resource, nil)
 
314
        c.Check(result, jc.DeepEquals, api.AddPendingResourcesResult{
 
315
                PendingIDs: []string{
 
316
                        id1,
 
317
                },
 
318
        })
 
319
}
 
320
 
 
321
func (s *AddPendingResourcesSuite) TestDataStoreError(c *gc.C) {
48
322
        _, apiRes1 := newResource(c, "spam", "a-user", "spamspamspam")
49
323
        failure := errors.New("<failure>")
50
324
        s.stub.SetErrors(failure)
51
 
        facade := server.NewFacade(s.data)
 
325
        facade, err := server.NewFacade(s.data, s.newCSClient)
 
326
        c.Assert(err, jc.ErrorIsNil)
52
327
 
53
328
        result, err := facade.AddPendingResources(api.AddPendingResourcesArgs{
54
329
                Entity: params.Entity{