X-Git-Url: https://git.r.bdr.sh/rbdr/mobius/blobdiff_plain/d005ef04cfaa26943e6dd33807d741577ffb232a..9360423f0aae6d7ce63cc9a4b20c031a58e06820:/hotline/transaction_test.go?ds=sidebyside

diff --git a/hotline/transaction_test.go b/hotline/transaction_test.go
index 65f428a..97d865d 100644
--- a/hotline/transaction_test.go
+++ b/hotline/transaction_test.go
@@ -6,111 +6,6 @@ import (
 	"testing"
 )
 
-func TestReadFields(t *testing.T) {
-	type args struct {
-		paramCount []byte
-		buf        []byte
-	}
-	tests := []struct {
-		name    string
-		args    args
-		want    []Field
-		wantErr bool
-	}{
-		{
-			name: "valid field data",
-			args: args{
-				paramCount: []byte{0x00, 0x02},
-				buf: []byte{
-					0x00, 0x65, // ID: FieldData
-					0x00, 0x04, // Size: 2 bytes
-					0x01, 0x02, 0x03, 0x04, // Data
-					0x00, 0x66, // ID: FieldUserName
-					0x00, 0x02, // Size: 2 bytes
-					0x00, 0x01, // Data
-				},
-			},
-			want: []Field{
-				{
-					ID:        []byte{0x00, 0x65},
-					FieldSize: []byte{0x00, 0x04},
-					Data:      []byte{0x01, 0x02, 0x03, 0x04},
-				},
-				{
-					ID:        []byte{0x00, 0x66},
-					FieldSize: []byte{0x00, 0x02},
-					Data:      []byte{0x00, 0x01},
-				},
-			},
-			wantErr: false,
-		},
-		{
-			name: "empty bytes",
-			args: args{
-				paramCount: []byte{0x00, 0x00},
-				buf:        []byte{},
-			},
-			want:    []Field(nil),
-			wantErr: false,
-		},
-		{
-			name: "when field size does not match data length",
-			args: args{
-				paramCount: []byte{0x00, 0x01},
-				buf: []byte{
-					0x00, 0x65, // ID: FieldData
-					0x00, 0x04, // Size: 4 bytes
-					0x01, 0x02, 0x03, // Data
-				},
-			},
-			want:    []Field{},
-			wantErr: true,
-		},
-		{
-			name: "when field size of second field does not match data length",
-			args: args{
-				paramCount: []byte{0x00, 0x01},
-				buf: []byte{
-					0x00, 0x65, // ID: FieldData
-					0x00, 0x02, // Size: 2 bytes
-					0x01, 0x02, // Data
-					0x00, 0x65, // ID: FieldData
-					0x00, 0x04, // Size: 4 bytes
-					0x01, 0x02, 0x03, // Data
-				},
-			},
-			want:    []Field{},
-			wantErr: true,
-		},
-		{
-			name: "when field data has extra bytes",
-			args: args{
-				paramCount: []byte{0x00, 0x01},
-				buf: []byte{
-					0x00, 0x65, // ID: FieldData
-					0x00, 0x02, // Size: 2 bytes
-					0x01, 0x02, 0x03, // Data
-				},
-			},
-			want:    []Field{},
-			wantErr: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := ReadFields(tt.args.paramCount, tt.args.buf)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ReadFields() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-
-			if !assert.Equal(t, tt.want, got) {
-				t.Errorf("ReadFields() got = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
 func Test_transactionScanner(t *testing.T) {
 	type args struct {
 		data []byte
@@ -299,64 +194,95 @@ 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
+		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
 	}
 	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{
-				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 {
 		t1.Run(tt.name, func(t1 *testing.T) {
 			t := &Transaction{
-				clientID:   tt.fields.clientID,
+				ClientID:   tt.fields.clientID,
 				Flags:      tt.fields.Flags,
 				IsReply:    tt.fields.IsReply,
 				Type:       tt.fields.Type,
@@ -366,12 +292,91 @@ func TestTransaction_Write(t1 *testing.T) {
 				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{
+					{
+						Type:      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})
 		})
 	}
 }