git.r.bdr.sh - rbdr/mobius/blob - hotline/field_test.go

   1 package hotline
   2
   3 import (
   4         "fmt"
   5         "github.com/stretchr/testify/assert"
   6         "testing"
   7 )
   8
   9 func TestHello(t *testing.T) {
  10
  11 }
  12
  13 func Test_fieldScanner(t *testing.T) {
  14         type args struct {
  15                 data []byte
  16                 in1  bool
  17         }
  18         tests := []struct {
  19                 name        string
  20                 args        args
  21                 wantAdvance int
  22                 wantToken   []byte
  23                 wantErr     assert.ErrorAssertionFunc
  24         }{
  25                 {
  26                         name: "when too few bytes are provided to read the field size",
  27                         args: args{
  28                                 data: []byte{},
  29                                 in1:  false,
  30                         },
  31                         wantAdvance: 0,
  32                         wantToken:   []byte(nil),
  33                         wantErr:     assert.NoError,
  34                 },
  35                 {
  36                         name: "when too few bytes are provided to read the full payload",
  37                         args: args{
  38                                 data: []byte{
  39                                         0, 1,
  40                                         0, 4,
  41                                         0, 0,
  42                                 },
  43                                 in1: false,
  44                         },
  45                         wantAdvance: 0,
  46                         wantToken:   []byte(nil),
  47                         wantErr:     assert.NoError,
  48                 },
  49                 {
  50                         name: "when a full field is provided",
  51                         args: args{
  52                                 data: []byte{
  53                                         0, 1,
  54                                         0, 4,
  55                                         0, 0,
  56                                         0, 0,
  57                                 },
  58                                 in1: false,
  59                         },
  60                         wantAdvance: 8,
  61                         wantToken: []byte{
  62                                 0, 1,
  63                                 0, 4,
  64                                 0, 0,
  65                                 0, 0,
  66                         },
  67                         wantErr: assert.NoError,
  68                 },
  69                 {
  70                         name: "when a full field plus extra bytes are provided",
  71                         args: args{
  72                                 data: []byte{
  73                                         0, 1,
  74                                         0, 4,
  75                                         0, 0,
  76                                         0, 0,
  77                                         1, 1,
  78                                 },
  79                                 in1: false,
  80                         },
  81                         wantAdvance: 8,
  82                         wantToken: []byte{
  83                                 0, 1,
  84                                 0, 4,
  85                                 0, 0,
  86                                 0, 0,
  87                         },
  88                         wantErr: assert.NoError,
  89                 },
  90         }
  91         for _, tt := range tests {
  92                 t.Run(tt.name, func(t *testing.T) {
  93                         gotAdvance, gotToken, err := fieldScanner(tt.args.data, tt.args.in1)
  94                         if !tt.wantErr(t, err, fmt.Sprintf("fieldScanner(%v, %v)", tt.args.data, tt.args.in1)) {
  95                                 return
  96                         }
  97                         assert.Equalf(t, tt.wantAdvance, gotAdvance, "fieldScanner(%v, %v)", tt.args.data, tt.args.in1)
  98                         assert.Equalf(t, tt.wantToken, gotToken, "fieldScanner(%v, %v)", tt.args.data, tt.args.in1)
  99                 })
 100         }
 101 }
 102
 103 func TestField_Read(t *testing.T) {
 104         type fields struct {
 105                 ID         [2]byte
 106                 FieldSize  [2]byte
 107                 Data       []byte
 108                 readOffset int
 109         }
 110         type args struct {
 111                 p []byte
 112         }
 113         tests := []struct {
 114                 name      string
 115                 fields    fields
 116                 args      args
 117                 want      int
 118                 wantErr   assert.ErrorAssertionFunc
 119                 wantBytes []byte
 120         }{
 121                 {
 122                         name: "returns field bytes",
 123                         fields: fields{
 124                                 ID:        [2]byte{0x00, 0x62},
 125                                 FieldSize: [2]byte{0x00, 0x03},
 126                                 Data:      []byte("hai!"),
 127                         },
 128                         args: args{
 129                                 p: make([]byte, 512),
 130                         },
 131                         want:    8,
 132                         wantErr: assert.NoError,
 133                         wantBytes: []byte{
 134                                 0x00, 0x62,
 135                                 0x00, 0x03,
 136                                 0x68, 0x61, 0x69, 0x21,
 137                         },
 138                 },
 139                 {
 140                         name: "returns field bytes from readOffset",
 141                         fields: fields{
 142                                 ID:         [2]byte{0x00, 0x62},
 143                                 FieldSize:  [2]byte{0x00, 0x03},
 144                                 Data:       []byte("hai!"),
 145                                 readOffset: 4,
 146                         },
 147                         args: args{
 148                                 p: make([]byte, 512),
 149                         },
 150                         want:    4,
 151                         wantErr: assert.NoError,
 152                         wantBytes: []byte{
 153                                 0x68, 0x61, 0x69, 0x21,
 154                         },
 155                 },
 156                 {
 157                         name: "returns io.EOF when all bytes read",
 158                         fields: fields{
 159                                 ID:         [2]byte{0x00, 0x62},
 160                                 FieldSize:  [2]byte{0x00, 0x03},
 161                                 Data:       []byte("hai!"),
 162                                 readOffset: 8,
 163                         },
 164                         args: args{
 165                                 p: make([]byte, 512),
 166                         },
 167                         want:      0,
 168                         wantErr:   assert.Error,
 169                         wantBytes: []byte{},
 170                 },
 171         }
 172         for _, tt := range tests {
 173                 t.Run(tt.name, func(t *testing.T) {
 174                         f := &Field{
 175                                 ID:         tt.fields.ID,
 176                                 FieldSize:  tt.fields.FieldSize,
 177                                 Data:       tt.fields.Data,
 178                                 readOffset: tt.fields.readOffset,
 179                         }
 180                         got, err := f.Read(tt.args.p)
 181                         if !tt.wantErr(t, err, fmt.Sprintf("Read(%v)", tt.args.p)) {
 182                                 return
 183                         }
 184                         assert.Equalf(t, tt.want, got, "Read(%v)", tt.args.p)
 185                         assert.Equalf(t, tt.wantBytes, tt.args.p[:got], "Read(%v)", tt.args.p)
 186                 })
 187         }
 188 }