← 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/v5/list_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/v5/list_test.go
19
19
        "gopkg.in/macaroon-bakery.v1/bakery/checkers"
20
20
        "gopkg.in/macaroon-bakery.v1/httpbakery"
21
21
        "gopkg.in/macaroon.v1"
22
 
        "gopkg.in/mgo.v2/bson"
23
22
 
24
 
        "gopkg.in/juju/charmstore.v5-unstable/internal/mongodoc"
25
23
        "gopkg.in/juju/charmstore.v5-unstable/internal/router"
26
24
        "gopkg.in/juju/charmstore.v5-unstable/internal/storetesting"
27
25
)
44
42
}
45
43
 
46
44
func (s *ListSuite) SetUpSuite(c *gc.C) {
47
 
        s.enableES = true
48
45
        s.enableIdentity = true
49
46
        s.commonSuite.SetUpSuite(c)
50
47
}
53
50
        s.commonSuite.SetUpTest(c)
54
51
        s.addCharmsToStore(c)
55
52
        // hide the riak charm
56
 
        err := s.store.DB.BaseEntities().UpdateId(
57
 
                charm.MustParseURL("cs:~charmers/riak"),
58
 
                bson.D{{"$set", map[string]mongodoc.ACL{
59
 
                        "acls": {
60
 
                                Read: []string{"charmers", "test-user"},
61
 
                        },
62
 
                }}},
63
 
        )
64
 
        c.Assert(err, gc.IsNil)
65
 
        err = s.store.UpdateSearch(newResolvedURL("~charmers/trusty/riak-0", 0))
66
 
        c.Assert(err, gc.IsNil)
67
 
        err = s.esSuite.ES.RefreshIndex(s.esSuite.TestIndex)
 
53
        err := s.store.SetPerms(charm.MustParseURL("cs:~charmers/riak"), "stable.read", "charmers", "test-user")
68
54
        c.Assert(err, gc.IsNil)
69
55
}
70
56
 
71
57
func (s *ListSuite) addCharmsToStore(c *gc.C) {
72
58
        for name, id := range exportListTestCharms {
73
 
                err := s.store.AddCharmWithArchive(id, getCharm(name))
74
 
                c.Assert(err, gc.IsNil)
75
 
                err = s.store.SetPerms(&id.URL, "read", params.Everyone, id.URL.User)
76
 
                c.Assert(err, gc.IsNil)
77
 
                err = s.store.UpdateSearch(id)
78
 
                c.Assert(err, gc.IsNil)
 
59
                s.addPublicCharm(c, getListCharm(name), id)
79
60
        }
80
61
        for name, id := range exportListTestBundles {
81
 
                err := s.store.AddBundleWithArchive(id, getListBundle(name))
82
 
                c.Assert(err, gc.IsNil)
83
 
                err = s.store.SetPerms(&id.URL, "read", params.Everyone, id.URL.User)
84
 
                c.Assert(err, gc.IsNil)
85
 
                err = s.store.UpdateSearch(id)
86
 
                c.Assert(err, gc.IsNil)
 
62
                s.addPublicBundle(c, getListBundle(name), id, false)
87
63
        }
88
64
}
89
65
 
90
 
func getListCharm(name string) *charm.CharmDir {
 
66
func getListCharm(name string) *storetesting.Charm {
91
67
        ca := storetesting.Charms.CharmDir(name)
92
 
        ca.Meta().Categories = append(strings.Split(name, "-"), "bar")
93
 
        return ca
 
68
        meta := ca.Meta()
 
69
        meta.Categories = append(strings.Split(name, "-"), "bar")
 
70
        return storetesting.NewCharm(meta)
94
71
}
95
72
 
96
 
func getListBundle(name string) *charm.BundleDir {
 
73
func getListBundle(name string) *storetesting.Bundle {
97
74
        ba := storetesting.Charms.BundleDir(name)
98
 
        ba.Data().Tags = append(strings.Split(name, "-"), "baz")
99
 
        return ba
 
75
        data := ba.Data()
 
76
        data.Tags = append(strings.Split(name, "-"), "baz")
 
77
        return storetesting.NewBundle(data)
100
78
}
101
79
 
102
80
func (s *ListSuite) TestSuccessfulList(c *gc.C) {
185
163
                about: "archive-size",
186
164
                query: "name=mysql&include=archive-size",
187
165
                meta: map[string]interface{}{
188
 
                        "archive-size": params.ArchiveSizeResponse{438},
 
166
                        "archive-size": params.ArchiveSizeResponse{getListCharm("mysql").Size()},
189
167
                },
190
168
        }, {
191
169
                about: "bundle-metadata",
222
200
                query: "name=wordpress&type=charm&include=charm-related",
223
201
                meta: map[string]interface{}{
224
202
                        "charm-related": params.RelatedResponse{
225
 
                                Provides: map[string][]params.MetaAnyResponse{
 
203
                                Provides: map[string][]params.EntityResult{
226
204
                                        "mysql": {
227
205
                                                {
228
206
                                                        Id: exportTestCharms["mysql"].PreferredURL(),
241
219
                query: "name=wordpress&type=charm&include=charm-related&include=charm-config",
242
220
                meta: map[string]interface{}{
243
221
                        "charm-related": params.RelatedResponse{
244
 
                                Provides: map[string][]params.MetaAnyResponse{
 
222
                                Provides: map[string][]params.EntityResult{
245
223
                                        "mysql": {
246
224
                                                {
247
225
                                                        Id: exportTestCharms["mysql"].PreferredURL(),
292
270
 
293
271
        // Now remove one of the blobs. The list should still
294
272
        // work, but only return a single result.
295
 
        blobName, _, err := s.store.BlobNameAndHash(newResolvedURL("~charmers/precise/wordpress-23", 23))
 
273
        entity, err := s.store.FindEntity(newResolvedURL("~charmers/precise/wordpress-23", 23), nil)
296
274
        c.Assert(err, gc.IsNil)
297
 
        err = s.store.BlobStore.Remove(blobName)
 
275
        err = s.store.BlobStore.Remove(entity.BlobName)
298
276
        c.Assert(err, gc.IsNil)
299
277
 
300
278
        // Now list again - we should get one result less
412
390
 
413
391
func (s *ListSuite) TestGetLatestRevisionOnly(c *gc.C) {
414
392
        id := newResolvedURL("cs:~charmers/precise/wordpress-24", 24)
415
 
        err := s.store.AddCharmWithArchive(id, getCharm("wordpress"))
416
 
        c.Assert(err, gc.IsNil)
417
 
        err = s.store.SetPerms(&id.URL, "read", params.Everyone, id.URL.User)
 
393
        s.addPublicCharm(c, getListCharm("wordpress"), id)
418
394
 
419
395
        testresults := []*router.ResolvedURL{
420
396
                exportTestBundles["wordpress-simple"],
428
404
                URL:     storeURL("list"),
429
405
        })
430
406
        var sr params.ListResponse
431
 
        err = json.Unmarshal(rec.Body.Bytes(), &sr)
 
407
        err := json.Unmarshal(rec.Body.Bytes(), &sr)
432
408
        c.Assert(err, gc.IsNil)
433
409
        c.Assert(sr.Results, gc.HasLen, 4, gc.Commentf("expected %#v", testresults))
434
410
        c.Logf("results: %s", rec.Body.Bytes())