github.com/catandhorse/git-lfs@v2.5.2+incompatible/git/pkt_line_test.go (about) 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 }