func (s *RemoteSuite) TestFetchDepth(c *C) {
url := s.GetBasicLocalRepositoryURL()
sto := memory.NewStorage()
r := newRemote(sto, nil, &config.RemoteConfig{Name: "foo", URL: url})
refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
err := r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{refspec},
Depth: 1,
})
c.Assert(err, IsNil)
c.Assert(sto.Objects, HasLen, 18)
expectedRefs := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
plumbing.NewReferenceFromStrings("refs/remotes/origin/branch", "e8d3ffab552895c19b9fcf7aa264d277cde33881"),
}
for _, exp := range expectedRefs {
r, _ := sto.Reference(exp.Name())
c.Assert(exp.String(), Equals, r.String())
}
h, err := sto.Shallow()
c.Assert(err, IsNil)
c.Assert(h, HasLen, 2)
c.Assert(h, DeepEquals, []plumbing.Hash{
plumbing.NewHash("e8d3ffab552895c19b9fcf7aa264d277cde33881"),
plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
})
}
func (s *RemoteSuite) TestFetch(c *C) {
sto := memory.NewStorage()
r := newRemote(sto, &config.RemoteConfig{Name: "foo", URL: RepositoryFixture})
r.upSrv = &MockGitUploadPackService{}
c.Assert(r.Connect(), IsNil)
err := r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{FixRefSpec},
})
c.Assert(err, IsNil)
c.Assert(sto.Objects, HasLen, 31)
expectedRefs := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("refs/remotes/origin/master", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
plumbing.NewReferenceFromStrings("refs/remotes/origin/branch", "e8d3ffab552895c19b9fcf7aa264d277cde33881"),
plumbing.NewReferenceFromStrings("refs/tags/v1.0.0", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
}
for _, exp := range expectedRefs {
r, _ := sto.Reference(exp.Name())
c.Assert(exp.String(), Equals, r.String())
}
}
func (s *SuiteDotGit) TestSetRefs(c *C) {
tmp, err := ioutil.TempDir("", "dot-git")
c.Assert(err, IsNil)
defer os.RemoveAll(tmp)
fs := osfs.New(tmp)
dir := New(fs)
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/foo",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
))
c.Assert(err, IsNil)
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"refs/heads/symbolic",
"ref: refs/heads/foo",
))
c.Assert(err, IsNil)
err = dir.SetRef(plumbing.NewReferenceFromStrings(
"bar",
"e8d3ffab552895c19b9fcf7aa264d277cde33881",
))
c.Assert(err, IsNil)
refs, err := dir.Refs()
c.Assert(err, IsNil)
c.Assert(refs, HasLen, 2)
ref := findReference(refs, "refs/heads/foo")
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
ref = findReference(refs, "refs/heads/symbolic")
c.Assert(ref, NotNil)
c.Assert(ref.Target().String(), Equals, "refs/heads/foo")
ref = findReference(refs, "bar")
c.Assert(ref, IsNil)
ref, err = dir.Ref("refs/heads/foo")
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
ref, err = dir.Ref("refs/heads/symbolic")
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
c.Assert(ref.Target().String(), Equals, "refs/heads/foo")
ref, err = dir.Ref("bar")
c.Assert(err, IsNil)
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
}
func (s *BaseStorageSuite) TestSetReferenceAndGetReference(c *C) {
err := s.Storer.SetReference(
plumbing.NewReferenceFromStrings("foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
)
c.Assert(err, IsNil)
err = s.Storer.SetReference(
plumbing.NewReferenceFromStrings("bar", "482e0eada5de4039e6f216b45b3c9b683b83bfa"),
)
c.Assert(err, IsNil)
e, err := s.Storer.Reference(plumbing.ReferenceName("foo"))
c.Assert(err, IsNil)
c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
}
func (s *ReferenceSuite) TestReferenceSliceIterForEach(c *C) {
slice := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
plumbing.NewReferenceFromStrings("bar", "bar"),
}
i := NewReferenceSliceIter(slice)
var count int
i.ForEach(func(r *plumbing.Reference) error {
c.Assert(r == slice[count], Equals, true)
count++
return nil
})
c.Assert(count, Equals, 2)
}
func (i *GitUploadPackInfo) addRefs(ar *advrefs.AdvRefs) error {
for name, hash := range ar.References {
ref := plumbing.NewReferenceFromStrings(name, hash.String())
i.Refs.SetReference(ref)
}
return i.addSymbolicRefs(ar)
}
func addRefs(s storer.ReferenceStorer, ar *AdvRefs) error {
for name, hash := range ar.References {
ref := plumbing.NewReferenceFromStrings(name, hash.String())
if err := s.SetReference(ref); err != nil {
return err
}
}
return addSymbolicRefs(s, ar)
}
func (s *ReferenceSuite) TestReferenceSliceIterNext(c *C) {
slice := []*plumbing.Reference{
plumbing.NewReferenceFromStrings("foo", "foo"),
plumbing.NewReferenceFromStrings("bar", "bar"),
}
i := NewReferenceSliceIter(slice)
foo, err := i.Next()
c.Assert(err, IsNil)
c.Assert(foo == slice[0], Equals, true)
bar, err := i.Next()
c.Assert(err, IsNil)
c.Assert(bar == slice[1], Equals, true)
empty, err := i.Next()
c.Assert(err, Equals, io.EOF)
c.Assert(empty, IsNil)
}
func (s *FetcherSuite) TestFetch(c *C) {
pkg := &Package{}
pkg.Repository, _ = common.NewEndpoint("https://github.com/git-fixtures/basic")
f := NewFetcher(pkg, nil)
ref := plumbing.NewReferenceFromStrings("foo", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
buf := bytes.NewBuffer(nil)
n, err := f.Fetch(buf, ref)
c.Assert(err, IsNil)
c.Assert(n, Equals, int64(85374))
c.Assert(buf.Len(), Equals, 85374)
}
// process lines from a packed-refs file
func (d *DotGit) processLine(line string) (*plumbing.Reference, error) {
switch line[0] {
case '#': // comment - ignore
return nil, nil
case '^': // annotated tag commit of the previous line - ignore
return nil, nil
default:
ws := strings.Split(line, " ") // hash then ref
if len(ws) != 2 {
return nil, ErrPackedRefsBadFormat
}
return plumbing.NewReferenceFromStrings(ws[1], ws[0]), nil
}
}
func (s *Storage) Reference(n plumbing.ReferenceName) (*plumbing.Reference, error) {
key, err := s.buildReferenceKey(n)
if err != nil {
return nil, err
}
rec, err := s.client.Get(nil, key)
if err != nil {
return nil, err
}
return plumbing.NewReferenceFromStrings(
rec.Bins["name"].(string),
rec.Bins["target"].(string),
), nil
}
func (s *BaseStorageSuite) TestIterReferences(c *C) {
err := s.Storer.SetReference(
plumbing.NewReferenceFromStrings("refs/foo", "bc9968d75e48de59f0870ffb71f5e160bbbdcf52"),
)
c.Assert(err, IsNil)
i, err := s.Storer.IterReferences()
c.Assert(err, IsNil)
e, err := i.Next()
c.Assert(err, IsNil)
c.Assert(e.Hash().String(), Equals, "bc9968d75e48de59f0870ffb71f5e160bbbdcf52")
e, err = i.Next()
c.Assert(e, IsNil)
c.Assert(err, Equals, io.EOF)
}
func (d *DotGit) readReferenceFile(refsPath, refFile string) (ref *plumbing.Reference, err error) {
path := d.fs.Join(refsPath, refFile)
f, err := d.fs.Open(path)
if err != nil {
return nil, err
}
defer func() {
if errClose := f.Close(); err == nil {
err = errClose
}
}()
b, err := ioutil.ReadAll(f)
if err != nil {
return nil, err
}
line := strings.TrimSpace(string(b))
return plumbing.NewReferenceFromStrings(refFile, line), nil
}
func (s *Storage) IterReferences() (storer.ReferenceIter, error) {
stmnt := driver.NewStatement(s.ns, referencesSet)
err := stmnt.Addfilter(driver.NewEqualFilter(urlField, s.url))
if err != nil {
return nil, err
}
rs, err := s.client.Query(nil, stmnt)
if err != nil {
return nil, err
}
var refs []*plumbing.Reference
for r := range rs.Records {
refs = append(refs, plumbing.NewReferenceFromStrings(
r.Bins["name"].(string),
r.Bins["target"].(string),
))
}
return storer.NewReferenceSliceIter(refs), nil
}