Fix Windows compatibility for -init flag

[rbdr/mobius] / hotline / transaction_test.go

diff --git a/hotline/transaction_test.go b/hotline/transaction_test.go
index 4b4f183a52b02b2939811d28d2a85ac7fce9a5b2..820b08c7f1fb6bf09cbd447bc49217a4582afb6a 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 {
        type fields struct {

-               clientID   *[]byte
+               clientID   [2]byte

                Flags      byte
                IsReply    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,91 @@ 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,

                        }
                        }

+                       got, err := t.Read(tt.args.p)
+                       if !tt.wantErr(t1, err, fmt.Sprintf("Read(%v)", tt.args.p)) {
+                               return
+                       }
+                       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)
+               })
+       }
+}
+
+func TestTransaction_Write(t1 *testing.T) {
+       type args struct {
+               p []byte
+       }
+       tests := []struct {
+               name            string
+               args            args
+               wantN           int
+               wantErr         assert.ErrorAssertionFunc
+               wantTransaction Transaction
+       }{
+               {
+                       name: "returns error if arg p is too small",
+                       args: args{p: []byte{
+                               0x00, 0x00,
+                       }},
+                       wantN:           0,
+                       wantErr:         assert.Error,
+                       wantTransaction: Transaction{},
+               },
+               //{
+               //      name: "returns error if param data is invalid",
+               //      args: args{p: []byte{
+               //              0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x15, 0x72,
+               //              0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+               //              0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x65,
+               //              0x00, 0x03, 0x68, 0x61, 0x69,
+               //      }},
+               //      wantN:           0,
+               //      wantErr:         assert.Error,
+               //      wantTransaction: Transaction{},
+               //},
+               {
+                       name: "writes bytes to transaction",
+                       args: args{p: []byte{
+                               0x00, 0x00, 0x00, 0x69, 0x00, 0x00, 0x15, 0x72,
+                               0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,
+                               0x00, 0x00, 0x00, 0x09, 0x00, 0x01, 0x00, 0x65,
+                               0x00, 0x03, 0x68, 0x61, 0x69,
+                       }},
+                       wantN:   29,
+                       wantErr: assert.NoError,
+                       wantTransaction: Transaction{
+                               Flags:      0,
+                               IsReply:    0,
+                               Type:       TranChatSend,
+                               ID:         [4]byte{},
+                               ErrorCode:  [4]byte{},
+                               TotalSize:  [4]byte{0, 0, 0, 9},
+                               DataSize:   [4]byte{0, 0, 0, 9},
+                               ParamCount: [2]byte{0, 1},
+                               Fields: []Field{
+                                       {
+                                               ID:        FieldData,
+                                               FieldSize: [2]byte{0, 3},
+                                               Data:      []byte("hai"),
+                                       },
+                               },
+                               clientID:   [2]byte{},
+                               readOffset: 0,
+                       },
+               },
+       }
+       for _, tt := range tests {
+               t1.Run(tt.name, func(t1 *testing.T) {
+                       t := &Transaction{}

                        gotN, err := t.Write(tt.args.p)
                        if !tt.wantErr(t1, err, fmt.Sprintf("Write(%v)", tt.args.p)) {
                                return
                        }
                        assert.Equalf(t1, tt.wantN, gotN, "Write(%v)", tt.args.p)
                        gotN, err := t.Write(tt.args.p)
                        if !tt.wantErr(t1, err, fmt.Sprintf("Write(%v)", tt.args.p)) {
                                return
                        }
                        assert.Equalf(t1, tt.wantN, gotN, "Write(%v)", tt.args.p)

+
+                       tranAssertEqual(t1, []Transaction{tt.wantTransaction}, []Transaction{*t})

                })
        }
 }
                })
        }
 }