git/pkt_line_reader_test.go

   1 package git
   2
   3 import (
   4         "bytes"
   5         "io"
   6         "io/ioutil"
   7         "testing"
   8
   9         "github.com/stretchr/testify/assert"
  10         "github.com/stretchr/testify/require"
  11 )
  12
  13 // writePackets
  14 func writePacket(t *testing.T, w io.Writer, datas ...[]byte) {
  15         pl := newPktline(nil, w)
  16
  17         for _, data := range datas {
  18                 require.Nil(t, pl.writePacket(data))
  19         }
  20
  21         require.Nil(t, pl.writeFlush())
  22 }
  23
  24 func TestPktlineReaderReadsSinglePacketsInOneCall(t *testing.T) {
  25         var buf bytes.Buffer
  26
  27         writePacket(t, &buf, []byte("asdf"))
  28
  29         pr := &pktlineReader{pl: newPktline(&buf, nil)}
  30
  31         data, err := ioutil.ReadAll(pr)
  32
  33         assert.Nil(t, err)
  34         assert.Equal(t, []byte("asdf"), data)
  35 }
  36
  37 func TestPktlineReaderReadsManyPacketsInOneCall(t *testing.T) {
  38         var buf bytes.Buffer
  39
  40         writePacket(t, &buf, []byte("first\n"), []byte("second"))
  41
  42         pr := &pktlineReader{pl: newPktline(&buf, nil)}
  43
  44         data, err := ioutil.ReadAll(pr)
  45
  46         assert.Nil(t, err)
  47         assert.Equal(t, []byte("first\nsecond"), data)
  48 }
  49
  50 func TestPktlineReaderReadsSinglePacketsInMultipleCallsWithUnevenBuffering(t *testing.T) {
  51         var buf bytes.Buffer
  52
  53         writePacket(t, &buf, []byte("asdf"))
  54
  55         pr := &pktlineReader{pl: newPktline(&buf, nil)}
  56
  57         var p1 [3]byte
  58         var p2 [1]byte
  59
  60         n1, e1 := pr.Read(p1[:])
  61         assert.Equal(t, 3, n1)
  62         assert.Equal(t, []byte("asd"), p1[:])
  63         assert.Nil(t, e1)
  64
  65         n2, e2 := pr.Read(p2[:])
  66         assert.Equal(t, 1, n2)
  67         assert.Equal(t, []byte("f"), p2[:])
  68         assert.Equal(t, io.EOF, e2)
  69 }
  70
  71 func TestPktlineReaderReadsManyPacketsInMultipleCallsWithUnevenBuffering(t *testing.T) {
  72         var buf bytes.Buffer
  73
  74         writePacket(t, &buf, []byte("first"), []byte("second"))
  75
  76         pr := &pktlineReader{pl: newPktline(&buf, nil)}
  77
  78         var p1 [4]byte
  79         var p2 [7]byte
  80         var p3 []byte
  81
  82         n1, e1 := pr.Read(p1[:])
  83         assert.Equal(t, 4, n1)
  84         assert.Equal(t, []byte("firs"), p1[:])
  85         assert.Nil(t, e1)
  86
  87         n2, e2 := pr.Read(p2[:])
  88         assert.Equal(t, 7, n2)
  89         assert.Equal(t, []byte("tsecond"), p2[:])
  90         assert.Equal(t, io.EOF, e2)
  91
  92         n3, e3 := pr.Read(p3[:])
  93         assert.Equal(t, 0, n3)
  94         assert.Empty(t, p3)
  95         assert.Equal(t, io.EOF, e3)
  96 }
  97
  98 func TestPktlineReaderReadsSinglePacketsInMultipleCallsWithEvenBuffering(t *testing.T) {
  99         var buf bytes.Buffer
 100
 101         writePacket(t, &buf, []byte("firstother"))
 102
 103         pr := &pktlineReader{pl: newPktline(&buf, nil)}
 104
 105         var p1 [5]byte
 106         var p2 [5]byte
 107
 108         n1, e1 := pr.Read(p1[:])
 109         assert.Equal(t, 5, n1)
 110         assert.Equal(t, []byte("first"), p1[:])
 111         assert.Nil(t, e1)
 112
 113         n2, e2 := pr.Read(p2[:])
 114         assert.Equal(t, 5, n2)
 115         assert.Equal(t, []byte("other"), p2[:])
 116         assert.Equal(t, io.EOF, e2)
 117 }
 118
 119 func TestPktlineReaderReadsManyPacketsInMultipleCallsWithEvenBuffering(t *testing.T) {
 120         var buf bytes.Buffer
 121
 122         writePacket(t, &buf, []byte("first"), []byte("other"))
 123
 124         pr := &pktlineReader{pl: newPktline(&buf, nil)}
 125
 126         var p1 [5]byte
 127         var p2 [5]byte
 128         var p3 []byte
 129
 130         n1, e1 := pr.Read(p1[:])
 131         assert.Equal(t, 5, n1)
 132         assert.Equal(t, []byte("first"), p1[:])
 133         assert.Nil(t, e1)
 134
 135         n2, e2 := pr.Read(p2[:])
 136         assert.Equal(t, 5, n2)
 137         assert.Equal(t, []byte("other"), p2[:])
 138         assert.Equal(t, io.EOF, e2)
 139
 140         n3, e3 := pr.Read(p3)
 141         assert.Equal(t, 0, n3)
 142         assert.Equal(t, io.EOF, e3)
 143 }