Infrastructure/Cloudreve
0
Fork 0
Code Issues Pull requests Activity

Test: delete object route

Browse source
This commit is contained in:
HFO4 2019-11-30 23:22:57 +08:00
parent 93010e3525
commit b4cfa6b601
5 changed files with 363 additions and 287 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
assets

@ -1 +0,0 @@
Subproject commit 79aaeb9e3a02dab9133f39f872602414b0ab57a0

14
models/file.go
View file

@ -99,11 +99,15 @@ func RemoveFilesWithSoftLinks(files []File) ([]File, error) {
} }
// 过滤具有软连接的文件 // 过滤具有软连接的文件
for i := 0; i < len(files); i++ { if len(filesWithSoftLinks) == 0 {
for _, value := range filesWithSoftLinks { filteredFiles = files
if value.PolicyID != files[i].PolicyID || value.SourceName != files[i].SourceName { } else {
filteredFiles = append(filteredFiles, files[i]) for i := 0; i < len(files); i++ {
break for _, value := range filesWithSoftLinks {
if value.PolicyID != files[i].PolicyID || value.SourceName != files[i].SourceName {
filteredFiles = append(filteredFiles, files[i])
break
}
} }
} }
} }

178
routers/file_router_test.go Normal file
View file

@ -0,0 +1,178 @@
package routers
import (
"bytes"
"encoding/json"
"github.com/HFO4/cloudreve/middleware"
model "github.com/HFO4/cloudreve/models"
"github.com/HFO4/cloudreve/pkg/serializer"
"github.com/HFO4/cloudreve/service/explorer"
"github.com/stretchr/testify/assert"
"net/http"
"net/http/httptest"
"strings"
"testing"
)
func TestListDirectoryRoute(t *testing.T) {
switchToMemDB()
asserts := assert.New(t)
router := InitRouter()
w := httptest.NewRecorder()
// 成功
req, _ := http.NewRequest(
"GET",
"/api/v3/directory/",
nil,
)
middleware.SessionMock = map[string]interface{}{"user_id": 1}
router.ServeHTTP(w, req)
asserts.Equal(200, w.Code)
resJSON := &serializer.Response{}
err := json.Unmarshal(w.Body.Bytes(), resJSON)
asserts.NoError(err)
asserts.Equal(0, resJSON.Code)
w.Body.Reset()
}
func TestLocalFileUpload(t *testing.T) {
switchToMemDB()
asserts := assert.New(t)
router := InitRouter()
w := httptest.NewRecorder()
middleware.SessionMock = map[string]interface{}{"user_id": 1}
testCases := []struct {
GetRequest func() *http.Request
ExpectCode int
RollBack func()
}{
// 文件大小指定错误
{
GetRequest: func() *http.Request {
req, _ := http.NewRequest(
"POST",
"/api/v3/file/upload",
nil,
)
req.Header.Add("Content-Length", "ddf")
return req
},
ExpectCode: 40001,
},
// 返回错误
{
GetRequest: func() *http.Request {
req, _ := http.NewRequest(
"POST",
"/api/v3/file/upload",
strings.NewReader("2333"),
)
req.Header.Add("Content-Length", "4")
req.Header.Add("X-FileName", "大地的%sfsf")
return req
},
ExpectCode: 40002,
},
// 成功
{
GetRequest: func() *http.Request {
req, _ := http.NewRequest(
"POST",
"/api/v3/file/upload",
strings.NewReader("2333"),
)
req.Header.Add("Content-Length", "4")
req.Header.Add("X-FileName", "TestFileUploadRoute.txt")
return req
},
ExpectCode: 0,
},
}
for key, testCase := range testCases {
req := testCase.GetRequest()
router.ServeHTTP(w, req)
asserts.Equal(200, w.Code)
resJSON := &serializer.Response{}
err := json.Unmarshal(w.Body.Bytes(), resJSON)
asserts.NoError(err, "测试用例%d", key)
asserts.Equal(testCase.ExpectCode, resJSON.Code, "测试用例%d", key)
if testCase.RollBack != nil {
testCase.RollBack()
}
w.Body.Reset()
}
}
func TestObjectDelete(t *testing.T) {
asserts := assert.New(t)
router := InitRouter()
w := httptest.NewRecorder()
middleware.SessionMock = map[string]interface{}{"user_id": 1}
testCases := []struct {
Mock []string
GetRequest func() *http.Request
ExpectCode int
RollBack []string
}{
// 路径不存在，返回无错误
{
GetRequest: func() *http.Request {
body := explorer.ItemService{
Items: []string{"/TestObjectDelete.txt"},
}
bodyStr, _ := json.Marshal(body)
req, _ := http.NewRequest(
"DELETE",
"/api/v3/object",
bytes.NewReader(bodyStr),
)
return req
},
ExpectCode: 0,
},
// 文件删除失败，返回203
{
Mock: []string{"INSERT INTO `files` (`id`, `created_at`, `updated_at`, `deleted_at`, `name`, `source_name`, `user_id`, `size`, `pic_info`, `folder_id`, `policy_id`, `dir`) VALUES(5, '2019-11-30 07:08:33', '2019-11-30 07:08:33', NULL, 'pigeon.zip', '65azil3B_pigeon.zip', 1, 1667217, '', 1, 1, '/');"},
GetRequest: func() *http.Request {
body := explorer.ItemService{
Items: []string{"/pigeon.zip"},
}
bodyStr, _ := json.Marshal(body)
req, _ := http.NewRequest(
"DELETE",
"/api/v3/object",
bytes.NewReader(bodyStr),
)
return req
},
RollBack: []string{"DELETE FROM `v3_files` WHERE `id`=5"},
ExpectCode: 203,
},
}
for key, testCase := range testCases {
for _, value := range testCase.Mock {
model.DB.Exec(value)
}
req := testCase.GetRequest()
router.ServeHTTP(w, req)
asserts.Equal(200, w.Code)
resJSON := &serializer.Response{}
err := json.Unmarshal(w.Body.Bytes(), resJSON)
asserts.NoError(err, "测试用例%d", key)
asserts.Equal(testCase.ExpectCode, resJSON.Code, "测试用例%d", key)
for _, value := range testCase.RollBack {
model.DB.Exec(value)
}
w.Body.Reset()
}
}

8
routers/main_test.go
View file

@ -11,6 +11,7 @@ import (
var mock sqlmock.Sqlmock var mock sqlmock.Sqlmock
var memDB *gorm.DB var memDB *gorm.DB
var mockDB *gorm.DB
// TestMain 初始化数据库Mock // TestMain 初始化数据库Mock
func TestMain(m *testing.M) { func TestMain(m *testing.M) {
@ -29,7 +30,8 @@ func TestMain(m *testing.M) {
model.Init() model.Init()
memDB = model.DB memDB = model.DB
model.DB, _ = gorm.Open("mysql", db) mockDB, _ = gorm.Open("mysql", db)
model.DB = memDB
defer db.Close() defer db.Close()
m.Run() m.Run()
@ -38,3 +40,7 @@ func TestMain(m *testing.M) {
func switchToMemDB() { func switchToMemDB() {
model.DB = memDB model.DB = memDB
} }
func switchToMockDB() {
model.DB = mockDB
}

449
routers/router_test.go
View file

@ -1,19 +1,11 @@
package routers package routers
import ( import (
"bytes"
"encoding/json"
"errors"
"github.com/DATA-DOG/go-sqlmock"
"github.com/HFO4/cloudreve/middleware"
"github.com/HFO4/cloudreve/models" "github.com/HFO4/cloudreve/models"
"github.com/HFO4/cloudreve/pkg/serializer"
"github.com/jinzhu/gorm" "github.com/jinzhu/gorm"
"github.com/mojocn/base64Captcha"
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"net/http" "net/http"
"net/http/httptest" "net/http/httptest"
"strings"
"testing" "testing"
) )
@ -46,183 +38,175 @@ func TestCaptcha(t *testing.T) {
asserts.Contains(w.Body.String(), "base64") asserts.Contains(w.Body.String(), "base64")
} }
func TestUserSession(t *testing.T) { //func TestUserSession(t *testing.T) {
asserts := assert.New(t) // mutex.Lock()
router := InitRouter() // defer mutex.Unlock()
w := httptest.NewRecorder() // switchToMockDB()
// asserts := assert.New(t)
// 创建测试用验证码 // router := InitRouter()
var configD = base64Captcha.ConfigDigit{ // w := httptest.NewRecorder()
Height: 80, //
Width: 240, // // 创建测试用验证码
MaxSkew: 0.7, // var configD = base64Captcha.ConfigDigit{
DotCount: 80, // Height: 80,
CaptchaLen: 1, // Width: 240,
} // MaxSkew: 0.7,
idKeyD, _ := base64Captcha.GenerateCaptcha("", configD) // DotCount: 80,
middleware.ContextMock = map[string]interface{}{ // CaptchaLen: 1,
"captchaID": idKeyD, // }
} // idKeyD, _ := base64Captcha.GenerateCaptcha("", configD)
// middleware.ContextMock = map[string]interface{}{
testCases := []struct { // "captchaID": idKeyD,
settingRows *sqlmock.Rows // }
userRows *sqlmock.Rows //
policyRows *sqlmock.Rows // testCases := []struct {
reqBody string // settingRows *sqlmock.Rows
expected interface{} // userRows *sqlmock.Rows
}{ // policyRows *sqlmock.Rows
// 登录信息正确，不需要验证码 // reqBody string
{ // expected interface{}
settingRows: sqlmock.NewRows([]string{"name", "value", "type"}). // }{
AddRow("login_captcha", "0", "login"), // // 登录信息正确，不需要验证码
userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options"}). // {
AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}"), policyRows: sqlmock.NewRows([]string{"name", "type", "options"}). // settingRows: sqlmock.NewRows([]string{"name", "value", "type"}).
AddRow("默认存储策略", "local", "{\"op_name\":\"123\"}"), // AddRow("login_captcha", "0", "login"),
reqBody: `{"userName":"admin@cloudreve.org","captchaCode":"captchaCode","Password":"admin"}`, // userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options"}).
expected: serializer.BuildUserResponse(model.User{ // AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}"),
Email: "admin@cloudreve.org", // expected: serializer.BuildUserResponse(model.User{
Nick: "admin", // Email: "admin@cloudreve.org",
Policy: model.Policy{ // Nick: "admin",
Type: "local", // Policy: model.Policy{
OptionsSerialized: model.PolicyOption{FileType: []string{}}, // Type: "local",
}, // OptionsSerialized: model.PolicyOption{FileType: []string{}},
}), // },
}, // }),
// 登录信息正确，需要验证码,验证码错误 // },
{ // // 登录信息正确，需要验证码,验证码错误
settingRows: sqlmock.NewRows([]string{"name", "value", "type"}). // {
AddRow("login_captcha", "1", "login"), // settingRows: sqlmock.NewRows([]string{"name", "value", "type"}).
userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options"}). // AddRow("login_captcha", "1", "login"),
AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}"), // userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options"}).
policyRows: sqlmock.NewRows([]string{"name", "type", "options"}). // AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}"),
AddRow("默认存储策略", "local", "{\"op_name\":\"123\"}"), // expected: serializer.ParamErr("验证码错误", nil),
reqBody: `{"userName":"admin@cloudreve.org","captchaCode":"captchaCode","Password":"admin"}`, // },
expected: serializer.ParamErr("验证码错误", nil), // // 邮箱正确密码错误
}, // {
// 邮箱正确密码错误 // settingRows: sqlmock.NewRows([]string{"name", "value", "type"}).
{ // AddRow("login_captcha", "0", "login"),
settingRows: sqlmock.NewRows([]string{"name", "value", "type"}). // userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options"}).
AddRow("login_captcha", "0", "login"), // AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}"),
userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options"}). // expected: serializer.Err(401, "用户邮箱或密码错误", nil),
AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}"), // },
policyRows: sqlmock.NewRows([]string{"name", "type", "options"}). // //邮箱格式不正确
AddRow("默认存储策略", "local", "{\"op_name\":\"123\"}"), // {
reqBody: `{"userName":"admin@cloudreve.org","captchaCode":"captchaCode","Password":"admin123"}`, // reqBody: `{"userName":"admin@cloudreve","captchaCode":"captchaCode","Password":"admin123"}`,
expected: serializer.Err(401, "用户邮箱或密码错误", nil), // expected: serializer.Err(40001, "邮箱格式不正确", errors.New("Key: 'UserLoginService.UserName' Error:Field validation for 'UserName' failed on the 'email' tag")),
}, // },
//邮箱格式不正确 // // 用户被Ban
{ // {
reqBody: `{"userName":"admin@cloudreve","captchaCode":"captchaCode","Password":"admin123"}`, // settingRows: sqlmock.NewRows([]string{"name", "value", "type"}).
expected: serializer.Err(40001, "邮箱格式不正确", errors.New("Key: 'UserLoginService.UserName' Error:Field validation for 'UserName' failed on the 'email' tag")), // AddRow("login_captcha", "0", "login"),
}, // userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options", "status"}).
// 用户被Ban // AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}", model.Baned),
{ // expected: serializer.Err(403, "该账号已被封禁", nil),
settingRows: sqlmock.NewRows([]string{"name", "value", "type"}). // },
AddRow("login_captcha", "0", "login"), // // 用户未激活
userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options", "status"}). // {
AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}", model.Baned), // settingRows: sqlmock.NewRows([]string{"name", "value", "type"}).
policyRows: sqlmock.NewRows([]string{"name", "type", "options"}). // AddRow("login_captcha", "0", "login"),
AddRow("默认存储策略", "local", "{\"op_name\":\"123\"}"), // userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options", "status"}).
reqBody: `{"userName":"admin@cloudreve.org","captchaCode":"captchaCode","Password":"admin"}`, // AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}", model.NotActivicated),
expected: serializer.Err(403, "该账号已被封禁", nil), // expected: serializer.Err(403, "该账号未激活", nil),
}, // },
// 用户未激活 // }
{ //
settingRows: sqlmock.NewRows([]string{"name", "value", "type"}). // for k, testCase := range testCases {
AddRow("login_captcha", "0", "login"), // if testCase.settingRows != nil {
userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options", "status"}). // mock.ExpectQuery("^SELECT (.+)").WillReturnRows(testCase.settingRows)
AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}", model.NotActivicated), // }
policyRows: sqlmock.NewRows([]string{"name", "type", "options"}). // if testCase.userRows != nil {
AddRow("默认存储策略", "local", "{\"op_name\":\"123\"}"), // mock.ExpectQuery("^SELECT (.+)").WillReturnRows(testCase.userRows)
reqBody: `{"userName":"admin@cloudreve.org","captchaCode":"captchaCode","Password":"admin"}`, // }
expected: serializer.Err(403, "该账号未激活", nil), // if testCase.policyRows != nil {
}, // mock.ExpectQuery("^SELECT \\* FROM `(.+)` WHERE `(.+)`\\.`deleted_at` IS NULL AND \\(\\(`policies`.`id` = 1\\)\\)(.+)$").WillReturnRows(testCase.policyRows)
} // }
// req, _ := http.NewRequest(
for k, testCase := range testCases { // "POST",
if testCase.settingRows != nil { // "/api/v3/user/session",
mock.ExpectQuery("^SELECT (.+)").WillReturnRows(testCase.settingRows) // bytes.NewReader([]byte(testCase.reqBody)),
} // )
if testCase.userRows != nil { // router.ServeHTTP(w, req)
mock.ExpectQuery("^SELECT (.+)").WillReturnRows(testCase.userRows) //
} // asserts.Equal(200, w.Code)
if testCase.policyRows != nil { // expectedJSON, _ := json.Marshal(testCase.expected)
mock.ExpectQuery("^SELECT \\* FROM `(.+)` WHERE `(.+)`\\.`deleted_at` IS NULL AND \\(\\(`policies`.`id` = 1\\)\\)(.+)$").WillReturnRows(testCase.policyRows) // asserts.JSONEq(string(expectedJSON), w.Body.String(), "测试用例：%d", k)
} //
req, _ := http.NewRequest( // w.Body.Reset()
"POST", // asserts.NoError(mock.ExpectationsWereMet())
"/api/v3/user/session", // model.ClearCache()
bytes.NewReader([]byte(testCase.reqBody)), // }
) //
router.ServeHTTP(w, req) //}
//
asserts.Equal(200, w.Code) //func TestSessionAuthCheck(t *testing.T) {
expectedJSON, _ := json.Marshal(testCase.expected) // mutex.Lock()
asserts.JSONEq(string(expectedJSON), w.Body.String(), "测试用例：%d", k) // defer mutex.Unlock()
// switchToMockDB()
w.Body.Reset() // asserts := assert.New(t)
asserts.NoError(mock.ExpectationsWereMet()) // router := InitRouter()
model.ClearCache() // w := httptest.NewRecorder()
} //
// mock.ExpectQuery("^SELECT (.+)").WillReturnRows(sqlmock.NewRows([]string{"email", "nick", "password", "options"}).
} // AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}"))
// expectedUser, _ := model.GetUserByID(1)
func TestSessionAuthCheck(t *testing.T) { //
asserts := assert.New(t) // testCases := []struct {
router := InitRouter() // userRows *sqlmock.Rows
w := httptest.NewRecorder() // sessionMock map[string]interface{}
// contextMock map[string]interface{}
mock.ExpectQuery("^SELECT (.+)").WillReturnRows(sqlmock.NewRows([]string{"email", "nick", "password", "options"}). // expected interface{}
AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}")) // }{
expectedUser, _ := model.GetUserByID(1) // // 未登录
// {
testCases := []struct { // expected: serializer.CheckLogin(),
userRows *sqlmock.Rows // },
sessionMock map[string]interface{} // // 登录正常
contextMock map[string]interface{} // {
expected interface{} // userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options"}).
}{ // AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}"),
// 未登录 // sessionMock: map[string]interface{}{"user_id": 1},
{ // expected: serializer.BuildUserResponse(expectedUser),
expected: serializer.CheckLogin(), // },
}, // // UID不存在
// 登录正常 // {
{ // userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options"}),
userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options"}). // sessionMock: map[string]interface{}{"user_id": -1},
AddRow("admin@cloudreve.org", "admin", "CKLmDKa1C9SD64vU:76adadd4fd4bad86959155f6f7bc8993c94e7adf", "{}"), // expected: serializer.CheckLogin(),
sessionMock: map[string]interface{}{"user_id": 1}, // },
expected: serializer.BuildUserResponse(expectedUser), // }
}, //
// UID不存在 // for _, testCase := range testCases {
{ // req, _ := http.NewRequest(
userRows: sqlmock.NewRows([]string{"email", "nick", "password", "options"}), // "GET",
sessionMock: map[string]interface{}{"user_id": -1}, // "/api/v3/user/me",
expected: serializer.CheckLogin(), // nil,
}, // )
} // if testCase.userRows != nil {
// mock.ExpectQuery("^SELECT (.+)").WillReturnRows(testCase.userRows)
for _, testCase := range testCases { // }
req, _ := http.NewRequest( // middleware.ContextMock = testCase.contextMock
"GET", // middleware.SessionMock = testCase.sessionMock
"/api/v3/user/me", // router.ServeHTTP(w, req)
nil, // expectedJSON, _ := json.Marshal(testCase.expected)
) //
if testCase.userRows != nil { // asserts.Equal(200, w.Code)
mock.ExpectQuery("^SELECT (.+)").WillReturnRows(testCase.userRows) // asserts.JSONEq(string(expectedJSON), w.Body.String())
} // asserts.NoError(mock.ExpectationsWereMet())
middleware.ContextMock = testCase.contextMock //
middleware.SessionMock = testCase.sessionMock // w.Body.Reset()
router.ServeHTTP(w, req) // }
expectedJSON, _ := json.Marshal(testCase.expected) //
//}
asserts.Equal(200, w.Code)
asserts.JSONEq(string(expectedJSON), w.Body.String())
asserts.NoError(mock.ExpectationsWereMet())
w.Body.Reset()
}
}
func TestSiteConfigRoute(t *testing.T) { func TestSiteConfigRoute(t *testing.T) {
switchToMemDB() switchToMemDB()
@ -263,98 +247,3 @@ func TestSiteConfigRoute(t *testing.T) {
}, },
}).UpdateColumn("name", "siteName") }).UpdateColumn("name", "siteName")
} }
func TestListDirectoryRoute(t *testing.T) {
switchToMemDB()
asserts := assert.New(t)
router := InitRouter()
w := httptest.NewRecorder()
// 成功
req, _ := http.NewRequest(
"GET",
"/api/v3/directory/",
nil,
)
middleware.SessionMock = map[string]interface{}{"user_id": 1}
router.ServeHTTP(w, req)
asserts.Equal(200, w.Code)
resJSON := &serializer.Response{}
err := json.Unmarshal(w.Body.Bytes(), resJSON)
asserts.NoError(err)
asserts.Equal(0, resJSON.Code)
w.Body.Reset()
}
func TestLocalFileUpload(t *testing.T) {
switchToMemDB()
asserts := assert.New(t)
router := InitRouter()
w := httptest.NewRecorder()
middleware.SessionMock = map[string]interface{}{"user_id": 1}
testCases := []struct {
GetRequest func() *http.Request
ExpectCode int
RollBack func()
}{
// 文件大小指定错误
{
GetRequest: func() *http.Request {
req, _ := http.NewRequest(
"POST",
"/api/v3/file/upload",
nil,
)
req.Header.Add("Content-Length", "ddf")
return req
},
ExpectCode: 40001,
},
// 返回错误
{
GetRequest: func() *http.Request {
req, _ := http.NewRequest(
"POST",
"/api/v3/file/upload",
strings.NewReader("2333"),
)
req.Header.Add("Content-Length", "4")
req.Header.Add("X-FileName", "大地的%sfsf")
return req
},
ExpectCode: 40002,
},
// 成功
{
GetRequest: func() *http.Request {
req, _ := http.NewRequest(
"POST",
"/api/v3/file/upload",
strings.NewReader("2333"),
)
req.Header.Add("Content-Length", "4")
req.Header.Add("X-FileName", "TestFileUploadRoute.txt")
return req
},
ExpectCode: 0,
},
}
for key, testCase := range testCases {
req := testCase.GetRequest()
router.ServeHTTP(w, req)
asserts.Equal(200, w.Code)
resJSON := &serializer.Response{}
err := json.Unmarshal(w.Body.Bytes(), resJSON)
asserts.NoError(err, "测试用例%d", key)
asserts.Equal(testCase.ExpectCode, resJSON.Code, "测试用例%d", key)
if testCase.RollBack != nil {
testCase.RollBack()
}
w.Body.Reset()
}
}