patch: v0.6.1

[rbdr/mobius] / hotline / file_path_test.go

diff --git a/hotline/file_path_test.go b/hotline/file_path_test.go
index a8ab2ce29c3bdee557f54389e2f985958ed2ad8c..f25941ebc55bc27ccd7a0e4eb01185a8b0a5deff 100644 (file)
--- a/hotline/file_path_test.go
+++ b/hotline/file_path_test.go
@@ -6,10 +6,6 @@ import (
 )
 
 func TestFilePath_UnmarshalBinary(t *testing.T) {
 )
 
 func TestFilePath_UnmarshalBinary(t *testing.T) {

-       type fields struct {
-               ItemCount []byte
-               Items     []FilePathItem
-       }

        type args struct {
                b []byte
        }
        type args struct {
                b []byte
        }


@@ -45,6 +41,17 @@ func TestFilePath_UnmarshalBinary(t *testing.T) {
                        },
                        wantErr: false,
                },
                        },
                        wantErr: false,
                },

+               {
+                       name: "handles empty data payload",
+                       args: args{b: []byte{
+                               0x00, 0x00,
+                       }},
+                       want: FilePath{
+                               ItemCount: [2]byte{0x00, 0x00},
+                               Items:     []FilePathItem(nil),
+                       },
+                       wantErr: false,
+               },

        }
        for _, tt := range tests {
                t.Run(tt.name, func(t *testing.T) {
        }
        for _, tt := range tests {
                t.Run(tt.name, func(t *testing.T) {


@@ -58,3 +65,102 @@ func TestFilePath_UnmarshalBinary(t *testing.T) {
                })
        }
 }
                })
        }
 }

+
+func Test_readPath(t *testing.T) {
+       type args struct {
+               fileRoot string
+               filePath []byte
+               fileName []byte
+       }
+       tests := []struct {
+               name    string
+               args    args
+               want    string
+               wantErr bool
+       }{
+               {
+                       name: "when filePath is invalid",
+                       args: args{
+                               fileRoot: "/usr/local/var/mobius/Files",
+                               filePath: []byte{
+                                       0x61,
+                               },
+                               fileName: []byte{
+                                       0x61, 0x61, 0x61,
+                               },
+                       },
+                       want:    "",
+                       wantErr: true,
+               },
+               {
+                       name: "when filePath is nil",
+                       args: args{
+                               fileRoot: "/usr/local/var/mobius/Files",
+                               filePath: nil,
+                               fileName: []byte("foo"),
+                       },
+                       want: "/usr/local/var/mobius/Files/foo",
+               },
+               {
+                       name: "when fileName contains .. ",
+                       args: args{
+                               fileRoot: "/usr/local/var/mobius/Files",
+                               filePath: nil,
+                               fileName: []byte("../../../foo"),
+                       },
+                       want: "/usr/local/var/mobius/Files/foo",
+               },
+               {
+                       name: "when filePath contains .. ",
+                       args: args{
+                               fileRoot: "/usr/local/var/mobius/Files",
+                               filePath: []byte{
+                                       0x00, 0x02,
+                                       0x00, 0x00,
+                                       0x03,
+                                       0x2e, 0x2e, 0x2f,
+                                       0x00, 0x00,
+                                       0x08,
+                                       0x41, 0x20, 0x53, 0x75, 0x62, 0x44, 0x69, 0x72,
+                               },
+                               fileName: []byte("foo"),
+                       },
+                       want: "/usr/local/var/mobius/Files/A SubDir/foo",
+               },
+               {
+                       name: "when a filePath entry contains .. ",
+                       args: args{
+                               fileRoot: "/usr/local/var/mobius/Files",
+                               filePath: []byte{
+                                       0x00, 0x01,
+                                       0x00, 0x00,
+                                       0x0b,
+                                       0x2e, 0x2e, 0x2f, 0x41, 0x20, 0x53, 0x75, 0x62, 0x44, 0x69, 0x72,
+                               },
+                               fileName: []byte("foo"),
+                       },
+                       want: "/usr/local/var/mobius/Files/A SubDir/foo",
+               },
+               {
+                       name: "when filePath and fileName are nil",
+                       args: args{
+                               fileRoot: "/usr/local/var/mobius/Files",
+                               filePath: nil,
+                               fileName: nil,
+                       },
+                       want: "/usr/local/var/mobius/Files",
+               },
+       }
+       for _, tt := range tests {
+               t.Run(tt.name, func(t *testing.T) {
+                       got, err := readPath(tt.args.fileRoot, tt.args.filePath, tt.args.fileName)
+                       if (err != nil) != tt.wantErr {
+                               t.Errorf("readPath() error = %v, wantErr %v", err, tt.wantErr)
+                               return
+                       }
+                       if got != tt.want {
+                               t.Errorf("readPath() got = %v, want %v", got, tt.want)
+                       }
+               })
+       }
+}