← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/gopkg.in/juju/charmstore.v5-unstable/internal/v4/content_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/gopkg.in/juju/charmstore.v5-unstable/internal/v4/content_test.go
19
19
        "gopkg.in/juju/charm.v6-unstable"
20
20
        "gopkg.in/juju/charmrepo.v2-unstable/csclient/params"
21
21
 
22
 
        "gopkg.in/juju/charmstore.v5-unstable/internal/charmstore"
23
22
        "gopkg.in/juju/charmstore.v5-unstable/internal/storetesting"
24
23
        "gopkg.in/juju/charmstore.v5-unstable/internal/v4"
25
24
)
35
34
        expectStatus: http.StatusNotFound,
36
35
        expectBody: params.Error{
37
36
                Code:    params.ErrNotFound,
38
 
                Message: `no matching charm or bundle for "cs:~charmers/bundle/foo-23"`,
 
37
                Message: `no matching charm or bundle for cs:~charmers/bundle/foo-23`,
39
38
        },
40
39
}, {
41
40
        about:        "diagram for a charm",
49
48
 
50
49
func (s *APISuite) TestServeDiagramErrors(c *gc.C) {
51
50
        id := newResolvedURL("cs:~charmers/trusty/wordpress-42", 42)
52
 
        s.addPublicCharm(c, "wordpress", id)
 
51
        s.addPublicCharmFromRepo(c, "wordpress", id)
53
52
        id = newResolvedURL("cs:~charmers/bundle/nopositionbundle-42", 42)
54
 
        s.addPublicBundle(c, "wordpress-simple", id)
 
53
        s.addPublicBundleFromRepo(c, "wordpress-simple", id, true)
55
54
 
56
55
        for i, test := range serveDiagramErrorsTests {
57
56
                c.Logf("test %d: %s", i, test.about)
65
64
}
66
65
 
67
66
func (s *APISuite) TestServeDiagram(c *gc.C) {
68
 
        bundle := &testingBundle{
69
 
                data: &charm.BundleData{
70
 
                        Services: map[string]*charm.ServiceSpec{
71
 
                                "wordpress": {
72
 
                                        Charm: "wordpress",
73
 
                                        Annotations: map[string]string{
74
 
                                                "gui-x": "100",
75
 
                                                "gui-y": "200",
76
 
                                        },
 
67
        bundle := storetesting.NewBundle(&charm.BundleData{
 
68
                Services: map[string]*charm.ServiceSpec{
 
69
                        "wordpress": {
 
70
                                Charm: "wordpress",
 
71
                                Annotations: map[string]string{
 
72
                                        "gui-x": "100",
 
73
                                        "gui-y": "200",
77
74
                                },
78
 
                                "mysql": {
79
 
                                        Charm: "utopic/mysql-23",
80
 
                                        Annotations: map[string]string{
81
 
                                                "gui-x": "200",
82
 
                                                "gui-y": "200",
83
 
                                        },
 
75
                        },
 
76
                        "mysql": {
 
77
                                Charm: "utopic/mysql-23",
 
78
                                Annotations: map[string]string{
 
79
                                        "gui-x": "200",
 
80
                                        "gui-y": "200",
84
81
                                },
85
82
                        },
86
83
                },
87
 
        }
 
84
        },
 
85
        )
88
86
 
89
87
        url := newResolvedURL("cs:~charmers/bundle/wordpressbundle-42", 42)
90
 
        err := s.store.AddBundle(bundle, charmstore.AddParams{
91
 
                URL:      url,
92
 
                BlobName: "blobName",
93
 
                BlobHash: fakeBlobHash,
94
 
                BlobSize: fakeBlobSize,
95
 
        })
96
 
        c.Assert(err, gc.IsNil)
97
 
        err = s.store.SetPerms(&url.URL, "read", params.Everyone, url.URL.User)
98
 
        c.Assert(err, gc.IsNil)
 
88
        s.addRequiredCharms(c, bundle)
 
89
        err := s.store.AddBundleWithArchive(url, bundle)
 
90
        c.Assert(err, gc.IsNil)
 
91
        s.setPublic(c, url)
99
92
 
100
93
        rec := httptesting.DoRequest(c, httptesting.DoRequestParams{
101
94
                Handler: s.srv,
137
130
}
138
131
 
139
132
func (s *APISuite) TestServeDiagramNoPosition(c *gc.C) {
140
 
        bundle := &testingBundle{
141
 
                data: &charm.BundleData{
 
133
        bundle := storetesting.NewBundle(
 
134
                &charm.BundleData{
142
135
                        Services: map[string]*charm.ServiceSpec{
143
136
                                "wordpress": {
144
137
                                        Charm: "wordpress",
151
144
                                        },
152
145
                                },
153
146
                        },
154
 
                },
155
 
        }
 
147
                })
156
148
 
157
149
        url := newResolvedURL("cs:~charmers/bundle/wordpressbundle-42", 42)
158
 
        err := s.store.AddBundle(bundle, charmstore.AddParams{
159
 
                URL:      url,
160
 
                BlobName: "blobName",
161
 
                BlobHash: fakeBlobHash,
162
 
                BlobSize: fakeBlobSize,
163
 
        })
164
 
        c.Assert(err, gc.IsNil)
165
 
        err = s.store.SetPerms(&url.URL, "read", params.Everyone, url.URL.User)
166
 
        c.Assert(err, gc.IsNil)
 
150
        s.addRequiredCharms(c, bundle)
 
151
        err := s.store.AddBundleWithArchive(url, bundle)
 
152
        c.Assert(err, gc.IsNil)
 
153
        s.setPublic(c, url)
167
154
 
168
155
        rec := httptesting.DoRequest(c, httptesting.DoRequestParams{
169
156
                Handler: s.srv,
218
205
                }
219
206
 
220
207
                url.URL.Revision = i
221
 
                err := s.store.AddCharmWithArchive(url, wordpress)
222
 
                c.Assert(err, gc.IsNil)
223
 
                err = s.store.SetPerms(&url.URL, "read", params.Everyone, url.URL.User)
224
 
                c.Assert(err, gc.IsNil)
 
208
                s.addPublicCharm(c, wordpress, url)
225
209
 
226
210
                rec := httptesting.DoRequest(c, httptesting.DoRequestParams{
227
211
                        Handler: s.srv,
256
240
        url := newResolvedURL("cs:~charmers/precise/wordpress-0", -1)
257
241
        err := s.store.AddCharmWithArchive(url, wordpress)
258
242
        c.Assert(err, gc.IsNil)
259
 
        err = s.store.SetPerms(&url.URL, "read", params.Everyone, url.URL.User)
260
 
        c.Assert(err, gc.IsNil)
 
243
        s.setPublic(c, url)
261
244
 
262
245
        rec := httptesting.DoRequest(c, httptesting.DoRequestParams{
263
246
                Handler: s.srv,
288
271
        url.URL.Revision++
289
272
        err = s.store.AddCharmWithArchive(url, wordpress)
290
273
        c.Assert(err, gc.IsNil)
 
274
        s.setPublic(c, url)
291
275
 
292
276
        // Check that we still get expected svg.
293
277
        rec = httptesting.DoRequest(c, httptesting.DoRequestParams{
300
284
}
301
285
 
302
286
func (s *APISuite) TestServeBundleIcon(c *gc.C) {
303
 
        s.addPublicBundle(c, "wordpress-simple", newResolvedURL("cs:~charmers/bundle/something-32", 32))
 
287
        s.addPublicBundleFromRepo(c, "wordpress-simple", newResolvedURL("cs:~charmers/bundle/something-32", 32), true)
304
288
 
305
289
        httptesting.AssertJSONCall(c, httptesting.JSONCallParams{
306
290
                Handler:      s.srv,
317
301
        wordpress := storetesting.Charms.ClonedDir(c.MkDir(), "wordpress")
318
302
 
319
303
        url := newResolvedURL("cs:~charmers/precise/wordpress-0", 0)
320
 
        err := s.store.AddCharmWithArchive(url, wordpress)
321
 
        c.Assert(err, gc.IsNil)
322
 
        err = s.store.SetPerms(&url.URL, "read", params.Everyone, url.URL.User)
323
 
        c.Assert(err, gc.IsNil)
 
304
        s.addPublicCharm(c, wordpress, url)
324
305
 
325
306
        rec := httptesting.DoRequest(c, httptesting.DoRequestParams{
326
307
                Handler: s.srv,
345
326
 
346
327
                url := newResolvedURL("cs:~charmers/precise/wordpress-0", -1)
347
328
                url.URL.Revision = i
348
 
                err := s.store.AddCharmWithArchive(url, wordpress)
349
 
                c.Assert(err, gc.IsNil)
350
 
                err = s.store.SetPerms(&url.URL, "read", params.Everyone, url.URL.User)
351
 
                c.Assert(err, gc.IsNil)
 
329
                s.addPublicCharm(c, wordpress, url)
352
330
 
353
331
                rec := httptesting.DoRequest(c, httptesting.DoRequestParams{
354
332
                        Handler: s.srv,