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

Migrate Roles Layered store to Sync by default (#10790)

Browse Source 
* Migrate Roles Layered store to Sync by default

* Fixing govet

* Addressing PR review comments
This commit is contained in:
Jesús Espino
2019-05-17 17:03:05 +02:00
committed by Jesse Hallam
parent fb01d37846
commit 6d1ac00330
18 changed files with 645 additions and 639 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
api4/role_test.go
View File

@@ -24,9 +24,8 @@ func TestGetRole(t *testing.T) {
SchemeManaged: true,
}
res1 := <-th.App.Srv.Store.Role().Save(role)
assert.Nil(t, res1.Err)
role = res1.Data.(*model.Role)
role, err := th.App.Srv.Store.Role().Save(role)
assert.Nil(t, err)
defer th.App.Srv.Store.Job().Delete(role.Id)
received, resp := th.Client.GetRole(role.Id)
@@ -58,9 +57,8 @@ func TestGetRoleByName(t *testing.T) {
SchemeManaged: true,
}
res1 := <-th.App.Srv.Store.Role().Save(role)
assert.Nil(t, res1.Err)
role = res1.Data.(*model.Role)
role, err := th.App.Srv.Store.Role().Save(role)
assert.Nil(t, err)
defer th.App.Srv.Store.Job().Delete(role.Id)
received, resp := th.Client.GetRoleByName(role.Name)
@@ -106,19 +104,16 @@ func TestGetRolesByNames(t *testing.T) {
SchemeManaged: true,
}
res1 := <-th.App.Srv.Store.Role().Save(role1)
assert.Nil(t, res1.Err)
role1 = res1.Data.(*model.Role)
role1, err := th.App.Srv.Store.Role().Save(role1)
assert.Nil(t, err)
defer th.App.Srv.Store.Job().Delete(role1.Id)
res2 := <-th.App.Srv.Store.Role().Save(role2)
assert.Nil(t, res2.Err)
role2 = res2.Data.(*model.Role)
role2, err = th.App.Srv.Store.Role().Save(role2)
assert.Nil(t, err)
defer th.App.Srv.Store.Job().Delete(role2.Id)
res3 := <-th.App.Srv.Store.Role().Save(role3)
assert.Nil(t, res3.Err)
role3 = res3.Data.(*model.Role)
role3, err = th.App.Srv.Store.Role().Save(role3)
assert.Nil(t, err)
defer th.App.Srv.Store.Job().Delete(role3.Id)
// Check all three roles can be found.
@@ -158,9 +153,8 @@ func TestPatchRole(t *testing.T) {
SchemeManaged: true,
}
res1 := <-th.App.Srv.Store.Role().Save(role)
assert.Nil(t, res1.Err)
role = res1.Data.(*model.Role)
role, err := th.App.Srv.Store.Role().Save(role)
assert.Nil(t, err)
defer th.App.Srv.Store.Job().Delete(role.Id)
patch := &model.RolePatch{

87
app/import_functions_test.go
View File

@@ -105,55 +105,49 @@ func TestImportImportScheme(t *testing.T) {
assert.Equal(t, *data.Description, scheme.Description)
assert.Equal(t, *data.Scope, scheme.Scope)
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
@@ -177,55 +171,49 @@ func TestImportImportScheme(t *testing.T) {
assert.Equal(t, *data.Description, scheme.Description)
assert.Equal(t, *data.Scope, scheme.Scope)
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
@@ -330,55 +318,49 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
assert.Equal(t, *data.Description, scheme.Description)
assert.Equal(t, *data.Scope, scheme.Scope)
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
@@ -402,55 +384,49 @@ func TestImportImportSchemeWithoutGuestRoles(t *testing.T) {
assert.Equal(t, *data.Description, scheme.Description)
assert.Equal(t, *data.Scope, scheme.Scope)
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultTeamGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultTeamGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelAdminRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelAdminRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelUserRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelUserRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
}
if res := <-th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(scheme.DefaultChannelGuestRole); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.DefaultChannelGuestRole.DisplayName, role.DisplayName)
assert.False(t, role.BuiltIn)
assert.True(t, role.SchemeManaged)
@@ -489,7 +465,7 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have failed to import.")
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err == nil {
if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil {
t.Fatalf("Role should not have imported.")
}
@@ -500,7 +476,7 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have succeeded.")
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err == nil {
if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil {
t.Fatalf("Role should not have imported as we are in dry run mode.")
}
@@ -511,7 +487,7 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have failed to import.")
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err == nil {
if _, err := th.App.Srv.Store.Role().GetByName(rid1); err == nil {
t.Fatalf("Role should not have imported.")
}
@@ -524,10 +500,9 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have succeeded.")
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.Name, role.Name)
assert.Equal(t, *data.DisplayName, role.DisplayName)
assert.Equal(t, *data.Description, role.Description)
@@ -545,10 +520,9 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have succeeded. %v", err)
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data.Name, role.Name)
assert.Equal(t, *data.DisplayName, role.DisplayName)
assert.Equal(t, *data.Description, role.Description)
@@ -567,10 +541,9 @@ func TestImportImportRole(t *testing.T) {
t.Fatalf("Should have succeeded.")
}
if res := <-th.App.Srv.Store.Role().GetByName(rid1); res.Err != nil {
if role, err := th.App.Srv.Store.Role().GetByName(rid1); err != nil {
t.Fatalf("Should have found the imported role.")
} else {
role := res.Data.(*model.Role)
assert.Equal(t, *data2.Name, role.Name)
assert.Equal(t, *data2.DisplayName, role.DisplayName)
assert.Equal(t, *data.Description, role.Description)

116
app/migrations.go
View File

@@ -30,27 +30,29 @@ func (a *App) DoAdvancedPermissionsMigration() {
allSucceeded := true
for _, role := range roles {
if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
// If this failed for reasons other than the role already existing, don't mark the migration as done.
if result2 := <-a.Srv.Store.Role().GetByName(role.Name); result2.Err != nil {
mlog.Critical("Failed to migrate role to database.")
mlog.Critical(fmt.Sprint(result.Err))
_, err := a.Srv.Store.Role().Save(role)
if err == nil {
continue
}
// If this failed for reasons other than the role already existing, don't mark the migration as done.
fetchedRole, err := a.Srv.Store.Role().GetByName(role.Name)
if err != nil {
mlog.Critical("Failed to migrate role to database.", mlog.Err(err))
allSucceeded = false
continue
}
// If the role already existed, check it is the same and update if not.
if !reflect.DeepEqual(fetchedRole.Permissions, role.Permissions) ||
fetchedRole.DisplayName != role.DisplayName ||
fetchedRole.Description != role.Description ||
fetchedRole.SchemeManaged != role.SchemeManaged {
role.Id = fetchedRole.Id
if _, err = a.Srv.Store.Role().Save(role); err != nil {
// Role is not the same, but failed to update.
mlog.Critical("Failed to migrate role to database.", mlog.Err(err))
allSucceeded = false
} else {
// If the role already existed, check it is the same and update if not.
fetchedRole := result.Data.(*model.Role)
if !reflect.DeepEqual(fetchedRole.Permissions, role.Permissions) ||
fetchedRole.DisplayName != role.DisplayName ||
fetchedRole.Description != role.Description ||
fetchedRole.SchemeManaged != role.SchemeManaged {
role.Id = fetchedRole.Id
if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
// Role is not the same, but failed to update.
mlog.Critical("Failed to migrate role to database.")
mlog.Critical(fmt.Sprint(result.Err))
allSucceeded = false
}
}
}
}
}
@@ -63,7 +65,7 @@ func (a *App) DoAdvancedPermissionsMigration() {
if *config.ServiceSettings.DEPRECATED_DO_NOT_USE_AllowEditPost == model.ALLOW_EDIT_POST_ALWAYS {
*config.ServiceSettings.PostEditTimeLimit = -1
if err := a.SaveConfig(config, true); err != nil {
mlog.Error("Failed to update config in Advanced Permissions Phase 1 Migration.", mlog.String("error", err.Error()))
mlog.Error("Failed to update config in Advanced Permissions Phase 1 Migration.", mlog.Err(err))
}
}
@@ -73,8 +75,7 @@ func (a *App) DoAdvancedPermissionsMigration() {
}
if result := <-a.Srv.Store.System().Save(&system); result.Err != nil {
mlog.Critical("Failed to mark advanced permissions migration as completed.")
mlog.Critical(fmt.Sprint(result.Err))
mlog.Critical("Failed to mark advanced permissions migration as completed.", mlog.Err(result.Err))
}
}
@@ -104,46 +105,40 @@ func (a *App) DoEmojisPermissionsMigration() {
case model.RESTRICT_EMOJI_CREATION_ALL:
role, err = a.GetRoleByName(model.SYSTEM_USER_ROLE_ID)
if err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical(err.Error())
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
return
}
case model.RESTRICT_EMOJI_CREATION_ADMIN:
role, err = a.GetRoleByName(model.TEAM_ADMIN_ROLE_ID)
if err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical(err.Error())
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
return
}
case model.RESTRICT_EMOJI_CREATION_SYSTEM_ADMIN:
role = nil
default:
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical("Invalid restrict emoji creation setting")
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config. Invalid restrict emoji creation setting")
return
}
if role != nil {
role.Permissions = append(role.Permissions, model.PERMISSION_CREATE_EMOJIS.Id, model.PERMISSION_DELETE_EMOJIS.Id)
if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical(result.Err.Error())
if _, err = a.Srv.Store.Role().Save(role); err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
return
}
}
systemAdminRole, err = a.GetRoleByName(model.SYSTEM_ADMIN_ROLE_ID)
if err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical(err.Error())
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
return
}
systemAdminRole.Permissions = append(systemAdminRole.Permissions, model.PERMISSION_CREATE_EMOJIS.Id, model.PERMISSION_DELETE_EMOJIS.Id)
systemAdminRole.Permissions = append(systemAdminRole.Permissions, model.PERMISSION_DELETE_OTHERS_EMOJIS.Id)
if result := <-a.Srv.Store.Role().Save(systemAdminRole); result.Err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.")
mlog.Critical(result.Err.Error())
if _, err := a.Srv.Store.Role().Save(systemAdminRole); err != nil {
mlog.Critical("Failed to migrate emojis creation permissions from mattermost config.", mlog.Err(err))
return
}
@@ -153,8 +148,7 @@ func (a *App) DoEmojisPermissionsMigration() {
}
if result := <-a.Srv.Store.System().Save(&system); result.Err != nil {
mlog.Critical("Failed to mark emojis permissions migration as completed.")
mlog.Critical(fmt.Sprint(result.Err))
mlog.Critical("Failed to mark emojis permissions migration as completed.", mlog.Err(result.Err))
}
}
@@ -167,32 +161,28 @@ func (a *App) DoGuestRolesCreationMigration() {
roles := model.MakeDefaultRoles()
allSucceeded := true
if result := <-a.Srv.Store.Role().GetByName(model.CHANNEL_GUEST_ROLE_ID); result.Err != nil {
if result := <-a.Srv.Store.Role().Save(roles[model.CHANNEL_GUEST_ROLE_ID]); result.Err != nil {
mlog.Critical("Failed to create new guest role to database.")
mlog.Critical(fmt.Sprint(result.Err))
if _, err := a.Srv.Store.Role().GetByName(model.CHANNEL_GUEST_ROLE_ID); err != nil {
if _, err := a.Srv.Store.Role().Save(roles[model.CHANNEL_GUEST_ROLE_ID]); err != nil {
mlog.Critical("Failed to create new guest role to database.", mlog.Err(err))
allSucceeded = false
}
}
if result := <-a.Srv.Store.Role().GetByName(model.TEAM_GUEST_ROLE_ID); result.Err != nil {
if result := <-a.Srv.Store.Role().Save(roles[model.TEAM_GUEST_ROLE_ID]); result.Err != nil {
mlog.Critical("Failed to create new guest role to database.")
mlog.Critical(fmt.Sprint(result.Err))
if _, err := a.Srv.Store.Role().GetByName(model.TEAM_GUEST_ROLE_ID); err != nil {
if _, err := a.Srv.Store.Role().Save(roles[model.TEAM_GUEST_ROLE_ID]); err != nil {
mlog.Critical("Failed to create new guest role to database.", mlog.Err(err))
allSucceeded = false
}
}
if result := <-a.Srv.Store.Role().GetByName(model.SYSTEM_GUEST_ROLE_ID); result.Err != nil {
if result := <-a.Srv.Store.Role().Save(roles[model.SYSTEM_GUEST_ROLE_ID]); result.Err != nil {
mlog.Critical("Failed to create new guest role to database.")
mlog.Critical(fmt.Sprint(result.Err))
if _, err := a.Srv.Store.Role().GetByName(model.SYSTEM_GUEST_ROLE_ID); err != nil {
if _, err := a.Srv.Store.Role().Save(roles[model.SYSTEM_GUEST_ROLE_ID]); err != nil {
mlog.Critical("Failed to create new guest role to database.", mlog.Err(err))
allSucceeded = false
}
}
resultSchemes := <-a.Srv.Store.Scheme().GetAllPage("", 0, 1000000)
if resultSchemes.Err != nil {
mlog.Critical("Failed to get all schemes.")
mlog.Critical(fmt.Sprint(resultSchemes.Err))
mlog.Critical("Failed to get all schemes.", mlog.Err(resultSchemes.Err))
allSucceeded = false
}
schemes := resultSchemes.Data.([]*model.Scheme)
@@ -206,12 +196,11 @@ func (a *App) DoGuestRolesCreationMigration() {
SchemeManaged: true,
}
if saveRoleResult := <-a.Srv.Store.Role().Save(teamGuestRole); saveRoleResult.Err != nil {
mlog.Critical("Failed to create new guest role for custom scheme.")
mlog.Critical(fmt.Sprint(saveRoleResult.Err))
if savedRole, err := a.Srv.Store.Role().Save(teamGuestRole); err != nil {
mlog.Critical("Failed to create new guest role for custom scheme.", mlog.Err(err))
allSucceeded = false
} else {
scheme.DefaultTeamGuestRole = saveRoleResult.Data.(*model.Role).Name
scheme.DefaultTeamGuestRole = savedRole.Name
}
// Channel Guest Role
@@ -222,18 +211,16 @@ func (a *App) DoGuestRolesCreationMigration() {
SchemeManaged: true,
}
if saveRoleResult := <-a.Srv.Store.Role().Save(channelGuestRole); saveRoleResult.Err != nil {
mlog.Critical("Failed to create new guest role for custom scheme.")
mlog.Critical(fmt.Sprint(saveRoleResult.Err))
if savedRole, err := a.Srv.Store.Role().Save(channelGuestRole); err != nil {
mlog.Critical("Failed to create new guest role for custom scheme.", mlog.Err(err))
allSucceeded = false
} else {
scheme.DefaultChannelGuestRole = saveRoleResult.Data.(*model.Role).Name
scheme.DefaultChannelGuestRole = savedRole.Name
}
result := <-a.Srv.Store.Scheme().Save(scheme)
if result.Err != nil {
mlog.Critical("Failed to update custom scheme.")
mlog.Critical(fmt.Sprint(result.Err))
mlog.Critical("Failed to update custom scheme.", mlog.Err(result.Err))
allSucceeded = false
}
}
@@ -249,8 +236,7 @@ func (a *App) DoGuestRolesCreationMigration() {
}
if result := <-a.Srv.Store.System().Save(&system); result.Err != nil {
mlog.Critical("Failed to mark guest roles creation migration as completed.")
mlog.Critical(fmt.Sprint(result.Err))
mlog.Critical("Failed to mark guest roles creation migration as completed.", mlog.Err(result.Err))
}
}

4
app/permissions.go
View File

@@ -48,8 +48,8 @@ func (a *App) ResetPermissionsSystem() *model.AppError {
}
// Purge all roles from the database.
if result := <-a.Srv.Store.Role().PermanentDeleteAll(); result.Err != nil {
return result.Err
if err := a.Srv.Store.Role().PermanentDeleteAll(); err != nil {
return err
}
// Remove the "System" table entry that marks the advanced permissions migration as done.

4
app/permissions_migrations.go
View File

@@ -143,8 +143,8 @@ func (a *App) doPermissionsMigration(key string, migrationMap permissionsMap) *m
for _, role := range roles {
role.Permissions = applyPermissionsMap(role.Name, roleMap, migrationMap)
if result := <-a.Srv.Store.Role().Save(role); result.Err != nil {
return result.Err
if _, err := a.Srv.Store.Role().Save(role); err != nil {
return err
}
}

40
app/role.go
View File

@@ -12,35 +12,19 @@ import (
)
func (a *App) GetRole(id string) (*model.Role, *model.AppError) {
result := <-a.Srv.Store.Role().Get(id)
if result.Err != nil {
return nil, result.Err
}
return result.Data.(*model.Role), nil
return a.Srv.Store.Role().Get(id)
}
func (a *App) GetAllRoles() ([]*model.Role, *model.AppError) {
result := <-a.Srv.Store.Role().GetAll()
if result.Err != nil {
return nil, result.Err
}
return result.Data.([]*model.Role), nil
return a.Srv.Store.Role().GetAll()
}
func (a *App) GetRoleByName(name string) (*model.Role, *model.AppError) {
result := <-a.Srv.Store.Role().GetByName(name)
if result.Err != nil {
return nil, result.Err
}
return result.Data.(*model.Role), nil
return a.Srv.Store.Role().GetByName(name)
}
func (a *App) GetRolesByNames(names []string) ([]*model.Role, *model.AppError) {
result := <-a.Srv.Store.Role().GetByNames(names)
if result.Err != nil {
return nil, result.Err
}
return result.Data.([]*model.Role), nil
return a.Srv.Store.Role().GetByNames(names)
}
func (a *App) PatchRole(role *model.Role, patch *model.RolePatch) (*model.Role, *model.AppError) {
@@ -66,22 +50,18 @@ func (a *App) CreateRole(role *model.Role) (*model.Role, *model.AppError) {
role.BuiltIn = false
role.SchemeManaged = false
result := <-a.Srv.Store.Role().Save(role)
if result.Err != nil {
return nil, result.Err
}
return result.Data.(*model.Role), nil
return a.Srv.Store.Role().Save(role)
}
func (a *App) UpdateRole(role *model.Role) (*model.Role, *model.AppError) {
result := <-a.Srv.Store.Role().Save(role)
if result.Err != nil {
return nil, result.Err
savedRole, err := a.Srv.Store.Role().Save(role)
if err != nil {
return nil, err
}
a.sendUpdatedRoleEvent(role)
a.sendUpdatedRoleEvent(savedRole)
return role, nil
return savedRole, nil
}

42
store/layered_store.go
View File

@@ -260,46 +260,32 @@ type LayeredRoleStore struct {
*LayeredStore
}
func (s *LayeredRoleStore) Save(role *model.Role) StoreChannel {
return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
return supplier.RoleSave(s.TmpContext, role)
})
func (s *LayeredRoleStore) Save(role *model.Role) (*model.Role, *model.AppError) {
return s.LayerChainHead.RoleSave(s.TmpContext, role)
}
func (s *LayeredRoleStore) Get(roleId string) StoreChannel {
return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
return supplier.RoleGet(s.TmpContext, roleId)
})
func (s *LayeredRoleStore) Get(roleId string) (*model.Role, *model.AppError) {
return s.LayerChainHead.RoleGet(s.TmpContext, roleId)
}
func (s *LayeredRoleStore) GetAll() StoreChannel {
return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
return supplier.RoleGetAll(s.TmpContext)
})
func (s *LayeredRoleStore) GetAll() ([]*model.Role, *model.AppError) {
return s.LayerChainHead.RoleGetAll(s.TmpContext)
}
func (s *LayeredRoleStore) GetByName(name string) StoreChannel {
return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
return supplier.RoleGetByName(s.TmpContext, name)
})
func (s *LayeredRoleStore) GetByName(name string) (*model.Role, *model.AppError) {
return s.LayerChainHead.RoleGetByName(s.TmpContext, name)
}
func (s *LayeredRoleStore) GetByNames(names []string) StoreChannel {
return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
return supplier.RoleGetByNames(s.TmpContext, names)
})
func (s *LayeredRoleStore) GetByNames(names []string) ([]*model.Role, *model.AppError) {
return s.LayerChainHead.RoleGetByNames(s.TmpContext, names)
}
func (s *LayeredRoleStore) Delete(roldId string) StoreChannel {
return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
return supplier.RoleDelete(s.TmpContext, roldId)
})
func (s *LayeredRoleStore) Delete(roldId string) (*model.Role, *model.AppError) {
return s.LayerChainHead.RoleDelete(s.TmpContext, roldId)
}
func (s *LayeredRoleStore) PermanentDeleteAll() StoreChannel {
return s.RunQuery(func(supplier LayeredStoreSupplier) *LayeredStoreSupplierResult {
return supplier.RolePermanentDeleteAll(s.TmpContext)
})
func (s *LayeredRoleStore) PermanentDeleteAll() *model.AppError {
return s.LayerChainHead.RolePermanentDeleteAll(s.TmpContext)
}
type LayeredSchemeStore struct {

14
store/layered_store_supplier.go
View File

@@ -32,13 +32,13 @@ type LayeredStoreSupplier interface {
ReactionsBulkGetForPosts(ctx context.Context, postIds []string, hints ...LayeredStoreHint) ([]*model.Reaction, *model.AppError)
// Roles
RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
RoleGetByNames(ctx context.Context, names []string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
RoleDelete(ctx context.Context, roldId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult
RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) (*model.Role, *model.AppError)
RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError)
RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError)
RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) (*model.Role, *model.AppError)
RoleGetByNames(ctx context.Context, names []string, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError)
RoleDelete(ctx context.Context, roldId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError)
RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *model.AppError
// Schemes
SchemeSave(ctx context.Context, scheme *model.Scheme, hints ...LayeredStoreHint) *LayeredStoreSupplierResult

54
store/local_cache_supplier_roles.go
View File

@@ -17,38 +17,43 @@ func (s *LocalCacheSupplier) handleClusterInvalidateRole(msg *model.ClusterMessa
}
}
func (s *LocalCacheSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *LocalCacheSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
if len(role.Name) != 0 {
defer s.doInvalidateCacheCluster(s.roleCache, role.Name)
}
return s.Next().RoleSave(ctx, role, hints...)
}
func (s *LocalCacheSupplier) RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *LocalCacheSupplier) RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
// Roles are cached by name, as that is most commonly how they are looked up.
// This means that no caching is supported on roles being looked up by ID.
return s.Next().RoleGet(ctx, roleId, hints...)
}
func (s *LocalCacheSupplier) RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *LocalCacheSupplier) RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError) {
// Roles are cached by name, as that is most commonly how they are looked up.
// This means that no caching is supported on roles being listed.
return s.Next().RoleGetAll(ctx, hints...)
}
func (s *LocalCacheSupplier) RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *LocalCacheSupplier) RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
if result := s.doStandardReadCache(ctx, s.roleCache, name, hints...); result != nil {
return result
return result.Data.(*model.Role), nil
}
result := s.Next().RoleGetByName(ctx, name, hints...)
role, err := s.Next().RoleGetByName(ctx, name, hints...)
if err != nil {
return nil, err
}
result := NewSupplierResult()
result.Data = role
s.doStandardAddToCache(ctx, s.roleCache, name, result, hints...)
return result
return role, nil
}
func (s *LocalCacheSupplier) RoleGetByNames(ctx context.Context, roleNames []string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *LocalCacheSupplier) RoleGetByNames(ctx context.Context, roleNames []string, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError) {
var foundRoles []*model.Role
var rolesToQuery []string
@@ -60,33 +65,30 @@ func (s *LocalCacheSupplier) RoleGetByNames(ctx context.Context, roleNames []str
}
}
result := s.Next().RoleGetByNames(ctx, rolesToQuery, hints...)
rolesFound, err := s.Next().RoleGetByNames(ctx, rolesToQuery, hints...)
if result.Data != nil {
rolesFound := result.Data.([]*model.Role)
for _, role := range rolesFound {
res := NewSupplierResult()
res.Data = role
s.doStandardAddToCache(ctx, s.roleCache, role.Name, res, hints...)
}
result.Data = append(foundRoles, result.Data.([]*model.Role)...)
for _, role := range rolesFound {
res := NewSupplierResult()
res.Data = role
s.doStandardAddToCache(ctx, s.roleCache, role.Name, res, hints...)
}
foundRoles = append(foundRoles, rolesFound...)
return result
return foundRoles, err
}
func (s *LocalCacheSupplier) RoleDelete(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
result := s.Next().RoleDelete(ctx, roleId, hints...)
if result.Err == nil {
role := result.Data.(*model.Role)
s.doInvalidateCacheCluster(s.roleCache, role.Name)
func (s *LocalCacheSupplier) RoleDelete(ctx context.Context, roleId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
role, err := s.Next().RoleDelete(ctx, roleId, hints...)
if err != nil {
return nil, err
}
return result
s.doInvalidateCacheCluster(s.roleCache, role.Name)
return role, nil
}
func (s *LocalCacheSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *LocalCacheSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *model.AppError {
defer s.roleCache.Purge()
defer s.doClearCacheCluster(s.roleCache)

40
store/redis_supplier_roles.go
View File

@@ -11,7 +11,7 @@ import (
"github.com/mattermost/mattermost-server/model"
)
func (s *RedisSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *RedisSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
key := buildRedisKeyForRoleName(role.Name)
defer func() {
@@ -23,19 +23,19 @@ func (s *RedisSupplier) RoleSave(ctx context.Context, role *model.Role, hints ..
return s.Next().RoleSave(ctx, role, hints...)
}
func (s *RedisSupplier) RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *RedisSupplier) RoleGet(ctx context.Context, roleId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
// Roles are cached by name, as that is most commonly how they are looked up.
// This means that no caching is supported on roles being looked up by ID.
return s.Next().RoleGet(ctx, roleId, hints...)
}
func (s *RedisSupplier) RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *RedisSupplier) RoleGetAll(ctx context.Context, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError) {
// Roles are cached by name, as that is most commonly how they are looked up.
// This means that no caching is supported on roles being listed.
return s.Next().RoleGetAll(ctx, hints...)
}
func (s *RedisSupplier) RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *RedisSupplier) RoleGetByName(ctx context.Context, name string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
key := buildRedisKeyForRoleName(name)
var role *model.Role
@@ -43,23 +43,21 @@ func (s *RedisSupplier) RoleGetByName(ctx context.Context, name string, hints ..
if err != nil {
mlog.Error("Redis encountered an error on read: " + err.Error())
} else if found {
result := NewSupplierResult()
result.Data = role
return result
return role, nil
}
result := s.Next().RoleGetByName(ctx, name, hints...)
role, appErr := s.Next().RoleGetByName(ctx, name, hints...)
if result.Err == nil {
if err := s.save(key, result.Data, REDIS_EXPIRY_TIME); err != nil {
if appErr == nil {
if err := s.save(key, role, REDIS_EXPIRY_TIME); err != nil {
mlog.Error("Redis encountered and error on write: " + err.Error())
}
}
return result
return role, appErr
}
func (s *RedisSupplier) RoleGetByNames(ctx context.Context, roleNames []string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *RedisSupplier) RoleGetByNames(ctx context.Context, roleNames []string, hints ...LayeredStoreHint) ([]*model.Role, *model.AppError) {
var foundRoles []*model.Role
var rolesToQuery []string
@@ -76,27 +74,25 @@ func (s *RedisSupplier) RoleGetByNames(ctx context.Context, roleNames []string,
}
}
result := s.Next().RoleGetByNames(ctx, rolesToQuery, hints...)
rolesFound, appErr := s.Next().RoleGetByNames(ctx, rolesToQuery, hints...)
if result.Err == nil {
rolesFound := result.Data.([]*model.Role)
if appErr == nil {
for _, role := range rolesFound {
if err := s.save(buildRedisKeyForRoleName(role.Name), role, REDIS_EXPIRY_TIME); err != nil {
mlog.Error("Redis encountered and error on write: " + err.Error())
}
}
result.Data = append(foundRoles, result.Data.([]*model.Role)...)
foundRoles = append(foundRoles, rolesFound...)
}
return result
return foundRoles, appErr
}
func (s *RedisSupplier) RoleDelete(ctx context.Context, roleId string, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
result := s.Next().RoleGet(ctx, roleId, hints...)
func (s *RedisSupplier) RoleDelete(ctx context.Context, roleId string, hints ...LayeredStoreHint) (*model.Role, *model.AppError) {
role, appErr := s.Next().RoleGet(ctx, roleId, hints...)
if result.Err == nil {
if appErr == nil {
defer func() {
role := result.Data.(*model.Role)
key := buildRedisKeyForRoleName(role.Name)
if err := s.client.Del(key).Err(); err != nil {
@@ -108,7 +104,7 @@ func (s *RedisSupplier) RoleDelete(ctx context.Context, roleId string, hints ...
return s.Next().RoleDelete(ctx, roleId, hints...)
}
func (s *RedisSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *LayeredStoreSupplierResult {
func (s *RedisSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...LayeredStoreHint) *model.AppError {
defer func() {
if keys, err := s.client.Keys("roles:*").Result(); err != nil {
mlog.Error("Redis encountered an error on read: " + err.Error())

143
store/sqlstore/role_supplier.go
View File

@@ -79,52 +79,43 @@ func initSqlSupplierRoles(sqlStore SqlStore) {
}
}
func (s *SqlSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
result := store.NewSupplierResult()
func (s *SqlSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
// Check the role is valid before proceeding.
if !role.IsValidWithoutId() {
result.Err = model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.invalid_role.app_error", nil, "", http.StatusBadRequest)
return result
return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.invalid_role.app_error", nil, "", http.StatusBadRequest)
}
if len(role.Id) == 0 {
if transaction, err := s.GetMaster().Begin(); err != nil {
result.Err = model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
return result
} else {
defer finalizeTransaction(transaction)
result = s.createRole(ctx, role, transaction, hints...)
if result.Err != nil {
transaction.Rollback()
} else if err := transaction.Commit(); err != nil {
result.Err = model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save_role.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
}
transaction, err := s.GetMaster().Begin()
if err != nil {
return nil, model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save.open_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
}
} else {
dbRole := NewRoleFromModel(role)
dbRole.UpdateAt = model.GetMillis()
if rowsChanged, err := s.GetMaster().Update(dbRole); err != nil {
result.Err = model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.update.app_error", nil, err.Error(), http.StatusInternalServerError)
} else if rowsChanged != 1 {
result.Err = model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.update.app_error", nil, "no record to update", http.StatusInternalServerError)
defer finalizeTransaction(transaction)
createdRole, appErr := s.createRole(ctx, role, transaction, hints...)
if appErr != nil {
transaction.Rollback()
return nil, appErr
} else if err := transaction.Commit(); err != nil {
return nil, model.NewAppError("SqlRoleStore.RoleSave", "store.sql_role.save_role.commit_transaction.app_error", nil, err.Error(), http.StatusInternalServerError)
}
result.Data = dbRole.ToModel()
return createdRole, nil
}
return result
dbRole := NewRoleFromModel(role)
dbRole.UpdateAt = model.GetMillis()
if rowsChanged, err := s.GetMaster().Update(dbRole); err != nil {
return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.update.app_error", nil, err.Error(), http.StatusInternalServerError)
} else if rowsChanged != 1 {
return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.update.app_error", nil, "no record to update", http.StatusInternalServerError)
}
return dbRole.ToModel(), nil
}
func (s *SqlSupplier) createRole(ctx context.Context, role *model.Role, transaction *gorp.Transaction, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
result := store.NewSupplierResult()
func (s *SqlSupplier) createRole(ctx context.Context, role *model.Role, transaction *gorp.Transaction, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
// Check the role is valid before proceeding.
if !role.IsValidWithoutId() {
result.Err = model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.invalid_role.app_error", nil, "", http.StatusBadRequest)
return result
return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.invalid_role.app_error", nil, "", http.StatusBadRequest)
}
dbRole := NewRoleFromModel(role)
@@ -134,80 +125,60 @@ func (s *SqlSupplier) createRole(ctx context.Context, role *model.Role, transact
dbRole.UpdateAt = dbRole.CreateAt
if err := transaction.Insert(dbRole); err != nil {
result.Err = model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.insert.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, model.NewAppError("SqlRoleStore.Save", "store.sql_role.save.insert.app_error", nil, err.Error(), http.StatusInternalServerError)
}
result.Data = dbRole.ToModel()
return result
return dbRole.ToModel(), nil
}
func (s *SqlSupplier) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
result := store.NewSupplierResult()
func (s *SqlSupplier) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
var dbRole Role
if err := s.GetReplica().SelectOne(&dbRole, "SELECT * from Roles WHERE Id = :Id", map[string]interface{}{"Id": roleId}); err != nil {
if err == sql.ErrNoRows {
result.Err = model.NewAppError("SqlRoleStore.Get", "store.sql_role.get.app_error", nil, "Id="+roleId+", "+err.Error(), http.StatusNotFound)
} else {
result.Err = model.NewAppError("SqlRoleStore.Get", "store.sql_role.get.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, model.NewAppError("SqlRoleStore.Get", "store.sql_role.get.app_error", nil, "Id="+roleId+", "+err.Error(), http.StatusNotFound)
}
return nil, model.NewAppError("SqlRoleStore.Get", "store.sql_role.get.app_error", nil, err.Error(), http.StatusInternalServerError)
}
result.Data = dbRole.ToModel()
return result
return dbRole.ToModel(), nil
}
func (s *SqlSupplier) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
result := store.NewSupplierResult()
func (s *SqlSupplier) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
var dbRoles []Role
if _, err := s.GetReplica().Select(&dbRoles, "SELECT * from Roles", map[string]interface{}{}); err != nil {
if err == sql.ErrNoRows {
result.Err = model.NewAppError("SqlRoleStore.GetAll", "store.sql_role.get_all.app_error", nil, err.Error(), http.StatusNotFound)
} else {
result.Err = model.NewAppError("SqlRoleStore.GetAll", "store.sql_role.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, model.NewAppError("SqlRoleStore.GetAll", "store.sql_role.get_all.app_error", nil, err.Error(), http.StatusNotFound)
}
return nil, model.NewAppError("SqlRoleStore.GetAll", "store.sql_role.get_all.app_error", nil, err.Error(), http.StatusInternalServerError)
}
var roles []*model.Role
for _, dbRole := range dbRoles {
roles = append(roles, dbRole.ToModel())
}
result.Data = roles
return result
return roles, nil
}
func (s *SqlSupplier) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
result := store.NewSupplierResult()
func (s *SqlSupplier) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
var dbRole Role
if err := s.GetReplica().SelectOne(&dbRole, "SELECT * from Roles WHERE Name = :Name", map[string]interface{}{"Name": name}); err != nil {
if err == sql.ErrNoRows {
result.Err = model.NewAppError("SqlRoleStore.GetByName", "store.sql_role.get_by_name.app_error", nil, "name="+name+",err="+err.Error(), http.StatusNotFound)
} else {
result.Err = model.NewAppError("SqlRoleStore.GetByName", "store.sql_role.get_by_name.app_error", nil, "name="+name+",err="+err.Error(), http.StatusInternalServerError)
return nil, model.NewAppError("SqlRoleStore.GetByName", "store.sql_role.get_by_name.app_error", nil, "name="+name+",err="+err.Error(), http.StatusNotFound)
}
return nil, model.NewAppError("SqlRoleStore.GetByName", "store.sql_role.get_by_name.app_error", nil, "name="+name+",err="+err.Error(), http.StatusInternalServerError)
}
result.Data = dbRole.ToModel()
return result
return dbRole.ToModel(), nil
}
func (s *SqlSupplier) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
result := store.NewSupplierResult()
func (s *SqlSupplier) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
var dbRoles []*Role
if len(names) == 0 {
result.Data = []*model.Role{}
return result
return []*model.Role{}, nil
}
var searchPlaceholders []string
@@ -220,7 +191,7 @@ func (s *SqlSupplier) RoleGetByNames(ctx context.Context, names []string, hints
searchTerm := "Name IN (" + strings.Join(searchPlaceholders, ", ") + ")"
if _, err := s.GetReplica().Select(&dbRoles, "SELECT * from Roles WHERE "+searchTerm, parameters); err != nil {
result.Err = model.NewAppError("SqlRoleStore.GetByNames", "store.sql_role.get_by_names.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, model.NewAppError("SqlRoleStore.GetByNames", "store.sql_role.get_by_names.app_error", nil, err.Error(), http.StatusInternalServerError)
}
var roles []*model.Role
@@ -228,24 +199,17 @@ func (s *SqlSupplier) RoleGetByNames(ctx context.Context, names []string, hints
roles = append(roles, dbRole.ToModel())
}
result.Data = roles
return result
return roles, nil
}
func (s *SqlSupplier) RoleDelete(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
result := store.NewSupplierResult()
func (s *SqlSupplier) RoleDelete(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
// Get the role.
var role *Role
if err := s.GetReplica().SelectOne(&role, "SELECT * from Roles WHERE Id = :Id", map[string]interface{}{"Id": roleId}); err != nil {
if err == sql.ErrNoRows {
result.Err = model.NewAppError("SqlRoleStore.Delete", "store.sql_role.get.app_error", nil, "Id="+roleId+", "+err.Error(), http.StatusNotFound)
} else {
result.Err = model.NewAppError("SqlRoleStore.Delete", "store.sql_role.get.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, model.NewAppError("SqlRoleStore.Delete", "store.sql_role.get.app_error", nil, "Id="+roleId+", "+err.Error(), http.StatusNotFound)
}
return result
return nil, model.NewAppError("SqlRoleStore.Delete", "store.sql_role.get.app_error", nil, err.Error(), http.StatusInternalServerError)
}
time := model.GetMillis()
@@ -253,22 +217,17 @@ func (s *SqlSupplier) RoleDelete(ctx context.Context, roleId string, hints ...st
role.UpdateAt = time
if rowsChanged, err := s.GetMaster().Update(role); err != nil {
result.Err = model.NewAppError("SqlRoleStore.Delete", "store.sql_role.delete.update.app_error", nil, err.Error(), http.StatusInternalServerError)
return nil, model.NewAppError("SqlRoleStore.Delete", "store.sql_role.delete.update.app_error", nil, err.Error(), http.StatusInternalServerError)
} else if rowsChanged != 1 {
result.Err = model.NewAppError("SqlRoleStore.Delete", "store.sql_role.delete.update.app_error", nil, "no record to update", http.StatusInternalServerError)
} else {
result.Data = role.ToModel()
return nil, model.NewAppError("SqlRoleStore.Delete", "store.sql_role.delete.update.app_error", nil, "no record to update", http.StatusInternalServerError)
}
return result
return role.ToModel(), nil
}
func (s *SqlSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
result := store.NewSupplierResult()
func (s *SqlSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *model.AppError {
if _, err := s.GetMaster().Exec("DELETE FROM Roles"); err != nil {
result.Err = model.NewAppError("SqlRoleStore.PermanentDeleteAll", "store.sql_role.permanent_delete_all.app_error", nil, err.Error(), http.StatusInternalServerError)
return model.NewAppError("SqlRoleStore.PermanentDeleteAll", "store.sql_role.permanent_delete_all.app_error", nil, err.Error(), http.StatusInternalServerError)
}
return result
return nil
}

81
store/sqlstore/scheme_supplier.go
View File

@@ -75,33 +75,34 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
// Fetch the default system scheme roles to populate default permissions.
defaultRoleNames := []string{model.TEAM_ADMIN_ROLE_ID, model.TEAM_USER_ROLE_ID, model.TEAM_GUEST_ROLE_ID, model.CHANNEL_ADMIN_ROLE_ID, model.CHANNEL_USER_ROLE_ID, model.CHANNEL_GUEST_ROLE_ID}
defaultRoles := make(map[string]*model.Role)
if rolesResult := s.RoleGetByNames(ctx, defaultRoleNames); rolesResult.Err != nil {
result.Err = rolesResult.Err
roles, err := s.RoleGetByNames(ctx, defaultRoleNames)
if err != nil {
result.Err = err
return result
} else {
for _, role := range rolesResult.Data.([]*model.Role) {
switch role.Name {
case model.TEAM_ADMIN_ROLE_ID:
defaultRoles[model.TEAM_ADMIN_ROLE_ID] = role
case model.TEAM_USER_ROLE_ID:
defaultRoles[model.TEAM_USER_ROLE_ID] = role
case model.TEAM_GUEST_ROLE_ID:
defaultRoles[model.TEAM_GUEST_ROLE_ID] = role
case model.CHANNEL_ADMIN_ROLE_ID:
defaultRoles[model.CHANNEL_ADMIN_ROLE_ID] = role
case model.CHANNEL_USER_ROLE_ID:
defaultRoles[model.CHANNEL_USER_ROLE_ID] = role
case model.CHANNEL_GUEST_ROLE_ID:
defaultRoles[model.CHANNEL_GUEST_ROLE_ID] = role
}
}
}
if len(defaultRoles) != 6 {
result.Err = model.NewAppError("SqlSchemeStore.SaveScheme", "store.sql_scheme.save.retrieve_default_scheme_roles.app_error", nil, "", http.StatusInternalServerError)
return result
for _, role := range roles {
switch role.Name {
case model.TEAM_ADMIN_ROLE_ID:
defaultRoles[model.TEAM_ADMIN_ROLE_ID] = role
case model.TEAM_USER_ROLE_ID:
defaultRoles[model.TEAM_USER_ROLE_ID] = role
case model.TEAM_GUEST_ROLE_ID:
defaultRoles[model.TEAM_GUEST_ROLE_ID] = role
case model.CHANNEL_ADMIN_ROLE_ID:
defaultRoles[model.CHANNEL_ADMIN_ROLE_ID] = role
case model.CHANNEL_USER_ROLE_ID:
defaultRoles[model.CHANNEL_USER_ROLE_ID] = role
case model.CHANNEL_GUEST_ROLE_ID:
defaultRoles[model.CHANNEL_GUEST_ROLE_ID] = role
}
}
if len(defaultRoles) != 6 {
result.Err = model.NewAppError("SqlSchemeStore.SaveScheme", "store.sql_scheme.save.retrieve_default_scheme_roles.app_error", nil, "", http.StatusInternalServerError)
return result
}
// Create the appropriate default roles for the scheme.
if scheme.Scope == model.SCHEME_SCOPE_TEAM {
// Team Admin Role
@@ -112,11 +113,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
SchemeManaged: true,
}
if saveRoleResult := s.createRole(ctx, teamAdminRole, transaction); saveRoleResult.Err != nil {
result.Err = saveRoleResult.Err
if savedRole, err := s.createRole(ctx, teamAdminRole, transaction); err != nil {
result.Err = err
return result
} else {
scheme.DefaultTeamAdminRole = saveRoleResult.Data.(*model.Role).Name
scheme.DefaultTeamAdminRole = savedRole.Name
}
// Team User Role
@@ -127,11 +128,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
SchemeManaged: true,
}
if saveRoleResult := s.createRole(ctx, teamUserRole, transaction); saveRoleResult.Err != nil {
result.Err = saveRoleResult.Err
if savedRole, err := s.createRole(ctx, teamUserRole, transaction); err != nil {
result.Err = err
return result
} else {
scheme.DefaultTeamUserRole = saveRoleResult.Data.(*model.Role).Name
scheme.DefaultTeamUserRole = savedRole.Name
}
// Team Guest Role
@@ -142,11 +143,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
SchemeManaged: true,
}
if saveRoleResult := s.createRole(ctx, teamGuestRole, transaction); saveRoleResult.Err != nil {
result.Err = saveRoleResult.Err
if savedRole, err := s.createRole(ctx, teamGuestRole, transaction); err != nil {
result.Err = err
return result
} else {
scheme.DefaultTeamGuestRole = saveRoleResult.Data.(*model.Role).Name
scheme.DefaultTeamGuestRole = savedRole.Name
}
}
if scheme.Scope == model.SCHEME_SCOPE_TEAM || scheme.Scope == model.SCHEME_SCOPE_CHANNEL {
@@ -158,11 +159,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
SchemeManaged: true,
}
if saveRoleResult := s.createRole(ctx, channelAdminRole, transaction); saveRoleResult.Err != nil {
result.Err = saveRoleResult.Err
if savedRole, err := s.createRole(ctx, channelAdminRole, transaction); err != nil {
result.Err = err
return result
} else {
scheme.DefaultChannelAdminRole = saveRoleResult.Data.(*model.Role).Name
scheme.DefaultChannelAdminRole = savedRole.Name
}
// Channel User Role
@@ -173,11 +174,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
SchemeManaged: true,
}
if saveRoleResult := s.createRole(ctx, channelUserRole, transaction); saveRoleResult.Err != nil {
result.Err = saveRoleResult.Err
if savedRole, err := s.createRole(ctx, channelUserRole, transaction); err != nil {
result.Err = err
return result
} else {
scheme.DefaultChannelUserRole = saveRoleResult.Data.(*model.Role).Name
scheme.DefaultChannelUserRole = savedRole.Name
}
// Channel Guest Role
@@ -188,11 +189,11 @@ func (s *SqlSupplier) createScheme(ctx context.Context, scheme *model.Scheme, tr
SchemeManaged: true,
}
if saveRoleResult := s.createRole(ctx, channelGuestRole, transaction); saveRoleResult.Err != nil {
result.Err = saveRoleResult.Err
if savedRole, err := s.createRole(ctx, channelGuestRole, transaction); err != nil {
result.Err = err
return result
} else {
scheme.DefaultChannelGuestRole = saveRoleResult.Data.(*model.Role).Name
scheme.DefaultChannelGuestRole = savedRole.Name
}
}

14
store/store.go
View File

@@ -538,13 +538,13 @@ type PluginStore interface {
}
type RoleStore interface {
Save(role *model.Role) StoreChannel
Get(roleId string) StoreChannel
GetAll() StoreChannel
GetByName(name string) StoreChannel
GetByNames(names []string) StoreChannel
Delete(roldId string) StoreChannel
PermanentDeleteAll() StoreChannel
Save(role *model.Role) (*model.Role, *model.AppError)
Get(roleId string) (*model.Role, *model.AppError)
GetAll() ([]*model.Role, *model.AppError)
GetByName(name string) (*model.Role, *model.AppError)
GetByNames(names []string) ([]*model.Role, *model.AppError)
Delete(roldId string) (*model.Role, *model.AppError)
PermanentDeleteAll() *model.AppError
}
type SchemeStore interface {

122
store/storetest/mocks/LayeredStoreDatabaseLayer.go
View File

@@ -1081,7 +1081,7 @@ func (_m *LayeredStoreDatabaseLayer) Role() store.RoleStore {
}
// RoleDelete provides a mock function with given fields: ctx, roldId, hints
func (_m *LayeredStoreDatabaseLayer) RoleDelete(ctx context.Context, roldId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreDatabaseLayer) RoleDelete(ctx context.Context, roldId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -1091,20 +1091,29 @@ func (_m *LayeredStoreDatabaseLayer) RoleDelete(ctx context.Context, roldId stri
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
r0 = rf(ctx, roldId, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, roldId, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// RoleGet provides a mock function with given fields: ctx, roleId, hints
func (_m *LayeredStoreDatabaseLayer) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreDatabaseLayer) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -1114,20 +1123,29 @@ func (_m *LayeredStoreDatabaseLayer) RoleGet(ctx context.Context, roleId string,
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
r0 = rf(ctx, roleId, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, roleId, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// RoleGetAll provides a mock function with given fields: ctx, hints
func (_m *LayeredStoreDatabaseLayer) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreDatabaseLayer) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -1137,20 +1155,29 @@ func (_m *LayeredStoreDatabaseLayer) RoleGetAll(ctx context.Context, hints ...st
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 []*model.Role
if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) []*model.Role); ok {
r0 = rf(ctx, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).([]*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// RoleGetByName provides a mock function with given fields: ctx, name, hints
func (_m *LayeredStoreDatabaseLayer) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreDatabaseLayer) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -1160,20 +1187,29 @@ func (_m *LayeredStoreDatabaseLayer) RoleGetByName(ctx context.Context, name str
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
r0 = rf(ctx, name, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, name, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// RoleGetByNames provides a mock function with given fields: ctx, names, hints
func (_m *LayeredStoreDatabaseLayer) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreDatabaseLayer) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -1183,20 +1219,29 @@ func (_m *LayeredStoreDatabaseLayer) RoleGetByNames(ctx context.Context, names [
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, []string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 []*model.Role
if rf, ok := ret.Get(0).(func(context.Context, []string, ...store.LayeredStoreHint) []*model.Role); ok {
r0 = rf(ctx, names, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).([]*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, []string, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, names, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// RolePermanentDeleteAll provides a mock function with given fields: ctx, hints
func (_m *LayeredStoreDatabaseLayer) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreDatabaseLayer) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *model.AppError {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -1206,12 +1251,12 @@ func (_m *LayeredStoreDatabaseLayer) RolePermanentDeleteAll(ctx context.Context,
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 *model.AppError
if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *model.AppError); ok {
r0 = rf(ctx, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).(*model.AppError)
}
}
@@ -1219,7 +1264,7 @@ func (_m *LayeredStoreDatabaseLayer) RolePermanentDeleteAll(ctx context.Context,
}
// RoleSave provides a mock function with given fields: ctx, role, hints
func (_m *LayeredStoreDatabaseLayer) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreDatabaseLayer) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -1229,16 +1274,25 @@ func (_m *LayeredStoreDatabaseLayer) RoleSave(ctx context.Context, role *model.R
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *model.Role); ok {
r0 = rf(ctx, role, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, role, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// Scheme provides a mock function with given fields:

122
store/storetest/mocks/LayeredStoreSupplier.go
View File

@@ -741,7 +741,7 @@ func (_m *LayeredStoreSupplier) ReactionsBulkGetForPosts(ctx context.Context, po
}
// RoleDelete provides a mock function with given fields: ctx, roldId, hints
func (_m *LayeredStoreSupplier) RoleDelete(ctx context.Context, roldId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreSupplier) RoleDelete(ctx context.Context, roldId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -751,20 +751,29 @@ func (_m *LayeredStoreSupplier) RoleDelete(ctx context.Context, roldId string, h
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
r0 = rf(ctx, roldId, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, roldId, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// RoleGet provides a mock function with given fields: ctx, roleId, hints
func (_m *LayeredStoreSupplier) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreSupplier) RoleGet(ctx context.Context, roleId string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -774,20 +783,29 @@ func (_m *LayeredStoreSupplier) RoleGet(ctx context.Context, roleId string, hint
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
r0 = rf(ctx, roleId, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, roleId, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// RoleGetAll provides a mock function with given fields: ctx, hints
func (_m *LayeredStoreSupplier) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreSupplier) RoleGetAll(ctx context.Context, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -797,20 +815,29 @@ func (_m *LayeredStoreSupplier) RoleGetAll(ctx context.Context, hints ...store.L
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 []*model.Role
if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) []*model.Role); ok {
r0 = rf(ctx, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).([]*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// RoleGetByName provides a mock function with given fields: ctx, name, hints
func (_m *LayeredStoreSupplier) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreSupplier) RoleGetByName(ctx context.Context, name string, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -820,20 +847,29 @@ func (_m *LayeredStoreSupplier) RoleGetByName(ctx context.Context, name string,
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(context.Context, string, ...store.LayeredStoreHint) *model.Role); ok {
r0 = rf(ctx, name, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, string, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, name, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// RoleGetByNames provides a mock function with given fields: ctx, names, hints
func (_m *LayeredStoreSupplier) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreSupplier) RoleGetByNames(ctx context.Context, names []string, hints ...store.LayeredStoreHint) ([]*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -843,20 +879,29 @@ func (_m *LayeredStoreSupplier) RoleGetByNames(ctx context.Context, names []stri
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, []string, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 []*model.Role
if rf, ok := ret.Get(0).(func(context.Context, []string, ...store.LayeredStoreHint) []*model.Role); ok {
r0 = rf(ctx, names, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).([]*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, []string, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, names, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// RolePermanentDeleteAll provides a mock function with given fields: ctx, hints
func (_m *LayeredStoreSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreSupplier) RolePermanentDeleteAll(ctx context.Context, hints ...store.LayeredStoreHint) *model.AppError {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -866,12 +911,12 @@ func (_m *LayeredStoreSupplier) RolePermanentDeleteAll(ctx context.Context, hint
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 *model.AppError
if rf, ok := ret.Get(0).(func(context.Context, ...store.LayeredStoreHint) *model.AppError); ok {
r0 = rf(ctx, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).(*model.AppError)
}
}
@@ -879,7 +924,7 @@ func (_m *LayeredStoreSupplier) RolePermanentDeleteAll(ctx context.Context, hint
}
// RoleSave provides a mock function with given fields: ctx, role, hints
func (_m *LayeredStoreSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult {
func (_m *LayeredStoreSupplier) RoleSave(ctx context.Context, role *model.Role, hints ...store.LayeredStoreHint) (*model.Role, *model.AppError) {
_va := make([]interface{}, len(hints))
for _i := range hints {
_va[_i] = hints[_i]
@@ -889,16 +934,25 @@ func (_m *LayeredStoreSupplier) RoleSave(ctx context.Context, role *model.Role,
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
var r0 *store.LayeredStoreSupplierResult
if rf, ok := ret.Get(0).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *store.LayeredStoreSupplierResult); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *model.Role); ok {
r0 = rf(ctx, role, hints...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*store.LayeredStoreSupplierResult)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(context.Context, *model.Role, ...store.LayeredStoreHint) *model.AppError); ok {
r1 = rf(ctx, role, hints...)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// SchemeDelete provides a mock function with given fields: ctx, schemeId, hints

123
store/storetest/mocks/RoleStore.go
View File

@@ -6,7 +6,6 @@ package mocks
import mock "github.com/stretchr/testify/mock"
import model "github.com/mattermost/mattermost-server/model"
import store "github.com/mattermost/mattermost-server/store"
// RoleStore is an autogenerated mock type for the RoleStore type
type RoleStore struct {
@@ -14,95 +13,140 @@ type RoleStore struct {
}
// Delete provides a mock function with given fields: roldId
func (_m *RoleStore) Delete(roldId string) store.StoreChannel {
func (_m *RoleStore) Delete(roldId string) (*model.Role, *model.AppError) {
ret := _m.Called(roldId)
var r0 store.StoreChannel
if rf, ok := ret.Get(0).(func(string) store.StoreChannel); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(string) *model.Role); ok {
r0 = rf(roldId)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.StoreChannel)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
r1 = rf(roldId)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// Get provides a mock function with given fields: roleId
func (_m *RoleStore) Get(roleId string) store.StoreChannel {
func (_m *RoleStore) Get(roleId string) (*model.Role, *model.AppError) {
ret := _m.Called(roleId)
var r0 store.StoreChannel
if rf, ok := ret.Get(0).(func(string) store.StoreChannel); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(string) *model.Role); ok {
r0 = rf(roleId)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.StoreChannel)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
r1 = rf(roleId)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// GetAll provides a mock function with given fields:
func (_m *RoleStore) GetAll() store.StoreChannel {
func (_m *RoleStore) GetAll() ([]*model.Role, *model.AppError) {
ret := _m.Called()
var r0 store.StoreChannel
if rf, ok := ret.Get(0).(func() store.StoreChannel); ok {
var r0 []*model.Role
if rf, ok := ret.Get(0).(func() []*model.Role); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.StoreChannel)
r0 = ret.Get(0).([]*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func() *model.AppError); ok {
r1 = rf()
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// GetByName provides a mock function with given fields: name
func (_m *RoleStore) GetByName(name string) store.StoreChannel {
func (_m *RoleStore) GetByName(name string) (*model.Role, *model.AppError) {
ret := _m.Called(name)
var r0 store.StoreChannel
if rf, ok := ret.Get(0).(func(string) store.StoreChannel); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(string) *model.Role); ok {
r0 = rf(name)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.StoreChannel)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
r1 = rf(name)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// GetByNames provides a mock function with given fields: names
func (_m *RoleStore) GetByNames(names []string) store.StoreChannel {
func (_m *RoleStore) GetByNames(names []string) ([]*model.Role, *model.AppError) {
ret := _m.Called(names)
var r0 store.StoreChannel
if rf, ok := ret.Get(0).(func([]string) store.StoreChannel); ok {
var r0 []*model.Role
if rf, ok := ret.Get(0).(func([]string) []*model.Role); ok {
r0 = rf(names)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.StoreChannel)
r0 = ret.Get(0).([]*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func([]string) *model.AppError); ok {
r1 = rf(names)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}
// PermanentDeleteAll provides a mock function with given fields:
func (_m *RoleStore) PermanentDeleteAll() store.StoreChannel {
func (_m *RoleStore) PermanentDeleteAll() *model.AppError {
ret := _m.Called()
var r0 store.StoreChannel
if rf, ok := ret.Get(0).(func() store.StoreChannel); ok {
var r0 *model.AppError
if rf, ok := ret.Get(0).(func() *model.AppError); ok {
r0 = rf()
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.StoreChannel)
r0 = ret.Get(0).(*model.AppError)
}
}
@@ -110,17 +154,26 @@ func (_m *RoleStore) PermanentDeleteAll() store.StoreChannel {
}
// Save provides a mock function with given fields: role
func (_m *RoleStore) Save(role *model.Role) store.StoreChannel {
func (_m *RoleStore) Save(role *model.Role) (*model.Role, *model.AppError) {
ret := _m.Called(role)
var r0 store.StoreChannel
if rf, ok := ret.Get(0).(func(*model.Role) store.StoreChannel); ok {
var r0 *model.Role
if rf, ok := ret.Get(0).(func(*model.Role) *model.Role); ok {
r0 = rf(role)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(store.StoreChannel)
r0 = ret.Get(0).(*model.Role)
}
}
return r0
var r1 *model.AppError
if rf, ok := ret.Get(1).(func(*model.Role) *model.AppError); ok {
r1 = rf(role)
} else {
if ret.Get(1) != nil {
r1 = ret.Get(1).(*model.AppError)
}
}
return r0, r1
}

144
store/storetest/role_store.go
View File

@@ -37,9 +37,8 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
SchemeManaged: false,
}
res1 := <-ss.Role().Save(r1)
assert.Nil(t, res1.Err)
d1 := res1.Data.(*model.Role)
d1, err := ss.Role().Save(r1)
assert.Nil(t, err)
assert.Len(t, d1.Id, 26)
assert.Equal(t, r1.Name, d1.Name)
assert.Equal(t, r1.DisplayName, d1.DisplayName)
@@ -54,9 +53,8 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
"delete_public_channel",
}
res2 := <-ss.Role().Save(d1)
assert.Nil(t, res2.Err)
d2 := res2.Data.(*model.Role)
d2, err := ss.Role().Save(d1)
assert.Nil(t, err)
assert.Len(t, d2.Id, 26)
assert.Equal(t, r1.Name, d2.Name)
assert.Equal(t, r1.DisplayName, d2.DisplayName)
@@ -78,8 +76,8 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
SchemeManaged: false,
}
res3 := <-ss.Role().Save(r3)
assert.NotNil(t, res3.Err)
_, err = ss.Role().Save(r3)
assert.NotNil(t, err)
// Try saving one with a duplicate "name" field.
r4 := &model.Role{
@@ -94,14 +92,14 @@ func testRoleStoreSave(t *testing.T, ss store.Store) {
SchemeManaged: false,
}
res4 := <-ss.Role().Save(r4)
assert.NotNil(t, res4.Err)
_, err = ss.Role().Save(r4)
assert.NotNil(t, err)
}
func testRoleStoreGetAll(t *testing.T, ss store.Store) {
prev := <-ss.Role().GetAll()
require.Nil(t, prev.Err)
prevCount := len(prev.Data.([]*model.Role))
prev, err := ss.Role().GetAll()
require.Nil(t, err)
prevCount := len(prev)
// Save a role to test with.
r1 := &model.Role{
@@ -116,8 +114,8 @@ func testRoleStoreGetAll(t *testing.T, ss store.Store) {
SchemeManaged: false,
}
res1 := <-ss.Role().Save(r1)
require.Nil(t, res1.Err)
_, err = ss.Role().Save(r1)
require.Nil(t, err)
r2 := &model.Role{
Name: model.NewId(),
@@ -130,12 +128,11 @@ func testRoleStoreGetAll(t *testing.T, ss store.Store) {
},
SchemeManaged: false,
}
res2 := <-ss.Role().Save(r2)
require.Nil(t, res2.Err)
_, err = ss.Role().Save(r2)
require.Nil(t, err)
res3 := <-ss.Role().GetAll()
require.Nil(t, res3.Err)
data := res3.Data.([]*model.Role)
data, err := ss.Role().GetAll()
require.Nil(t, err)
assert.Len(t, data, prevCount+2)
}
@@ -153,15 +150,13 @@ func testRoleStoreGet(t *testing.T, ss store.Store) {
SchemeManaged: false,
}
res1 := <-ss.Role().Save(r1)
assert.Nil(t, res1.Err)
d1 := res1.Data.(*model.Role)
d1, err := ss.Role().Save(r1)
assert.Nil(t, err)
assert.Len(t, d1.Id, 26)
// Get a valid role
res2 := <-ss.Role().Get(d1.Id)
assert.Nil(t, res2.Err)
d2 := res1.Data.(*model.Role)
d2, err := ss.Role().Get(d1.Id)
assert.Nil(t, err)
assert.Equal(t, d1.Id, d2.Id)
assert.Equal(t, r1.Name, d2.Name)
assert.Equal(t, r1.DisplayName, d2.DisplayName)
@@ -170,8 +165,8 @@ func testRoleStoreGet(t *testing.T, ss store.Store) {
assert.Equal(t, r1.SchemeManaged, d2.SchemeManaged)
// Get an invalid role
res3 := <-ss.Role().Get(model.NewId())
assert.NotNil(t, res3.Err)
_, err = ss.Role().Get(model.NewId())
assert.NotNil(t, err)
}
func testRoleStoreGetByName(t *testing.T, ss store.Store) {
@@ -188,15 +183,13 @@ func testRoleStoreGetByName(t *testing.T, ss store.Store) {
SchemeManaged: false,
}
res1 := <-ss.Role().Save(r1)
assert.Nil(t, res1.Err)
d1 := res1.Data.(*model.Role)
d1, err := ss.Role().Save(r1)
assert.Nil(t, err)
assert.Len(t, d1.Id, 26)
// Get a valid role
res2 := <-ss.Role().GetByName(d1.Name)
assert.Nil(t, res2.Err)
d2 := res1.Data.(*model.Role)
d2, err := ss.Role().GetByName(d1.Name)
assert.Nil(t, err)
assert.Equal(t, d1.Id, d2.Id)
assert.Equal(t, r1.Name, d2.Name)
assert.Equal(t, r1.DisplayName, d2.DisplayName)
@@ -205,8 +198,8 @@ func testRoleStoreGetByName(t *testing.T, ss store.Store) {
assert.Equal(t, r1.SchemeManaged, d2.SchemeManaged)
// Get an invalid role
res3 := <-ss.Role().GetByName(model.NewId())
assert.NotNil(t, res3.Err)
_, err = ss.Role().GetByName(model.NewId())
assert.NotNil(t, err)
}
func testRoleStoreGetByNames(t *testing.T, ss store.Store) {
@@ -245,26 +238,22 @@ func testRoleStoreGetByNames(t *testing.T, ss store.Store) {
SchemeManaged: false,
}
res1 := <-ss.Role().Save(r1)
assert.Nil(t, res1.Err)
d1 := res1.Data.(*model.Role)
d1, err := ss.Role().Save(r1)
assert.Nil(t, err)
assert.Len(t, d1.Id, 26)
res2 := <-ss.Role().Save(r2)
assert.Nil(t, res2.Err)
d2 := res2.Data.(*model.Role)
d2, err := ss.Role().Save(r2)
assert.Nil(t, err)
assert.Len(t, d2.Id, 26)
res3 := <-ss.Role().Save(r3)
assert.Nil(t, res3.Err)
d3 := res3.Data.(*model.Role)
d3, err := ss.Role().Save(r3)
assert.Nil(t, err)
assert.Len(t, d3.Id, 26)
// Get two valid roles.
n4 := []string{r1.Name, r2.Name}
res4 := <-ss.Role().GetByNames(n4)
assert.Nil(t, res4.Err)
roles4 := res4.Data.([]*model.Role)
roles4, err := ss.Role().GetByNames(n4)
assert.Nil(t, err)
assert.Len(t, roles4, 2)
assert.Contains(t, roles4, d1)
assert.Contains(t, roles4, d2)
@@ -272,16 +261,14 @@ func testRoleStoreGetByNames(t *testing.T, ss store.Store) {
// Get two invalid roles.
n5 := []string{model.NewId(), model.NewId()}
res5 := <-ss.Role().GetByNames(n5)
assert.Nil(t, res5.Err)
roles5 := res5.Data.([]*model.Role)
roles5, err := ss.Role().GetByNames(n5)
assert.Nil(t, err)
assert.Len(t, roles5, 0)
// Get one valid one and one invalid one.
n6 := []string{r1.Name, model.NewId()}
res6 := <-ss.Role().GetByNames(n6)
assert.Nil(t, res6.Err)
roles6 := res6.Data.([]*model.Role)
roles6, err := ss.Role().GetByNames(n6)
assert.Nil(t, err)
assert.Len(t, roles6, 1)
assert.Contains(t, roles6, d1)
assert.NotContains(t, roles6, d2)
@@ -302,33 +289,30 @@ func testRoleStoreDelete(t *testing.T, ss store.Store) {
SchemeManaged: false,
}
res1 := <-ss.Role().Save(r1)
assert.Nil(t, res1.Err)
d1 := res1.Data.(*model.Role)
d1, err := ss.Role().Save(r1)
assert.Nil(t, err)
assert.Len(t, d1.Id, 26)
// Check the role is there.
res2 := <-ss.Role().Get(d1.Id)
assert.Nil(t, res2.Err)
_, err = ss.Role().Get(d1.Id)
assert.Nil(t, err)
// Delete the role.
res3 := <-ss.Role().Delete(d1.Id)
assert.Nil(t, res3.Err)
_, err = ss.Role().Delete(d1.Id)
assert.Nil(t, err)
// Check the role is deleted there.
res4 := <-ss.Role().Get(d1.Id)
assert.Nil(t, res4.Err)
d2 := res4.Data.(*model.Role)
d2, err := ss.Role().Get(d1.Id)
assert.Nil(t, err)
assert.NotZero(t, d2.DeleteAt)
res5 := <-ss.Role().GetByName(d1.Name)
assert.Nil(t, res5.Err)
d3 := res5.Data.(*model.Role)
d3, err := ss.Role().GetByName(d1.Name)
assert.Nil(t, err)
assert.NotZero(t, d3.DeleteAt)
// Try and delete a role that does not exist.
res6 := <-ss.Role().Delete(model.NewId())
assert.NotNil(t, res6.Err)
_, err = ss.Role().Delete(model.NewId())
assert.NotNil(t, err)
}
func testRoleStorePermanentDeleteAll(t *testing.T, ss store.Store) {
@@ -356,17 +340,19 @@ func testRoleStorePermanentDeleteAll(t *testing.T, ss store.Store) {
SchemeManaged: false,
}
store.Must(ss.Role().Save(r1))
store.Must(ss.Role().Save(r2))
_, err := ss.Role().Save(r1)
require.Nil(t, err)
_, err = ss.Role().Save(r2)
require.Nil(t, err)
res1 := <-ss.Role().GetByNames([]string{r1.Name, r2.Name})
assert.Nil(t, res1.Err)
assert.Len(t, res1.Data.([]*model.Role), 2)
roles, err := ss.Role().GetByNames([]string{r1.Name, r2.Name})
assert.Nil(t, err)
assert.Len(t, roles, 2)
res2 := <-ss.Role().PermanentDeleteAll()
assert.Nil(t, res2.Err)
err = ss.Role().PermanentDeleteAll()
assert.Nil(t, err)
res3 := <-ss.Role().GetByNames([]string{r1.Name, r2.Name})
assert.Nil(t, res3.Err)
assert.Len(t, res3.Data.([]*model.Role), 0)
roles, err = ss.Role().GetByNames([]string{r1.Name, r2.Name})
assert.Nil(t, err)
assert.Len(t, roles, 0)
}

104
store/storetest/scheme_store.go
View File

@@ -25,7 +25,7 @@ func TestSchemeStore(t *testing.T, ss store.Store) {
}
func createDefaultRoles(t *testing.T, ss store.Store) {
<-ss.Role().Save(&model.Role{
ss.Role().Save(&model.Role{
Name: model.TEAM_ADMIN_ROLE_ID,
DisplayName: model.TEAM_ADMIN_ROLE_ID,
Permissions: []string{
@@ -33,7 +33,7 @@ func createDefaultRoles(t *testing.T, ss store.Store) {
},
})
<-ss.Role().Save(&model.Role{
ss.Role().Save(&model.Role{
Name: model.TEAM_USER_ROLE_ID,
DisplayName: model.TEAM_USER_ROLE_ID,
Permissions: []string{
@@ -42,7 +42,7 @@ func createDefaultRoles(t *testing.T, ss store.Store) {
},
})
<-ss.Role().Save(&model.Role{
ss.Role().Save(&model.Role{
Name: model.TEAM_GUEST_ROLE_ID,
DisplayName: model.TEAM_GUEST_ROLE_ID,
Permissions: []string{
@@ -50,7 +50,7 @@ func createDefaultRoles(t *testing.T, ss store.Store) {
},
})
<-ss.Role().Save(&model.Role{
ss.Role().Save(&model.Role{
Name: model.CHANNEL_ADMIN_ROLE_ID,
DisplayName: model.CHANNEL_ADMIN_ROLE_ID,
Permissions: []string{
@@ -59,7 +59,7 @@ func createDefaultRoles(t *testing.T, ss store.Store) {
},
})
<-ss.Role().Save(&model.Role{
ss.Role().Save(&model.Role{
Name: model.CHANNEL_USER_ROLE_ID,
DisplayName: model.CHANNEL_USER_ROLE_ID,
Permissions: []string{
@@ -68,7 +68,7 @@ func createDefaultRoles(t *testing.T, ss store.Store) {
},
})
<-ss.Role().Save(&model.Role{
ss.Role().Save(&model.Role{
Name: model.CHANNEL_GUEST_ROLE_ID,
DisplayName: model.CHANNEL_GUEST_ROLE_ID,
Permissions: []string{
@@ -107,39 +107,33 @@ func testSchemeStoreSave(t *testing.T, ss store.Store) {
assert.Len(t, d1.DefaultChannelGuestRole, 26)
// Check the default roles were created correctly.
roleRes1 := <-ss.Role().GetByName(d1.DefaultTeamAdminRole)
assert.Nil(t, roleRes1.Err)
role1 := roleRes1.Data.(*model.Role)
role1, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
assert.Nil(t, err)
assert.Equal(t, role1.Permissions, []string{"delete_others_posts"})
assert.True(t, role1.SchemeManaged)
roleRes2 := <-ss.Role().GetByName(d1.DefaultTeamUserRole)
assert.Nil(t, roleRes2.Err)
role2 := roleRes2.Data.(*model.Role)
role2, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
assert.Nil(t, err)
assert.Equal(t, role2.Permissions, []string{"view_team", "add_user_to_team"})
assert.True(t, role2.SchemeManaged)
roleRes3 := <-ss.Role().GetByName(d1.DefaultChannelAdminRole)
assert.Nil(t, roleRes3.Err)
role3 := roleRes3.Data.(*model.Role)
role3, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
assert.Nil(t, err)
assert.Equal(t, role3.Permissions, []string{"manage_public_channel_members", "manage_private_channel_members"})
assert.True(t, role3.SchemeManaged)
roleRes4 := <-ss.Role().GetByName(d1.DefaultChannelUserRole)
assert.Nil(t, roleRes4.Err)
role4 := roleRes4.Data.(*model.Role)
role4, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
assert.Nil(t, err)
assert.Equal(t, role4.Permissions, []string{"read_channel", "create_post"})
assert.True(t, role4.SchemeManaged)
roleRes5 := <-ss.Role().GetByName(d1.DefaultTeamGuestRole)
assert.Nil(t, roleRes5.Err)
role5 := roleRes5.Data.(*model.Role)
role5, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
assert.Nil(t, err)
assert.Equal(t, role5.Permissions, []string{"view_team"})
assert.True(t, role5.SchemeManaged)
roleRes6 := <-ss.Role().GetByName(d1.DefaultChannelGuestRole)
assert.Nil(t, roleRes6.Err)
role6 := roleRes6.Data.(*model.Role)
role6, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
assert.Nil(t, err)
assert.Equal(t, role6.Permissions, []string{"read_channel", "create_post"})
assert.True(t, role6.SchemeManaged)
@@ -350,39 +344,33 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
assert.Len(t, d1.DefaultChannelGuestRole, 26)
// Check the default roles were created correctly.
roleRes1 := <-ss.Role().GetByName(d1.DefaultTeamAdminRole)
assert.Nil(t, roleRes1.Err)
role1 := roleRes1.Data.(*model.Role)
role1, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
assert.Nil(t, err)
assert.Equal(t, role1.Permissions, []string{"delete_others_posts"})
assert.True(t, role1.SchemeManaged)
roleRes2 := <-ss.Role().GetByName(d1.DefaultTeamUserRole)
assert.Nil(t, roleRes2.Err)
role2 := roleRes2.Data.(*model.Role)
role2, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
assert.Nil(t, err)
assert.Equal(t, role2.Permissions, []string{"view_team", "add_user_to_team"})
assert.True(t, role2.SchemeManaged)
roleRes3 := <-ss.Role().GetByName(d1.DefaultChannelAdminRole)
assert.Nil(t, roleRes3.Err)
role3 := roleRes3.Data.(*model.Role)
role3, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
assert.Nil(t, err)
assert.Equal(t, role3.Permissions, []string{"manage_public_channel_members", "manage_private_channel_members"})
assert.True(t, role3.SchemeManaged)
roleRes4 := <-ss.Role().GetByName(d1.DefaultChannelUserRole)
assert.Nil(t, roleRes4.Err)
role4 := roleRes4.Data.(*model.Role)
role4, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
assert.Nil(t, err)
assert.Equal(t, role4.Permissions, []string{"read_channel", "create_post"})
assert.True(t, role4.SchemeManaged)
roleRes5 := <-ss.Role().GetByName(d1.DefaultTeamGuestRole)
assert.Nil(t, roleRes5.Err)
role5 := roleRes5.Data.(*model.Role)
role5, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
assert.Nil(t, err)
assert.Equal(t, role5.Permissions, []string{"view_team"})
assert.True(t, role5.SchemeManaged)
roleRes6 := <-ss.Role().GetByName(d1.DefaultChannelGuestRole)
assert.Nil(t, roleRes6.Err)
role6 := roleRes6.Data.(*model.Role)
role6, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
assert.Nil(t, err)
assert.Equal(t, role6.Permissions, []string{"read_channel", "create_post"})
assert.True(t, role6.SchemeManaged)
@@ -395,34 +383,28 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
assert.NotZero(t, d2.DeleteAt)
// Check that the roles are deleted too.
roleRes7 := <-ss.Role().GetByName(d1.DefaultTeamAdminRole)
assert.Nil(t, roleRes7.Err)
role7 := roleRes7.Data.(*model.Role)
role7, err := ss.Role().GetByName(d1.DefaultTeamAdminRole)
assert.Nil(t, err)
assert.NotZero(t, role7.DeleteAt)
roleRes8 := <-ss.Role().GetByName(d1.DefaultTeamUserRole)
assert.Nil(t, roleRes8.Err)
role8 := roleRes8.Data.(*model.Role)
role8, err := ss.Role().GetByName(d1.DefaultTeamUserRole)
assert.Nil(t, err)
assert.NotZero(t, role8.DeleteAt)
roleRes9 := <-ss.Role().GetByName(d1.DefaultChannelAdminRole)
assert.Nil(t, roleRes9.Err)
role9 := roleRes9.Data.(*model.Role)
role9, err := ss.Role().GetByName(d1.DefaultChannelAdminRole)
assert.Nil(t, err)
assert.NotZero(t, role9.DeleteAt)
roleRes10 := <-ss.Role().GetByName(d1.DefaultChannelUserRole)
assert.Nil(t, roleRes10.Err)
role10 := roleRes10.Data.(*model.Role)
role10, err := ss.Role().GetByName(d1.DefaultChannelUserRole)
assert.Nil(t, err)
assert.NotZero(t, role10.DeleteAt)
roleRes11 := <-ss.Role().GetByName(d1.DefaultTeamGuestRole)
assert.Nil(t, roleRes11.Err)
role11 := roleRes11.Data.(*model.Role)
role11, err := ss.Role().GetByName(d1.DefaultTeamGuestRole)
assert.Nil(t, err)
assert.NotZero(t, role11.DeleteAt)
roleRes12 := <-ss.Role().GetByName(d1.DefaultChannelGuestRole)
assert.Nil(t, roleRes12.Err)
role12 := roleRes12.Data.(*model.Role)
role12, err := ss.Role().GetByName(d1.DefaultChannelGuestRole)
assert.Nil(t, err)
assert.NotZero(t, role12.DeleteAt)
// Try deleting a scheme that does not exist.
@@ -447,7 +429,7 @@ func testSchemeStoreDelete(t *testing.T, ss store.Store) {
Type: model.TEAM_OPEN,
SchemeId: &d4.Id,
}
t4, err := ss.Team().Save(t4)
t4, err = ss.Team().Save(t4)
require.Nil(t, err)
sres4 := <-ss.Scheme().Delete(d4.Id)