github.com/cloudreve/Cloudreve/v3@v3.0.0-20240224133659-3edb00a6484c/models/policy_test.go (about)

     1  package model
     2  
     3  import (
     4  	"encoding/json"
     5  	"strconv"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/DATA-DOG/go-sqlmock"
    10  	"github.com/cloudreve/Cloudreve/v3/pkg/cache"
    11  	"github.com/jinzhu/gorm"
    12  	"github.com/stretchr/testify/assert"
    13  )
    14  
    15  func TestGetPolicyByID(t *testing.T) {
    16  	asserts := assert.New(t)
    17  
    18  	cache.Deletes([]string{"22", "23"}, "policy_")
    19  	// 缓存未命中
    20  	{
    21  		rows := sqlmock.NewRows([]string{"name", "type", "options"}).
    22  			AddRow("默认存储策略", "local", "{\"od_redirect\":\"123\"}")
    23  		mock.ExpectQuery("^SELECT(.+)").WillReturnRows(rows)
    24  		policy, err := GetPolicyByID(uint(22))
    25  		asserts.NoError(err)
    26  		asserts.NoError(mock.ExpectationsWereMet())
    27  		asserts.Equal("默认存储策略", policy.Name)
    28  		asserts.Equal("123", policy.OptionsSerialized.OauthRedirect)
    29  
    30  		rows = sqlmock.NewRows([]string{"name", "type", "options"})
    31  		mock.ExpectQuery("^SELECT(.+)").WillReturnRows(rows)
    32  		policy, err = GetPolicyByID(uint(23))
    33  		asserts.NoError(mock.ExpectationsWereMet())
    34  		asserts.Error(err)
    35  	}
    36  
    37  	// 命中
    38  	{
    39  		policy, err := GetPolicyByID(uint(22))
    40  		asserts.NoError(err)
    41  		asserts.Equal("默认存储策略", policy.Name)
    42  		asserts.Equal("123", policy.OptionsSerialized.OauthRedirect)
    43  
    44  	}
    45  
    46  }
    47  
    48  func TestPolicy_BeforeSave(t *testing.T) {
    49  	asserts := assert.New(t)
    50  
    51  	testPolicy := Policy{
    52  		OptionsSerialized: PolicyOption{
    53  			OauthRedirect: "123",
    54  		},
    55  	}
    56  	expected, _ := json.Marshal(testPolicy.OptionsSerialized)
    57  	err := testPolicy.BeforeSave()
    58  	asserts.NoError(err)
    59  	asserts.Equal(string(expected), testPolicy.Options)
    60  
    61  }
    62  
    63  func TestPolicy_GeneratePath(t *testing.T) {
    64  	asserts := assert.New(t)
    65  	testPolicy := Policy{}
    66  
    67  	testPolicy.DirNameRule = "{randomkey16}"
    68  	asserts.Len(testPolicy.GeneratePath(1, "/"), 16)
    69  
    70  	testPolicy.DirNameRule = "{randomkey8}"
    71  	asserts.Len(testPolicy.GeneratePath(1, "/"), 8)
    72  
    73  	testPolicy.DirNameRule = "{timestamp}"
    74  	asserts.Equal(testPolicy.GeneratePath(1, "/"), strconv.FormatInt(time.Now().Unix(), 10))
    75  
    76  	testPolicy.DirNameRule = "{uid}"
    77  	asserts.Equal(testPolicy.GeneratePath(1, "/"), strconv.Itoa(int(1)))
    78  
    79  	testPolicy.DirNameRule = "{datetime}"
    80  	asserts.Len(testPolicy.GeneratePath(1, "/"), 14)
    81  
    82  	testPolicy.DirNameRule = "{date}"
    83  	asserts.Len(testPolicy.GeneratePath(1, "/"), 8)
    84  
    85  	testPolicy.DirNameRule = "123{date}ss{datetime}"
    86  	asserts.Len(testPolicy.GeneratePath(1, "/"), 27)
    87  
    88  	testPolicy.DirNameRule = "/1/{path}/456"
    89  	asserts.Condition(func() (success bool) {
    90  		res := testPolicy.GeneratePath(1, "/23")
    91  		return res == "/1/23/456" || res == "\\1\\23\\456"
    92  	})
    93  
    94  }
    95  
    96  func TestPolicy_GenerateFileName(t *testing.T) {
    97  	asserts := assert.New(t)
    98  	// 重命名关闭
    99  	{
   100  		testPolicy := Policy{
   101  			AutoRename: false,
   102  		}
   103  		testPolicy.FileNameRule = "{randomkey16}"
   104  		asserts.Equal("123.txt", testPolicy.GenerateFileName(1, "123.txt"))
   105  
   106  		testPolicy.Type = "oss"
   107  		asserts.Equal("origin", testPolicy.GenerateFileName(1, "origin"))
   108  	}
   109  
   110  	// 重命名开启
   111  	{
   112  		testPolicy := Policy{
   113  			AutoRename: true,
   114  		}
   115  
   116  		testPolicy.FileNameRule = "{randomkey16}"
   117  		asserts.Len(testPolicy.GenerateFileName(1, "123.txt"), 16)
   118  
   119  		testPolicy.FileNameRule = "{randomkey8}"
   120  		asserts.Len(testPolicy.GenerateFileName(1, "123.txt"), 8)
   121  
   122  		testPolicy.FileNameRule = "{timestamp}"
   123  		asserts.Equal(testPolicy.GenerateFileName(1, "123.txt"), strconv.FormatInt(time.Now().Unix(), 10))
   124  
   125  		testPolicy.FileNameRule = "{uid}"
   126  		asserts.Equal(testPolicy.GenerateFileName(1, "123.txt"), strconv.Itoa(int(1)))
   127  
   128  		testPolicy.FileNameRule = "{datetime}"
   129  		asserts.Len(testPolicy.GenerateFileName(1, "123.txt"), 14)
   130  
   131  		testPolicy.FileNameRule = "{date}"
   132  		asserts.Len(testPolicy.GenerateFileName(1, "123.txt"), 8)
   133  
   134  		testPolicy.FileNameRule = "123{date}ss{datetime}"
   135  		asserts.Len(testPolicy.GenerateFileName(1, "123.txt"), 27)
   136  
   137  		testPolicy.FileNameRule = "{originname_without_ext}"
   138  		asserts.Len(testPolicy.GenerateFileName(1, "123.txt"), 3)
   139  
   140  		testPolicy.FileNameRule = "{originname_without_ext}_{randomkey8}{ext}"
   141  		asserts.Len(testPolicy.GenerateFileName(1, "123.txt"), 16)
   142  
   143  		// 支持{originname}的策略
   144  		testPolicy.Type = "local"
   145  		testPolicy.FileNameRule = "123{originname}"
   146  		asserts.Equal("123123.txt", testPolicy.GenerateFileName(1, "123.txt"))
   147  
   148  		testPolicy.Type = "qiniu"
   149  		testPolicy.FileNameRule = "{uid}123{originname}"
   150  		asserts.Equal("1123123.txt", testPolicy.GenerateFileName(1, "123.txt"))
   151  
   152  		testPolicy.Type = "oss"
   153  		testPolicy.FileNameRule = "{uid}123{originname}"
   154  		asserts.Equal("1123123321", testPolicy.GenerateFileName(1, "123321"))
   155  
   156  		testPolicy.Type = "upyun"
   157  		testPolicy.FileNameRule = "{uid}123{originname}"
   158  		asserts.Equal("1123123321", testPolicy.GenerateFileName(1, "123321"))
   159  
   160  		testPolicy.Type = "qiniu"
   161  		testPolicy.FileNameRule = "{uid}123{originname}"
   162  		asserts.Equal("1123123321", testPolicy.GenerateFileName(1, "123321"))
   163  
   164  		testPolicy.Type = "local"
   165  		testPolicy.FileNameRule = "{uid}123{originname}"
   166  		asserts.Equal("1123", testPolicy.GenerateFileName(1, ""))
   167  
   168  		testPolicy.Type = "local"
   169  		testPolicy.FileNameRule = "{ext}123{uuid}"
   170  		asserts.Contains(testPolicy.GenerateFileName(1, "123.txt"), ".txt123")
   171  	}
   172  
   173  }
   174  
   175  func TestPolicy_IsDirectlyPreview(t *testing.T) {
   176  	asserts := assert.New(t)
   177  	policy := Policy{Type: "local"}
   178  	asserts.True(policy.IsDirectlyPreview())
   179  	policy.Type = "remote"
   180  	asserts.False(policy.IsDirectlyPreview())
   181  }
   182  
   183  func TestPolicy_ClearCache(t *testing.T) {
   184  	asserts := assert.New(t)
   185  	cache.Set("policy_202", 1, 0)
   186  	policy := Policy{Model: gorm.Model{ID: 202}}
   187  	policy.ClearCache()
   188  	_, ok := cache.Get("policy_202")
   189  	asserts.False(ok)
   190  }
   191  
   192  func TestPolicy_UpdateAccessKey(t *testing.T) {
   193  	asserts := assert.New(t)
   194  	policy := Policy{Model: gorm.Model{ID: 202}}
   195  	mock.ExpectBegin()
   196  	mock.ExpectExec("UPDATE(.+)").WillReturnResult(sqlmock.NewResult(1, 1))
   197  	mock.ExpectCommit()
   198  	policy.AccessKey = "123"
   199  	err := policy.SaveAndClearCache()
   200  	asserts.NoError(mock.ExpectationsWereMet())
   201  	asserts.NoError(err)
   202  }
   203  
   204  func TestPolicy_Props(t *testing.T) {
   205  	asserts := assert.New(t)
   206  	policy := Policy{Type: "onedrive"}
   207  	policy.OptionsSerialized.PlaceholderWithSize = true
   208  	asserts.False(policy.IsThumbGenerateNeeded())
   209  	asserts.False(policy.IsTransitUpload(4))
   210  	asserts.False(policy.IsTransitUpload(5 * 1024 * 1024))
   211  	asserts.True(policy.CanStructureBeListed())
   212  	asserts.True(policy.IsUploadPlaceholderWithSize())
   213  	policy.Type = "local"
   214  	asserts.True(policy.IsThumbGenerateNeeded())
   215  	asserts.False(policy.CanStructureBeListed())
   216  	asserts.False(policy.IsUploadPlaceholderWithSize())
   217  	policy.Type = "remote"
   218  	asserts.True(policy.IsUploadPlaceholderWithSize())
   219  }
   220  
   221  func TestPolicy_UpdateAccessKeyAndClearCache(t *testing.T) {
   222  	a := assert.New(t)
   223  	cache.Set("policy_1331", Policy{}, 3600)
   224  	p := &Policy{}
   225  	p.ID = 1331
   226  	mock.ExpectBegin()
   227  	mock.ExpectExec("UPDATE(.+)").WithArgs("ak", sqlmock.AnyArg()).WillReturnResult(sqlmock.NewResult(1, 1))
   228  	mock.ExpectCommit()
   229  
   230  	a.NoError(p.UpdateAccessKeyAndClearCache("ak"))
   231  	a.NoError(mock.ExpectationsWereMet())
   232  	_, ok := cache.Get("policy_1331")
   233  	a.False(ok)
   234  }
   235  
   236  func TestPolicy_CouldProxyThumb(t *testing.T) {
   237  	a := assert.New(t)
   238  	p := &Policy{Type: "local"}
   239  
   240  	// local policy
   241  	{
   242  		a.False(p.CouldProxyThumb())
   243  	}
   244  
   245  	// feature not enabled
   246  	{
   247  		p.Type = "remote"
   248  		cache.Set("setting_thumb_proxy_enabled", "0", 0)
   249  		a.False(p.CouldProxyThumb())
   250  	}
   251  
   252  	// list not contain current policy
   253  	{
   254  		p.ID = 2
   255  		cache.Set("setting_thumb_proxy_enabled", "1", 0)
   256  		cache.Set("setting_thumb_proxy_policy", "[1]", 0)
   257  		a.False(p.CouldProxyThumb())
   258  	}
   259  
   260  	// enabled
   261  	{
   262  		p.ID = 2
   263  		cache.Set("setting_thumb_proxy_enabled", "1", 0)
   264  		cache.Set("setting_thumb_proxy_policy", "[2]", 0)
   265  		a.True(p.CouldProxyThumb())
   266  	}
   267  
   268  	cache.Deletes([]string{"thumb_proxy_enabled", "thumb_proxy_policy"}, "setting_")
   269  }