| 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/src-d/go-git.v4/plumbing/protocol/packp/capability" |
| |
| . "gopkg.in/check.v1" |
| ) |
| |
| type UlReqDecodeSuite struct{} |
| |
| var _ = Suite(&UlReqDecodeSuite{}) |
| |
| func (s *UlReqDecodeSuite) TestEmpty(c *C) { |
| ur := NewUploadRequest() |
| 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 := NewUploadRequest() |
| 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) *UploadRequest { |
| var buf bytes.Buffer |
| e := pktline.NewEncoder(&buf) |
| err := e.EncodeString(payloads...) |
| c.Assert(err, IsNil) |
| |
| ur := NewUploadRequest() |
| 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(capability.OFSDelta), Equals, true) |
| c.Assert(ur.Capabilities.Supports(capability.MultiACK), 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(capability.OFSDelta), Equals, true) |
| c.Assert(ur.Capabilities.Supports(capability.MultiACK), 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(capability.OFSDelta), Equals, true) |
| c.Assert(ur.Capabilities.Supports(capability.MultiACK), 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(capability.OFSDelta), Equals, true) |
| c.Assert(ur.Capabilities.Supports(capability.MultiACK), 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(capability.OFSDelta), Equals, true) |
| c.Assert(ur.Capabilities.Supports(capability.MultiACK), 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(capability.OFSDelta), Equals, true) |
| c.Assert(ur.Capabilities.Supports(capability.MultiACK), 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(capability.OFSDelta), Equals, true) |
| c.Assert(ur.Capabilities.Supports(capability.MultiACK), 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.*") |
| } |
