peer_protocol/protocol_test.go

   1 package peer_protocol
   2
   3 import (
   4         "bufio"
   5         "bytes"
   6         "strings"
   7         "testing"
   8
   9         "github.com/stretchr/testify/assert"
  10 )
  11
  12 func TestBinaryReadSliceOfPointers(t *testing.T) {
  13         var msg Message
  14         r := bytes.NewBufferString("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00@\x00")
  15         if r.Len() != 12 {
  16                 t.Fatalf("expected 12 bytes left, but there %d", r.Len())
  17         }
  18         for _, data := range []*Integer{&msg.Index, &msg.Begin, &msg.Length} {
  19                 err := data.Read(r)
  20                 if err != nil {
  21                         t.Fatal(err)
  22                 }
  23         }
  24         if r.Len() != 0 {
  25                 t.FailNow()
  26         }
  27 }
  28
  29 func TestConstants(t *testing.T) {
  30         assert.EqualValues(t, 3, NotInterested)
  31         assert.EqualValues(t, 14, HaveAll)
  32 }
  33
  34 func TestBitfieldEncode(t *testing.T) {
  35         bf := make([]bool, 37)
  36         bf[2] = true
  37         bf[7] = true
  38         bf[32] = true
  39         s := string(marshalBitfield(bf))
  40         const expected = "\x21\x00\x00\x00\x80"
  41         if s != expected {
  42                 t.Fatalf("got %#v, expected %#v", s, expected)
  43         }
  44 }
  45
  46 func TestBitfieldUnmarshal(t *testing.T) {
  47         bf := unmarshalBitfield([]byte("\x81\x06"))
  48         expected := make([]bool, 16)
  49         expected[0] = true
  50         expected[7] = true
  51         expected[13] = true
  52         expected[14] = true
  53         if len(bf) != len(expected) {
  54                 t.FailNow()
  55         }
  56         for i := range expected {
  57                 if bf[i] != expected[i] {
  58                         t.FailNow()
  59                 }
  60         }
  61 }
  62
  63 func TestHaveEncode(t *testing.T) {
  64         actualBytes, err := Message{
  65                 Type:  Have,
  66                 Index: 42,
  67         }.MarshalBinary()
  68         if err != nil {
  69                 t.Fatal(err)
  70         }
  71         actualString := string(actualBytes)
  72         expected := "\x00\x00\x00\x05\x04\x00\x00\x00\x2a"
  73         if actualString != expected {
  74                 t.Fatalf("expected %#v, got %#v", expected, actualString)
  75         }
  76 }
  77
  78 func TestShortRead(t *testing.T) {
  79         dec := Decoder{
  80                 R:         bufio.NewReader(bytes.NewBufferString("\x00\x00\x00\x02\x00!")),
  81                 MaxLength: 2,
  82         }
  83         msg := new(Message)
  84         err := dec.Decode(msg)
  85         if !strings.Contains(err.Error(), "1 unused bytes in message type Choke") {
  86                 t.Fatal(err)
  87         }
  88 }
  89
  90 func TestUnexpectedEOF(t *testing.T) {
  91         msg := new(Message)
  92         for _, stream := range []string{
  93                 "\x00\x00\x00",     // Header truncated.
  94                 "\x00\x00\x00\x01", // Expecting 1 more byte.
  95                 // Request with wrong length, and too short anyway.
  96                 "\x00\x00\x00\x06\x06\x00\x00\x00\x00\x00",
  97                 // Request truncated.
  98                 "\x00\x00\x00\x0b\x06\x00\x00\x00\x00\x00",
  99         } {
 100                 dec := Decoder{
 101                         R:         bufio.NewReader(bytes.NewBufferString(stream)),
 102                         MaxLength: 42,
 103                 }
 104                 err := dec.Decode(msg)
 105                 if err == nil {
 106                         t.Fatalf("expected an error decoding %q", stream)
 107                 }
 108         }
 109 }
 110
 111 func TestMarshalKeepalive(t *testing.T) {
 112         b, err := (Message{
 113                 Keepalive: true,
 114         }).MarshalBinary()
 115         if err != nil {
 116                 t.Fatalf("error marshalling keepalive: %s", err)
 117         }
 118         bs := string(b)
 119         const expected = "\x00\x00\x00\x00"
 120         if bs != expected {
 121                 t.Fatalf("marshalled keepalive is %q, expected %q", bs, expected)
 122         }
 123 }
 124
 125 func TestMarshalPortMsg(t *testing.T) {
 126         b, err := (Message{
 127                 Type: Port,
 128                 Port: 0xaabb,
 129         }).MarshalBinary()
 130         if err != nil {
 131                 t.Fatal(err)
 132         }
 133         if string(b) != "\x00\x00\x00\x03\x09\xaa\xbb" {
 134                 t.FailNow()
 135         }
 136 }
 137
 138 func TestUnmarshalPortMsg(t *testing.T) {
 139         var m Message
 140         d := Decoder{
 141                 R:         bufio.NewReader(bytes.NewBufferString("\x00\x00\x00\x03\x09\xaa\xbb")),
 142                 MaxLength: 8,
 143         }
 144         err := d.Decode(&m)
 145         if err != nil {
 146                 t.Fatal(err)
 147         }
 148         if m.Type != Port {
 149                 t.FailNow()
 150         }
 151         if m.Port != 0xaabb {
 152                 t.FailNow()
 153         }
 154 }