Minor cleanup of transfer

4 files changed, 105 insertions, 35 deletions

diff --git a/hotline/server.go b/hotline/server.go
index e51f673..0203dc9 100644
--- a/hotline/server.go
+++ b/hotline/server.go
@@ -622,7 +622,8 @@ func (s *Server) TransferFile(conn net.Conn) error {
 		return err
 	}
 
-	t, err := NewReadTransfer(buf)
+	var t transfer
+	_, err := t.Write(buf[:16])
 	if err != nil {
 		return err
 	}
@@ -726,7 +727,7 @@ func (s *Server) TransferFile(conn net.Conn) error {
 		}
 	case FolderDownload:
 		// Folder Download flow:
-		// 1. Get filePath from the Transfer
+		// 1. Get filePath from the transfer
 		// 2. Iterate over files
 		// 3. For each file:
 		// 	 Send file header to client
diff --git a/hotline/transaction_handlers.go b/hotline/transaction_handlers.go
index 0812f9a..ba90a56 100644
--- a/hotline/transaction_handlers.go
+++ b/hotline/transaction_handlers.go
@@ -1263,7 +1263,7 @@ func HandleDownloadFolder(cc *ClientConn, t *Transaction) (res []Transaction, er
 // Fields used in the request
 // 201	File name
 // 202	File path
-// 108	Transfer size	Total size of all items in the folder
+// 108	transfer size	Total size of all items in the folder
 // 220	Folder item count
 // 204	File transfer options	"Optional Currently set to 1" (TODO: ??)
 func HandleUploadFolder(cc *ClientConn, t *Transaction) (res []Transaction, err error) {
diff --git a/hotline/transfer.go b/hotline/transfer.go
index b8bec1d..fa431ce 100644
--- a/hotline/transfer.go
+++ b/hotline/transfer.go
@@ -6,45 +6,23 @@ import (
 	"errors"
 )
 
-type Transfer struct {
+type transfer struct {
 	Protocol        [4]byte // "HTXF" 0x48545846
 	ReferenceNumber [4]byte // Unique ID generated for the transfer
 	DataSize        [4]byte // File size
 	RSVD            [4]byte // Not implemented in Hotline Protocol
 }
 
-func NewReadTransfer(b []byte) (Transfer, error) {
-	r := bytes.NewReader(b)
-	var transfer Transfer
+var HTXF = [4]byte{0x48, 0x54, 0x58, 0x46} // (HTXF) is the only supported transfer protocol
 
-	if err := binary.Read(r, binary.BigEndian, &transfer); err != nil {
-		return transfer, err
+func (tf *transfer) Write(b []byte) (int, error) {
+	if err := binary.Read(bytes.NewReader(b), binary.BigEndian, tf); err != nil {
+		return 0, err
 	}
 
-	// 0x48545846 (HTXF) is the only supported transfer protocol
-	if transfer.Protocol != [4]byte{0x48, 0x54, 0x58, 0x46} {
-		return transfer, errors.New("invalid protocol")
+	if tf.Protocol != HTXF {
+		return 0, errors.New("invalid protocol")
 	}
 
-	return transfer, nil
+	return len(b), nil
 }
-
-//
-//type FolderTransfer struct {
-//	Protocol        [4]byte // "HTXF" 0x48545846
-//	ReferenceNumber [4]byte // Unique ID generated for the transfer
-//	DataSize        [4]byte // File size
-//	RSVD            [4]byte // Not implemented in Hotline Protocol
-//	Action          [2]byte // Next file action
-//}
-//
-//func ReadFolderTransfer(b []byte) (FolderTransfer, error) {
-//	r := bytes.NewReader(b)
-//	var decodedEvent FolderTransfer
-//
-//	if err := binary.Read(r, binary.BigEndian, &decodedEvent); err != nil {
-//		return decodedEvent, err
-//	}
-//
-//	return decodedEvent, nil
-//}
diff --git a/hotline/transfer_test.go b/hotline/transfer_test.go
index 52044b0..63e22c0 100644
--- a/hotline/transfer_test.go
+++ b/hotline/transfer_test.go
@@ -2,6 +2,97 @@ package hotline
 
 import "testing"
 
-func TestReadTransfer(t *testing.T) {
-
+func TestTransfer_Read(t *testing.T) {
+	type fields struct {
+		Protocol        [4]byte
+		ReferenceNumber [4]byte
+		DataSize        [4]byte
+		RSVD            [4]byte
+	}
+	type args struct {
+		b []byte
+	}
+	tests := []struct {
+		name    string
+		fields  fields
+		args    args
+		want    int
+		wantErr bool
+	}{
+		{
+			name: "when b is a valid transfer",
+			fields: fields{
+				Protocol:        [4]byte{},
+				ReferenceNumber: [4]byte{},
+				DataSize:        [4]byte{},
+				RSVD:            [4]byte{},
+			},
+			args: args{
+				b: []byte{
+					0x48, 0x54, 0x58, 0x46,
+					0x00, 0x00, 0x00, 0x01,
+					0x00, 0x00, 0x00, 0x02,
+					0x00, 0x00, 0x00, 0x00,
+				},
+			},
+			want:    16,
+			wantErr: false,
+		},
+		{
+			name: "when b contains invalid transfer protocol",
+			fields: fields{
+				Protocol:        [4]byte{},
+				ReferenceNumber: [4]byte{},
+				DataSize:        [4]byte{},
+				RSVD:            [4]byte{},
+			},
+			args: args{
+				b: []byte{
+					0x11, 0x11, 0x11, 0x11,
+					0x00, 0x00, 0x00, 0x01,
+					0x00, 0x00, 0x00, 0x02,
+					0x00, 0x00, 0x00, 0x00,
+				},
+			},
+			want:    0,
+			wantErr: true,
+		},
+		{
+			name: "when b does not contain expected len of bytes",
+			fields: fields{
+				Protocol:        [4]byte{},
+				ReferenceNumber: [4]byte{},
+				DataSize:        [4]byte{},
+				RSVD:            [4]byte{},
+			},
+			args: args{
+				b: []byte{
+					0x48, 0x54, 0x58, 0x46,
+					0x00, 0x00, 0x00, 0x01,
+					0x00, 0x00, 0x00, 0x02,
+					0x00, 0x00, 0x00,
+				},
+			},
+			want:    0,
+			wantErr: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tf := &transfer{
+				Protocol:        tt.fields.Protocol,
+				ReferenceNumber: tt.fields.ReferenceNumber,
+				DataSize:        tt.fields.DataSize,
+				RSVD:            tt.fields.RSVD,
+			}
+			got, err := tf.Write(tt.args.b)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Read() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if got != tt.want {
+				t.Errorf("Read() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
 }