github.com/cloudreve/Cloudreve/v3@v3.0.0-20240224133659-3edb00a6484c/pkg/filesystem/driver/onedrive/handler_test.go (about) 1 package onedrive 2 3 import ( 4 "context" 5 "fmt" 6 "github.com/cloudreve/Cloudreve/v3/pkg/mq" 7 "github.com/cloudreve/Cloudreve/v3/pkg/serializer" 8 "github.com/jinzhu/gorm" 9 "io" 10 "io/ioutil" 11 "net/http" 12 "strings" 13 "testing" 14 "time" 15 16 model "github.com/cloudreve/Cloudreve/v3/models" 17 "github.com/cloudreve/Cloudreve/v3/pkg/cache" 18 "github.com/cloudreve/Cloudreve/v3/pkg/filesystem/fsctx" 19 "github.com/cloudreve/Cloudreve/v3/pkg/request" 20 "github.com/stretchr/testify/assert" 21 testMock "github.com/stretchr/testify/mock" 22 ) 23 24 func TestDriver_Token(t *testing.T) { 25 asserts := assert.New(t) 26 h, _ := NewDriver(&model.Policy{ 27 AccessKey: "ak", 28 SecretKey: "sk", 29 BucketName: "test", 30 Server: "test.com", 31 }) 32 handler := h.(Driver) 33 34 // 分片上传 失败 35 { 36 cache.Set("setting_siteURL", "http://test.cloudreve.org", 0) 37 handler.Client, _ = NewClient(&model.Policy{}) 38 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 39 clientMock := ClientMock{} 40 clientMock.On( 41 "Request", 42 "POST", 43 testMock.Anything, 44 testMock.Anything, 45 testMock.Anything, 46 ).Return(&request.Response{ 47 Err: nil, 48 Response: &http.Response{ 49 StatusCode: 400, 50 Body: ioutil.NopCloser(strings.NewReader(`{"uploadUrl":"123321"}`)), 51 }, 52 }) 53 handler.Client.Request = clientMock 54 res, err := handler.Token(context.Background(), 10, &serializer.UploadSession{}, &fsctx.FileStream{}) 55 asserts.Error(err) 56 asserts.Nil(res) 57 } 58 59 // 分片上传 成功 60 { 61 cache.Set("setting_siteURL", "http://test.cloudreve.org", 0) 62 cache.Set("setting_onedrive_monitor_timeout", "600", 0) 63 cache.Set("setting_onedrive_callback_check", "20", 0) 64 handler.Client, _ = NewClient(&model.Policy{}) 65 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 66 handler.Client.Credential.AccessToken = "1" 67 clientMock := ClientMock{} 68 clientMock.On( 69 "Request", 70 "POST", 71 testMock.Anything, 72 testMock.Anything, 73 testMock.Anything, 74 ).Return(&request.Response{ 75 Err: nil, 76 Response: &http.Response{ 77 StatusCode: 200, 78 Body: ioutil.NopCloser(strings.NewReader(`{"uploadUrl":"123321"}`)), 79 }, 80 }) 81 handler.Client.Request = clientMock 82 go func() { 83 time.Sleep(time.Duration(1) * time.Second) 84 mq.GlobalMQ.Publish("TestDriver_Token", mq.Message{}) 85 }() 86 res, err := handler.Token(context.Background(), 10, &serializer.UploadSession{Key: "TestDriver_Token"}, &fsctx.FileStream{}) 87 asserts.NoError(err) 88 asserts.Equal("123321", res.UploadURLs[0]) 89 } 90 } 91 92 func TestDriver_Source(t *testing.T) { 93 asserts := assert.New(t) 94 handler := Driver{ 95 Policy: &model.Policy{ 96 AccessKey: "ak", 97 SecretKey: "sk", 98 BucketName: "test", 99 Server: "test.com", 100 }, 101 } 102 handler.Client, _ = NewClient(&model.Policy{}) 103 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 104 cache.Set("setting_onedrive_source_timeout", "1800", 0) 105 106 // 失败 107 { 108 res, err := handler.Source(context.Background(), "123.jpg", 1, true, 0) 109 asserts.Error(err) 110 asserts.Empty(res) 111 } 112 113 // 命中缓存 成功 114 { 115 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 116 handler.Client.Credential.AccessToken = "1" 117 cache.Set("onedrive_source_0_123.jpg", "res", 1) 118 res, err := handler.Source(context.Background(), "123.jpg", 0, true, 0) 119 cache.Deletes([]string{"0_123.jpg"}, "onedrive_source_") 120 asserts.NoError(err) 121 asserts.Equal("res", res) 122 } 123 124 // 命中缓存 上下文存在文件 成功 125 { 126 file := model.File{} 127 file.ID = 1 128 file.UpdatedAt = time.Now() 129 ctx := context.WithValue(context.Background(), fsctx.FileModelCtx, file) 130 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 131 handler.Client.Credential.AccessToken = "1" 132 cache.Set(fmt.Sprintf("onedrive_source_file_%d_1", file.UpdatedAt.Unix()), "res", 0) 133 res, err := handler.Source(ctx, "123.jpg", 1, true, 0) 134 cache.Deletes([]string{"0_123.jpg"}, "onedrive_source_") 135 asserts.NoError(err) 136 asserts.Equal("res", res) 137 } 138 139 // 成功 140 { 141 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 142 clientMock := ClientMock{} 143 clientMock.On( 144 "Request", 145 "GET", 146 testMock.Anything, 147 testMock.Anything, 148 testMock.Anything, 149 ).Return(&request.Response{ 150 Err: nil, 151 Response: &http.Response{ 152 StatusCode: 200, 153 Body: ioutil.NopCloser(strings.NewReader(`{"@microsoft.graph.downloadUrl":"123321"}`)), 154 }, 155 }) 156 handler.Client.Request = clientMock 157 handler.Client.Credential.AccessToken = "1" 158 res, err := handler.Source(context.Background(), "123.jpg", 1, true, 0) 159 asserts.NoError(err) 160 asserts.Equal("123321", res) 161 } 162 } 163 164 func TestDriver_List(t *testing.T) { 165 asserts := assert.New(t) 166 handler := Driver{ 167 Policy: &model.Policy{ 168 AccessKey: "ak", 169 SecretKey: "sk", 170 BucketName: "test", 171 Server: "test.com", 172 }, 173 } 174 handler.Client, _ = NewClient(&model.Policy{}) 175 handler.Client.Credential.AccessToken = "AccessToken" 176 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 177 178 // 非递归 179 { 180 clientMock := ClientMock{} 181 clientMock.On( 182 "Request", 183 "GET", 184 testMock.Anything, 185 testMock.Anything, 186 testMock.Anything, 187 ).Return(&request.Response{ 188 Err: nil, 189 Response: &http.Response{ 190 StatusCode: 200, 191 Body: ioutil.NopCloser(strings.NewReader(`{"value":[{}]}`)), 192 }, 193 }) 194 handler.Client.Request = clientMock 195 res, err := handler.List(context.Background(), "/", false) 196 asserts.NoError(err) 197 asserts.Len(res, 1) 198 } 199 200 // 递归一次 201 { 202 clientMock := ClientMock{} 203 clientMock.On( 204 "Request", 205 "GET", 206 "me/drive/root/children?$top=999999999", 207 testMock.Anything, 208 testMock.Anything, 209 ).Return(&request.Response{ 210 Err: nil, 211 Response: &http.Response{ 212 StatusCode: 200, 213 Body: ioutil.NopCloser(strings.NewReader(`{"value":[{"name":"1","folder":{}}]}`)), 214 }, 215 }) 216 clientMock.On( 217 "Request", 218 "GET", 219 "me/drive/root:/1:/children?$top=999999999", 220 testMock.Anything, 221 testMock.Anything, 222 ).Return(&request.Response{ 223 Err: nil, 224 Response: &http.Response{ 225 StatusCode: 200, 226 Body: ioutil.NopCloser(strings.NewReader(`{"value":[{"name":"2"}]}`)), 227 }, 228 }) 229 handler.Client.Request = clientMock 230 res, err := handler.List(context.Background(), "/", true) 231 asserts.NoError(err) 232 asserts.Len(res, 2) 233 } 234 } 235 236 func TestDriver_Thumb(t *testing.T) { 237 asserts := assert.New(t) 238 handler := Driver{ 239 Policy: &model.Policy{ 240 AccessKey: "ak", 241 SecretKey: "sk", 242 BucketName: "test", 243 Server: "test.com", 244 }, 245 } 246 handler.Client, _ = NewClient(&model.Policy{}) 247 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 248 file := &model.File{PicInfo: "1,1", Model: gorm.Model{ID: 1}} 249 250 // 失败 251 { 252 ctx := context.WithValue(context.Background(), fsctx.ThumbSizeCtx, [2]uint{10, 20}) 253 res, err := handler.Thumb(ctx, file) 254 asserts.Error(err) 255 asserts.Empty(res.URL) 256 } 257 258 // 上下文错误 259 { 260 _, err := handler.Thumb(context.Background(), file) 261 asserts.Error(err) 262 } 263 } 264 265 func TestDriver_Delete(t *testing.T) { 266 asserts := assert.New(t) 267 handler := Driver{ 268 Policy: &model.Policy{ 269 AccessKey: "ak", 270 SecretKey: "sk", 271 BucketName: "test", 272 Server: "test.com", 273 }, 274 } 275 handler.Client, _ = NewClient(&model.Policy{}) 276 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 277 278 // 失败 279 { 280 _, err := handler.Delete(context.Background(), []string{"1"}) 281 asserts.Error(err) 282 } 283 284 } 285 286 func TestDriver_Put(t *testing.T) { 287 asserts := assert.New(t) 288 handler := Driver{ 289 Policy: &model.Policy{ 290 AccessKey: "ak", 291 SecretKey: "sk", 292 BucketName: "test", 293 Server: "test.com", 294 }, 295 } 296 handler.Client, _ = NewClient(&model.Policy{}) 297 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 298 299 // 失败 300 { 301 err := handler.Put(context.Background(), &fsctx.FileStream{}) 302 asserts.Error(err) 303 } 304 } 305 306 func TestDriver_Get(t *testing.T) { 307 asserts := assert.New(t) 308 handler := Driver{ 309 Policy: &model.Policy{ 310 AccessKey: "ak", 311 SecretKey: "sk", 312 BucketName: "test", 313 Server: "test.com", 314 }, 315 } 316 handler.Client, _ = NewClient(&model.Policy{}) 317 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 318 319 // 无法获取source 320 { 321 res, err := handler.Get(context.Background(), "123.txt") 322 asserts.Error(err) 323 asserts.Nil(res) 324 } 325 326 // 成功 327 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 328 clientMock := ClientMock{} 329 clientMock.On( 330 "Request", 331 "GET", 332 testMock.Anything, 333 testMock.Anything, 334 testMock.Anything, 335 ).Return(&request.Response{ 336 Err: nil, 337 Response: &http.Response{ 338 StatusCode: 200, 339 Body: ioutil.NopCloser(strings.NewReader(`{"@microsoft.graph.downloadUrl":"123321"}`)), 340 }, 341 }) 342 handler.Client.Request = clientMock 343 handler.Client.Credential.AccessToken = "1" 344 345 driverClientMock := ClientMock{} 346 driverClientMock.On( 347 "Request", 348 "GET", 349 testMock.Anything, 350 testMock.Anything, 351 testMock.Anything, 352 ).Return(&request.Response{ 353 Err: nil, 354 Response: &http.Response{ 355 StatusCode: 200, 356 Body: ioutil.NopCloser(strings.NewReader(`123`)), 357 }, 358 }) 359 handler.HTTPClient = driverClientMock 360 res, err := handler.Get(context.Background(), "123.txt") 361 clientMock.AssertExpectations(t) 362 asserts.NoError(err) 363 _, err = res.Seek(0, io.SeekEnd) 364 asserts.NoError(err) 365 content, err := ioutil.ReadAll(res) 366 asserts.NoError(err) 367 asserts.Equal("123", string(content)) 368 } 369 370 func TestDriver_replaceSourceHost(t *testing.T) { 371 tests := []struct { 372 name string 373 origin string 374 cdn string 375 want string 376 wantErr bool 377 }{ 378 {"TestNoReplace", "http://1dr.ms/download.aspx?123456", "", "http://1dr.ms/download.aspx?123456", false}, 379 {"TestReplaceCorrect", "http://1dr.ms/download.aspx?123456", "https://test.com:8080", "https://test.com:8080/download.aspx?123456", false}, 380 {"TestCdnFormatError", "http://1dr.ms/download.aspx?123456", string([]byte{0x7f}), "", true}, 381 {"TestSrcFormatError", string([]byte{0x7f}), "https://test.com:8080", "", true}, 382 } 383 for _, tt := range tests { 384 t.Run(tt.name, func(t *testing.T) { 385 policy := &model.Policy{} 386 policy.OptionsSerialized.OdProxy = tt.cdn 387 handler := Driver{ 388 Policy: policy, 389 } 390 got, err := handler.replaceSourceHost(tt.origin) 391 if (err != nil) != tt.wantErr { 392 t.Errorf("replaceSourceHost() error = %v, wantErr %v", err, tt.wantErr) 393 return 394 } 395 if got != tt.want { 396 t.Errorf("replaceSourceHost() got = %v, want %v", got, tt.want) 397 } 398 }) 399 } 400 } 401 402 func TestDriver_CancelToken(t *testing.T) { 403 asserts := assert.New(t) 404 handler := Driver{ 405 Policy: &model.Policy{ 406 AccessKey: "ak", 407 SecretKey: "sk", 408 BucketName: "test", 409 Server: "test.com", 410 }, 411 } 412 handler.Client, _ = NewClient(&model.Policy{}) 413 handler.Client.Credential.ExpiresIn = time.Now().Add(time.Duration(100) * time.Hour).Unix() 414 415 // 失败 416 { 417 err := handler.CancelToken(context.Background(), &serializer.UploadSession{}) 418 asserts.Error(err) 419 } 420 }