← Back to branch summary

~gz/juju-core/trunk

« back to all changes in this revision

Viewing changes to charm/repo_test.go

[r=rogpeppe] all: standardise gocheck imports, A-D

This is an automated change to use "gc" for gocheck
imports throughout. To avoid clogging Rietveld, I've
split it up into three parts - this is the first.

https://codereview.appspot.com/12940044/

Show diffs side-by-side

added added

removed removed

Lines of Context:
charm/repo_test.go
16
16
        "strconv"
17
17
        "strings"
18
18
 
19
 
        . "launchpad.net/gocheck"
 
19
        gc "launchpad.net/gocheck"
20
20
 
21
21
        "launchpad.net/juju-core/charm"
22
22
        "launchpad.net/juju-core/testing"
30
30
        downloads    []*charm.URL
31
31
}
32
32
 
33
 
func NewMockStore(c *C) *MockStore {
 
33
func NewMockStore(c *gc.C) *MockStore {
34
34
        s := &MockStore{}
35
35
        bytes, err := ioutil.ReadFile(testing.Charms.BundlePath(c.MkDir(), "dummy"))
36
 
        c.Assert(err, IsNil)
 
36
        c.Assert(err, gc.IsNil)
37
37
        s.bundleBytes = bytes
38
38
        h := sha256.New()
39
39
        h.Write(bytes)
49
49
                s.ServeCharm(w, r)
50
50
        })
51
51
        lis, err := net.Listen("tcp", "127.0.0.1:4444")
52
 
        c.Assert(err, IsNil)
 
52
        c.Assert(err, gc.IsNil)
53
53
        s.lis = lis
54
54
        go http.Serve(s.lis, s)
55
55
        return s
157
157
        oldCacheDir string
158
158
}
159
159
 
160
 
var _ = Suite(&StoreSuite{})
 
160
var _ = gc.Suite(&StoreSuite{})
161
161
 
162
 
func (s *StoreSuite) SetUpSuite(c *C) {
 
162
func (s *StoreSuite) SetUpSuite(c *gc.C) {
163
163
        s.LoggingSuite.SetUpSuite(c)
164
164
        s.server = NewMockStore(c)
165
165
        s.oldCacheDir = charm.CacheDir
166
166
}
167
167
 
168
 
func (s *StoreSuite) SetUpTest(c *C) {
 
168
func (s *StoreSuite) SetUpTest(c *gc.C) {
169
169
        s.LoggingSuite.SetUpTest(c)
170
170
        charm.CacheDir = c.MkDir()
171
171
        s.store = charm.NewStore("http://127.0.0.1:4444")
174
174
 
175
175
// Uses the TearDownTest from testing.LoggingSuite
176
176
 
177
 
func (s *StoreSuite) TearDownSuite(c *C) {
 
177
func (s *StoreSuite) TearDownSuite(c *gc.C) {
178
178
        charm.CacheDir = s.oldCacheDir
179
179
        s.server.lis.Close()
180
180
        s.LoggingSuite.TearDownSuite(c)
181
181
}
182
182
 
183
 
func (s *StoreSuite) TestMissing(c *C) {
 
183
func (s *StoreSuite) TestMissing(c *gc.C) {
184
184
        charmURL := charm.MustParseURL("cs:series/missing")
185
185
        expect := `charm not found: cs:series/missing`
186
186
        _, err := s.store.Latest(charmURL)
187
 
        c.Assert(err, ErrorMatches, expect)
 
187
        c.Assert(err, gc.ErrorMatches, expect)
188
188
        _, err = s.store.Get(charmURL)
189
 
        c.Assert(err, ErrorMatches, expect)
 
189
        c.Assert(err, gc.ErrorMatches, expect)
190
190
}
191
191
 
192
 
func (s *StoreSuite) TestError(c *C) {
 
192
func (s *StoreSuite) TestError(c *gc.C) {
193
193
        charmURL := charm.MustParseURL("cs:series/borken")
194
194
        expect := `charm info errors for "cs:series/borken": badness`
195
195
        _, err := s.store.Latest(charmURL)
196
 
        c.Assert(err, ErrorMatches, expect)
 
196
        c.Assert(err, gc.ErrorMatches, expect)
197
197
        _, err = s.store.Get(charmURL)
198
 
        c.Assert(err, ErrorMatches, expect)
 
198
        c.Assert(err, gc.ErrorMatches, expect)
199
199
}
200
200
 
201
 
func (s *StoreSuite) TestWarning(c *C) {
 
201
func (s *StoreSuite) TestWarning(c *gc.C) {
202
202
        charmURL := charm.MustParseURL("cs:series/unwise")
203
203
        expect := `.* WARNING juju charm: charm store reports for "cs:series/unwise": foolishness` + "\n"
204
204
        r, err := s.store.Latest(charmURL)
205
 
        c.Assert(r, Equals, 23)
206
 
        c.Assert(err, IsNil)
207
 
        c.Assert(c.GetTestLog(), Matches, expect)
 
205
        c.Assert(r, gc.Equals, 23)
 
206
        c.Assert(err, gc.IsNil)
 
207
        c.Assert(c.GetTestLog(), gc.Matches, expect)
208
208
        ch, err := s.store.Get(charmURL)
209
 
        c.Assert(ch, NotNil)
210
 
        c.Assert(err, IsNil)
211
 
        c.Assert(c.GetTestLog(), Matches, expect+expect)
 
209
        c.Assert(ch, gc.NotNil)
 
210
        c.Assert(err, gc.IsNil)
 
211
        c.Assert(c.GetTestLog(), gc.Matches, expect+expect)
212
212
}
213
213
 
214
 
func (s *StoreSuite) TestLatest(c *C) {
 
214
func (s *StoreSuite) TestLatest(c *gc.C) {
215
215
        for _, str := range []string{
216
216
                "cs:series/good",
217
217
                "cs:series/good-2",
218
218
                "cs:series/good-99",
219
219
        } {
220
220
                r, err := s.store.Latest(charm.MustParseURL(str))
221
 
                c.Assert(r, Equals, 23)
222
 
                c.Assert(err, IsNil)
 
221
                c.Assert(r, gc.Equals, 23)
 
222
                c.Assert(err, gc.IsNil)
223
223
        }
224
224
}
225
225
 
226
 
func (s *StoreSuite) assertCached(c *C, charmURL *charm.URL) {
 
226
func (s *StoreSuite) assertCached(c *gc.C, charmURL *charm.URL) {
227
227
        s.server.downloads = nil
228
228
        ch, err := s.store.Get(charmURL)
229
 
        c.Assert(err, IsNil)
230
 
        c.Assert(ch, NotNil)
231
 
        c.Assert(s.server.downloads, IsNil)
 
229
        c.Assert(err, gc.IsNil)
 
230
        c.Assert(ch, gc.NotNil)
 
231
        c.Assert(s.server.downloads, gc.IsNil)
232
232
}
233
233
 
234
 
func (s *StoreSuite) TestGetCacheImplicitRevision(c *C) {
 
234
func (s *StoreSuite) TestGetCacheImplicitRevision(c *gc.C) {
235
235
        base := "cs:series/good"
236
236
        charmURL := charm.MustParseURL(base)
237
237
        revCharmURL := charm.MustParseURL(base + "-23")
238
238
        ch, err := s.store.Get(charmURL)
239
 
        c.Assert(err, IsNil)
240
 
        c.Assert(ch, NotNil)
241
 
        c.Assert(s.server.downloads, DeepEquals, []*charm.URL{revCharmURL})
 
239
        c.Assert(err, gc.IsNil)
 
240
        c.Assert(ch, gc.NotNil)
 
241
        c.Assert(s.server.downloads, gc.DeepEquals, []*charm.URL{revCharmURL})
242
242
        s.assertCached(c, charmURL)
243
243
        s.assertCached(c, revCharmURL)
244
244
}
245
245
 
246
 
func (s *StoreSuite) TestGetCacheExplicitRevision(c *C) {
 
246
func (s *StoreSuite) TestGetCacheExplicitRevision(c *gc.C) {
247
247
        base := "cs:series/good-12"
248
248
        charmURL := charm.MustParseURL(base)
249
249
        ch, err := s.store.Get(charmURL)
250
 
        c.Assert(err, IsNil)
251
 
        c.Assert(ch, NotNil)
252
 
        c.Assert(s.server.downloads, DeepEquals, []*charm.URL{charmURL})
 
250
        c.Assert(err, gc.IsNil)
 
251
        c.Assert(ch, gc.NotNil)
 
252
        c.Assert(s.server.downloads, gc.DeepEquals, []*charm.URL{charmURL})
253
253
        s.assertCached(c, charmURL)
254
254
}
255
255
 
256
 
func (s *StoreSuite) TestGetBadCache(c *C) {
257
 
        c.Assert(os.Mkdir(filepath.Join(charm.CacheDir, "cache"), 0777), IsNil)
 
256
func (s *StoreSuite) TestGetBadCache(c *gc.C) {
 
257
        c.Assert(os.Mkdir(filepath.Join(charm.CacheDir, "cache"), 0777), gc.IsNil)
258
258
        base := "cs:series/good"
259
259
        charmURL := charm.MustParseURL(base)
260
260
        revCharmURL := charm.MustParseURL(base + "-23")
261
261
        name := charm.Quote(revCharmURL.String()) + ".charm"
262
262
        err := ioutil.WriteFile(filepath.Join(charm.CacheDir, "cache", name), nil, 0666)
263
 
        c.Assert(err, IsNil)
 
263
        c.Assert(err, gc.IsNil)
264
264
        ch, err := s.store.Get(charmURL)
265
 
        c.Assert(err, IsNil)
266
 
        c.Assert(ch, NotNil)
267
 
        c.Assert(s.server.downloads, DeepEquals, []*charm.URL{revCharmURL})
 
265
        c.Assert(err, gc.IsNil)
 
266
        c.Assert(ch, gc.NotNil)
 
267
        c.Assert(s.server.downloads, gc.DeepEquals, []*charm.URL{revCharmURL})
268
268
        s.assertCached(c, charmURL)
269
269
        s.assertCached(c, revCharmURL)
270
270
}
271
271
 
272
272
// The following tests cover the low-level CharmStore-specific API.
273
273
 
274
 
func (s *StoreSuite) TestInfo(c *C) {
 
274
func (s *StoreSuite) TestInfo(c *gc.C) {
275
275
        charmURL := charm.MustParseURL("cs:series/good")
276
276
        info, err := s.store.Info(charmURL)
277
 
        c.Assert(err, IsNil)
278
 
        c.Assert(info.Errors, IsNil)
279
 
        c.Assert(info.Revision, Equals, 23)
 
277
        c.Assert(err, gc.IsNil)
 
278
        c.Assert(info.Errors, gc.IsNil)
 
279
        c.Assert(info.Revision, gc.Equals, 23)
280
280
}
281
281
 
282
 
func (s *StoreSuite) TestInfoNotFound(c *C) {
 
282
func (s *StoreSuite) TestInfoNotFound(c *gc.C) {
283
283
        charmURL := charm.MustParseURL("cs:series/missing")
284
284
        info, err := s.store.Info(charmURL)
285
 
        c.Assert(err, ErrorMatches, `charm not found: cs:series/missing`)
286
 
        c.Assert(info, IsNil)
 
285
        c.Assert(err, gc.ErrorMatches, `charm not found: cs:series/missing`)
 
286
        c.Assert(info, gc.IsNil)
287
287
}
288
288
 
289
 
func (s *StoreSuite) TestInfoError(c *C) {
 
289
func (s *StoreSuite) TestInfoError(c *gc.C) {
290
290
        charmURL := charm.MustParseURL("cs:series/borken")
291
291
        info, err := s.store.Info(charmURL)
292
 
        c.Assert(err, IsNil)
293
 
        c.Assert(info.Errors, DeepEquals, []string{"badness"})
 
292
        c.Assert(err, gc.IsNil)
 
293
        c.Assert(info.Errors, gc.DeepEquals, []string{"badness"})
294
294
}
295
295
 
296
 
func (s *StoreSuite) TestInfoWarning(c *C) {
 
296
func (s *StoreSuite) TestInfoWarning(c *gc.C) {
297
297
        charmURL := charm.MustParseURL("cs:series/unwise")
298
298
        info, err := s.store.Info(charmURL)
299
 
        c.Assert(err, IsNil)
300
 
        c.Assert(info.Warnings, DeepEquals, []string{"foolishness"})
 
299
        c.Assert(err, gc.IsNil)
 
300
        c.Assert(info.Warnings, gc.DeepEquals, []string{"foolishness"})
301
301
}
302
302
 
303
 
func (s *StoreSuite) TestEvent(c *C) {
 
303
func (s *StoreSuite) TestEvent(c *gc.C) {
304
304
        charmURL := charm.MustParseURL("cs:series/good")
305
305
        event, err := s.store.Event(charmURL, "")
306
 
        c.Assert(err, IsNil)
307
 
        c.Assert(event.Errors, IsNil)
308
 
        c.Assert(event.Revision, Equals, 23)
309
 
        c.Assert(event.Digest, Equals, "the-digest")
 
306
        c.Assert(err, gc.IsNil)
 
307
        c.Assert(event.Errors, gc.IsNil)
 
308
        c.Assert(event.Revision, gc.Equals, 23)
 
309
        c.Assert(event.Digest, gc.Equals, "the-digest")
310
310
}
311
311
 
312
 
func (s *StoreSuite) TestEventWithDigest(c *C) {
 
312
func (s *StoreSuite) TestEventWithDigest(c *gc.C) {
313
313
        charmURL := charm.MustParseURL("cs:series/good")
314
314
        event, err := s.store.Event(charmURL, "the-digest")
315
 
        c.Assert(err, IsNil)
316
 
        c.Assert(event.Errors, IsNil)
317
 
        c.Assert(event.Revision, Equals, 23)
318
 
        c.Assert(event.Digest, Equals, "the-digest")
 
315
        c.Assert(err, gc.IsNil)
 
316
        c.Assert(event.Errors, gc.IsNil)
 
317
        c.Assert(event.Revision, gc.Equals, 23)
 
318
        c.Assert(event.Digest, gc.Equals, "the-digest")
319
319
}
320
320
 
321
 
func (s *StoreSuite) TestEventNotFound(c *C) {
 
321
func (s *StoreSuite) TestEventNotFound(c *gc.C) {
322
322
        charmURL := charm.MustParseURL("cs:series/missing")
323
323
        event, err := s.store.Event(charmURL, "")
324
 
        c.Assert(err, ErrorMatches, `charm event not found for "cs:series/missing"`)
325
 
        c.Assert(event, IsNil)
 
324
        c.Assert(err, gc.ErrorMatches, `charm event not found for "cs:series/missing"`)
 
325
        c.Assert(event, gc.IsNil)
326
326
}
327
327
 
328
 
func (s *StoreSuite) TestEventNotFoundDigest(c *C) {
 
328
func (s *StoreSuite) TestEventNotFoundDigest(c *gc.C) {
329
329
        charmURL := charm.MustParseURL("cs:series/good")
330
330
        event, err := s.store.Event(charmURL, "missing-digest")
331
 
        c.Assert(err, ErrorMatches, `charm event not found for "cs:series/good" with digest "missing-digest"`)
332
 
        c.Assert(event, IsNil)
 
331
        c.Assert(err, gc.ErrorMatches, `charm event not found for "cs:series/good" with digest "missing-digest"`)
 
332
        c.Assert(event, gc.IsNil)
333
333
}
334
334
 
335
 
func (s *StoreSuite) TestEventError(c *C) {
 
335
func (s *StoreSuite) TestEventError(c *gc.C) {
336
336
        charmURL := charm.MustParseURL("cs:series/borken")
337
337
        event, err := s.store.Event(charmURL, "")
338
 
        c.Assert(err, IsNil)
339
 
        c.Assert(event.Errors, DeepEquals, []string{"badness"})
 
338
        c.Assert(err, gc.IsNil)
 
339
        c.Assert(event.Errors, gc.DeepEquals, []string{"badness"})
340
340
}
341
341
 
342
 
func (s *StoreSuite) TestEventWarning(c *C) {
 
342
func (s *StoreSuite) TestEventWarning(c *gc.C) {
343
343
        charmURL := charm.MustParseURL("cs:series/unwise")
344
344
        event, err := s.store.Event(charmURL, "")
345
 
        c.Assert(err, IsNil)
346
 
        c.Assert(event.Warnings, DeepEquals, []string{"foolishness"})
 
345
        c.Assert(err, gc.IsNil)
 
346
        c.Assert(event.Warnings, gc.DeepEquals, []string{"foolishness"})
347
347
}
348
348
 
349
 
func (s *StoreSuite) TestBranchLocation(c *C) {
 
349
func (s *StoreSuite) TestBranchLocation(c *gc.C) {
350
350
        charmURL := charm.MustParseURL("cs:series/name")
351
351
        location := s.store.BranchLocation(charmURL)
352
 
        c.Assert(location, Equals, "lp:charms/series/name")
 
352
        c.Assert(location, gc.Equals, "lp:charms/series/name")
353
353
 
354
354
        charmURL = charm.MustParseURL("cs:~user/series/name")
355
355
        location = s.store.BranchLocation(charmURL)
356
 
        c.Assert(location, Equals, "lp:~user/charms/series/name/trunk")
 
356
        c.Assert(location, gc.Equals, "lp:~user/charms/series/name/trunk")
357
357
}
358
358
 
359
 
func (s *StoreSuite) TestCharmURL(c *C) {
 
359
func (s *StoreSuite) TestCharmURL(c *gc.C) {
360
360
        tests := []struct{ url, loc string }{
361
361
                {"cs:precise/wordpress", "lp:charms/precise/wordpress"},
362
362
                {"cs:precise/wordpress", "http://launchpad.net/+branch/charms/precise/wordpress"},
383
383
        for _, t := range tests {
384
384
                charmURL, err := s.store.CharmURL(t.loc)
385
385
                if t.url == "" {
386
 
                        c.Assert(err, ErrorMatches, fmt.Sprintf("unknown branch location: %q", t.loc))
 
386
                        c.Assert(err, gc.ErrorMatches, fmt.Sprintf("unknown branch location: %q", t.loc))
387
387
                } else {
388
 
                        c.Assert(err, IsNil)
389
 
                        c.Assert(charmURL.String(), Equals, t.url)
 
388
                        c.Assert(err, gc.IsNil)
 
389
                        c.Assert(charmURL.String(), gc.Equals, t.url)
390
390
                }
391
391
        }
392
392
}
397
397
        seriesPath string
398
398
}
399
399
 
400
 
var _ = Suite(&LocalRepoSuite{})
 
400
var _ = gc.Suite(&LocalRepoSuite{})
401
401
 
402
 
func (s *LocalRepoSuite) SetUpTest(c *C) {
 
402
func (s *LocalRepoSuite) SetUpTest(c *gc.C) {
403
403
        s.LoggingSuite.SetUpTest(c)
404
404
        root := c.MkDir()
405
405
        s.repo = &charm.LocalRepository{root}
406
406
        s.seriesPath = filepath.Join(root, "series")
407
 
        c.Assert(os.Mkdir(s.seriesPath, 0777), IsNil)
 
407
        c.Assert(os.Mkdir(s.seriesPath, 0777), gc.IsNil)
408
408
}
409
409
 
410
410
func (s *LocalRepoSuite) addBundle(name string) string {
415
415
        return testing.Charms.ClonedDirPath(s.seriesPath, name)
416
416
}
417
417
 
418
 
func (s *LocalRepoSuite) checkNotFoundErr(c *C, err error, charmURL *charm.URL) {
 
418
func (s *LocalRepoSuite) checkNotFoundErr(c *gc.C, err error, charmURL *charm.URL) {
419
419
        expect := `charm not found in "` + s.repo.Path + `": ` + charmURL.String()
420
 
        c.Check(err, ErrorMatches, expect)
 
420
        c.Check(err, gc.ErrorMatches, expect)
421
421
}
422
422
 
423
 
func (s *LocalRepoSuite) TestMissingCharm(c *C) {
 
423
func (s *LocalRepoSuite) TestMissingCharm(c *gc.C) {
424
424
        for i, str := range []string{
425
425
                "local:series/zebra", "local:badseries/zebra",
426
426
        } {
433
433
        }
434
434
}
435
435
 
436
 
func (s *LocalRepoSuite) TestMissingRepo(c *C) {
437
 
        c.Assert(os.RemoveAll(s.repo.Path), IsNil)
 
436
func (s *LocalRepoSuite) TestMissingRepo(c *gc.C) {
 
437
        c.Assert(os.RemoveAll(s.repo.Path), gc.IsNil)
438
438
        _, err := s.repo.Latest(charm.MustParseURL("local:series/zebra"))
439
 
        c.Assert(err, ErrorMatches, `no repository found at ".*"`)
 
439
        c.Assert(err, gc.ErrorMatches, `no repository found at ".*"`)
440
440
        _, err = s.repo.Get(charm.MustParseURL("local:series/zebra"))
441
 
        c.Assert(err, ErrorMatches, `no repository found at ".*"`)
442
 
        c.Assert(ioutil.WriteFile(s.repo.Path, nil, 0666), IsNil)
 
441
        c.Assert(err, gc.ErrorMatches, `no repository found at ".*"`)
 
442
        c.Assert(ioutil.WriteFile(s.repo.Path, nil, 0666), gc.IsNil)
443
443
        _, err = s.repo.Latest(charm.MustParseURL("local:series/zebra"))
444
 
        c.Assert(err, ErrorMatches, `no repository found at ".*"`)
 
444
        c.Assert(err, gc.ErrorMatches, `no repository found at ".*"`)
445
445
        _, err = s.repo.Get(charm.MustParseURL("local:series/zebra"))
446
 
        c.Assert(err, ErrorMatches, `no repository found at ".*"`)
 
446
        c.Assert(err, gc.ErrorMatches, `no repository found at ".*"`)
447
447
}
448
448
 
449
 
func (s *LocalRepoSuite) TestMultipleVersions(c *C) {
 
449
func (s *LocalRepoSuite) TestMultipleVersions(c *gc.C) {
450
450
        charmURL := charm.MustParseURL("local:series/upgrade")
451
451
        s.addDir("upgrade1")
452
452
        rev, err := s.repo.Latest(charmURL)
453
 
        c.Assert(err, IsNil)
454
 
        c.Assert(rev, Equals, 1)
 
453
        c.Assert(err, gc.IsNil)
 
454
        c.Assert(rev, gc.Equals, 1)
455
455
        ch, err := s.repo.Get(charmURL)
456
 
        c.Assert(err, IsNil)
457
 
        c.Assert(ch.Revision(), Equals, 1)
 
456
        c.Assert(err, gc.IsNil)
 
457
        c.Assert(ch.Revision(), gc.Equals, 1)
458
458
 
459
459
        s.addDir("upgrade2")
460
460
        rev, err = s.repo.Latest(charmURL)
461
 
        c.Assert(err, IsNil)
462
 
        c.Assert(rev, Equals, 2)
 
461
        c.Assert(err, gc.IsNil)
 
462
        c.Assert(rev, gc.Equals, 2)
463
463
        ch, err = s.repo.Get(charmURL)
464
 
        c.Assert(err, IsNil)
465
 
        c.Assert(ch.Revision(), Equals, 2)
 
464
        c.Assert(err, gc.IsNil)
 
465
        c.Assert(ch.Revision(), gc.Equals, 2)
466
466
 
467
467
        revCharmURL := charmURL.WithRevision(1)
468
468
        rev, err = s.repo.Latest(revCharmURL)
469
 
        c.Assert(err, IsNil)
470
 
        c.Assert(rev, Equals, 2)
 
469
        c.Assert(err, gc.IsNil)
 
470
        c.Assert(rev, gc.Equals, 2)
471
471
        ch, err = s.repo.Get(revCharmURL)
472
 
        c.Assert(err, IsNil)
473
 
        c.Assert(ch.Revision(), Equals, 1)
 
472
        c.Assert(err, gc.IsNil)
 
473
        c.Assert(ch.Revision(), gc.Equals, 1)
474
474
 
475
475
        badRevCharmURL := charmURL.WithRevision(33)
476
476
        rev, err = s.repo.Latest(badRevCharmURL)
477
 
        c.Assert(err, IsNil)
478
 
        c.Assert(rev, Equals, 2)
 
477
        c.Assert(err, gc.IsNil)
 
478
        c.Assert(rev, gc.Equals, 2)
479
479
        _, err = s.repo.Get(badRevCharmURL)
480
480
        s.checkNotFoundErr(c, err, badRevCharmURL)
481
481
}
482
482
 
483
 
func (s *LocalRepoSuite) TestBundle(c *C) {
 
483
func (s *LocalRepoSuite) TestBundle(c *gc.C) {
484
484
        charmURL := charm.MustParseURL("local:series/dummy")
485
485
        s.addBundle("dummy")
486
486
 
487
487
        rev, err := s.repo.Latest(charmURL)
488
 
        c.Assert(err, IsNil)
489
 
        c.Assert(rev, Equals, 1)
 
488
        c.Assert(err, gc.IsNil)
 
489
        c.Assert(rev, gc.Equals, 1)
490
490
        ch, err := s.repo.Get(charmURL)
491
 
        c.Assert(err, IsNil)
492
 
        c.Assert(ch.Revision(), Equals, 1)
 
491
        c.Assert(err, gc.IsNil)
 
492
        c.Assert(ch.Revision(), gc.Equals, 1)
493
493
}
494
494
 
495
 
func (s *LocalRepoSuite) TestLogsErrors(c *C) {
 
495
func (s *LocalRepoSuite) TestLogsErrors(c *gc.C) {
496
496
        err := ioutil.WriteFile(filepath.Join(s.seriesPath, "blah.charm"), nil, 0666)
497
 
        c.Assert(err, IsNil)
 
497
        c.Assert(err, gc.IsNil)
498
498
        err = os.Mkdir(filepath.Join(s.seriesPath, "blah"), 0666)
499
 
        c.Assert(err, IsNil)
 
499
        c.Assert(err, gc.IsNil)
500
500
        samplePath := s.addDir("upgrade2")
501
501
        gibberish := []byte("don't parse me by")
502
502
        err = ioutil.WriteFile(filepath.Join(samplePath, "metadata.yaml"), gibberish, 0666)
503
 
        c.Assert(err, IsNil)
 
503
        c.Assert(err, gc.IsNil)
504
504
 
505
505
        charmURL := charm.MustParseURL("local:series/dummy")
506
506
        s.addDir("dummy")
507
507
        ch, err := s.repo.Get(charmURL)
508
 
        c.Assert(err, IsNil)
509
 
        c.Assert(ch.Revision(), Equals, 1)
510
 
        c.Assert(c.GetTestLog(), Matches, `
 
508
        c.Assert(err, gc.IsNil)
 
509
        c.Assert(ch.Revision(), gc.Equals, 1)
 
510
        c.Assert(c.GetTestLog(), gc.Matches, `
511
511
.* WARNING juju charm: failed to load charm at ".*/series/blah": .*
512
512
.* WARNING juju charm: failed to load charm at ".*/series/blah.charm": .*
513
513
.* WARNING juju charm: failed to load charm at ".*/series/upgrade2": .*
514
514
`[1:])
515
515
}
516
516
 
517
 
func renameSibling(c *C, path, name string) {
518
 
        c.Assert(os.Rename(path, filepath.Join(filepath.Dir(path), name)), IsNil)
 
517
func renameSibling(c *gc.C, path, name string) {
 
518
        c.Assert(os.Rename(path, filepath.Join(filepath.Dir(path), name)), gc.IsNil)
519
519
}
520
520
 
521
 
func (s *LocalRepoSuite) TestIgnoresUnpromisingNames(c *C) {
 
521
func (s *LocalRepoSuite) TestIgnoresUnpromisingNames(c *gc.C) {
522
522
        err := ioutil.WriteFile(filepath.Join(s.seriesPath, "blah.notacharm"), nil, 0666)
523
 
        c.Assert(err, IsNil)
 
523
        c.Assert(err, gc.IsNil)
524
524
        err = os.Mkdir(filepath.Join(s.seriesPath, ".blah"), 0666)
525
 
        c.Assert(err, IsNil)
 
525
        c.Assert(err, gc.IsNil)
526
526
        renameSibling(c, s.addDir("dummy"), ".dummy")
527
527
        renameSibling(c, s.addBundle("dummy"), "dummy.notacharm")
528
528
        charmURL := charm.MustParseURL("local:series/dummy")
531
531
        s.checkNotFoundErr(c, err, charmURL)
532
532
        _, err = s.repo.Latest(charmURL)
533
533
        s.checkNotFoundErr(c, err, charmURL)
534
 
        c.Assert(c.GetTestLog(), Equals, "")
 
534
        c.Assert(c.GetTestLog(), gc.Equals, "")
535
535
}
536
536
 
537
 
func (s *LocalRepoSuite) TestFindsSymlinks(c *C) {
 
537
func (s *LocalRepoSuite) TestFindsSymlinks(c *gc.C) {
538
538
        realPath := testing.Charms.ClonedDirPath(c.MkDir(), "dummy")
539
539
        linkPath := filepath.Join(s.seriesPath, "dummy")
540
540
        err := os.Symlink(realPath, linkPath)
541
 
        c.Assert(err, IsNil)
 
541
        c.Assert(err, gc.IsNil)
542
542
        ch, err := s.repo.Get(charm.MustParseURL("local:series/dummy"))
543
 
        c.Assert(err, IsNil)
 
543
        c.Assert(err, gc.IsNil)
544
544
        checkDummy(c, ch, linkPath)
545
545
}