Adopt more fixed size array types for struct fields

[rbdr/mobius] / hotline / transaction_test.go

diff --git a/hotline/transaction_test.go b/hotline/transaction_test.go
index 4b4f183a52b02b2939811d28d2a85ac7fce9a5b2..b5ee9901b524c853909090a4a8dbedb3b742b775 100644 (file)
--- a/hotline/transaction_test.go
+++ b/hotline/transaction_test.go
@@ -22,23 +22,23 @@ func TestReadFields(t *testing.T) {
                        args: args{
                                paramCount: []byte{0x00, 0x02},
                                buf: []byte{
                        args: args{
                                paramCount: []byte{0x00, 0x02},
                                buf: []byte{

-                                       0x00, 0x65, // ID: fieldData
+                                       0x00, 0x65, // ID: FieldData

                                        0x00, 0x04, // Size: 2 bytes
                                        0x01, 0x02, 0x03, 0x04, // Data
                                        0x00, 0x04, // Size: 2 bytes
                                        0x01, 0x02, 0x03, 0x04, // Data

-                                       0x00, 0x66, // ID: fieldUserName
+                                       0x00, 0x66, // ID: FieldUserName

                                        0x00, 0x02, // Size: 2 bytes
                                        0x00, 0x01, // Data
                                },
                        },
                        want: []Field{
                                {
                                        0x00, 0x02, // Size: 2 bytes
                                        0x00, 0x01, // Data
                                },
                        },
                        want: []Field{
                                {

-                                       ID:        []byte{0x00, 0x65},
-                                       FieldSize: []byte{0x00, 0x04},
+                                       ID:        [2]byte{0x00, 0x65},
+                                       FieldSize: [2]byte{0x00, 0x04},

                                        Data:      []byte{0x01, 0x02, 0x03, 0x04},
                                },
                                {
                                        Data:      []byte{0x01, 0x02, 0x03, 0x04},
                                },
                                {

-                                       ID:        []byte{0x00, 0x66},
-                                       FieldSize: []byte{0x00, 0x02},
+                                       ID:        [2]byte{0x00, 0x66},
+                                       FieldSize: [2]byte{0x00, 0x02},

                                        Data:      []byte{0x00, 0x01},
                                },
                        },
                                        Data:      []byte{0x00, 0x01},
                                },
                        },


@@ -58,7 +58,7 @@ func TestReadFields(t *testing.T) {
                        args: args{
                                paramCount: []byte{0x00, 0x01},
                                buf: []byte{
                        args: args{
                                paramCount: []byte{0x00, 0x01},
                                buf: []byte{

-                                       0x00, 0x65, // ID: fieldData
+                                       0x00, 0x65, // ID: FieldData

                                        0x00, 0x04, // Size: 4 bytes
                                        0x01, 0x02, 0x03, // Data
                                },
                                        0x00, 0x04, // Size: 4 bytes
                                        0x01, 0x02, 0x03, // Data
                                },


@@ -71,10 +71,10 @@ func TestReadFields(t *testing.T) {
                        args: args{
                                paramCount: []byte{0x00, 0x01},
                                buf: []byte{
                        args: args{
                                paramCount: []byte{0x00, 0x01},
                                buf: []byte{

-                                       0x00, 0x65, // ID: fieldData
+                                       0x00, 0x65, // ID: FieldData

                                        0x00, 0x02, // Size: 2 bytes
                                        0x01, 0x02, // Data
                                        0x00, 0x02, // Size: 2 bytes
                                        0x01, 0x02, // Data

-                                       0x00, 0x65, // ID: fieldData
+                                       0x00, 0x65, // ID: FieldData

                                        0x00, 0x04, // Size: 4 bytes
                                        0x01, 0x02, 0x03, // Data
                                },
                                        0x00, 0x04, // Size: 4 bytes
                                        0x01, 0x02, 0x03, // Data
                                },


@@ -87,7 +87,7 @@ func TestReadFields(t *testing.T) {
                        args: args{
                                paramCount: []byte{0x00, 0x01},
                                buf: []byte{
                        args: args{
                                paramCount: []byte{0x00, 0x01},
                                buf: []byte{

-                                       0x00, 0x65, // ID: fieldData
+                                       0x00, 0x65, // ID: FieldData

                                        0x00, 0x02, // Size: 2 bytes
                                        0x01, 0x02, 0x03, // Data
                                },
                                        0x00, 0x02, // Size: 2 bytes
                                        0x01, 0x02, 0x03, // Data
                                },


@@ -163,10 +163,10 @@ func Test_transactionScanner(t *testing.T) {
                                        00, 00, 00, 0x10,
                                        00, 00, 00, 0x10,
                                        00, 02,
                                        00, 00, 00, 0x10,
                                        00, 00, 00, 0x10,
                                        00, 02,

-                                       00, 0x6c, // 108 - fieldTransferSize
+                                       00, 0x6c, // 108 - FieldTransferSize

                                        00, 02,
                                        0x63, 0x3b,
                                        00, 02,
                                        0x63, 0x3b,

-                                       00, 0x6b, // 107 = fieldRefNum
+                                       00, 0x6b, // 107 = FieldRefNum

                                        00, 0x04,
                                        00, 0x02, 0x93, 0x47,
                                },
                                        00, 0x04,
                                        00, 0x02, 0x93, 0x47,
                                },


@@ -182,10 +182,10 @@ func Test_transactionScanner(t *testing.T) {
                                00, 00, 00, 0x10,
                                00, 00, 00, 0x10,
                                00, 02,
                                00, 00, 00, 0x10,
                                00, 00, 00, 0x10,
                                00, 02,

-                               00, 0x6c, // 108 - fieldTransferSize
+                               00, 0x6c, // 108 - FieldTransferSize

                                00, 02,
                                0x63, 0x3b,
                                00, 02,
                                0x63, 0x3b,

-                               00, 0x6b, // 107 = fieldRefNum
+                               00, 0x6b, // 107 = FieldRefNum

                                00, 0x04,
                                00, 0x02, 0x93, 0x47,
                        },
                                00, 0x04,
                                00, 0x02, 0x93, 0x47,
                        },


@@ -203,10 +203,10 @@ func Test_transactionScanner(t *testing.T) {
                                        00, 00, 00, 0x10,
                                        00, 00, 00, 0x10,
                                        00, 02,
                                        00, 00, 00, 0x10,
                                        00, 00, 00, 0x10,
                                        00, 02,

-                                       00, 0x6c, // 108 - fieldTransferSize
+                                       00, 0x6c, // 108 - FieldTransferSize

                                        00, 02,
                                        0x63, 0x3b,
                                        00, 02,
                                        0x63, 0x3b,

-                                       00, 0x6b, // 107 = fieldRefNum
+                                       00, 0x6b, // 107 = FieldRefNum

                                        00, 0x04,
                                        00, 0x02, 0x93, 0x47,
                                        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                                        00, 0x04,
                                        00, 0x02, 0x93, 0x47,
                                        1, 1, 1, 1, 1, 1, 1, 1, 1, 1,


@@ -223,10 +223,10 @@ func Test_transactionScanner(t *testing.T) {
                                00, 00, 00, 0x10,
                                00, 00, 00, 0x10,
                                00, 02,
                                00, 00, 00, 0x10,
                                00, 00, 00, 0x10,
                                00, 02,

-                               00, 0x6c, // 108 - fieldTransferSize
+                               00, 0x6c, // 108 - FieldTransferSize

                                00, 02,
                                0x63, 0x3b,
                                00, 02,
                                0x63, 0x3b,

-                               00, 0x6b, // 107 = fieldRefNum
+                               00, 0x6b, // 107 = FieldRefNum

                                00, 0x04,
                                00, 0x02, 0x93, 0x47,
                        },
                                00, 0x04,
                                00, 0x02, 0x93, 0x47,
                        },


@@ -244,10 +244,10 @@ func Test_transactionScanner(t *testing.T) {
                                        00, 00, 00, 0x10,
                                        00, 00, 00, 0x10,
                                        00, 02,
                                        00, 00, 00, 0x10,
                                        00, 00, 00, 0x10,
                                        00, 02,

-                                       00, 0x6c, // 108 - fieldTransferSize
+                                       00, 0x6c, // 108 - FieldTransferSize

                                        00, 02,
                                        0x63, 0x3b,
                                        00, 02,
                                        0x63, 0x3b,

-                                       00, 0x6b, // 107 = fieldRefNum
+                                       00, 0x6b, // 107 = FieldRefNum

                                        00, 0x04,
                                        00, 0x02, 0x93, 0x47,
                                        0,
                                        00, 0x04,
                                        00, 0x02, 0x93, 0x47,
                                        0,


@@ -258,10 +258,10 @@ func Test_transactionScanner(t *testing.T) {
                                        00, 00, 00, 0x10,
                                        00, 00, 00, 0x10,
                                        00, 02,
                                        00, 00, 00, 0x10,
                                        00, 00, 00, 0x10,
                                        00, 02,

-                                       00, 0x6c, // 108 - fieldTransferSize
+                                       00, 0x6c, // 108 - FieldTransferSize

                                        00, 02,
                                        0x63, 0x3b,
                                        00, 02,
                                        0x63, 0x3b,

-                                       00, 0x6b, // 107 = fieldRefNum
+                                       00, 0x6b, // 107 = FieldRefNum

                                        00, 0x04,
                                        00, 0x02, 0x93, 0x47,
                                },
                                        00, 0x04,
                                        00, 0x02, 0x93, 0x47,
                                },


@@ -277,10 +277,10 @@ func Test_transactionScanner(t *testing.T) {
                                00, 00, 00, 0x10,
                                00, 00, 00, 0x10,
                                00, 02,
                                00, 00, 00, 0x10,
                                00, 00, 00, 0x10,
                                00, 02,

-                               00, 0x6c, // 108 - fieldTransferSize
+                               00, 0x6c, // 108 - FieldTransferSize

                                00, 02,
                                0x63, 0x3b,
                                00, 02,
                                0x63, 0x3b,

-                               00, 0x6b, // 107 = fieldRefNum
+                               00, 0x6b, // 107 = FieldRefNum

                                00, 0x04,
                                00, 0x02, 0x93, 0x47,
                        },
                                00, 0x04,
                                00, 0x02, 0x93, 0x47,
                        },


@@ -299,58 +299,89 @@ func Test_transactionScanner(t *testing.T) {
        }
 }
 
        }
 }
 

-func TestTransaction_Write(t1 *testing.T) {
-       sampleTransaction := &Transaction{
-               Flags:      byte(0),
-               IsReply:    byte(0),
-               Type:       []byte{0x000, 0x93},
-               ID:         []byte{0x000, 0x00, 0x00, 0x01},
-               ErrorCode:  []byte{0x000, 0x00, 0x00, 0x00},
-               TotalSize:  []byte{0x000, 0x00, 0x00, 0x08},
-               DataSize:   []byte{0x000, 0x00, 0x00, 0x08},
-               ParamCount: []byte{0x00, 0x01},
-               Fields: []Field{
-                       {
-                               ID:        []byte{0x00, 0x01},
-                               FieldSize: []byte{0x00, 0x02},
-                               Data:      []byte{0xff, 0xff},
-                       },
-               },
-       }
-
+func TestTransaction_Read(t1 *testing.T) {

        type fields struct {
                clientID   *[]byte
                Flags      byte
                IsReply    byte
        type fields struct {
                clientID   *[]byte
                Flags      byte
                IsReply    byte

-               Type       []byte
-               ID         []byte
-               ErrorCode  []byte
-               TotalSize  []byte
-               DataSize   []byte
-               ParamCount []byte
+               Type       [2]byte
+               ID         [4]byte
+               ErrorCode  [4]byte
+               TotalSize  [4]byte
+               DataSize   [4]byte
+               ParamCount [2]byte

                Fields     []Field
                Fields     []Field

+               readOffset int

        }
        type args struct {
                p []byte
        }
        tests := []struct {
        }
        type args struct {
                p []byte
        }
        tests := []struct {

-               name    string
-               fields  fields
-               args    args
-               wantN   int
-               wantErr assert.ErrorAssertionFunc
+               name      string
+               fields    fields
+               args      args
+               want      int
+               wantErr   assert.ErrorAssertionFunc
+               wantBytes []byte

        }{
                {
        }{
                {

-                       name:   "when buf contains all bytes for a single transaction",
-                       fields: fields{},
+                       name: "returns transaction bytes",
+                       fields: fields{
+                               Flags:     0x00,
+                               IsReply:   0x01,
+                               Type:      [2]byte{0, 0},
+                               ID:        [4]byte{0x9a, 0xcb, 0x04, 0x42},
+                               ErrorCode: [4]byte{0, 0, 0, 0},
+                               Fields: []Field{
+                                       NewField(FieldData, []byte("TEST")),
+                               },
+                       },

                        args: args{
                        args: args{

-                               p: func() []byte {
-                                       b, _ := sampleTransaction.MarshalBinary()
-                                       return b
-                               }(),
+                               p: make([]byte, 1024),

                        },
                        },

-                       wantN:   28,
-                       wantErr: assert.NoError,
+                       want:      30,
+                       wantErr:   assert.NoError,
+                       wantBytes: []byte{0x0, 0x1, 0x0, 0x0, 0x9a, 0xcb, 0x4, 0x42, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xa, 0x0, 0x0, 0x0, 0xa, 0x0, 0x1, 0x0, 0x65, 0x0, 0x4, 0x54, 0x45, 0x53, 0x54},
+               },
+               {
+                       name: "returns transaction bytes from readOffset",
+                       fields: fields{
+                               Flags:     0x00,
+                               IsReply:   0x01,
+                               Type:      [2]byte{0, 0},
+                               ID:        [4]byte{0x9a, 0xcb, 0x04, 0x42},
+                               ErrorCode: [4]byte{0, 0, 0, 0},
+                               Fields: []Field{
+                                       NewField(FieldData, []byte("TEST")),
+                               },
+                               readOffset: 20,
+                       },
+                       args: args{
+                               p: make([]byte, 1024),
+                       },
+                       want:      10,
+                       wantErr:   assert.NoError,
+                       wantBytes: []byte{0x0, 0x1, 0x0, 0x65, 0x0, 0x4, 0x54, 0x45, 0x53, 0x54},
+               },
+               {
+                       name: "returns io.EOF when all bytes read",
+                       fields: fields{
+                               Flags:     0x00,
+                               IsReply:   0x01,
+                               Type:      [2]byte{0, 0},
+                               ID:        [4]byte{0x9a, 0xcb, 0x04, 0x42},
+                               ErrorCode: [4]byte{0, 0, 0, 0},
+                               Fields: []Field{
+                                       NewField(FieldData, []byte("TEST")),
+                               },
+                               readOffset: 30,
+                       },
+                       args: args{
+                               p: make([]byte, 1024),
+                       },
+                       want:      0,
+                       wantErr:   assert.Error,
+                       wantBytes: []byte{},

                },
        }
        for _, tt := range tests {
                },
        }
        for _, tt := range tests {


@@ -366,12 +397,14 @@ func TestTransaction_Write(t1 *testing.T) {
                                DataSize:   tt.fields.DataSize,
                                ParamCount: tt.fields.ParamCount,
                                Fields:     tt.fields.Fields,
                                DataSize:   tt.fields.DataSize,
                                ParamCount: tt.fields.ParamCount,
                                Fields:     tt.fields.Fields,

+                               readOffset: tt.fields.readOffset,

                        }
                        }

-                       gotN, err := t.Write(tt.args.p)
-                       if !tt.wantErr(t1, err, fmt.Sprintf("Write(%v)", tt.args.p)) {
+                       got, err := t.Read(tt.args.p)
+                       if !tt.wantErr(t1, err, fmt.Sprintf("Read(%v)", tt.args.p)) {

                                return
                        }
                                return
                        }

-                       assert.Equalf(t1, tt.wantN, gotN, "Write(%v)", tt.args.p)
+                       assert.Equalf(t1, tt.want, got, "Read(%v)", tt.args.p)
+                       assert.Equalf(t1, tt.wantBytes, tt.args.p[:got], "Read(%v)", tt.args.p)

                })
        }
 }
                })
        }
 }