aboutsummaryrefslogtreecommitdiffstats
path: root/plumbing/protocol/packp/ulreq_decoder_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'plumbing/protocol/packp/ulreq_decoder_test.go')
-rw-r--r--plumbing/protocol/packp/ulreq_decoder_test.go532
1 files changed, 532 insertions, 0 deletions
diff --git a/plumbing/protocol/packp/ulreq_decoder_test.go b/plumbing/protocol/packp/ulreq_decoder_test.go
new file mode 100644
index 0000000..e90962a
--- /dev/null
+++ b/plumbing/protocol/packp/ulreq_decoder_test.go
@@ -0,0 +1,532 @@
+package packp
+
+import (
+ "bytes"
+ "io"
+ "sort"
+ "time"
+
+ "gopkg.in/src-d/go-git.v4/plumbing"
+ "gopkg.in/src-d/go-git.v4/plumbing/format/pktline"
+
+ . "gopkg.in/check.v1"
+)
+
+type UlReqDecodeSuite struct{}
+
+var _ = Suite(&UlReqDecodeSuite{})
+
+func (s *UlReqDecodeSuite) TestEmpty(c *C) {
+ ur := NewUlReq()
+ var buf bytes.Buffer
+ d := NewUlReqDecoder(&buf)
+
+ err := d.Decode(ur)
+ c.Assert(err, ErrorMatches, "pkt-line 1: EOF")
+}
+
+func (s *UlReqDecodeSuite) TestNoWant(c *C) {
+ payloads := []string{
+ "foobar",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*missing 'want '.*")
+}
+
+func (s *UlReqDecodeSuite) testDecoderErrorMatches(c *C, input io.Reader, pattern string) {
+ ur := NewUlReq()
+ d := NewUlReqDecoder(input)
+
+ err := d.Decode(ur)
+ c.Assert(err, ErrorMatches, pattern)
+}
+
+func (s *UlReqDecodeSuite) TestInvalidFirstHash(c *C) {
+ payloads := []string{
+ "want 6ecf0ef2c2dffb796alberto2219af86ec6584e5\n",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*invalid hash.*")
+}
+
+func (s *UlReqDecodeSuite) TestWantOK(c *C) {
+ payloads := []string{
+ "want 1111111111111111111111111111111111111111",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ c.Assert(ur.Wants, DeepEquals, []plumbing.Hash{
+ plumbing.NewHash("1111111111111111111111111111111111111111"),
+ })
+}
+
+func (s *UlReqDecodeSuite) testDecodeOK(c *C, payloads []string) *UlReq {
+ var buf bytes.Buffer
+ e := pktline.NewEncoder(&buf)
+ err := e.EncodeString(payloads...)
+ c.Assert(err, IsNil)
+
+ ur := NewUlReq()
+ d := NewUlReqDecoder(&buf)
+
+ err = d.Decode(ur)
+ c.Assert(err, IsNil)
+
+ return ur
+}
+
+func (s *UlReqDecodeSuite) TestWantWithCapabilities(c *C) {
+ payloads := []string{
+ "want 1111111111111111111111111111111111111111 ofs-delta multi_ack",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+ c.Assert(ur.Wants, DeepEquals, []plumbing.Hash{
+ plumbing.NewHash("1111111111111111111111111111111111111111")})
+
+ c.Assert(ur.Capabilities.Supports("ofs-delta"), Equals, true)
+ c.Assert(ur.Capabilities.Supports("multi_ack"), Equals, true)
+}
+
+func (s *UlReqDecodeSuite) TestManyWantsNoCapabilities(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333",
+ "want 4444444444444444444444444444444444444444",
+ "want 1111111111111111111111111111111111111111",
+ "want 2222222222222222222222222222222222222222",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ expected := []plumbing.Hash{
+ plumbing.NewHash("1111111111111111111111111111111111111111"),
+ plumbing.NewHash("2222222222222222222222222222222222222222"),
+ plumbing.NewHash("3333333333333333333333333333333333333333"),
+ plumbing.NewHash("4444444444444444444444444444444444444444"),
+ }
+
+ sort.Sort(byHash(ur.Wants))
+ sort.Sort(byHash(expected))
+ c.Assert(ur.Wants, DeepEquals, expected)
+}
+
+type byHash []plumbing.Hash
+
+func (a byHash) Len() int { return len(a) }
+func (a byHash) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
+func (a byHash) Less(i, j int) bool {
+ ii := [20]byte(a[i])
+ jj := [20]byte(a[j])
+ return bytes.Compare(ii[:], jj[:]) < 0
+}
+
+func (s *UlReqDecodeSuite) TestManyWantsBadWant(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333",
+ "want 4444444444444444444444444444444444444444",
+ "foo",
+ "want 2222222222222222222222222222222222222222",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
+}
+
+func (s *UlReqDecodeSuite) TestManyWantsInvalidHash(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333",
+ "want 4444444444444444444444444444444444444444",
+ "want 1234567890abcdef",
+ "want 2222222222222222222222222222222222222222",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*malformed hash.*")
+}
+
+func (s *UlReqDecodeSuite) TestManyWantsWithCapabilities(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "want 4444444444444444444444444444444444444444",
+ "want 1111111111111111111111111111111111111111",
+ "want 2222222222222222222222222222222222222222",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ expected := []plumbing.Hash{
+ plumbing.NewHash("1111111111111111111111111111111111111111"),
+ plumbing.NewHash("2222222222222222222222222222222222222222"),
+ plumbing.NewHash("3333333333333333333333333333333333333333"),
+ plumbing.NewHash("4444444444444444444444444444444444444444"),
+ }
+
+ sort.Sort(byHash(ur.Wants))
+ sort.Sort(byHash(expected))
+ c.Assert(ur.Wants, DeepEquals, expected)
+
+ c.Assert(ur.Capabilities.Supports("ofs-delta"), Equals, true)
+ c.Assert(ur.Capabilities.Supports("multi_ack"), Equals, true)
+}
+
+func (s *UlReqDecodeSuite) TestSingleShallowSingleWant(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ expectedWants := []plumbing.Hash{
+ plumbing.NewHash("3333333333333333333333333333333333333333"),
+ }
+
+ expectedShallows := []plumbing.Hash{
+ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+ }
+
+ c.Assert(ur.Wants, DeepEquals, expectedWants)
+ c.Assert(ur.Capabilities.Supports("ofs-delta"), Equals, true)
+ c.Assert(ur.Capabilities.Supports("multi_ack"), Equals, true)
+
+ c.Assert(ur.Shallows, DeepEquals, expectedShallows)
+}
+
+func (s *UlReqDecodeSuite) TestSingleShallowManyWants(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "want 4444444444444444444444444444444444444444",
+ "want 1111111111111111111111111111111111111111",
+ "want 2222222222222222222222222222222222222222",
+ "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ expectedWants := []plumbing.Hash{
+ plumbing.NewHash("1111111111111111111111111111111111111111"),
+ plumbing.NewHash("2222222222222222222222222222222222222222"),
+ plumbing.NewHash("3333333333333333333333333333333333333333"),
+ plumbing.NewHash("4444444444444444444444444444444444444444"),
+ }
+ sort.Sort(byHash(expectedWants))
+
+ expectedShallows := []plumbing.Hash{
+ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+ }
+
+ sort.Sort(byHash(ur.Wants))
+ c.Assert(ur.Wants, DeepEquals, expectedWants)
+ c.Assert(ur.Capabilities.Supports("ofs-delta"), Equals, true)
+ c.Assert(ur.Capabilities.Supports("multi_ack"), Equals, true)
+
+ c.Assert(ur.Shallows, DeepEquals, expectedShallows)
+}
+
+func (s *UlReqDecodeSuite) TestManyShallowSingleWant(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ "shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+ "shallow cccccccccccccccccccccccccccccccccccccccc",
+ "shallow dddddddddddddddddddddddddddddddddddddddd",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ expectedWants := []plumbing.Hash{
+ plumbing.NewHash("3333333333333333333333333333333333333333"),
+ }
+
+ expectedShallows := []plumbing.Hash{
+ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+ plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
+ plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"),
+ plumbing.NewHash("dddddddddddddddddddddddddddddddddddddddd"),
+ }
+ sort.Sort(byHash(expectedShallows))
+
+ c.Assert(ur.Wants, DeepEquals, expectedWants)
+ c.Assert(ur.Capabilities.Supports("ofs-delta"), Equals, true)
+ c.Assert(ur.Capabilities.Supports("multi_ack"), Equals, true)
+
+ sort.Sort(byHash(ur.Shallows))
+ c.Assert(ur.Shallows, DeepEquals, expectedShallows)
+}
+
+func (s *UlReqDecodeSuite) TestManyShallowManyWants(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "want 4444444444444444444444444444444444444444",
+ "want 1111111111111111111111111111111111111111",
+ "want 2222222222222222222222222222222222222222",
+ "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ "shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+ "shallow cccccccccccccccccccccccccccccccccccccccc",
+ "shallow dddddddddddddddddddddddddddddddddddddddd",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ expectedWants := []plumbing.Hash{
+ plumbing.NewHash("1111111111111111111111111111111111111111"),
+ plumbing.NewHash("2222222222222222222222222222222222222222"),
+ plumbing.NewHash("3333333333333333333333333333333333333333"),
+ plumbing.NewHash("4444444444444444444444444444444444444444"),
+ }
+ sort.Sort(byHash(expectedWants))
+
+ expectedShallows := []plumbing.Hash{
+ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+ plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
+ plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"),
+ plumbing.NewHash("dddddddddddddddddddddddddddddddddddddddd"),
+ }
+ sort.Sort(byHash(expectedShallows))
+
+ sort.Sort(byHash(ur.Wants))
+ c.Assert(ur.Wants, DeepEquals, expectedWants)
+ c.Assert(ur.Capabilities.Supports("ofs-delta"), Equals, true)
+ c.Assert(ur.Capabilities.Supports("multi_ack"), Equals, true)
+
+ sort.Sort(byHash(ur.Shallows))
+ c.Assert(ur.Shallows, DeepEquals, expectedShallows)
+}
+
+func (s *UlReqDecodeSuite) TestMalformedShallow(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "shalow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
+}
+
+func (s *UlReqDecodeSuite) TestMalformedShallowHash(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*malformed hash.*")
+}
+
+func (s *UlReqDecodeSuite) TestMalformedShallowManyShallows(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ "shalow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+ "shallow cccccccccccccccccccccccccccccccccccccccc",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
+}
+
+func (s *UlReqDecodeSuite) TestMalformedDeepenSpec(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "deepen-foo 34",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*unexpected deepen.*")
+}
+
+func (s *UlReqDecodeSuite) TestMalformedDeepenSingleWant(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "depth 32",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
+}
+
+func (s *UlReqDecodeSuite) TestMalformedDeepenMultiWant(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "want 2222222222222222222222222222222222222222",
+ "depth 32",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
+}
+
+func (s *UlReqDecodeSuite) TestMalformedDeepenWithSingleShallow(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "shallow 2222222222222222222222222222222222222222",
+ "depth 32",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
+}
+
+func (s *UlReqDecodeSuite) TestMalformedDeepenWithMultiShallow(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "shallow 2222222222222222222222222222222222222222",
+ "shallow 5555555555555555555555555555555555555555",
+ "depth 32",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
+}
+
+func (s *UlReqDecodeSuite) TestDeepenCommits(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "deepen 1234",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0))
+ commits, ok := ur.Depth.(DepthCommits)
+ c.Assert(ok, Equals, true)
+ c.Assert(int(commits), Equals, 1234)
+}
+
+func (s *UlReqDecodeSuite) TestDeepenCommitsInfiniteInplicit(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "deepen 0",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0))
+ commits, ok := ur.Depth.(DepthCommits)
+ c.Assert(ok, Equals, true)
+ c.Assert(int(commits), Equals, 0)
+}
+
+func (s *UlReqDecodeSuite) TestDeepenCommitsInfiniteExplicit(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0))
+ commits, ok := ur.Depth.(DepthCommits)
+ c.Assert(ok, Equals, true)
+ c.Assert(int(commits), Equals, 0)
+}
+
+func (s *UlReqDecodeSuite) TestMalformedDeepenCommits(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "deepen -32",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*negative depth.*")
+}
+
+func (s *UlReqDecodeSuite) TestDeepenCommitsEmpty(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "deepen ",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*invalid syntax.*")
+}
+
+func (s *UlReqDecodeSuite) TestDeepenSince(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "deepen-since 1420167845", // 2015-01-02T03:04:05+00:00
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ expected := time.Date(2015, time.January, 2, 3, 4, 5, 0, time.UTC)
+
+ c.Assert(ur.Depth, FitsTypeOf, DepthSince(time.Now()))
+ since, ok := ur.Depth.(DepthSince)
+ c.Assert(ok, Equals, true)
+ c.Assert(time.Time(since).Equal(expected), Equals, true,
+ Commentf("obtained=%s\nexpected=%s", time.Time(since), expected))
+}
+
+func (s *UlReqDecodeSuite) TestDeepenReference(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "deepen-not refs/heads/master",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ expected := "refs/heads/master"
+
+ c.Assert(ur.Depth, FitsTypeOf, DepthReference(""))
+ reference, ok := ur.Depth.(DepthReference)
+ c.Assert(ok, Equals, true)
+ c.Assert(string(reference), Equals, expected)
+}
+
+func (s *UlReqDecodeSuite) TestAll(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "want 4444444444444444444444444444444444444444",
+ "want 1111111111111111111111111111111111111111",
+ "want 2222222222222222222222222222222222222222",
+ "shallow aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+ "shallow bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+ "shallow cccccccccccccccccccccccccccccccccccccccc",
+ "shallow dddddddddddddddddddddddddddddddddddddddd",
+ "deepen 1234",
+ pktline.FlushString,
+ }
+ ur := s.testDecodeOK(c, payloads)
+
+ expectedWants := []plumbing.Hash{
+ plumbing.NewHash("1111111111111111111111111111111111111111"),
+ plumbing.NewHash("2222222222222222222222222222222222222222"),
+ plumbing.NewHash("3333333333333333333333333333333333333333"),
+ plumbing.NewHash("4444444444444444444444444444444444444444"),
+ }
+ sort.Sort(byHash(expectedWants))
+ sort.Sort(byHash(ur.Wants))
+ c.Assert(ur.Wants, DeepEquals, expectedWants)
+
+ c.Assert(ur.Capabilities.Supports("ofs-delta"), Equals, true)
+ c.Assert(ur.Capabilities.Supports("multi_ack"), Equals, true)
+
+ expectedShallows := []plumbing.Hash{
+ plumbing.NewHash("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
+ plumbing.NewHash("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"),
+ plumbing.NewHash("cccccccccccccccccccccccccccccccccccccccc"),
+ plumbing.NewHash("dddddddddddddddddddddddddddddddddddddddd"),
+ }
+ sort.Sort(byHash(expectedShallows))
+ sort.Sort(byHash(ur.Shallows))
+ c.Assert(ur.Shallows, DeepEquals, expectedShallows)
+
+ c.Assert(ur.Depth, FitsTypeOf, DepthCommits(0))
+ commits, ok := ur.Depth.(DepthCommits)
+ c.Assert(ok, Equals, true)
+ c.Assert(int(commits), Equals, 1234)
+}
+
+func (s *UlReqDecodeSuite) TestExtraData(c *C) {
+ payloads := []string{
+ "want 3333333333333333333333333333333333333333 ofs-delta multi_ack",
+ "deepen 32",
+ "foo",
+ pktline.FlushString,
+ }
+ r := toPktLines(c, payloads)
+ s.testDecoderErrorMatches(c, r, ".*unexpected payload.*")
+}
generated by cgit (git 2.34.1) at 2024-11-10 22:51:01 +0000