management-refactor/internal/modules/team/manager_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ./manager.go

// Package team is a generated GoMock package.
package team

import (
	context "context"
	db "management/internal/shared/db"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockManager is a mock of Manager interface.
type MockManager struct {
	ctrl     *gomock.Controller
	recorder *MockManagerMockRecorder
}

// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
	mock *MockManager
}

// NewMockManager creates a new mock instance.
func NewMockManager(ctrl *gomock.Controller) *MockManager {
	mock := &MockManager{ctrl: ctrl}
	mock.recorder = &MockManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockManager) EXPECT() *MockManagerMockRecorder {
	return m.recorder
}

// CreateGroup mocks base method.
func (m *MockManager) CreateGroup(ctx context.Context, tx db.Transaction, group *Group) (*Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGroup", ctx, tx, group)
	ret0, _ := ret[0].(*Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGroup indicates an expected call of CreateGroup.
func (mr *MockManagerMockRecorder) CreateGroup(ctx, tx, group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroup", reflect.TypeOf((*MockManager)(nil).CreateGroup), ctx, tx, group)
}

// CreatePAT mocks base method.
func (m *MockManager) CreatePAT(ctx context.Context, tx db.Transaction, group *PersonalAccessToken) (*PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePAT", ctx, tx, group)
	ret0, _ := ret[0].(*PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePAT indicates an expected call of CreatePAT.
func (mr *MockManagerMockRecorder) CreatePAT(ctx, tx, group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePAT", reflect.TypeOf((*MockManager)(nil).CreatePAT), ctx, tx, group)
}

// CreateUser mocks base method.
func (m *MockManager) CreateUser(ctx context.Context, tx db.Transaction, user *User) (*User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateUser", ctx, tx, user)
	ret0, _ := ret[0].(*User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateUser indicates an expected call of CreateUser.
func (mr *MockManagerMockRecorder) CreateUser(ctx, tx, user interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUser", reflect.TypeOf((*MockManager)(nil).CreateUser), ctx, tx, user)
}

// DeleteGroup mocks base method.
func (m *MockManager) DeleteGroup(ctx context.Context, tx db.Transaction, group *Group) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGroup", ctx, tx, group)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteGroup indicates an expected call of DeleteGroup.
func (mr *MockManagerMockRecorder) DeleteGroup(ctx, tx, group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroup", reflect.TypeOf((*MockManager)(nil).DeleteGroup), ctx, tx, group)
}

// DeletePAT mocks base method.
func (m *MockManager) DeletePAT(ctx context.Context, tx db.Transaction, group *PersonalAccessToken) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePAT", ctx, tx, group)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePAT indicates an expected call of DeletePAT.
func (mr *MockManagerMockRecorder) DeletePAT(ctx, tx, group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePAT", reflect.TypeOf((*MockManager)(nil).DeletePAT), ctx, tx, group)
}

// DeleteUser mocks base method.
func (m *MockManager) DeleteUser(ctx context.Context, tx db.Transaction, user *User) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteUser", ctx, tx, user)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteUser indicates an expected call of DeleteUser.
func (mr *MockManagerMockRecorder) DeleteUser(ctx, tx, user interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUser", reflect.TypeOf((*MockManager)(nil).DeleteUser), ctx, tx, user)
}

// GetGroupById mocks base method.
func (m *MockManager) GetGroupById(ctx context.Context, tx db.Transaction, strength db.LockingStrength, accountID, groupID string) (*Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupById", ctx, tx, strength, accountID, groupID)
	ret0, _ := ret[0].(*Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupById indicates an expected call of GetGroupById.
func (mr *MockManagerMockRecorder) GetGroupById(ctx, tx, strength, accountID, groupID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupById", reflect.TypeOf((*MockManager)(nil).GetGroupById), ctx, tx, strength, accountID, groupID)
}

// GetGroupsByAccount mocks base method.
func (m *MockManager) GetGroupsByAccount(ctx context.Context, tx db.Transaction, strength db.LockingStrength, accountID string) ([]*Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupsByAccount", ctx, tx, strength, accountID)
	ret0, _ := ret[0].([]*Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupsByAccount indicates an expected call of GetGroupsByAccount.
func (mr *MockManagerMockRecorder) GetGroupsByAccount(ctx, tx, strength, accountID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsByAccount", reflect.TypeOf((*MockManager)(nil).GetGroupsByAccount), ctx, tx, strength, accountID)
}

// GetGroupsByUser mocks base method.
func (m *MockManager) GetGroupsByUser(ctx context.Context, tx db.Transaction, strength db.LockingStrength, accountID, userID string) ([]*Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupsByUser", ctx, tx, strength, accountID, userID)
	ret0, _ := ret[0].([]*Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGroupsByUser indicates an expected call of GetGroupsByUser.
func (mr *MockManagerMockRecorder) GetGroupsByUser(ctx, tx, strength, accountID, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsByUser", reflect.TypeOf((*MockManager)(nil).GetGroupsByUser), ctx, tx, strength, accountID, userID)
}

// GetPATById mocks base method.
func (m *MockManager) GetPATById(ctx context.Context, tx db.Transaction, strength db.LockingStrength, accountID, patID string) (*PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPATById", ctx, tx, strength, accountID, patID)
	ret0, _ := ret[0].(*PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPATById indicates an expected call of GetPATById.
func (mr *MockManagerMockRecorder) GetPATById(ctx, tx, strength, accountID, patID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPATById", reflect.TypeOf((*MockManager)(nil).GetPATById), ctx, tx, strength, accountID, patID)
}

// GetPATSByAccount mocks base method.
func (m *MockManager) GetPATSByAccount(ctx context.Context, tx db.Transaction, strength db.LockingStrength, accountID string) ([]*PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPATSByAccount", ctx, tx, strength, accountID)
	ret0, _ := ret[0].([]*PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPATSByAccount indicates an expected call of GetPATSByAccount.
func (mr *MockManagerMockRecorder) GetPATSByAccount(ctx, tx, strength, accountID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPATSByAccount", reflect.TypeOf((*MockManager)(nil).GetPATSByAccount), ctx, tx, strength, accountID)
}

// GetPATSByUser mocks base method.
func (m *MockManager) GetPATSByUser(ctx context.Context, tx db.Transaction, strength db.LockingStrength, accountID, userID string) ([]*PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPATSByUser", ctx, tx, strength, accountID, userID)
	ret0, _ := ret[0].([]*PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPATSByUser indicates an expected call of GetPATSByUser.
func (mr *MockManagerMockRecorder) GetPATSByUser(ctx, tx, strength, accountID, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPATSByUser", reflect.TypeOf((*MockManager)(nil).GetPATSByUser), ctx, tx, strength, accountID, userID)
}

// GetUserById mocks base method.
func (m *MockManager) GetUserById(ctx context.Context, tx db.Transaction, strength db.LockingStrength, accountID, userID string) (*User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUserById", ctx, tx, strength, accountID, userID)
	ret0, _ := ret[0].(*User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUserById indicates an expected call of GetUserById.
func (mr *MockManagerMockRecorder) GetUserById(ctx, tx, strength, accountID, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserById", reflect.TypeOf((*MockManager)(nil).GetUserById), ctx, tx, strength, accountID, userID)
}

// GetUsersByAccount mocks base method.
func (m *MockManager) GetUsersByAccount(ctx context.Context, tx db.Transaction, strength db.LockingStrength, accountID string) ([]*User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUsersByAccount", ctx, tx, strength, accountID)
	ret0, _ := ret[0].([]*User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetUsersByAccount indicates an expected call of GetUsersByAccount.
func (mr *MockManagerMockRecorder) GetUsersByAccount(ctx, tx, strength, accountID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUsersByAccount", reflect.TypeOf((*MockManager)(nil).GetUsersByAccount), ctx, tx, strength, accountID)
}

// OnGroupCreate mocks base method.
func (m *MockManager) OnGroupCreate() GroupHookEvent {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnGroupCreate")
	ret0, _ := ret[0].(GroupHookEvent)
	return ret0
}

// OnGroupCreate indicates an expected call of OnGroupCreate.
func (mr *MockManagerMockRecorder) OnGroupCreate() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnGroupCreate", reflect.TypeOf((*MockManager)(nil).OnGroupCreate))
}

// OnGroupCreateError mocks base method.
func (m *MockManager) OnGroupCreateError() GroupHookErrorEvent {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnGroupCreateError")
	ret0, _ := ret[0].(GroupHookErrorEvent)
	return ret0
}

// OnGroupCreateError indicates an expected call of OnGroupCreateError.
func (mr *MockManagerMockRecorder) OnGroupCreateError() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnGroupCreateError", reflect.TypeOf((*MockManager)(nil).OnGroupCreateError))
}

// OnGroupDelete mocks base method.
func (m *MockManager) OnGroupDelete() GroupHookEvent {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnGroupDelete")
	ret0, _ := ret[0].(GroupHookEvent)
	return ret0
}

// OnGroupDelete indicates an expected call of OnGroupDelete.
func (mr *MockManagerMockRecorder) OnGroupDelete() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnGroupDelete", reflect.TypeOf((*MockManager)(nil).OnGroupDelete))
}

// OnGroupDeleteError mocks base method.
func (m *MockManager) OnGroupDeleteError() GroupHookErrorEvent {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnGroupDeleteError")
	ret0, _ := ret[0].(GroupHookErrorEvent)
	return ret0
}

// OnGroupDeleteError indicates an expected call of OnGroupDeleteError.
func (mr *MockManagerMockRecorder) OnGroupDeleteError() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnGroupDeleteError", reflect.TypeOf((*MockManager)(nil).OnGroupDeleteError))
}

// OnGroupUpdate mocks base method.
func (m *MockManager) OnGroupUpdate() GroupHookEvent {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnGroupUpdate")
	ret0, _ := ret[0].(GroupHookEvent)
	return ret0
}

// OnGroupUpdate indicates an expected call of OnGroupUpdate.
func (mr *MockManagerMockRecorder) OnGroupUpdate() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnGroupUpdate", reflect.TypeOf((*MockManager)(nil).OnGroupUpdate))
}

// OnGroupUpdateError mocks base method.
func (m *MockManager) OnGroupUpdateError() GroupHookErrorEvent {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnGroupUpdateError")
	ret0, _ := ret[0].(GroupHookErrorEvent)
	return ret0
}

// OnGroupUpdateError indicates an expected call of OnGroupUpdateError.
func (mr *MockManagerMockRecorder) OnGroupUpdateError() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnGroupUpdateError", reflect.TypeOf((*MockManager)(nil).OnGroupUpdateError))
}

// UpdateGroup mocks base method.
func (m *MockManager) UpdateGroup(ctx context.Context, tx db.Transaction, group *Group) (*Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGroup", ctx, tx, group)
	ret0, _ := ret[0].(*Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateGroup indicates an expected call of UpdateGroup.
func (mr *MockManagerMockRecorder) UpdateGroup(ctx, tx, group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroup", reflect.TypeOf((*MockManager)(nil).UpdateGroup), ctx, tx, group)
}

// UpdatePAT mocks base method.
func (m *MockManager) UpdatePAT(ctx context.Context, tx db.Transaction, group *PersonalAccessToken) (*PersonalAccessToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePAT", ctx, tx, group)
	ret0, _ := ret[0].(*PersonalAccessToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePAT indicates an expected call of UpdatePAT.
func (mr *MockManagerMockRecorder) UpdatePAT(ctx, tx, group interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePAT", reflect.TypeOf((*MockManager)(nil).UpdatePAT), ctx, tx, group)
}

// UpdateUser mocks base method.
func (m *MockManager) UpdateUser(ctx context.Context, tx db.Transaction, user *User) (*User, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateUser", ctx, tx, user)
	ret0, _ := ret[0].(*User)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateUser indicates an expected call of UpdateUser.
func (mr *MockManagerMockRecorder) UpdateUser(ctx, tx, user interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUser", reflect.TypeOf((*MockManager)(nil).UpdateUser), ctx, tx, user)
}