IntenseWebs/grafana
3
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-02-25 18:55:37 -06:00
Code Issues Packages Projects Releases Wiki Activity

Chore: Add context to team (#40504)

Browse Source 
* Add ctx to team

* Remove convey from team
This commit is contained in:
idafurjes 2021-10-18 14:02:39 +02:00 committed by GitHub
parent a531c6e26f
commit 5a087d2708
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 213 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
pkg/api/team.go
View File

@ -55,7 +55,7 @@ func (hs *HTTPServer) UpdateTeam(c *models.ReqContext, cmd models.UpdateTeamComm
return response.Error(403, "Not allowed to update team", err) return response.Error(403, "Not allowed to update team", err)
} }
if err := hs.Bus.Dispatch(&cmd); err != nil { if err := hs.Bus.DispatchCtx(c.Req.Context(), &cmd); err != nil {
if errors.Is(err, models.ErrTeamNameTaken) { if errors.Is(err, models.ErrTeamNameTaken) {
return response.Error(400, "Team name taken", err) return response.Error(400, "Team name taken", err)
} }
@ -75,7 +75,7 @@ func (hs *HTTPServer) DeleteTeamByID(c *models.ReqContext) response.Response {
return response.Error(403, "Not allowed to delete team", err) return response.Error(403, "Not allowed to delete team", err)
} }
if err := hs.Bus.Dispatch(&models.DeleteTeamCommand{OrgId: orgId, Id: teamId}); err != nil { if err := hs.Bus.DispatchCtx(c.Req.Context(), &models.DeleteTeamCommand{OrgId: orgId, Id: teamId}); err != nil {
if errors.Is(err, models.ErrTeamNotFound) { if errors.Is(err, models.ErrTeamNotFound) {
return response.Error(404, "Failed to delete Team. ID not found", nil) return response.Error(404, "Failed to delete Team. ID not found", nil)
} }
@ -111,7 +111,7 @@ func (hs *HTTPServer) SearchTeams(c *models.ReqContext) response.Response {
HiddenUsers: hs.Cfg.HiddenUsers, HiddenUsers: hs.Cfg.HiddenUsers,
} }
if err := bus.Dispatch(&query); err != nil { if err := bus.DispatchCtx(c.Req.Context(), &query); err != nil {
return response.Error(500, "Failed to search Teams", err) return response.Error(500, "Failed to search Teams", err)
} }
@ -134,7 +134,7 @@ func (hs *HTTPServer) GetTeamByID(c *models.ReqContext) response.Response {
HiddenUsers: hs.Cfg.HiddenUsers, HiddenUsers: hs.Cfg.HiddenUsers,
} }
if err := bus.Dispatch(&query); err != nil { if err := bus.DispatchCtx(c.Req.Context(), &query); err != nil {
if errors.Is(err, models.ErrTeamNotFound) { if errors.Is(err, models.ErrTeamNotFound) {
return response.Error(404, "Team not found", err) return response.Error(404, "Team not found", err)
} }

6
pkg/api/team_members.go
View File

@ -16,7 +16,7 @@ import (
func (hs *HTTPServer) GetTeamMembers(c *models.ReqContext) response.Response { func (hs *HTTPServer) GetTeamMembers(c *models.ReqContext) response.Response {
query := models.GetTeamMembersQuery{OrgId: c.OrgId, TeamId: c.ParamsInt64(":teamId")} query := models.GetTeamMembersQuery{OrgId: c.OrgId, TeamId: c.ParamsInt64(":teamId")}
if err := bus.Dispatch(&query); err != nil { if err := bus.DispatchCtx(c.Req.Context(), &query); err != nil {
return response.Error(500, "Failed to get Team Members", err) return response.Error(500, "Failed to get Team Members", err)
} }
@ -84,7 +84,7 @@ func (hs *HTTPServer) UpdateTeamMember(c *models.ReqContext, cmd models.UpdateTe
cmd.UserId = c.ParamsInt64(":userId") cmd.UserId = c.ParamsInt64(":userId")
cmd.OrgId = orgId cmd.OrgId = orgId
if err := hs.Bus.Dispatch(&cmd); err != nil { if err := hs.Bus.DispatchCtx(c.Req.Context(), &cmd); err != nil {
if errors.Is(err, models.ErrTeamMemberNotFound) { if errors.Is(err, models.ErrTeamMemberNotFound) {
return response.Error(404, "Team member not found.", nil) return response.Error(404, "Team member not found.", nil)
} }
@ -108,7 +108,7 @@ func (hs *HTTPServer) RemoveTeamMember(c *models.ReqContext) response.Response {
protectLastAdmin = true protectLastAdmin = true
} }
if err := hs.Bus.Dispatch(&models.RemoveTeamMemberCommand{OrgId: orgId, TeamId: teamId, UserId: userId, ProtectLastAdmin: protectLastAdmin}); err != nil { if err := hs.Bus.DispatchCtx(c.Req.Context(), &models.RemoveTeamMemberCommand{OrgId: orgId, TeamId: teamId, UserId: userId, ProtectLastAdmin: protectLastAdmin}); err != nil {
if errors.Is(err, models.ErrTeamNotFound) { if errors.Is(err, models.ErrTeamNotFound) {
return response.Error(404, "Team not found", nil) return response.Error(404, "Team not found", nil)
} }

2
pkg/middleware/auth.go
View File

@ -204,7 +204,7 @@ func OrgAdminFolderAdminOrTeamAdmin(c *models.ReqContext) {
} }
isAdminOfTeamsQuery := models.IsAdminOfTeamsQuery{SignedInUser: c.SignedInUser} isAdminOfTeamsQuery := models.IsAdminOfTeamsQuery{SignedInUser: c.SignedInUser}
if err := sqlstore.IsAdminOfTeams(&isAdminOfTeamsQuery); err != nil { if err := sqlstore.IsAdminOfTeams(c.Req.Context(), &isAdminOfTeamsQuery); err != nil {
c.JsonApiErr(500, "Failed to check if user is a team admin", err) c.JsonApiErr(500, "Failed to check if user is a team admin", err)
} }

36
pkg/services/sqlstore/team.go
View File

@ -12,16 +12,16 @@ import (
) )
func init() { func init() {
bus.AddHandler("sql", UpdateTeam) bus.AddHandlerCtx("sql", UpdateTeam)
bus.AddHandler("sql", DeleteTeam) bus.AddHandlerCtx("sql", DeleteTeam)
bus.AddHandler("sql", SearchTeams) bus.AddHandlerCtx("sql", SearchTeams)
bus.AddHandler("sql", GetTeamById) bus.AddHandlerCtx("sql", GetTeamById)
bus.AddHandler("sql", GetTeamsByUser) bus.AddHandlerCtx("sql", GetTeamsByUser)
bus.AddHandler("sql", UpdateTeamMember) bus.AddHandlerCtx("sql", UpdateTeamMember)
bus.AddHandler("sql", RemoveTeamMember) bus.AddHandlerCtx("sql", RemoveTeamMember)
bus.AddHandler("sql", GetTeamMembers) bus.AddHandlerCtx("sql", GetTeamMembers)
bus.AddHandler("sql", IsAdminOfTeams) bus.AddHandlerCtx("sql", IsAdminOfTeams)
} }
func getFilteredUsers(signedInUser *models.SignedInUser, hiddenUsers map[string]struct{}) []string { func getFilteredUsers(signedInUser *models.SignedInUser, hiddenUsers map[string]struct{}) []string {
@ -95,7 +95,7 @@ func (ss *SQLStore) CreateTeam(name, email string, orgID int64) (models.Team, er
return team, err return team, err
} }
func UpdateTeam(cmd *models.UpdateTeamCommand) error { func UpdateTeam(ctx context.Context, cmd *models.UpdateTeamCommand) error {
return inTransaction(func(sess *DBSession) error { return inTransaction(func(sess *DBSession) error {
if isNameTaken, err := isTeamNameTaken(cmd.OrgId, cmd.Name, cmd.Id, sess); err != nil { if isNameTaken, err := isTeamNameTaken(cmd.OrgId, cmd.Name, cmd.Id, sess); err != nil {
return err return err
@ -126,7 +126,7 @@ func UpdateTeam(cmd *models.UpdateTeamCommand) error {
} }
// DeleteTeam will delete a team, its member and any permissions connected to the team // DeleteTeam will delete a team, its member and any permissions connected to the team
func DeleteTeam(cmd *models.DeleteTeamCommand) error { func DeleteTeam(ctx context.Context, cmd *models.DeleteTeamCommand) error {
return inTransaction(func(sess *DBSession) error { return inTransaction(func(sess *DBSession) error {
if _, err := teamExists(cmd.OrgId, cmd.Id, sess); err != nil { if _, err := teamExists(cmd.OrgId, cmd.Id, sess); err != nil {
return err return err
@ -172,7 +172,7 @@ func isTeamNameTaken(orgId int64, name string, existingId int64, sess *DBSession
return false, nil return false, nil
} }
func SearchTeams(query *models.SearchTeamsQuery) error { func SearchTeams(ctx context.Context, query *models.SearchTeamsQuery) error {
query.Result = models.SearchTeamQueryResult{ query.Result = models.SearchTeamQueryResult{
Teams: make([]*models.TeamDTO, 0), Teams: make([]*models.TeamDTO, 0),
} }
@ -235,7 +235,7 @@ func SearchTeams(query *models.SearchTeamsQuery) error {
return err return err
} }
func GetTeamById(query *models.GetTeamByIdQuery) error { func GetTeamById(ctx context.Context, query *models.GetTeamByIdQuery) error {
var sql bytes.Buffer var sql bytes.Buffer
params := make([]interface{}, 0) params := make([]interface{}, 0)
@ -264,7 +264,7 @@ func GetTeamById(query *models.GetTeamByIdQuery) error {
} }
// GetTeamsByUser is used by the Guardian when checking a users' permissions // GetTeamsByUser is used by the Guardian when checking a users' permissions
func GetTeamsByUser(query *models.GetTeamsByUserQuery) error { func GetTeamsByUser(ctx context.Context, query *models.GetTeamsByUserQuery) error {
query.Result = make([]*models.TeamDTO, 0) query.Result = make([]*models.TeamDTO, 0)
var sql bytes.Buffer var sql bytes.Buffer
@ -322,7 +322,7 @@ func getTeamMember(sess *DBSession, orgId int64, teamId int64, userId int64) (mo
} }
// UpdateTeamMember updates a team member // UpdateTeamMember updates a team member
func UpdateTeamMember(cmd *models.UpdateTeamMemberCommand) error { func UpdateTeamMember(ctx context.Context, cmd *models.UpdateTeamMemberCommand) error {
return inTransaction(func(sess *DBSession) error { return inTransaction(func(sess *DBSession) error {
member, err := getTeamMember(sess, cmd.OrgId, cmd.TeamId, cmd.UserId) member, err := getTeamMember(sess, cmd.OrgId, cmd.TeamId, cmd.UserId)
if err != nil { if err != nil {
@ -348,7 +348,7 @@ func UpdateTeamMember(cmd *models.UpdateTeamMemberCommand) error {
} }
// RemoveTeamMember removes a member from a team // RemoveTeamMember removes a member from a team
func RemoveTeamMember(cmd *models.RemoveTeamMemberCommand) error { func RemoveTeamMember(ctx context.Context, cmd *models.RemoveTeamMemberCommand) error {
return inTransaction(func(sess *DBSession) error { return inTransaction(func(sess *DBSession) error {
if _, err := teamExists(cmd.OrgId, cmd.TeamId, sess); err != nil { if _, err := teamExists(cmd.OrgId, cmd.TeamId, sess); err != nil {
return err return err
@ -399,7 +399,7 @@ func isLastAdmin(sess *DBSession, orgId int64, teamId int64, userId int64) (bool
} }
// GetTeamMembers return a list of members for the specified team // GetTeamMembers return a list of members for the specified team
func GetTeamMembers(query *models.GetTeamMembersQuery) error { func GetTeamMembers(ctx context.Context, query *models.GetTeamMembersQuery) error {
query.Result = make([]*models.TeamMemberDTO, 0) query.Result = make([]*models.TeamMemberDTO, 0)
sess := x.Table("team_member") sess := x.Table("team_member")
sess.Join("INNER", x.Dialect().Quote("user"), fmt.Sprintf("team_member.user_id=%s.id", x.Dialect().Quote("user"))) sess.Join("INNER", x.Dialect().Quote("user"), fmt.Sprintf("team_member.user_id=%s.id", x.Dialect().Quote("user")))
@ -441,7 +441,7 @@ func GetTeamMembers(query *models.GetTeamMembersQuery) error {
return err return err
} }
func IsAdminOfTeams(query *models.IsAdminOfTeamsQuery) error { func IsAdminOfTeams(ctx context.Context, query *models.IsAdminOfTeamsQuery) error {
builder := &SQLBuilder{} builder := &SQLBuilder{}
builder.Write("SELECT COUNT(team.id) AS count FROM team INNER JOIN team_member ON team_member.team_id = team.id WHERE team.org_id = ? AND team_member.user_id = ? AND team_member.permission = ?", query.SignedInUser.OrgId, query.SignedInUser.UserId, models.PERMISSION_ADMIN) builder.Write("SELECT COUNT(team.id) AS count FROM team INNER JOIN team_member ON team_member.team_id = team.id WHERE team.org_id = ? AND team_member.user_id = ? AND team_member.permission = ?", query.SignedInUser.OrgId, query.SignedInUser.UserId, models.PERMISSION_ADMIN)

348
pkg/services/sqlstore/team_test.go
View File

@ -8,314 +8,338 @@ import (
"fmt" "fmt"
"testing" "testing"
. "github.com/smartystreets/goconvey/convey"
"github.com/grafana/grafana/pkg/models" "github.com/grafana/grafana/pkg/models"
"github.com/stretchr/testify/require"
) )
func TestTeamCommandsAndQueries(t *testing.T) { func TestTeamCommandsAndQueries(t *testing.T) {
Convey("Testing Team commands & queries", t, func() { t.Run("Testing Team commands & queries", func(t *testing.T) {
sqlStore := InitTestDB(t) sqlStore := InitTestDB(t)
Convey("Given saved users and two teams", func() { t.Run("Given saved users and two teams", func(t *testing.T) {
var userIds []int64 var userIds []int64
for i := 0; i < 5; i++ {
userCmd := models.CreateUserCommand{
Email: fmt.Sprint("user", i, "@test.com"),
Name: fmt.Sprint("user", i),
Login: fmt.Sprint("loginuser", i),
}
user, err := sqlStore.CreateUser(context.Background(), userCmd)
So(err, ShouldBeNil)
userIds = append(userIds, user.Id)
}
const testOrgID int64 = 1 const testOrgID int64 = 1
team1, err := sqlStore.CreateTeam("group1 name", "test1@test.com", testOrgID) var team1, team2 models.Team
So(err, ShouldBeNil) var user *models.User
team2, err := sqlStore.CreateTeam("group2 name", "test2@test.com", testOrgID) var userCmd models.CreateUserCommand
So(err, ShouldBeNil) var err error
Convey("Should be able to create teams and add users", func() { setup := func() {
for i := 0; i < 5; i++ {
userCmd = models.CreateUserCommand{
Email: fmt.Sprint("user", i, "@test.com"),
Name: fmt.Sprint("user", i),
Login: fmt.Sprint("loginuser", i),
}
user, err = sqlStore.CreateUser(context.Background(), userCmd)
require.NoError(t, err)
userIds = append(userIds, user.Id)
}
team1, err = sqlStore.CreateTeam("group1 name", "test1@test.com", testOrgID)
require.NoError(t, err)
team2, err = sqlStore.CreateTeam("group2 name", "test2@test.com", testOrgID)
require.NoError(t, err)
}
setup()
t.Run("Should be able to create teams and add users", func(t *testing.T) {
query := &models.SearchTeamsQuery{OrgId: testOrgID, Name: "group1 name", Page: 1, Limit: 10} query := &models.SearchTeamsQuery{OrgId: testOrgID, Name: "group1 name", Page: 1, Limit: 10}
err = SearchTeams(query) err = SearchTeams(context.Background(), query)
So(err, ShouldBeNil) require.NoError(t, err)
So(query.Page, ShouldEqual, 1) require.Equal(t, query.Page, 1)
team1 := query.Result.Teams[0] team1 := query.Result.Teams[0]
So(team1.Name, ShouldEqual, "group1 name") require.Equal(t, team1.Name, "group1 name")
So(team1.Email, ShouldEqual, "test1@test.com") require.Equal(t, team1.Email, "test1@test.com")
So(team1.OrgId, ShouldEqual, testOrgID) require.Equal(t, team1.OrgId, testOrgID)
So(team1.MemberCount, ShouldEqual, 0) require.EqualValues(t, team1.MemberCount, 0)
err = sqlStore.AddTeamMember(userIds[0], testOrgID, team1.Id, false, 0) err = sqlStore.AddTeamMember(userIds[0], testOrgID, team1.Id, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
err = sqlStore.AddTeamMember(userIds[1], testOrgID, team1.Id, true, 0) err = sqlStore.AddTeamMember(userIds[1], testOrgID, team1.Id, true, 0)
So(err, ShouldBeNil) require.NoError(t, err)
q1 := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team1.Id} q1 := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team1.Id}
err = GetTeamMembers(q1) err = GetTeamMembers(context.Background(), q1)
So(err, ShouldBeNil) require.NoError(t, err)
So(q1.Result, ShouldHaveLength, 2) require.Equal(t, len(q1.Result), 2)
So(q1.Result[0].TeamId, ShouldEqual, team1.Id) require.Equal(t, q1.Result[0].TeamId, team1.Id)
So(q1.Result[0].Login, ShouldEqual, "loginuser0") require.Equal(t, q1.Result[0].Login, "loginuser0")
So(q1.Result[0].OrgId, ShouldEqual, testOrgID) require.Equal(t, q1.Result[0].OrgId, testOrgID)
So(q1.Result[1].TeamId, ShouldEqual, team1.Id) require.Equal(t, q1.Result[1].TeamId, team1.Id)
So(q1.Result[1].Login, ShouldEqual, "loginuser1") require.Equal(t, q1.Result[1].Login, "loginuser1")
So(q1.Result[1].OrgId, ShouldEqual, testOrgID) require.Equal(t, q1.Result[1].OrgId, testOrgID)
So(q1.Result[1].External, ShouldEqual, true) require.Equal(t, q1.Result[1].External, true)
q2 := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team1.Id, External: true} q2 := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team1.Id, External: true}
err = GetTeamMembers(q2) err = GetTeamMembers(context.Background(), q2)
So(err, ShouldBeNil) require.NoError(t, err)
So(q2.Result, ShouldHaveLength, 1) require.Equal(t, len(q2.Result), 1)
So(q2.Result[0].TeamId, ShouldEqual, team1.Id) require.Equal(t, q2.Result[0].TeamId, team1.Id)
So(q2.Result[0].Login, ShouldEqual, "loginuser1") require.Equal(t, q2.Result[0].Login, "loginuser1")
So(q2.Result[0].OrgId, ShouldEqual, testOrgID) require.Equal(t, q2.Result[0].OrgId, testOrgID)
So(q2.Result[0].External, ShouldEqual, true) require.Equal(t, q2.Result[0].External, true)
err = SearchTeams(query) err = SearchTeams(context.Background(), query)
So(err, ShouldBeNil) require.NoError(t, err)
team1 = query.Result.Teams[0] team1 = query.Result.Teams[0]
So(team1.MemberCount, ShouldEqual, 2) require.EqualValues(t, team1.MemberCount, 2)
getTeamQuery := &models.GetTeamByIdQuery{OrgId: testOrgID, Id: team1.Id} getTeamQuery := &models.GetTeamByIdQuery{OrgId: testOrgID, Id: team1.Id}
err = GetTeamById(getTeamQuery) err = GetTeamById(context.Background(), getTeamQuery)
So(err, ShouldBeNil) require.NoError(t, err)
team1 = getTeamQuery.Result team1 = getTeamQuery.Result
So(team1.Name, ShouldEqual, "group1 name") require.Equal(t, team1.Name, "group1 name")
So(team1.Email, ShouldEqual, "test1@test.com") require.Equal(t, team1.Email, "test1@test.com")
So(team1.OrgId, ShouldEqual, testOrgID) require.Equal(t, team1.OrgId, testOrgID)
So(team1.MemberCount, ShouldEqual, 2) require.EqualValues(t, team1.MemberCount, 2)
}) })
Convey("Should return latest auth module for users when getting team members", func() { t.Run("Should return latest auth module for users when getting team members", func(t *testing.T) {
sqlStore = InitTestDB(t)
setup()
userId := userIds[1] userId := userIds[1]
teamQuery := &models.SearchTeamsQuery{OrgId: testOrgID, Name: "group1 name", Page: 1, Limit: 10} teamQuery := &models.SearchTeamsQuery{OrgId: testOrgID, Name: "group1 name", Page: 1, Limit: 10}
err = SearchTeams(teamQuery) err = SearchTeams(context.Background(), teamQuery)
So(err, ShouldBeNil) require.NoError(t, err)
So(teamQuery.Page, ShouldEqual, 1) require.Equal(t, teamQuery.Page, 1)
team1 := teamQuery.Result.Teams[0] team1 := teamQuery.Result.Teams[0]
err = sqlStore.AddTeamMember(userId, testOrgID, team1.Id, true, 0) err = sqlStore.AddTeamMember(userId, testOrgID, team1.Id, true, 0)
So(err, ShouldBeNil) require.NoError(t, err)
memberQuery := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team1.Id, External: true} memberQuery := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team1.Id, External: true}
err = GetTeamMembers(memberQuery) err = GetTeamMembers(context.Background(), memberQuery)
So(err, ShouldBeNil) require.NoError(t, err)
So(memberQuery.Result, ShouldHaveLength, 1) require.Equal(t, len(memberQuery.Result), 1)
So(memberQuery.Result[0].TeamId, ShouldEqual, team1.Id) require.Equal(t, memberQuery.Result[0].TeamId, team1.Id)
So(memberQuery.Result[0].Login, ShouldEqual, "loginuser1") require.Equal(t, memberQuery.Result[0].Login, "loginuser1")
So(memberQuery.Result[0].OrgId, ShouldEqual, testOrgID) require.Equal(t, memberQuery.Result[0].OrgId, testOrgID)
So(memberQuery.Result[0].External, ShouldEqual, true) require.Equal(t, memberQuery.Result[0].External, true)
}) })
Convey("Should be able to update users in a team", func() { t.Run("Should be able to update users in a team", func(t *testing.T) {
userId := userIds[0] userId := userIds[0]
team := team1 team := team1
err = sqlStore.AddTeamMember(userId, testOrgID, team.Id, false, 0) err = sqlStore.AddTeamMember(userId, testOrgID, team.Id, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
qBeforeUpdate := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team.Id} qBeforeUpdate := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team.Id}
err = GetTeamMembers(qBeforeUpdate) err = GetTeamMembers(context.Background(), qBeforeUpdate)
So(err, ShouldBeNil) require.NoError(t, err)
So(qBeforeUpdate.Result[0].Permission, ShouldEqual, 0) require.EqualValues(t, qBeforeUpdate.Result[0].Permission, 0)
err = UpdateTeamMember(&models.UpdateTeamMemberCommand{ err = UpdateTeamMember(context.Background(), &models.UpdateTeamMemberCommand{
UserId: userId, UserId: userId,
OrgId: testOrgID, OrgId: testOrgID,
TeamId: team.Id, TeamId: team.Id,
Permission: models.PERMISSION_ADMIN, Permission: models.PERMISSION_ADMIN,
}) })
So(err, ShouldBeNil) require.NoError(t, err)
qAfterUpdate := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team.Id} qAfterUpdate := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team.Id}
err = GetTeamMembers(qAfterUpdate) err = GetTeamMembers(context.Background(), qAfterUpdate)
So(err, ShouldBeNil) require.NoError(t, err)
So(qAfterUpdate.Result[0].Permission, ShouldEqual, models.PERMISSION_ADMIN) require.Equal(t, qAfterUpdate.Result[0].Permission, models.PERMISSION_ADMIN)
}) })
Convey("Should default to member permission level when updating a user with invalid permission level", func() { t.Run("Should default to member permission level when updating a user with invalid permission level", func(t *testing.T) {
sqlStore = InitTestDB(t)
setup()
userID := userIds[0] userID := userIds[0]
team := team1 team := team1
err = sqlStore.AddTeamMember(userID, testOrgID, team.Id, false, 0) err = sqlStore.AddTeamMember(userID, testOrgID, team.Id, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
qBeforeUpdate := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team.Id} qBeforeUpdate := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team.Id}
err = GetTeamMembers(qBeforeUpdate) err = GetTeamMembers(context.Background(), qBeforeUpdate)
So(err, ShouldBeNil) require.NoError(t, err)
So(qBeforeUpdate.Result[0].Permission, ShouldEqual, 0) require.EqualValues(t, qBeforeUpdate.Result[0].Permission, 0)
invalidPermissionLevel := models.PERMISSION_EDIT invalidPermissionLevel := models.PERMISSION_EDIT
err = UpdateTeamMember(&models.UpdateTeamMemberCommand{ err = UpdateTeamMember(context.Background(), &models.UpdateTeamMemberCommand{
UserId: userID, UserId: userID,
OrgId: testOrgID, OrgId: testOrgID,
TeamId: team.Id, TeamId: team.Id,
Permission: invalidPermissionLevel, Permission: invalidPermissionLevel,
}) })
So(err, ShouldBeNil) require.NoError(t, err)
qAfterUpdate := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team.Id} qAfterUpdate := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team.Id}
err = GetTeamMembers(qAfterUpdate) err = GetTeamMembers(context.Background(), qAfterUpdate)
So(err, ShouldBeNil) require.NoError(t, err)
So(qAfterUpdate.Result[0].Permission, ShouldEqual, 0) require.EqualValues(t, qAfterUpdate.Result[0].Permission, 0)
}) })
Convey("Shouldn't be able to update a user not in the team.", func() { t.Run("Shouldn't be able to update a user not in the team.", func(t *testing.T) {
err = UpdateTeamMember(&models.UpdateTeamMemberCommand{ sqlStore = InitTestDB(t)
setup()
err = UpdateTeamMember(context.Background(), &models.UpdateTeamMemberCommand{
UserId: 1, UserId: 1,
OrgId: testOrgID, OrgId: testOrgID,
TeamId: team1.Id, TeamId: team1.Id,
Permission: models.PERMISSION_ADMIN, Permission: models.PERMISSION_ADMIN,
}) })
So(err, ShouldEqual, models.ErrTeamMemberNotFound) require.Error(t, err, models.ErrTeamMemberNotFound)
}) })
Convey("Should be able to search for teams", func() { t.Run("Should be able to search for teams", func(t *testing.T) {
query := &models.SearchTeamsQuery{OrgId: testOrgID, Query: "group", Page: 1} query := &models.SearchTeamsQuery{OrgId: testOrgID, Query: "group", Page: 1}
err = SearchTeams(query) err = SearchTeams(context.Background(), query)
So(err, ShouldBeNil) require.NoError(t, err)
So(len(query.Result.Teams), ShouldEqual, 2) require.Equal(t, len(query.Result.Teams), 2)
So(query.Result.TotalCount, ShouldEqual, 2) require.EqualValues(t, query.Result.TotalCount, 2)
query2 := &models.SearchTeamsQuery{OrgId: testOrgID, Query: ""} query2 := &models.SearchTeamsQuery{OrgId: testOrgID, Query: ""}
err = SearchTeams(query2) err = SearchTeams(context.Background(), query2)
So(err, ShouldBeNil) require.NoError(t, err)
So(len(query2.Result.Teams), ShouldEqual, 2) require.Equal(t, len(query2.Result.Teams), 2)
}) })
Convey("Should be able to return all teams a user is member of", func() { t.Run("Should be able to return all teams a user is member of", func(t *testing.T) {
sqlStore = InitTestDB(t)
setup()
groupId := team2.Id groupId := team2.Id
err := sqlStore.AddTeamMember(userIds[0], testOrgID, groupId, false, 0) err := sqlStore.AddTeamMember(userIds[0], testOrgID, groupId, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
query := &models.GetTeamsByUserQuery{OrgId: testOrgID, UserId: userIds[0]} query := &models.GetTeamsByUserQuery{OrgId: testOrgID, UserId: userIds[0]}
err = GetTeamsByUser(query) err = GetTeamsByUser(context.Background(), query)
So(err, ShouldBeNil) require.NoError(t, err)
So(len(query.Result), ShouldEqual, 1) require.Equal(t, len(query.Result), 1)
So(query.Result[0].Name, ShouldEqual, "group2 name") require.Equal(t, query.Result[0].Name, "group2 name")
So(query.Result[0].Email, ShouldEqual, "test2@test.com") require.Equal(t, query.Result[0].Email, "test2@test.com")
}) })
Convey("Should be able to remove users from a group", func() { t.Run("Should be able to remove users from a group", func(t *testing.T) {
err = sqlStore.AddTeamMember(userIds[0], testOrgID, team1.Id, false, 0) err = sqlStore.AddTeamMember(userIds[0], testOrgID, team1.Id, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
err = RemoveTeamMember(&models.RemoveTeamMemberCommand{OrgId: testOrgID, TeamId: team1.Id, UserId: userIds[0]}) err = RemoveTeamMember(context.Background(), &models.RemoveTeamMemberCommand{OrgId: testOrgID, TeamId: team1.Id, UserId: userIds[0]})
So(err, ShouldBeNil) require.NoError(t, err)
q2 := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team1.Id} q2 := &models.GetTeamMembersQuery{OrgId: testOrgID, TeamId: team1.Id}
err = GetTeamMembers(q2) err = GetTeamMembers(context.Background(), q2)
So(err, ShouldBeNil) require.NoError(t, err)
So(len(q2.Result), ShouldEqual, 0) require.Equal(t, len(q2.Result), 0)
}) })
Convey("When ProtectLastAdmin is set to true", func() { t.Run("When ProtectLastAdmin is set to true", func(t *testing.T) {
err = sqlStore.AddTeamMember(userIds[0], testOrgID, team1.Id, false, models.PERMISSION_ADMIN) err = sqlStore.AddTeamMember(userIds[0], testOrgID, team1.Id, false, models.PERMISSION_ADMIN)
So(err, ShouldBeNil) require.NoError(t, err)
Convey("A user should not be able to remove the last admin", func() { t.Run("A user should not be able to remove the last admin", func(t *testing.T) {
err = RemoveTeamMember(&models.RemoveTeamMemberCommand{OrgId: testOrgID, TeamId: team1.Id, UserId: userIds[0], ProtectLastAdmin: true}) err = RemoveTeamMember(context.Background(), &models.RemoveTeamMemberCommand{OrgId: testOrgID, TeamId: team1.Id, UserId: userIds[0], ProtectLastAdmin: true})
So(err, ShouldEqual, models.ErrLastTeamAdmin) require.Equal(t, err, models.ErrLastTeamAdmin)
}) })
Convey("A user should be able to remove an admin if there are other admins", func() { t.Run("A user should be able to remove an admin if there are other admins", func(t *testing.T) {
err = sqlStore.AddTeamMember(userIds[1], testOrgID, team1.Id, false, models.PERMISSION_ADMIN) err = sqlStore.AddTeamMember(userIds[1], testOrgID, team1.Id, false, models.PERMISSION_ADMIN)
So(err, ShouldBeNil) require.NoError(t, err)
err = RemoveTeamMember(&models.RemoveTeamMemberCommand{OrgId: testOrgID, TeamId: team1.Id, UserId: userIds[0], ProtectLastAdmin: true}) err = RemoveTeamMember(context.Background(), &models.RemoveTeamMemberCommand{OrgId: testOrgID, TeamId: team1.Id, UserId: userIds[0], ProtectLastAdmin: true})
So(err, ShouldBeNil) require.NoError(t, err)
}) })
Convey("A user should not be able to remove the admin permission for the last admin", func() { t.Run("A user should not be able to remove the admin permission for the last admin", func(t *testing.T) {
err = UpdateTeamMember(&models.UpdateTeamMemberCommand{OrgId: testOrgID, TeamId: team1.Id, UserId: userIds[0], Permission: 0, ProtectLastAdmin: true}) err = UpdateTeamMember(context.Background(), &models.UpdateTeamMemberCommand{OrgId: testOrgID, TeamId: team1.Id, UserId: userIds[0], Permission: 0, ProtectLastAdmin: true})
So(err, ShouldBeError, models.ErrLastTeamAdmin) require.Error(t, err, models.ErrLastTeamAdmin)
}) })
Convey("A user should be able to remove the admin permission if there are other admins", func() { t.Run("A user should be able to remove the admin permission if there are other admins", func(t *testing.T) {
sqlStore = InitTestDB(t)
setup()
err = sqlStore.AddTeamMember(userIds[0], testOrgID, team1.Id, false, models.PERMISSION_ADMIN)
require.NoError(t, err)
err = sqlStore.AddTeamMember(userIds[1], testOrgID, team1.Id, false, models.PERMISSION_ADMIN) err = sqlStore.AddTeamMember(userIds[1], testOrgID, team1.Id, false, models.PERMISSION_ADMIN)
So(err, ShouldBeNil) require.NoError(t, err)
err = UpdateTeamMember(&models.UpdateTeamMemberCommand{OrgId: testOrgID, TeamId: team1.Id, UserId: userIds[0], Permission: 0, ProtectLastAdmin: true}) err = UpdateTeamMember(context.Background(), &models.UpdateTeamMemberCommand{OrgId: testOrgID, TeamId: team1.Id, UserId: userIds[0], Permission: 0, ProtectLastAdmin: true})
So(err, ShouldBeNil) require.NoError(t, err)
}) })
}) })
Convey("Should be able to remove a group with users and permissions", func() { t.Run("Should be able to remove a group with users and permissions", func(t *testing.T) {
groupId := team2.Id groupId := team2.Id
err := sqlStore.AddTeamMember(userIds[1], testOrgID, groupId, false, 0) err := sqlStore.AddTeamMember(userIds[1], testOrgID, groupId, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
err = sqlStore.AddTeamMember(userIds[2], testOrgID, groupId, false, 0) err = sqlStore.AddTeamMember(userIds[2], testOrgID, groupId, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
err = testHelperUpdateDashboardAcl(t, sqlStore, 1, models.DashboardAcl{ err = testHelperUpdateDashboardAcl(t, sqlStore, 1, models.DashboardAcl{
DashboardID: 1, OrgID: testOrgID, Permission: models.PERMISSION_EDIT, TeamID: groupId, DashboardID: 1, OrgID: testOrgID, Permission: models.PERMISSION_EDIT, TeamID: groupId,
}) })
So(err, ShouldBeNil) require.NoError(t, err)
err = DeleteTeam(&models.DeleteTeamCommand{OrgId: testOrgID, Id: groupId}) err = DeleteTeam(context.Background(), &models.DeleteTeamCommand{OrgId: testOrgID, Id: groupId})
So(err, ShouldBeNil) require.NoError(t, err)
query := &models.GetTeamByIdQuery{OrgId: testOrgID, Id: groupId} query := &models.GetTeamByIdQuery{OrgId: testOrgID, Id: groupId}
err = GetTeamById(query) err = GetTeamById(context.Background(), query)
So(err, ShouldEqual, models.ErrTeamNotFound) require.Equal(t, err, models.ErrTeamNotFound)
permQuery := &models.GetDashboardAclInfoListQuery{DashboardID: 1, OrgID: testOrgID} permQuery := &models.GetDashboardAclInfoListQuery{DashboardID: 1, OrgID: testOrgID}
err = sqlStore.GetDashboardAclInfoList(context.Background(), permQuery) err = sqlStore.GetDashboardAclInfoList(context.Background(), permQuery)
So(err, ShouldBeNil) require.NoError(t, err)
So(len(permQuery.Result), ShouldEqual, 0) require.Equal(t, len(permQuery.Result), 0)
}) })
Convey("Should be able to return if user is admin of teams or not", func() { t.Run("Should be able to return if user is admin of teams or not", func(t *testing.T) {
sqlStore = InitTestDB(t)
setup()
groupId := team2.Id groupId := team2.Id
err := sqlStore.AddTeamMember(userIds[0], testOrgID, groupId, false, 0) err := sqlStore.AddTeamMember(userIds[0], testOrgID, groupId, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
err = sqlStore.AddTeamMember(userIds[1], testOrgID, groupId, false, models.PERMISSION_ADMIN) err = sqlStore.AddTeamMember(userIds[1], testOrgID, groupId, false, models.PERMISSION_ADMIN)
So(err, ShouldBeNil) require.NoError(t, err)
query := &models.IsAdminOfTeamsQuery{SignedInUser: &models.SignedInUser{OrgId: testOrgID, UserId: userIds[0]}} query := &models.IsAdminOfTeamsQuery{SignedInUser: &models.SignedInUser{OrgId: testOrgID, UserId: userIds[0]}}
err = IsAdminOfTeams(query) err = IsAdminOfTeams(context.Background(), query)
So(err, ShouldBeNil) require.NoError(t, err)
So(query.Result, ShouldBeFalse) require.False(t, query.Result)
query = &models.IsAdminOfTeamsQuery{SignedInUser: &models.SignedInUser{OrgId: testOrgID, UserId: userIds[1]}} query = &models.IsAdminOfTeamsQuery{SignedInUser: &models.SignedInUser{OrgId: testOrgID, UserId: userIds[1]}}
err = IsAdminOfTeams(query) err = IsAdminOfTeams(context.Background(), query)
So(err, ShouldBeNil) require.NoError(t, err)
So(query.Result, ShouldBeTrue) require.True(t, query.Result)
}) })
Convey("Should not return hidden users in team member count", func() { t.Run("Should not return hidden users in team member count", func(t *testing.T) {
sqlStore = InitTestDB(t)
setup()
signedInUser := &models.SignedInUser{Login: "loginuser0"} signedInUser := &models.SignedInUser{Login: "loginuser0"}
hiddenUsers := map[string]struct{}{"loginuser0": {}, "loginuser1": {}} hiddenUsers := map[string]struct{}{"loginuser0": {}, "loginuser1": {}}
teamId := team1.Id teamId := team1.Id
err = sqlStore.AddTeamMember(userIds[0], testOrgID, teamId, false, 0) err = sqlStore.AddTeamMember(userIds[0], testOrgID, teamId, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
err = sqlStore.AddTeamMember(userIds[1], testOrgID, teamId, false, 0) err = sqlStore.AddTeamMember(userIds[1], testOrgID, teamId, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
err = sqlStore.AddTeamMember(userIds[2], testOrgID, teamId, false, 0) err = sqlStore.AddTeamMember(userIds[2], testOrgID, teamId, false, 0)
So(err, ShouldBeNil) require.NoError(t, err)
searchQuery := &models.SearchTeamsQuery{OrgId: testOrgID, Page: 1, Limit: 10, SignedInUser: signedInUser, HiddenUsers: hiddenUsers} searchQuery := &models.SearchTeamsQuery{OrgId: testOrgID, Page: 1, Limit: 10, SignedInUser: signedInUser, HiddenUsers: hiddenUsers}
err = SearchTeams(searchQuery) err = SearchTeams(context.Background(), searchQuery)
So(err, ShouldBeNil) require.NoError(t, err)
So(searchQuery.Result.Teams, ShouldHaveLength, 2) require.Equal(t, len(searchQuery.Result.Teams), 2)
team1 := searchQuery.Result.Teams[0] team1 := searchQuery.Result.Teams[0]
So(team1.MemberCount, ShouldEqual, 2) require.EqualValues(t, team1.MemberCount, 2)
searchQueryFilteredByUser := &models.SearchTeamsQuery{OrgId: testOrgID, Page: 1, Limit: 10, UserIdFilter: userIds[0], SignedInUser: signedInUser, HiddenUsers: hiddenUsers} searchQueryFilteredByUser := &models.SearchTeamsQuery{OrgId: testOrgID, Page: 1, Limit: 10, UserIdFilter: userIds[0], SignedInUser: signedInUser, HiddenUsers: hiddenUsers}
err = SearchTeams(searchQueryFilteredByUser) err = SearchTeams(context.Background(), searchQueryFilteredByUser)
So(err, ShouldBeNil) require.NoError(t, err)
So(searchQueryFilteredByUser.Result.Teams, ShouldHaveLength, 1) require.Equal(t, len(searchQueryFilteredByUser.Result.Teams), 1)
team1 = searchQuery.Result.Teams[0] team1 = searchQuery.Result.Teams[0]
So(team1.MemberCount, ShouldEqual, 2) require.EqualValues(t, team1.MemberCount, 2)
getTeamQuery := &models.GetTeamByIdQuery{OrgId: testOrgID, Id: teamId, SignedInUser: signedInUser, HiddenUsers: hiddenUsers} getTeamQuery := &models.GetTeamByIdQuery{OrgId: testOrgID, Id: teamId, SignedInUser: signedInUser, HiddenUsers: hiddenUsers}
err = GetTeamById(getTeamQuery) err = GetTeamById(context.Background(), getTeamQuery)
So(err, ShouldBeNil) require.NoError(t, err)
So(getTeamQuery.Result.MemberCount, ShouldEqual, 2) require.EqualValues(t, getTeamQuery.Result.MemberCount, 2)
}) })
}) })
}) })

2
pkg/services/sqlstore/user.go
View File

@ -562,7 +562,7 @@ func GetSignedInUser(ctx context.Context, query *models.GetSignedInUserQuery) er
} }
getTeamsByUserQuery := &models.GetTeamsByUserQuery{OrgId: user.OrgId, UserId: user.UserId} getTeamsByUserQuery := &models.GetTeamsByUserQuery{OrgId: user.OrgId, UserId: user.UserId}
err = GetTeamsByUser(getTeamsByUserQuery) err = GetTeamsByUser(ctx, getTeamsByUserQuery)
if err != nil { if err != nil {
return err return err
} }