MM-10249 Adding plugin ability to intercept posts before they reach the DB. (#8791)

* Adding plugin ability to intercept posts before they reach the DB.

* s/envoked/invoked/

Makefile

@@ -277,7 +277,14 @@ store-mocks: ## Creates mock files.
 
 ldap-mocks: ## Creates mock files for ldap.
 	go get github.com/vektra/mockery/...
-	GOPATH=$(shell go env GOPATH) $(shell go env GOPATH)/bin/mockery -dir enterprise/ldap -all -output enterprise/ldap/mocks -note 'Regenerate this file using `make ldap-mocks`.'
+	$(GOPATH)/bin/mockery -dir enterprise/ldap -all -output enterprise/ldap/mocks -note 'Regenerate this file using `make ldap-mocks`.'
+
+plugin-mocks: ## Creates mock files for plugins.
+	go get github.com/vektra/mockery/...
+	$(GOPATH)/bin/mockery -dir plugin -name API -output plugin/plugintest -outpkg plugintest -case underscore -note 'Regenerate this file using `make plugin-mocks`.'
+	$(GOPATH)/bin/mockery -dir plugin -name KeyValueStore -output plugin/plugintest -outpkg plugintest -case underscore -note 'Regenerate this file using `make plugin-mocks`.'
+	$(GOPATH)/bin/mockery -dir plugin -name Hooks -output plugin/plugintest -outpkg plugintest -case underscore -note 'Regenerate this file using `make plugin-mocks`.'
+	@sed -i'' -e 's|API|APIMOCKINTERNAL|g' plugin/plugintest/api.go
 
 update-jira-plugin: ## Updates Jira plugin.
 	go get github.com/mattermost/go-bindata/...

app/plugin.go

@@ -661,3 +661,7 @@ func (a *App) ExecutePluginCommand(args *model.CommandArgs) (*model.Command, *mo
 	}
 	return nil, nil, nil
 }
+
+func (a *App) PluginsReady() bool {
+	return a.PluginEnv != nil && *a.Config().PluginSettings.Enable
+}

app/post.go

@@ -160,6 +160,14 @@ func (a *App) CreatePost(post *model.Post, channel *model.Channel, triggerWebhoo
 		return nil, err
 	}
 
+	if a.PluginsReady() {
+		if newPost, rejectionReason := a.PluginEnv.Hooks().MessageWillBePosted(post); newPost == nil {
+			return nil, model.NewAppError("createPost", "Post rejected by plugin. "+rejectionReason, nil, "", http.StatusBadRequest)
+		} else {
+			post = newPost
+		}
+	}
+
 	var rpost *model.Post
 	if result := <-a.Srv.Store.Post().Save(post); result.Err != nil {
 		return nil, result.Err
@@ -167,6 +175,12 @@ func (a *App) CreatePost(post *model.Post, channel *model.Channel, triggerWebhoo
 		rpost = result.Data.(*model.Post)
 	}
 
+	if a.PluginsReady() {
+		a.Go(func() {
+			a.PluginEnv.Hooks().MessageHasBeenPosted(rpost)
+		})
+	}
+
 	esInterface := a.Elasticsearch
 	if esInterface != nil && *a.Config().ElasticsearchSettings.EnableIndexing {
 		a.Go(func() {
@@ -371,11 +385,25 @@ func (a *App) UpdatePost(post *model.Post, safeUpdate bool) (*model.Post, *model
 		return nil, err
 	}
 
+	if a.PluginsReady() {
+		if pluginModifiedPost, rejectionReason := a.PluginEnv.Hooks().MessageWillBeUpdated(newPost, oldPost); pluginModifiedPost == nil {
+			return nil, model.NewAppError("createPost", "Post rejected by plugin. "+rejectionReason, nil, "", http.StatusBadRequest)
+		} else {
+			newPost = pluginModifiedPost
+		}
+	}
+
 	if result := <-a.Srv.Store.Post().Update(newPost, oldPost); result.Err != nil {
 		return nil, result.Err
 	} else {
 		rpost := result.Data.(*model.Post)
 
+		if a.PluginsReady() {
+			a.Go(func() {
+				a.PluginEnv.Hooks().MessageHasBeenUpdated(newPost, oldPost)
+			})
+		}
+
 		esInterface := a.Elasticsearch
 		if esInterface != nil && *a.Config().ElasticsearchSettings.EnableIndexing {
 			a.Go(func() {

plugin/hooks.go

@@ -36,4 +36,37 @@ type Hooks interface {
 	// ExecuteCommand executes a command that has been previously registered via the RegisterCommand
 	// API.
 	ExecuteCommand(args *model.CommandArgs) (*model.CommandResponse, *model.AppError)
+
+	// MessageWillBePosted is invoked when a message is posted by a user before it is commited
+	// to the database. If you also want to act on edited posts, see MessageWillBeUpdated.
+	// Return values should be the modified post or nil if rejected and an explanation for the user.
+	//
+	// If you don't need to modify or reject posts, use MessageHasBeenPosted instead.
+	//
+	// Note that this method will be called for posts created by plugins, including the plugin that
+	// created the post.
+	MessageWillBePosted(post *model.Post) (*model.Post, string)
+
+	// MessageWillBeUpdated is invoked when a message is updated by a user before it is commited
+	// to the database. If you also want to act on new posts, see MessageWillBePosted.
+	// Return values should be the modified post or nil if rejected and an explanation for the user.
+	// On rejection, the post will be kept in its previous state.
+	//
+	// If you don't need to modify or rejected updated posts, use MessageHasBeenUpdated instead.
+	//
+	// Note that this method will be called for posts updated by plugins, including the plugin that
+	// updated the post.
+	MessageWillBeUpdated(newPost, oldPost *model.Post) (*model.Post, string)
+
+	// MessageHasBeenPosted is invoked after the message has been commited to the databse.
+	// If you need to modify or reject the post, see MessageWillBePosted
+	// Note that this method will be called for posts created by plugins, including the plugin that
+	// created the post.
+	MessageHasBeenPosted(post *model.Post)
+
+	// MessageHasBeenUpdated is invoked after a message is updated and has been updated in the databse.
+	// If you need to modify or reject the post, see MessageWillBeUpdated
+	// Note that this method will be called for posts created by plugins, including the plugin that
+	// created the post.
+	MessageHasBeenUpdated(newPost, oldPost *model.Post)
 }

plugin/pluginenv/environment.go

@@ -306,6 +306,65 @@ func (h *MultiPluginHooks) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	http.NotFound(w, r)
 }
 
+// MessageWillBePosted invokes the MessageWillBePosted hook for all plugins. Ordering
+// is not guaranteed and the next plugin will get the previous one's modifications.
+// if a plugin rejects a post, the rest of the plugins will not know that an attempt was made.
+// Returns the final result post, or nil if the post was rejected and a string with a reason
+// for the user the message was rejected.
+func (h *MultiPluginHooks) MessageWillBePosted(post *model.Post) (*model.Post, string) {
+	h.env.mutex.RLock()
+	defer h.env.mutex.RUnlock()
+
+	for _, activePlugin := range h.env.activePlugins {
+		if activePlugin.Supervisor == nil {
+			continue
+		}
+		var rejectionReason string
+		post, rejectionReason = activePlugin.Supervisor.Hooks().MessageWillBePosted(post)
+		if post == nil {
+			return nil, rejectionReason
+		}
+	}
+	return post, ""
+}
+
+// MessageWillBeUpdated invokes the MessageWillBeUpdated hook for all plugins. Ordering
+// is not guaranteed and the next plugin will get the previous one's modifications.
+// if a plugin rejects a post, the rest of the plugins will not know that an attempt was made.
+// Returns the final result post, or nil if the post was rejected and a string with a reason
+// for the user the message was rejected.
+func (h *MultiPluginHooks) MessageWillBeUpdated(newPost, oldPost *model.Post) (*model.Post, string) {
+	h.env.mutex.RLock()
+	defer h.env.mutex.RUnlock()
+
+	post := newPost
+	for _, activePlugin := range h.env.activePlugins {
+		if activePlugin.Supervisor == nil {
+			continue
+		}
+		var rejectionReason string
+		post, rejectionReason = activePlugin.Supervisor.Hooks().MessageWillBeUpdated(post, oldPost)
+		if post == nil {
+			return nil, rejectionReason
+		}
+	}
+	return post, ""
+}
+
+func (h *MultiPluginHooks) MessageHasBeenPosted(post *model.Post) {
+	h.invoke(func(hooks plugin.Hooks) error {
+		hooks.MessageHasBeenPosted(post)
+		return nil
+	})
+}
+
+func (h *MultiPluginHooks) MessageHasBeenUpdated(newPost, oldPost *model.Post) {
+	h.invoke(func(hooks plugin.Hooks) error {
+		hooks.MessageHasBeenUpdated(newPost, oldPost)
+		return nil
+	})
+}
+
 func (h *SinglePluginHooks) invoke(f func(plugin.Hooks) error) error {
 	h.env.mutex.RLock()
 	defer h.env.mutex.RUnlock()

plugin/plugintest/api.go

@@ -1,344 +1,702 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// Code generated by mockery v1.0.0. DO NOT EDIT.
-// See License.txt for license information.
+
+// Regenerate this file using `make plugin-mocks`.
 
 package plugintest
 
-import (
+import mock "github.com/stretchr/testify/mock"
-	"github.com/stretchr/testify/mock"
+import model "github.com/mattermost/mattermost-server/model"
+import plugin "github.com/mattermost/mattermost-server/plugin"
 
-	"github.com/mattermost/mattermost-server/model"
+// APIMOCKINTERNAL is an autogenerated mock type for the APIMOCKINTERNAL type
-	"github.com/mattermost/mattermost-server/plugin"
+type APIMOCKINTERNAL struct {
-)
-
-type API struct {
-	mock.Mock
-	Store *KeyValueStore
-}
-
-type KeyValueStore struct {
 	mock.Mock
 }
 
-var _ plugin.API = (*API)(nil)
+// AddChannelMember provides a mock function with given fields: channelId, userId
-var _ plugin.KeyValueStore = (*KeyValueStore)(nil)
+func (_m *APIMOCKINTERNAL) AddChannelMember(channelId string, userId string) (*model.ChannelMember, *model.AppError) {
+	ret := _m.Called(channelId, userId)
 
-func (m *API) LoadPluginConfiguration(dest interface{}) error {
+	var r0 *model.ChannelMember
-	ret := m.Called(dest)
+	if rf, ok := ret.Get(0).(func(string, string) *model.ChannelMember); ok {
-	if f, ok := ret.Get(0).(func(interface{}) error); ok {
+		r0 = rf(channelId, userId)
-		return f(dest)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelMember)
+		}
 	}
-	return ret.Error(0)
-}
 
-func (m *API) RegisterCommand(command *model.Command) error {
+	var r1 *model.AppError
-	ret := m.Called(command)
+	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(*model.Command) error); ok {
+		r1 = rf(channelId, userId)
-		return f(command)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	return ret.Error(0)
+
+	return r0, r1
 }
 
-func (m *API) UnregisterCommand(teamId, trigger string) error {
+// CreateChannel provides a mock function with given fields: channel
-	ret := m.Called(teamId, trigger)
+func (_m *APIMOCKINTERNAL) CreateChannel(channel *model.Channel) (*model.Channel, *model.AppError) {
-	if f, ok := ret.Get(0).(func(string, string) error); ok {
+	ret := _m.Called(channel)
-		return f(teamId, trigger)
+
+	var r0 *model.Channel
+	if rf, ok := ret.Get(0).(func(*model.Channel) *model.Channel); ok {
+		r0 = rf(channel)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Channel)
+		}
 	}
-	return ret.Error(0)
-}
 
-func (m *API) CreateUser(user *model.User) (*model.User, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(user)
+	if rf, ok := ret.Get(1).(func(*model.Channel) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(*model.User) (*model.User, *model.AppError)); ok {
+		r1 = rf(channel)
-		return f(user)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	userOut, _ := ret.Get(0).(*model.User)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return userOut, err
 }
 
-func (m *API) DeleteUser(userId string) *model.AppError {
+// CreatePost provides a mock function with given fields: post
-	ret := m.Called(userId)
+func (_m *APIMOCKINTERNAL) CreatePost(post *model.Post) (*model.Post, *model.AppError) {
-	if f, ok := ret.Get(0).(func(string) *model.AppError); ok {
+	ret := _m.Called(post)
-		return f(userId)
+
+	var r0 *model.Post
+	if rf, ok := ret.Get(0).(func(*model.Post) *model.Post); ok {
+		r0 = rf(post)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Post)
+		}
 	}
-	err, _ := ret.Get(0).(*model.AppError)
-	return err
-}
 
-func (m *API) GetUser(userId string) (*model.User, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(userId)
+	if rf, ok := ret.Get(1).(func(*model.Post) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(string) (*model.User, *model.AppError)); ok {
+		r1 = rf(post)
-		return f(userId)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	user, _ := ret.Get(0).(*model.User)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return user, err
 }
 
-func (m *API) GetUserByEmail(email string) (*model.User, *model.AppError) {
+// CreateTeam provides a mock function with given fields: team
-	ret := m.Called(email)
+func (_m *APIMOCKINTERNAL) CreateTeam(team *model.Team) (*model.Team, *model.AppError) {
-	if f, ok := ret.Get(0).(func(string) (*model.User, *model.AppError)); ok {
+	ret := _m.Called(team)
-		return f(email)
+
+	var r0 *model.Team
+	if rf, ok := ret.Get(0).(func(*model.Team) *model.Team); ok {
+		r0 = rf(team)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Team)
+		}
 	}
-	user, _ := ret.Get(0).(*model.User)
-	err, _ := ret.Get(1).(*model.AppError)
-	return user, err
-}
 
-func (m *API) GetUserByUsername(name string) (*model.User, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(name)
+	if rf, ok := ret.Get(1).(func(*model.Team) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(string) (*model.User, *model.AppError)); ok {
+		r1 = rf(team)
-		return f(name)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	user, _ := ret.Get(0).(*model.User)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return user, err
 }
 
-func (m *API) UpdateUser(user *model.User) (*model.User, *model.AppError) {
+// CreateUser provides a mock function with given fields: user
-	ret := m.Called(user)
+func (_m *APIMOCKINTERNAL) CreateUser(user *model.User) (*model.User, *model.AppError) {
-	if f, ok := ret.Get(0).(func(*model.User) (*model.User, *model.AppError)); ok {
+	ret := _m.Called(user)
-		return f(user)
+
+	var r0 *model.User
+	if rf, ok := ret.Get(0).(func(*model.User) *model.User); ok {
+		r0 = rf(user)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.User)
+		}
 	}
-	userOut, _ := ret.Get(0).(*model.User)
-	err, _ := ret.Get(1).(*model.AppError)
-	return userOut, err
-}
 
-func (m *API) CreateTeam(team *model.Team) (*model.Team, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(team)
+	if rf, ok := ret.Get(1).(func(*model.User) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(*model.Team) (*model.Team, *model.AppError)); ok {
+		r1 = rf(user)
-		return f(team)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	teamOut, _ := ret.Get(0).(*model.Team)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return teamOut, err
 }
 
-func (m *API) DeleteTeam(teamId string) *model.AppError {
+// DeleteChannel provides a mock function with given fields: channelId
-	ret := m.Called(teamId)
+func (_m *APIMOCKINTERNAL) DeleteChannel(channelId string) *model.AppError {
-	if f, ok := ret.Get(0).(func(string) *model.AppError); ok {
+	ret := _m.Called(channelId)
-		return f(teamId)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+		r0 = rf(channelId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
 	}
-	err, _ := ret.Get(0).(*model.AppError)
+
-	return err
+	return r0
 }
 
-func (m *API) GetTeam(teamId string) (*model.Team, *model.AppError) {
+// DeleteChannelMember provides a mock function with given fields: channelId, userId
-	ret := m.Called(teamId)
+func (_m *APIMOCKINTERNAL) DeleteChannelMember(channelId string, userId string) *model.AppError {
-	if f, ok := ret.Get(0).(func(string) (*model.Team, *model.AppError)); ok {
+	ret := _m.Called(channelId, userId)
-		return f(teamId)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string, string) *model.AppError); ok {
+		r0 = rf(channelId, userId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
 	}
-	team, _ := ret.Get(0).(*model.Team)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0
-	return team, err
 }
 
-func (m *API) GetTeamByName(name string) (*model.Team, *model.AppError) {
+// DeletePost provides a mock function with given fields: postId
-	ret := m.Called(name)
+func (_m *APIMOCKINTERNAL) DeletePost(postId string) *model.AppError {
-	if f, ok := ret.Get(0).(func(string) (*model.Team, *model.AppError)); ok {
+	ret := _m.Called(postId)
-		return f(name)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+		r0 = rf(postId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
 	}
-	team, _ := ret.Get(0).(*model.Team)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0
-	return team, err
 }
 
-func (m *API) UpdateTeam(team *model.Team) (*model.Team, *model.AppError) {
+// DeleteTeam provides a mock function with given fields: teamId
-	ret := m.Called(team)
+func (_m *APIMOCKINTERNAL) DeleteTeam(teamId string) *model.AppError {
-	if f, ok := ret.Get(0).(func(*model.Team) (*model.Team, *model.AppError)); ok {
+	ret := _m.Called(teamId)
-		return f(team)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+		r0 = rf(teamId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
 	}
-	teamOut, _ := ret.Get(0).(*model.Team)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0
-	return teamOut, err
 }
 
-func (m *API) CreateChannel(channel *model.Channel) (*model.Channel, *model.AppError) {
+// DeleteUser provides a mock function with given fields: userId
-	ret := m.Called(channel)
+func (_m *APIMOCKINTERNAL) DeleteUser(userId string) *model.AppError {
-	if f, ok := ret.Get(0).(func(*model.Channel) (*model.Channel, *model.AppError)); ok {
+	ret := _m.Called(userId)
-		return f(channel)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+		r0 = rf(userId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
 	}
-	channelOut, _ := ret.Get(0).(*model.Channel)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0
-	return channelOut, err
 }
 
-func (m *API) DeleteChannel(channelId string) *model.AppError {
+// GetChannel provides a mock function with given fields: channelId
-	ret := m.Called(channelId)
+func (_m *APIMOCKINTERNAL) GetChannel(channelId string) (*model.Channel, *model.AppError) {
-	if f, ok := ret.Get(0).(func(string) *model.AppError); ok {
+	ret := _m.Called(channelId)
-		return f(channelId)
+
+	var r0 *model.Channel
+	if rf, ok := ret.Get(0).(func(string) *model.Channel); ok {
+		r0 = rf(channelId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Channel)
+		}
 	}
-	err, _ := ret.Get(0).(*model.AppError)
-	return err
-}
 
-func (m *API) GetChannel(channelId string) (*model.Channel, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(channelId)
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(string) (*model.Channel, *model.AppError)); ok {
+		r1 = rf(channelId)
-		return f(channelId)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	channel, _ := ret.Get(0).(*model.Channel)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return channel, err
 }
 
-func (m *API) GetChannelByName(name, teamId string) (*model.Channel, *model.AppError) {
+// GetChannelByName provides a mock function with given fields: name, teamId
-	ret := m.Called(name, teamId)
+func (_m *APIMOCKINTERNAL) GetChannelByName(name string, teamId string) (*model.Channel, *model.AppError) {
-	if f, ok := ret.Get(0).(func(_, _ string) (*model.Channel, *model.AppError)); ok {
+	ret := _m.Called(name, teamId)
-		return f(name, teamId)
+
+	var r0 *model.Channel
+	if rf, ok := ret.Get(0).(func(string, string) *model.Channel); ok {
+		r0 = rf(name, teamId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Channel)
+		}
 	}
-	channel, _ := ret.Get(0).(*model.Channel)
-	err, _ := ret.Get(1).(*model.AppError)
-	return channel, err
-}
 
-func (m *API) GetDirectChannel(userId1, userId2 string) (*model.Channel, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(userId1, userId2)
+	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(_, _ string) (*model.Channel, *model.AppError)); ok {
+		r1 = rf(name, teamId)
-		return f(userId1, userId2)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	channel, _ := ret.Get(0).(*model.Channel)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return channel, err
 }
 
-func (m *API) GetGroupChannel(userIds []string) (*model.Channel, *model.AppError) {
+// GetChannelMember provides a mock function with given fields: channelId, userId
-	ret := m.Called(userIds)
+func (_m *APIMOCKINTERNAL) GetChannelMember(channelId string, userId string) (*model.ChannelMember, *model.AppError) {
-	if f, ok := ret.Get(0).(func([]string) (*model.Channel, *model.AppError)); ok {
+	ret := _m.Called(channelId, userId)
-		return f(userIds)
+
+	var r0 *model.ChannelMember
+	if rf, ok := ret.Get(0).(func(string, string) *model.ChannelMember); ok {
+		r0 = rf(channelId, userId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelMember)
+		}
 	}
-	channel, _ := ret.Get(0).(*model.Channel)
-	err, _ := ret.Get(1).(*model.AppError)
-	return channel, err
-}
 
-func (m *API) UpdateChannel(channel *model.Channel) (*model.Channel, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(channel)
+	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(*model.Channel) (*model.Channel, *model.AppError)); ok {
+		r1 = rf(channelId, userId)
-		return f(channel)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	channelOut, _ := ret.Get(0).(*model.Channel)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return channelOut, err
 }
 
-func (m *API) AddChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) {
+// GetDirectChannel provides a mock function with given fields: userId1, userId2
-	ret := m.Called(channelId, userId)
+func (_m *APIMOCKINTERNAL) GetDirectChannel(userId1 string, userId2 string) (*model.Channel, *model.AppError) {
-	if f, ok := ret.Get(0).(func(_, _ string) (*model.ChannelMember, *model.AppError)); ok {
+	ret := _m.Called(userId1, userId2)
-		return f(channelId, userId)
+
+	var r0 *model.Channel
+	if rf, ok := ret.Get(0).(func(string, string) *model.Channel); ok {
+		r0 = rf(userId1, userId2)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Channel)
+		}
 	}
-	member, _ := ret.Get(0).(*model.ChannelMember)
-	err, _ := ret.Get(1).(*model.AppError)
-	return member, err
-}
 
-func (m *API) GetChannelMember(channelId, userId string) (*model.ChannelMember, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(channelId, userId)
+	if rf, ok := ret.Get(1).(func(string, string) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(_, _ string) (*model.ChannelMember, *model.AppError)); ok {
+		r1 = rf(userId1, userId2)
-		return f(channelId, userId)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	member, _ := ret.Get(0).(*model.ChannelMember)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return member, err
 }
 
-func (m *API) UpdateChannelMemberRoles(channelId, userId, newRoles string) (*model.ChannelMember, *model.AppError) {
+// GetGroupChannel provides a mock function with given fields: userIds
-	ret := m.Called(channelId, userId, newRoles)
+func (_m *APIMOCKINTERNAL) GetGroupChannel(userIds []string) (*model.Channel, *model.AppError) {
-	if f, ok := ret.Get(0).(func(_, _, _ string) (*model.ChannelMember, *model.AppError)); ok {
+	ret := _m.Called(userIds)
-		return f(channelId, userId, newRoles)
+
+	var r0 *model.Channel
+	if rf, ok := ret.Get(0).(func([]string) *model.Channel); ok {
+		r0 = rf(userIds)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Channel)
+		}
 	}
-	member, _ := ret.Get(0).(*model.ChannelMember)
-	err, _ := ret.Get(1).(*model.AppError)
-	return member, err
-}
 
-func (m *API) UpdateChannelMemberNotifications(channelId, userId string, notifications map[string]string) (*model.ChannelMember, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(channelId, userId, notifications)
+	if rf, ok := ret.Get(1).(func([]string) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(_, _ string, _ map[string]string) (*model.ChannelMember, *model.AppError)); ok {
+		r1 = rf(userIds)
-		return f(channelId, userId, notifications)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	member, _ := ret.Get(0).(*model.ChannelMember)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return member, err
 }
 
-func (m *API) DeleteChannelMember(channelId, userId string) *model.AppError {
+// GetPost provides a mock function with given fields: postId
-	ret := m.Called(channelId, userId)
+func (_m *APIMOCKINTERNAL) GetPost(postId string) (*model.Post, *model.AppError) {
-	if f, ok := ret.Get(0).(func(_, _ string) *model.AppError); ok {
+	ret := _m.Called(postId)
-		return f(channelId, userId)
+
+	var r0 *model.Post
+	if rf, ok := ret.Get(0).(func(string) *model.Post); ok {
+		r0 = rf(postId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Post)
+		}
 	}
-	err, _ := ret.Get(0).(*model.AppError)
-	return err
-}
 
-func (m *API) CreatePost(post *model.Post) (*model.Post, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(post)
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(*model.Post) (*model.Post, *model.AppError)); ok {
+		r1 = rf(postId)
-		return f(post)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	postOut, _ := ret.Get(0).(*model.Post)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return postOut, err
 }
 
-func (m *API) DeletePost(postId string) *model.AppError {
+// GetTeam provides a mock function with given fields: teamId
-	ret := m.Called(postId)
+func (_m *APIMOCKINTERNAL) GetTeam(teamId string) (*model.Team, *model.AppError) {
-	if f, ok := ret.Get(0).(func(string) *model.AppError); ok {
+	ret := _m.Called(teamId)
-		return f(postId)
+
+	var r0 *model.Team
+	if rf, ok := ret.Get(0).(func(string) *model.Team); ok {
+		r0 = rf(teamId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Team)
+		}
 	}
-	err, _ := ret.Get(0).(*model.AppError)
-	return err
-}
 
-func (m *API) GetPost(postId string) (*model.Post, *model.AppError) {
+	var r1 *model.AppError
-	ret := m.Called(postId)
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
-	if f, ok := ret.Get(0).(func(string) (*model.Post, *model.AppError)); ok {
+		r1 = rf(teamId)
-		return f(postId)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
 	}
-	post, _ := ret.Get(0).(*model.Post)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return post, err
 }
 
-func (m *API) UpdatePost(post *model.Post) (*model.Post, *model.AppError) {
+// GetTeamByName provides a mock function with given fields: name
-	ret := m.Called(post)
+func (_m *APIMOCKINTERNAL) GetTeamByName(name string) (*model.Team, *model.AppError) {
-	if f, ok := ret.Get(0).(func(*model.Post) (*model.Post, *model.AppError)); ok {
+	ret := _m.Called(name)
-		return f(post)
+
+	var r0 *model.Team
+	if rf, ok := ret.Get(0).(func(string) *model.Team); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Team)
+		}
 	}
-	postOut, _ := ret.Get(0).(*model.Post)
-	err, _ := ret.Get(1).(*model.AppError)
-	return postOut, err
-}
 
-func (m *API) KeyValueStore() plugin.KeyValueStore {
+	var r1 *model.AppError
-	return m.Store
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
-}
+		r1 = rf(name)
-
+	} else {
-func (m *KeyValueStore) Set(key string, value []byte) *model.AppError {
+		if ret.Get(1) != nil {
-	ret := m.Called(key, value)
+			r1 = ret.Get(1).(*model.AppError)
-	if f, ok := ret.Get(0).(func(string, []byte) *model.AppError); ok {
+		}
-		return f(key, value)
 	}
-	err, _ := ret.Get(0).(*model.AppError)
+
-	return err
+	return r0, r1
 }
 
-func (m *KeyValueStore) Get(key string) ([]byte, *model.AppError) {
+// GetUser provides a mock function with given fields: userId
-	ret := m.Called(key)
+func (_m *APIMOCKINTERNAL) GetUser(userId string) (*model.User, *model.AppError) {
-	if f, ok := ret.Get(0).(func(string) ([]byte, *model.AppError)); ok {
+	ret := _m.Called(userId)
-		return f(key)
+
+	var r0 *model.User
+	if rf, ok := ret.Get(0).(func(string) *model.User); ok {
+		r0 = rf(userId)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.User)
+		}
 	}
-	psv, _ := ret.Get(0).([]byte)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	var r1 *model.AppError
-	return psv, err
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(userId)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }
 
-func (m *KeyValueStore) Delete(key string) *model.AppError {
+// GetUserByEmail provides a mock function with given fields: email
-	ret := m.Called(key)
+func (_m *APIMOCKINTERNAL) GetUserByEmail(email string) (*model.User, *model.AppError) {
-	if f, ok := ret.Get(0).(func(string) *model.AppError); ok {
+	ret := _m.Called(email)
-		return f(key)
+
+	var r0 *model.User
+	if rf, ok := ret.Get(0).(func(string) *model.User); ok {
+		r0 = rf(email)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.User)
+		}
 	}
-	err, _ := ret.Get(0).(*model.AppError)
+
-	return err
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(email)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
+// GetUserByUsername provides a mock function with given fields: name
+func (_m *APIMOCKINTERNAL) GetUserByUsername(name string) (*model.User, *model.AppError) {
+	ret := _m.Called(name)
+
+	var r0 *model.User
+	if rf, ok := ret.Get(0).(func(string) *model.User); ok {
+		r0 = rf(name)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.User)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(name)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
+// KeyValueStore provides a mock function with given fields:
+func (_m *APIMOCKINTERNAL) KeyValueStore() plugin.KeyValueStore {
+	ret := _m.Called()
+
+	var r0 plugin.KeyValueStore
+	if rf, ok := ret.Get(0).(func() plugin.KeyValueStore); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(plugin.KeyValueStore)
+		}
+	}
+
+	return r0
+}
+
+// LoadPluginConfiguration provides a mock function with given fields: dest
+func (_m *APIMOCKINTERNAL) LoadPluginConfiguration(dest interface{}) error {
+	ret := _m.Called(dest)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(interface{}) error); ok {
+		r0 = rf(dest)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// RegisterCommand provides a mock function with given fields: command
+func (_m *APIMOCKINTERNAL) RegisterCommand(command *model.Command) error {
+	ret := _m.Called(command)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(*model.Command) error); ok {
+		r0 = rf(command)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UnregisterCommand provides a mock function with given fields: teamId, trigger
+func (_m *APIMOCKINTERNAL) UnregisterCommand(teamId string, trigger string) error {
+	ret := _m.Called(teamId, trigger)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(string, string) error); ok {
+		r0 = rf(teamId, trigger)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// UpdateChannel provides a mock function with given fields: channel
+func (_m *APIMOCKINTERNAL) UpdateChannel(channel *model.Channel) (*model.Channel, *model.AppError) {
+	ret := _m.Called(channel)
+
+	var r0 *model.Channel
+	if rf, ok := ret.Get(0).(func(*model.Channel) *model.Channel); ok {
+		r0 = rf(channel)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Channel)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.Channel) *model.AppError); ok {
+		r1 = rf(channel)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
+// UpdateChannelMemberNotifications provides a mock function with given fields: channelId, userId, notifications
+func (_m *APIMOCKINTERNAL) UpdateChannelMemberNotifications(channelId string, userId string, notifications map[string]string) (*model.ChannelMember, *model.AppError) {
+	ret := _m.Called(channelId, userId, notifications)
+
+	var r0 *model.ChannelMember
+	if rf, ok := ret.Get(0).(func(string, string, map[string]string) *model.ChannelMember); ok {
+		r0 = rf(channelId, userId, notifications)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelMember)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string, string, map[string]string) *model.AppError); ok {
+		r1 = rf(channelId, userId, notifications)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
+// UpdateChannelMemberRoles provides a mock function with given fields: channelId, userId, newRoles
+func (_m *APIMOCKINTERNAL) UpdateChannelMemberRoles(channelId string, userId string, newRoles string) (*model.ChannelMember, *model.AppError) {
+	ret := _m.Called(channelId, userId, newRoles)
+
+	var r0 *model.ChannelMember
+	if rf, ok := ret.Get(0).(func(string, string, string) *model.ChannelMember); ok {
+		r0 = rf(channelId, userId, newRoles)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.ChannelMember)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string, string, string) *model.AppError); ok {
+		r1 = rf(channelId, userId, newRoles)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
+// UpdatePost provides a mock function with given fields: post
+func (_m *APIMOCKINTERNAL) UpdatePost(post *model.Post) (*model.Post, *model.AppError) {
+	ret := _m.Called(post)
+
+	var r0 *model.Post
+	if rf, ok := ret.Get(0).(func(*model.Post) *model.Post); ok {
+		r0 = rf(post)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Post)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.Post) *model.AppError); ok {
+		r1 = rf(post)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
+// UpdateTeam provides a mock function with given fields: team
+func (_m *APIMOCKINTERNAL) UpdateTeam(team *model.Team) (*model.Team, *model.AppError) {
+	ret := _m.Called(team)
+
+	var r0 *model.Team
+	if rf, ok := ret.Get(0).(func(*model.Team) *model.Team); ok {
+		r0 = rf(team)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Team)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.Team) *model.AppError); ok {
+		r1 = rf(team)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
+// UpdateUser provides a mock function with given fields: user
+func (_m *APIMOCKINTERNAL) UpdateUser(user *model.User) (*model.User, *model.AppError) {
+	ret := _m.Called(user)
+
+	var r0 *model.User
+	if rf, ok := ret.Get(0).(func(*model.User) *model.User); ok {
+		r0 = rf(user)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.User)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(*model.User) *model.AppError); ok {
+		r1 = rf(user)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
 }

plugin/plugintest/apioverride.go

@@ -0,0 +1,18 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package plugintest
+
+import "github.com/mattermost/mattermost-server/plugin"
+
+type API struct {
+	APIMOCKINTERNAL
+	Store *KeyValueStore
+}
+
+var _ plugin.API = (*API)(nil)
+var _ plugin.KeyValueStore = (*KeyValueStore)(nil)
+
+func (m *API) KeyValueStore() plugin.KeyValueStore {
+	return m.Store
+}

plugin/plugintest/hooks.go

@@ -1,49 +1,143 @@
-// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// Code generated by mockery v1.0.0. DO NOT EDIT.
-// See License.txt for license information.
+
+// Regenerate this file using `make plugin-mocks`.
 
 package plugintest
 
-import (
+import http "net/http"
-	"net/http"
+import mock "github.com/stretchr/testify/mock"
-
+import model "github.com/mattermost/mattermost-server/model"
-	"github.com/stretchr/testify/mock"
+import plugin "github.com/mattermost/mattermost-server/plugin"
-
-	"github.com/mattermost/mattermost-server/model"
-	"github.com/mattermost/mattermost-server/plugin"
-)
 
+// Hooks is an autogenerated mock type for the Hooks type
 type Hooks struct {
 	mock.Mock
 }
 
-var _ plugin.Hooks = (*Hooks)(nil)
+// ExecuteCommand provides a mock function with given fields: args
+func (_m *Hooks) ExecuteCommand(args *model.CommandArgs) (*model.CommandResponse, *model.AppError) {
+	ret := _m.Called(args)
 
-func (m *Hooks) OnActivate(api plugin.API) error {
+	var r0 *model.CommandResponse
-	ret := m.Called(api)
+	if rf, ok := ret.Get(0).(func(*model.CommandArgs) *model.CommandResponse); ok {
-	if f, ok := ret.Get(0).(func(plugin.API) error); ok {
+		r0 = rf(args)
-		return f(api)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.CommandResponse)
+		}
 	}
-	return ret.Error(0)
-}
 
-func (m *Hooks) OnDeactivate() error {
+	var r1 *model.AppError
-	return m.Called().Error(0)
+	if rf, ok := ret.Get(1).(func(*model.CommandArgs) *model.AppError); ok {
-}
+		r1 = rf(args)
-
+	} else {
-func (m *Hooks) OnConfigurationChange() error {
+		if ret.Get(1) != nil {
-	return m.Called().Error(0)
+			r1 = ret.Get(1).(*model.AppError)
-}
+		}
-
-func (m *Hooks) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	m.Called(w, r)
-}
-
-func (m *Hooks) ExecuteCommand(args *model.CommandArgs) (*model.CommandResponse, *model.AppError) {
-	ret := m.Called(args)
-	if f, ok := ret.Get(0).(func(*model.CommandArgs) (*model.CommandResponse, *model.AppError)); ok {
-		return f(args)
 	}
-	resp, _ := ret.Get(0).(*model.CommandResponse)
+
-	err, _ := ret.Get(1).(*model.AppError)
+	return r0, r1
-	return resp, err
+}
+
+// MessageHasBeenPosted provides a mock function with given fields: post
+func (_m *Hooks) MessageHasBeenPosted(post *model.Post) {
+	_m.Called(post)
+}
+
+// MessageHasBeenUpdated provides a mock function with given fields: newPost, oldPost
+func (_m *Hooks) MessageHasBeenUpdated(newPost *model.Post, oldPost *model.Post) {
+	_m.Called(newPost, oldPost)
+}
+
+// MessageWillBePosted provides a mock function with given fields: post
+func (_m *Hooks) MessageWillBePosted(post *model.Post) (*model.Post, string) {
+	ret := _m.Called(post)
+
+	var r0 *model.Post
+	if rf, ok := ret.Get(0).(func(*model.Post) *model.Post); ok {
+		r0 = rf(post)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Post)
+		}
+	}
+
+	var r1 string
+	if rf, ok := ret.Get(1).(func(*model.Post) string); ok {
+		r1 = rf(post)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// MessageWillBeUpdated provides a mock function with given fields: newPost, oldPost
+func (_m *Hooks) MessageWillBeUpdated(newPost *model.Post, oldPost *model.Post) (*model.Post, string) {
+	ret := _m.Called(newPost, oldPost)
+
+	var r0 *model.Post
+	if rf, ok := ret.Get(0).(func(*model.Post, *model.Post) *model.Post); ok {
+		r0 = rf(newPost, oldPost)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.Post)
+		}
+	}
+
+	var r1 string
+	if rf, ok := ret.Get(1).(func(*model.Post, *model.Post) string); ok {
+		r1 = rf(newPost, oldPost)
+	} else {
+		r1 = ret.Get(1).(string)
+	}
+
+	return r0, r1
+}
+
+// OnActivate provides a mock function with given fields: _a0
+func (_m *Hooks) OnActivate(_a0 plugin.API) error {
+	ret := _m.Called(_a0)
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func(plugin.API) error); ok {
+		r0 = rf(_a0)
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// OnConfigurationChange provides a mock function with given fields:
+func (_m *Hooks) OnConfigurationChange() error {
+	ret := _m.Called()
+
+	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 given fields:
+func (_m *Hooks) OnDeactivate() error {
+	ret := _m.Called()
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// ServeHTTP provides a mock function with given fields: _a0, _a1
+func (_m *Hooks) ServeHTTP(_a0 http.ResponseWriter, _a1 *http.Request) {
+	_m.Called(_a0, _a1)
 }

plugin/plugintest/key_value_store.go

@@ -0,0 +1,70 @@
+// Code generated by mockery v1.0.0. DO NOT EDIT.
+
+// Regenerate this file using `make plugin-mocks`.
+
+package plugintest
+
+import mock "github.com/stretchr/testify/mock"
+import model "github.com/mattermost/mattermost-server/model"
+
+// KeyValueStore is an autogenerated mock type for the KeyValueStore type
+type KeyValueStore struct {
+	mock.Mock
+}
+
+// Delete provides a mock function with given fields: key
+func (_m *KeyValueStore) Delete(key string) *model.AppError {
+	ret := _m.Called(key)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string) *model.AppError); ok {
+		r0 = rf(key)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
+	}
+
+	return r0
+}
+
+// Get provides a mock function with given fields: key
+func (_m *KeyValueStore) Get(key string) ([]byte, *model.AppError) {
+	ret := _m.Called(key)
+
+	var r0 []byte
+	if rf, ok := ret.Get(0).(func(string) []byte); ok {
+		r0 = rf(key)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]byte)
+		}
+	}
+
+	var r1 *model.AppError
+	if rf, ok := ret.Get(1).(func(string) *model.AppError); ok {
+		r1 = rf(key)
+	} else {
+		if ret.Get(1) != nil {
+			r1 = ret.Get(1).(*model.AppError)
+		}
+	}
+
+	return r0, r1
+}
+
+// Set provides a mock function with given fields: key, value
+func (_m *KeyValueStore) Set(key string, value []byte) *model.AppError {
+	ret := _m.Called(key, value)
+
+	var r0 *model.AppError
+	if rf, ok := ret.Get(0).(func(string, []byte) *model.AppError); ok {
+		r0 = rf(key, value)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*model.AppError)
+		}
+	}
+
+	return r0
+}

plugin/rpcplugin/api_test.go

@@ -90,10 +90,10 @@ func TestAPI(t *testing.T) {
 		api.On("UnregisterCommand", "team", "trigger").Return(nil).Once()
 		assert.NoError(t, remote.UnregisterCommand("team", "trigger"))
 
-		api.On("CreateChannel", mock.AnythingOfType("*model.Channel")).Return(func(c *model.Channel) (*model.Channel, *model.AppError) {
+		api.On("CreateChannel", mock.AnythingOfType("*model.Channel")).Return(func(c *model.Channel) *model.Channel {
 			c.Id = "thechannelid"
-			return c, nil
+			return c
-		}).Once()
+		}, nil).Once()
 		channel, err := remote.CreateChannel(testChannel)
 		assert.Equal(t, "thechannelid", channel.Id)
 		assert.Nil(t, err)
@@ -121,9 +121,9 @@ func TestAPI(t *testing.T) {
 		assert.Equal(t, testChannel, channel)
 		assert.Nil(t, err)
 
-		api.On("UpdateChannel", mock.AnythingOfType("*model.Channel")).Return(func(c *model.Channel) (*model.Channel, *model.AppError) {
+		api.On("UpdateChannel", mock.AnythingOfType("*model.Channel")).Return(func(c *model.Channel) *model.Channel {
-			return c, nil
+			return c
-		}).Once()
+		}, nil).Once()
 		channel, err = remote.UpdateChannel(testChannel)
 		assert.Equal(t, testChannel, channel)
 		assert.Nil(t, err)
@@ -154,10 +154,10 @@ func TestAPI(t *testing.T) {
 		err = remote.DeleteChannelMember("thechannelid", "theuserid")
 		assert.Nil(t, err)
 
-		api.On("CreateUser", mock.AnythingOfType("*model.User")).Return(func(u *model.User) (*model.User, *model.AppError) {
+		api.On("CreateUser", mock.AnythingOfType("*model.User")).Return(func(u *model.User) *model.User {
 			u.Id = "theuserid"
-			return u, nil
+			return u
-		}).Once()
+		}, nil).Once()
 		user, err := remote.CreateUser(testUser)
 		assert.Equal(t, "theuserid", user.Id)
 		assert.Nil(t, err)
@@ -180,17 +180,17 @@ func TestAPI(t *testing.T) {
 		assert.Equal(t, testUser, user)
 		assert.Nil(t, err)
 
-		api.On("UpdateUser", mock.AnythingOfType("*model.User")).Return(func(u *model.User) (*model.User, *model.AppError) {
+		api.On("UpdateUser", mock.AnythingOfType("*model.User")).Return(func(u *model.User) *model.User {
-			return u, nil
+			return u
-		}).Once()
+		}, nil).Once()
 		user, err = remote.UpdateUser(testUser)
 		assert.Equal(t, testUser, user)
 		assert.Nil(t, err)
 
-		api.On("CreateTeam", mock.AnythingOfType("*model.Team")).Return(func(t *model.Team) (*model.Team, *model.AppError) {
+		api.On("CreateTeam", mock.AnythingOfType("*model.Team")).Return(func(t *model.Team) *model.Team {
 			t.Id = "theteamid"
-			return t, nil
+			return t
-		}).Once()
+		}, nil).Once()
 		team, err := remote.CreateTeam(testTeam)
 		assert.Equal(t, "theteamid", team.Id)
 		assert.Nil(t, err)
@@ -213,17 +213,17 @@ func TestAPI(t *testing.T) {
 		assert.Nil(t, team)
 		assert.Equal(t, teamNotFoundError, err)
 
-		api.On("UpdateTeam", mock.AnythingOfType("*model.Team")).Return(func(t *model.Team) (*model.Team, *model.AppError) {
+		api.On("UpdateTeam", mock.AnythingOfType("*model.Team")).Return(func(t *model.Team) *model.Team {
-			return t, nil
+			return t
-		}).Once()
+		}, nil).Once()
 		team, err = remote.UpdateTeam(testTeam)
 		assert.Equal(t, testTeam, team)
 		assert.Nil(t, err)
 
-		api.On("CreatePost", mock.AnythingOfType("*model.Post")).Return(func(p *model.Post) (*model.Post, *model.AppError) {
+		api.On("CreatePost", mock.AnythingOfType("*model.Post")).Return(func(p *model.Post) *model.Post {
 			p.Id = "thepostid"
-			return p, nil
+			return p
-		}).Once()
+		}, nil).Once()
 		post, err := remote.CreatePost(testPost)
 		require.Nil(t, err)
 		assert.NotEmpty(t, post.Id)
@@ -237,9 +237,9 @@ func TestAPI(t *testing.T) {
 		assert.Equal(t, testPost, post)
 		assert.Nil(t, err)
 
-		api.On("UpdatePost", mock.AnythingOfType("*model.Post")).Return(func(p *model.Post) (*model.Post, *model.AppError) {
+		api.On("UpdatePost", mock.AnythingOfType("*model.Post")).Return(func(p *model.Post) *model.Post {
-			return p, nil
+			return p
-		}).Once()
+		}, nil).Once()
 		post, err = remote.UpdatePost(testPost)
 		assert.Equal(t, testPost, post)
 		assert.Nil(t, err)
@@ -248,9 +248,9 @@ func TestAPI(t *testing.T) {
 		err = remote.KeyValueStore().Set("thekey", []byte("thevalue"))
 		assert.Nil(t, err)
 
-		api.KeyValueStore().(*plugintest.KeyValueStore).On("Get", "thekey").Return(func(key string) ([]byte, *model.AppError) {
+		api.KeyValueStore().(*plugintest.KeyValueStore).On("Get", "thekey").Return(func(key string) []byte {
-			return []byte("thevalue"), nil
+			return []byte("thevalue")
-		}).Once()
+		}, nil).Once()
 		ret, err := remote.KeyValueStore().Get("thekey")
 		assert.Nil(t, err)
 		assert.Equal(t, []byte("thevalue"), ret)
@@ -267,10 +267,10 @@ func TestAPI_GobRegistration(t *testing.T) {
 	defer api.AssertExpectations(t)
 
 	testAPIRPC(&api, func(remote plugin.API) {
-		api.On("CreatePost", mock.AnythingOfType("*model.Post")).Return(func(p *model.Post) (*model.Post, *model.AppError) {
+		api.On("CreatePost", mock.AnythingOfType("*model.Post")).Return(func(p *model.Post) *model.Post {
 			p.Id = "thepostid"
-			return p, nil
+			return p
-		}).Once()
+		}, nil).Once()
 		_, err := remote.CreatePost(&model.Post{
 			Message: "hello",
 			Props: map[string]interface{}{

plugin/rpcplugin/hooks.go

@@ -141,6 +141,52 @@ func (h *LocalHooks) ExecuteCommand(args *model.CommandArgs, reply *HooksExecute
 	return nil
 }
 
+type MessageWillBeReply struct {
+	Post            *model.Post
+	RejectionReason string
+}
+
+type MessageUpdatedArgs struct {
+	NewPost *model.Post
+	OldPost *model.Post
+}
+
+func (h *LocalHooks) MessageWillBePosted(args *model.Post, reply *MessageWillBeReply) error {
+	if hook, ok := h.hooks.(interface {
+		MessageWillBePosted(*model.Post) (*model.Post, string)
+	}); ok {
+		reply.Post, reply.RejectionReason = hook.MessageWillBePosted(args)
+	}
+	return nil
+}
+
+func (h *LocalHooks) MessageWillBeUpdated(args *MessageUpdatedArgs, reply *MessageWillBeReply) error {
+	if hook, ok := h.hooks.(interface {
+		MessageWillBeUpdated(*model.Post, *model.Post) (*model.Post, string)
+	}); ok {
+		reply.Post, reply.RejectionReason = hook.MessageWillBeUpdated(args.NewPost, args.OldPost)
+	}
+	return nil
+}
+
+func (h *LocalHooks) MessageHasBeenPosted(args *model.Post, reply *struct{}) error {
+	if hook, ok := h.hooks.(interface {
+		MessageHasBeenPosted(*model.Post)
+	}); ok {
+		hook.MessageHasBeenPosted(args)
+	}
+	return nil
+}
+
+func (h *LocalHooks) MessageHasBeenUpdated(args *MessageUpdatedArgs, reply *struct{}) error {
+	if hook, ok := h.hooks.(interface {
+		MessageHasBeenUpdated(*model.Post, *model.Post)
+	}); ok {
+		hook.MessageHasBeenUpdated(args.NewPost, args.OldPost)
+	}
+	return nil
+}
+
 func ServeHooks(hooks interface{}, conn io.ReadWriteCloser, muxer *Muxer) {
 	server := rpc.NewServer()
 	server.Register(&LocalHooks{
@@ -158,6 +204,10 @@ const (
 	remoteServeHTTP             = 2
 	remoteOnConfigurationChange = 3
 	remoteExecuteCommand        = 4
+	remoteMessageWillBePosted   = 5
+	remoteMessageWillBeUpdated  = 6
+	remoteMessageHasBeenPosted  = 7
+	remoteMessageHasBeenUpdated = 8
 	maxRemoteHookCount          = iota
 )
 
@@ -255,6 +305,54 @@ func (h *RemoteHooks) ExecuteCommand(args *model.CommandArgs) (*model.CommandRes
 	return reply.Response, reply.Error
 }
 
+func (h *RemoteHooks) MessageWillBePosted(args *model.Post) (*model.Post, string) {
+	if !h.implemented[remoteMessageWillBePosted] {
+		return args, ""
+	}
+	var reply MessageWillBeReply
+	if err := h.client.Call("LocalHooks.MessageWillBePosted", args, &reply); err != nil {
+		return nil, ""
+	}
+	return reply.Post, reply.RejectionReason
+}
+
+func (h *RemoteHooks) MessageWillBeUpdated(newPost, oldPost *model.Post) (*model.Post, string) {
+	if !h.implemented[remoteMessageWillBeUpdated] {
+		return newPost, ""
+	}
+	var reply MessageWillBeReply
+	args := &MessageUpdatedArgs{
+		NewPost: newPost,
+		OldPost: oldPost,
+	}
+	if err := h.client.Call("LocalHooks.MessageWillBeUpdated", args, &reply); err != nil {
+		return nil, ""
+	}
+	return reply.Post, reply.RejectionReason
+}
+
+func (h *RemoteHooks) MessageHasBeenPosted(args *model.Post) {
+	if !h.implemented[remoteMessageHasBeenPosted] {
+		return
+	}
+	if err := h.client.Call("LocalHooks.MessageHasBeenPosted", args, nil); err != nil {
+		return
+	}
+}
+
+func (h *RemoteHooks) MessageHasBeenUpdated(newPost, oldPost *model.Post) {
+	if !h.implemented[remoteMessageHasBeenUpdated] {
+		return
+	}
+	args := &MessageUpdatedArgs{
+		NewPost: newPost,
+		OldPost: oldPost,
+	}
+	if err := h.client.Call("LocalHooks.MessageHasBeenUpdated", args, nil); err != nil {
+		return
+	}
+}
+
 func (h *RemoteHooks) Close() error {
 	if h.apiCloser != nil {
 		h.apiCloser.Close()
@@ -286,6 +384,14 @@ func ConnectHooks(conn io.ReadWriteCloser, muxer *Muxer, pluginId string) (*Remo
 			remote.implemented[remoteServeHTTP] = true
 		case "ExecuteCommand":
 			remote.implemented[remoteExecuteCommand] = true
+		case "MessageWillBePosted":
+			remote.implemented[remoteMessageWillBePosted] = true
+		case "MessageWillBeUpdated":
+			remote.implemented[remoteMessageWillBeUpdated] = true
+		case "MessageHasBeenPosted":
+			remote.implemented[remoteMessageHasBeenPosted] = true
+		case "MessageHasBeenUpdated":
+			remote.implemented[remoteMessageHasBeenUpdated] = true
 		}
 	}
 	return remote, nil

plugin/rpcplugin/hooks_test.go

@@ -91,6 +91,30 @@ func TestHooks(t *testing.T) {
 		})
 		assert.Equal(t, "bar", commandResponse.Text)
 		assert.Nil(t, appErr)
+
+		hooks.On("MessageWillBePosted", mock.AnythingOfType("*model.Post")).Return(func(post *model.Post) *model.Post {
+			post.Message += "_testing"
+			return post
+		}, "changemessage")
+		post, changemessage := remote.MessageWillBePosted(&model.Post{Id: "1", Message: "base"})
+		assert.Equal(t, "changemessage", changemessage)
+		assert.Equal(t, "base_testing", post.Message)
+		assert.Equal(t, "1", post.Id)
+
+		hooks.On("MessageWillBeUpdated", mock.AnythingOfType("*model.Post"), mock.AnythingOfType("*model.Post")).Return(func(newPost, oldPost *model.Post) *model.Post {
+			newPost.Message += "_testing"
+			return newPost
+		}, "changemessage2")
+		post2, changemessage2 := remote.MessageWillBeUpdated(&model.Post{Id: "2", Message: "base2"}, &model.Post{Id: "OLD", Message: "OLDMESSAGE"})
+		assert.Equal(t, "changemessage2", changemessage2)
+		assert.Equal(t, "base2_testing", post2.Message)
+		assert.Equal(t, "2", post2.Id)
+
+		hooks.On("MessageHasBeenPosted", mock.AnythingOfType("*model.Post")).Return(nil)
+		remote.MessageHasBeenPosted(&model.Post{})
+
+		hooks.On("MessageHasBeenUpdated", mock.AnythingOfType("*model.Post"), mock.AnythingOfType("*model.Post")).Return(nil)
+		remote.MessageHasBeenUpdated(&model.Post{}, &model.Post{})
 	}))
 }
 

scripts/license-check.sh

@@ -5,7 +5,7 @@ count=0
 for fileType in GoFiles; do
     for file in `go list -f $'{{range .GoFiles}}{{$.Dir}}/{{.}}\n{{end}}' "$@"`; do
         case $file in
-            */utils/lru.go|*/store/storetest/mocks/*|*/app/plugin/jira/plugin_*|*/app/plugin/zoom/plugin_*)
+            */utils/lru.go|*/store/storetest/mocks/*|*/app/plugin/jira/plugin_*|*/plugin/plugintest/*|*/app/plugin/zoom/plugin_*)
             # Third-party, doesn't require a header.
             ;;
         *)