2016-10-26 21:39:35 +00:00
|
|
|
package git
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
2016-11-03 17:51:21 +00:00
|
|
|
"io"
|
2016-10-26 21:39:35 +00:00
|
|
|
"testing"
|
|
|
|
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
)
|
|
|
|
|
|
|
|
type PacketReadTestCase struct {
|
|
|
|
In []byte
|
|
|
|
|
|
|
|
Payload []byte
|
|
|
|
Err string
|
|
|
|
}
|
|
|
|
|
|
|
|
func (c *PacketReadTestCase) Assert(t *testing.T) {
|
|
|
|
buf := bytes.NewReader(c.In)
|
2016-11-08 20:45:38 +00:00
|
|
|
rw := newPktline(buf, nil)
|
2016-10-26 21:39:35 +00:00
|
|
|
|
|
|
|
pkt, err := rw.readPacket()
|
|
|
|
|
|
|
|
if len(c.Payload) > 0 {
|
|
|
|
assert.Equal(t, c.Payload, pkt)
|
|
|
|
} else {
|
|
|
|
assert.Empty(t, pkt)
|
|
|
|
}
|
|
|
|
|
|
|
|
if len(c.Err) > 0 {
|
|
|
|
require.NotNil(t, err)
|
|
|
|
assert.Equal(t, c.Err, err.Error())
|
|
|
|
} else {
|
|
|
|
assert.Nil(t, err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineReadsWholePackets(t *testing.T) {
|
2016-10-26 21:39:35 +00:00
|
|
|
tc := &PacketReadTestCase{
|
|
|
|
In: []byte{
|
|
|
|
0x30, 0x30, 0x30, 0x38, // 0008 (hex. length)
|
|
|
|
0x1, 0x2, 0x3, 0x4, // payload
|
|
|
|
},
|
|
|
|
Payload: []byte{0x1, 0x2, 0x3, 0x4},
|
|
|
|
}
|
|
|
|
|
|
|
|
tc.Assert(t)
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineNoPacket(t *testing.T) {
|
2016-11-03 17:51:21 +00:00
|
|
|
tc := &PacketReadTestCase{
|
|
|
|
In: []byte{},
|
|
|
|
Err: io.EOF.Error(),
|
|
|
|
}
|
|
|
|
|
|
|
|
tc.Assert(t)
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineEmptyPacket(t *testing.T) {
|
2016-10-26 21:39:35 +00:00
|
|
|
tc := &PacketReadTestCase{
|
|
|
|
In: []byte{
|
2016-11-03 17:51:21 +00:00
|
|
|
0x30, 0x30, 0x30, 0x34,
|
|
|
|
// No body (invalid)
|
2016-10-26 21:39:35 +00:00
|
|
|
},
|
2016-11-03 17:51:21 +00:00
|
|
|
|
2016-10-26 21:39:35 +00:00
|
|
|
Err: "Invalid packet length.",
|
|
|
|
}
|
|
|
|
|
|
|
|
tc.Assert(t)
|
2016-11-03 17:51:21 +00:00
|
|
|
|
2016-10-26 21:39:35 +00:00
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineFlushPacket(t *testing.T) {
|
2016-10-26 21:39:35 +00:00
|
|
|
tc := &PacketReadTestCase{
|
2016-11-03 17:51:21 +00:00
|
|
|
In: []byte{0x30, 0x30, 0x30, 0x30}, // Flush packet
|
|
|
|
|
|
|
|
Payload: []byte{},
|
|
|
|
Err: "",
|
2016-10-26 21:39:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tc.Assert(t)
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineDiscardsPacketsWithUnparseableLength(t *testing.T) {
|
2016-10-26 21:39:35 +00:00
|
|
|
tc := &PacketReadTestCase{
|
|
|
|
In: []byte{
|
2016-11-03 17:51:21 +00:00
|
|
|
0xff, 0xff, 0xff, 0xff, // ÿÿÿÿ (invalid hex. length)
|
|
|
|
// No body
|
2016-10-26 21:39:35 +00:00
|
|
|
},
|
2016-11-03 17:51:21 +00:00
|
|
|
Err: "strconv.ParseInt: parsing \"\\xff\\xff\\xff\\xff\": invalid syntax",
|
2016-10-26 21:39:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
tc.Assert(t)
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineReadsTextWithNewline(t *testing.T) {
|
|
|
|
rw := newPktline(bytes.NewReader([]byte{
|
2016-10-26 21:39:35 +00:00
|
|
|
0x30, 0x30, 0x30, 0x39, // 0009 (hex. length)
|
|
|
|
0x61, 0x62, 0x63, 0x64, 0xa,
|
|
|
|
// Empty body
|
|
|
|
}), nil)
|
|
|
|
|
|
|
|
str, err := rw.readPacketText()
|
|
|
|
|
|
|
|
assert.Nil(t, err)
|
|
|
|
assert.Equal(t, "abcd", str)
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineReadsTextWithoutNewline(t *testing.T) {
|
|
|
|
rw := newPktline(bytes.NewReader([]byte{
|
2016-10-26 21:39:35 +00:00
|
|
|
0x30, 0x30, 0x30, 0x38, // 0009 (hex. length)
|
|
|
|
0x61, 0x62, 0x63, 0x64,
|
|
|
|
}), nil)
|
|
|
|
|
|
|
|
str, err := rw.readPacketText()
|
|
|
|
|
|
|
|
assert.Nil(t, err)
|
|
|
|
assert.Equal(t, "abcd", str)
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineReadsTextWithErr(t *testing.T) {
|
|
|
|
rw := newPktline(bytes.NewReader([]byte{
|
2016-10-26 21:39:35 +00:00
|
|
|
0x30, 0x30, 0x30, 0x34, // 0004 (hex. length)
|
|
|
|
// No body
|
|
|
|
}), nil)
|
|
|
|
|
|
|
|
str, err := rw.readPacketText()
|
|
|
|
|
|
|
|
require.NotNil(t, err)
|
|
|
|
assert.Equal(t, "Invalid packet length.", err.Error())
|
|
|
|
assert.Equal(t, "", str)
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineAppendsPacketLists(t *testing.T) {
|
|
|
|
rw := newPktline(bytes.NewReader([]byte{
|
2016-10-26 21:39:35 +00:00
|
|
|
0x30, 0x30, 0x30, 0x38, // 0009 (hex. length)
|
|
|
|
0x61, 0x62, 0x63, 0x64, // "abcd"
|
|
|
|
|
|
|
|
0x30, 0x30, 0x30, 0x38, // 0008 (hex. length)
|
|
|
|
0x65, 0x66, 0x67, 0x68, // "efgh"
|
|
|
|
|
|
|
|
0x30, 0x30, 0x30, 0x30, // 0000 (hex. length)
|
|
|
|
}), nil)
|
|
|
|
|
|
|
|
str, err := rw.readPacketList()
|
|
|
|
|
|
|
|
assert.Nil(t, err)
|
|
|
|
assert.Equal(t, []string{"abcd", "efgh"}, str)
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineAppendsPacketListsAndReturnsErrs(t *testing.T) {
|
|
|
|
rw := newPktline(bytes.NewReader([]byte{
|
2016-10-26 21:39:35 +00:00
|
|
|
0x30, 0x30, 0x30, 0x38, // 0009 (hex. length)
|
|
|
|
0x61, 0x62, 0x63, 0x64, // "abcd"
|
|
|
|
|
|
|
|
0x30, 0x30, 0x30, 0x34, // 0004 (hex. length)
|
|
|
|
// No body
|
|
|
|
}), nil)
|
|
|
|
|
|
|
|
str, err := rw.readPacketList()
|
|
|
|
|
|
|
|
require.NotNil(t, err)
|
|
|
|
assert.Equal(t, "Invalid packet length.", err.Error())
|
|
|
|
assert.Empty(t, str)
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineWritesPackets(t *testing.T) {
|
2016-10-26 21:39:35 +00:00
|
|
|
var buf bytes.Buffer
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
rw := newPktline(nil, &buf)
|
2016-11-15 17:03:35 +00:00
|
|
|
require.Nil(t, rw.writePacket([]byte{
|
2016-10-26 21:39:35 +00:00
|
|
|
0x1, 0x2, 0x3, 0x4,
|
2016-11-15 17:03:35 +00:00
|
|
|
}))
|
|
|
|
require.Nil(t, rw.writeFlush())
|
2016-10-26 21:39:35 +00:00
|
|
|
|
|
|
|
assert.Equal(t, []byte{
|
|
|
|
0x30, 0x30, 0x30, 0x38, // 0008 (hex. length)
|
|
|
|
0x1, 0x2, 0x3, 0x4, // payload
|
2016-11-15 17:03:35 +00:00
|
|
|
0x30, 0x30, 0x30, 0x30, // 0000 (flush packet)
|
2016-10-26 21:39:35 +00:00
|
|
|
}, buf.Bytes())
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineWritesPacketsEqualToMaxLength(t *testing.T) {
|
2016-11-03 00:03:06 +00:00
|
|
|
var buf bytes.Buffer
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
rw := newPktline(nil, &buf)
|
2016-11-03 00:03:06 +00:00
|
|
|
err := rw.writePacket(make([]byte, MaxPacketLength))
|
|
|
|
|
|
|
|
assert.Nil(t, err)
|
|
|
|
assert.Equal(t, 4+MaxPacketLength, len(buf.Bytes()))
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineDoesNotWritePacketsExceedingMaxLength(t *testing.T) {
|
2016-10-26 21:39:35 +00:00
|
|
|
var buf bytes.Buffer
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
rw := newPktline(nil, &buf)
|
2016-10-26 21:39:35 +00:00
|
|
|
err := rw.writePacket(make([]byte, MaxPacketLength+1))
|
|
|
|
|
|
|
|
require.NotNil(t, err)
|
|
|
|
assert.Equal(t, "Packet length exceeds maximal length", err.Error())
|
|
|
|
assert.Empty(t, buf.Bytes())
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineWritesPacketText(t *testing.T) {
|
2016-10-26 21:39:35 +00:00
|
|
|
var buf bytes.Buffer
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
rw := newPktline(nil, &buf)
|
2016-10-26 21:39:35 +00:00
|
|
|
|
2016-11-15 17:03:35 +00:00
|
|
|
require.Nil(t, rw.writePacketText("abcd"))
|
|
|
|
require.Nil(t, rw.writeFlush())
|
|
|
|
|
2016-10-26 21:39:35 +00:00
|
|
|
assert.Equal(t, []byte{
|
|
|
|
0x30, 0x30, 0x30, 0x39, // 0009 (hex. length)
|
|
|
|
0x61, 0x62, 0x63, 0x64, 0xa, // "abcd\n" (payload)
|
2016-11-15 17:03:35 +00:00
|
|
|
0x30, 0x30, 0x30, 0x30, // 0000 (flush packet)
|
2016-10-26 21:39:35 +00:00
|
|
|
}, buf.Bytes())
|
|
|
|
}
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
func TestPktLineWritesPacketLists(t *testing.T) {
|
2016-10-26 21:39:35 +00:00
|
|
|
var buf bytes.Buffer
|
|
|
|
|
2016-11-08 20:45:38 +00:00
|
|
|
rw := newPktline(nil, &buf)
|
2016-10-26 21:39:35 +00:00
|
|
|
err := rw.writePacketList([]string{"foo", "bar"})
|
|
|
|
|
|
|
|
assert.Nil(t, err)
|
|
|
|
assert.Equal(t, []byte{
|
|
|
|
0x30, 0x30, 0x30, 0x38, // 0008 (hex. length)
|
|
|
|
0x66, 0x6f, 0x6f, 0xa, // "foo\n" (payload)
|
|
|
|
|
|
|
|
0x30, 0x30, 0x30, 0x38, // 0008 (hex. length)
|
|
|
|
0x62, 0x61, 0x72, 0xa, // "bar\n" (payload)
|
|
|
|
|
|
|
|
0x30, 0x30, 0x30, 0x30, // 0000 (hex. length)
|
|
|
|
}, buf.Bytes())
|
|
|
|
}
|