← 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/search_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/search_test.go
4
4
package v4_test // import "gopkg.in/juju/charmstore.v5-unstable/internal/v4"
5
5
 
6
6
import (
7
 
        "bytes"
8
7
        "encoding/json"
9
8
        "net/http"
10
9
        "sort"
19
18
        "gopkg.in/macaroon-bakery.v1/bakery/checkers"
20
19
        "gopkg.in/macaroon-bakery.v1/httpbakery"
21
20
        "gopkg.in/macaroon.v1"
22
 
        "gopkg.in/mgo.v2/bson"
23
21
 
24
 
        "gopkg.in/juju/charmstore.v5-unstable/internal/mongodoc"
25
22
        "gopkg.in/juju/charmstore.v5-unstable/internal/router"
26
23
        "gopkg.in/juju/charmstore.v5-unstable/internal/storetesting"
27
24
        "gopkg.in/juju/charmstore.v5-unstable/internal/v4"
34
31
var _ = gc.Suite(&SearchSuite{})
35
32
 
36
33
var exportTestCharms = map[string]*router.ResolvedURL{
37
 
        "wordpress": newResolvedURL("cs:~charmers/precise/wordpress-23", 23),
38
 
        "mysql":     newResolvedURL("cs:~openstack-charmers/trusty/mysql-7", 7),
39
 
        "varnish":   newResolvedURL("cs:~foo/trusty/varnish-1", -1),
40
 
        "riak":      newResolvedURL("cs:~charmers/trusty/riak-67", 67),
 
34
        "multi-series": newResolvedURL("cs:~charmers/multi-series-0", 0),
 
35
        "wordpress":    newResolvedURL("cs:~charmers/precise/wordpress-23", 23),
 
36
        "mysql":        newResolvedURL("cs:~openstack-charmers/trusty/mysql-7", 7),
 
37
        "varnish":      newResolvedURL("cs:~foo/trusty/varnish-1", -1),
 
38
        "riak":         newResolvedURL("cs:~charmers/trusty/riak-67", 67),
41
39
}
42
40
 
43
41
var exportTestBundles = map[string]*router.ResolvedURL{
53
51
func (s *SearchSuite) SetUpTest(c *gc.C) {
54
52
        s.commonSuite.SetUpTest(c)
55
53
        s.addCharmsToStore(c)
56
 
        // hide the riak charm
57
 
        err := s.store.DB.BaseEntities().UpdateId(
58
 
                charm.MustParseURL("cs:~charmers/riak"),
59
 
                bson.D{{"$set", map[string]mongodoc.ACL{
60
 
                        "acls": {
61
 
                                Read: []string{"charmers", "test-user"},
62
 
                        },
63
 
                }}},
64
 
        )
 
54
        err := s.store.SetPerms(charm.MustParseURL("cs:~charmers/riak"), "stable.read", "charmers", "test-user")
65
55
        c.Assert(err, gc.IsNil)
66
56
        err = s.store.UpdateSearch(newResolvedURL("~charmers/trusty/riak-0", 0))
67
57
        c.Assert(err, gc.IsNil)
71
61
 
72
62
func (s *SearchSuite) addCharmsToStore(c *gc.C) {
73
63
        for name, id := range exportTestCharms {
74
 
                err := s.store.AddCharmWithArchive(id, getCharm(name))
75
 
                c.Assert(err, gc.IsNil)
76
 
                err = s.store.SetPerms(&id.URL, "read", params.Everyone, id.URL.User)
77
 
                c.Assert(err, gc.IsNil)
78
 
                err = s.store.UpdateSearch(id)
79
 
                c.Assert(err, gc.IsNil)
 
64
                s.addPublicCharm(c, getSearchCharm(name), id)
80
65
        }
81
66
        for name, id := range exportTestBundles {
82
 
                err := s.store.AddBundleWithArchive(id, getBundle(name))
83
 
                c.Assert(err, gc.IsNil)
84
 
                err = s.store.SetPerms(&id.URL, "read", params.Everyone, id.URL.User)
85
 
                c.Assert(err, gc.IsNil)
86
 
                err = s.store.UpdateSearch(id)
87
 
                c.Assert(err, gc.IsNil)
 
67
                s.addPublicBundle(c, getSearchBundle(name), id, false)
88
68
        }
89
69
}
90
70
 
91
 
func getCharm(name string) *charm.CharmDir {
 
71
func getSearchCharm(name string) *storetesting.Charm {
92
72
        ca := storetesting.Charms.CharmDir(name)
93
 
        ca.Meta().Categories = append(strings.Split(name, "-"), "bar")
94
 
        return ca
 
73
        meta := ca.Meta()
 
74
        meta.Categories = append(strings.Split(name, "-"), "bar")
 
75
        return storetesting.NewCharm(meta)
95
76
}
96
77
 
97
 
func getBundle(name string) *charm.BundleDir {
 
78
func getSearchBundle(name string) *storetesting.Bundle {
98
79
        ba := storetesting.Charms.BundleDir(name)
99
 
        ba.Data().Tags = append(strings.Split(name, "-"), "baz")
100
 
        return ba
 
80
        data := ba.Data()
 
81
        data.Tags = append(strings.Split(name, "-"), "baz")
 
82
        return storetesting.NewBundle(data)
101
83
}
102
84
 
103
85
func (s *SearchSuite) TestSuccessfulSearches(c *gc.C) {
109
91
                about: "bare search",
110
92
                query: "",
111
93
                results: []*router.ResolvedURL{
 
94
                        // V4 SPECIFIC
 
95
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
96
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
97
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
98
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
112
99
                        exportTestCharms["wordpress"],
113
100
                        exportTestCharms["mysql"],
114
101
                        exportTestCharms["varnish"],
132
119
                about: "blank text search",
133
120
                query: "text=",
134
121
                results: []*router.ResolvedURL{
 
122
                        // V4 SPECIFIC
 
123
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
124
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
125
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
126
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
135
127
                        exportTestCharms["wordpress"],
136
128
                        exportTestCharms["mysql"],
137
129
                        exportTestCharms["varnish"],
166
158
                about: "requires filter search",
167
159
                query: "requires=mysql",
168
160
                results: []*router.ResolvedURL{
 
161
                        // V4 SPECIFIC
 
162
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
163
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
164
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
165
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
169
166
                        exportTestCharms["wordpress"],
170
167
                },
171
168
        }, {
172
169
                about: "series filter search",
173
170
                query: "series=trusty",
174
171
                results: []*router.ResolvedURL{
 
172
                        // V4 SPECIFIC
 
173
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
175
174
                        exportTestCharms["mysql"],
176
175
                        exportTestCharms["varnish"],
177
176
                },
199
198
                about: "multiple type filter search",
200
199
                query: "type=bundle&type=charm",
201
200
                results: []*router.ResolvedURL{
 
201
                        // V4 SPECIFIC
 
202
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
203
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
204
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
205
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
202
206
                        exportTestCharms["wordpress"],
203
207
                        exportTestCharms["mysql"],
204
208
                        exportTestCharms["varnish"],
208
212
                about: "provides multiple interfaces filter search",
209
213
                query: "provides=monitoring+http",
210
214
                results: []*router.ResolvedURL{
 
215
                        // V4 SPECIFIC
 
216
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
217
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
218
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
219
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
211
220
                        exportTestCharms["wordpress"],
212
221
                },
213
222
        }, {
214
223
                about: "requires multiple interfaces filter search",
215
224
                query: "requires=mysql+varnish",
216
225
                results: []*router.ResolvedURL{
 
226
                        // V4 SPECIFIC
 
227
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
228
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
229
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
230
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
217
231
                        exportTestCharms["wordpress"],
218
232
                },
219
233
        }, {
226
240
                about: "blank owner",
227
241
                query: "owner=",
228
242
                results: []*router.ResolvedURL{
 
243
                        // V4 SPECIFIC
 
244
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
245
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
246
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
247
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
229
248
                        exportTestCharms["wordpress"],
230
249
                        exportTestCharms["mysql"],
231
250
                        exportTestBundles["wordpress-simple"],
237
256
                about: "promulgated",
238
257
                query: "promulgated=1",
239
258
                results: []*router.ResolvedURL{
 
259
                        // V4 SPECIFIC
 
260
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
261
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
262
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
263
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
240
264
                        exportTestCharms["wordpress"],
241
265
                        exportTestCharms["mysql"],
242
266
                        exportTestBundles["wordpress-simple"],
290
314
                about: "archive-size",
291
315
                query: "name=mysql&include=archive-size",
292
316
                meta: map[string]interface{}{
293
 
                        "archive-size": params.ArchiveSizeResponse{438},
 
317
                        "archive-size": params.ArchiveSizeResponse{getSearchCharm("mysql").Size()},
294
318
                },
295
319
        }, {
296
320
                about: "bundle-metadata",
297
321
                query: "name=wordpress-simple&type=bundle&include=bundle-metadata",
298
322
                meta: map[string]interface{}{
299
 
                        "bundle-metadata": getBundle("wordpress-simple").Data(),
 
323
                        "bundle-metadata": getSearchBundle("wordpress-simple").Data(),
300
324
                },
301
325
        }, {
302
326
                about: "bundle-machine-count",
314
338
                about: "charm-actions",
315
339
                query: "name=wordpress&type=charm&include=charm-actions",
316
340
                meta: map[string]interface{}{
317
 
                        "charm-actions": getCharm("wordpress").Actions(),
 
341
                        "charm-actions": getSearchCharm("wordpress").Actions(),
318
342
                },
319
343
        }, {
320
344
                about: "charm-config",
321
345
                query: "name=wordpress&type=charm&include=charm-config",
322
346
                meta: map[string]interface{}{
323
 
                        "charm-config": getCharm("wordpress").Config(),
 
347
                        "charm-config": getSearchCharm("wordpress").Config(),
324
348
                },
325
349
        }, {
326
350
                about: "charm-related",
327
351
                query: "name=wordpress&type=charm&include=charm-related",
328
352
                meta: map[string]interface{}{
329
353
                        "charm-related": params.RelatedResponse{
330
 
                                Provides: map[string][]params.MetaAnyResponse{
 
354
                                Provides: map[string][]params.EntityResult{
331
355
                                        "mysql": {
332
356
                                                {
333
357
                                                        Id: exportTestCharms["mysql"].PreferredURL(),
346
370
                query: "name=wordpress&type=charm&include=charm-related&include=charm-config",
347
371
                meta: map[string]interface{}{
348
372
                        "charm-related": params.RelatedResponse{
349
 
                                Provides: map[string][]params.MetaAnyResponse{
 
373
                                Provides: map[string][]params.EntityResult{
350
374
                                        "mysql": {
351
375
                                                {
352
376
                                                        Id: exportTestCharms["mysql"].PreferredURL(),
359
383
                                        },
360
384
                                },
361
385
                        },
362
 
                        "charm-config": getCharm("wordpress").Config(),
 
386
                        "charm-config": getSearchCharm("wordpress").Config(),
363
387
                },
364
388
        }}
365
389
        for i, test := range tests {
407
431
        c.Assert(rec.Code, gc.Equals, http.StatusOK)
408
432
        var resp params.SearchResponse
409
433
        err := json.Unmarshal(rec.Body.Bytes(), &resp)
 
434
        // V4 SPECIFIC
410
435
        // cs:riak will not be found because it is not visible to "everyone".
411
 
        c.Assert(resp.Results, gc.HasLen, len(exportTestCharms)-1)
 
436
        // cs:multi-series will be expanded to 4 different results.
 
437
        c.Assert(resp.Results, gc.HasLen, len(exportTestCharms)+3-1)
412
438
 
413
 
        // Now remove one of the blobs. The search should still
 
439
        // Now remove one of the blobs. The list should still
414
440
        // work, but only return a single result.
415
 
        blobName, _, err := s.store.BlobNameAndHash(newResolvedURL("~charmers/precise/wordpress-23", 23))
 
441
        entity, err := s.store.FindEntity(newResolvedURL("~charmers/precise/wordpress-23", 23), nil)
 
442
 
416
443
        c.Assert(err, gc.IsNil)
417
 
        err = s.store.BlobStore.Remove(blobName)
 
444
        err = s.store.BlobStore.Remove(entity.BlobName)
418
445
        c.Assert(err, gc.IsNil)
419
446
 
420
447
        // Now search again - we should get one result less
434
461
        c.Assert(rec.Code, gc.Equals, http.StatusOK)
435
462
        resp = params.SearchResponse{}
436
463
        err = json.Unmarshal(rec.Body.Bytes(), &resp)
 
464
        // V4 SPECIFIC
437
465
        // cs:riak will not be found because it is not visible to "everyone".
 
466
        // cs:multi-series will be expanded to 4 different results.
438
467
        // cs:wordpress will not be found because it has no manifest.
439
 
        c.Assert(resp.Results, gc.HasLen, len(exportTestCharms)-2)
 
468
        c.Assert(resp.Results, gc.HasLen, len(exportTestCharms)+3-2)
440
469
 
441
470
        c.Assert(tw.Log(), jc.LogMatches, []string{"cannot retrieve metadata for cs:precise/wordpress-23: cannot open archive data for cs:precise/wordpress-23: .*"})
442
471
}
450
479
                about: "name ascending",
451
480
                query: "sort=name",
452
481
                results: []*router.ResolvedURL{
 
482
                        // V4 SPECIFIC
 
483
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
484
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
485
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
486
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
453
487
                        exportTestCharms["mysql"],
454
488
                        exportTestCharms["varnish"],
455
489
                        exportTestCharms["wordpress"],
459
493
                about: "name descending",
460
494
                query: "sort=-name",
461
495
                results: []*router.ResolvedURL{
 
496
                        // V4 SPECIFIC
462
497
                        exportTestBundles["wordpress-simple"],
463
498
                        exportTestCharms["wordpress"],
464
499
                        exportTestCharms["varnish"],
465
500
                        exportTestCharms["mysql"],
 
501
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
502
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
503
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
504
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
466
505
                },
467
506
        }, {
468
507
                about: "series ascending",
469
508
                query: "sort=series,name",
470
509
                results: []*router.ResolvedURL{
 
510
                        // V4 SPECIFIC
471
511
                        exportTestBundles["wordpress-simple"],
472
512
                        exportTestCharms["wordpress"],
 
513
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
473
514
                        exportTestCharms["mysql"],
474
515
                        exportTestCharms["varnish"],
 
516
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
517
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
518
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
475
519
                },
476
520
        }, {
477
521
                about: "series descending",
478
522
                query: "sort=-series&sort=name",
479
523
                results: []*router.ResolvedURL{
 
524
                        // V4 SPECIFIC
 
525
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
 
526
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
527
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
528
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
480
529
                        exportTestCharms["mysql"],
481
530
                        exportTestCharms["varnish"],
482
531
                        exportTestCharms["wordpress"],
486
535
                about: "owner ascending",
487
536
                query: "sort=owner,name",
488
537
                results: []*router.ResolvedURL{
 
538
                        // V4 SPECIFIC
 
539
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
540
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
541
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
542
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
489
543
                        exportTestCharms["wordpress"],
490
544
                        exportTestBundles["wordpress-simple"],
491
545
                        exportTestCharms["varnish"],
495
549
                about: "owner descending",
496
550
                query: "sort=-owner&sort=name",
497
551
                results: []*router.ResolvedURL{
 
552
                        // V4 SPECIFIC
498
553
                        exportTestCharms["mysql"],
499
554
                        exportTestCharms["varnish"],
 
555
                        router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
556
                        router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
557
                        router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
558
                        router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
500
559
                        exportTestCharms["wordpress"],
501
560
                        exportTestBundles["wordpress-simple"],
502
561
                },
542
601
        for n, cnt := range charmDownloads {
543
602
                url := newResolvedURL("cs:~downloads-test/trusty/x-1", -1)
544
603
                url.URL.Name = n
545
 
                err := s.store.AddCharmWithArchive(url, getCharm(n))
546
 
                c.Assert(err, gc.IsNil)
547
 
                err = s.store.SetPerms(&url.URL, "read", params.Everyone, url.URL.User)
548
 
                c.Assert(err, gc.IsNil)
549
 
                err = s.store.UpdateSearch(url)
550
 
                c.Assert(err, gc.IsNil)
 
604
                s.addPublicCharm(c, getSearchCharm(n), url)
551
605
                for i := 0; i < cnt; i++ {
552
606
                        err := s.store.IncrementDownloadCounts(url)
553
607
                        c.Assert(err, gc.IsNil)
574
628
        doc, err := s.store.ES.GetSearchDocument(charm.MustParseURL("~openstack-charmers/trusty/mysql-7"))
575
629
        c.Assert(err, gc.IsNil)
576
630
        c.Assert(doc.TotalDownloads, gc.Equals, int64(0))
577
 
        s.assertPut(c, "~openstack-charmers/trusty/mysql-7/meta/extra-info/"+params.LegacyDownloadStats, 57)
 
631
        s.assertPutAsAdmin(c, "~openstack-charmers/trusty/mysql-7/meta/extra-info/"+params.LegacyDownloadStats, 57)
578
632
        doc, err = s.store.ES.GetSearchDocument(charm.MustParseURL("~openstack-charmers/trusty/mysql-7"))
579
633
        c.Assert(err, gc.IsNil)
580
634
        c.Assert(doc.TotalDownloads, gc.Equals, int64(57))
581
635
}
582
636
 
583
 
func (s *SearchSuite) assertPut(c *gc.C, url string, val interface{}) {
584
 
        body, err := json.Marshal(val)
585
 
        c.Assert(err, gc.IsNil)
586
 
        rec := httptesting.DoRequest(c, httptesting.DoRequestParams{
587
 
                Handler: s.srv,
588
 
                URL:     storeURL(url),
589
 
                Method:  "PUT",
590
 
                Header: http.Header{
591
 
                        "Content-Type": {"application/json"},
592
 
                },
593
 
                Username: testUsername,
594
 
                Password: testPassword,
595
 
                Body:     bytes.NewReader(body),
596
 
        })
597
 
        c.Assert(rec.Code, gc.Equals, http.StatusOK, gc.Commentf("headers: %v, body: %s", rec.HeaderMap, rec.Body.String()))
598
 
        c.Assert(rec.Body.String(), gc.HasLen, 0)
599
 
}
600
 
 
601
637
func (s *SearchSuite) TestSearchWithAdminCredentials(c *gc.C) {
602
638
        rec := httptesting.DoRequest(c, httptesting.DoRequestParams{
603
639
                Handler:  s.srv,
607
643
        })
608
644
        c.Assert(rec.Code, gc.Equals, http.StatusOK)
609
645
        expected := []*router.ResolvedURL{
 
646
                // V4 SPECIFIC
 
647
                router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
648
                router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
649
                router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
650
                router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
610
651
                exportTestCharms["mysql"],
611
652
                exportTestCharms["wordpress"],
612
653
                exportTestCharms["riak"],
633
674
        })
634
675
        c.Assert(rec.Code, gc.Equals, http.StatusOK)
635
676
        expected := []*router.ResolvedURL{
 
677
                // V4 SPECIFIC
 
678
                router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
679
                router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
680
                router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
681
                router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
636
682
                exportTestCharms["mysql"],
637
683
                exportTestCharms["wordpress"],
638
684
                exportTestCharms["riak"],
662
708
        })
663
709
        c.Assert(rec.Code, gc.Equals, http.StatusOK)
664
710
        expected := []*router.ResolvedURL{
 
711
                // V4 SPECIFIC
 
712
                router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
713
                router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
714
                router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
715
                router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
665
716
                exportTestCharms["mysql"],
666
717
                exportTestCharms["wordpress"],
667
718
                exportTestCharms["riak"],
690
741
        })
691
742
        c.Assert(rec.Code, gc.Equals, http.StatusOK)
692
743
        expected := []*router.ResolvedURL{
 
744
                // V4 SPECIFIC
 
745
                router.MustNewResolvedURL("cs:~charmers/trusty/multi-series-0", 0),
 
746
                router.MustNewResolvedURL("cs:~charmers/utopic/multi-series-0", 0),
 
747
                router.MustNewResolvedURL("cs:~charmers/vivid/multi-series-0", 0),
 
748
                router.MustNewResolvedURL("cs:~charmers/wily/multi-series-0", 0),
693
749
                exportTestCharms["mysql"],
694
750
                exportTestCharms["wordpress"],
695
751
                exportTestCharms["varnish"],