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
Files
09a52aab3e4dd88e345cff6a34f1cc10b9ad078d
mattermost/store/storetest/preference_store.go
jingkai 0eafaa502d Refactor SQL queries in store/sqlstore/preference_store.go to use the squirrel builder (#17086) 
* refactor: refactored deleteUnusedFeatures

* refactor: refactored Get to remove hardcoded sql queries

* refactor: remove debug log

* refactor: refactored getcategory

* refactor: refactored GetAll to replace with sq

* refactor: refactor delete with sq

* refactor: refactored delete category with sq

* refactor: refactored cleanup flagsbatch

* refactor: refactor save to usq sq

* fix: fixed missing wildcard in LIKE operator

* refactor: fixed previous double call to database with a cleaner approach

* refactor: removed debug logs

* refactor: removed debug logs

* fix: added a new error checking as Limit accepts uint and the function parameter accepts int

* fix: golangcilint error

Co-authored-by: Mattermod <mattermod@users.noreply.github.com>
2021-04-09 11:13:31 +02:00

374 lines
10 KiB
Go
Raw Blame History

// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See LICENSE.txt for license information.
package storetest
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/mattermost/mattermost-server/v5/model"
"github.com/mattermost/mattermost-server/v5/store"
)
func TestPreferenceStore(t *testing.T, ss store.Store) {
t.Run("PreferenceSave", func(t *testing.T) { testPreferenceSave(t, ss) })
t.Run("PreferenceGet", func(t *testing.T) { testPreferenceGet(t, ss) })
t.Run("PreferenceGetCategory", func(t *testing.T) { testPreferenceGetCategory(t, ss) })
t.Run("PreferenceGetAll", func(t *testing.T) { testPreferenceGetAll(t, ss) })
t.Run("PreferenceDeleteByUser", func(t *testing.T) { testPreferenceDeleteByUser(t, ss) })
t.Run("PreferenceDelete", func(t *testing.T) { testPreferenceDelete(t, ss) })
t.Run("PreferenceDeleteCategory", func(t *testing.T) { testPreferenceDeleteCategory(t, ss) })
t.Run("PreferenceDeleteCategoryAndName", func(t *testing.T) { testPreferenceDeleteCategoryAndName(t, ss) })
t.Run("PreferenceCleanupFlagsBatch", func(t *testing.T) { testPreferenceCleanupFlagsBatch(t, ss) })
}
func testPreferenceSave(t *testing.T, ss store.Store) {
id := model.NewId()
preferences := model.Preferences{
{
UserId: id,
Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
Name: model.NewId(),
Value: "value1a",
},
{
UserId: id,
Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
Name: model.NewId(),
Value: "value1b",
},
}
err := ss.Preference().Save(&preferences)
require.NoError(t, err, "saving preference returned error")
for _, preference := range preferences {
data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name)
require.Equal(t, data.ToJson(), preference.ToJson(), "got incorrect preference after first Save")
}
preferences[0].Value = "value2a"
preferences[1].Value = "value2b"
err = ss.Preference().Save(&preferences)
require.NoError(t, err, "saving preference returned error")
for _, preference := range preferences {
data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name)
require.Equal(t, data.ToJson(), preference.ToJson(), "got incorrect preference after second Save")
}
}
func testPreferenceGet(t *testing.T, ss store.Store) {
userId := model.NewId()
category := model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
name := model.NewId()
preferences := model.Preferences{
{
UserId: userId,
Category: category,
Name: name,
},
{
UserId: userId,
Category: category,
Name: model.NewId(),
},
{
UserId: userId,
Category: model.NewId(),
Name: name,
},
{
UserId: model.NewId(),
Category: category,
Name: name,
},
}
err := ss.Preference().Save(&preferences)
require.NoError(t, err)
data, err := ss.Preference().Get(userId, category, name)
require.NoError(t, err)
require.Equal(t, preferences[0].ToJson(), data.ToJson(), "got incorrect preference")
// make sure getting a missing preference fails
_, err = ss.Preference().Get(model.NewId(), model.NewId(), model.NewId())
require.Error(t, err, "no error on getting a missing preference")
}
func testPreferenceGetCategory(t *testing.T, ss store.Store) {
userId := model.NewId()
category := model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
name := model.NewId()
preferences := model.Preferences{
{
UserId: userId,
Category: category,
Name: name,
},
// same user/category, different name
{
UserId: userId,
Category: category,
Name: model.NewId(),
},
// same user/name, different category
{
UserId: userId,
Category: model.NewId(),
Name: name,
},
// same name/category, different user
{
UserId: model.NewId(),
Category: category,
Name: name,
},
}
err := ss.Preference().Save(&preferences)
require.NoError(t, err)
preferencesByCategory, err := ss.Preference().GetCategory(userId, category)
require.NoError(t, err)
require.Equal(t, 2, len(preferencesByCategory), "got the wrong number of preferences")
require.True(
t,
((preferencesByCategory[0] == preferences[0] && preferencesByCategory[1] == preferences[1]) || (preferencesByCategory[0] == preferences[1] && preferencesByCategory[1] == preferences[0])),
"got incorrect preferences",
)
// make sure getting a missing preference category doesn't fail
preferencesByCategory, err = ss.Preference().GetCategory(model.NewId(), model.NewId())
require.NoError(t, err)
require.Equal(t, 0, len(preferencesByCategory), "shouldn't have got any preferences")
}
func testPreferenceGetAll(t *testing.T, ss store.Store) {
userId := model.NewId()
category := model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
name := model.NewId()
preferences := model.Preferences{
{
UserId: userId,
Category: category,
Name: name,
},
// same user/category, different name
{
UserId: userId,
Category: category,
Name: model.NewId(),
},
// same user/name, different category
{
UserId: userId,
Category: model.NewId(),
Name: name,
},
// same name/category, different user
{
UserId: model.NewId(),
Category: category,
Name: name,
},
}
err := ss.Preference().Save(&preferences)
require.NoError(t, err)
result, err := ss.Preference().GetAll(userId)
require.NoError(t, err)
require.Equal(t, 3, len(result), "got the wrong number of preferences")
for i := 0; i < 3; i++ {
assert.Falsef(t, result[0] != preferences[i] && result[1] != preferences[i] && result[2] != preferences[i], "got incorrect preferences")
}
}
func testPreferenceDeleteByUser(t *testing.T, ss store.Store) {
userId := model.NewId()
category := model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
name := model.NewId()
preferences := model.Preferences{
{
UserId: userId,
Category: category,
Name: name,
},
// same user/category, different name
{
UserId: userId,
Category: category,
Name: model.NewId(),
},
// same user/name, different category
{
UserId: userId,
Category: model.NewId(),
Name: name,
},
// same name/category, different user
{
UserId: model.NewId(),
Category: category,
Name: name,
},
}
err := ss.Preference().Save(&preferences)
require.NoError(t, err)
err = ss.Preference().PermanentDeleteByUser(userId)
require.NoError(t, err)
}
func testPreferenceDelete(t *testing.T, ss store.Store) {
preference := model.Preference{
UserId: model.NewId(),
Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
Name: model.NewId(),
Value: "value1a",
}
err := ss.Preference().Save(&model.Preferences{preference})
require.NoError(t, err)
preferences, err := ss.Preference().GetAll(preference.UserId)
require.NoError(t, err)
assert.Len(t, preferences, 1, "should've returned 1 preference")
err = ss.Preference().Delete(preference.UserId, preference.Category, preference.Name)
require.NoError(t, err)
preferences, err = ss.Preference().GetAll(preference.UserId)
require.NoError(t, err)
assert.Empty(t, preferences, "should've returned no preferences")
}
func testPreferenceDeleteCategory(t *testing.T, ss store.Store) {
category := model.NewId()
userId := model.NewId()
preference1 := model.Preference{
UserId: userId,
Category: category,
Name: model.NewId(),
Value: "value1a",
}
preference2 := model.Preference{
UserId: userId,
Category: category,
Name: model.NewId(),
Value: "value1a",
}
err := ss.Preference().Save(&model.Preferences{preference1, preference2})
require.NoError(t, err)
preferences, err := ss.Preference().GetAll(userId)
require.NoError(t, err)
assert.Len(t, preferences, 2, "should've returned 2 preferences")
err = ss.Preference().DeleteCategory(userId, category)
require.NoError(t, err)
preferences, err = ss.Preference().GetAll(userId)
require.NoError(t, err)
assert.Empty(t, preferences, "should've returned no preferences")
}
func testPreferenceDeleteCategoryAndName(t *testing.T, ss store.Store) {
category := model.NewId()
name := model.NewId()
userId := model.NewId()
userId2 := model.NewId()
preference1 := model.Preference{
UserId: userId,
Category: category,
Name: name,
Value: "value1a",
}
preference2 := model.Preference{
UserId: userId2,
Category: category,
Name: name,
Value: "value1a",
}
err := ss.Preference().Save(&model.Preferences{preference1, preference2})
require.NoError(t, err)
preferences, err := ss.Preference().GetAll(userId)
require.NoError(t, err)
assert.Len(t, preferences, 1, "should've returned 1 preference")
preferences, err = ss.Preference().GetAll(userId2)
require.NoError(t, err)
assert.Len(t, preferences, 1, "should've returned 1 preference")
err = ss.Preference().DeleteCategoryAndName(category, name)
require.NoError(t, err)
preferences, err = ss.Preference().GetAll(userId)
require.NoError(t, err)
assert.Empty(t, preferences, "should've returned no preference")
preferences, err = ss.Preference().GetAll(userId2)
require.NoError(t, err)
assert.Empty(t, preferences, "should've returned no preference")
}
func testPreferenceCleanupFlagsBatch(t *testing.T, ss store.Store) {
category := model.PREFERENCE_CATEGORY_FLAGGED_POST
userId := model.NewId()
o1 := &model.Post{}
o1.ChannelId = model.NewId()
o1.UserId = userId
o1.Message = "zz" + model.NewId() + "AAAAAAAAAAA"
o1.CreateAt = 1000
o1, err := ss.Post().Save(o1)
require.NoError(t, err)
preference1 := model.Preference{
UserId: userId,
Category: category,
Name: o1.Id,
Value: "true",
}
preference2 := model.Preference{
UserId: userId,
Category: category,
Name: model.NewId(),
Value: "true",
}
nErr := ss.Preference().Save(&model.Preferences{preference1, preference2})
require.NoError(t, nErr)
_, nErr = ss.Preference().CleanupFlagsBatch(-1)
require.Error(t, nErr)
_, nErr = ss.Preference().CleanupFlagsBatch(10000)
assert.NoError(t, nErr)
_, nErr = ss.Preference().Get(userId, category, preference1.Name)
assert.NoError(t, nErr)
_, nErr = ss.Preference().Get(userId, category, preference2.Name)
assert.Error(t, nErr)
}
Reference in New Issue View Git Blame Copy Permalink