← 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/cmd/deploy_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/cmd/deploy_test.go
12
12
        "github.com/juju/testing"
13
13
        jc "github.com/juju/testing/checkers"
14
14
        gc "gopkg.in/check.v1"
 
15
        "gopkg.in/juju/charm.v6-unstable"
15
16
        charmresource "gopkg.in/juju/charm.v6-unstable/resource"
 
17
        "gopkg.in/macaroon.v1"
16
18
)
17
19
 
18
20
type DeploySuite struct {
29
31
        s.stub = &testing.Stub{}
30
32
}
31
33
 
32
 
func (s DeploySuite) TestUploadOK(c *gc.C) {
33
 
        deps := uploadDeps{s.stub, rsc{&bytes.Buffer{}}}
34
 
        du := deployUploader{
35
 
                serviceID: "mysql",
36
 
                client:    deps,
37
 
                resources: map[string]charmresource.Meta{
38
 
                        "upload": {
39
 
                                Name: "upload",
40
 
                                Type: charmresource.TypeFile,
41
 
                                Path: "upload",
42
 
                        },
43
 
                        "store": {
44
 
                                Name: "store",
45
 
                                Type: charmresource.TypeFile,
46
 
                                Path: "store",
47
 
                        },
48
 
                },
49
 
                osOpen: deps.Open,
50
 
                osStat: deps.Stat,
51
 
        }
52
 
 
53
 
        files := map[string]string{
54
 
                "upload": "foobar.txt",
55
 
        }
56
 
        ids, err := du.upload(files)
57
 
        c.Assert(err, jc.ErrorIsNil)
58
 
        c.Check(ids, gc.DeepEquals, map[string]string{
59
 
                "upload": "id-upload",
60
 
                "store":  "id-store",
61
 
        })
62
 
 
63
 
        expectedStore := []charmresource.Resource{
64
 
                {
65
 
                        Meta:   du.resources["store"],
66
 
                        Origin: charmresource.OriginStore,
67
 
                },
68
 
        }
69
 
        s.stub.CheckCall(c, 1, "AddPendingResources", "mysql", expectedStore)
70
 
        s.stub.CheckCall(c, 2, "Open", "foobar.txt")
71
 
 
72
 
        expectedUpload := charmresource.Resource{
73
 
                Meta:   du.resources["upload"],
74
 
                Origin: charmresource.OriginUpload,
75
 
        }
76
 
        s.stub.CheckCall(c, 3, "AddPendingResource", "mysql", expectedUpload, deps.ReadSeekCloser)
77
 
}
78
 
 
79
 
func (s DeploySuite) TestUploadUnexpectedResource(c *gc.C) {
 
34
func (s DeploySuite) TestDeployResourcesWithoutFiles(c *gc.C) {
 
35
        deps := uploadDeps{s.stub, rsc{&bytes.Buffer{}}}
 
36
        cURL := charm.MustParseURL("cs:~a-user/trusty/spam-5")
 
37
        csMac := &macaroon.Macaroon{}
 
38
        resources := map[string]charmresource.Meta{
 
39
                "store-tarball": {
 
40
                        Name: "store-tarball",
 
41
                        Type: charmresource.TypeFile,
 
42
                        Path: "store.tgz",
 
43
                },
 
44
                "store-zip": {
 
45
                        Name: "store-zip",
 
46
                        Type: charmresource.TypeFile,
 
47
                        Path: "store.zip",
 
48
                },
 
49
        }
 
50
 
 
51
        ids, err := DeployResources(DeployResourcesArgs{
 
52
                ServiceID:          "mysql",
 
53
                CharmURL:           cURL,
 
54
                CharmStoreMacaroon: csMac,
 
55
                Filenames:          nil,
 
56
                Client:             deps,
 
57
                ResourcesMeta:      resources,
 
58
        })
 
59
        c.Assert(err, jc.ErrorIsNil)
 
60
 
 
61
        c.Check(ids, gc.DeepEquals, map[string]string{
 
62
                "store-tarball": "id-store-tarball",
 
63
                "store-zip":     "id-store-zip",
 
64
        })
 
65
 
 
66
        s.stub.CheckCallNames(c, "AddPendingResources")
 
67
        s.stub.CheckCall(c, 0, "AddPendingResources", "mysql", cURL, csMac, []charmresource.Resource{{
 
68
                Meta:     resources["store-tarball"],
 
69
                Origin:   charmresource.OriginStore,
 
70
                Revision: -1,
 
71
        }, {
 
72
                Meta:     resources["store-zip"],
 
73
                Origin:   charmresource.OriginStore,
 
74
                Revision: -1,
 
75
        }})
 
76
}
 
77
 
 
78
func (s DeploySuite) TestUploadFilesOnly(c *gc.C) {
 
79
        deps := uploadDeps{s.stub, rsc{&bytes.Buffer{}}}
 
80
        cURL := charm.MustParseURL("cs:~a-user/trusty/spam-5")
 
81
        csMac := &macaroon.Macaroon{}
 
82
        du := deployUploader{
 
83
                serviceID: "mysql",
 
84
                cURL:      cURL,
 
85
                csMac:     csMac,
 
86
                client:    deps,
 
87
                resources: map[string]charmresource.Meta{
 
88
                        "upload": {
 
89
                                Name: "upload",
 
90
                                Type: charmresource.TypeFile,
 
91
                                Path: "upload",
 
92
                        },
 
93
                        "store": {
 
94
                                Name: "store",
 
95
                                Type: charmresource.TypeFile,
 
96
                                Path: "store",
 
97
                        },
 
98
                },
 
99
                osOpen: deps.Open,
 
100
                osStat: deps.Stat,
 
101
        }
 
102
 
 
103
        files := map[string]string{
 
104
                "upload": "foobar.txt",
 
105
        }
 
106
        revisions := map[string]int{}
 
107
        ids, err := du.upload(files, revisions)
 
108
        c.Assert(err, jc.ErrorIsNil)
 
109
        c.Check(ids, gc.DeepEquals, map[string]string{
 
110
                "upload": "id-upload",
 
111
                "store":  "id-store",
 
112
        })
 
113
 
 
114
        s.stub.CheckCallNames(c, "Stat", "AddPendingResources", "Open", "AddPendingResource")
 
115
        expectedStore := []charmresource.Resource{
 
116
                {
 
117
                        Meta:     du.resources["store"],
 
118
                        Origin:   charmresource.OriginStore,
 
119
                        Revision: -1,
 
120
                },
 
121
        }
 
122
        s.stub.CheckCall(c, 1, "AddPendingResources", "mysql", cURL, csMac, expectedStore)
 
123
        s.stub.CheckCall(c, 2, "Open", "foobar.txt")
 
124
 
 
125
        expectedUpload := charmresource.Resource{
 
126
                Meta:   du.resources["upload"],
 
127
                Origin: charmresource.OriginUpload,
 
128
        }
 
129
        s.stub.CheckCall(c, 3, "AddPendingResource", "mysql", expectedUpload, "foobar.txt", deps.ReadSeekCloser)
 
130
}
 
131
 
 
132
func (s DeploySuite) TestUploadRevisionsOnly(c *gc.C) {
 
133
        deps := uploadDeps{s.stub, rsc{&bytes.Buffer{}}}
 
134
        cURL := charm.MustParseURL("cs:~a-user/trusty/spam-5")
 
135
        csMac := &macaroon.Macaroon{}
 
136
        du := deployUploader{
 
137
                serviceID: "mysql",
 
138
                cURL:      cURL,
 
139
                csMac:     csMac,
 
140
                client:    deps,
 
141
                resources: map[string]charmresource.Meta{
 
142
                        "upload": {
 
143
                                Name: "upload",
 
144
                                Type: charmresource.TypeFile,
 
145
                                Path: "upload",
 
146
                        },
 
147
                        "store": {
 
148
                                Name: "store",
 
149
                                Type: charmresource.TypeFile,
 
150
                                Path: "store",
 
151
                        },
 
152
                },
 
153
                osOpen: deps.Open,
 
154
                osStat: deps.Stat,
 
155
        }
 
156
 
 
157
        files := map[string]string{}
 
158
        revisions := map[string]int{
 
159
                "store": 3,
 
160
        }
 
161
        ids, err := du.upload(files, revisions)
 
162
        c.Assert(err, jc.ErrorIsNil)
 
163
        c.Check(ids, gc.DeepEquals, map[string]string{
 
164
                "upload": "id-upload",
 
165
                "store":  "id-store",
 
166
        })
 
167
 
 
168
        s.stub.CheckCallNames(c, "AddPendingResources")
 
169
        expectedStore := []charmresource.Resource{{
 
170
                Meta:     du.resources["store"],
 
171
                Origin:   charmresource.OriginStore,
 
172
                Revision: 3,
 
173
        }, {
 
174
                Meta:     du.resources["upload"],
 
175
                Origin:   charmresource.OriginStore,
 
176
                Revision: -1,
 
177
        }}
 
178
        s.stub.CheckCall(c, 0, "AddPendingResources", "mysql", cURL, csMac, expectedStore)
 
179
}
 
180
 
 
181
func (s DeploySuite) TestUploadFilesAndRevisions(c *gc.C) {
 
182
        deps := uploadDeps{s.stub, rsc{&bytes.Buffer{}}}
 
183
        cURL := charm.MustParseURL("cs:~a-user/trusty/spam-5")
 
184
        csMac := &macaroon.Macaroon{}
 
185
        du := deployUploader{
 
186
                serviceID: "mysql",
 
187
                cURL:      cURL,
 
188
                csMac:     csMac,
 
189
                client:    deps,
 
190
                resources: map[string]charmresource.Meta{
 
191
                        "upload": {
 
192
                                Name: "upload",
 
193
                                Type: charmresource.TypeFile,
 
194
                                Path: "upload",
 
195
                        },
 
196
                        "store": {
 
197
                                Name: "store",
 
198
                                Type: charmresource.TypeFile,
 
199
                                Path: "store",
 
200
                        },
 
201
                },
 
202
                osOpen: deps.Open,
 
203
                osStat: deps.Stat,
 
204
        }
 
205
 
 
206
        files := map[string]string{
 
207
                "upload": "foobar.txt",
 
208
        }
 
209
        revisions := map[string]int{
 
210
                "store": 3,
 
211
        }
 
212
        ids, err := du.upload(files, revisions)
 
213
        c.Assert(err, jc.ErrorIsNil)
 
214
        c.Check(ids, gc.DeepEquals, map[string]string{
 
215
                "upload": "id-upload",
 
216
                "store":  "id-store",
 
217
        })
 
218
 
 
219
        s.stub.CheckCallNames(c, "Stat", "AddPendingResources", "Open", "AddPendingResource")
 
220
        expectedStore := []charmresource.Resource{
 
221
                {
 
222
                        Meta:     du.resources["store"],
 
223
                        Origin:   charmresource.OriginStore,
 
224
                        Revision: 3,
 
225
                },
 
226
        }
 
227
        s.stub.CheckCall(c, 1, "AddPendingResources", "mysql", cURL, csMac, expectedStore)
 
228
        s.stub.CheckCall(c, 2, "Open", "foobar.txt")
 
229
 
 
230
        expectedUpload := charmresource.Resource{
 
231
                Meta:   du.resources["upload"],
 
232
                Origin: charmresource.OriginUpload,
 
233
        }
 
234
        s.stub.CheckCall(c, 3, "AddPendingResource", "mysql", expectedUpload, "foobar.txt", deps.ReadSeekCloser)
 
235
}
 
236
 
 
237
func (s DeploySuite) TestUploadUnexpectedResourceFile(c *gc.C) {
80
238
        deps := uploadDeps{s.stub, rsc{&bytes.Buffer{}}}
81
239
        du := deployUploader{
82
240
                serviceID: "mysql",
93
251
        }
94
252
 
95
253
        files := map[string]string{"some bad resource": "foobar.txt"}
96
 
        _, err := du.upload(files)
 
254
        revisions := map[string]int{}
 
255
        _, err := du.upload(files, revisions)
 
256
        c.Check(err, gc.ErrorMatches, `unrecognized resource "some bad resource"`)
 
257
 
 
258
        s.stub.CheckNoCalls(c)
 
259
}
 
260
 
 
261
func (s DeploySuite) TestUploadUnexpectedResourceRevision(c *gc.C) {
 
262
        deps := uploadDeps{s.stub, rsc{&bytes.Buffer{}}}
 
263
        du := deployUploader{
 
264
                serviceID: "mysql",
 
265
                client:    deps,
 
266
                resources: map[string]charmresource.Meta{
 
267
                        "res1": {
 
268
                                Name: "res1",
 
269
                                Type: charmresource.TypeFile,
 
270
                                Path: "path",
 
271
                        },
 
272
                },
 
273
                osOpen: deps.Open,
 
274
                osStat: deps.Stat,
 
275
        }
 
276
 
 
277
        files := map[string]string{}
 
278
        revisions := map[string]int{"some bad resource": 2}
 
279
        _, err := du.upload(files, revisions)
97
280
        c.Check(err, gc.ErrorMatches, `unrecognized resource "some bad resource"`)
98
281
 
99
282
        s.stub.CheckNoCalls(c)
119
302
        s.stub.SetErrors(os.ErrNotExist)
120
303
 
121
304
        files := map[string]string{"res1": "foobar.txt"}
122
 
        _, err := du.upload(files)
 
305
        revisions := map[string]int{}
 
306
        _, err := du.upload(files, revisions)
123
307
        c.Check(err, gc.ErrorMatches, `file for resource "res1".*`)
124
308
        c.Check(errors.Cause(err), jc.Satisfies, os.IsNotExist)
125
309
}
129
313
        ReadSeekCloser ReadSeekCloser
130
314
}
131
315
 
132
 
func (s uploadDeps) AddPendingResources(serviceID string, resources []charmresource.Resource) (ids []string, err error) {
133
 
        s.stub.AddCall("AddPendingResources", serviceID, resources)
 
316
func (s uploadDeps) AddPendingResources(serviceID string, cURL *charm.URL, csMac *macaroon.Macaroon, resources []charmresource.Resource) (ids []string, err error) {
 
317
        charmresource.Sort(resources)
 
318
        s.stub.AddCall("AddPendingResources", serviceID, cURL, csMac, resources)
134
319
        if err := s.stub.NextErr(); err != nil {
135
320
                return nil, err
136
321
        }
141
326
        return ids, nil
142
327
}
143
328
 
144
 
func (s uploadDeps) AddPendingResource(serviceID string, resource charmresource.Resource, r io.ReadSeeker) (id string, err error) {
145
 
        s.stub.AddCall("AddPendingResource", serviceID, resource, r)
 
329
func (s uploadDeps) AddPendingResource(serviceID string, resource charmresource.Resource, filename string, r io.ReadSeeker) (id string, err error) {
 
330
        s.stub.AddCall("AddPendingResource", serviceID, resource, filename, r)
146
331
        if err := s.stub.NextErr(); err != nil {
147
332
                return "", err
148
333
        }