From 07bd06ca284b20336cb927d471d81e03590c2e33 Mon Sep 17 00:00:00 2001 From: zl Date: Thu, 22 Sep 2022 00:07:38 +0800 Subject: [PATCH 1/5] feat: STM annotations --- auth/app.go | 19 +--- auth/jwt_test.go | 94 ++++++++++++---- auth/transport.go | 19 ++-- integrate_test/miner_test.go | 84 ++++++++++----- integrate_test/ratelimit_test.go | 20 +++- integrate_test/token_test.go | 1 + integrate_test/user_test.go | 67 ++++++++++-- jwtclient/auth_client_test.go | 2 + storage/mysql.go | 5 + storage/mysql_test.go | 180 ++++++++++++++++++++++--------- storage/store.go | 4 +- storage/store_test.go | 46 +++++++- 12 files changed, 407 insertions(+), 134 deletions(-) diff --git a/auth/app.go b/auth/app.go index ad2fff3..106dbfe 100644 --- a/auth/app.go +++ b/auth/app.go @@ -72,8 +72,7 @@ func SuccessResponse(c *gin.Context, obj interface{}) { func Response(c *gin.Context, err error) { if err != nil { - c.Error(err) // nolint - c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) + BadResponse(c, err) return } c.AbortWithStatus(http.StatusOK) @@ -205,10 +204,6 @@ func (o *oauthApp) UpdateUser(c *gin.Context) { return } err := o.srv.UpdateUser(c, req) - if err != nil { - BadResponse(c, err) - return - } Response(c, err) } @@ -276,11 +271,7 @@ func (o *oauthApp) DeleteUser(c *gin.Context) { return } err := o.srv.DeleteUser(c, req) - if err != nil { - BadResponse(c, err) - return - } - Response(c, nil) + Response(c, err) } func (o *oauthApp) RecoverUser(c *gin.Context) { @@ -290,11 +281,7 @@ func (o *oauthApp) RecoverUser(c *gin.Context) { return } err := o.srv.RecoverUser(c, req) - if err != nil { - BadResponse(c, err) - return - } - Response(c, nil) + Response(c, err) } func (o *oauthApp) AddUserRateLimit(c *gin.Context) { diff --git a/auth/jwt_test.go b/auth/jwt_test.go index f222e5f..e41ecaf 100644 --- a/auth/jwt_test.go +++ b/auth/jwt_test.go @@ -1,3 +1,4 @@ +// stm: #unit package auth import ( @@ -36,26 +37,39 @@ func TestJwt(t *testing.T) { "test_user_003": {"t01007", "t01008", "t01009"}, } - // Features about tokens + //stm: @VENUSAUTH_JWT_GENERATE_TOKEN_001 t.Run("generate token", testGenerateToken) + //stm: @VENUSAUTH_JWT_VERIFY_TOKEN_001, @VENUSAUTH_JWT_VERIFY_TOKEN_002 t.Run("verify token", testVerifyToken) + //stm: @VENUSAUTH_JWT_GET_TOKEN_001, @VENUSAUTH_JWT_GET_TOKEN_002 t.Run("get token", testGetToken) + //stm: @VENUSAUTH_JWT_GET_TOKEN_BY_NAME_001, @VENUSAUTH_JWT_GET_TOKEN_BY_NAME_002 t.Run("get token by name", testGetTokenByName) + //stm: @VENUSAUTH_JWT_TOKENS_001 t.Run("list all tokens", testTokenList) + //stm: @VENUSAUTH_JWT_REMOVE_TOKEN_001, @VENUSAUTH_JWT_RECOVER_TOKEN_001, @VENUSAUTH_JWT_RECOVER_TOKEN_003 t.Run("remove and recover tokens", testRemoveAndRecoverToken) - // Features about users + //stm: @VENUSAUTH_JWT_CREATE_USER_001, @VENUSAUTH_JWT_CREATE_USER_003 t.Run("test create user", func(t *testing.T) { testCreateUser(t, userMiners) }) + //stm: @VENUSAUTH_JWT_GET_USER_001, @VENUSAUTH_JWT_HAS_USER_001, @VENUSAUTH_JWT_GET_USER_002 t.Run("test get user", func(t *testing.T) { testGetUser(t, userMiners) }) + //stm: @VENUSAUTH_JWT_LIST_USERS_001 t.Run("test list user", func(t *testing.T) { testListUser(t, userMiners) }) + //stm: @VENUSAUTH_JWT_UPDATE_USER_001, @VENUSAUTH_JWT_UPDATE_USER_002 t.Run("test update user", func(t *testing.T) { testUpdateUser(t, userMiners) }) + //stm: @VENUSAUTH_JWT_DELETE_USER_001, @VENUSAUTH_JWT_RECOVER_USER_001, @VENUSAUTH_JWT_RECOVER_USER_002, @VENUSAUTH_JWT_RECOVER_USER_003 t.Run("test delete and recover user", func(t *testing.T) { testDeleteAndRecoverUser(t, userMiners) }) - // Features about miners + //stm: @VENUSAUTH_JWT_UPSERT_MINER_001, @VENUSAUTH_JWT_UPSERT_MINER_002 t.Run("test upsert miner", func(t *testing.T) { testUpsertMiner(t, userMiners) }) + //stm: @VENUSAUTH_JWT_LIST_MINERS_001 t.Run("test list miner", func(t *testing.T) { testListMiner(t, userMiners) }) + //stm: @VENUSAUTH_JWT_HAS_MINER_001, @VENUSAUTH_JWT_HAS_MINER_002 t.Run("test has miner", func(t *testing.T) { testHasMiner(t, userMiners) }) + //stm: @VENUSAUTH_JWT_GET_USER_BY_MINER_001, @VENUSAUTH_JWT_GET_USER_BY_MINER_002, @VENUSAUTH_JWT_GET_USER_BY_MINER_003 t.Run("test get user by miner", func(t *testing.T) { testGetUserByMiner(t, userMiners) }) + //stm: @VENUSAUTH_JWT_DELETE_MINER_001, @VENUSAUTH_JWT_DELETE_MINER_002 t.Run("test delete miner", func(t *testing.T) { testDeleteMiner(t, userMiners) }) // Features about signers @@ -73,8 +87,10 @@ func TestJwt(t *testing.T) { t.Run("test delete signer", func(t *testing.T) { testDeleteSigner(t, userSigners) }) // Features about rate limits + //stm: @VENUSAUTH_JWT_UPSERT_USER_RATE_LIMITS_001 t.Run("test upsert rate limit", func(t *testing.T) { testUpsertUserRateLimit(t, userMiners, originLimits) }) t.Run("test get rate limit", func(t *testing.T) { testGetUserRateLimits(t, userMiners, originLimits) }) + //stm: @VENUSAUTH_JWT_DELETE_USER_RATE_LIMITS_001 t.Run("test delete rate limit", func(t *testing.T) { testDeleteUserRateLimits(t, userMiners, originLimits) }) } @@ -106,17 +122,18 @@ func testVerifyToken(t *testing.T) { Perm: "admin", Extra: "", } - token1, err := jwtOAuthInstance.GenerateToken(context.Background(), pl1) + ctx := context.TODO() + token1, err := jwtOAuthInstance.GenerateToken(ctx, pl1) assert.Nil(t, err) // Verify a valid token - payload1, err := jwtOAuthInstance.Verify(context.Background(), token1) + payload1, err := jwtOAuthInstance.Verify(ctx, token1) assert.Nil(t, err) assert.True(t, reflect.DeepEqual(payload1, pl1)) // Try to verify an invalid token invalidToken := "I'm just an invalid token" - _, err = jwtOAuthInstance.Verify(context.Background(), invalidToken) + _, err = jwtOAuthInstance.Verify(ctx, invalidToken) assert.NotNil(t, err) } @@ -219,9 +236,14 @@ func testRemoveAndRecoverToken(t *testing.T) { Perm: "admin", Extra: "", } - token1, err := jwtOAuthInstance.GenerateToken(context.Background(), pl1) + ctx := context.TODO() + token1, err := jwtOAuthInstance.GenerateToken(ctx, pl1) assert.Nil(t, err) + // token is usable. + err = jwtOAuthInstance.RecoverToken(ctx, token1) + assert.Error(t, err) + // Remove a token err = jwtOAuthInstance.RemoveToken(context.Background(), token1) assert.Nil(t, err) @@ -290,13 +312,19 @@ func testGetUser(t *testing.T, userMiners map[string][]string) { setup(&cfg, t) defer shutdown(&cfg, t) createUsers(t, userMiners) + + ctx := context.TODO() // HasUser - exist, err := jwtOAuthInstance.HasUser(context.Background(), &HasUserRequest{Name: existUserName}) + exist, err := jwtOAuthInstance.HasUser(ctx, &HasUserRequest{Name: existUserName}) assert.Nil(t, err) assert.True(t, exist) - exist, err = jwtOAuthInstance.HasUser(context.Background(), &HasUserRequest{Name: invalidUserName}) + exist, err = jwtOAuthInstance.HasUser(ctx, &HasUserRequest{Name: invalidUserName}) assert.Nil(t, err) assert.False(t, exist) + + u, err := jwtOAuthInstance.GetUser(ctx, &GetUserRequest{Name: existUserName}) + assert.Nil(t, err) + assert.Equal(t, u.Name, existUserName) } func testListUser(t *testing.T, userMiners map[string][]string) { @@ -333,6 +361,10 @@ func testUpdateUser(t *testing.T, userMiners map[string][]string) { outPutUser1, err := jwtOAuthInstance.GetUser(context.Background(), &GetUserRequest{Name: existUserName}) assert.Nil(t, err) assert.Equal(t, "New Comment", outPutUser1.Comment) + + // invalid user name + err = jwtOAuthInstance.UpdateUser(context.Background(), &UpdateUserRequest{}) + assert.Error(t, err) } func testDeleteAndRecoverUser(t *testing.T, userMiners map[string][]string) { @@ -405,12 +437,17 @@ func testUpsertMiner(t *testing.T, userMiners map[string][]string) { defer shutdown(&cfg, t) addUsersAndMiners(t, userMiners) + var ctx = context.TODO() // error signer address - _, _ = jwtOAuthInstance.CreateUser(context.Background(), &CreateUserRequest{ + _, _ = jwtOAuthInstance.CreateUser(ctx, &CreateUserRequest{ Name: "user_01", State: 1, }) - _, err := jwtOAuthInstance.UpsertMiner(context.Background(), &UpsertMinerReq{ + isCreate, err := jwtOAuthInstance.UpsertMiner(ctx, &UpsertMinerReq{User: "user_01", Miner: "f01034"}) + assert.Nil(t, err) + assert.True(t, isCreate) + + _, err = jwtOAuthInstance.UpsertMiner(ctx, &UpsertMinerReq{ User: "user_01", Miner: "f1mpvdqt2acgihevibd4greavlsfn3dfph5sckc2a", }) @@ -426,8 +463,9 @@ func testListMiner(t *testing.T, userMiners map[string][]string) { validUser1 := "test_user_001" user1Miners := []string{"t01000", "t01002", "t01003"} + ctx := context.TODO() // List miners - resp, err := jwtOAuthInstance.ListMiners(context.Background(), &ListMinerReq{User: validUser1}) + resp, err := jwtOAuthInstance.ListMiners(ctx, &ListMinerReq{User: validUser1}) assert.Nil(t, err) assert.Equal(t, len(user1Miners), len(resp)) sort.Slice(resp, func(i, j int) bool { return resp[i].Miner < resp[j].Miner }) @@ -456,6 +494,9 @@ func testHasMiner(t *testing.T, userMiners map[string][]string) { exist, err = jwtOAuthInstance.MinerExistInUser(context.Background(), &MinerExistInUserRequest{Miner: "t01000", User: "test_user_002"}) assert.Nil(t, err) assert.False(t, exist) + + _, err = jwtOAuthInstance.HasMiner(context.Background(), &HasMinerRequest{Miner: "invalid address"}) + assert.Error(t, err) } func testGetUserByMiner(t *testing.T, userMiners map[string][]string) { @@ -464,14 +505,27 @@ func testGetUserByMiner(t *testing.T, userMiners map[string][]string) { defer shutdown(&cfg, t) addUsersAndMiners(t, userMiners) + ctx := context.TODO() // Get User By Miner validUser1 := "test_user_001" user1Miners := []string{"t01000", "t01002", "t01003"} - userInfo, err := jwtOAuthInstance.GetUserByMiner(context.Background(), &GetUserByMinerRequest{ + userInfo, err := jwtOAuthInstance.GetUserByMiner(ctx, &GetUserByMinerRequest{ Miner: user1Miners[1], }) assert.Nil(t, err) assert.Equal(t, validUser1, userInfo.Name) + + // invalid miner address + _, err = jwtOAuthInstance.GetUserByMiner(ctx, &GetUserByMinerRequest{ + Miner: "invalid address", + }) + assert.Error(t, err) + + // miner address not exist + _, err = jwtOAuthInstance.GetUserByMiner(ctx, &GetUserByMinerRequest{ + Miner: "f01989787", + }) + assert.Error(t, err) } func testDeleteMiner(t *testing.T, userMiners map[string][]string) { @@ -482,22 +536,23 @@ func testDeleteMiner(t *testing.T, userMiners map[string][]string) { user1Miners := []string{"t01000", "t01002", "t01003"} invalidMiner := "t02000" + ctx := context.TODO() // Delete miner - deleted, err := jwtOAuthInstance.DelMiner(context.Background(), &DelMinerReq{Miner: user1Miners[0]}) + deleted, err := jwtOAuthInstance.DelMiner(ctx, &DelMinerReq{Miner: user1Miners[0]}) assert.Nil(t, err) assert.True(t, deleted) // Then get this miner - has, err := jwtOAuthInstance.HasMiner(context.Background(), &HasMinerRequest{Miner: user1Miners[0]}) + has, err := jwtOAuthInstance.HasMiner(ctx, &HasMinerRequest{Miner: user1Miners[0]}) assert.Nil(t, err) assert.False(t, has) // Try to get user by this miner - _, err = jwtOAuthInstance.GetUserByMiner(context.Background(), &GetUserByMinerRequest{ + _, err = jwtOAuthInstance.GetUserByMiner(ctx, &GetUserByMinerRequest{ Miner: user1Miners[0], }) assert.NotNil(t, err) // Delete an invalid miner - deleted, err = jwtOAuthInstance.DelMiner(context.Background(), &DelMinerReq{Miner: invalidMiner}) + deleted, err = jwtOAuthInstance.DelMiner(ctx, &DelMinerReq{Miner: invalidMiner}) assert.Nil(t, err) assert.False(t, deleted) } @@ -509,11 +564,12 @@ func addUsersAndSigners(t *testing.T, userSigners map[string][]string) { State: 1, } + ctx := context.TODO() // Create users. - _, _ = jwtOAuthInstance.CreateUser(context.Background(), createUserReq) + _, _ = jwtOAuthInstance.CreateUser(ctx, createUserReq) // Add Signer for _, signer := range signers { - ifCreate, err := jwtOAuthInstance.RegisterSigner(context.Background(), &RegisterSignerReq{ + ifCreate, err := jwtOAuthInstance.RegisterSigner(ctx, &RegisterSignerReq{ User: userName, Signer: signer, }) diff --git a/auth/transport.go b/auth/transport.go index c1c2d3f..11402e3 100644 --- a/auth/transport.go +++ b/auth/transport.go @@ -60,7 +60,7 @@ type GetTokensResponse = []*TokenInfo type GetUserRateLimitsReq struct { Id string `form:"id"` - Name string `form:"name"` + Name string `form:"name" binding:"required"` } type DelUserRateLimitReq struct { @@ -97,24 +97,24 @@ type OutputUser struct { } type GetUserRequest struct { - Name string `form:"name"` + Name string `form:"name" binding:"required"` } type HasUserRequest struct { - Name string `form:"name"` + Name string `form:"name" binding:"required"` } type DeleteUserRequest struct { - Name string `form:"name"` + Name string `form:"name" binding:"required"` } type RecoverUserRequest struct { - Name string `form:"name"` + Name string `form:"name" binding:"required"` } type GetUserByMinerRequest struct { // todo make miner tobe address - Miner string `form:"miner"` + Miner string `form:"miner" binding:"required"` } func (ls GetUserRateLimitResponse) MatchedLimit(service, api string) *storage.UserRateLimit { @@ -129,11 +129,12 @@ func (ls GetUserRateLimitResponse) MatchedLimit(service, api string) *storage.Us } type UpsertMinerReq struct { - User, Miner string + User string `binding:"required"` + Miner string `binding:"required"` } type HasMinerRequest struct { - Miner string `form:"miner"` + Miner string `form:"miner" binding:"required"` } type MinerExistInUserRequest struct { @@ -142,7 +143,7 @@ type MinerExistInUserRequest struct { } type ListMinerReq struct { - User string `form:"user"` + User string `form:"user" binding:"required"` } type OutputMiner struct { diff --git a/integrate_test/miner_test.go b/integrate_test/miner_test.go index 35eada0..9c856ec 100644 --- a/integrate_test/miner_test.go +++ b/integrate_test/miner_test.go @@ -1,3 +1,4 @@ +//stm: #integration package integrate import ( @@ -5,20 +6,26 @@ import ( "github.com/stretchr/testify/assert" + "github.com/filecoin-project/go-address" "github.com/filecoin-project/venus-auth/auth" "github.com/filecoin-project/venus-auth/jwtclient" ) func TestMinerApis(t *testing.T) { + //stm: @VENUSAUTH_APP_UPSERT_MINER_001, @VENUSAUTH_APP_UPSERT_MINER_002, @VENUSAUTH_APP_UPSERT_MINER_003 t.Run("upsert miner", testUpsertMiners) + //stm: @VENUSAUTH_APP_LIST_MINERS_001, @VENUSAUTH_APP_LIST_MINERS_002 t.Run("list miner by user", testListMinerByUser) + //stm: @VENUSAUTH_APP_HAS_MINER_001, @VENUSAUTH_APP_HAS_MINER_002, @VENUSAUTH_APP_HAS_MINER_003 t.Run("has miner", testHasMiner) t.Run("miner exist in user", testMinerExistInUser) + //stm: @VENUSAUTH_APP_GET_USERS_BY_MINER_001, @VENUSAUTH_APP_GET_USERS_BY_MINER_002, @VENUSAUTH_APP_GET_USERS_BY_MINER_003 t.Run("get user by miner", testGetUserByMiner) + //stm: @VENUSAUTH_APP_DEL_MINER_001, @VENUSAUTH_APP_DEL_MINER_003 t.Run("delete miner", testDeleteMiner) } -func setupAndAddMiners(t *testing.T) (*jwtclient.AuthClient, string) { +func setupAndAddMiners(t *testing.T) (*jwtclient.AuthClient, *auth.OutputUser, string) { server, tmpDir := setup(t) client, err := jwtclient.NewAuthClient(server.URL) @@ -29,7 +36,7 @@ func setupAndAddMiners(t *testing.T) (*jwtclient.AuthClient, string) { miner2 := "t01002" // Create a user - _, err = client.CreateUser(&auth.CreateUserRequest{Name: userName}) + user, err := client.CreateUser(&auth.CreateUserRequest{Name: userName}) assert.Nil(t, err) // Add 2 miners success, err := client.UpsertMiner(userName, miner1) @@ -39,27 +46,42 @@ func setupAndAddMiners(t *testing.T) (*jwtclient.AuthClient, string) { assert.Nil(t, err) assert.True(t, success) - return client, tmpDir + user.Miners = append(user.Miners, &auth.OutputMiner{Miner: miner1, User: userName}, + &auth.OutputMiner{Miner: miner2, User: userName}) + + return client, user, tmpDir } func testUpsertMiners(t *testing.T) { - _, tmpDir := setupAndAddMiners(t) + c, user, tmpDir := setupAndAddMiners(t) + + // `ShouldBind` failed + _, err := c.UpsertMiner("", "f01034") + assert.Error(t, err) + + // invalid address error + _, err = c.UpsertMiner(user.Name, address.Undef.String()) + assert.Error(t, err) + shutdown(t, tmpDir) } func testListMinerByUser(t *testing.T) { - client, tmpDir := setupAndAddMiners(t) + client, user, tmpDir := setupAndAddMiners(t) defer shutdown(t, tmpDir) - userName := "Rennbon" // List miner by user - listResp, err := client.ListMiners(userName) + listResp, err := client.ListMiners(user.Name) assert.Nil(t, err) assert.Equal(t, 2, len(listResp)) + + // `ShouldBind` failed + _, err = client.ListMiners("") + assert.Error(t, err) } func testHasMiner(t *testing.T) { - client, tmpDir := setupAndAddMiners(t) + client, _, tmpDir := setupAndAddMiners(t) defer shutdown(t, tmpDir) miner2 := "t01002" @@ -74,55 +96,67 @@ func testHasMiner(t *testing.T) { has, err = client.HasMiner(&auth.HasMinerRequest{Miner: miner3}) assert.Nil(t, err) assert.False(t, has) + + // `ShouldBind` failed + has, err = client.HasMiner(&auth.HasMinerRequest{}) + assert.Error(t, err) + assert.False(t, has) } func testMinerExistInUser(t *testing.T) { - client, tmpDir := setupAndAddMiners(t) + client, user, tmpDir := setupAndAddMiners(t) defer shutdown(t, tmpDir) - userName := "Rennbon" - miner := "t01002" notExistMiner := "t010010" - exist, err := client.MinerExistInUser(userName, miner) + exist, err := client.MinerExistInUser(user.Name, user.Miners[0].Miner) assert.Nil(t, err) assert.True(t, exist) - exist, err = client.MinerExistInUser(userName, notExistMiner) + exist, err = client.MinerExistInUser(user.Name, notExistMiner) assert.Nil(t, err) assert.False(t, exist) } func testGetUserByMiner(t *testing.T) { - client, tmpDir := setupAndAddMiners(t) + client, user, tmpDir := setupAndAddMiners(t) defer shutdown(t, tmpDir) - miner2 := "t01002" - userName := "Rennbon" // Get user by miner - getUserInfo, err := client.GetUserByMiner(&auth.GetUserByMinerRequest{Miner: miner2}) + getUserInfo, err := client.GetUserByMiner(&auth.GetUserByMinerRequest{Miner: user.Miners[0].Miner}) assert.Nil(t, err) - assert.Equal(t, userName, getUserInfo.Name) + assert.Equal(t, user.Name, getUserInfo.Name) + + // `ShouldBind` failed + _, err = client.GetUserByMiner(&auth.GetUserByMinerRequest{}) + assert.Error(t, err) + + // miner not exists error + _, err = client.GetUserByMiner(&auth.GetUserByMinerRequest{Miner: "f011112222233333"}) + assert.Error(t, err) } func testDeleteMiner(t *testing.T) { - client, tmpDir := setupAndAddMiners(t) + client, user, tmpDir := setupAndAddMiners(t) defer shutdown(t, tmpDir) - miner1 := "t01000" - miner3 := "t01004" + notExistMiner := "t01004" // Delete a miner - success, err := client.DelMiner(miner1) + success, err := client.DelMiner(user.Miners[0].Miner) assert.Nil(t, err) assert.True(t, success) // Check this miner - has, err := client.HasMiner(&auth.HasMinerRequest{Miner: miner1}) + has, err := client.HasMiner(&auth.HasMinerRequest{Miner: user.Miners[0].Miner}) assert.Nil(t, err) assert.False(t, has) - // Try to delete invalid miner - success, err = client.DelMiner(miner3) + // Try to delete not exist miner + success, err = client.DelMiner(notExistMiner) assert.Nil(t, err) assert.False(t, success) + + // Try to delete a invalid miner + _, err = client.DelMiner("abcdfghijk") + assert.Error(t, err) } diff --git a/integrate_test/ratelimit_test.go b/integrate_test/ratelimit_test.go index 39d9de3..0b3157e 100644 --- a/integrate_test/ratelimit_test.go +++ b/integrate_test/ratelimit_test.go @@ -1,3 +1,4 @@ +//stm: #integration package integrate import ( @@ -10,8 +11,12 @@ import ( ) func TestRateLimitApis(t *testing.T) { + //stm: @VENUSAUTH_APP_ADD_USER_RATE_LIMIT_001, @VENUSAUTH_APP_ADD_USER_RATE_LIMIT_002, @VENUSAUTH_APP_ADD_USER_RATE_LIMIT_003 + //stm: @VENUSAUTH_APP_UPSERT_USER_RATE_LIMIT_001, @VENUSAUTH_APP_UPSERT_USER_RATE_LIMIT_002 t.Run("upsert rate limit", testUpsertUserRateLimit) + //stm: @VENUSAUTH_APP_GET_USER_RATE_LIMIT_001, @VENUSAUTH_APP_GET_USER_RATE_LIMIT_002 t.Run("get rate limit", testGetRateLimit) + //stm: @VENUSAUTH_APP_DEL_USER_RATE_LIMIT_001, @VENUSAUTH_APP_DEL_USER_RATE_LIMIT_003 t.Run("delete rate limit", testDeleteRateLimit) } @@ -46,7 +51,12 @@ func setupAndAddRateLimits(t *testing.T) (*jwtclient.AuthClient, string) { } func testUpsertUserRateLimit(t *testing.T) { - _, tmpDir := setupAndAddRateLimits(t) + c, tmpDir := setupAndAddRateLimits(t) + + // `ShouldBind` failed + _, err := c.UpsertUserRateLimit(&auth.UpsertUserRateLimitReq{}) + assert.Error(t, err) + shutdown(t, tmpDir) } @@ -61,6 +71,10 @@ func testGetRateLimit(t *testing.T) { assert.Nil(t, err) assert.Equal(t, 1, len(getResp)) assert.Equal(t, reqId, getResp[0].Id) + + // `ShouldBind` failed + _, err = client.GetUserRateLimit("", "") + assert.Error(t, err) } func testDeleteRateLimit(t *testing.T) { @@ -78,4 +92,8 @@ func testDeleteRateLimit(t *testing.T) { getResp, err := client.GetUserRateLimit(userName, reqId) assert.Nil(t, err) assert.Equal(t, 0, len(getResp)) + + // if there is an error deleting user rate limits + _, err = client.DelUserRateLimit(&auth.DelUserRateLimitReq{}) + assert.Error(t, err) } diff --git a/integrate_test/token_test.go b/integrate_test/token_test.go index 4df5749..3d9678f 100644 --- a/integrate_test/token_test.go +++ b/integrate_test/token_test.go @@ -1,3 +1,4 @@ +//stm: #integration package integrate import ( diff --git a/integrate_test/user_test.go b/integrate_test/user_test.go index 2d724c7..18844dc 100644 --- a/integrate_test/user_test.go +++ b/integrate_test/user_test.go @@ -1,3 +1,4 @@ +//stm: #integration package integrate import ( @@ -10,10 +11,19 @@ import ( ) func TestUserApis(t *testing.T) { + //stm: @VENUSAUTH_APP_BAD_RESPONSE_001, @VENUSAUTH_APP_SUCCESS_RESPONSE_001 + //stm: @VENUSAUTH_APP_CREATE_USER_001, @VENUSAUTH_APP_CREATE_USER_002, @VENUSAUTH_APP_CREATE_USER_003 t.Run("create user", testCreateUser) + //stm: @VENUSAUTH_APP_UPDATE_USER_001, @VENUSAUTH_APP_UPDATE_USER_002, @VENUSAUTH_APP_UPDATE_USER_003 + t.Run("update user", testUpdateUser) + //stm: @VENUSAUTH_APP_GET_USER_001, @VENUSAUTH_APP_GET_USER_003 t.Run("get user", testGetUser) + //stm: @VENUSAUTH_APP_HAS_USER_001, @VENUSAUTH_APP_HAS_USER_002 t.Run("has user", testHasUser) + //stm: @VENUSAUTH_APP_LIST_USERS_001 t.Run("list user", testListUser) + //stm: @VENUSAUTH_APP_DELETE_USER_001, @VENUSAUTH_APP_DELETE_USER_002, @VENUSAUTH_APP_DELETE_USER_003 + //stm: @VENUSAUTH_APP_RECOVER_USER_001, @VENUSAUTH_APP_RECOVER_USER_003 t.Run("delete user", testDeleteUser) } @@ -33,7 +43,16 @@ func setupAndAddUser(t *testing.T) (*jwtclient.AuthClient, string, *auth.CreateU } func testCreateUser(t *testing.T) { - _, tmpDir, _ := setupAndAddUser(t) + c, tmpDir, userResp := setupAndAddUser(t) + + // user already exist error, and `BadResponse` + _, err := c.CreateUser(&auth.CreateUserRequest{Name: userResp.Name}) + assert.Error(t, err) + + // `ShouldBind` failed + _, err = c.CreateUser(&auth.CreateUserRequest{}) + assert.Error(t, err) + shutdown(t, tmpDir) } @@ -47,6 +66,29 @@ func testGetUser(t *testing.T) { assert.Equal(t, createResp.Name, getResp.Name) assert.Equal(t, createResp.Id, getResp.Id) assert.Equal(t, createResp.CreateTime, getResp.CreateTime) + + _, err = client.GetUser(&auth.GetUserRequest{Name: "not-exist-user"}) + assert.Error(t, err) +} + +func testUpdateUser(t *testing.T) { + c, tmpDir, user := setupAndAddUser(t) + + comment := "updated user comment" + + updateReq := &auth.UpdateUserRequest{Name: user.Name, Comment: &comment, State: core.UserStateEnabled} + err := c.UpdateUser(updateReq) + assert.NoError(t, err) + + // `ShouldBind` failed + err = c.UpdateUser(&auth.UpdateUserRequest{}) + assert.Error(t, err) + + // user not exist error + err = c.UpdateUser(&auth.UpdateUserRequest{Name: "not-exist-user-name"}) + assert.Error(t, err) + + shutdown(t, tmpDir) } func testHasUser(t *testing.T) { @@ -57,7 +99,9 @@ func testHasUser(t *testing.T) { has, err := client.HasUser(&auth.HasUserRequest{Name: createResp.Name}) assert.Nil(t, err) assert.True(t, has) - + // `ShouldBind` failed + _, err = client.HasUser(&auth.HasUserRequest{}) + assert.Error(t, err) } func testListUser(t *testing.T) { @@ -65,13 +109,7 @@ func testListUser(t *testing.T) { shutdown(t, tmpDir) // List users - listResp, err := client.ListUsers(&auth.ListUsersRequest{ - Page: &core.Page{ - Skip: 0, - Limit: 10, - }, - State: int(core.UserStateUndefined), - }) + listResp, err := client.ListUsers(auth.NewListUsersRequest(0, 10, int(core.UserStateUndefined))) assert.Nil(t, err) assert.Equal(t, len(listResp), 1) } @@ -100,4 +138,15 @@ func testDeleteUser(t *testing.T) { assert.Nil(t, err) assert.True(t, has) + // Recover not exist user. + err = client.RecoverUser(&auth.RecoverUserRequest{Name: "not-exist-user"}) + assert.Error(t, err) + + // `ShouldBind` failed + err = client.DeleteUser(&auth.DeleteUserRequest{}) + assert.Error(t, err) + + // Delete a not exists user + err = client.DeleteUser(&auth.DeleteUserRequest{Name: "not-exist-user"}) + assert.Error(t, err) } diff --git a/jwtclient/auth_client_test.go b/jwtclient/auth_client_test.go index aa092f4..8ac51be 100644 --- a/jwtclient/auth_client_test.go +++ b/jwtclient/auth_client_test.go @@ -1,3 +1,4 @@ +//stm: #unit package jwtclient import ( @@ -49,6 +50,7 @@ func TestMain(m *testing.M) { defer os.RemoveAll(tmpPath) } + //stm: @VENUSAUTH_JWT_NEW_OAUTH_SERVICE_001 app, err := auth.NewOAuthApp(cnf.Secret, tmpPath, cnf.DB) if err != nil { log.Fatalf("Failed to init oauthApp : %s", err) diff --git a/storage/mysql.go b/storage/mysql.go index 91f14b8..03d6e9b 100644 --- a/storage/mysql.go +++ b/storage/mysql.go @@ -2,6 +2,7 @@ package storage import ( "database/sql" + "errors" "time" "github.com/google/uuid" @@ -247,6 +248,10 @@ func (s *mysqlStore) PutRateLimit(limit *UserRateLimit) (string, error) { } func (s *mysqlStore) DelRateLimit(name, id string) error { + if len(name) == 0 || len(id) == 0 { + return errors.New("user and rate-limit id is required for removing rate limit regulation") + } + return s.db.Table("user_rate_limits"). Where("id = ? and name= ?", id, name). Delete(nil).Error diff --git a/storage/mysql_test.go b/storage/mysql_test.go index d51b74f..6c89598 100644 --- a/storage/mysql_test.go +++ b/storage/mysql_test.go @@ -1,3 +1,4 @@ +//stm: #unit package storage import ( @@ -20,6 +21,20 @@ import ( type anyTime struct{} +var simulateError = fmt.Errorf("just simulate an error") + +func sqlMockExpect(m sqlmock.Sqlmock, prefix string, fail bool) { + m.ExpectBegin() + exe := m.ExpectExec(regexp.QuoteMeta(prefix)) + if fail { + exe.WillReturnError(simulateError) + m.ExpectRollback() + return + } + exe.WillReturnResult(sqlmock.NewResult(1, 1)) + m.ExpectCommit() +} + // Match satisfies sqlmock.Argument interface func (a anyTime) Match(v driver.Value) bool { _, ok := v.(time.Time) @@ -39,35 +54,59 @@ func TestMysqlStore(t *testing.T) { } // Token + //stm: @VENUSAUTH_MYSQL_PUT_001 t.Run("mysql put token", wrapper(testMySQLPutToken, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_UPDATE_TOKEN_001, @VENUSAUTH_MYSQL_UPDATE_TOKEN_002 t.Run("mysql update token", wrapper(testMySQLUpdateToken, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_HAS_001 t.Run("mysql has token", wrapper(testMySQLHasToken, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_GET_001, @VENUSAUTH_MYSQL_HAS_002 t.Run("mysql get token", wrapper(testMySQLGetToken, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_LIST_001, @VENUSAUTH_MYSQL_LIST_002 t.Run("mysql list tokens", wrapper(testMySQLListTokens, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_GET_TOKEN_RECORD_001, @VENUSAUTH_MYSQL_GET_TOKEN_RECORD_002 t.Run("mysql get token record", wrapper(testMySQLGetTokenRecord, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_BY_NAME_001, @VENUSAUTH_MYSQL_BY_NAME_002 t.Run("mysql get token by name", wrapper(testMySQLGetTokenByName, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_DELETE_001,@VENUSAUTH_MYSQL_DELETE_002, @VENUSAUTH_MYSQL_DELETE_003 + //stm: @VENUSAUTH_MYSQL_HAS_001, @VENUSAUTH_MYSQL_HAS_002 t.Run("mysql delete token", wrapper(testMySQLDeleteToken, mySQLStore, mock)) // User + //stm: @VENUSAUTH_MYSQL_PUT_USER_001, @VENUSAUTH_MYSQL_UPDATE_USER_002 t.Run("mysql put users", wrapper(testMySQLPutUser, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_UPDATE_USER_001, @VENUSAUTH_MYSQL_INNER_UPDATE_USER_001, @VENUSAUTH_MYSQL_INNER_UPDATE_USER_002 t.Run("mysql update user", wrapper(testMySQLUpdateUser, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_HAS_USER_001, @VENUSAUTH_MYSQL_HAS_USER_002 t.Run("mysql has user", wrapper(testMySQLHasUser, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_GET_USER_001, @VENUSAUTH_MYSQL_INNER_GET_USER_001, @VENUSAUTH_MYSQL_INNER_GET_USER_002 t.Run("mysql get user", wrapper(testMySQLGetUser, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_GET_USER_RECORD_001, @VENUSAUTH_MYSQL_GET_USER_RECORD_002 t.Run("mysql get user record", wrapper(testMySQLGetUserRecord, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_LIST_USERS_001, @VENUSAUTH_MYSQL_LIST_USERS_002 t.Run("mysql list users", wrapper(testMySQLListUsers, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_DELETE_USER_001 t.Run("mysql delete user", wrapper(testMySQLDeleteUser, mySQLStore, mock)) // Rate limit + //stm: @VENUSAUTH_MYSQL_GET_RATE_LIMITS_001 t.Run("mysql get rate limit", wrapper(testMySQLGetRateLimits, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_PUT_RATE_LIMITS_001 t.Run("mysql put rate limit", wrapper(testMySQLPutRateLimits, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_DEL_RATE_LIMITS_001 t.Run("mysql delete rate limit", wrapper(testMySQLDeleteRateLimit, mySQLStore, mock)) // Miner + //stm: @VENUSAUTH_MYSQL_HAS_MINER_001 t.Run("mysql has miner", wrapper(testMySQLHasMiner, mySQLStore, mock)) t.Run("mysql miner exist in user", wrapper(testMySQLMinerExistInUser, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_GET_USER_BY_MINER_001 t.Run("mysql get user by miner", wrapper(testMySQLGetUserByMiner, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_LIST_MINERS_001, @VENUSAUTH_MYSQL_INNER_LIST_MINERS_001 t.Run("mysql list miners", wrapper(testMySQLListMiner, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_DEL_MINER_001, @VENUSAUTH_MYSQL_INNER_DEL_MINER_001 t.Run("mysql delete miner", wrapper(testMySQLDeleteMiner, mySQLStore, mock)) + //stm: @VENUSAUTH_MYSQL_UPSERT_MINER_001 t.Run("mysql upsert miner", wrapper(testMySQLUpsertMiner, mySQLStore, mock)) // Signer @@ -121,15 +160,12 @@ func testMySQLUpdateToken(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sql IsDeleted: 0, } - mock.ExpectBegin() - mock.ExpectExec(regexp.QuoteMeta( - "UPDATE `token` SET `createTime`=?,`extra`=?,`is_deleted`=?,`name`=?,`perm`=?,`secret`=?,`token`=? WHERE token = ?")). - WithArgs(kp.CreateTime, kp.Extra, kp.IsDeleted, kp.Name, kp.Perm, kp.Secret, kp.Token, kp.Token). - WillReturnResult(sqlmock.NewResult(1, 1)) - mock.ExpectCommit() - + sqlMockExpect(mock, "UPDATE", false) err := mySQLStore.UpdateToken(kp) assert.Nil(t, err) + + sqlMockExpect(mock, "UPDATE", true) + assert.Error(t, mySQLStore.UpdateToken(kp)) } func testMySQLHasToken(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -158,6 +194,13 @@ func testMySQLGetToken(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmoc assert.Nil(t, err) assert.Equal(t, name, tokenInfo.Name) assert.Equal(t, token, tokenInfo.Token) + + mock.ExpectQuery(regexp.QuoteMeta( + "SELECT * FROM `token` WHERE token = ? and is_deleted=? LIMIT 1")). + WithArgs(token, core.NotDelete).WillReturnError(simulateError) + _, err = mySQLStore.Get(token) + assert.Equal(t, err, simulateError) + } func testMySQLGetTokenRecord(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -173,6 +216,12 @@ func testMySQLGetTokenRecord(t *testing.T, mySQLStore *mysqlStore, mock sqlmock. assert.Nil(t, err) assert.Equal(t, name, tokenInfo.Name) assert.Equal(t, token, tokenInfo.Token) + + mock.ExpectQuery(regexp.QuoteMeta( + "SELECT * FROM `token` WHERE token = ? LIMIT 1")). + WithArgs(token).WillReturnError(simulateError) + _, err = mySQLStore.GetTokenRecord(token) + assert.Equal(t, err, simulateError) } func testMySQLGetTokenByName(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -189,6 +238,9 @@ func testMySQLGetTokenByName(t *testing.T, mySQLStore *mysqlStore, mock sqlmock. assert.Equal(t, 1, len(tokenInfo)) assert.Equal(t, name, tokenInfo[0].Name) assert.Equal(t, token, tokenInfo[0].Token) + + _, err = mySQLStore.ByName("not-exist-name") + assert.Error(t, err) } func testMySQLListTokens(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -203,6 +255,13 @@ func testMySQLListTokens(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlm tokens, err := mySQLStore.List(skip, limit) assert.Nil(t, err) assert.Equal(t, 1, len(tokens)) + + mock.ExpectQuery(regexp.QuoteMeta( + fmt.Sprintf("SELECT * FROM `token` WHERE is_deleted=? ORDER BY name LIMIT %v OFFSET %v", limit, skip))). + WithArgs(core.NotDelete).WillReturnError(simulateError) + + _, err = mySQLStore.List(skip, limit) + assert.Equal(t, err, simulateError) } func testMySQLDeleteToken(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -222,69 +281,81 @@ func testMySQLDeleteToken(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sql err := mySQLStore.Delete(token) assert.Nil(t, err) + + // simulate `Has` retuens an error + mock.ExpectQuery(regexp.QuoteMeta( + "SELECT count(*) FROM `token` WHERE token=? and is_deleted=?")). + WithArgs(token, core.NotDelete).WillReturnError(simulateError) + assert.Error(t, mySQLStore.Delete(token)) + + // `Has` returns a false + mock.ExpectQuery(regexp.QuoteMeta( + "SELECT count(*) FROM `token` WHERE token=? and is_deleted=?")). + WithArgs(token, core.NotDelete).WillReturnRows( + sqlmock.NewRows([]string{"count"}).AddRow(0)) + assert.Equal(t, mySQLStore.Delete(token), gorm.ErrRecordNotFound) } func testMySQLPutUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { now := time.Now() - id := uuid.NewString() - user := "test_user_001" - - mock.ExpectBegin() - mock.ExpectExec(regexp.QuoteMeta( - "INSERT INTO `users` (`id`,`name`,`comment`,`state`,`createTime`,`updateTime`,`is_deleted`) VALUES (?,?,?,?,?,?,?)")). - WithArgs(id, user, "", 0, now, now, 0). - WillReturnResult(sqlmock.NewResult(1, 1)) - mock.ExpectCommit() - - err := mySQLStore.PutUser(&User{ - Id: id, - Name: user, + user := &User{ + Id: uuid.NewString(), + Name: "test_user_001", UpdateTime: now, CreateTime: now, - }) - assert.Nil(t, err) + } + + op := "INSERT INTO `users`" + + sqlMockExpect(mock, op, false) + assert.Nil(t, mySQLStore.PutUser(user)) + + sqlMockExpect(mock, op, true) + assert.Equal(t, mySQLStore.PutUser(user), simulateError) } func testMySQLUpdateUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { now := time.Now() - id := uuid.NewString() - user := "test_user_001" - - mock.ExpectBegin() - mock.ExpectExec(regexp.QuoteMeta( - "UPDATE `users` SET `name`=?,`comment`=?,`state`=?,`createTime`=?,`updateTime`=?,`is_deleted`=? WHERE `id` = ?")). - WithArgs(user, "", 0, now, now, 0, id). - WillReturnResult(sqlmock.NewResult(1, 1)) - mock.ExpectCommit() - - err := mySQLStore.UpdateUser(&User{ - Id: id, - Name: user, + var newUser = &User{ + Id: uuid.NewString(), + Name: "test_user_001", UpdateTime: now, CreateTime: now, - }) + } + + op := "UPDATE `users`" + + sqlMockExpect(mock, op, false) + err := mySQLStore.UpdateUser(newUser) assert.Nil(t, err) + + sqlMockExpect(mock, op, true) + err = mySQLStore.UpdateUser(newUser) + assert.Equal(t, err, simulateError) } func testMySQLHasUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { user := "test_user_001" - mock.ExpectQuery(regexp.QuoteMeta( - "SELECT count(*) FROM `users` WHERE name=? and is_deleted=?")). - WithArgs(user, core.NotDelete). - WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1)) + op := regexp.QuoteMeta("SELECT count(*) FROM `users`") + mock.ExpectQuery(op).WillReturnRows(sqlmock.NewRows([]string{"count"}).AddRow(1)) exist, err := mySQLStore.HasUser(user) assert.Nil(t, err) assert.True(t, exist) + + mock.ExpectQuery(op).WillReturnError(simulateError) + _, err = mySQLStore.HasUser(user) + assert.Equal(t, err, simulateError) } func testMySQLGetUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { user := "test_user_001" comment := "comment" - mock.ExpectQuery(regexp.QuoteMeta( - "SELECT * FROM `users` WHERE name=? and is_deleted=? LIMIT 1")). + op := regexp.QuoteMeta("SELECT * FROM `users` WHERE name=? and is_deleted=? LIMIT 1") + + mock.ExpectQuery(op). WithArgs(user, core.NotDelete). WillReturnRows(sqlmock.NewRows([]string{"name", "comment"}).AddRow(user, comment)) @@ -292,14 +363,18 @@ func testMySQLGetUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock assert.Nil(t, err) assert.Equal(t, userInfo.Name, user) assert.Equal(t, userInfo.Comment, comment) + + mock.ExpectQuery(op).WillReturnError(simulateError) + _, err = mySQLStore.GetUser(user) + assert.Error(t, err) } func testMySQLGetUserRecord(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { user := "test_user_001" comment := "comment" - mock.ExpectQuery(regexp.QuoteMeta( - "SELECT * FROM `users` WHERE name=? LIMIT 1")). + op := regexp.QuoteMeta("SELECT * FROM `users` WHERE name=? LIMIT 1") + mock.ExpectQuery(op). WithArgs(user). WillReturnRows(sqlmock.NewRows([]string{"name", "comment"}).AddRow(user, comment)) @@ -307,20 +382,27 @@ func testMySQLGetUserRecord(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.S assert.Nil(t, err) assert.Equal(t, userInfo.Name, user) assert.Equal(t, userInfo.Comment, comment) + + mock.ExpectQuery(op).WillReturnError(simulateError) + _, err = mySQLStore.GetUserRecord(user) + assert.Error(t, err) } func testMySQLListUsers(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { var skip int64 = 2 var limit int64 = 10 - mock.ExpectQuery(regexp.QuoteMeta( - fmt.Sprintf("SELECT * FROM `users` WHERE is_deleted=? ORDER BY createTime LIMIT %v OFFSET %v", limit, skip))). - WithArgs(core.NotDelete). - WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("user1").AddRow("user2")) + op := regexp.QuoteMeta("SELECT * FROM `users`") + mock.ExpectQuery(op).WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("user1").AddRow("user2")) users, err := mySQLStore.ListUsers(skip, limit, core.UserStateUndefined) assert.Nil(t, err) assert.Equal(t, 2, len(users)) + + mock.ExpectQuery(op).WillReturnError(simulateError) + _, err = mySQLStore.ListUsers(skip, limit, core.UserStateUndefined) + assert.Error(t, err) + } func testMySQLDeleteUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -688,7 +770,7 @@ func mysqlSetup() (*mysqlStore, sqlmock.Sqlmock, *sql.DB, error) { gormDB, err := gorm.Open(mysql.New(mysql.Config{ Conn: sqlDB, }), &gorm.Config{}) - mySQLStore := &mysqlStore{db: gormDB} + mySQLStore := &mysqlStore{db: gormDB.Debug()} return mySQLStore, mock, sqlDB, err } diff --git a/storage/store.go b/storage/store.go index fd05bdb..90e182f 100644 --- a/storage/store.go +++ b/storage/store.go @@ -328,9 +328,11 @@ func (s *StoreVersion) Bytes() ([]byte, error) { return json.Marshal(s) } +// we are perpose to support limit user requests with `Service`/`Service.API` ferther, +// so we add their declars in `UserRateLimit` type UserRateLimit struct { Id string `gorm:"column:id;type:varchar(64);primary_key"` - Name string `gorm:"column:name;type:varchar(50);index:user_service_api_IDX;not null"` + Name string `gorm:"column:name;type:varchar(50);index:user_service_api_IDX;not null" binding:"required"` Service string `gorm:"column:service;type:varchar(50);index:user_service_api_IDX"` API string `gorm:"column:api;type:varchar(50);index:user_service_api_IDX"` ReqLimit ReqLimit `gorm:"column:reqLimit;type:varchar(256)"` diff --git a/storage/store_test.go b/storage/store_test.go index 71aa30f..ec19fbf 100644 --- a/storage/store_test.go +++ b/storage/store_test.go @@ -1,3 +1,4 @@ +//stm: #unit package storage import ( @@ -6,6 +7,7 @@ import ( "fmt" "io/ioutil" "os" + "strings" "testing" "time" @@ -90,6 +92,9 @@ func testAddUser(t *testing.T) { t.Fatalf("add user failed:%s", err.Error()) } } + users, err := theStore.ListUsers(0, 0, core.UserStateUndefined) + require.NoError(t, err) + require.Equal(t, len(userMiners), len(users)) } func testDeleteUser(t *testing.T) { @@ -98,10 +103,23 @@ func testDeleteUser(t *testing.T) { res, err := theStore.GetUser(userName) require.Nil(t, err) + { + updated := res + updated.State = core.UserStateEnabled + updated.Comment = "new comment" + require.NoError(t, theStore.UpdateUser(updated)) + res, err = theStore.GetUser(res.Name) + require.Equal(t, res.State, updated.State) + require.Equal(t, res.Comment, updated.Comment) + } require.Nil(t, theStore.DeleteUser(userName)) has, err := theStore.HasUser(userName) require.Nil(t, err) require.False(t, has) + + // delete already deleted user + require.Error(t, theStore.DeleteUser(userName)) + _, err = theStore.GetUser(userName) require.Error(t, err) @@ -137,6 +155,13 @@ func testAddMiner(t *testing.T) { require.NoError(t, err) } } + + newAddr, _ := address.NewFromString("f0109988") + + // expects a not found error + _, err := theStore.UpsertMiner(newAddr, "not-exist-user") + require.True(t, strings.Contains(err.Error(), "not exist user")) + require.Error(t, err) } func testListMiners(t *testing.T) { @@ -166,14 +191,14 @@ func testListMiners(t *testing.T) { func testDelMiners(t *testing.T) { for userName, miners := range userMiners { - // already delete user - if userName == "test_user_001" { - continue - } for m := range miners { addr, _ := address.NewFromString(m) _, err := theStore.DelMiner(addr) - require.NoError(t, err) + if userName == "test_user_001" { // already deleted user, expect an error + require.Error(t, err) + } else { + require.NoError(t, err) + } } } } @@ -338,23 +363,34 @@ func testRatelimit(t *testing.T) { require.NoError(t, err) require.Equal(t, 0, len(limit)) } + require.Error(t, theStore.DelRateLimit("", "")) } func TestStore(t *testing.T) { + //stm: @VENUSAUTH_BADGER_PUT_001, @VENUSAUTH_BADGER_PUT_USER_001, @VENUSAUTH_BADGER_LIST_USERS_001 t.Run("add users", testAddUser) + //stm: @VENUSAUTH_BADGER_UPSERT_MINER_001, @VENUSAUTH_BADGER_UPSERT_MINER_002, @VENUSAUTH_BADGER_UPSERT_MINER_003 t.Run("add miners", testAddMiner) + //stm: @VENUSAUTH_BADGER_GET_USER_BY_MINER_001, @VENUSAUTH_BADGER_GET_USER_BY_MINER_002 t.Run("get miners", testListMiners) t.Run("add signers", testAddSigner) t.Run("signer exist in user", testSignerExistInUser) + //stm: @VENUSAUTH_BADGER_HAS_001 t.Run("has signer", testHasSigner) t.Run("list signers", testListSigners) t.Run("get user by signer", testGetUserBySigner) + //stm: @VENUSAUTH_BADGER_DELETE_001, @VENUSAUTH_BADGER_GET_USER_001, @VENUSAUTH_BADGER_GET_USER_RECORD_001, @VENUSAUTH_BADGER_UPDATE_USER_001 + //stm: @VENUSAUTH_BADGER_HAS_USER_001, @VENUSAUTH_BADGER_HAS_MINER_001, @VENUSAUTH_BADGER_DELETE_USER_001 + //stm: @VENUSAUTH_BADGER_DELETE_USER_003 t.Run("del user", testDeleteUser) + //stm: @VENUSAUTH_BADGER_DEL_MINER_001, @VENUSAUTH_BADGER_DEL_MINER_002 t.Run("del miners", testDelMiners) t.Run("unregister signer", testUnregisterSigner) t.Run("del signers", testDelSigners) + //stm: @VENUSAUTH_BADGER_HAS_001, @VENUSAUTH_BADGER_GET_001, @VENUSAUTH_BADGER_BY_NAME_001, @VENUSAUTH_BADGER_LIST_001 t.Run("test token", testTokens) + //stm: @VENUSAUTH_BADGER_GET_RATE_LIMITS_001, @VENUSAUTH_BADGER_DEL_RATE_LIMITS_001, @VENUSAUTH_BADGER_DEL_RATE_LIMITS_002 t.Run("test ratelimit", testRatelimit) } From 026f7fa8a2a7902bd6f94753876bed9e61437c11 Mon Sep 17 00:00:00 2001 From: zl Date: Thu, 22 Sep 2022 00:14:40 +0800 Subject: [PATCH 2/5] fix: ci lint --- auth/jwt_test.go | 2 +- integrate_test/token_test.go | 1 - storage/mysql_test.go | 34 ++++++++++++++++------------------ storage/store.go | 2 +- storage/store_test.go | 2 ++ 5 files changed, 20 insertions(+), 21 deletions(-) diff --git a/auth/jwt_test.go b/auth/jwt_test.go index e41ecaf..5d0b28d 100644 --- a/auth/jwt_test.go +++ b/auth/jwt_test.go @@ -28,7 +28,7 @@ func TestJwt(t *testing.T) { var originLimits []*storage.UserRateLimit if err := json.Unmarshal([]byte(limitStrs), &originLimits); err != nil { - t.Fatal(fmt.Sprintf("initialize origin Ratelimit failed:%s", err.Error())) + t.Fatalf("initialize origin Ratelimit failed:%s", err.Error()) } var userMiners = map[string][]string{ diff --git a/integrate_test/token_test.go b/integrate_test/token_test.go index 3d9678f..4df5749 100644 --- a/integrate_test/token_test.go +++ b/integrate_test/token_test.go @@ -1,4 +1,3 @@ -//stm: #integration package integrate import ( diff --git a/storage/mysql_test.go b/storage/mysql_test.go index 6c89598..56b1dfe 100644 --- a/storage/mysql_test.go +++ b/storage/mysql_test.go @@ -21,13 +21,13 @@ import ( type anyTime struct{} -var simulateError = fmt.Errorf("just simulate an error") +var errSimulated = fmt.Errorf("just simulate an error") func sqlMockExpect(m sqlmock.Sqlmock, prefix string, fail bool) { m.ExpectBegin() exe := m.ExpectExec(regexp.QuoteMeta(prefix)) if fail { - exe.WillReturnError(simulateError) + exe.WillReturnError(errSimulated) m.ExpectRollback() return } @@ -52,7 +52,6 @@ func TestMysqlStore(t *testing.T) { if err != nil { t.Fatal(err) } - // Token //stm: @VENUSAUTH_MYSQL_PUT_001 t.Run("mysql put token", wrapper(testMySQLPutToken, mySQLStore, mock)) @@ -197,10 +196,9 @@ func testMySQLGetToken(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmoc mock.ExpectQuery(regexp.QuoteMeta( "SELECT * FROM `token` WHERE token = ? and is_deleted=? LIMIT 1")). - WithArgs(token, core.NotDelete).WillReturnError(simulateError) + WithArgs(token, core.NotDelete).WillReturnError(errSimulated) _, err = mySQLStore.Get(token) - assert.Equal(t, err, simulateError) - + assert.Error(t, err) } func testMySQLGetTokenRecord(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -219,9 +217,9 @@ func testMySQLGetTokenRecord(t *testing.T, mySQLStore *mysqlStore, mock sqlmock. mock.ExpectQuery(regexp.QuoteMeta( "SELECT * FROM `token` WHERE token = ? LIMIT 1")). - WithArgs(token).WillReturnError(simulateError) + WithArgs(token).WillReturnError(errSimulated) _, err = mySQLStore.GetTokenRecord(token) - assert.Equal(t, err, simulateError) + assert.Error(t, err) } func testMySQLGetTokenByName(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -258,10 +256,10 @@ func testMySQLListTokens(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlm mock.ExpectQuery(regexp.QuoteMeta( fmt.Sprintf("SELECT * FROM `token` WHERE is_deleted=? ORDER BY name LIMIT %v OFFSET %v", limit, skip))). - WithArgs(core.NotDelete).WillReturnError(simulateError) + WithArgs(core.NotDelete).WillReturnError(errSimulated) _, err = mySQLStore.List(skip, limit) - assert.Equal(t, err, simulateError) + assert.Error(t, err) } func testMySQLDeleteToken(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -285,7 +283,7 @@ func testMySQLDeleteToken(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sql // simulate `Has` retuens an error mock.ExpectQuery(regexp.QuoteMeta( "SELECT count(*) FROM `token` WHERE token=? and is_deleted=?")). - WithArgs(token, core.NotDelete).WillReturnError(simulateError) + WithArgs(token, core.NotDelete).WillReturnError(errSimulated) assert.Error(t, mySQLStore.Delete(token)) // `Has` returns a false @@ -311,7 +309,7 @@ func testMySQLPutUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock assert.Nil(t, mySQLStore.PutUser(user)) sqlMockExpect(mock, op, true) - assert.Equal(t, mySQLStore.PutUser(user), simulateError) + assert.Error(t, mySQLStore.PutUser(user)) } func testMySQLUpdateUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -331,7 +329,7 @@ func testMySQLUpdateUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlm sqlMockExpect(mock, op, true) err = mySQLStore.UpdateUser(newUser) - assert.Equal(t, err, simulateError) + assert.Error(t, err) } func testMySQLHasUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -344,9 +342,9 @@ func testMySQLHasUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock assert.Nil(t, err) assert.True(t, exist) - mock.ExpectQuery(op).WillReturnError(simulateError) + mock.ExpectQuery(op).WillReturnError(errSimulated) _, err = mySQLStore.HasUser(user) - assert.Equal(t, err, simulateError) + assert.Error(t, err) } func testMySQLGetUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { @@ -364,7 +362,7 @@ func testMySQLGetUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock assert.Equal(t, userInfo.Name, user) assert.Equal(t, userInfo.Comment, comment) - mock.ExpectQuery(op).WillReturnError(simulateError) + mock.ExpectQuery(op).WillReturnError(errSimulated) _, err = mySQLStore.GetUser(user) assert.Error(t, err) } @@ -383,7 +381,7 @@ func testMySQLGetUserRecord(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.S assert.Equal(t, userInfo.Name, user) assert.Equal(t, userInfo.Comment, comment) - mock.ExpectQuery(op).WillReturnError(simulateError) + mock.ExpectQuery(op).WillReturnError(errSimulated) _, err = mySQLStore.GetUserRecord(user) assert.Error(t, err) } @@ -399,7 +397,7 @@ func testMySQLListUsers(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmo assert.Nil(t, err) assert.Equal(t, 2, len(users)) - mock.ExpectQuery(op).WillReturnError(simulateError) + mock.ExpectQuery(op).WillReturnError(errSimulated) _, err = mySQLStore.ListUsers(skip, limit, core.UserStateUndefined) assert.Error(t, err) diff --git a/storage/store.go b/storage/store.go index 90e182f..82088e5 100644 --- a/storage/store.go +++ b/storage/store.go @@ -329,7 +329,7 @@ func (s *StoreVersion) Bytes() ([]byte, error) { } // we are perpose to support limit user requests with `Service`/`Service.API` ferther, -// so we add their declars in `UserRateLimit` +// so we add their declar in `UserRateLimit` type UserRateLimit struct { Id string `gorm:"column:id;type:varchar(64);primary_key"` Name string `gorm:"column:name;type:varchar(50);index:user_service_api_IDX;not null" binding:"required"` diff --git a/storage/store_test.go b/storage/store_test.go index ec19fbf..95e59ae 100644 --- a/storage/store_test.go +++ b/storage/store_test.go @@ -108,7 +108,9 @@ func testDeleteUser(t *testing.T) { updated.State = core.UserStateEnabled updated.Comment = "new comment" require.NoError(t, theStore.UpdateUser(updated)) + res, err = theStore.GetUser(res.Name) + require.NoError(t, err) require.Equal(t, res.State, updated.State) require.Equal(t, res.Comment, updated.Comment) } From 09642359401ea988c56bf5fde9cd1bf1e694ae1e Mon Sep 17 00:00:00 2001 From: zl Date: Thu, 22 Sep 2022 10:49:29 +0800 Subject: [PATCH 3/5] opt: minor optmization on sqlmock expect function --- storage/mysql_test.go | 45 ++++++++++++++++++++++++++++--------------- 1 file changed, 29 insertions(+), 16 deletions(-) diff --git a/storage/mysql_test.go b/storage/mysql_test.go index 56b1dfe..86298a1 100644 --- a/storage/mysql_test.go +++ b/storage/mysql_test.go @@ -23,15 +23,21 @@ type anyTime struct{} var errSimulated = fmt.Errorf("just simulate an error") -func sqlMockExpect(m sqlmock.Sqlmock, prefix string, fail bool) { +func sqlMockExpect(m sqlmock.Sqlmock, sql string, fail bool, params ...driver.Value) { m.ExpectBegin() - exe := m.ExpectExec(regexp.QuoteMeta(prefix)) + exe := m.ExpectExec(regexp.QuoteMeta(sql)) + + if len(params) > 0 { + exe = exe.WithArgs(params...) + } + if fail { - exe.WillReturnError(errSimulated) + exe = exe.WillReturnError(errSimulated) m.ExpectRollback() return } - exe.WillReturnResult(sqlmock.NewResult(1, 1)) + + exe = exe.WillReturnResult(sqlmock.NewResult(1, 1)) m.ExpectCommit() } @@ -159,11 +165,14 @@ func testMySQLUpdateToken(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sql IsDeleted: 0, } - sqlMockExpect(mock, "UPDATE", false) + sql := "UPDATE `token` SET `createTime`=?,`extra`=?,`is_deleted`=?,`name`=?,`perm`=?,`secret`=?,`token`=? WHERE token = ?" + sqlMockExpect(mock, sql, false, + kp.CreateTime, kp.Extra, kp.IsDeleted, kp.Name, kp.Perm, kp.Secret, kp.Token, kp.Token) err := mySQLStore.UpdateToken(kp) assert.Nil(t, err) - sqlMockExpect(mock, "UPDATE", true) + sqlMockExpect(mock, sql, true, + kp.CreateTime, kp.Extra, kp.IsDeleted, kp.Name, kp.Perm, kp.Secret, kp.Token, kp.Token) assert.Error(t, mySQLStore.UpdateToken(kp)) } @@ -303,32 +312,36 @@ func testMySQLPutUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock CreateTime: now, } - op := "INSERT INTO `users`" - - sqlMockExpect(mock, op, false) + sql := "INSERT INTO `users` (`id`,`name`,`comment`,`state`,`createTime`,`updateTime`,`is_deleted`) VALUES (?,?,?,?,?,?,?)" + sqlMockExpect(mock, sql, false, + user.Id, user.Name, user.Comment, user.State, user.CreateTime, user.UpdateTime, user.IsDeleted) assert.Nil(t, mySQLStore.PutUser(user)) - sqlMockExpect(mock, op, true) + sqlMockExpect(mock, sql, true, + user.Id, user.Name, user.Comment, user.State, user.CreateTime, user.UpdateTime, user.IsDeleted) assert.Error(t, mySQLStore.PutUser(user)) } func testMySQLUpdateUser(t *testing.T, mySQLStore *mysqlStore, mock sqlmock.Sqlmock) { now := time.Now() - var newUser = &User{ + var user = &User{ Id: uuid.NewString(), Name: "test_user_001", UpdateTime: now, CreateTime: now, + IsDeleted: core.NotDelete, } - op := "UPDATE `users`" + sql := "UPDATE `users` SET `name`=?,`comment`=?,`state`=?,`createTime`=?,`updateTime`=?,`is_deleted`=? WHERE `id` = ?" - sqlMockExpect(mock, op, false) - err := mySQLStore.UpdateUser(newUser) + sqlMockExpect(mock, sql, false, + user.Name, user.Comment, user.State, user.CreateTime, user.UpdateTime, user.IsDeleted, user.Id) + err := mySQLStore.UpdateUser(user) assert.Nil(t, err) - sqlMockExpect(mock, op, true) - err = mySQLStore.UpdateUser(newUser) + sqlMockExpect(mock, sql, true, + user.Name, user.Comment, user.State, user.CreateTime, user.UpdateTime, user.IsDeleted, user.Id) + err = mySQLStore.UpdateUser(user) assert.Error(t, err) } From 09fe770e2938b6c1b35d7d979bb6d192d7809aee Mon Sep 17 00:00:00 2001 From: zl Date: Thu, 22 Sep 2022 11:09:37 +0800 Subject: [PATCH 4/5] refactor: reuse context in jwt unit tests. --- auth/jwt_test.go | 124 ++++++++++++++++++++++++++--------------------- 1 file changed, 70 insertions(+), 54 deletions(-) diff --git a/auth/jwt_test.go b/auth/jwt_test.go index 5d0b28d..dbf6cc0 100644 --- a/auth/jwt_test.go +++ b/auth/jwt_test.go @@ -122,7 +122,7 @@ func testVerifyToken(t *testing.T) { Perm: "admin", Extra: "", } - ctx := context.TODO() + ctx := context.Background() token1, err := jwtOAuthInstance.GenerateToken(ctx, pl1) assert.Nil(t, err) @@ -148,17 +148,18 @@ func testGetToken(t *testing.T) { Perm: "admin", Extra: "", } - token1, err := jwtOAuthInstance.GenerateToken(context.Background(), pl1) + ctx := context.Background() + token1, err := jwtOAuthInstance.GenerateToken(ctx, pl1) assert.Nil(t, err) // Get token - tokenInfo1, err := jwtOAuthInstance.GetToken(context.Background(), token1) + tokenInfo1, err := jwtOAuthInstance.GetToken(ctx, token1) assert.Nil(t, err) assert.Equal(t, pl1.Name, tokenInfo1.Name) assert.Equal(t, pl1.Perm, tokenInfo1.Perm) // Try to get invalid token invalidToken := "I'm just an invalid token" - _, err = jwtOAuthInstance.GetToken(context.Background(), invalidToken) + _, err = jwtOAuthInstance.GetToken(ctx, invalidToken) assert.NotNil(t, err) } @@ -173,16 +174,17 @@ func testGetTokenByName(t *testing.T) { Perm: "admin", Extra: "", } - token1, err := jwtOAuthInstance.GenerateToken(context.Background(), pl1) + ctx := context.Background() + token1, err := jwtOAuthInstance.GenerateToken(ctx, pl1) assert.Nil(t, err) // Get token by name - tokenInfoList1, err := jwtOAuthInstance.GetTokenByName(context.Background(), "test-token-01") + tokenInfoList1, err := jwtOAuthInstance.GetTokenByName(ctx, "test-token-01") assert.Nil(t, err) assert.Equal(t, 1, len(tokenInfoList1)) assert.Equal(t, token1, tokenInfoList1[0].Token) // Try to get token by wrong name - tokenInfoInvalid, err := jwtOAuthInstance.GetTokenByName(context.Background(), "invalid_name") + tokenInfoInvalid, err := jwtOAuthInstance.GetTokenByName(ctx, "invalid_name") assert.Nil(t, err) assert.Equal(t, 0, len(tokenInfoInvalid)) } @@ -203,24 +205,25 @@ func testTokenList(t *testing.T) { Perm: "admin", Extra: "", } - _, err := jwtOAuthInstance.GenerateToken(context.Background(), pl1) + ctx := context.Background() + _, err := jwtOAuthInstance.GenerateToken(ctx, pl1) assert.Nil(t, err) - _, err = jwtOAuthInstance.GenerateToken(context.Background(), pl2) + _, err = jwtOAuthInstance.GenerateToken(ctx, pl2) assert.Nil(t, err) - allTokenInfos, err := jwtOAuthInstance.Tokens(context.Background(), 0, 2) + allTokenInfos, err := jwtOAuthInstance.Tokens(ctx, 0, 2) assert.Nil(t, err) assert.Equal(t, 2, len(allTokenInfos)) // with skip or limit - allTokenInfos, err = jwtOAuthInstance.Tokens(context.Background(), 1, 10) + allTokenInfos, err = jwtOAuthInstance.Tokens(ctx, 1, 10) assert.Nil(t, err) assert.Equal(t, 1, len(allTokenInfos)) - allTokenInfos, err = jwtOAuthInstance.Tokens(context.Background(), 0, 1) + allTokenInfos, err = jwtOAuthInstance.Tokens(ctx, 0, 1) assert.Nil(t, err) assert.Equal(t, 1, len(allTokenInfos)) - allTokenInfos, err = jwtOAuthInstance.Tokens(context.Background(), 2, 10) + allTokenInfos, err = jwtOAuthInstance.Tokens(ctx, 2, 10) assert.Nil(t, err) assert.Equal(t, 0, len(allTokenInfos)) } @@ -236,7 +239,7 @@ func testRemoveAndRecoverToken(t *testing.T) { Perm: "admin", Extra: "", } - ctx := context.TODO() + ctx := context.Background() token1, err := jwtOAuthInstance.GenerateToken(ctx, pl1) assert.Nil(t, err) @@ -245,35 +248,36 @@ func testRemoveAndRecoverToken(t *testing.T) { assert.Error(t, err) // Remove a token - err = jwtOAuthInstance.RemoveToken(context.Background(), token1) + err = jwtOAuthInstance.RemoveToken(ctx, token1) assert.Nil(t, err) - _, err = jwtOAuthInstance.Verify(context.Background(), token1) + _, err = jwtOAuthInstance.Verify(ctx, token1) assert.NotNil(t, err) - tokenInfoList1, err := jwtOAuthInstance.GetTokenByName(context.Background(), "test-token-01") + tokenInfoList1, err := jwtOAuthInstance.GetTokenByName(ctx, "test-token-01") assert.Nil(t, err) assert.Equal(t, 0, len(tokenInfoList1)) // Recover a token - err = jwtOAuthInstance.RecoverToken(context.Background(), token1) + err = jwtOAuthInstance.RecoverToken(ctx, token1) assert.Nil(t, err) - payload1, err := jwtOAuthInstance.Verify(context.Background(), token1) + payload1, err := jwtOAuthInstance.Verify(ctx, token1) assert.Nil(t, err) assert.True(t, reflect.DeepEqual(payload1, pl1)) - allTokenInfos, err := jwtOAuthInstance.Tokens(context.Background(), 0, 2) + allTokenInfos, err := jwtOAuthInstance.Tokens(ctx, 0, 2) assert.Nil(t, err) assert.Equal(t, 1, len(allTokenInfos)) } func createUsers(t *testing.T, userMiners map[string][]string) { + ctx := context.Background() // Create 3 users for userName := range userMiners { createUserReq := &CreateUserRequest{ Name: userName, State: 0, } - resp, err := jwtOAuthInstance.CreateUser(context.Background(), createUserReq) + resp, err := jwtOAuthInstance.CreateUser(ctx, createUserReq) assert.Nil(t, err) assert.Equal(t, userName, resp.Name) assert.Equal(t, "", resp.Comment) @@ -285,6 +289,8 @@ func testCreateUser(t *testing.T, userMiners map[string][]string) { setup(&cfg, t) defer shutdown(&cfg, t) + ctx := context.Background() + existUserName := "test_user_001" comment := "test comment" // Create 3 users @@ -294,13 +300,13 @@ func testCreateUser(t *testing.T, userMiners map[string][]string) { Comment: &comment, State: 0, } - resp, err := jwtOAuthInstance.CreateUser(context.Background(), createUserReq) + resp, err := jwtOAuthInstance.CreateUser(ctx, createUserReq) assert.Nil(t, err) assert.Equal(t, userName, resp.Name) assert.Equal(t, "test comment", resp.Comment) } // Create duplicate user - _, err := jwtOAuthInstance.CreateUser(context.Background(), &CreateUserRequest{Name: existUserName}) + _, err := jwtOAuthInstance.CreateUser(ctx, &CreateUserRequest{Name: existUserName}) assert.NotNil(t, err) } @@ -313,7 +319,7 @@ func testGetUser(t *testing.T, userMiners map[string][]string) { defer shutdown(&cfg, t) createUsers(t, userMiners) - ctx := context.TODO() + ctx := context.Background() // HasUser exist, err := jwtOAuthInstance.HasUser(ctx, &HasUserRequest{Name: existUserName}) assert.Nil(t, err) @@ -355,15 +361,16 @@ func testUpdateUser(t *testing.T, userMiners map[string][]string) { Name: existUserName, Comment: &comment, } - err := jwtOAuthInstance.UpdateUser(context.Background(), updateUserReq) + ctx := context.Background() + err := jwtOAuthInstance.UpdateUser(ctx, updateUserReq) assert.Nil(t, err) // Then get this user - outPutUser1, err := jwtOAuthInstance.GetUser(context.Background(), &GetUserRequest{Name: existUserName}) + outPutUser1, err := jwtOAuthInstance.GetUser(ctx, &GetUserRequest{Name: existUserName}) assert.Nil(t, err) assert.Equal(t, "New Comment", outPutUser1.Comment) // invalid user name - err = jwtOAuthInstance.UpdateUser(context.Background(), &UpdateUserRequest{}) + err = jwtOAuthInstance.UpdateUser(ctx, &UpdateUserRequest{}) assert.Error(t, err) } @@ -376,14 +383,16 @@ func testDeleteAndRecoverUser(t *testing.T, userMiners map[string][]string) { defer shutdown(&cfg, t) createUsers(t, userMiners) + ginCtx := &gin.Context{} + // Delete User - err := jwtOAuthInstance.DeleteUser(&gin.Context{}, &DeleteUserRequest{Name: existUserName}) + err := jwtOAuthInstance.DeleteUser(ginCtx, &DeleteUserRequest{Name: existUserName}) assert.Nil(t, err) // Then try to get this user - _, err = jwtOAuthInstance.GetUser(context.Background(), &GetUserRequest{Name: existUserName}) + _, err = jwtOAuthInstance.GetUser(ginCtx, &GetUserRequest{Name: existUserName}) assert.NotNil(t, err) // And also list users now - allUserInfos, err := jwtOAuthInstance.ListUsers(context.Background(), &ListUsersRequest{ + allUserInfos, err := jwtOAuthInstance.ListUsers(ginCtx, &ListUsersRequest{ Page: &core.Page{}, State: int(core.UserStateUndefined), }) @@ -391,37 +400,38 @@ func testDeleteAndRecoverUser(t *testing.T, userMiners map[string][]string) { assert.Equal(t, 2, len(allUserInfos)) // Try to delete non-existing users - err = jwtOAuthInstance.DeleteUser(&gin.Context{}, &DeleteUserRequest{Name: invalidUserName}) + err = jwtOAuthInstance.DeleteUser(ginCtx, &DeleteUserRequest{Name: invalidUserName}) assert.NotNil(t, err) // Recover user - err = jwtOAuthInstance.RecoverUser(&gin.Context{}, &RecoverUserRequest{Name: existUserName}) + err = jwtOAuthInstance.RecoverUser(ginCtx, &RecoverUserRequest{Name: existUserName}) assert.Nil(t, err) // Then get this user - outPutUser1, err := jwtOAuthInstance.GetUser(context.Background(), &GetUserRequest{Name: existUserName}) + outPutUser1, err := jwtOAuthInstance.GetUser(ginCtx, &GetUserRequest{Name: existUserName}) assert.Nil(t, err) assert.Equal(t, existUserName, outPutUser1.Name) // Try to recover an invalid user - err = jwtOAuthInstance.RecoverUser(&gin.Context{}, &RecoverUserRequest{Name: invalidUserName}) + err = jwtOAuthInstance.RecoverUser(ginCtx, &RecoverUserRequest{Name: invalidUserName}) assert.NotNil(t, err) // Try to recover a valid, but not deleted user - err = jwtOAuthInstance.RecoverUser(&gin.Context{}, &RecoverUserRequest{Name: existUserName}) + err = jwtOAuthInstance.RecoverUser(ginCtx, &RecoverUserRequest{Name: existUserName}) assert.NotNil(t, err) } func addUsersAndMiners(t *testing.T, userMiners map[string][]string) { + ctx := context.Background() for userName, miners := range userMiners { createUserReq := &CreateUserRequest{ Name: userName, State: 0, } // Create users. - _, _ = jwtOAuthInstance.CreateUser(context.Background(), createUserReq) + _, _ = jwtOAuthInstance.CreateUser(ctx, createUserReq) // Add miners for _, minerID := range miners { - ifCreate, err := jwtOAuthInstance.UpsertMiner(context.Background(), &UpsertMinerReq{ + ifCreate, err := jwtOAuthInstance.UpsertMiner(ctx, &UpsertMinerReq{ User: userName, Miner: minerID, }) @@ -437,7 +447,7 @@ func testUpsertMiner(t *testing.T, userMiners map[string][]string) { defer shutdown(&cfg, t) addUsersAndMiners(t, userMiners) - var ctx = context.TODO() + var ctx = context.Background() // error signer address _, _ = jwtOAuthInstance.CreateUser(ctx, &CreateUserRequest{ Name: "user_01", @@ -463,7 +473,7 @@ func testListMiner(t *testing.T, userMiners map[string][]string) { validUser1 := "test_user_001" user1Miners := []string{"t01000", "t01002", "t01003"} - ctx := context.TODO() + ctx := context.Background() // List miners resp, err := jwtOAuthInstance.ListMiners(ctx, &ListMinerReq{User: validUser1}) assert.Nil(t, err) @@ -481,21 +491,23 @@ func testHasMiner(t *testing.T, userMiners map[string][]string) { defer shutdown(&cfg, t) addUsersAndMiners(t, userMiners) + ctx := context.Background() + // Has Miner - has, err := jwtOAuthInstance.HasMiner(context.Background(), &HasMinerRequest{Miner: "t01000"}) + has, err := jwtOAuthInstance.HasMiner(ctx, &HasMinerRequest{Miner: "t01000"}) assert.Nil(t, err) assert.True(t, has) // Miner Exist In Account - exist, err := jwtOAuthInstance.MinerExistInUser(context.Background(), &MinerExistInUserRequest{Miner: "t01000", User: "test_user_001"}) + exist, err := jwtOAuthInstance.MinerExistInUser(ctx, &MinerExistInUserRequest{Miner: "t01000", User: "test_user_001"}) assert.Nil(t, err) assert.True(t, exist) - exist, err = jwtOAuthInstance.MinerExistInUser(context.Background(), &MinerExistInUserRequest{Miner: "t01000", User: "test_user_002"}) + exist, err = jwtOAuthInstance.MinerExistInUser(ctx, &MinerExistInUserRequest{Miner: "t01000", User: "test_user_002"}) assert.Nil(t, err) assert.False(t, exist) - _, err = jwtOAuthInstance.HasMiner(context.Background(), &HasMinerRequest{Miner: "invalid address"}) + _, err = jwtOAuthInstance.HasMiner(ctx, &HasMinerRequest{Miner: "invalid address"}) assert.Error(t, err) } @@ -505,7 +517,7 @@ func testGetUserByMiner(t *testing.T, userMiners map[string][]string) { defer shutdown(&cfg, t) addUsersAndMiners(t, userMiners) - ctx := context.TODO() + ctx := context.Background() // Get User By Miner validUser1 := "test_user_001" user1Miners := []string{"t01000", "t01002", "t01003"} @@ -536,7 +548,7 @@ func testDeleteMiner(t *testing.T, userMiners map[string][]string) { user1Miners := []string{"t01000", "t01002", "t01003"} invalidMiner := "t02000" - ctx := context.TODO() + ctx := context.Background() // Delete miner deleted, err := jwtOAuthInstance.DelMiner(ctx, &DelMinerReq{Miner: user1Miners[0]}) assert.Nil(t, err) @@ -564,7 +576,7 @@ func addUsersAndSigners(t *testing.T, userSigners map[string][]string) { State: 1, } - ctx := context.TODO() + ctx := context.Background() // Create users. _, _ = jwtOAuthInstance.CreateUser(ctx, createUserReq) // Add Signer @@ -650,12 +662,13 @@ func testHasSigner(t *testing.T, userSigners map[string][]string) { setup(&cfg, t) defer shutdown(&cfg, t) addUsersAndSigners(t, userSigners) + ctx := context.Background() - has, err := jwtOAuthInstance.HasSigner(context.Background(), &HasSignerReq{Signer: "t15rynkupqyfx5ebvaishg7duutwb5ooq2qpaikua"}) + has, err := jwtOAuthInstance.HasSigner(ctx, &HasSignerReq{Signer: "t15rynkupqyfx5ebvaishg7duutwb5ooq2qpaikua"}) assert.Nil(t, err) assert.True(t, has) - has, err = jwtOAuthInstance.HasSigner(context.Background(), &HasSignerReq{Signer: "f3r72mrymha6wrtb6dzynkzjbnl572az27ddbiq3aovj3d235h2jjgsya4afbf3d37vzfbtsy3dssfnitnhklq"}) + has, err = jwtOAuthInstance.HasSigner(ctx, &HasSignerReq{Signer: "f3r72mrymha6wrtb6dzynkzjbnl572az27ddbiq3aovj3d235h2jjgsya4afbf3d37vzfbtsy3dssfnitnhklq"}) assert.Nil(t, err) assert.False(t, has) } @@ -720,22 +733,23 @@ func testDeleteSigner(t *testing.T, userSigners map[string][]string) { assert.True(t, deleted) // Then get this signer - has, err := jwtOAuthInstance.HasSigner(context.Background(), &HasSignerReq{Signer: signer}) + has, err := jwtOAuthInstance.HasSigner(ctx, &HasSignerReq{Signer: signer}) assert.Nil(t, err) assert.False(t, has) } func addUsersAndRateLimits(t *testing.T, userMiners map[string][]string, originLimits []*storage.UserRateLimit) { + ctx := context.Background() // Create 3 users and add rate limits for userName := range userMiners { createUserReq := &CreateUserRequest{ Name: userName, State: 0, } - _, _ = jwtOAuthInstance.CreateUser(context.Background(), createUserReq) + _, _ = jwtOAuthInstance.CreateUser(ctx, createUserReq) } for _, limit := range originLimits { - id, err := jwtOAuthInstance.UpsertUserRateLimit(context.Background(), &UpsertUserRateLimitReq{ + id, err := jwtOAuthInstance.UpsertUserRateLimit(ctx, &UpsertUserRateLimitReq{ Id: limit.Id, Name: limit.Name, Service: limit.Service, @@ -782,20 +796,22 @@ func testDeleteUserRateLimits(t *testing.T, userMiners map[string][]string, orig userName := originLimits[0].Name existId := originLimits[0].Id - err := jwtOAuthInstance.DelUserRateLimit(context.Background(), &DelUserRateLimitReq{ + ctx := context.Background() + + err := jwtOAuthInstance.DelUserRateLimit(ctx, &DelUserRateLimitReq{ Name: userName, Id: existId, }) assert.Nil(t, err) // Try to get it again - resp, err := jwtOAuthInstance.GetUserRateLimits(context.Background(), &GetUserRateLimitsReq{ + resp, err := jwtOAuthInstance.GetUserRateLimits(ctx, &GetUserRateLimitsReq{ Id: existId, Name: userName, }) assert.Nil(t, err) assert.Equal(t, 0, len(resp)) // Try to delete again - err = jwtOAuthInstance.DelUserRateLimit(context.Background(), &DelUserRateLimitReq{ + err = jwtOAuthInstance.DelUserRateLimit(ctx, &DelUserRateLimitReq{ Name: userName, Id: existId, }) From fb52724e5cab8e2bf52dab8675475514207c1e3b Mon Sep 17 00:00:00 2001 From: zl Date: Thu, 22 Sep 2022 11:11:43 +0800 Subject: [PATCH 5/5] fix: makes lint check happy --- storage/mysql_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/storage/mysql_test.go b/storage/mysql_test.go index 86298a1..d8689ee 100644 --- a/storage/mysql_test.go +++ b/storage/mysql_test.go @@ -32,12 +32,12 @@ func sqlMockExpect(m sqlmock.Sqlmock, sql string, fail bool, params ...driver.Va } if fail { - exe = exe.WillReturnError(errSimulated) + exe.WillReturnError(errSimulated) m.ExpectRollback() return } - exe = exe.WillReturnResult(sqlmock.NewResult(1, 1)) + exe.WillReturnResult(sqlmock.NewResult(1, 1)) m.ExpectCommit() }