path: root/formats/packfile/parser_test.go

package packfile

import (
	"bytes"
	"encoding/base64"
	"io/ioutil"

	. "gopkg.in/check.v1"
	"gopkg.in/src-d/go-git.v4/core"
)

type ScannerSuite struct{}

var _ = Suite(&ScannerSuite{})

func (s *ScannerSuite) TestHeader(c *C) {
	data, _ := base64.StdEncoding.DecodeString(packFileWithEmptyObjects)

	p := NewScanner(bytes.NewReader(data))
	version, objects, err := p.Header()
	c.Assert(err, IsNil)
	c.Assert(version, Equals, VersionSupported)
	c.Assert(objects, Equals, uint32(11))
}

func (s *ScannerSuite) TestNextObjectHeader(c *C) {
	data, _ := base64.StdEncoding.DecodeString(packFileWithEmptyObjects)

	r := bytes.NewReader(data)
	p := NewScanner(r)
	_, objects, err := p.Header()
	c.Assert(err, IsNil)

	for i := 0; i < int(objects); i++ {
		h, err := p.NextObjectHeader()
		c.Assert(err, IsNil)
		c.Assert(*h, DeepEquals, expectedHeaders[i])

		buf := bytes.NewBuffer(nil)
		n, err := p.NextObject(buf)
		c.Assert(err, IsNil)
		c.Assert(n, Equals, h.Length)
	}

	n, err := ioutil.ReadAll(r)
	c.Assert(err, IsNil)
	c.Assert(n, HasLen, 20)
}

func (s *ScannerSuite) TestNextObjectHeaderWithOutReadObject(c *C) {
	data, _ := base64.StdEncoding.DecodeString(packFileWithEmptyObjects)

	r := bytes.NewReader(data)
	p := NewScanner(r)
	_, objects, err := p.Header()
	c.Assert(err, IsNil)

	for i := 0; i < int(objects); i++ {
		h, err := p.NextObjectHeader()
		c.Assert(err, IsNil)
		c.Assert(*h, DeepEquals, expectedHeaders[i])
	}

	err = p.discardObjectIfNeeded()
	c.Assert(err, IsNil)

	n, err := ioutil.ReadAll(r)
	c.Assert(err, IsNil)
	c.Assert(n, HasLen, 20)
}

var expectedHeaders = []ObjectHeader{
	{Type: core.CommitObject, Offset: 12, Length: 239},
	{Type: core.CommitObject, Offset: 177, Length: 244},
	{Type: core.CommitObject, Offset: 345, Length: 239},
	{Type: core.CommitObject, Offset: 507, Length: 191},
	{Type: core.TreeObject, Offset: 639, Length: 91},
	{Type: core.BlobObject, Offset: 714, Length: 0},
	{Type: core.BlobObject, Offset: 723, Length: 14},
	{Type: core.OFSDeltaObject, Offset: 740, Length: 4, OffsetReference: 639},
	{Type: core.TreeObject, Offset: 754, Length: 58},
	{Type: core.BlobObject, Offset: 820, Length: 7},
	{Type: core.TreeObject, Offset: 833, Length: 29},
}

/*
const (
	sigOffset   = 0
	verOffset   = 4
	countOffset = 8
)

type ParserSuite struct {
	fixtures map[string]*fix
}

type fix struct {
	path     string
	parser   *Parser
	seekable io.Seeker
}

func newFix(path string) (*fix, error) {
	fix := new(fix)
	fix.path = path

	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}

	data, err := ioutil.ReadAll(f)
	if err != nil {
		return nil, err
	}

	if err = f.Close(); err != nil {
		return nil, err
	}

	seekable := NewSeekable(bytes.NewReader(data))
	fix.seekable = seekable
	fix.parser = NewParser(seekable)

	return fix, nil
}

func (f *fix) seek(o int64) error {
	_, err := f.seekable.Seek(o, os.SEEK_SET)
	return err
}

var _ = Suite(&ParserSuite{})

func (s *ParserSuite) SetUpSuite(c *C) {
	s.fixtures = make(map[string]*fix)
	for _, fixData := range []struct {
		id   string
		path string
	}{
		{"ofs-deltas", "fixtures/alcortesm-binary-relations.pack"},
		{"ref-deltas", "fixtures/git-fixture.ref-delta"},
	} {
		fix, err := newFix(fixData.path)
		c.Assert(err, IsNil,
			Commentf("setting up fixture id %s: %s", fixData.id, err))

		_, ok := s.fixtures[fixData.id]
		c.Assert(ok, Equals, false,
			Commentf("duplicated fixture id: %s", fixData.id))

		s.fixtures[fixData.id] = fix
	}
}

func (s *ParserSuite) TestSignature(c *C) {
	for id, fix := range s.fixtures {
		com := Commentf("fixture id = %s", id)
		err := fix.seek(sigOffset)
		c.Assert(err, IsNil, com)
		p := fix.parser

		sig, err := p.ReadSignature()
		c.Assert(err, IsNil, com)
		c.Assert(p.IsValidSignature(sig), Equals, true, com)
	}
}

func (s *ParserSuite) TestVersion(c *C) {
	for i, test := range [...]struct {
		fixID    string
		expected uint32
	}{
		{
			fixID:    "ofs-deltas",
			expected: uint32(2),
		}, {
			fixID:    "ref-deltas",
			expected: uint32(2),
		},
	} {
		com := Commentf("test %d) fixture id = %s", i, test.fixID)
		fix, ok := s.fixtures[test.fixID]
		c.Assert(ok, Equals, true, com)

		err := fix.seek(verOffset)
		c.Assert(err, IsNil, com)
		p := fix.parser

		v, err := p.ReadVersion()
		c.Assert(err, IsNil, com)
		c.Assert(v, Equals, test.expected, com)
		c.Assert(p.IsSupportedVersion(v), Equals, true, com)
	}
}

func (s *ParserSuite) TestCount(c *C) {
	for i, test := range [...]struct {
		fixID    string
		expected uint32
	}{
		{
			fixID:    "ofs-deltas",
			expected: uint32(0x50),
		}, {
			fixID:    "ref-deltas",
			expected: uint32(0x1c),
		},
	} {
		com := Commentf("test %d) fixture id = %s", i, test.fixID)
		fix, ok := s.fixtures[test.fixID]
		c.Assert(ok, Equals, true, com)

		err := fix.seek(countOffset)
		c.Assert(err, IsNil, com)
		p := fix.parser

		count, err := p.ReadCount()
		c.Assert(err, IsNil, com)
		c.Assert(count, Equals, test.expected, com)
	}
}

func (s *ParserSuite) TestReadObjectTypeAndLength(c *C) {
	for i, test := range [...]struct {
		fixID     string
		offset    int64
		expType   core.ObjectType
		expLength int64
	}{
		{
			fixID:     "ofs-deltas",
			offset:    12,
			expType:   core.CommitObject,
			expLength: 342,
		}, {
			fixID:     "ofs-deltas",
			offset:    1212,
			expType:   core.OFSDeltaObject,
			expLength: 104,
		}, {
			fixID:     "ofs-deltas",
			offset:    3193,
			expType:   core.TreeObject,
			expLength: 226,
		}, {
			fixID:     "ofs-deltas",
			offset:    3639,
			expType:   core.BlobObject,
			expLength: 90,
		}, {
			fixID:     "ofs-deltas",
			offset:    4504,
			expType:   core.BlobObject,
			expLength: 7107,
		}, {
			fixID:     "ref-deltas",
			offset:    84849,
			expType:   core.REFDeltaObject,
			expLength: 6,
		}, {
			fixID:     "ref-deltas",
			offset:    85070,
			expType:   core.REFDeltaObject,
			expLength: 8,
		},
	} {
		com := Commentf("test %d) fixture id = %s", i, test.fixID)
		fix, ok := s.fixtures[test.fixID]
		c.Assert(ok, Equals, true, com)

		err := fix.seek(test.offset)
		c.Assert(err, IsNil, com)
		p := fix.parser

		typ, length, err := p.ReadObjectTypeAndLength()
		c.Assert(err, IsNil, com)
		c.Assert(typ, Equals, test.expType, com)
		c.Assert(length, Equals, test.expLength, com)
	}
}

func (s *ParserSuite) TestReadNonDeltaObjectContent(c *C) {
	for i, test := range [...]struct {
		fixID    string
		offset   int64
		expected []byte
	}{
		{
			fixID:    "ofs-deltas",
			offset:   12,
			expected: []byte("tree 87c87d16e815a43e4e574dd8edd72c5450ac3a8e\nparent a87d72684d1cf68099ce6e9f68689e25e645a14c\nauthor Gorka Guardiola <Gorka Guardiola Múzquiz> 1450265632 +0100\ncommitter Gorka Guardiola <Gorka Guardiola Múzquiz> 1450265632 +0100\n\nChanged example to use dot.\nI did not remove the original files outside of the\ntex, I leave that to alcortes.\n"),
		}, {
			fixID:    "ofs-deltas",
			offset:   1610,
			expected: []byte("tree 4b4f0d9a07109ef0b8a3051138cc20cdb47fa513\nparent b373f85fa2594d7dcd9989f4a5858a81647fb8ea\nauthor Alberto Cortés <alberto@sourced.tech> 1448017995 +0100\ncommitter Alberto Cortés <alberto@sourced.tech> 1448018112 +0100\n\nMove generated images to it own dir (img/)\n\nFixes #1.\n"),
		}, {
			fixID:    "ofs-deltas",
			offset:   10566,
			expected: []byte("40000 map-slice\x00\x00\xce\xfb\x8ew\xf7\xa8\xc6\x1b\x99\xdd$\x91\xffH\xa3\xb0\xb1fy40000 simple-arrays\x00\x9a7\x81\xb7\xfd\x9d(Q\xe2\xa4H\x8c\x03^٬\x90Z\xecy"),
		},
	} {
		com := Commentf("test %d) fixture id = %s", i, test.fixID)
		fix, ok := s.fixtures[test.fixID]
		c.Assert(ok, Equals, true, com)

		err := fix.seek(test.offset)
		c.Assert(err, IsNil, com)
		p := fix.parser

		_, _, err = p.ReadObjectTypeAndLength()
		c.Assert(err, IsNil, com)

		obj := &core.MemoryObject{}
		err = p.FillFromNonDeltaContent(obj)
		c.Assert(err, IsNil, com)

		r, _ := obj.Reader()
		bytes, _ := ioutil.ReadAll(r)
		c.Assert(bytes, DeepEquals, test.expected, com)
	}
}

func (s *ParserSuite) TestFillOFSDeltaObjectContent(c *C) {
	for i, test := range [...]struct {
		fixID      string
		offset     int64
		expOffset  int64
		expType    core.ObjectType
		expContent []byte
	}{
		{
			fixID:      "ofs-deltas",
			offset:     1212,
			expOffset:  -212,
			expType:    core.CommitObject,
			expContent: []byte("tree c4573589ce78ac63769c20742b9a970f6e274a38\nparent 4571a24948494ebe1cb3dc18ca5a9286e79705ae\nauthor Alberto Cortés <alberto@sourced.tech> 1448139640 +0100\ncommitter Alberto Cortés <alberto@sourced.tech> 1448139640 +0100\n\nUpdate reference to binrels module\n"),
		}, {
			fixID:      "ofs-deltas",
			offset:     3514,
			expOffset:  -102,
			expType:    core.TreeObject,
			expContent: []byte("100644 .gitignore\x00\u007fA\x90[Mw\xabJ\x9a-3O\xcd\x0f\xb5\xdbn\x8e!\x83100644 .gitmodules\x00\xd4`\xa8>\x15\xcfd\x05\x81B7_\xc4\v\x04\xa7\xa9A\x85\n100644 Makefile\x00-ҭ\x8c\x14\xdef\x12\xed\x15\x816y\xa6UK\xad\x993\v100644 binary-relations.tex\x00\x802\x05@\x11'^ \xf5<\xf7\xfd\x81%3\xd1o\xa9_$40000 graphs\x00\xdehu\x16\xc6\x0e\\H\x8e\xe9\xa1JIXE\xbaڽg\xc540000 imgs-gen\x00\xeb\"\xddhzg\xa3\x1f\xc8j\xc5\xfc豢\xe9\x96\xce\xce^40000 src\x00\x895\x11t\xff\x86\xa7\xea\xa6\xc0v%\x11E\x10f,ݒ\x1a"),
		}, {
			fixID:      "ofs-deltas",
			offset:     9806,
			expOffset:  -6613,
			expType:    core.TreeObject,
			expContent: []byte("100644 .gitignore\x00\u007fA\x90[Mw\xabJ\x9a-3O\xcd\x0f\xb5\xdbn\x8e!\x83100644 .gitmodules\x00\xd4`\xa8>\x15\xcfd\x05\x81B7_\xc4\v\x04\xa7\xa9A\x85\n100644 Makefile\x00-ҭ\x8c\x14\xdef\x12\xed\x15\x816y\xa6UK\xad\x993\v100644 binary-relations.tex\x00I\x13~\xb8کEU\x9f\x99#\xc4E.\x9d>\uef1e\xad40000 graphs\x00\xb9\x00\xf34\xde\xff\xce@+\xbd\xf8 9\xb8=\xc1\xb9\x00\x84]40000 imgs-gen\x00\xeb\"\xddhzg\xa3\x1f\xc8j\xc5\xfc豢\xe9\x96\xce\xce^40000 src\x00\x895\x11t\xff\x86\xa7\xea\xa6\xc0v%\x11E\x10f,ݒ\x1a"),
		},
	} {
		com := Commentf("test %d) fixture id = %s", i, test.fixID)
		fix, ok := s.fixtures[test.fixID]
		c.Assert(ok, Equals, true, com)

		err := fix.seek(test.offset)
		c.Assert(err, IsNil, com)
		p := fix.parser

		_, _, err = p.ReadObjectTypeAndLength()
		c.Assert(err, IsNil, com)

		beforeJumpSize, err := p.Offset()
		c.Assert(err, IsNil, com)

		jump, err := p.ReadNegativeOffset()
		c.Assert(err, IsNil, com)
		c.Assert(jump, Equals, test.expOffset, com)

		err = fix.seek(beforeJumpSize)
		c.Assert(err, IsNil, com)

		obj := &core.MemoryObject{}
		err = p.FillOFSDeltaObjectContent(obj, test.offset)
		c.Assert(err, IsNil, com)
		c.Assert(obj.Type(), Equals, test.expType, com)

		r, _ := obj.Reader()
		bytes, _ := ioutil.ReadAll(r)
		c.Assert(bytes, DeepEquals, test.expContent, com)
	}
}

func (s *ParserSuite) TestFillREFDeltaObjectContent(c *C) {
	for i, test := range [...]struct {
		fixID      string
		offset     int64
		deps       map[int64]core.Object
		expHash    core.Hash
		expType    core.ObjectType
		expContent []byte
	}{
		{
			fixID:  "ref-deltas",
			offset: 84849,
			deps: map[int64]core.Object{
				83607: newObject(core.TreeObject, []byte("100644 .gitignore\x002\x85\x8a\xad<8>\xd1\xff\n\x0f\x9b\xdf#\x1dT\xa0\f\x9e\x88100644 CHANGELOG\x00\xd3\xffS\xe0VJ\x9f\x87\xd8\xe8Kn(\xe5\x06\x0eQp\b\xaa100644 LICENSE\x00\xc1\x92\xbdj$\xea\x1a\xb0\x1dxhnA|\x8b\xdc|=\x19\u007f100644 binary.jpg\x00\xd5\xc0\xf4\xab\x81\x18\x97\xca\xdf\x03\xae\xc3X\xae`\xd2\x1f\x91\xc5\r40000 go\x00\xa3\x97q\xa7e\x1f\x97\xfa\xf5\xc7.\b\"M\x85\u007f\xc3Q3\xdb40000 json\x00Z\x87~j\x90j'C\xadnEٜ\x17\x93d*\xaf\x8e\xda40000 php\x00Xj\xf5gл^w\x1eI\xbd\xd9CO^\x0f\xb7m%\xfa40000 vendor\x00\xcfJ\xa3\xb3\x89t\xfb}\x81\xf3g\xc0\x83\x0f}x\xd6Z\xb8k")),
			},
			expHash:    core.NewHash("a8d315b2b1c615d43042c3a62402b8a54288cf5c"),
			expType:    core.TreeObject,
			expContent: []byte("100644 .gitignore\x002\x85\x8a\xad<8>\xd1\xff\n\x0f\x9b\xdf#\x1dT\xa0\f\x9e\x88100644 CHANGELOG\x00\xd3\xffS\xe0VJ\x9f\x87\xd8\xe8Kn(\xe5\x06\x0eQp\b\xaa100644 LICENSE\x00\xc1\x92\xbdj$\xea\x1a\xb0\x1dxhnA|\x8b\xdc|=\x19\u007f100644 binary.jpg\x00\xd5\xc0\xf4\xab\x81\x18\x97\xca\xdf\x03\xae\xc3X\xae`\xd2\x1f\x91\xc5\r40000 go\x00\xa3\x97q\xa7e\x1f\x97\xfa\xf5\xc7.\b\"M\x85\u007f\xc3Q3\xdb40000 json\x00Z\x87~j\x90j'C\xadnEٜ\x17\x93d*\xaf\x8e\xda40000 php\x00Xj\xf5gл^w\x1eI\xbd\xd9CO^\x0f\xb7m%\xfa"),
		}, {
			fixID:  "ref-deltas",
			offset: 85070,
			deps: map[int64]core.Object{
				84922: newObject(core.TreeObject, []byte("100644 .gitignore\x002\x85\x8a\xad<8>\xd1\xff\n\x0f\x9b\xdf#\x1dT\xa0\f\x9e\x88100644 CHANGELOG\x00\xd3\xffS\xe0VJ\x9f\x87\xd8\xe8Kn(\xe5\x06\x0eQp\b\xaa100644 LICENSE\x00\xc1\x92\xbdj$\xea\x1a\xb0\x1dxhnA|\x8b\xdc|=\x19\u007f100644 binary.jpg\x00\xd5\xc0\xf4\xab\x81\x18\x97\xca\xdf\x03\xae\xc3X\xae`\xd2\x1f\x91\xc5\r")),
				84849: newObject(core.TreeObject, []byte("100644 .gitignore\x002\x85\x8a\xad<8>\xd1\xff\n\x0f\x9b\xdf#\x1dT\xa0\f\x9e\x88100644 CHANGELOG\x00\xd3\xffS\xe0VJ\x9f\x87\xd8\xe8Kn(\xe5\x06\x0eQp\b\xaa100644 LICENSE\x00\xc1\x92\xbdj$\xea\x1a\xb0\x1dxhnA|\x8b\xdc|=\x19\u007f100644 binary.jpg\x00\xd5\xc0\xf4\xab\x81\x18\x97\xca\xdf\x03\xae\xc3X\xae`\xd2\x1f\x91\xc5\r40000 go\x00\xa3\x97q\xa7e\x1f\x97\xfa\xf5\xc7.\b\"M\x85\u007f\xc3Q3\xdb40000 json\x00Z\x87~j\x90j'C\xadnEٜ\x17\x93d*\xaf\x8e\xda40000 php\x00Xj\xf5gл^w\x1eI\xbd\xd9CO^\x0f\xb7m%\xfa")),
				83607: newObject(core.TreeObject, []byte("100644 .gitignore\x002\x85\x8a\xad<8>\xd1\xff\n\x0f\x9b\xdf#\x1dT\xa0\f\x9e\x88100644 CHANGELOG\x00\xd3\xffS\xe0VJ\x9f\x87\xd8\xe8Kn(\xe5\x06\x0eQp\b\xaa100644 LICENSE\x00\xc1\x92\xbdj$\xea\x1a\xb0\x1dxhnA|\x8b\xdc|=\x19\u007f100644 binary.jpg\x00\xd5\xc0\xf4\xab\x81\x18\x97\xca\xdf\x03\xae\xc3X\xae`\xd2\x1f\x91\xc5\r40000 go\x00\xa3\x97q\xa7e\x1f\x97\xfa\xf5\xc7.\b\"M\x85\u007f\xc3Q3\xdb40000 json\x00Z\x87~j\x90j'C\xadnEٜ\x17\x93d*\xaf\x8e\xda40000 php\x00Xj\xf5gл^w\x1eI\xbd\xd9CO^\x0f\xb7m%\xfa40000 vendor\x00\xcfJ\xa3\xb3\x89t\xfb}\x81\xf3g\xc0\x83\x0f}x\xd6Z\xb8k")),
			},
			expHash:    core.NewHash("eba74343e2f15d62adedfd8c883ee0262b5c8021"),
			expType:    core.TreeObject,
			expContent: []byte("100644 .gitignore\x002\x85\x8a\xad<8>\xd1\xff\n\x0f\x9b\xdf#\x1dT\xa0\f\x9e\x88100644 LICENSE\x00\xc1\x92\xbdj$\xea\x1a\xb0\x1dxhnA|\x8b\xdc|=\x19\u007f100644 binary.jpg\x00\xd5\xc0\xf4\xab\x81\x18\x97\xca\xdf\x03\xae\xc3X\xae`\xd2\x1f\x91\xc5\r"),
		},
	} {
		com := Commentf("test %d) fixture id = %s", i, test.fixID)
		fix, ok := s.fixtures[test.fixID]
		c.Assert(ok, Equals, true, com)

		err := fix.seek(test.offset)
		c.Assert(err, IsNil, com)
		p := fix.parser
		for k, v := range test.deps {
			err = p.Remember(k, v)
			c.Assert(err, IsNil, com)
		}

		_, _, err = p.ReadObjectTypeAndLength()
		c.Assert(err, IsNil, com)

		beforeHash, err := p.Offset()
		c.Assert(err, IsNil, com)

		hash, err := p.ReadHash()
		c.Assert(err, IsNil, com)
		c.Assert(hash, Equals, test.expHash, com)

		err = fix.seek(beforeHash)
		c.Assert(err, IsNil, com)

		obj := &core.MemoryObject{}
		err = p.FillREFDeltaObjectContent(obj)
		c.Assert(err, IsNil, com)
		c.Assert(obj.Type(), Equals, test.expType, com)

		r, _ := obj.Reader()
		bytes, _ := ioutil.ReadAll(r)
		c.Assert(bytes, DeepEquals, test.expContent, com)

		p.ForgetAll()
	}
}

func newObject(t core.ObjectType, c []byte) core.Object {
	o := &core.MemoryObject{}
	o.SetType(t)
	o.SetSize(int64(len(c)))
	o.Write(c)

	return o
}

func (s *ParserSuite) TestReadHeaderBadSignatureError(c *C) {
	data := []byte{
		0x50, 0x42, 0x43, 0x4b, 0x00, 0x00, 0x00, 0x02,
		0x00, 0x00, 0x00, 0x50,
	}
	p := NewParser(NewSeekable(bytes.NewReader(data)))

	_, err := p.ReadHeader()
	c.Assert(err, ErrorMatches, ErrBadSignature.Error())
}

func (s *ParserSuite) TestReadHeaderEmptyPackfileError(c *C) {
	data := []byte{}
	p := NewParser(NewSeekable(bytes.NewReader(data)))

	_, err := p.ReadHeader()
	c.Assert(err, ErrorMatches, ErrEmptyPackfile.Error())
}

func (s *ParserSuite) TestReadHeaderUnsupportedVersionError(c *C) {
	data := []byte{
		0x50, 0x41, 0x43, 0x4b, 0x00, 0x00, 0x00, 0x01,
		0x00, 0x00, 0x00, 0x50,
	}
	p := NewParser(NewSeekable(bytes.NewReader(data)))

	_, err := p.ReadHeader()
	c.Assert(err, ErrorMatches, ErrUnsupportedVersion.Error()+".*")
}

func (s *ParserSuite) TestReadHeader(c *C) {
	data := []byte{
		0x50, 0x41, 0x43, 0x4b, 0x00, 0x00, 0x00, 0x02,
		0x00, 0x00, 0x00, 0x50,
	}
	p := NewParser(NewSeekable(bytes.NewReader(data)))

	count, err := p.ReadHeader()
	c.Assert(err, IsNil)
	c.Assert(count, Equals, uint32(0x50))
}
*/