func (s *FileSuite) TestIter(c *C) {
for i, t := range fileIterTests {
f := fixtures.ByURL(t.repo).One()
sto, err := filesystem.NewStorage(f.DotGit())
c.Assert(err, IsNil)
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
tree, err := commit.Tree()
c.Assert(err, IsNil)
iter := NewFileIter(sto, tree)
for k := 0; k < len(t.files); k++ {
exp := t.files[k]
file, err := iter.Next()
c.Assert(err, IsNil, Commentf("subtest %d, iter %d, err=%v", i, k, err))
c.Assert(file.Mode.String(), Equals, "-rw-r--r--")
c.Assert(file.Hash.IsZero(), Equals, false)
c.Assert(file.Hash, Equals, file.ID())
c.Assert(file.Name, Equals, exp.Name, Commentf("subtest %d, iter %d, name=%s, expected=%s", i, k, file.Name, exp.Hash))
c.Assert(file.Hash.String(), Equals, exp.Hash, Commentf("subtest %d, iter %d, hash=%v, expected=%s", i, k, file.Hash.String(), exp.Hash))
}
_, err = iter.Next()
c.Assert(err, Equals, io.EOF)
}
}
func (s *BaseObjectsSuite) SetUpSuite(c *C) {
s.Suite.SetUpSuite(c)
s.Fixture = fixtures.Basic().One()
storer, err := filesystem.NewStorage(s.Fixture.DotGit())
c.Assert(err, IsNil)
s.Storer = storer
}
func (s *TagSuite) SetUpSuite(c *C) {
s.BaseObjectsSuite.SetUpSuite(c)
storer, err := filesystem.NewStorage(
fixtures.ByURL("https://github.com/git-fixtures/tags.git").One().DotGit())
c.Assert(err, IsNil)
s.Storer = storer
}
func (s *RemoteSuite) TestFetchWithPackfileWriter(c *C) {
dir, err := ioutil.TempDir("", "fetch")
c.Assert(err, IsNil)
defer os.RemoveAll(dir) // clean up
fss, err := filesystem.NewStorage(osfs.New(dir))
c.Assert(err, IsNil)
mock := &mockPackfileWriter{Storer: fss}
r := newRemote(mock, &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)
var count int
iter, err := mock.IterObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
iter.ForEach(func(plumbing.Object) error {
count++
return nil
})
c.Assert(count, Equals, 31)
c.Assert(mock.PackfileWriterCalled, Equals, true)
}
func (s *RemoteSuite) TestFetchWithPackfileWriter(c *C) {
dir, err := ioutil.TempDir("", "fetch")
c.Assert(err, IsNil)
defer os.RemoveAll(dir) // clean up
fss, err := filesystem.NewStorage(osfs.New(dir))
c.Assert(err, IsNil)
mock := &mockPackfileWriter{Storer: fss}
url := s.GetBasicLocalRepositoryURL()
r := newRemote(mock, nil, &config.RemoteConfig{Name: "foo", URL: url})
refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
err = r.Fetch(&FetchOptions{
RefSpecs: []config.RefSpec{refspec},
})
c.Assert(err, IsNil)
var count int
iter, err := mock.IterEncodedObjects(plumbing.AnyObject)
c.Assert(err, IsNil)
iter.ForEach(func(plumbing.EncodedObject) error {
count++
return nil
})
c.Assert(count, Equals, 31)
c.Assert(mock.PackfileWriterCalled, Equals, true)
}
func (s *DiffTreeSuite) SetUpSuite(c *C) {
s.Suite.SetUpSuite(c)
s.Fixture = fixtures.Basic().One()
sto, err := filesystem.NewStorage(s.Fixture.DotGit())
c.Assert(err, IsNil)
s.Storer = sto
s.cache = make(map[string]storer.EncodedObjectStorer)
}
// NewFilesystemRepository creates a new repository, backed by a filesystem.Storage
// based on a fs.OS, if you want to use a custom one you need to use the function
// NewRepository and build you filesystem.Storage
func NewFilesystemRepository(path string) (*Repository, error) {
s, err := filesystem.NewStorage(osfs.New(path))
if err != nil {
return nil, err
}
return NewRepository(s)
}
func (s *RepositorySuite) TestPushNonExistentRemote(c *C) {
srcFs := fixtures.Basic().One().DotGit()
sto, err := filesystem.NewStorage(srcFs)
c.Assert(err, IsNil)
r, err := NewRepository(sto)
c.Assert(err, IsNil)
err = r.Push(&PushOptions{RemoteName: "myremote"})
c.Assert(err, ErrorMatches, ".*remote not found.*")
}
func (s *RepositorySuite) TestPushToEmptyRepository(c *C) {
srcFs := fixtures.Basic().One().DotGit()
sto, err := filesystem.NewStorage(srcFs)
c.Assert(err, IsNil)
dstFs := fixtures.ByTag("empty").One().DotGit()
url := fmt.Sprintf("file://%s", dstFs.Base())
r, err := NewRepository(sto)
c.Assert(err, IsNil)
_, err = r.CreateRemote(&config.RemoteConfig{
Name: "myremote",
URL: url,
})
c.Assert(err, IsNil)
err = r.Push(&PushOptions{RemoteName: "myremote"})
c.Assert(err, IsNil)
sto, err = filesystem.NewStorage(dstFs)
c.Assert(err, IsNil)
dstRepo, err := NewRepository(sto)
c.Assert(err, IsNil)
iter, err := sto.IterReferences()
c.Assert(err, IsNil)
err = iter.ForEach(func(ref *plumbing.Reference) error {
if !ref.IsBranch() {
return nil
}
dstRef, err := dstRepo.Reference(ref.Name(), true)
c.Assert(err, IsNil)
c.Assert(dstRef, DeepEquals, ref)
return nil
})
c.Assert(err, IsNil)
}
func (s *BaseSuite) NewRepository(f *fixtures.Fixture) *Repository {
storage, err := filesystem.NewStorage(f.DotGit())
if err != nil {
panic(err)
}
r, err := NewRepository(storage)
if err != nil {
panic(err)
}
return r
}
func (s *RemoteSuite) TestPushToEmptyRepository(c *C) {
srcFs := fixtures.Basic().One().DotGit()
sto, err := filesystem.NewStorage(srcFs)
c.Assert(err, IsNil)
dstFs := fixtures.ByTag("empty").One().DotGit()
url := fmt.Sprintf("file://%s", dstFs.Base())
r := newRemote(sto, nil, &config.RemoteConfig{
Name: DefaultRemoteName,
URL: url,
})
rs := config.RefSpec("refs/heads/*:refs/heads/*")
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{rs},
})
c.Assert(err, IsNil)
dstSto, err := filesystem.NewStorage(dstFs)
c.Assert(err, IsNil)
dstRepo, err := NewRepository(dstSto)
c.Assert(err, IsNil)
iter, err := sto.IterReferences()
c.Assert(err, IsNil)
err = iter.ForEach(func(ref *plumbing.Reference) error {
if !ref.IsBranch() {
return nil
}
dstRef, err := dstRepo.Reference(ref.Name(), true)
c.Assert(err, IsNil, Commentf("ref: %s", ref.String()))
c.Assert(dstRef, DeepEquals, ref)
return nil
})
c.Assert(err, IsNil)
}
func (s *RemoteSuite) TestPushNoErrAlreadyUpToDate(c *C) {
f := fixtures.Basic().One()
sto, err := filesystem.NewStorage(f.DotGit())
c.Assert(err, IsNil)
url := fmt.Sprintf("file://%s", f.DotGit().Base())
r := newRemote(sto, nil, &config.RemoteConfig{
Name: DefaultRemoteName,
URL: url,
})
rs := config.RefSpec("refs/heads/*:refs/heads/*")
err = r.Push(&PushOptions{
RefSpecs: []config.RefSpec{rs},
})
c.Assert(err, Equals, NoErrAlreadyUpToDate)
}
func (s *FileSuite) TestLines(c *C) {
for i, t := range linesTests {
f := fixtures.ByURL(t.repo).One()
sto, err := filesystem.NewStorage(f.DotGit())
c.Assert(err, IsNil)
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
file, err := commit.File(t.path)
c.Assert(err, IsNil)
lines, err := file.Lines()
c.Assert(err, IsNil)
c.Assert(lines, DeepEquals, t.lines, Commentf(
"subtest %d: commit=%s, path=%s", i, t.commit, t.path))
}
}
// It is difficult to assert that we are ignoring an (empty) dir as even
// if we don't, no files will be found in it.
//
// At least this test has a high chance of panicking if
// we don't ignore empty dirs.
func (s *FileSuite) TestIgnoreEmptyDirEntries(c *C) {
for i, t := range ignoreEmptyDirEntriesTests {
f := fixtures.ByURL(t.repo).One()
sto, err := filesystem.NewStorage(f.DotGit())
c.Assert(err, IsNil)
h := plumbing.NewHash(t.commit)
commit, err := GetCommit(sto, h)
c.Assert(err, IsNil, Commentf("subtest %d: %v (%s)", i, err, t.commit))
tree, err := commit.Tree()
c.Assert(err, IsNil)
iter := tree.Files()
defer iter.Close()
for file, err := iter.Next(); err == nil; file, err = iter.Next() {
_, _ = file.Contents()
// this would probably panic if we are not ignoring empty dirs
}
}
}
func (s *SuiteCommit) TestStringMultiLine(c *C) {
hash := plumbing.NewHash("e7d896db87294e33ca3202e536d4d9bb16023db3")
f := fixtures.ByURL("https://github.com/src-d/go-git.git").One()
sto, err := filesystem.NewStorage(f.DotGit())
o, err := sto.EncodedObject(plumbing.CommitObject, hash)
c.Assert(err, IsNil)
commit, err := DecodeCommit(sto, o)
c.Assert(err, IsNil)
c.Assert(commit.String(), Equals, ""+
"commit e7d896db87294e33ca3202e536d4d9bb16023db3\n"+
"Author: Alberto Cortés <*****@*****.**>\n"+
"Date: Wed Jan 27 11:13:49 2016 +0100\n"+
"\n"+
" fix zlib invalid header error\n"+
"\n"+
" The return value of reads to the packfile were being ignored, so zlib\n"+
" was getting invalid data on it read buffers.\n"+
"\n",
)
}
func (s *ReaderSuite) TestDecodeNoSeekableWithoutTxStorer(c *C) {
fixtures.Basic().ByTag("packfile").Test(c, func(f *fixtures.Fixture) {
reader := nonSeekableReader{
r: f.Packfile(),
}
scanner := packfile.NewScanner(reader)
var storage storer.EncodedObjectStorer
storage, _ = filesystem.NewStorage(fs.New())
_, isTxStorer := storage.(storer.Transactioner)
c.Assert(isTxStorer, Equals, false)
d, err := packfile.NewDecoder(scanner, storage)
c.Assert(err, IsNil)
defer d.Close()
ch, err := d.Decode()
c.Assert(err, IsNil)
c.Assert(ch, Equals, f.PackfileHash)
assertObjects(c, storage, expectedHashes)
})
}
func (s *RevListSuite) SetUpTest(c *C) {
s.Suite.SetUpSuite(c)
sto, err := filesystem.NewStorage(fixtures.Basic().One().DotGit())
c.Assert(err, IsNil)
s.Storer = sto
}
