Refactoring, cleanup, test backfilling

[rbdr/mobius] / hotline / transaction_test.go

diff --git a/hotline/transaction_test.go b/hotline/transaction_test.go
index cdb6f1e627a40ab0d4f0ec59459b15c8ae33d292..820b08c7f1fb6bf09cbd447bc49217a4582afb6a 100644 (file)
--- a/hotline/transaction_test.go
+++ b/hotline/transaction_test.go
@@ -301,15 +301,15 @@ func Test_transactionScanner(t *testing.T) {
 
 func TestTransaction_Read(t1 *testing.T) {
        type fields struct {
-               clientID   *[]byte
+               clientID   [2]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
                readOffset int
        }
@@ -329,9 +329,9 @@ func TestTransaction_Read(t1 *testing.T) {
                        fields: fields{
                                Flags:     0x00,
                                IsReply:   0x01,
-                               Type:      []byte{0, 0},
-                               ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                               ErrorCode: []byte{0, 0, 0, 0},
+                               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")),
                                },
@@ -348,9 +348,9 @@ func TestTransaction_Read(t1 *testing.T) {
                        fields: fields{
                                Flags:     0x00,
                                IsReply:   0x01,
-                               Type:      []byte{0, 0},
-                               ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                               ErrorCode: []byte{0, 0, 0, 0},
+                               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")),
                                },
@@ -368,9 +368,9 @@ func TestTransaction_Read(t1 *testing.T) {
                        fields: fields{
                                Flags:     0x00,
                                IsReply:   0x01,
-                               Type:      []byte{0, 0},
-                               ID:        []byte{0x9a, 0xcb, 0x04, 0x42},
-                               ErrorCode: []byte{0, 0, 0, 0},
+                               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")),
                                },
@@ -408,3 +408,80 @@ func TestTransaction_Read(t1 *testing.T) {
                })
        }
 }
+
+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)
+
+                       tranAssertEqual(t1, []Transaction{tt.wantTransaction}, []Transaction{*t})
+               })
+       }
+}