oppi.li
fork of go-git with some jj specific features
1package git
2
3import (
4 "bytes"
5 "context"
6 "fmt"
7 "io"
8 "io/ioutil"
9 "os"
10 "os/exec"
11 "path/filepath"
12 "strings"
13 "time"
14
15 "gopkg.in/src-d/go-git.v4/config"
16 "gopkg.in/src-d/go-git.v4/plumbing"
17 "gopkg.in/src-d/go-git.v4/plumbing/object"
18 "gopkg.in/src-d/go-git.v4/plumbing/storer"
19 "gopkg.in/src-d/go-git.v4/storage"
20 "gopkg.in/src-d/go-git.v4/storage/filesystem"
21 "gopkg.in/src-d/go-git.v4/storage/memory"
22
23 . "gopkg.in/check.v1"
24 "gopkg.in/src-d/go-billy.v4/memfs"
25 "gopkg.in/src-d/go-billy.v4/osfs"
26 "gopkg.in/src-d/go-billy.v4/util"
27 "gopkg.in/src-d/go-git-fixtures.v3"
28)
29
30type RepositorySuite struct {
31 BaseSuite
32}
33
34var _ = Suite(&RepositorySuite{})
35
36func (s *RepositorySuite) TestInit(c *C) {
37 r, err := Init(memory.NewStorage(), memfs.New())
38 c.Assert(err, IsNil)
39 c.Assert(r, NotNil)
40
41 cfg, err := r.Config()
42 c.Assert(err, IsNil)
43 c.Assert(cfg.Core.IsBare, Equals, false)
44}
45
46func (s *RepositorySuite) TestInitNonStandardDotGit(c *C) {
47 dir, err := ioutil.TempDir("", "init-non-standard")
48 c.Assert(err, IsNil)
49 c.Assert(os.RemoveAll(dir), IsNil)
50
51 fs := osfs.New(dir)
52 dot, _ := fs.Chroot("storage")
53 storage, err := filesystem.NewStorage(dot)
54 c.Assert(err, IsNil)
55
56 wt, _ := fs.Chroot("worktree")
57 r, err := Init(storage, wt)
58 c.Assert(err, IsNil)
59 c.Assert(r, NotNil)
60
61 f, err := fs.Open(fs.Join("worktree", ".git"))
62 c.Assert(err, IsNil)
63
64 all, err := ioutil.ReadAll(f)
65 c.Assert(err, IsNil)
66 c.Assert(string(all), Equals, fmt.Sprintf("gitdir: %s\n", filepath.Join("..", "storage")))
67
68 cfg, err := r.Config()
69 c.Assert(err, IsNil)
70 c.Assert(cfg.Core.Worktree, Equals, filepath.Join("..", "worktree"))
71}
72
73func (s *RepositorySuite) TestInitStandardDotGit(c *C) {
74 dir, err := ioutil.TempDir("", "init-standard")
75 c.Assert(err, IsNil)
76 c.Assert(os.RemoveAll(dir), IsNil)
77
78 fs := osfs.New(dir)
79 dot, _ := fs.Chroot(".git")
80 storage, err := filesystem.NewStorage(dot)
81 c.Assert(err, IsNil)
82
83 r, err := Init(storage, fs)
84 c.Assert(err, IsNil)
85 c.Assert(r, NotNil)
86
87 l, err := fs.ReadDir(".git")
88 c.Assert(err, IsNil)
89 c.Assert(len(l) > 0, Equals, true)
90
91 cfg, err := r.Config()
92 c.Assert(err, IsNil)
93 c.Assert(cfg.Core.Worktree, Equals, "")
94}
95
96func (s *RepositorySuite) TestInitBare(c *C) {
97 r, err := Init(memory.NewStorage(), nil)
98 c.Assert(err, IsNil)
99 c.Assert(r, NotNil)
100
101 cfg, err := r.Config()
102 c.Assert(err, IsNil)
103 c.Assert(cfg.Core.IsBare, Equals, true)
104
105}
106
107func (s *RepositorySuite) TestInitAlreadyExists(c *C) {
108 st := memory.NewStorage()
109
110 r, err := Init(st, nil)
111 c.Assert(err, IsNil)
112 c.Assert(r, NotNil)
113
114 r, err = Init(st, nil)
115 c.Assert(err, Equals, ErrRepositoryAlreadyExists)
116 c.Assert(r, IsNil)
117}
118
119func (s *RepositorySuite) TestOpen(c *C) {
120 st := memory.NewStorage()
121
122 r, err := Init(st, memfs.New())
123 c.Assert(err, IsNil)
124 c.Assert(r, NotNil)
125
126 r, err = Open(st, memfs.New())
127 c.Assert(err, IsNil)
128 c.Assert(r, NotNil)
129}
130
131func (s *RepositorySuite) TestOpenBare(c *C) {
132 st := memory.NewStorage()
133
134 r, err := Init(st, nil)
135 c.Assert(err, IsNil)
136 c.Assert(r, NotNil)
137
138 r, err = Open(st, nil)
139 c.Assert(err, IsNil)
140 c.Assert(r, NotNil)
141}
142
143func (s *RepositorySuite) TestOpenMissingWorktree(c *C) {
144 st := memory.NewStorage()
145
146 r, err := Init(st, memfs.New())
147 c.Assert(err, IsNil)
148 c.Assert(r, NotNil)
149
150 r, err = Open(st, nil)
151 c.Assert(err, Equals, ErrWorktreeNotProvided)
152 c.Assert(r, IsNil)
153}
154
155func (s *RepositorySuite) TestOpenNotExists(c *C) {
156 r, err := Open(memory.NewStorage(), nil)
157 c.Assert(err, Equals, ErrRepositoryNotExists)
158 c.Assert(r, IsNil)
159}
160
161func (s *RepositorySuite) TestClone(c *C) {
162 r, err := Clone(memory.NewStorage(), nil, &CloneOptions{
163 URL: s.GetBasicLocalRepositoryURL(),
164 })
165
166 c.Assert(err, IsNil)
167
168 remotes, err := r.Remotes()
169 c.Assert(err, IsNil)
170 c.Assert(remotes, HasLen, 1)
171}
172
173func (s *RepositorySuite) TestCloneContext(c *C) {
174 ctx, cancel := context.WithCancel(context.Background())
175 cancel()
176
177 _, err := CloneContext(ctx, memory.NewStorage(), nil, &CloneOptions{
178 URL: s.GetBasicLocalRepositoryURL(),
179 })
180
181 c.Assert(err, NotNil)
182}
183
184func (s *RepositorySuite) TestCloneWithTags(c *C) {
185 url := s.GetLocalRepositoryURL(
186 fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
187 )
188
189 r, err := Clone(memory.NewStorage(), nil, &CloneOptions{URL: url, Tags: NoTags})
190 c.Assert(err, IsNil)
191
192 remotes, err := r.Remotes()
193 c.Assert(err, IsNil)
194 c.Assert(remotes, HasLen, 1)
195
196 i, err := r.References()
197 c.Assert(err, IsNil)
198
199 var count int
200 i.ForEach(func(r *plumbing.Reference) error { count++; return nil })
201
202 c.Assert(count, Equals, 3)
203}
204
205func (s *RepositorySuite) TestCreateRemoteAndRemote(c *C) {
206 r, _ := Init(memory.NewStorage(), nil)
207 remote, err := r.CreateRemote(&config.RemoteConfig{
208 Name: "foo",
209 URLs: []string{"http://foo/foo.git"},
210 })
211
212 c.Assert(err, IsNil)
213 c.Assert(remote.Config().Name, Equals, "foo")
214
215 alt, err := r.Remote("foo")
216 c.Assert(err, IsNil)
217 c.Assert(alt, Not(Equals), remote)
218 c.Assert(alt.Config().Name, Equals, "foo")
219}
220
221func (s *RepositorySuite) TestCreateRemoteInvalid(c *C) {
222 r, _ := Init(memory.NewStorage(), nil)
223 remote, err := r.CreateRemote(&config.RemoteConfig{})
224
225 c.Assert(err, Equals, config.ErrRemoteConfigEmptyName)
226 c.Assert(remote, IsNil)
227}
228
229func (s *RepositorySuite) TestDeleteRemote(c *C) {
230 r, _ := Init(memory.NewStorage(), nil)
231 _, err := r.CreateRemote(&config.RemoteConfig{
232 Name: "foo",
233 URLs: []string{"http://foo/foo.git"},
234 })
235
236 c.Assert(err, IsNil)
237
238 err = r.DeleteRemote("foo")
239 c.Assert(err, IsNil)
240
241 alt, err := r.Remote("foo")
242 c.Assert(err, Equals, ErrRemoteNotFound)
243 c.Assert(alt, IsNil)
244}
245
246func (s *RepositorySuite) TestPlainInit(c *C) {
247 dir, err := ioutil.TempDir("", "plain-init")
248 c.Assert(err, IsNil)
249 defer os.RemoveAll(dir)
250
251 r, err := PlainInit(dir, true)
252 c.Assert(err, IsNil)
253 c.Assert(r, NotNil)
254
255 cfg, err := r.Config()
256 c.Assert(err, IsNil)
257 c.Assert(cfg.Core.IsBare, Equals, true)
258}
259
260func (s *RepositorySuite) TestPlainInitAlreadyExists(c *C) {
261 dir, err := ioutil.TempDir("", "plain-init")
262 c.Assert(err, IsNil)
263 defer os.RemoveAll(dir)
264
265 r, err := PlainInit(dir, true)
266 c.Assert(err, IsNil)
267 c.Assert(r, NotNil)
268
269 r, err = PlainInit(dir, true)
270 c.Assert(err, Equals, ErrRepositoryAlreadyExists)
271 c.Assert(r, IsNil)
272}
273
274func (s *RepositorySuite) TestPlainOpen(c *C) {
275 dir, err := ioutil.TempDir("", "plain-open")
276 c.Assert(err, IsNil)
277 defer os.RemoveAll(dir)
278
279 r, err := PlainInit(dir, false)
280 c.Assert(err, IsNil)
281 c.Assert(r, NotNil)
282
283 r, err = PlainOpen(dir)
284 c.Assert(err, IsNil)
285 c.Assert(r, NotNil)
286}
287
288func (s *RepositorySuite) TestPlainOpenBare(c *C) {
289 dir, err := ioutil.TempDir("", "plain-open")
290 c.Assert(err, IsNil)
291 defer os.RemoveAll(dir)
292
293 r, err := PlainInit(dir, true)
294 c.Assert(err, IsNil)
295 c.Assert(r, NotNil)
296
297 r, err = PlainOpen(dir)
298 c.Assert(err, IsNil)
299 c.Assert(r, NotNil)
300}
301
302func (s *RepositorySuite) TestPlainOpenNotBare(c *C) {
303 dir, err := ioutil.TempDir("", "plain-open")
304 c.Assert(err, IsNil)
305 defer os.RemoveAll(dir)
306
307 r, err := PlainInit(dir, false)
308 c.Assert(err, IsNil)
309 c.Assert(r, NotNil)
310
311 r, err = PlainOpen(filepath.Join(dir, ".git"))
312 c.Assert(err, Equals, ErrWorktreeNotProvided)
313 c.Assert(r, IsNil)
314}
315
316func (s *RepositorySuite) testPlainOpenGitFile(c *C, f func(string, string) string) {
317 dir, err := ioutil.TempDir("", "plain-open")
318 c.Assert(err, IsNil)
319 defer os.RemoveAll(dir)
320
321 r, err := PlainInit(dir, true)
322 c.Assert(err, IsNil)
323 c.Assert(r, NotNil)
324
325 altDir, err := ioutil.TempDir("", "plain-open")
326 c.Assert(err, IsNil)
327 defer os.RemoveAll(altDir)
328
329 err = ioutil.WriteFile(filepath.Join(altDir, ".git"), []byte(f(dir, altDir)), 0644)
330 c.Assert(err, IsNil)
331
332 r, err = PlainOpen(altDir)
333 c.Assert(err, IsNil)
334 c.Assert(r, NotNil)
335}
336
337func (s *RepositorySuite) TestPlainOpenBareAbsoluteGitDirFile(c *C) {
338 s.testPlainOpenGitFile(c, func(dir, altDir string) string {
339 return fmt.Sprintf("gitdir: %s\n", dir)
340 })
341}
342
343func (s *RepositorySuite) TestPlainOpenBareAbsoluteGitDirFileNoEOL(c *C) {
344 s.testPlainOpenGitFile(c, func(dir, altDir string) string {
345 return fmt.Sprintf("gitdir: %s", dir)
346 })
347}
348
349func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFile(c *C) {
350 s.testPlainOpenGitFile(c, func(dir, altDir string) string {
351 dir, err := filepath.Rel(altDir, dir)
352 c.Assert(err, IsNil)
353 return fmt.Sprintf("gitdir: %s\n", dir)
354 })
355}
356
357func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileNoEOL(c *C) {
358 s.testPlainOpenGitFile(c, func(dir, altDir string) string {
359 dir, err := filepath.Rel(altDir, dir)
360 c.Assert(err, IsNil)
361 return fmt.Sprintf("gitdir: %s\n", dir)
362 })
363}
364
365func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileTrailingGarbage(c *C) {
366 dir, err := ioutil.TempDir("", "plain-open")
367 c.Assert(err, IsNil)
368 defer os.RemoveAll(dir)
369
370 r, err := PlainInit(dir, true)
371 c.Assert(err, IsNil)
372 c.Assert(r, NotNil)
373
374 altDir, err := ioutil.TempDir("", "plain-open")
375 c.Assert(err, IsNil)
376 err = ioutil.WriteFile(filepath.Join(altDir, ".git"), []byte(fmt.Sprintf("gitdir: %s\nTRAILING", altDir)), 0644)
377 c.Assert(err, IsNil)
378
379 r, err = PlainOpen(altDir)
380 c.Assert(err, Equals, ErrRepositoryNotExists)
381 c.Assert(r, IsNil)
382}
383
384func (s *RepositorySuite) TestPlainOpenBareRelativeGitDirFileBadPrefix(c *C) {
385 dir, err := ioutil.TempDir("", "plain-open")
386 c.Assert(err, IsNil)
387 defer os.RemoveAll(dir)
388
389 r, err := PlainInit(dir, true)
390 c.Assert(err, IsNil)
391 c.Assert(r, NotNil)
392
393 altDir, err := ioutil.TempDir("", "plain-open")
394 c.Assert(err, IsNil)
395 err = ioutil.WriteFile(filepath.Join(altDir, ".git"), []byte(fmt.Sprintf("xgitdir: %s\n", dir)), 0644)
396 c.Assert(err, IsNil)
397
398 r, err = PlainOpen(altDir)
399 c.Assert(err, ErrorMatches, ".*gitdir.*")
400 c.Assert(r, IsNil)
401}
402
403func (s *RepositorySuite) TestPlainOpenNotExists(c *C) {
404 r, err := PlainOpen("/not-exists/")
405 c.Assert(err, Equals, ErrRepositoryNotExists)
406 c.Assert(r, IsNil)
407}
408
409func (s *RepositorySuite) TestPlainClone(c *C) {
410 r, err := PlainClone(c.MkDir(), false, &CloneOptions{
411 URL: s.GetBasicLocalRepositoryURL(),
412 })
413
414 c.Assert(err, IsNil)
415
416 remotes, err := r.Remotes()
417 c.Assert(err, IsNil)
418 c.Assert(remotes, HasLen, 1)
419}
420
421func (s *RepositorySuite) TestPlainCloneContext(c *C) {
422 ctx, cancel := context.WithCancel(context.Background())
423 cancel()
424
425 _, err := PlainCloneContext(ctx, c.MkDir(), false, &CloneOptions{
426 URL: s.GetBasicLocalRepositoryURL(),
427 })
428
429 c.Assert(err, NotNil)
430}
431
432func (s *RepositorySuite) TestPlainCloneWithRecurseSubmodules(c *C) {
433 dir, err := ioutil.TempDir("", "plain-clone-submodule")
434 c.Assert(err, IsNil)
435 defer os.RemoveAll(dir)
436
437 path := fixtures.ByTag("submodule").One().Worktree().Root()
438 r, err := PlainClone(dir, false, &CloneOptions{
439 URL: path,
440 RecurseSubmodules: DefaultSubmoduleRecursionDepth,
441 })
442
443 c.Assert(err, IsNil)
444
445 cfg, err := r.Config()
446 c.Assert(err, IsNil)
447 c.Assert(cfg.Remotes, HasLen, 1)
448 c.Assert(cfg.Submodules, HasLen, 2)
449}
450
451func (s *RepositorySuite) TestPlainCloneNoCheckout(c *C) {
452 dir, err := ioutil.TempDir("", "plain-clone-no-checkout")
453 c.Assert(err, IsNil)
454 defer os.RemoveAll(dir)
455
456 path := fixtures.ByTag("submodule").One().Worktree().Root()
457 r, err := PlainClone(dir, false, &CloneOptions{
458 URL: path,
459 NoCheckout: true,
460 RecurseSubmodules: DefaultSubmoduleRecursionDepth,
461 })
462 c.Assert(err, IsNil)
463
464 h, err := r.Head()
465 c.Assert(err, IsNil)
466 c.Assert(h.Hash().String(), Equals, "b685400c1f9316f350965a5993d350bc746b0bf4")
467
468 fi, err := osfs.New(dir).ReadDir("")
469 c.Assert(err, IsNil)
470 c.Assert(fi, HasLen, 1) // .git
471}
472
473func (s *RepositorySuite) TestFetch(c *C) {
474 r, _ := Init(memory.NewStorage(), nil)
475 _, err := r.CreateRemote(&config.RemoteConfig{
476 Name: DefaultRemoteName,
477 URLs: []string{s.GetBasicLocalRepositoryURL()},
478 })
479 c.Assert(err, IsNil)
480 c.Assert(r.Fetch(&FetchOptions{}), IsNil)
481
482 remotes, err := r.Remotes()
483 c.Assert(err, IsNil)
484 c.Assert(remotes, HasLen, 1)
485
486 _, err = r.Head()
487 c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
488
489 branch, err := r.Reference("refs/remotes/origin/master", false)
490 c.Assert(err, IsNil)
491 c.Assert(branch, NotNil)
492 c.Assert(branch.Type(), Equals, plumbing.HashReference)
493 c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
494}
495
496func (s *RepositorySuite) TestFetchContext(c *C) {
497 r, _ := Init(memory.NewStorage(), nil)
498 _, err := r.CreateRemote(&config.RemoteConfig{
499 Name: DefaultRemoteName,
500 URLs: []string{s.GetBasicLocalRepositoryURL()},
501 })
502 c.Assert(err, IsNil)
503
504 ctx, cancel := context.WithCancel(context.Background())
505 cancel()
506
507 c.Assert(r.FetchContext(ctx, &FetchOptions{}), NotNil)
508}
509
510func (s *RepositorySuite) TestCloneWithProgress(c *C) {
511 fs := memfs.New()
512
513 buf := bytes.NewBuffer(nil)
514 _, err := Clone(memory.NewStorage(), fs, &CloneOptions{
515 URL: s.GetBasicLocalRepositoryURL(),
516 Progress: buf,
517 })
518
519 c.Assert(err, IsNil)
520 c.Assert(buf.Len(), Not(Equals), 0)
521}
522
523func (s *RepositorySuite) TestCloneDeep(c *C) {
524 fs := memfs.New()
525 r, _ := Init(memory.NewStorage(), fs)
526
527 head, err := r.Head()
528 c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
529 c.Assert(head, IsNil)
530
531 err = r.clone(context.Background(), &CloneOptions{
532 URL: s.GetBasicLocalRepositoryURL(),
533 })
534
535 c.Assert(err, IsNil)
536
537 remotes, err := r.Remotes()
538 c.Assert(err, IsNil)
539 c.Assert(remotes, HasLen, 1)
540
541 head, err = r.Reference(plumbing.HEAD, false)
542 c.Assert(err, IsNil)
543 c.Assert(head, NotNil)
544 c.Assert(head.Type(), Equals, plumbing.SymbolicReference)
545 c.Assert(head.Target().String(), Equals, "refs/heads/master")
546
547 branch, err := r.Reference(head.Target(), false)
548 c.Assert(err, IsNil)
549 c.Assert(branch, NotNil)
550 c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
551
552 branch, err = r.Reference("refs/remotes/origin/master", false)
553 c.Assert(err, IsNil)
554 c.Assert(branch, NotNil)
555 c.Assert(branch.Type(), Equals, plumbing.HashReference)
556 c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
557
558 fi, err := fs.ReadDir("")
559 c.Assert(err, IsNil)
560 c.Assert(fi, HasLen, 8)
561}
562
563func (s *RepositorySuite) TestCloneConfig(c *C) {
564 r, _ := Init(memory.NewStorage(), nil)
565
566 head, err := r.Head()
567 c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
568 c.Assert(head, IsNil)
569
570 err = r.clone(context.Background(), &CloneOptions{
571 URL: s.GetBasicLocalRepositoryURL(),
572 })
573
574 c.Assert(err, IsNil)
575
576 cfg, err := r.Config()
577 c.Assert(err, IsNil)
578
579 c.Assert(cfg.Core.IsBare, Equals, true)
580 c.Assert(cfg.Remotes, HasLen, 1)
581 c.Assert(cfg.Remotes["origin"].Name, Equals, "origin")
582 c.Assert(cfg.Remotes["origin"].URLs, HasLen, 1)
583}
584
585func (s *RepositorySuite) TestCloneSingleBranchAndNonHEAD(c *C) {
586 r, _ := Init(memory.NewStorage(), nil)
587
588 head, err := r.Head()
589 c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
590 c.Assert(head, IsNil)
591
592 err = r.clone(context.Background(), &CloneOptions{
593 URL: s.GetBasicLocalRepositoryURL(),
594 ReferenceName: plumbing.ReferenceName("refs/heads/branch"),
595 SingleBranch: true,
596 })
597
598 c.Assert(err, IsNil)
599
600 remotes, err := r.Remotes()
601 c.Assert(err, IsNil)
602 c.Assert(remotes, HasLen, 1)
603
604 head, err = r.Reference(plumbing.HEAD, false)
605 c.Assert(err, IsNil)
606 c.Assert(head, NotNil)
607 c.Assert(head.Type(), Equals, plumbing.SymbolicReference)
608 c.Assert(head.Target().String(), Equals, "refs/heads/branch")
609
610 branch, err := r.Reference(head.Target(), false)
611 c.Assert(err, IsNil)
612 c.Assert(branch, NotNil)
613 c.Assert(branch.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
614
615 branch, err = r.Reference("refs/remotes/origin/branch", false)
616 c.Assert(err, IsNil)
617 c.Assert(branch, NotNil)
618 c.Assert(branch.Type(), Equals, plumbing.HashReference)
619 c.Assert(branch.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
620}
621
622func (s *RepositorySuite) TestCloneSingleBranch(c *C) {
623 r, _ := Init(memory.NewStorage(), nil)
624
625 head, err := r.Head()
626 c.Assert(err, Equals, plumbing.ErrReferenceNotFound)
627 c.Assert(head, IsNil)
628
629 err = r.clone(context.Background(), &CloneOptions{
630 URL: s.GetBasicLocalRepositoryURL(),
631 SingleBranch: true,
632 })
633
634 c.Assert(err, IsNil)
635
636 remotes, err := r.Remotes()
637 c.Assert(err, IsNil)
638 c.Assert(remotes, HasLen, 1)
639
640 head, err = r.Reference(plumbing.HEAD, false)
641 c.Assert(err, IsNil)
642 c.Assert(head, NotNil)
643 c.Assert(head.Type(), Equals, plumbing.SymbolicReference)
644 c.Assert(head.Target().String(), Equals, "refs/heads/master")
645
646 branch, err := r.Reference(head.Target(), false)
647 c.Assert(err, IsNil)
648 c.Assert(branch, NotNil)
649 c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
650
651 branch, err = r.Reference("refs/remotes/origin/master", false)
652 c.Assert(err, IsNil)
653 c.Assert(branch, NotNil)
654 c.Assert(branch.Type(), Equals, plumbing.HashReference)
655 c.Assert(branch.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
656}
657
658func (s *RepositorySuite) TestCloneDetachedHEAD(c *C) {
659 r, _ := Init(memory.NewStorage(), nil)
660 err := r.clone(context.Background(), &CloneOptions{
661 URL: s.GetBasicLocalRepositoryURL(),
662 ReferenceName: plumbing.ReferenceName("refs/tags/v1.0.0"),
663 })
664 c.Assert(err, IsNil)
665
666 head, err := r.Reference(plumbing.HEAD, false)
667 c.Assert(err, IsNil)
668 c.Assert(head, NotNil)
669 c.Assert(head.Type(), Equals, plumbing.HashReference)
670 c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
671
672 count := 0
673 objects, err := r.Objects()
674 c.Assert(err, IsNil)
675 objects.ForEach(func(object.Object) error { count++; return nil })
676 c.Assert(count, Equals, 31)
677}
678
679func (s *RepositorySuite) TestCloneDetachedHEADAndShallow(c *C) {
680 r, _ := Init(memory.NewStorage(), memfs.New())
681 err := r.clone(context.Background(), &CloneOptions{
682 URL: s.GetBasicLocalRepositoryURL(),
683 ReferenceName: plumbing.ReferenceName("refs/tags/v1.0.0"),
684 Depth: 1,
685 })
686
687 c.Assert(err, IsNil)
688
689 head, err := r.Reference(plumbing.HEAD, false)
690 c.Assert(err, IsNil)
691 c.Assert(head, NotNil)
692 c.Assert(head.Type(), Equals, plumbing.HashReference)
693 c.Assert(head.Hash().String(), Equals, "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
694
695 count := 0
696 objects, err := r.Objects()
697 c.Assert(err, IsNil)
698 objects.ForEach(func(object.Object) error { count++; return nil })
699 c.Assert(count, Equals, 15)
700}
701
702func (s *RepositorySuite) TestCloneDetachedHEADAnnotatedTag(c *C) {
703 r, _ := Init(memory.NewStorage(), nil)
704 err := r.clone(context.Background(), &CloneOptions{
705 URL: s.GetLocalRepositoryURL(fixtures.ByTag("tags").One()),
706 ReferenceName: plumbing.ReferenceName("refs/tags/annotated-tag"),
707 })
708 c.Assert(err, IsNil)
709
710 head, err := r.Reference(plumbing.HEAD, false)
711 c.Assert(err, IsNil)
712 c.Assert(head, NotNil)
713 c.Assert(head.Type(), Equals, plumbing.HashReference)
714 c.Assert(head.Hash().String(), Equals, "f7b877701fbf855b44c0a9e86f3fdce2c298b07f")
715
716 count := 0
717 objects, err := r.Objects()
718 c.Assert(err, IsNil)
719 objects.ForEach(func(object.Object) error { count++; return nil })
720 c.Assert(count, Equals, 7)
721}
722
723func (s *RepositorySuite) TestPush(c *C) {
724 url := c.MkDir()
725 server, err := PlainInit(url, true)
726 c.Assert(err, IsNil)
727
728 _, err = s.Repository.CreateRemote(&config.RemoteConfig{
729 Name: "test",
730 URLs: []string{url},
731 })
732 c.Assert(err, IsNil)
733
734 err = s.Repository.Push(&PushOptions{
735 RemoteName: "test",
736 })
737 c.Assert(err, IsNil)
738
739 AssertReferences(c, server, map[string]string{
740 "refs/heads/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
741 "refs/heads/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881",
742 })
743
744 AssertReferences(c, s.Repository, map[string]string{
745 "refs/remotes/test/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
746 "refs/remotes/test/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881",
747 })
748}
749
750func (s *RepositorySuite) TestPushContext(c *C) {
751 url := c.MkDir()
752 _, err := PlainInit(url, true)
753 c.Assert(err, IsNil)
754
755 _, err = s.Repository.CreateRemote(&config.RemoteConfig{
756 Name: "foo",
757 URLs: []string{url},
758 })
759 c.Assert(err, IsNil)
760
761 ctx, cancel := context.WithCancel(context.Background())
762 cancel()
763
764 err = s.Repository.PushContext(ctx, &PushOptions{
765 RemoteName: "foo",
766 })
767 c.Assert(err, NotNil)
768}
769
770// installPreReceiveHook installs a pre-receive hook in the .git
771// directory at path which prints message m before exiting
772// successfully.
773func installPreReceiveHook(c *C, path, m string) {
774 hooks := filepath.Join(path, "hooks")
775 err := os.MkdirAll(hooks, 0777)
776 c.Assert(err, IsNil)
777
778 err = ioutil.WriteFile(filepath.Join(hooks, "pre-receive"), preReceiveHook(m), 0777)
779 c.Assert(err, IsNil)
780}
781
782func (s *RepositorySuite) TestPushWithProgress(c *C) {
783 url := c.MkDir()
784 server, err := PlainInit(url, true)
785 c.Assert(err, IsNil)
786
787 m := "Receiving..."
788 installPreReceiveHook(c, url, m)
789
790 _, err = s.Repository.CreateRemote(&config.RemoteConfig{
791 Name: "bar",
792 URLs: []string{url},
793 })
794 c.Assert(err, IsNil)
795
796 var p bytes.Buffer
797 err = s.Repository.Push(&PushOptions{
798 RemoteName: "bar",
799 Progress: &p,
800 })
801 c.Assert(err, IsNil)
802
803 AssertReferences(c, server, map[string]string{
804 "refs/heads/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
805 "refs/heads/branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881",
806 })
807
808 c.Assert((&p).Bytes(), DeepEquals, []byte(m))
809}
810
811func (s *RepositorySuite) TestPushDepth(c *C) {
812 url := c.MkDir()
813 server, err := PlainClone(url, true, &CloneOptions{
814 URL: fixtures.Basic().One().DotGit().Root(),
815 })
816
817 c.Assert(err, IsNil)
818
819 r, err := Clone(memory.NewStorage(), memfs.New(), &CloneOptions{
820 URL: url,
821 Depth: 1,
822 })
823 c.Assert(err, IsNil)
824
825 err = util.WriteFile(r.wt, "foo", nil, 0755)
826 c.Assert(err, IsNil)
827
828 w, err := r.Worktree()
829 c.Assert(err, IsNil)
830
831 _, err = w.Add("foo")
832 c.Assert(err, IsNil)
833
834 hash, err := w.Commit("foo", &CommitOptions{
835 Author: defaultSignature(),
836 Committer: defaultSignature(),
837 })
838 c.Assert(err, IsNil)
839
840 err = r.Push(&PushOptions{})
841 c.Assert(err, IsNil)
842
843 AssertReferences(c, server, map[string]string{
844 "refs/heads/master": hash.String(),
845 })
846
847 AssertReferences(c, r, map[string]string{
848 "refs/remotes/origin/master": hash.String(),
849 })
850}
851
852func (s *RepositorySuite) TestPushNonExistentRemote(c *C) {
853 srcFs := fixtures.Basic().One().DotGit()
854 sto, err := filesystem.NewStorage(srcFs)
855 c.Assert(err, IsNil)
856
857 r, err := Open(sto, srcFs)
858 c.Assert(err, IsNil)
859
860 err = r.Push(&PushOptions{RemoteName: "myremote"})
861 c.Assert(err, ErrorMatches, ".*remote not found.*")
862}
863
864func (s *RepositorySuite) TestLog(c *C) {
865 r, _ := Init(memory.NewStorage(), nil)
866 err := r.clone(context.Background(), &CloneOptions{
867 URL: s.GetBasicLocalRepositoryURL(),
868 })
869
870 c.Assert(err, IsNil)
871
872 cIter, err := r.Log(&LogOptions{
873 plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"),
874 })
875
876 c.Assert(err, IsNil)
877
878 commitOrder := []plumbing.Hash{
879 plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"),
880 plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
881 }
882
883 for _, o := range commitOrder {
884 commit, err := cIter.Next()
885 c.Assert(err, IsNil)
886 c.Assert(commit.Hash, Equals, o)
887 }
888 _, err = cIter.Next()
889 c.Assert(err, Equals, io.EOF)
890}
891
892func (s *RepositorySuite) TestLogHead(c *C) {
893 r, _ := Init(memory.NewStorage(), nil)
894 err := r.clone(context.Background(), &CloneOptions{
895 URL: s.GetBasicLocalRepositoryURL(),
896 })
897
898 c.Assert(err, IsNil)
899
900 cIter, err := r.Log(&LogOptions{})
901
902 c.Assert(err, IsNil)
903
904 commitOrder := []plumbing.Hash{
905 plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
906 plumbing.NewHash("918c48b83bd081e863dbe1b80f8998f058cd8294"),
907 plumbing.NewHash("af2d6a6954d532f8ffb47615169c8fdf9d383a1a"),
908 plumbing.NewHash("1669dce138d9b841a518c64b10914d88f5e488ea"),
909 plumbing.NewHash("35e85108805c84807bc66a02d91535e1e24b38b9"),
910 plumbing.NewHash("b029517f6300c2da0f4b651b8642506cd6aaf45d"),
911 plumbing.NewHash("a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69"),
912 plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"),
913 }
914
915 for _, o := range commitOrder {
916 commit, err := cIter.Next()
917 c.Assert(err, IsNil)
918 c.Assert(commit.Hash, Equals, o)
919 }
920 _, err = cIter.Next()
921 c.Assert(err, Equals, io.EOF)
922}
923
924func (s *RepositorySuite) TestLogError(c *C) {
925 r, _ := Init(memory.NewStorage(), nil)
926 err := r.clone(context.Background(), &CloneOptions{
927 URL: s.GetBasicLocalRepositoryURL(),
928 })
929
930 c.Assert(err, IsNil)
931
932 _, err = r.Log(&LogOptions{
933 plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
934 })
935 c.Assert(err, NotNil)
936}
937
938func (s *RepositorySuite) TestCommit(c *C) {
939 r, _ := Init(memory.NewStorage(), nil)
940 err := r.clone(context.Background(), &CloneOptions{
941 URL: s.GetBasicLocalRepositoryURL(),
942 })
943
944 c.Assert(err, IsNil)
945
946 hash := plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47")
947 commit, err := r.CommitObject(hash)
948 c.Assert(err, IsNil)
949
950 c.Assert(commit.Hash.IsZero(), Equals, false)
951 c.Assert(commit.Hash, Equals, commit.ID())
952 c.Assert(commit.Hash, Equals, hash)
953 c.Assert(commit.Type(), Equals, plumbing.CommitObject)
954
955 tree, err := commit.Tree()
956 c.Assert(err, IsNil)
957 c.Assert(tree.Hash.IsZero(), Equals, false)
958
959 c.Assert(commit.Author.Email, Equals, "daniel@lordran.local")
960}
961
962func (s *RepositorySuite) TestCommits(c *C) {
963 r, _ := Init(memory.NewStorage(), nil)
964 err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
965 c.Assert(err, IsNil)
966
967 count := 0
968 commits, err := r.CommitObjects()
969 c.Assert(err, IsNil)
970 for {
971 commit, err := commits.Next()
972 if err != nil {
973 break
974 }
975
976 count++
977 c.Assert(commit.Hash.IsZero(), Equals, false)
978 c.Assert(commit.Hash, Equals, commit.ID())
979 c.Assert(commit.Type(), Equals, plumbing.CommitObject)
980 }
981
982 c.Assert(count, Equals, 9)
983}
984
985func (s *RepositorySuite) TestBlob(c *C) {
986 r, _ := Init(memory.NewStorage(), nil)
987 err := r.clone(context.Background(), &CloneOptions{
988 URL: s.GetBasicLocalRepositoryURL(),
989 })
990
991 c.Assert(err, IsNil)
992
993 blob, err := r.BlobObject(plumbing.NewHash("b8e471f58bcbca63b07bda20e428190409c2db47"))
994 c.Assert(err, NotNil)
995 c.Assert(blob, IsNil)
996
997 blobHash := plumbing.NewHash("9a48f23120e880dfbe41f7c9b7b708e9ee62a492")
998 blob, err = r.BlobObject(blobHash)
999 c.Assert(err, IsNil)
1000
1001 c.Assert(blob.Hash.IsZero(), Equals, false)
1002 c.Assert(blob.Hash, Equals, blob.ID())
1003 c.Assert(blob.Hash, Equals, blobHash)
1004 c.Assert(blob.Type(), Equals, plumbing.BlobObject)
1005}
1006
1007func (s *RepositorySuite) TestBlobs(c *C) {
1008 r, _ := Init(memory.NewStorage(), nil)
1009 err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
1010 c.Assert(err, IsNil)
1011
1012 count := 0
1013 blobs, err := r.BlobObjects()
1014 c.Assert(err, IsNil)
1015 for {
1016 blob, err := blobs.Next()
1017 if err != nil {
1018 break
1019 }
1020
1021 count++
1022 c.Assert(blob.Hash.IsZero(), Equals, false)
1023 c.Assert(blob.Hash, Equals, blob.ID())
1024 c.Assert(blob.Type(), Equals, plumbing.BlobObject)
1025 }
1026
1027 c.Assert(count, Equals, 10)
1028}
1029
1030func (s *RepositorySuite) TestTagObject(c *C) {
1031 url := s.GetLocalRepositoryURL(
1032 fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
1033 )
1034
1035 r, _ := Init(memory.NewStorage(), nil)
1036 err := r.clone(context.Background(), &CloneOptions{URL: url})
1037 c.Assert(err, IsNil)
1038
1039 hash := plumbing.NewHash("ad7897c0fb8e7d9a9ba41fa66072cf06095a6cfc")
1040 tag, err := r.TagObject(hash)
1041 c.Assert(err, IsNil)
1042
1043 c.Assert(tag.Hash.IsZero(), Equals, false)
1044 c.Assert(tag.Hash, Equals, hash)
1045 c.Assert(tag.Type(), Equals, plumbing.TagObject)
1046}
1047
1048func (s *RepositorySuite) TestTags(c *C) {
1049 url := s.GetLocalRepositoryURL(
1050 fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
1051 )
1052
1053 r, _ := Init(memory.NewStorage(), nil)
1054 err := r.clone(context.Background(), &CloneOptions{URL: url})
1055 c.Assert(err, IsNil)
1056
1057 count := 0
1058 tags, err := r.Tags()
1059 c.Assert(err, IsNil)
1060
1061 tags.ForEach(func(tag *plumbing.Reference) error {
1062 count++
1063 c.Assert(tag.Hash().IsZero(), Equals, false)
1064 c.Assert(tag.Name().IsTag(), Equals, true)
1065 return nil
1066 })
1067
1068 c.Assert(count, Equals, 5)
1069}
1070
1071func (s *RepositorySuite) TestBranches(c *C) {
1072 f := fixtures.ByURL("https://github.com/git-fixtures/root-references.git").One()
1073 sto, err := filesystem.NewStorage(f.DotGit())
1074 c.Assert(err, IsNil)
1075 r, err := Open(sto, f.DotGit())
1076 c.Assert(err, IsNil)
1077
1078 count := 0
1079 branches, err := r.Branches()
1080 c.Assert(err, IsNil)
1081
1082 branches.ForEach(func(branch *plumbing.Reference) error {
1083 count++
1084 c.Assert(branch.Hash().IsZero(), Equals, false)
1085 c.Assert(branch.Name().IsBranch(), Equals, true)
1086 return nil
1087 })
1088
1089 c.Assert(count, Equals, 8)
1090}
1091
1092func (s *RepositorySuite) TestNotes(c *C) {
1093 // TODO add fixture with Notes
1094 url := s.GetLocalRepositoryURL(
1095 fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
1096 )
1097
1098 r, _ := Init(memory.NewStorage(), nil)
1099 err := r.clone(context.Background(), &CloneOptions{URL: url})
1100 c.Assert(err, IsNil)
1101
1102 count := 0
1103 notes, err := r.Notes()
1104 c.Assert(err, IsNil)
1105
1106 notes.ForEach(func(note *plumbing.Reference) error {
1107 count++
1108 c.Assert(note.Hash().IsZero(), Equals, false)
1109 c.Assert(note.Name().IsNote(), Equals, true)
1110 return nil
1111 })
1112
1113 c.Assert(count, Equals, 0)
1114}
1115
1116func (s *RepositorySuite) TestTree(c *C) {
1117 r, _ := Init(memory.NewStorage(), nil)
1118 err := r.clone(context.Background(), &CloneOptions{
1119 URL: s.GetBasicLocalRepositoryURL(),
1120 })
1121 c.Assert(err, IsNil)
1122
1123 invalidHash := plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
1124 tree, err := r.TreeObject(invalidHash)
1125 c.Assert(tree, IsNil)
1126 c.Assert(err, NotNil)
1127
1128 hash := plumbing.NewHash("dbd3641b371024f44d0e469a9c8f5457b0660de1")
1129 tree, err = r.TreeObject(hash)
1130 c.Assert(err, IsNil)
1131
1132 c.Assert(tree.Hash.IsZero(), Equals, false)
1133 c.Assert(tree.Hash, Equals, tree.ID())
1134 c.Assert(tree.Hash, Equals, hash)
1135 c.Assert(tree.Type(), Equals, plumbing.TreeObject)
1136 c.Assert(len(tree.Entries), Not(Equals), 0)
1137}
1138
1139func (s *RepositorySuite) TestTrees(c *C) {
1140 r, _ := Init(memory.NewStorage(), nil)
1141 err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
1142 c.Assert(err, IsNil)
1143
1144 count := 0
1145 trees, err := r.TreeObjects()
1146 c.Assert(err, IsNil)
1147 for {
1148 tree, err := trees.Next()
1149 if err != nil {
1150 break
1151 }
1152
1153 count++
1154 c.Assert(tree.Hash.IsZero(), Equals, false)
1155 c.Assert(tree.Hash, Equals, tree.ID())
1156 c.Assert(tree.Type(), Equals, plumbing.TreeObject)
1157 c.Assert(len(tree.Entries), Not(Equals), 0)
1158 }
1159
1160 c.Assert(count, Equals, 12)
1161}
1162
1163func (s *RepositorySuite) TestTagObjects(c *C) {
1164 url := s.GetLocalRepositoryURL(
1165 fixtures.ByURL("https://github.com/git-fixtures/tags.git").One(),
1166 )
1167
1168 r, _ := Init(memory.NewStorage(), nil)
1169 err := r.clone(context.Background(), &CloneOptions{URL: url})
1170 c.Assert(err, IsNil)
1171
1172 count := 0
1173 tags, err := r.TagObjects()
1174 c.Assert(err, IsNil)
1175
1176 tags.ForEach(func(tag *object.Tag) error {
1177 count++
1178
1179 c.Assert(tag.Hash.IsZero(), Equals, false)
1180 c.Assert(tag.Type(), Equals, plumbing.TagObject)
1181 return nil
1182 })
1183
1184 refs, _ := r.References()
1185 refs.ForEach(func(ref *plumbing.Reference) error {
1186 return nil
1187 })
1188
1189 c.Assert(count, Equals, 4)
1190}
1191
1192func (s *RepositorySuite) TestCommitIterClosePanic(c *C) {
1193 r, _ := Init(memory.NewStorage(), nil)
1194 err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
1195 c.Assert(err, IsNil)
1196
1197 commits, err := r.CommitObjects()
1198 c.Assert(err, IsNil)
1199 commits.Close()
1200}
1201
1202func (s *RepositorySuite) TestRef(c *C) {
1203 r, _ := Init(memory.NewStorage(), nil)
1204 err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
1205 c.Assert(err, IsNil)
1206
1207 ref, err := r.Reference(plumbing.HEAD, false)
1208 c.Assert(err, IsNil)
1209 c.Assert(ref.Name(), Equals, plumbing.HEAD)
1210
1211 ref, err = r.Reference(plumbing.HEAD, true)
1212 c.Assert(err, IsNil)
1213 c.Assert(ref.Name(), Equals, plumbing.ReferenceName("refs/heads/master"))
1214}
1215
1216func (s *RepositorySuite) TestRefs(c *C) {
1217 r, _ := Init(memory.NewStorage(), nil)
1218 err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
1219 c.Assert(err, IsNil)
1220
1221 c.Assert(err, IsNil)
1222
1223 iter, err := r.References()
1224 c.Assert(err, IsNil)
1225 c.Assert(iter, NotNil)
1226}
1227
1228func (s *RepositorySuite) TestObject(c *C) {
1229 r, _ := Init(memory.NewStorage(), nil)
1230 err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
1231 c.Assert(err, IsNil)
1232
1233 hash := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
1234 o, err := r.Object(plumbing.CommitObject, hash)
1235 c.Assert(err, IsNil)
1236
1237 c.Assert(o.ID().IsZero(), Equals, false)
1238 c.Assert(o.Type(), Equals, plumbing.CommitObject)
1239}
1240
1241func (s *RepositorySuite) TestObjects(c *C) {
1242 r, _ := Init(memory.NewStorage(), nil)
1243 err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
1244 c.Assert(err, IsNil)
1245
1246 count := 0
1247 objects, err := r.Objects()
1248 c.Assert(err, IsNil)
1249 for {
1250 o, err := objects.Next()
1251 if err != nil {
1252 break
1253 }
1254
1255 count++
1256 c.Assert(o.ID().IsZero(), Equals, false)
1257 c.Assert(o.Type(), Not(Equals), plumbing.AnyObject)
1258 }
1259
1260 c.Assert(count, Equals, 31)
1261}
1262
1263func (s *RepositorySuite) TestObjectNotFound(c *C) {
1264 r, _ := Init(memory.NewStorage(), nil)
1265 err := r.clone(context.Background(), &CloneOptions{URL: s.GetBasicLocalRepositoryURL()})
1266 c.Assert(err, IsNil)
1267
1268 hash := plumbing.NewHash("0a3fb06ff80156fb153bcdcc58b5e16c2d27625c")
1269 tag, err := r.Object(plumbing.TagObject, hash)
1270 c.Assert(err, DeepEquals, plumbing.ErrObjectNotFound)
1271 c.Assert(tag, IsNil)
1272}
1273
1274func (s *RepositorySuite) TestWorktree(c *C) {
1275 def := memfs.New()
1276 r, _ := Init(memory.NewStorage(), def)
1277 w, err := r.Worktree()
1278 c.Assert(err, IsNil)
1279 c.Assert(w.Filesystem, Equals, def)
1280}
1281
1282func (s *RepositorySuite) TestWorktreeBare(c *C) {
1283 r, _ := Init(memory.NewStorage(), nil)
1284 w, err := r.Worktree()
1285 c.Assert(err, Equals, ErrIsBareRepository)
1286 c.Assert(w, IsNil)
1287}
1288
1289func (s *RepositorySuite) TestResolveRevision(c *C) {
1290 f := fixtures.ByURL("https://github.com/git-fixtures/basic.git").One()
1291 sto, err := filesystem.NewStorage(f.DotGit())
1292 c.Assert(err, IsNil)
1293 r, err := Open(sto, f.DotGit())
1294 c.Assert(err, IsNil)
1295
1296 datas := map[string]string{
1297 "HEAD": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
1298 "heads/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
1299 "heads/master~1": "918c48b83bd081e863dbe1b80f8998f058cd8294",
1300 "refs/heads/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
1301 "refs/heads/master~2^^~": "b029517f6300c2da0f4b651b8642506cd6aaf45d",
1302 "refs/tags/v1.0.0": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
1303 "refs/remotes/origin/master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
1304 "refs/remotes/origin/HEAD": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
1305 "HEAD~2^^~": "b029517f6300c2da0f4b651b8642506cd6aaf45d",
1306 "HEAD~3^2": "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
1307 "HEAD~3^2^0": "a5b8b09e2f8fcb0bb99d3ccb0958157b40890d69",
1308 "HEAD~2^{/binary file}": "35e85108805c84807bc66a02d91535e1e24b38b9",
1309 "HEAD~^{/!-some}": "1669dce138d9b841a518c64b10914d88f5e488ea",
1310 "master": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
1311 "branch": "e8d3ffab552895c19b9fcf7aa264d277cde33881",
1312 "v1.0.0": "6ecf0ef2c2dffb796033e5a02219af86ec6584e5",
1313 "branch~1": "918c48b83bd081e863dbe1b80f8998f058cd8294",
1314 "v1.0.0~1": "918c48b83bd081e863dbe1b80f8998f058cd8294",
1315 "master~1": "918c48b83bd081e863dbe1b80f8998f058cd8294",
1316 }
1317
1318 for rev, hash := range datas {
1319 h, err := r.ResolveRevision(plumbing.Revision(rev))
1320
1321 c.Assert(err, IsNil)
1322 c.Assert(h.String(), Equals, hash)
1323 }
1324}
1325
1326func (s *RepositorySuite) TestResolveRevisionWithErrors(c *C) {
1327 url := s.GetLocalRepositoryURL(
1328 fixtures.ByURL("https://github.com/git-fixtures/basic.git").One(),
1329 )
1330
1331 r, _ := Init(memory.NewStorage(), nil)
1332 err := r.clone(context.Background(), &CloneOptions{URL: url})
1333 c.Assert(err, IsNil)
1334
1335 datas := map[string]string{
1336 "efs/heads/master~": "reference not found",
1337 "HEAD^3": `Revision invalid : "3" found must be 0, 1 or 2 after "^"`,
1338 "HEAD^{/whatever}": `No commit message match regexp : "whatever"`,
1339 }
1340
1341 for rev, rerr := range datas {
1342 _, err := r.ResolveRevision(plumbing.Revision(rev))
1343
1344 c.Assert(err.Error(), Equals, rerr)
1345 }
1346}
1347
1348func (s *RepositorySuite) testRepackObjects(
1349 c *C, deleteTime time.Time, expectedPacks int) {
1350 srcFs := fixtures.ByTag("unpacked").One().DotGit()
1351 var sto storage.Storer
1352 var err error
1353 sto, err = filesystem.NewStorage(srcFs)
1354 c.Assert(err, IsNil)
1355
1356 los := sto.(storer.LooseObjectStorer)
1357 c.Assert(los, NotNil)
1358
1359 numLooseStart := 0
1360 err = los.ForEachObjectHash(func(_ plumbing.Hash) error {
1361 numLooseStart++
1362 return nil
1363 })
1364 c.Assert(err, IsNil)
1365 c.Assert(numLooseStart > 0, Equals, true)
1366
1367 pos := sto.(storer.PackedObjectStorer)
1368 c.Assert(los, NotNil)
1369
1370 packs, err := pos.ObjectPacks()
1371 c.Assert(err, IsNil)
1372 numPacksStart := len(packs)
1373 c.Assert(numPacksStart > 1, Equals, true)
1374
1375 r, err := Open(sto, srcFs)
1376 c.Assert(err, IsNil)
1377 c.Assert(r, NotNil)
1378
1379 err = r.RepackObjects(&RepackConfig{
1380 OnlyDeletePacksOlderThan: deleteTime,
1381 })
1382 c.Assert(err, IsNil)
1383
1384 numLooseEnd := 0
1385 err = los.ForEachObjectHash(func(_ plumbing.Hash) error {
1386 numLooseEnd++
1387 return nil
1388 })
1389 c.Assert(err, IsNil)
1390 c.Assert(numLooseEnd, Equals, 0)
1391
1392 packs, err = pos.ObjectPacks()
1393 c.Assert(err, IsNil)
1394 numPacksEnd := len(packs)
1395 c.Assert(numPacksEnd, Equals, expectedPacks)
1396}
1397
1398func (s *RepositorySuite) TestRepackObjects(c *C) {
1399 s.testRepackObjects(c, time.Time{}, 1)
1400}
1401
1402func (s *RepositorySuite) TestRepackObjectsWithNoDelete(c *C) {
1403 s.testRepackObjects(c, time.Unix(0, 1), 3)
1404}
1405
1406func ExecuteOnPath(c *C, path string, cmds ...string) error {
1407 for _, cmd := range cmds {
1408 err := executeOnPath(path, cmd)
1409 c.Assert(err, IsNil)
1410 }
1411
1412 return nil
1413}
1414
1415func executeOnPath(path, cmd string) error {
1416 args := strings.Split(cmd, " ")
1417 c := exec.Command(args[0], args[1:]...)
1418 c.Dir = path
1419 c.Env = os.Environ()
1420
1421 buf := bytes.NewBuffer(nil)
1422 c.Stderr = buf
1423 c.Stdout = buf
1424
1425 //defer func() { fmt.Println(buf.String()) }()
1426
1427 return c.Run()
1428}