func (s *BaseSuite) buildRepository(c *C) {
f := fixtures.Basic().One()
var err error
s.Repository, err = NewFilesystemRepository(f.DotGit().Base())
c.Assert(err, IsNil)
}
func (s *IdxfileSuite) TestDecodeCRCs(c *C) {
f := fixtures.Basic().ByTag("ofs-delta").One()
scanner := packfile.NewScanner(f.Packfile())
storage := memory.NewStorage()
pd, err := packfile.NewDecoder(scanner, storage)
c.Assert(err, IsNil)
_, err = pd.Decode()
c.Assert(err, IsNil)
i := &Idxfile{Version: VersionSupported}
offsets := pd.Offsets()
for h, crc := range pd.CRCs() {
i.Add(h, uint64(offsets[h]), crc)
}
buf := bytes.NewBuffer(nil)
e := NewEncoder(buf)
_, err = e.Encode(i)
c.Assert(err, IsNil)
idx := &Idxfile{}
d := NewDecoder(buf)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Entries, DeepEquals, i.Entries)
}
func (s *IdxfileSuite) TestDecodeEntries(c *C) {
f, err := fixtures.Basic().One().DotGit().Open("index")
c.Assert(err, IsNil)
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 9)
e := idx.Entries[0]
c.Assert(e.CreatedAt.Unix(), Equals, int64(1473350251))
c.Assert(e.CreatedAt.Nanosecond(), Equals, 12059307)
c.Assert(e.ModifiedAt.Unix(), Equals, int64(1473350251))
c.Assert(e.ModifiedAt.Nanosecond(), Equals, 12059307)
c.Assert(e.Dev, Equals, uint32(38))
c.Assert(e.Inode, Equals, uint32(1715795))
c.Assert(e.UID, Equals, uint32(1000))
c.Assert(e.GID, Equals, uint32(100))
c.Assert(e.Size, Equals, uint32(189))
c.Assert(e.Hash.String(), Equals, "32858aad3c383ed1ff0a0f9bdf231d54a00c9e88")
c.Assert(e.Name, Equals, ".gitignore")
c.Assert(e.Mode.String(), Equals, "-rw-r--r--")
e = idx.Entries[1]
c.Assert(e.Name, Equals, "CHANGELOG")
}
func (s *IdxfileSuite) TestDecodeV4(c *C) {
f, err := fixtures.Basic().ByTag("index-v4").One().DotGit().Open("index")
c.Assert(err, IsNil)
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Version, Equals, uint32(4))
c.Assert(idx.Entries, HasLen, 11)
names := []string{
".gitignore", "CHANGELOG", "LICENSE", "binary.jpg", "go/example.go",
"haskal/haskal.hs", "intent-to-add", "json/long.json",
"json/short.json", "php/crappy.php", "vendor/foo.go",
}
for i, e := range idx.Entries {
c.Assert(e.Name, Equals, names[i])
}
c.Assert(idx.Entries[6].Name, Equals, "intent-to-add")
c.Assert(idx.Entries[6].IntentToAdd, Equals, true)
c.Assert(idx.Entries[6].SkipWorktree, Equals, false)
}
func (s *FetchPackSuite) SetUpSuite(c *C) {
s.Suite.SetUpSuite(c)
if err := exec.Command("git", "--version").Run(); err != nil {
c.Skip("git command not found")
}
s.FetchPackSuite.Client = DefaultClient
fixture := fixtures.Basic().One()
path := fixture.DotGit().Base()
url := fmt.Sprintf("file://%s", path)
ep, err := transport.NewEndpoint(url)
c.Assert(err, IsNil)
s.Endpoint = ep
fixture = fixtures.ByTag("empty").One()
path = fixture.DotGit().Base()
url = fmt.Sprintf("file://%s", path)
ep, err = transport.NewEndpoint(url)
c.Assert(err, IsNil)
s.EmptyEndpoint = ep
url = fmt.Sprintf("file://%s/%s", fixtures.DataFolder, "non-existent")
ep, err = transport.NewEndpoint(url)
c.Assert(err, IsNil)
s.NonExistentEndpoint = ep
}
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 *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)
}
func (s *BaseSuite) SetUpSuite(c *C) {
s.Suite.SetUpSuite(c)
s.installMockProtocol(c)
s.buildRepository(c)
s.Repositories = make(map[string]*Repository, 0)
s.buildRepositories(c, fixtures.Basic().ByTag("packfile"))
}
func (s *SuiteDotGit) TestShallow(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
file, err := dir.Shallow()
c.Assert(err, IsNil)
c.Assert(file, IsNil)
}
func (s *SuiteDotGit) TestConfig(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
file, err := dir.Config()
c.Assert(err, IsNil)
c.Assert(filepath.Base(file.Filename()), Equals, "config")
}
func (s *SuiteDotGit) TestObjectPackIdx(c *C) {
f := fixtures.Basic().ByTag(".git").One()
fs := f.DotGit()
dir := New(fs)
idx, err := dir.ObjectPackIdx(f.PackfileHash)
c.Assert(err, IsNil)
c.Assert(filepath.Ext(idx.Filename()), Equals, ".idx")
}
func (s *ScannerSuite) TestHeader(c *C) {
r := fixtures.Basic().One().Packfile()
p := NewScanner(r)
version, objects, err := p.Header()
c.Assert(err, IsNil)
c.Assert(version, Equals, VersionSupported)
c.Assert(objects, Equals, uint32(31))
}
func (s *SuiteDotGit) TestObjectsPack(c *C) {
f := fixtures.Basic().ByTag(".git").One()
fs := f.DotGit()
dir := New(fs)
hashes, err := dir.ObjectPacks()
c.Assert(err, IsNil)
c.Assert(hashes, HasLen, 1)
c.Assert(hashes[0], Equals, f.PackfileHash)
}
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 *SendPackSuite) TestDefaultBranch(c *C) {
r, err := s.Client.NewSendPackSession(s.Endpoint)
c.Assert(err, IsNil)
defer func() { c.Assert(r.Close(), IsNil) }()
info, err := r.AdvertisedReferences()
c.Assert(err, IsNil)
ref, ok := info.References["refs/heads/master"]
c.Assert(ok, Equals, true)
c.Assert(ref, Equals, fixtures.Basic().One().Head)
}
func (s *ReaderSuite) TestDecodeInMemory(c *C) {
fixtures.Basic().ByTag("packfile").Test(c, func(f *fixtures.Fixture) {
scanner := packfile.NewScanner(f.Packfile())
d, err := packfile.NewDecoder(scanner, nil)
c.Assert(err, IsNil)
ch, err := d.Decode()
c.Assert(err, IsNil)
c.Assert(ch, Equals, f.PackfileHash)
})
}
func (s *SuiteDotGit) TestObjectPackNotFound(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
pack, err := dir.ObjectPack(plumbing.ZeroHash)
c.Assert(err, Equals, ErrPackfileNotFound)
c.Assert(pack, IsNil)
idx, err := dir.ObjectPackIdx(plumbing.ZeroHash)
c.Assert(idx, IsNil)
}
func (s *SendPackSuite) TestFullSendPackOnEmpty(c *C) {
endpoint := s.EmptyEndpoint
full := true
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{"refs/heads/master", plumbing.ZeroHash, fixture.Head},
}
s.sendPack(c, endpoint, req, fixture, full)
s.checkRemoteHead(c, endpoint, fixture.Head)
}
func (s *SendPackSuite) SetUpTest(c *C) {
fixture := fixtures.Basic().One()
path := fixture.DotGit().Base()
s.Endpoint = prepareRepo(c, path)
fixture = fixtures.ByTag("empty").One()
path = fixture.DotGit().Base()
s.EmptyEndpoint = prepareRepo(c, path)
s.NonExistentEndpoint = prepareRepo(c, "/non-existent")
}
func (s *IdxfileSuite) TestDecode(c *C) {
f, err := fixtures.Basic().One().DotGit().Open("index")
c.Assert(err, IsNil)
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Version, Equals, uint32(2))
c.Assert(idx.Entries, HasLen, 9)
}
func (s *SendPackSuite) TestSendPackOnEmptyWithReportStatus(c *C) {
endpoint := s.EmptyEndpoint
full := false
fixture := fixtures.Basic().ByTag("packfile").One()
req := packp.NewReferenceUpdateRequest()
req.Commands = []*packp.Command{
{"refs/heads/master", plumbing.ZeroHash, fixture.Head},
}
req.Capabilities.Set(capability.ReportStatus)
s.sendPack(c, endpoint, req, fixture, full)
s.checkRemoteHead(c, endpoint, fixture.Head)
}
func (s *SuiteDotGit) TestRefsFromPackedRefs(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
refs, err := dir.Refs()
c.Assert(err, IsNil)
ref := findReference(refs, "refs/remotes/origin/branch")
c.Assert(ref, NotNil)
c.Assert(ref.Hash().String(), Equals, "e8d3ffab552895c19b9fcf7aa264d277cde33881")
}
func (s *SuiteDotGit) TestRefsFromHEADFile(c *C) {
fs := fixtures.Basic().ByTag(".git").One().DotGit()
dir := New(fs)
refs, err := dir.Refs()
c.Assert(err, IsNil)
ref := findReference(refs, "HEAD")
c.Assert(ref, NotNil)
c.Assert(ref.Type(), Equals, plumbing.SymbolicReference)
c.Assert(string(ref.Target()), Equals, "refs/heads/master")
}
func (s *FsSuite) TestGetFromPackfile(c *C) {
fixtures.Basic().ByTag(".git").Test(c, func(f *fixtures.Fixture) {
fs := f.DotGit()
o, err := newObjectStorage(dotgit.New(fs))
c.Assert(err, IsNil)
expected := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
obj, err := o.Object(plumbing.AnyObject, expected)
c.Assert(err, IsNil)
c.Assert(obj.Hash(), Equals, expected)
})
}
func (s *ReaderSuite) TestOffsets(c *C) {
f := fixtures.Basic().One()
scanner := packfile.NewScanner(f.Packfile())
d, err := packfile.NewDecoder(scanner, nil)
c.Assert(err, IsNil)
c.Assert(d.Offsets(), HasLen, 0)
_, err = d.Decode()
c.Assert(err, IsNil)
c.Assert(d.Offsets(), HasLen, 31)
}
func (s *ReaderSuite) TestSetOffsets(c *C) {
f := fixtures.Basic().One()
scanner := packfile.NewScanner(f.Packfile())
d, err := packfile.NewDecoder(scanner, nil)
c.Assert(err, IsNil)
h := plumbing.NewHash("6ecf0ef2c2dffb796033e5a02219af86ec6584e5")
d.SetOffsets(map[plumbing.Hash]int64{h: 42})
o := d.Offsets()
c.Assert(o, HasLen, 1)
c.Assert(o[h], Equals, int64(42))
}
func (s *ScannerSuite) TestNextObjectHeaderWithoutHeader(c *C) {
r := fixtures.Basic().One().Packfile()
p := NewScanner(r)
h, err := p.NextObjectHeader()
c.Assert(err, IsNil)
c.Assert(h, DeepEquals, &expectedHeadersOFS[0])
version, objects, err := p.Header()
c.Assert(err, IsNil)
c.Assert(version, Equals, VersionSupported)
c.Assert(objects, Equals, uint32(31))
}
func (s *ConfigSuite) TestRemotes(c *C) {
dir := dotgit.New(fixtures.Basic().ByTag(".git").One().DotGit())
storer := &ConfigStorage{dir}
cfg, err := storer.Config()
c.Assert(err, IsNil)
remotes := cfg.Remotes
c.Assert(remotes, HasLen, 1)
remote := remotes["origin"]
c.Assert(remote.Name, Equals, "origin")
c.Assert(remote.URL, Equals, "https://github.com/git-fixtures/basic")
c.Assert(remote.Fetch, HasLen, 1)
c.Assert(remote.Fetch[0].String(), Equals, "+refs/heads/*:refs/remotes/origin/*")
}
func (s *IdxfileSuite) TestDecode(c *C) {
f := fixtures.Basic().One()
d := NewDecoder(f.Idx())
idx := &Idxfile{}
err := d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Entries, HasLen, 31)
c.Assert(idx.Entries[0].Hash.String(), Equals, "1669dce138d9b841a518c64b10914d88f5e488ea")
c.Assert(idx.Entries[0].Offset, Equals, uint64(615))
c.Assert(idx.Entries[0].CRC32, Equals, uint32(3645019190))
c.Assert(fmt.Sprintf("%x", idx.IdxChecksum), Equals, "fb794f1ec720b9bc8e43257451bd99c4be6fa1c9")
c.Assert(fmt.Sprintf("%x", idx.PackfileChecksum), Equals, f.PackfileHash.String())
}
func (s *IdxfileSuite) TestDecodeExtendedV3(c *C) {
f, err := fixtures.Basic().ByTag("intent-to-add").One().DotGit().Open("index")
c.Assert(err, IsNil)
idx := &Index{}
d := NewDecoder(f)
err = d.Decode(idx)
c.Assert(err, IsNil)
c.Assert(idx.Version, Equals, uint32(3))
c.Assert(idx.Entries, HasLen, 11)
c.Assert(idx.Entries[6].Name, Equals, "intent-to-add")
c.Assert(idx.Entries[6].IntentToAdd, Equals, true)
c.Assert(idx.Entries[6].SkipWorktree, Equals, false)
}