snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/public/plugin/plugintest/doc.go

@@ -0,0 +1,11 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+// The plugintest package provides mocks that can be used to test plugins.
+//
+// The mocks are created using testify's mock package:
+// https://godoc.org/github.com/stretchr/testify/mock
+//
+// If you need to import the mock package, you can import it with
+// "github.com/mattermost/mattermost/server/public/plugin/plugintest/mock".
+package plugintest

server/public/plugin/plugintest/driver.go

@@ -0,0 +1,480 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make plugin-mocks`.
+
+package plugintest
+
+import (
+	driver "database/sql/driver"
+
+	plugin "github.com/mattermost/mattermost/server/public/plugin"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// Driver is an autogenerated mock type for the Driver type
+type Driver struct {
+	mock.Mock
+}
+
+// Conn provides a mock function with given fields: isMaster
+func (_m *Driver) Conn(isMaster bool) (string, error) {
+	ret := _m.Called(isMaster)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Conn")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(bool) (string, error)); ok {
+		return rf(isMaster)
+	}
+	if rf, ok := ret.Get(0).(func(bool) string); ok {
+		r0 = rf(isMaster)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(bool) error); ok {
+		r1 = rf(isMaster)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ConnClose provides a mock function with given fields: connID
+func (_m *Driver) ConnClose(connID string) error {
+	ret := _m.Called(connID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConnClose")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(connID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ConnExec provides a mock function with given fields: connID, q, args
+func (_m *Driver) ConnExec(connID string, q string, args []driver.NamedValue) (plugin.ResultContainer, error) {
+	ret := _m.Called(connID, q, args)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConnExec")
+	}
+
+	var r0 plugin.ResultContainer
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, []driver.NamedValue) (plugin.ResultContainer, error)); ok {
+		return rf(connID, q, args)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, []driver.NamedValue) plugin.ResultContainer); ok {
+		r0 = rf(connID, q, args)
+	} else {
+		r0 = ret.Get(0).(plugin.ResultContainer)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, []driver.NamedValue) error); ok {
+		r1 = rf(connID, q, args)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ConnPing provides a mock function with given fields: connID
+func (_m *Driver) ConnPing(connID string) error {
+	ret := _m.Called(connID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConnPing")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(connID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ConnQuery provides a mock function with given fields: connID, q, args
+func (_m *Driver) ConnQuery(connID string, q string, args []driver.NamedValue) (string, error) {
+	ret := _m.Called(connID, q, args)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConnQuery")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string, []driver.NamedValue) (string, error)); ok {
+		return rf(connID, q, args)
+	}
+	if rf, ok := ret.Get(0).(func(string, string, []driver.NamedValue) string); ok {
+		r0 = rf(connID, q, args)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string, []driver.NamedValue) error); ok {
+		r1 = rf(connID, q, args)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// RowsClose provides a mock function with given fields: rowsID
+func (_m *Driver) RowsClose(rowsID string) error {
+	ret := _m.Called(rowsID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RowsClose")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(rowsID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RowsColumnTypeDatabaseTypeName provides a mock function with given fields: rowsID, index
+func (_m *Driver) RowsColumnTypeDatabaseTypeName(rowsID string, index int) string {
+	ret := _m.Called(rowsID, index)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RowsColumnTypeDatabaseTypeName")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func(string, int) string); ok {
+		r0 = rf(rowsID, index)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// RowsColumnTypePrecisionScale provides a mock function with given fields: rowsID, index
+func (_m *Driver) RowsColumnTypePrecisionScale(rowsID string, index int) (int64, int64, bool) {
+	ret := _m.Called(rowsID, index)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RowsColumnTypePrecisionScale")
+	}
+
+	var r0 int64
+	var r1 int64
+	var r2 bool
+	if rf, ok := ret.Get(0).(func(string, int) (int64, int64, bool)); ok {
+		return rf(rowsID, index)
+	}
+	if rf, ok := ret.Get(0).(func(string, int) int64); ok {
+		r0 = rf(rowsID, index)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, int) int64); ok {
+		r1 = rf(rowsID, index)
+	} else {
+		r1 = ret.Get(1).(int64)
+	}
+
+	if rf, ok := ret.Get(2).(func(string, int) bool); ok {
+		r2 = rf(rowsID, index)
+	} else {
+		r2 = ret.Get(2).(bool)
+	}
+
+	return r0, r1, r2
+}
+
+// RowsColumns provides a mock function with given fields: rowsID
+func (_m *Driver) RowsColumns(rowsID string) []string {
+	ret := _m.Called(rowsID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RowsColumns")
+	}
+
+	var r0 []string
+	if rf, ok := ret.Get(0).(func(string) []string); ok {
+		r0 = rf(rowsID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	return r0
+}
+
+// RowsHasNextResultSet provides a mock function with given fields: rowsID
+func (_m *Driver) RowsHasNextResultSet(rowsID string) bool {
+	ret := _m.Called(rowsID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RowsHasNextResultSet")
+	}
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(string) bool); ok {
+		r0 = rf(rowsID)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// RowsNext provides a mock function with given fields: rowsID, dest
+func (_m *Driver) RowsNext(rowsID string, dest []driver.Value) error {
+	ret := _m.Called(rowsID, dest)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RowsNext")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, []driver.Value) error); ok {
+		r0 = rf(rowsID, dest)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RowsNextResultSet provides a mock function with given fields: rowsID
+func (_m *Driver) RowsNextResultSet(rowsID string) error {
+	ret := _m.Called(rowsID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RowsNextResultSet")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(rowsID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// Stmt provides a mock function with given fields: connID, q
+func (_m *Driver) Stmt(connID string, q string) (string, error) {
+	ret := _m.Called(connID, q)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Stmt")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, string) (string, error)); ok {
+		return rf(connID, q)
+	}
+	if rf, ok := ret.Get(0).(func(string, string) string); ok {
+		r0 = rf(connID, q)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, string) error); ok {
+		r1 = rf(connID, q)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// StmtClose provides a mock function with given fields: stID
+func (_m *Driver) StmtClose(stID string) error {
+	ret := _m.Called(stID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StmtClose")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(stID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// StmtExec provides a mock function with given fields: stID, args
+func (_m *Driver) StmtExec(stID string, args []driver.NamedValue) (plugin.ResultContainer, error) {
+	ret := _m.Called(stID, args)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StmtExec")
+	}
+
+	var r0 plugin.ResultContainer
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, []driver.NamedValue) (plugin.ResultContainer, error)); ok {
+		return rf(stID, args)
+	}
+	if rf, ok := ret.Get(0).(func(string, []driver.NamedValue) plugin.ResultContainer); ok {
+		r0 = rf(stID, args)
+	} else {
+		r0 = ret.Get(0).(plugin.ResultContainer)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, []driver.NamedValue) error); ok {
+		r1 = rf(stID, args)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// StmtNumInput provides a mock function with given fields: stID
+func (_m *Driver) StmtNumInput(stID string) int {
+	ret := _m.Called(stID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StmtNumInput")
+	}
+
+	var r0 int
+	if rf, ok := ret.Get(0).(func(string) int); ok {
+		r0 = rf(stID)
+	} else {
+		r0 = ret.Get(0).(int)
+	}
+
+	return r0
+}
+
+// StmtQuery provides a mock function with given fields: stID, args
+func (_m *Driver) StmtQuery(stID string, args []driver.NamedValue) (string, error) {
+	ret := _m.Called(stID, args)
+
+	if len(ret) == 0 {
+		panic("no return value specified for StmtQuery")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, []driver.NamedValue) (string, error)); ok {
+		return rf(stID, args)
+	}
+	if rf, ok := ret.Get(0).(func(string, []driver.NamedValue) string); ok {
+		r0 = rf(stID, args)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, []driver.NamedValue) error); ok {
+		r1 = rf(stID, args)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Tx provides a mock function with given fields: connID, opts
+func (_m *Driver) Tx(connID string, opts driver.TxOptions) (string, error) {
+	ret := _m.Called(connID, opts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for Tx")
+	}
+
+	var r0 string
+	var r1 error
+	if rf, ok := ret.Get(0).(func(string, driver.TxOptions) (string, error)); ok {
+		return rf(connID, opts)
+	}
+	if rf, ok := ret.Get(0).(func(string, driver.TxOptions) string); ok {
+		r0 = rf(connID, opts)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	if rf, ok := ret.Get(1).(func(string, driver.TxOptions) error); ok {
+		r1 = rf(connID, opts)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// TxCommit provides a mock function with given fields: txID
+func (_m *Driver) TxCommit(txID string) error {
+	ret := _m.Called(txID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for TxCommit")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(txID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// TxRollback provides a mock function with given fields: txID
+func (_m *Driver) TxRollback(txID string) error {
+	ret := _m.Called(txID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for TxRollback")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string) error); ok {
+		r0 = rf(txID)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NewDriver creates a new instance of Driver. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewDriver(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Driver {
+	mock := &Driver{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/public/plugin/plugintest/example_hello_user_test.go

@@ -0,0 +1,58 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package plugintest_test
+
+import (
+	"fmt"
+	io "io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/plugin"
+	"github.com/mattermost/mattermost/server/public/plugin/plugintest"
+)
+
+type HelloUserPlugin struct {
+	plugin.MattermostPlugin
+}
+
+func (p *HelloUserPlugin) ServeHTTP(context *plugin.Context, w http.ResponseWriter, r *http.Request) {
+	userID := r.Header.Get("Mattermost-User-Id")
+	user, err := p.API.GetUser(userID)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		p.API.LogError(err.Error())
+		return
+	}
+
+	fmt.Fprintf(w, "Welcome back, %s!", user.Username)
+}
+
+func Example() {
+	t := &testing.T{}
+	user := &model.User{
+		Id:       model.NewId(),
+		Username: "billybob",
+	}
+
+	api := &plugintest.API{}
+	api.On("GetUser", user.Id).Return(user, nil)
+	defer api.AssertExpectations(t)
+
+	p := &HelloUserPlugin{}
+	p.SetAPI(api)
+
+	w := httptest.NewRecorder()
+	r := httptest.NewRequest("GET", "/", nil)
+	r.Header.Add("Mattermost-User-Id", user.Id)
+	p.ServeHTTP(&plugin.Context{}, w, r)
+	body, err := io.ReadAll(w.Result().Body)
+	require.NoError(t, err)
+	assert.Equal(t, "Welcome back, billybob!", string(body))
+}

server/public/plugin/plugintest/example_reattach_test.go

@@ -0,0 +1,85 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package plugintest_test
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	goPlugin "github.com/hashicorp/go-plugin"
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/plugin"
+)
+
+type UnitTestedPlugin struct {
+	plugin.MattermostPlugin
+}
+
+// This example demonstrates a plugin that's launched during a unit test and reattached to an
+// existing server instance to obtain a real PluginAPI.
+func Example_unitTestingPlugins() {
+	t := &testing.T{}
+
+	// The manifest is usually generated dynamically.
+	manifest := &model.Manifest{
+		Id: "reattach-plugin-test",
+	}
+
+	// ctx, and specifically cancel, gives us control over the plugin lifecycle
+	ctx, cancel := context.WithCancel(context.Background())
+
+	// reattachConfigCh is the means by which we get the Unix socket information to relay back
+	// to the server and finish the reattachment.
+	reattachConfigCh := make(chan *goPlugin.ReattachConfig)
+
+	// closeCh tells us when the plugin exits and allows for cleanup.
+	closeCh := make(chan struct{})
+
+	// plugin.ClientMain with options allows for reattachment.
+	go plugin.ClientMain(
+		&UnitTestedPlugin{},
+		plugin.WithTestContext(ctx),
+		plugin.WithTestReattachConfigCh(reattachConfigCh),
+		plugin.WithTestCloseCh(closeCh),
+	)
+
+	// Make sure the plugin shuts down normally with the test
+	t.Cleanup(func() {
+		cancel()
+
+		select {
+		case <-closeCh:
+		case <-time.After(5 * time.Second):
+			panic("plugin failed to close after 5 seconds")
+		}
+	})
+
+	// Wait for the plugin to start and then reattach to the server.
+	var reattachConfig *goPlugin.ReattachConfig
+	select {
+	case reattachConfig = <-reattachConfigCh:
+	case <-time.After(5 * time.Second):
+		t.Fatal("failed to get reattach config")
+	}
+
+	// Reattaching requires a local mode client.
+	socketPath := os.Getenv("MM_LOCALSOCKETPATH")
+	if socketPath == "" {
+		socketPath = model.LocalModeSocketPath
+	}
+
+	clientLocal := model.NewAPIv4SocketClient(socketPath)
+	_, err := clientLocal.ReattachPlugin(ctx, &model.PluginReattachRequest{
+		Manifest:             manifest,
+		PluginReattachConfig: model.NewPluginReattachConfig(reattachConfig),
+	})
+	require.NoError(t, err)
+
+	// At this point, the plugin is ready for unit testing and will be cleaned up automatically
+	// with the testing.T instance.
+}

server/public/plugin/plugintest/hooks.go

@@ -0,0 +1,883 @@
+// Code generated by mockery v2.53.4. DO NOT EDIT.
+
+// Regenerate this file using `make plugin-mocks`.
+
+package plugintest
+
+import (
+	io "io"
+	http "net/http"
+
+	saml2 "github.com/mattermost/gosaml2"
+	model "github.com/mattermost/mattermost/server/public/model"
+	plugin "github.com/mattermost/mattermost/server/public/plugin"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// Hooks is an autogenerated mock type for the Hooks type
+type Hooks struct {
+	mock.Mock
+}
+
+// ChannelHasBeenCreated provides a mock function with given fields: c, channel
+func (_m *Hooks) ChannelHasBeenCreated(c *plugin.Context, channel *model.Channel) {
+	_m.Called(c, channel)
+}
+
+// ChannelMemberWillBeAdded provides a mock function with given fields: c, channelMember
+func (_m *Hooks) ChannelMemberWillBeAdded(c *plugin.Context, channelMember *model.ChannelMember) (*model.ChannelMember, string) {
+	ret := _m.Called(c, channelMember)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ChannelMemberWillBeAdded")
+	}
+
+	var r0 *model.ChannelMember
+	var r1 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.ChannelMember) (*model.ChannelMember, string)); ok {
+		return rf(c, channelMember)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.ChannelMember) *model.ChannelMember); ok {
+		r0 = rf(c, channelMember)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelMember)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.ChannelMember) string); ok {
+		r1 = rf(c, channelMember)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// ChannelWillBeArchived provides a mock function with given fields: c, channel
+func (_m *Hooks) ChannelWillBeArchived(c *plugin.Context, channel *model.Channel) string {
+	ret := _m.Called(c, channel)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ChannelWillBeArchived")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Channel) string); ok {
+		r0 = rf(c, channel)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// ChannelWillBeRestored provides a mock function with given fields: c, channel
+func (_m *Hooks) ChannelWillBeRestored(c *plugin.Context, channel *model.Channel) string {
+	ret := _m.Called(c, channel)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ChannelWillBeRestored")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Channel) string); ok {
+		r0 = rf(c, channel)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// ChannelWillBeUpdated provides a mock function with given fields: c, newChannel, oldChannel
+func (_m *Hooks) ChannelWillBeUpdated(c *plugin.Context, newChannel *model.Channel, oldChannel *model.Channel) (*model.Channel, string) {
+	ret := _m.Called(c, newChannel, oldChannel)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ChannelWillBeUpdated")
+	}
+
+	var r0 *model.Channel
+	var r1 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Channel, *model.Channel) (*model.Channel, string)); ok {
+		return rf(c, newChannel, oldChannel)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Channel, *model.Channel) *model.Channel); ok {
+		r0 = rf(c, newChannel, oldChannel)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Channel)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.Channel, *model.Channel) string); ok {
+		r1 = rf(c, newChannel, oldChannel)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// ConfigurationWillBeSaved provides a mock function with given fields: newCfg
+func (_m *Hooks) ConfigurationWillBeSaved(newCfg *model.Config) (*model.Config, error) {
+	ret := _m.Called(newCfg)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ConfigurationWillBeSaved")
+	}
+
+	var r0 *model.Config
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.Config) (*model.Config, error)); ok {
+		return rf(newCfg)
+	}
+	if rf, ok := ret.Get(0).(func(*model.Config) *model.Config); ok {
+		r0 = rf(newCfg)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Config)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.Config) error); ok {
+		r1 = rf(newCfg)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// DraftWillBeUpserted provides a mock function with given fields: c, draft
+func (_m *Hooks) DraftWillBeUpserted(c *plugin.Context, draft *model.Draft) (*model.Draft, string) {
+	ret := _m.Called(c, draft)
+
+	if len(ret) == 0 {
+		panic("no return value specified for DraftWillBeUpserted")
+	}
+
+	var r0 *model.Draft
+	var r1 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Draft) (*model.Draft, string)); ok {
+		return rf(c, draft)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Draft) *model.Draft); ok {
+		r0 = rf(c, draft)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Draft)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.Draft) string); ok {
+		r1 = rf(c, draft)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// EmailNotificationWillBeSent provides a mock function with given fields: emailNotification
+func (_m *Hooks) EmailNotificationWillBeSent(emailNotification *model.EmailNotification) (*model.EmailNotificationContent, string) {
+	ret := _m.Called(emailNotification)
+
+	if len(ret) == 0 {
+		panic("no return value specified for EmailNotificationWillBeSent")
+	}
+
+	var r0 *model.EmailNotificationContent
+	var r1 string
+	if rf, ok := ret.Get(0).(func(*model.EmailNotification) (*model.EmailNotificationContent, string)); ok {
+		return rf(emailNotification)
+	}
+	if rf, ok := ret.Get(0).(func(*model.EmailNotification) *model.EmailNotificationContent); ok {
+		r0 = rf(emailNotification)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.EmailNotificationContent)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.EmailNotification) string); ok {
+		r1 = rf(emailNotification)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// ExecuteCommand provides a mock function with given fields: c, args
+func (_m *Hooks) ExecuteCommand(c *plugin.Context, args *model.CommandArgs) (*model.CommandResponse, *model.AppError) {
+	ret := _m.Called(c, args)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ExecuteCommand")
+	}
+
+	var r0 *model.CommandResponse
+	var r1 *model.AppError
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.CommandArgs) (*model.CommandResponse, *model.AppError)); ok {
+		return rf(c, args)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.CommandArgs) *model.CommandResponse); ok {
+		r0 = rf(c, args)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.CommandResponse)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.CommandArgs) *model.AppError); ok {
+		r1 = rf(c, args)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
+// FileWillBeDownloaded provides a mock function with given fields: c, fileInfo, userID, downloadType
+func (_m *Hooks) FileWillBeDownloaded(c *plugin.Context, fileInfo *model.FileInfo, userID string, downloadType model.FileDownloadType) string {
+	ret := _m.Called(c, fileInfo, userID, downloadType)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FileWillBeDownloaded")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.FileInfo, string, model.FileDownloadType) string); ok {
+		r0 = rf(c, fileInfo, userID, downloadType)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// FileWillBeUploaded provides a mock function with given fields: c, info, file, output
+func (_m *Hooks) FileWillBeUploaded(c *plugin.Context, info *model.FileInfo, file io.Reader, output io.Writer) (*model.FileInfo, string) {
+	ret := _m.Called(c, info, file, output)
+
+	if len(ret) == 0 {
+		panic("no return value specified for FileWillBeUploaded")
+	}
+
+	var r0 *model.FileInfo
+	var r1 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.FileInfo, io.Reader, io.Writer) (*model.FileInfo, string)); ok {
+		return rf(c, info, file, output)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.FileInfo, io.Reader, io.Writer) *model.FileInfo); ok {
+		r0 = rf(c, info, file, output)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.FileInfo)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.FileInfo, io.Reader, io.Writer) string); ok {
+		r1 = rf(c, info, file, output)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// GenerateSupportData provides a mock function with given fields: c
+func (_m *Hooks) GenerateSupportData(c *plugin.Context) ([]*model.FileData, error) {
+	ret := _m.Called(c)
+
+	if len(ret) == 0 {
+		panic("no return value specified for GenerateSupportData")
+	}
+
+	var r0 []*model.FileData
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*plugin.Context) ([]*model.FileData, error)); ok {
+		return rf(c)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context) []*model.FileData); ok {
+		r0 = rf(c)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.FileData)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context) error); ok {
+		r1 = rf(c)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// Implemented provides a mock function with no fields
+func (_m *Hooks) Implemented() ([]string, error) {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for Implemented")
+	}
+
+	var r0 []string
+	var r1 error
+	if rf, ok := ret.Get(0).(func() ([]string, error)); ok {
+		return rf()
+	}
+	if rf, ok := ret.Get(0).(func() []string); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]string)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// MessageHasBeenDeleted provides a mock function with given fields: c, post
+func (_m *Hooks) MessageHasBeenDeleted(c *plugin.Context, post *model.Post) {
+	_m.Called(c, post)
+}
+
+// MessageHasBeenPosted provides a mock function with given fields: c, post
+func (_m *Hooks) MessageHasBeenPosted(c *plugin.Context, post *model.Post) {
+	_m.Called(c, post)
+}
+
+// MessageHasBeenUpdated provides a mock function with given fields: c, newPost, oldPost
+func (_m *Hooks) MessageHasBeenUpdated(c *plugin.Context, newPost *model.Post, oldPost *model.Post) {
+	_m.Called(c, newPost, oldPost)
+}
+
+// MessageWillBePosted provides a mock function with given fields: c, post
+func (_m *Hooks) MessageWillBePosted(c *plugin.Context, post *model.Post) (*model.Post, string) {
+	ret := _m.Called(c, post)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MessageWillBePosted")
+	}
+
+	var r0 *model.Post
+	var r1 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Post) (*model.Post, string)); ok {
+		return rf(c, post)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Post) *model.Post); ok {
+		r0 = rf(c, post)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Post)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.Post) string); ok {
+		r1 = rf(c, post)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// MessageWillBeUpdated provides a mock function with given fields: c, newPost, oldPost
+func (_m *Hooks) MessageWillBeUpdated(c *plugin.Context, newPost *model.Post, oldPost *model.Post) (*model.Post, string) {
+	ret := _m.Called(c, newPost, oldPost)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MessageWillBeUpdated")
+	}
+
+	var r0 *model.Post
+	var r1 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Post, *model.Post) (*model.Post, string)); ok {
+		return rf(c, newPost, oldPost)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Post, *model.Post) *model.Post); ok {
+		r0 = rf(c, newPost, oldPost)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Post)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.Post, *model.Post) string); ok {
+		r1 = rf(c, newPost, oldPost)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// MessagesWillBeConsumed provides a mock function with given fields: posts
+func (_m *Hooks) MessagesWillBeConsumed(posts []*model.Post) []*model.Post {
+	ret := _m.Called(posts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MessagesWillBeConsumed")
+	}
+
+	var r0 []*model.Post
+	if rf, ok := ret.Get(0).(func([]*model.Post) []*model.Post); ok {
+		r0 = rf(posts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Post)
+		}
+	}
+
+	return r0
+}
+
+// MessagesWillBeConsumedWithContext provides a mock function with given fields: c, posts
+func (_m *Hooks) MessagesWillBeConsumedWithContext(c *plugin.Context, posts []*model.Post) []*model.Post {
+	ret := _m.Called(c, posts)
+
+	if len(ret) == 0 {
+		panic("no return value specified for MessagesWillBeConsumedWithContext")
+	}
+
+	var r0 []*model.Post
+	if rf, ok := ret.Get(0).(func(*plugin.Context, []*model.Post) []*model.Post); ok {
+		r0 = rf(c, posts)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*model.Post)
+		}
+	}
+
+	return r0
+}
+
+// NotificationWillBePushed provides a mock function with given fields: pushNotification, userID
+func (_m *Hooks) NotificationWillBePushed(pushNotification *model.PushNotification, userID string) (*model.PushNotification, string) {
+	ret := _m.Called(pushNotification, userID)
+
+	if len(ret) == 0 {
+		panic("no return value specified for NotificationWillBePushed")
+	}
+
+	var r0 *model.PushNotification
+	var r1 string
+	if rf, ok := ret.Get(0).(func(*model.PushNotification, string) (*model.PushNotification, string)); ok {
+		return rf(pushNotification, userID)
+	}
+	if rf, ok := ret.Get(0).(func(*model.PushNotification, string) *model.PushNotification); ok {
+		r0 = rf(pushNotification, userID)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.PushNotification)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.PushNotification, string) string); ok {
+		r1 = rf(pushNotification, userID)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// OnActivate provides a mock function with no fields
+func (_m *Hooks) OnActivate() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnActivate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OnCloudLimitsUpdated provides a mock function with given fields: limits
+func (_m *Hooks) OnCloudLimitsUpdated(limits *model.ProductLimits) {
+	_m.Called(limits)
+}
+
+// OnConfigurationChange provides a mock function with no fields
+func (_m *Hooks) OnConfigurationChange() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnConfigurationChange")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OnDeactivate provides a mock function with no fields
+func (_m *Hooks) OnDeactivate() error {
+	ret := _m.Called()
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnDeactivate")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OnInstall provides a mock function with given fields: c, event
+func (_m *Hooks) OnInstall(c *plugin.Context, event model.OnInstallEvent) error {
+	ret := _m.Called(c, event)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnInstall")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*plugin.Context, model.OnInstallEvent) error); ok {
+		r0 = rf(c, event)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OnLicenseChanged provides a mock function with given fields: oldLicense, newLicense
+func (_m *Hooks) OnLicenseChanged(oldLicense *model.License, newLicense *model.License) {
+	_m.Called(oldLicense, newLicense)
+}
+
+// OnPluginClusterEvent provides a mock function with given fields: c, ev
+func (_m *Hooks) OnPluginClusterEvent(c *plugin.Context, ev model.PluginClusterEvent) {
+	_m.Called(c, ev)
+}
+
+// OnSAMLLogin provides a mock function with given fields: c, user, assertion
+func (_m *Hooks) OnSAMLLogin(c *plugin.Context, user *model.User, assertion *saml2.AssertionInfo) error {
+	ret := _m.Called(c, user, assertion)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnSAMLLogin")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.User, *saml2.AssertionInfo) error); ok {
+		r0 = rf(c, user, assertion)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OnSendDailyTelemetry provides a mock function with no fields
+func (_m *Hooks) OnSendDailyTelemetry() {
+	_m.Called()
+}
+
+// OnSharedChannelsAttachmentSyncMsg provides a mock function with given fields: fi, post, rc
+func (_m *Hooks) OnSharedChannelsAttachmentSyncMsg(fi *model.FileInfo, post *model.Post, rc *model.RemoteCluster) error {
+	ret := _m.Called(fi, post, rc)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnSharedChannelsAttachmentSyncMsg")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.FileInfo, *model.Post, *model.RemoteCluster) error); ok {
+		r0 = rf(fi, post, rc)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OnSharedChannelsPing provides a mock function with given fields: rc
+func (_m *Hooks) OnSharedChannelsPing(rc *model.RemoteCluster) bool {
+	ret := _m.Called(rc)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnSharedChannelsPing")
+	}
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(*model.RemoteCluster) bool); ok {
+		r0 = rf(rc)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// OnSharedChannelsProfileImageSyncMsg provides a mock function with given fields: user, rc
+func (_m *Hooks) OnSharedChannelsProfileImageSyncMsg(user *model.User, rc *model.RemoteCluster) error {
+	ret := _m.Called(user, rc)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnSharedChannelsProfileImageSyncMsg")
+	}
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.User, *model.RemoteCluster) error); ok {
+		r0 = rf(user, rc)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OnSharedChannelsSyncMsg provides a mock function with given fields: msg, rc
+func (_m *Hooks) OnSharedChannelsSyncMsg(msg *model.SyncMsg, rc *model.RemoteCluster) (model.SyncResponse, error) {
+	ret := _m.Called(msg, rc)
+
+	if len(ret) == 0 {
+		panic("no return value specified for OnSharedChannelsSyncMsg")
+	}
+
+	var r0 model.SyncResponse
+	var r1 error
+	if rf, ok := ret.Get(0).(func(*model.SyncMsg, *model.RemoteCluster) (model.SyncResponse, error)); ok {
+		return rf(msg, rc)
+	}
+	if rf, ok := ret.Get(0).(func(*model.SyncMsg, *model.RemoteCluster) model.SyncResponse); ok {
+		r0 = rf(msg, rc)
+	} else {
+		r0 = ret.Get(0).(model.SyncResponse)
+	}
+
+	if rf, ok := ret.Get(1).(func(*model.SyncMsg, *model.RemoteCluster) error); ok {
+		r1 = rf(msg, rc)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// OnWebSocketConnect provides a mock function with given fields: webConnID, userID
+func (_m *Hooks) OnWebSocketConnect(webConnID string, userID string) {
+	_m.Called(webConnID, userID)
+}
+
+// OnWebSocketDisconnect provides a mock function with given fields: webConnID, userID
+func (_m *Hooks) OnWebSocketDisconnect(webConnID string, userID string) {
+	_m.Called(webConnID, userID)
+}
+
+// PreferencesHaveChanged provides a mock function with given fields: c, preferences
+func (_m *Hooks) PreferencesHaveChanged(c *plugin.Context, preferences []model.Preference) {
+	_m.Called(c, preferences)
+}
+
+// ReactionHasBeenAdded provides a mock function with given fields: c, reaction
+func (_m *Hooks) ReactionHasBeenAdded(c *plugin.Context, reaction *model.Reaction) {
+	_m.Called(c, reaction)
+}
+
+// ReactionHasBeenRemoved provides a mock function with given fields: c, reaction
+func (_m *Hooks) ReactionHasBeenRemoved(c *plugin.Context, reaction *model.Reaction) {
+	_m.Called(c, reaction)
+}
+
+// RunDataRetention provides a mock function with given fields: nowTime, batchSize
+func (_m *Hooks) RunDataRetention(nowTime int64, batchSize int64) (int64, error) {
+	ret := _m.Called(nowTime, batchSize)
+
+	if len(ret) == 0 {
+		panic("no return value specified for RunDataRetention")
+	}
+
+	var r0 int64
+	var r1 error
+	if rf, ok := ret.Get(0).(func(int64, int64) (int64, error)); ok {
+		return rf(nowTime, batchSize)
+	}
+	if rf, ok := ret.Get(0).(func(int64, int64) int64); ok {
+		r0 = rf(nowTime, batchSize)
+	} else {
+		r0 = ret.Get(0).(int64)
+	}
+
+	if rf, ok := ret.Get(1).(func(int64, int64) error); ok {
+		r1 = rf(nowTime, batchSize)
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}
+
+// ScheduledPostWillBeCreated provides a mock function with given fields: c, scheduledPost
+func (_m *Hooks) ScheduledPostWillBeCreated(c *plugin.Context, scheduledPost *model.ScheduledPost) (*model.ScheduledPost, string) {
+	ret := _m.Called(c, scheduledPost)
+
+	if len(ret) == 0 {
+		panic("no return value specified for ScheduledPostWillBeCreated")
+	}
+
+	var r0 *model.ScheduledPost
+	var r1 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.ScheduledPost) (*model.ScheduledPost, string)); ok {
+		return rf(c, scheduledPost)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.ScheduledPost) *model.ScheduledPost); ok {
+		r0 = rf(c, scheduledPost)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ScheduledPost)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.ScheduledPost) string); ok {
+		r1 = rf(c, scheduledPost)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// ServeHTTP provides a mock function with given fields: c, w, r
+func (_m *Hooks) ServeHTTP(c *plugin.Context, w http.ResponseWriter, r *http.Request) {
+	_m.Called(c, w, r)
+}
+
+// ServeMetrics provides a mock function with given fields: c, w, r
+func (_m *Hooks) ServeMetrics(c *plugin.Context, w http.ResponseWriter, r *http.Request) {
+	_m.Called(c, w, r)
+}
+
+// TeamMemberWillBeAdded provides a mock function with given fields: c, teamMember
+func (_m *Hooks) TeamMemberWillBeAdded(c *plugin.Context, teamMember *model.TeamMember) (*model.TeamMember, string) {
+	ret := _m.Called(c, teamMember)
+
+	if len(ret) == 0 {
+		panic("no return value specified for TeamMemberWillBeAdded")
+	}
+
+	var r0 *model.TeamMember
+	var r1 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.TeamMember) (*model.TeamMember, string)); ok {
+		return rf(c, teamMember)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.TeamMember) *model.TeamMember); ok {
+		r0 = rf(c, teamMember)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.TeamMember)
+		}
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.TeamMember) string); ok {
+		r1 = rf(c, teamMember)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// UserHasBeenCreated provides a mock function with given fields: c, user
+func (_m *Hooks) UserHasBeenCreated(c *plugin.Context, user *model.User) {
+	_m.Called(c, user)
+}
+
+// UserHasBeenDeactivated provides a mock function with given fields: c, user
+func (_m *Hooks) UserHasBeenDeactivated(c *plugin.Context, user *model.User) {
+	_m.Called(c, user)
+}
+
+// UserHasJoinedChannel provides a mock function with given fields: c, channelMember, actor
+func (_m *Hooks) UserHasJoinedChannel(c *plugin.Context, channelMember *model.ChannelMember, actor *model.User) {
+	_m.Called(c, channelMember, actor)
+}
+
+// UserHasJoinedTeam provides a mock function with given fields: c, teamMember, actor
+func (_m *Hooks) UserHasJoinedTeam(c *plugin.Context, teamMember *model.TeamMember, actor *model.User) {
+	_m.Called(c, teamMember, actor)
+}
+
+// UserHasLeftChannel provides a mock function with given fields: c, channelMember, actor
+func (_m *Hooks) UserHasLeftChannel(c *plugin.Context, channelMember *model.ChannelMember, actor *model.User) {
+	_m.Called(c, channelMember, actor)
+}
+
+// UserHasLeftTeam provides a mock function with given fields: c, teamMember, actor
+func (_m *Hooks) UserHasLeftTeam(c *plugin.Context, teamMember *model.TeamMember, actor *model.User) {
+	_m.Called(c, teamMember, actor)
+}
+
+// UserHasLoggedIn provides a mock function with given fields: c, user
+func (_m *Hooks) UserHasLoggedIn(c *plugin.Context, user *model.User) {
+	_m.Called(c, user)
+}
+
+// UserWillLogIn provides a mock function with given fields: c, user
+func (_m *Hooks) UserWillLogIn(c *plugin.Context, user *model.User) string {
+	ret := _m.Called(c, user)
+
+	if len(ret) == 0 {
+		panic("no return value specified for UserWillLogIn")
+	}
+
+	var r0 string
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.User) string); ok {
+		r0 = rf(c, user)
+	} else {
+		r0 = ret.Get(0).(string)
+	}
+
+	return r0
+}
+
+// WebSocketMessageHasBeenPosted provides a mock function with given fields: webConnID, userID, req
+func (_m *Hooks) WebSocketMessageHasBeenPosted(webConnID string, userID string, req *model.WebSocketRequest) {
+	_m.Called(webConnID, userID, req)
+}
+
+// NewHooks creates a new instance of Hooks. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// The first argument is typically a *testing.T value.
+func NewHooks(t interface {
+	mock.TestingT
+	Cleanup(func())
+}) *Hooks {
+	mock := &Hooks{}
+	mock.Mock.Test(t)
+
+	t.Cleanup(func() { mock.AssertExpectations(t) })
+
+	return mock
+}

server/public/plugin/plugintest/hooks_with_rpcerr.go

@@ -0,0 +1,114 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+// Hand-written *WithRPCErr mock methods for the three hooks excluded from the code generator.
+// The auto-generated hooks.go (regenerated by `make plugin-mocks`) covers the base Hooks interface;
+// this file adds the extra *WithRPCErr companions so *Hooks satisfies plugin.HooksWithRPCErr.
+// This file is not overwritten by `make plugin-mocks` because mockery writes only hooks.go for the
+// Hooks interface (filename: "{{.InterfaceNameLower}}.go" in .mockery.yaml).
+
+package plugintest
+
+import (
+	model "github.com/mattermost/mattermost/server/public/model"
+	plugin "github.com/mattermost/mattermost/server/public/plugin"
+)
+
+// MessageWillBePostedWithRPCErr provides a mock function with given fields: c, post
+func (_m *Hooks) MessageWillBePostedWithRPCErr(c *plugin.Context, post *model.Post) (*model.Post, string, error) {
+	ret := _m.Called(c, post)
+
+	var r0 *model.Post
+	var r1 string
+	var r2 error
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Post) (*model.Post, string, error)); ok {
+		return rf(c, post)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Post) *model.Post); ok {
+		r0 = rf(c, post)
+	} else if ret.Get(0) != nil {
+		r0 = ret.Get(0).(*model.Post)
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.Post) string); ok {
+		r1 = rf(c, post)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	if rf, ok := ret.Get(2).(func(*plugin.Context, *model.Post) error); ok {
+		r2 = rf(c, post)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// MessageWillBeUpdatedWithRPCErr provides a mock function with given fields: c, newPost, oldPost
+func (_m *Hooks) MessageWillBeUpdatedWithRPCErr(c *plugin.Context, newPost *model.Post, oldPost *model.Post) (*model.Post, string, error) {
+	ret := _m.Called(c, newPost, oldPost)
+
+	var r0 *model.Post
+	var r1 string
+	var r2 error
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Post, *model.Post) (*model.Post, string, error)); ok {
+		return rf(c, newPost, oldPost)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.Post, *model.Post) *model.Post); ok {
+		r0 = rf(c, newPost, oldPost)
+	} else if ret.Get(0) != nil {
+		r0 = ret.Get(0).(*model.Post)
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.Post, *model.Post) string); ok {
+		r1 = rf(c, newPost, oldPost)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	if rf, ok := ret.Get(2).(func(*plugin.Context, *model.Post, *model.Post) error); ok {
+		r2 = rf(c, newPost, oldPost)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// ChannelMemberWillBeAddedWithRPCErr provides a mock function with given fields: c, channelMember
+func (_m *Hooks) ChannelMemberWillBeAddedWithRPCErr(c *plugin.Context, channelMember *model.ChannelMember) (*model.ChannelMember, string, error) {
+	ret := _m.Called(c, channelMember)
+
+	var r0 *model.ChannelMember
+	var r1 string
+	var r2 error
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.ChannelMember) (*model.ChannelMember, string, error)); ok {
+		return rf(c, channelMember)
+	}
+	if rf, ok := ret.Get(0).(func(*plugin.Context, *model.ChannelMember) *model.ChannelMember); ok {
+		r0 = rf(c, channelMember)
+	} else if ret.Get(0) != nil {
+		r0 = ret.Get(0).(*model.ChannelMember)
+	}
+
+	if rf, ok := ret.Get(1).(func(*plugin.Context, *model.ChannelMember) string); ok {
+		r1 = rf(c, channelMember)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	if rf, ok := ret.Get(2).(func(*plugin.Context, *model.ChannelMember) error); ok {
+		r2 = rf(c, channelMember)
+	} else {
+		r2 = ret.Error(2)
+	}
+
+	return r0, r1, r2
+}
+
+// Note: plugintest.Hooks is a mock for the base Hooks interface only. The auto-generated
+// hooks.go does not include *WithRPCErr methods, so *Hooks cannot satisfy HooksWithRPCErr
+// in full. The production compile-time assertions for HooksWithRPCErr live in client_rpc.go
+// (for *hooksRPCClient and *hooksTimerLayer). Tests that need a HooksWithRPCErr double
+// should embed *Hooks and add the needed *WithRPCErr stubs directly.

server/public/plugin/plugintest/mock/mock.go

@@ -0,0 +1,33 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+// This package provides aliases for the contents of "github.com/stretchr/testify/mock". Because
+// external packages can't import our vendored dependencies, this is necessary for them to be able
+// to fully utilize the plugintest package.
+package mock
+
+import (
+	"github.com/stretchr/testify/mock"
+)
+
+const (
+	Anything = mock.Anything
+)
+
+type Arguments = mock.Arguments
+type AnythingOfTypeArgument = mock.AnythingOfTypeArgument
+type Call = mock.Call
+type Mock = mock.Mock
+type TestingT = mock.TestingT
+
+func AnythingOfType(t string) AnythingOfTypeArgument {
+	return mock.AnythingOfType(t)
+}
+
+func AssertExpectationsForObjects(t TestingT, testObjects ...any) bool {
+	return mock.AssertExpectationsForObjects(t, testObjects...)
+}
+
+func MatchedBy(fn any) any {
+	return mock.MatchedBy(fn)
+}