github.com/haalcala/mattermost-server-change-repo@v0.0.0-20210713015153-16753fbeee5f/store/storetest/preference_store.go (about)

     1  // Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
     2  // See LICENSE.txt for license information.
     3  
     4  package storetest
     5  
     6  import (
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/mattermost/mattermost-server/v5/model"
    13  	"github.com/mattermost/mattermost-server/v5/store"
    14  )
    15  
    16  func TestPreferenceStore(t *testing.T, ss store.Store) {
    17  	t.Run("PreferenceSave", func(t *testing.T) { testPreferenceSave(t, ss) })
    18  	t.Run("PreferenceGet", func(t *testing.T) { testPreferenceGet(t, ss) })
    19  	t.Run("PreferenceGetCategory", func(t *testing.T) { testPreferenceGetCategory(t, ss) })
    20  	t.Run("PreferenceGetAll", func(t *testing.T) { testPreferenceGetAll(t, ss) })
    21  	t.Run("PreferenceDeleteByUser", func(t *testing.T) { testPreferenceDeleteByUser(t, ss) })
    22  	t.Run("PreferenceDelete", func(t *testing.T) { testPreferenceDelete(t, ss) })
    23  	t.Run("PreferenceDeleteCategory", func(t *testing.T) { testPreferenceDeleteCategory(t, ss) })
    24  	t.Run("PreferenceDeleteCategoryAndName", func(t *testing.T) { testPreferenceDeleteCategoryAndName(t, ss) })
    25  	t.Run("PreferenceCleanupFlagsBatch", func(t *testing.T) { testPreferenceCleanupFlagsBatch(t, ss) })
    26  }
    27  
    28  func testPreferenceSave(t *testing.T, ss store.Store) {
    29  	id := model.NewId()
    30  
    31  	preferences := model.Preferences{
    32  		{
    33  			UserId:   id,
    34  			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
    35  			Name:     model.NewId(),
    36  			Value:    "value1a",
    37  		},
    38  		{
    39  			UserId:   id,
    40  			Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
    41  			Name:     model.NewId(),
    42  			Value:    "value1b",
    43  		},
    44  	}
    45  	err := ss.Preference().Save(&preferences)
    46  	require.NoError(t, err, "saving preference returned error")
    47  
    48  	for _, preference := range preferences {
    49  		data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name)
    50  		require.Equal(t, data.ToJson(), preference.ToJson(), "got incorrect preference after first Save")
    51  	}
    52  
    53  	preferences[0].Value = "value2a"
    54  	preferences[1].Value = "value2b"
    55  	err = ss.Preference().Save(&preferences)
    56  	require.NoError(t, err, "saving preference returned error")
    57  
    58  	for _, preference := range preferences {
    59  		data, _ := ss.Preference().Get(preference.UserId, preference.Category, preference.Name)
    60  		require.Equal(t, data.ToJson(), preference.ToJson(), "got incorrect preference after second Save")
    61  	}
    62  }
    63  
    64  func testPreferenceGet(t *testing.T, ss store.Store) {
    65  	userId := model.NewId()
    66  	category := model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
    67  	name := model.NewId()
    68  
    69  	preferences := model.Preferences{
    70  		{
    71  			UserId:   userId,
    72  			Category: category,
    73  			Name:     name,
    74  		},
    75  		{
    76  			UserId:   userId,
    77  			Category: category,
    78  			Name:     model.NewId(),
    79  		},
    80  		{
    81  			UserId:   userId,
    82  			Category: model.NewId(),
    83  			Name:     name,
    84  		},
    85  		{
    86  			UserId:   model.NewId(),
    87  			Category: category,
    88  			Name:     name,
    89  		},
    90  	}
    91  
    92  	err := ss.Preference().Save(&preferences)
    93  	require.NoError(t, err)
    94  
    95  	data, err := ss.Preference().Get(userId, category, name)
    96  	require.NoError(t, err)
    97  	require.Equal(t, preferences[0].ToJson(), data.ToJson(), "got incorrect preference")
    98  
    99  	// make sure getting a missing preference fails
   100  	_, err = ss.Preference().Get(model.NewId(), model.NewId(), model.NewId())
   101  	require.Error(t, err, "no error on getting a missing preference")
   102  }
   103  
   104  func testPreferenceGetCategory(t *testing.T, ss store.Store) {
   105  	userId := model.NewId()
   106  	category := model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
   107  	name := model.NewId()
   108  
   109  	preferences := model.Preferences{
   110  		{
   111  			UserId:   userId,
   112  			Category: category,
   113  			Name:     name,
   114  		},
   115  		// same user/category, different name
   116  		{
   117  			UserId:   userId,
   118  			Category: category,
   119  			Name:     model.NewId(),
   120  		},
   121  		// same user/name, different category
   122  		{
   123  			UserId:   userId,
   124  			Category: model.NewId(),
   125  			Name:     name,
   126  		},
   127  		// same name/category, different user
   128  		{
   129  			UserId:   model.NewId(),
   130  			Category: category,
   131  			Name:     name,
   132  		},
   133  	}
   134  
   135  	err := ss.Preference().Save(&preferences)
   136  	require.NoError(t, err)
   137  
   138  	preferencesByCategory, err := ss.Preference().GetCategory(userId, category)
   139  	require.NoError(t, err)
   140  	require.Equal(t, 2, len(preferencesByCategory), "got the wrong number of preferences")
   141  	require.True(
   142  		t,
   143  		((preferencesByCategory[0] == preferences[0] && preferencesByCategory[1] == preferences[1]) || (preferencesByCategory[0] == preferences[1] && preferencesByCategory[1] == preferences[0])),
   144  		"got incorrect preferences",
   145  	)
   146  
   147  	// make sure getting a missing preference category doesn't fail
   148  	preferencesByCategory, err = ss.Preference().GetCategory(model.NewId(), model.NewId())
   149  	require.NoError(t, err)
   150  	require.Equal(t, 0, len(preferencesByCategory), "shouldn't have got any preferences")
   151  }
   152  
   153  func testPreferenceGetAll(t *testing.T, ss store.Store) {
   154  	userId := model.NewId()
   155  	category := model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
   156  	name := model.NewId()
   157  
   158  	preferences := model.Preferences{
   159  		{
   160  			UserId:   userId,
   161  			Category: category,
   162  			Name:     name,
   163  		},
   164  		// same user/category, different name
   165  		{
   166  			UserId:   userId,
   167  			Category: category,
   168  			Name:     model.NewId(),
   169  		},
   170  		// same user/name, different category
   171  		{
   172  			UserId:   userId,
   173  			Category: model.NewId(),
   174  			Name:     name,
   175  		},
   176  		// same name/category, different user
   177  		{
   178  			UserId:   model.NewId(),
   179  			Category: category,
   180  			Name:     name,
   181  		},
   182  	}
   183  
   184  	err := ss.Preference().Save(&preferences)
   185  	require.NoError(t, err)
   186  
   187  	result, err := ss.Preference().GetAll(userId)
   188  	require.NoError(t, err)
   189  	require.Equal(t, 3, len(result), "got the wrong number of preferences")
   190  
   191  	for i := 0; i < 3; i++ {
   192  		assert.Falsef(t, result[0] != preferences[i] && result[1] != preferences[i] && result[2] != preferences[i], "got incorrect preferences")
   193  	}
   194  
   195  }
   196  
   197  func testPreferenceDeleteByUser(t *testing.T, ss store.Store) {
   198  	userId := model.NewId()
   199  	category := model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW
   200  	name := model.NewId()
   201  
   202  	preferences := model.Preferences{
   203  		{
   204  			UserId:   userId,
   205  			Category: category,
   206  			Name:     name,
   207  		},
   208  		// same user/category, different name
   209  		{
   210  			UserId:   userId,
   211  			Category: category,
   212  			Name:     model.NewId(),
   213  		},
   214  		// same user/name, different category
   215  		{
   216  			UserId:   userId,
   217  			Category: model.NewId(),
   218  			Name:     name,
   219  		},
   220  		// same name/category, different user
   221  		{
   222  			UserId:   model.NewId(),
   223  			Category: category,
   224  			Name:     name,
   225  		},
   226  	}
   227  
   228  	err := ss.Preference().Save(&preferences)
   229  	require.NoError(t, err)
   230  
   231  	err = ss.Preference().PermanentDeleteByUser(userId)
   232  	require.NoError(t, err)
   233  }
   234  
   235  func testPreferenceDelete(t *testing.T, ss store.Store) {
   236  	preference := model.Preference{
   237  		UserId:   model.NewId(),
   238  		Category: model.PREFERENCE_CATEGORY_DIRECT_CHANNEL_SHOW,
   239  		Name:     model.NewId(),
   240  		Value:    "value1a",
   241  	}
   242  
   243  	err := ss.Preference().Save(&model.Preferences{preference})
   244  	require.NoError(t, err)
   245  
   246  	preferences, err := ss.Preference().GetAll(preference.UserId)
   247  	require.NoError(t, err)
   248  	assert.Len(t, preferences, 1, "should've returned 1 preference")
   249  
   250  	err = ss.Preference().Delete(preference.UserId, preference.Category, preference.Name)
   251  	require.NoError(t, err)
   252  	preferences, err = ss.Preference().GetAll(preference.UserId)
   253  	require.NoError(t, err)
   254  	assert.Empty(t, preferences, "should've returned no preferences")
   255  }
   256  
   257  func testPreferenceDeleteCategory(t *testing.T, ss store.Store) {
   258  	category := model.NewId()
   259  	userId := model.NewId()
   260  
   261  	preference1 := model.Preference{
   262  		UserId:   userId,
   263  		Category: category,
   264  		Name:     model.NewId(),
   265  		Value:    "value1a",
   266  	}
   267  
   268  	preference2 := model.Preference{
   269  		UserId:   userId,
   270  		Category: category,
   271  		Name:     model.NewId(),
   272  		Value:    "value1a",
   273  	}
   274  
   275  	err := ss.Preference().Save(&model.Preferences{preference1, preference2})
   276  	require.NoError(t, err)
   277  
   278  	preferences, err := ss.Preference().GetAll(userId)
   279  	require.NoError(t, err)
   280  	assert.Len(t, preferences, 2, "should've returned 2 preferences")
   281  
   282  	err = ss.Preference().DeleteCategory(userId, category)
   283  	require.NoError(t, err)
   284  
   285  	preferences, err = ss.Preference().GetAll(userId)
   286  	require.NoError(t, err)
   287  	assert.Empty(t, preferences, "should've returned no preferences")
   288  }
   289  
   290  func testPreferenceDeleteCategoryAndName(t *testing.T, ss store.Store) {
   291  	category := model.NewId()
   292  	name := model.NewId()
   293  	userId := model.NewId()
   294  	userId2 := model.NewId()
   295  
   296  	preference1 := model.Preference{
   297  		UserId:   userId,
   298  		Category: category,
   299  		Name:     name,
   300  		Value:    "value1a",
   301  	}
   302  
   303  	preference2 := model.Preference{
   304  		UserId:   userId2,
   305  		Category: category,
   306  		Name:     name,
   307  		Value:    "value1a",
   308  	}
   309  
   310  	err := ss.Preference().Save(&model.Preferences{preference1, preference2})
   311  	require.NoError(t, err)
   312  
   313  	preferences, err := ss.Preference().GetAll(userId)
   314  	require.NoError(t, err)
   315  	assert.Len(t, preferences, 1, "should've returned 1 preference")
   316  
   317  	preferences, err = ss.Preference().GetAll(userId2)
   318  	require.NoError(t, err)
   319  	assert.Len(t, preferences, 1, "should've returned 1 preference")
   320  
   321  	err = ss.Preference().DeleteCategoryAndName(category, name)
   322  	require.NoError(t, err)
   323  
   324  	preferences, err = ss.Preference().GetAll(userId)
   325  	require.NoError(t, err)
   326  	assert.Empty(t, preferences, "should've returned no preference")
   327  
   328  	preferences, err = ss.Preference().GetAll(userId2)
   329  	require.NoError(t, err)
   330  	assert.Empty(t, preferences, "should've returned no preference")
   331  }
   332  
   333  func testPreferenceCleanupFlagsBatch(t *testing.T, ss store.Store) {
   334  	category := model.PREFERENCE_CATEGORY_FLAGGED_POST
   335  	userId := model.NewId()
   336  
   337  	o1 := &model.Post{}
   338  	o1.ChannelId = model.NewId()
   339  	o1.UserId = userId
   340  	o1.Message = "zz" + model.NewId() + "AAAAAAAAAAA"
   341  	o1.CreateAt = 1000
   342  	o1, err := ss.Post().Save(o1)
   343  	require.NoError(t, err)
   344  
   345  	preference1 := model.Preference{
   346  		UserId:   userId,
   347  		Category: category,
   348  		Name:     o1.Id,
   349  		Value:    "true",
   350  	}
   351  
   352  	preference2 := model.Preference{
   353  		UserId:   userId,
   354  		Category: category,
   355  		Name:     model.NewId(),
   356  		Value:    "true",
   357  	}
   358  
   359  	nErr := ss.Preference().Save(&model.Preferences{preference1, preference2})
   360  	require.NoError(t, nErr)
   361  
   362  	_, nErr = ss.Preference().CleanupFlagsBatch(10000)
   363  	assert.NoError(t, nErr)
   364  
   365  	_, nErr = ss.Preference().Get(userId, category, preference1.Name)
   366  	assert.NoError(t, nErr)
   367  
   368  	_, nErr = ss.Preference().Get(userId, category, preference2.Name)
   369  	assert.Error(t, nErr)
   370  }