Mono repo -> Master (#22553)

Combines the following repositories into one:

https://github.com/mattermost/mattermost-server
https://github.com/mattermost/mattermost-webapp
https://github.com/mattermost/focalboard
https://github.com/mattermost/mattermost-plugin-playbooks

server/channels/testlib/assertions.go

@@ -0,0 +1,55 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package testlib
+
+import (
+	"encoding/json"
+	"io"
+	"testing"
+)
+
+// AssertLog asserts that a JSON-encoded buffer of logs contains one with the given level and message.
+func AssertLog(t *testing.T, logs io.Reader, level, message string) {
+	dec := json.NewDecoder(logs)
+	for {
+		var log struct {
+			Level string
+			Msg   string
+		}
+		if err := dec.Decode(&log); err == io.EOF {
+			break
+		} else if err != nil {
+			t.Logf("Error decoding log entry: %s", err)
+			continue
+		}
+
+		if log.Level == level && log.Msg == message {
+			return
+		}
+	}
+
+	t.Fatalf("failed to find %s log message: %s", level, message)
+}
+
+// AssertNoLog asserts that a JSON-encoded buffer of logs does not contains one with the given level and message.
+func AssertNoLog(t *testing.T, logs io.Reader, level, message string) {
+	dec := json.NewDecoder(logs)
+	for {
+		var log struct {
+			Level string
+			Msg   string
+		}
+		if err := dec.Decode(&log); err == io.EOF {
+			break
+		} else if err != nil {
+			t.Logf("Error decoding log entry: %s", err)
+			continue
+		}
+
+		if log.Level == level && log.Msg == message {
+			t.Fatalf("found %s log message: %s", level, message)
+			return
+		}
+	}
+}

server/channels/testlib/cluster.go

@@ -0,0 +1,105 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package testlib
+
+import (
+	"sync"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/einterfaces"
+)
+
+type FakeClusterInterface struct {
+	clusterMessageHandler einterfaces.ClusterMessageHandler
+	mut                   sync.RWMutex
+	messages              []*model.ClusterMessage
+}
+
+func (c *FakeClusterInterface) StartInterNodeCommunication() {}
+
+func (c *FakeClusterInterface) StopInterNodeCommunication() {}
+
+func (c *FakeClusterInterface) RegisterClusterMessageHandler(event model.ClusterEvent, crm einterfaces.ClusterMessageHandler) {
+	c.clusterMessageHandler = crm
+}
+
+func (c *FakeClusterInterface) HealthScore() int {
+	return 0
+}
+
+func (c *FakeClusterInterface) GetClusterId() string { return "" }
+
+func (c *FakeClusterInterface) IsLeader() bool { return false }
+
+func (c *FakeClusterInterface) GetMyClusterInfo() *model.ClusterInfo { return nil }
+
+func (c *FakeClusterInterface) GetClusterInfos() []*model.ClusterInfo { return nil }
+
+func (c *FakeClusterInterface) SendClusterMessage(message *model.ClusterMessage) {
+	c.mut.Lock()
+	defer c.mut.Unlock()
+	c.messages = append(c.messages, message)
+}
+
+func (c *FakeClusterInterface) SendClusterMessageToNode(nodeID string, message *model.ClusterMessage) error {
+	c.mut.Lock()
+	defer c.mut.Unlock()
+	c.messages = append(c.messages, message)
+	return nil
+}
+
+func (c *FakeClusterInterface) NotifyMsg(buf []byte) {}
+
+func (c *FakeClusterInterface) GetClusterStats() ([]*model.ClusterStats, *model.AppError) {
+	return nil, nil
+}
+
+func (c *FakeClusterInterface) GetLogs(page, perPage int) ([]string, *model.AppError) {
+	return []string{}, nil
+}
+
+func (c *FakeClusterInterface) QueryLogs(page, perPage int) (map[string][]string, *model.AppError) {
+	return make(map[string][]string), nil
+}
+
+func (c *FakeClusterInterface) ConfigChanged(previousConfig *model.Config, newConfig *model.Config, sendToOtherServer bool) *model.AppError {
+	return nil
+}
+
+func (c *FakeClusterInterface) SendClearRoleCacheMessage() {
+	if c.clusterMessageHandler != nil {
+		c.clusterMessageHandler(&model.ClusterMessage{
+			Event: model.ClusterEventInvalidateCacheForRoles,
+		})
+	}
+}
+
+func (c *FakeClusterInterface) GetPluginStatuses() (model.PluginStatuses, *model.AppError) {
+	return nil, nil
+}
+
+func (c *FakeClusterInterface) GetMessages() []*model.ClusterMessage {
+	c.mut.RLock()
+	defer c.mut.RUnlock()
+	return c.messages
+}
+
+func (c *FakeClusterInterface) SelectMessages(filterCond func(message *model.ClusterMessage) bool) []*model.ClusterMessage {
+	c.mut.RLock()
+	defer c.mut.RUnlock()
+
+	filteredMessages := []*model.ClusterMessage{}
+	for _, msg := range c.messages {
+		if filterCond(msg) {
+			filteredMessages = append(filteredMessages, msg)
+		}
+	}
+	return filteredMessages
+}
+
+func (c *FakeClusterInterface) ClearMessages() {
+	c.mut.Lock()
+	defer c.mut.Unlock()
+	c.messages = nil
+}

server/channels/testlib/doc.go

@@ -0,0 +1,5 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+// Package testlib exposes helper methods for running unit tests against a containerized test store.
+package testlib

server/channels/testlib/helper.go

@@ -0,0 +1,273 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package testlib
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/pkg/errors"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/searchlayer"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/sqlstore"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest"
+	"github.com/mattermost/mattermost-server/v6/server/channels/utils"
+	"github.com/mattermost/mattermost-server/v6/server/platform/services/searchengine"
+)
+
+type MainHelper struct {
+	Settings         *model.SqlSettings
+	Store            store.Store
+	SearchEngine     *searchengine.Broker
+	SQLStore         *sqlstore.SqlStore
+	ClusterInterface *FakeClusterInterface
+
+	status           int
+	testResourcePath string
+	replicas         []string
+}
+
+type HelperOptions struct {
+	EnableStore     bool
+	EnableResources bool
+	WithReadReplica bool
+}
+
+func NewMainHelper() *MainHelper {
+	return NewMainHelperWithOptions(&HelperOptions{
+		EnableStore:     true,
+		EnableResources: true,
+	})
+}
+
+func NewMainHelperWithOptions(options *HelperOptions) *MainHelper {
+	var mainHelper MainHelper
+	flag.Parse()
+
+	utils.TranslationsPreInit()
+
+	if options != nil {
+		if options.EnableStore && !testing.Short() {
+			mainHelper.setupStore(options.WithReadReplica)
+		}
+
+		if options.EnableResources {
+			mainHelper.setupResources()
+		}
+	}
+
+	return &mainHelper
+}
+
+func (h *MainHelper) Main(m *testing.M) {
+	if h.testResourcePath != "" {
+		prevDir, err := os.Getwd()
+		if err != nil {
+			panic("Failed to get current working directory: " + err.Error())
+		}
+
+		err = os.Chdir(h.testResourcePath)
+		if err != nil {
+			panic(fmt.Sprintf("Failed to set current working directory to %s: %s", h.testResourcePath, err.Error()))
+		}
+
+		defer func() {
+			err := os.Chdir(prevDir)
+			if err != nil {
+				panic(fmt.Sprintf("Failed to restore current working directory to %s: %s", prevDir, err.Error()))
+			}
+		}()
+	}
+
+	h.status = m.Run()
+}
+
+func (h *MainHelper) setupStore(withReadReplica bool) {
+	driverName := os.Getenv("MM_SQLSETTINGS_DRIVERNAME")
+	if driverName == "" {
+		driverName = model.DatabaseDriverPostgres
+	}
+
+	h.Settings = storetest.MakeSqlSettings(driverName, withReadReplica)
+	h.replicas = h.Settings.DataSourceReplicas
+
+	config := &model.Config{}
+	config.SetDefaults()
+
+	h.SearchEngine = searchengine.NewBroker(config)
+	h.ClusterInterface = &FakeClusterInterface{}
+	h.SQLStore = sqlstore.New(*h.Settings, nil)
+	h.Store = searchlayer.NewSearchLayer(&TestStore{
+		h.SQLStore,
+	}, h.SearchEngine, config)
+}
+
+func (h *MainHelper) ToggleReplicasOff() {
+	if h.SQLStore.GetLicense() == nil {
+		panic("expecting a license to use this")
+	}
+	h.Settings.DataSourceReplicas = []string{}
+	lic := h.SQLStore.GetLicense()
+	h.SQLStore = sqlstore.New(*h.Settings, nil)
+	h.SQLStore.UpdateLicense(lic)
+}
+
+func (h *MainHelper) ToggleReplicasOn() {
+	if h.SQLStore.GetLicense() == nil {
+		panic("expecting a license to use this")
+	}
+	h.Settings.DataSourceReplicas = h.replicas
+	lic := h.SQLStore.GetLicense()
+	h.SQLStore = sqlstore.New(*h.Settings, nil)
+	h.SQLStore.UpdateLicense(lic)
+}
+
+func (h *MainHelper) setupResources() {
+	var err error
+	h.testResourcePath, err = SetupTestResources()
+	if err != nil {
+		panic("failed to setup test resources: " + err.Error())
+	}
+}
+
+// PreloadMigrations preloads the migrations and roles into the database
+// so that they are not run again when the migrations happen every time
+// the server is started.
+// This change is forward-compatible with new migrations and only new migrations
+// will get executed.
+// Only if the schema of either roles or systems table changes, this will break.
+// In that case, just update the migrations or comment this out for the time being.
+// In the worst case, only an optimization is lost.
+//
+// Re-generate the files with:
+// pg_dump -a -h localhost -U mmuser -d <> --no-comments --inserts -t roles -t systems
+// mysqldump -u root -p <> --no-create-info --extended-insert=FALSE Systems Roles
+// And keep only the permission related rows in the systems table output.
+func (h *MainHelper) PreloadMigrations() {
+	var buf []byte
+	var err error
+	basePath := os.Getenv("MM_SERVER_PATH")
+	if basePath == "" {
+		basePath = "mattermost-server/server"
+	}
+	relPath := "channels/testlib/testdata"
+	switch *h.Settings.DriverName {
+	case model.DatabaseDriverPostgres:
+		finalPath := filepath.Join(basePath, relPath, "postgres_migration_warmup.sql")
+		buf, err = os.ReadFile(finalPath)
+		if err != nil {
+			panic(fmt.Errorf("cannot read file: %v", err))
+		}
+	case model.DatabaseDriverMysql:
+		finalPath := filepath.Join(basePath, relPath, "mysql_migration_warmup.sql")
+		buf, err = os.ReadFile(finalPath)
+		if err != nil {
+			panic(fmt.Errorf("cannot read file: %v", err))
+		}
+	}
+	handle := h.SQLStore.GetMasterX()
+	_, err = handle.Exec(string(buf))
+	if err != nil {
+		panic(errors.Wrap(err, "Error preloading migrations. Check if you have &multiStatements=true in your DSN if you are using MySQL. Or perhaps the schema changed? If yes, then update the warmup files accordingly"))
+	}
+}
+
+func (h *MainHelper) Close() error {
+	if h.SQLStore != nil {
+		h.SQLStore.Close()
+	}
+	if h.Settings != nil {
+		storetest.CleanupSqlSettings(h.Settings)
+	}
+	if h.testResourcePath != "" {
+		os.RemoveAll(h.testResourcePath)
+	}
+
+	if r := recover(); r != nil {
+		log.Fatalln(r)
+	}
+
+	os.Exit(h.status)
+
+	return nil
+}
+
+func (h *MainHelper) GetSQLSettings() *model.SqlSettings {
+	if h.Settings == nil {
+		panic("MainHelper not initialized with database access.")
+	}
+
+	return h.Settings
+}
+
+func (h *MainHelper) GetStore() store.Store {
+	if h.Store == nil {
+		panic("MainHelper not initialized with store.")
+	}
+
+	return h.Store
+}
+
+func (h *MainHelper) GetSQLStore() *sqlstore.SqlStore {
+	if h.SQLStore == nil {
+		panic("MainHelper not initialized with sql store.")
+	}
+
+	return h.SQLStore
+}
+
+func (h *MainHelper) GetClusterInterface() *FakeClusterInterface {
+	if h.ClusterInterface == nil {
+		panic("MainHelper not initialized with cluster interface.")
+	}
+
+	return h.ClusterInterface
+}
+
+func (h *MainHelper) GetSearchEngine() *searchengine.Broker {
+	if h.SearchEngine == nil {
+		panic("MainHelper not initialized with search engine")
+	}
+
+	return h.SearchEngine
+}
+
+func (h *MainHelper) SetReplicationLagForTesting(seconds int) error {
+	if dn := h.SQLStore.DriverName(); dn != model.DatabaseDriverMysql {
+		return fmt.Errorf("method not implemented for %q database driver, only %q is supported", dn, model.DatabaseDriverMysql)
+	}
+
+	err := h.execOnEachReplica("STOP SLAVE SQL_THREAD FOR CHANNEL ''")
+	if err != nil {
+		return err
+	}
+
+	err = h.execOnEachReplica(fmt.Sprintf("CHANGE MASTER TO MASTER_DELAY = %d", seconds))
+	if err != nil {
+		return err
+	}
+
+	err = h.execOnEachReplica("START SLAVE SQL_THREAD FOR CHANNEL ''")
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (h *MainHelper) execOnEachReplica(query string, args ...any) error {
+	for _, replica := range h.SQLStore.ReplicaXs {
+		_, err := replica.Exec(query, args...)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}

server/channels/testlib/resources.go

@@ -0,0 +1,203 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package testlib
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path"
+	"path/filepath"
+
+	"github.com/pkg/errors"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/server/channels/utils"
+	"github.com/mattermost/mattermost-server/v6/server/channels/utils/fileutils"
+	"github.com/mattermost/mattermost-server/v6/server/platform/shared/filestore"
+)
+
+const (
+	resourceTypeFile = iota
+	resourceTypeFolder
+)
+
+const (
+	actionCopy = iota
+	actionSymlink
+)
+
+const root = "___mattermost-server"
+
+type testResourceDetails struct {
+	src     string
+	dest    string
+	resType int8
+	action  int8
+}
+
+func findFile(path string) string {
+	return fileutils.FindPath(path, fileutils.CommonBaseSearchPaths(), func(fileInfo os.FileInfo) bool {
+		return !fileInfo.IsDir()
+	})
+}
+
+func findDir(dir string) (string, bool) {
+	if dir == root {
+		srcPath := findFile("go.mod")
+		if srcPath == "" {
+			return "./", false
+		}
+
+		return path.Dir(srcPath), true
+	}
+
+	found := fileutils.FindPath(dir, fileutils.CommonBaseSearchPaths(), func(fileInfo os.FileInfo) bool {
+		return fileInfo.IsDir()
+	})
+	if found == "" {
+		return "./", false
+	}
+
+	return found, true
+}
+
+func getTestResourcesToSetup() []testResourceDetails {
+	var srcPath string
+	var found bool
+
+	var testResourcesToSetup = []testResourceDetails{
+		{root, "mattermost-server", resourceTypeFolder, actionSymlink},
+		{"go.mod", "go.mod", resourceTypeFile, actionSymlink},
+		{"i18n", "i18n", resourceTypeFolder, actionSymlink},
+		{"templates", "templates", resourceTypeFolder, actionSymlink},
+		{"tests", "tests", resourceTypeFolder, actionSymlink},
+		{"fonts", "fonts", resourceTypeFolder, actionSymlink},
+		{"channels/utils/policies-roles-mapping.json", "channels/utils/policies-roles-mapping.json", resourceTypeFile, actionSymlink},
+	}
+
+	// Finding resources and setting full path to source to be used for further processing
+	for i, testResource := range testResourcesToSetup {
+		if testResource.resType == resourceTypeFile {
+			srcPath = findFile(testResource.src)
+			if srcPath == "" {
+				panic(fmt.Sprintf("Failed to find file %s", testResource.src))
+			}
+
+			testResourcesToSetup[i].src = srcPath
+		} else if testResource.resType == resourceTypeFolder {
+			srcPath, found = findDir(testResource.src)
+			if !found {
+				panic(fmt.Sprintf("Failed to find folder %s", testResource.src))
+			}
+
+			testResourcesToSetup[i].src = srcPath
+		} else {
+			panic(fmt.Sprintf("Invalid resource type: %d", testResource.resType))
+		}
+	}
+
+	return testResourcesToSetup
+}
+
+func CopyFile(src, dst string) error {
+	fileBackend, err := filestore.NewFileBackend(filestore.FileBackendSettings{DriverName: "local", Directory: ""})
+	if err != nil {
+		return errors.Wrapf(err, "failed to copy file %s to %s", src, dst)
+	}
+	if err = fileBackend.CopyFile(src, dst); err != nil {
+		return errors.Wrapf(err, "failed to copy file %s to %s", src, dst)
+	}
+	return nil
+}
+
+func SetupTestResources() (string, error) {
+	testResourcesToSetup := getTestResourcesToSetup()
+
+	tempDir, err := os.MkdirTemp("", "testlib")
+	if err != nil {
+		return "", errors.Wrap(err, "failed to create temporary directory")
+	}
+
+	pluginsDir := path.Join(tempDir, "plugins")
+	err = os.Mkdir(pluginsDir, 0700)
+	if err != nil {
+		return "", errors.Wrapf(err, "failed to create plugins directory %s", pluginsDir)
+	}
+
+	clientDir := path.Join(tempDir, "client")
+	err = os.Mkdir(clientDir, 0700)
+	if err != nil {
+		return "", errors.Wrapf(err, "failed to create client directory %s", clientDir)
+	}
+
+	err = setupConfig(path.Join(tempDir, "config"))
+	if err != nil {
+		return "", errors.Wrap(err, "failed to setup config")
+	}
+
+	var resourceDestInTemp string
+
+	// Setting up test resources in temp.
+	// Action in each resource tells whether it needs to be copied or just symlinked
+	for _, testResource := range testResourcesToSetup {
+		resourceDestInTemp = filepath.Join(tempDir, testResource.dest)
+
+		if testResource.action == actionCopy {
+			if testResource.resType == resourceTypeFile {
+				if err = CopyFile(testResource.src, resourceDestInTemp); err != nil {
+					return "", err
+				}
+			} else if testResource.resType == resourceTypeFolder {
+				err = utils.CopyDir(testResource.src, resourceDestInTemp)
+				if err != nil {
+					return "", errors.Wrapf(err, "failed to copy folder %s to %s", testResource.src, resourceDestInTemp)
+				}
+			}
+		} else if testResource.action == actionSymlink {
+			destDir := path.Dir(resourceDestInTemp)
+			if destDir != "." {
+				err = os.MkdirAll(destDir, os.ModePerm)
+				if err != nil {
+					return "", errors.Wrapf(err, "failed to make dir %s", destDir)
+				}
+			}
+
+			err = os.Symlink(testResource.src, resourceDestInTemp)
+			if err != nil {
+				return "", errors.Wrapf(err, "failed to symlink %s to %s", testResource.src, resourceDestInTemp)
+			}
+		} else {
+			return "", errors.Wrapf(err, "Invalid action: %d", testResource.action)
+		}
+
+	}
+
+	return tempDir, nil
+}
+
+func setupConfig(configDir string) error {
+	var err error
+	var config model.Config
+
+	config.SetDefaults()
+
+	err = os.Mkdir(configDir, 0700)
+	if err != nil {
+		return errors.Wrapf(err, "failed to create config directory %s", configDir)
+	}
+
+	buf, err := json.Marshal(config)
+	if err != nil {
+		return fmt.Errorf("failed to marshal config: %v", err)
+	}
+
+	configJSON := path.Join(configDir, "config.json")
+	err = os.WriteFile(configJSON, buf, 0644)
+	if err != nil {
+		return errors.Wrapf(err, "failed to write config to %s", configJSON)
+	}
+
+	return nil
+}

server/channels/testlib/resources_test.go

@@ -0,0 +1,18 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package testlib
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFindDir(t *testing.T) {
+	t.Run("find root", func(t *testing.T) {
+		path, found := findDir(root)
+		assert.True(t, found, "failed to find root")
+		assert.NotEmpty(t, path)
+	})
+}

server/channels/testlib/store.go

@@ -0,0 +1,121 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package testlib
+
+import (
+	"net/http"
+	"strconv"
+
+	"github.com/mattermost/mattermost-server/v6/model"
+	"github.com/mattermost/mattermost-server/v6/plugin/plugintest/mock"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store"
+	"github.com/mattermost/mattermost-server/v6/server/channels/store/storetest/mocks"
+)
+
+type TestStore struct {
+	store.Store
+}
+
+func (s *TestStore) Close() {
+	// Don't propagate to the underlying store, since this instance is persistent.
+}
+
+func GetMockStoreForSetupFunctions() *mocks.Store {
+	mockStore := mocks.Store{}
+	systemStore := mocks.SystemStore{}
+	systemStore.On("GetByName", "FirstAdminSetupComplete").Return(&model.System{Name: "FirstAdminSetupComplete", Value: "true"}, nil)
+	systemStore.On("GetByName", "RemainingSchemaMigrations").Return(&model.System{Name: "RemainingSchemaMigrations", Value: "true"}, nil)
+	systemStore.On("GetByName", "ContentExtractionConfigDefaultTrueMigrationComplete").Return(&model.System{Name: "ContentExtractionConfigDefaultTrueMigrationComplete", Value: "true"}, nil)
+	systemStore.On("GetByName", "UpgradedFromTE").Return(nil, model.NewAppError("FakeError", "app.system.get_by_name.app_error", nil, "", http.StatusInternalServerError))
+	systemStore.On("GetByName", "ContentExtractionConfigMigrationComplete").Return(&model.System{Name: "ContentExtractionConfigMigrationComplete", Value: "true"}, nil)
+	systemStore.On("GetByName", "AsymmetricSigningKey").Return(nil, model.NewAppError("FakeError", "app.system.get_by_name.app_error", nil, "", http.StatusInternalServerError))
+	systemStore.On("GetByName", "PostActionCookieSecret").Return(nil, model.NewAppError("FakeError", "app.system.get_by_name.app_error", nil, "", http.StatusInternalServerError))
+	systemStore.On("GetByName", "InstallationDate").Return(&model.System{Name: "InstallationDate", Value: strconv.FormatInt(model.GetMillis(), 10)}, nil)
+	systemStore.On("GetByName", "FirstServerRunTimestamp").Return(&model.System{Name: "FirstServerRunTimestamp", Value: "10"}, nil)
+	systemStore.On("GetByName", "AdvancedPermissionsMigrationComplete").Return(&model.System{Name: "AdvancedPermissionsMigrationComplete", Value: "true"}, nil)
+	systemStore.On("GetByName", "EmojisPermissionsMigrationComplete").Return(&model.System{Name: "EmojisPermissionsMigrationComplete", Value: "true"}, nil)
+	systemStore.On("GetByName", "GuestRolesCreationMigrationComplete").Return(&model.System{Name: "GuestRolesCreationMigrationComplete", Value: "true"}, nil)
+	systemStore.On("GetByName", "SystemConsoleRolesCreationMigrationComplete").Return(&model.System{Name: "SystemConsoleRolesCreationMigrationComplete", Value: "true"}, nil)
+	systemStore.On("GetByName", "PlaybookRolesCreationMigrationComplete").Return(&model.System{Name: "PlaybookRolesCreationMigrationComplete", Value: "true"}, nil)
+	systemStore.On("GetByName", "PostPriorityConfigDefaultTrueMigrationComplete").Return(&model.System{Name: "PostPriorityConfigDefaultTrueMigrationComplete", Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyEmojiPermissionsSplit).Return(&model.System{Name: model.MigrationKeyEmojiPermissionsSplit, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyWebhookPermissionsSplit).Return(&model.System{Name: model.MigrationKeyWebhookPermissionsSplit, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyListJoinPublicPrivateTeams).Return(&model.System{Name: model.MigrationKeyListJoinPublicPrivateTeams, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyRemovePermanentDeleteUser).Return(&model.System{Name: model.MigrationKeyRemovePermanentDeleteUser, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddBotPermissions).Return(&model.System{Name: model.MigrationKeyAddBotPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyApplyChannelManageDeleteToChannelUser).Return(&model.System{Name: model.MigrationKeyApplyChannelManageDeleteToChannelUser, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyRemoveChannelManageDeleteFromTeamUser).Return(&model.System{Name: model.MigrationKeyRemoveChannelManageDeleteFromTeamUser, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyViewMembersNewPermission).Return(&model.System{Name: model.MigrationKeyViewMembersNewPermission, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddManageGuestsPermissions).Return(&model.System{Name: model.MigrationKeyAddManageGuestsPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyChannelModerationsPermissions).Return(&model.System{Name: model.MigrationKeyChannelModerationsPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddUseGroupMentionsPermission).Return(&model.System{Name: model.MigrationKeyAddUseGroupMentionsPermission, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddSystemConsolePermissions).Return(&model.System{Name: model.MigrationKeyAddSystemConsolePermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddConvertChannelPermissions).Return(&model.System{Name: model.MigrationKeyAddConvertChannelPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddSystemRolesPermissions).Return(&model.System{Name: model.MigrationKeyAddSystemRolesPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddBillingPermissions).Return(&model.System{Name: model.MigrationKeyAddBillingPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddDownloadComplianceExportResults).Return(&model.System{Name: model.MigrationKeyAddDownloadComplianceExportResults, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddSiteSubsectionPermissions).Return(&model.System{Name: model.MigrationKeyAddSiteSubsectionPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddExperimentalSubsectionPermissions).Return(&model.System{Name: model.MigrationKeyAddExperimentalSubsectionPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddAuthenticationSubsectionPermissions).Return(&model.System{Name: model.MigrationKeyAddAuthenticationSubsectionPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddComplianceSubsectionPermissions).Return(&model.System{Name: model.MigrationKeyAddExperimentalSubsectionPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddEnvironmentSubsectionPermissions).Return(&model.System{Name: model.MigrationKeyAddEnvironmentSubsectionPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddReportingSubsectionPermissions).Return(&model.System{Name: model.MigrationKeyAddReportingSubsectionPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddTestEmailAncillaryPermission).Return(&model.System{Name: model.MigrationKeyAddTestEmailAncillaryPermission, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddAboutSubsectionPermissions).Return(&model.System{Name: model.MigrationKeyAddAboutSubsectionPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddIntegrationsSubsectionPermissions).Return(&model.System{Name: model.MigrationKeyAddIntegrationsSubsectionPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddManageSharedChannelPermissions).Return(&model.System{Name: model.MigrationKeyAddManageSharedChannelPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddManageSecureConnectionsPermissions).Return(&model.System{Name: model.MigrationKeyAddManageSecureConnectionsPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddPlaybooksPermissions).Return(&model.System{Name: model.MigrationKeyAddPlaybooksPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddCustomUserGroupsPermissions).Return(&model.System{Name: model.MigrationKeyAddCustomUserGroupsPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddPlayboosksManageRolesPermissions).Return(&model.System{Name: model.MigrationKeyAddPlayboosksManageRolesPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", model.MigrationKeyAddCustomUserGroupsPermissionRestore).Return(&model.System{Name: model.MigrationKeyAddCustomUserGroupsPermissionRestore, Value: "true"}, nil)
+	systemStore.On("GetByName", "CustomGroupAdminRoleCreationMigrationComplete").Return(&model.System{Name: model.MigrationKeyAddPlayboosksManageRolesPermissions, Value: "true"}, nil)
+	systemStore.On("GetByName", "products_boards").Return(&model.System{Name: "products_boards", Value: "true"}, nil)
+	systemStore.On("InsertIfExists", mock.AnythingOfType("*model.System")).Return(&model.System{}, nil).Once()
+	systemStore.On("Save", mock.AnythingOfType("*model.System")).Return(nil)
+
+	userStore := mocks.UserStore{}
+	userStore.On("Count", mock.AnythingOfType("model.UserCountOptions")).Return(int64(1), nil)
+	userStore.On("DeactivateGuests").Return(nil, nil)
+	userStore.On("ClearCaches").Return(nil)
+
+	postStore := mocks.PostStore{}
+	postStore.On("GetMaxPostSize").Return(4000)
+
+	statusStore := mocks.StatusStore{}
+	statusStore.On("ResetAll").Return(nil)
+
+	channelStore := mocks.ChannelStore{}
+	channelStore.On("ClearCaches").Return(nil)
+
+	schemeStore := mocks.SchemeStore{}
+	schemeStore.On("GetAllPage", model.SchemeScopeTeam, mock.Anything, 100).Return([]*model.Scheme{}, nil)
+
+	teamStore := mocks.TeamStore{}
+
+	roleStore := mocks.RoleStore{}
+	roleStore.On("GetAll").Return([]*model.Role{}, nil)
+
+	sessionStore := mocks.SessionStore{}
+	oAuthStore := mocks.OAuthStore{}
+	groupStore := mocks.GroupStore{}
+
+	mockStore.On("System").Return(&systemStore)
+	mockStore.On("User").Return(&userStore)
+	mockStore.On("Post").Return(&postStore)
+	mockStore.On("Status").Return(&statusStore)
+	mockStore.On("Channel").Return(&channelStore)
+	mockStore.On("Team").Return(&teamStore)
+	mockStore.On("Role").Return(&roleStore)
+	mockStore.On("Scheme").Return(&schemeStore)
+	mockStore.On("Close").Return(nil)
+	mockStore.On("DropAllTables").Return(nil)
+	mockStore.On("MarkSystemRanUnitTests").Return(nil)
+	mockStore.On("Session").Return(&sessionStore)
+	mockStore.On("OAuth").Return(&oAuthStore)
+	mockStore.On("Group").Return(&groupStore)
+	mockStore.On("GetDBSchemaVersion").Return(1, nil)
+
+	return &mockStore
+}