git/pkt_line_test.go

   1 package git
   2
   3 import (
   4         "bytes"
   5         "io"
   6         "testing"
   7
   8         "github.com/stretchr/testify/assert"
   9         "github.com/stretchr/testify/require"
  10 )
  11
  12 type PacketReadTestCase struct {
  13         In []byte
  14
  15         Payload []byte
  16         Err     string
  17 }
  18
  19 func (c *PacketReadTestCase) Assert(t *testing.T) {
  20         buf := bytes.NewReader(c.In)
  21         rw := newPktline(buf, nil)
  22
  23         pkt, err := rw.readPacket()
  24
  25         if len(c.Payload) > 0 {
  26                 assert.Equal(t, c.Payload, pkt)
  27         } else {
  28                 assert.Empty(t, pkt)
  29         }
  30
  31         if len(c.Err) > 0 {
  32                 require.NotNil(t, err)
  33                 assert.Equal(t, c.Err, err.Error())
  34         } else {
  35                 assert.Nil(t, err)
  36         }
  37 }
  38
  39 func TestPktLineReadsWholePackets(t *testing.T) {
  40         tc := &PacketReadTestCase{
  41                 In: []byte{
  42                         0x30, 0x30, 0x30, 0x38, // 0008 (hex. length)
  43                         0x1, 0x2, 0x3, 0x4, // payload
  44                 },
  45                 Payload: []byte{0x1, 0x2, 0x3, 0x4},
  46         }
  47
  48         tc.Assert(t)
  49 }
  50
  51 func TestPktLineNoPacket(t *testing.T) {
  52         tc := &PacketReadTestCase{
  53                 In:  []byte{},
  54                 Err: io.EOF.Error(),
  55         }
  56
  57         tc.Assert(t)
  58 }
  59
  60 func TestPktLineEmptyPacket(t *testing.T) {
  61         tc := &PacketReadTestCase{
  62                 In: []byte{
  63                         0x30, 0x30, 0x30, 0x34,
  64                         // No body (invalid)
  65                 },
  66
  67                 Err: "Invalid packet length.",
  68         }
  69
  70         tc.Assert(t)
  71
  72 }
  73
  74 func TestPktLineFlushPacket(t *testing.T) {
  75         tc := &PacketReadTestCase{
  76                 In: []byte{0x30, 0x30, 0x30, 0x30}, // Flush packet
  77
  78                 Payload: []byte{},
  79                 Err:     "",
  80         }
  81
  82         tc.Assert(t)
  83 }
  84
  85 func TestPktLineDiscardsPacketsWithUnparseableLength(t *testing.T) {
  86         tc := &PacketReadTestCase{
  87                 In: []byte{
  88                         0xff, 0xff, 0xff, 0xff, // ÿÿÿÿ (invalid hex. length)
  89                         // No body
  90                 },
  91                 Err: "strconv.ParseInt: parsing \"\\xff\\xff\\xff\\xff\": invalid syntax",
  92         }
  93
  94         tc.Assert(t)
  95 }
  96
  97 func TestPktLineReadsTextWithNewline(t *testing.T) {
  98         rw := newPktline(bytes.NewReader([]byte{
  99                 0x30, 0x30, 0x30, 0x39, // 0009 (hex. length)
 100                 0x61, 0x62, 0x63, 0x64, 0xa,
 101                 // Empty body
 102         }), nil)
 103
 104         str, err := rw.readPacketText()
 105
 106         assert.Nil(t, err)
 107         assert.Equal(t, "abcd", str)
 108 }
 109
 110 func TestPktLineReadsTextWithoutNewline(t *testing.T) {
 111         rw := newPktline(bytes.NewReader([]byte{
 112                 0x30, 0x30, 0x30, 0x38, // 0009 (hex. length)
 113                 0x61, 0x62, 0x63, 0x64,
 114         }), nil)
 115
 116         str, err := rw.readPacketText()
 117
 118         assert.Nil(t, err)
 119         assert.Equal(t, "abcd", str)
 120 }
 121
 122 func TestPktLineReadsTextWithErr(t *testing.T) {
 123         rw := newPktline(bytes.NewReader([]byte{
 124                 0x30, 0x30, 0x30, 0x34, // 0004 (hex. length)
 125                 // No body
 126         }), nil)
 127
 128         str, err := rw.readPacketText()
 129
 130         require.NotNil(t, err)
 131         assert.Equal(t, "Invalid packet length.", err.Error())
 132         assert.Equal(t, "", str)
 133 }
 134
 135 func TestPktLineAppendsPacketLists(t *testing.T) {
 136         rw := newPktline(bytes.NewReader([]byte{
 137                 0x30, 0x30, 0x30, 0x38, // 0009 (hex. length)
 138                 0x61, 0x62, 0x63, 0x64, // "abcd"
 139
 140                 0x30, 0x30, 0x30, 0x38, // 0008 (hex. length)
 141                 0x65, 0x66, 0x67, 0x68, // "efgh"
 142
 143                 0x30, 0x30, 0x30, 0x30, // 0000 (hex. length)
 144         }), nil)
 145
 146         str, err := rw.readPacketList()
 147
 148         assert.Nil(t, err)
 149         assert.Equal(t, []string{"abcd", "efgh"}, str)
 150 }
 151
 152 func TestPktLineAppendsPacketListsAndReturnsErrs(t *testing.T) {
 153         rw := newPktline(bytes.NewReader([]byte{
 154                 0x30, 0x30, 0x30, 0x38, // 0009 (hex. length)
 155                 0x61, 0x62, 0x63, 0x64, // "abcd"
 156
 157                 0x30, 0x30, 0x30, 0x34, // 0004 (hex. length)
 158                 // No body
 159         }), nil)
 160
 161         str, err := rw.readPacketList()
 162
 163         require.NotNil(t, err)
 164         assert.Equal(t, "Invalid packet length.", err.Error())
 165         assert.Empty(t, str)
 166 }
 167
 168 func TestPktLineWritesPackets(t *testing.T) {
 169         var buf bytes.Buffer
 170
 171         rw := newPktline(nil, &buf)
 172         require.Nil(t, rw.writePacket([]byte{
 173                 0x1, 0x2, 0x3, 0x4,
 174         }))
 175         require.Nil(t, rw.writeFlush())
 176
 177         assert.Equal(t, []byte{
 178                 0x30, 0x30, 0x30, 0x38, // 0008 (hex. length)
 179                 0x1, 0x2, 0x3, 0x4, // payload
 180                 0x30, 0x30, 0x30, 0x30, // 0000 (flush packet)
 181         }, buf.Bytes())
 182 }
 183
 184 func TestPktLineWritesPacketsEqualToMaxLength(t *testing.T) {
 185         var buf bytes.Buffer
 186
 187         rw := newPktline(nil, &buf)
 188         err := rw.writePacket(make([]byte, MaxPacketLength))
 189
 190         assert.Nil(t, err)
 191         assert.Equal(t, 4+MaxPacketLength, len(buf.Bytes()))
 192 }
 193
 194 func TestPktLineDoesNotWritePacketsExceedingMaxLength(t *testing.T) {
 195         var buf bytes.Buffer
 196
 197         rw := newPktline(nil, &buf)
 198         err := rw.writePacket(make([]byte, MaxPacketLength+1))
 199
 200         require.NotNil(t, err)
 201         assert.Equal(t, "Packet length exceeds maximal length", err.Error())
 202         assert.Empty(t, buf.Bytes())
 203 }
 204
 205 func TestPktLineWritesPacketText(t *testing.T) {
 206         var buf bytes.Buffer
 207
 208         rw := newPktline(nil, &buf)
 209
 210         require.Nil(t, rw.writePacketText("abcd"))
 211         require.Nil(t, rw.writeFlush())
 212
 213         assert.Equal(t, []byte{
 214                 0x30, 0x30, 0x30, 0x39, // 0009 (hex. length)
 215                 0x61, 0x62, 0x63, 0x64, 0xa, // "abcd\n" (payload)
 216                 0x30, 0x30, 0x30, 0x30, // 0000 (flush packet)
 217         }, buf.Bytes())
 218 }
 219
 220 func TestPktLineWritesPacketLists(t *testing.T) {
 221         var buf bytes.Buffer
 222
 223         rw := newPktline(nil, &buf)
 224         err := rw.writePacketList([]string{"foo", "bar"})
 225
 226         assert.Nil(t, err)
 227         assert.Equal(t, []byte{
 228                 0x30, 0x30, 0x30, 0x38, // 0008 (hex. length)
 229                 0x66, 0x6f, 0x6f, 0xa, // "foo\n" (payload)
 230
 231                 0x30, 0x30, 0x30, 0x38, // 0008 (hex. length)
 232                 0x62, 0x61, 0x72, 0xa, // "bar\n" (payload)
 233
 234                 0x30, 0x30, 0x30, 0x30, // 0000 (hex. length)
 235         }, buf.Bytes())
 236 }