Extensive refactor, quality of life enhancements

[rbdr/mobius] / hotline / file_transfer_test.go

diff --git a/hotline/file_transfer_test.go b/hotline/file_transfer_test.go
index 213cb9aacaac12a4b54ad66a1857bf1af26c7a4f..b1236b650c7fb3513af13137f98163ede5598639 100644 (file)
--- a/hotline/file_transfer_test.go
+++ b/hotline/file_transfer_test.go
@@ -3,6 +3,8 @@ package hotline
 import (
        "encoding/binary"
        "github.com/stretchr/testify/assert"
+       "io"
+       "reflect"
        "testing"
 )
 
@@ -11,7 +13,7 @@ func TestFileTransfer_String(t *testing.T) {
                FileName         []byte
                FilePath         []byte
                refNum           [4]byte
-               Type             int
+               Type             FileTransferType
                TransferSize     []byte
                FolderItemCount  []byte
                fileResumeData   *FileResumeData
@@ -74,12 +76,12 @@ func TestFileTransfer_String(t *testing.T) {
                        ft := &FileTransfer{
                                FileName:         tt.fields.FileName,
                                FilePath:         tt.fields.FilePath,
-                               refNum:           tt.fields.refNum,
+                               RefNum:           tt.fields.refNum,
                                Type:             tt.fields.Type,
                                TransferSize:     tt.fields.TransferSize,
                                FolderItemCount:  tt.fields.FolderItemCount,
-                               fileResumeData:   tt.fields.fileResumeData,
-                               options:          tt.fields.options,
+                               FileResumeData:   tt.fields.fileResumeData,
+                               Options:          tt.fields.options,
                                bytesSentCounter: tt.fields.bytesSentCounter,
                                ClientConn:       tt.fields.ClientConn,
                        }
@@ -87,3 +89,90 @@ func TestFileTransfer_String(t *testing.T) {
                })
        }
 }
+
+func TestNewFileHeader(t *testing.T) {
+       type args struct {
+               fileName string
+               isDir    bool
+       }
+       tests := []struct {
+               name string
+               args args
+               want FileHeader
+       }{
+               {
+                       name: "when path is file",
+                       args: args{
+                               fileName: "foo",
+                               isDir:    false,
+                       },
+                       want: FileHeader{
+                               Size:     [2]byte{0x00, 0x0a},
+                               Type:     [2]byte{0x00, 0x00},
+                               FilePath: EncodeFilePath("foo"),
+                       },
+               },
+               {
+                       name: "when path is dir",
+                       args: args{
+                               fileName: "foo",
+                               isDir:    true,
+                       },
+                       want: FileHeader{
+                               Size:     [2]byte{0x00, 0x0a},
+                               Type:     [2]byte{0x00, 0x01},
+                               FilePath: EncodeFilePath("foo"),
+                       },
+               },
+       }
+       for _, tt := range tests {
+               t.Run(tt.name, func(t *testing.T) {
+                       if got := NewFileHeader(tt.args.fileName, tt.args.isDir); !reflect.DeepEqual(got, tt.want) {
+                               t.Errorf("NewFileHeader() = %v, want %v", got, tt.want)
+                       }
+               })
+       }
+}
+
+func TestFileHeader_Payload(t *testing.T) {
+       type fields struct {
+               Size     [2]byte
+               Type     [2]byte
+               FilePath []byte
+       }
+       tests := []struct {
+               name   string
+               fields fields
+               want   []byte
+       }{
+               {
+                       name: "has expected payload bytes",
+                       fields: fields{
+                               Size:     [2]byte{0x00, 0x0a},
+                               Type:     [2]byte{0x00, 0x00},
+                               FilePath: EncodeFilePath("foo"),
+                       },
+                       want: []byte{
+                               0x00, 0x0a, // total size
+                               0x00, 0x00, // type
+                               0x00, 0x01, // path item count
+                               0x00, 0x00, // path separator
+                               0x03,             // pathName len
+                               0x66, 0x6f, 0x6f, // "foo"
+                       },
+               },
+       }
+       for _, tt := range tests {
+               t.Run(tt.name, func(t *testing.T) {
+                       fh := &FileHeader{
+                               Size:     tt.fields.Size,
+                               Type:     tt.fields.Type,
+                               FilePath: tt.fields.FilePath,
+                       }
+                       got, _ := io.ReadAll(fh)
+                       if !reflect.DeepEqual(got, tt.want) {
+                               t.Errorf("Read() = %v, want %v", got, tt.want)
+                       }
+               })
+       }
+}