Files
zitadel/internal/notification/handlers/mock/commands.mock.go
T
Marco A.andGitHub 96bbd6a65c chore: management console naming inconsistency (#11390)
# Which Problems Are Solved

The following terms have all been renamed to management console:

- Customer Portal (when used to mean the console)
- Console
- Admin Console

# How the Problems Are Solved

- Search & Replace smartly
- Use Copilot for translation files

Changes done to: backend + frontend codebase, docs, translations and
protobufs (descriptions only)

# Additional Context

- Partially Closes #11279
2026-01-26 14:52:15 +00:00

577 lines
22 KiB
Go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/zitadel/zitadel/internal/notification/handlers (interfaces: Commands)
//
// Generated by this command:
//
// mockgen -typed -package mock -destination ./mock/commands.mock.go . Commands
//
// Package mock is a generated GoMock package.
package mock
import (
context "context"
reflect "reflect"
senders "github.com/zitadel/zitadel/internal/notification/senders"
milestone "github.com/zitadel/zitadel/internal/repository/milestone"
quota "github.com/zitadel/zitadel/internal/repository/quota"
gomock "go.uber.org/mock/gomock"
)
// MockCommands is a mock of Commands interface.
type MockCommands struct {
ctrl *gomock.Controller
recorder *MockCommandsMockRecorder
isgomock struct{}
}
// MockCommandsMockRecorder is the mock recorder for MockCommands.
type MockCommandsMockRecorder struct {
mock *MockCommands
}
// NewMockCommands creates a new mock instance.
func NewMockCommands(ctrl *gomock.Controller) *MockCommands {
mock := &MockCommands{ctrl: ctrl}
mock.recorder = &MockCommandsMockRecorder{mock}
return mock
}
// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCommands) EXPECT() *MockCommandsMockRecorder {
return m.recorder
}
// HumanEmailVerificationCodeSent mocks base method.
func (m *MockCommands) HumanEmailVerificationCodeSent(ctx context.Context, orgID, userID string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HumanEmailVerificationCodeSent", ctx, orgID, userID)
ret0, _ := ret[0].(error)
return ret0
}
// HumanEmailVerificationCodeSent indicates an expected call of HumanEmailVerificationCodeSent.
func (mr *MockCommandsMockRecorder) HumanEmailVerificationCodeSent(ctx, orgID, userID any) *MockCommandsHumanEmailVerificationCodeSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanEmailVerificationCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanEmailVerificationCodeSent), ctx, orgID, userID)
return &MockCommandsHumanEmailVerificationCodeSentCall{Call: call}
}
// MockCommandsHumanEmailVerificationCodeSentCall wrap *gomock.Call
type MockCommandsHumanEmailVerificationCodeSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsHumanEmailVerificationCodeSentCall) Return(arg0 error) *MockCommandsHumanEmailVerificationCodeSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsHumanEmailVerificationCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsHumanEmailVerificationCodeSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsHumanEmailVerificationCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsHumanEmailVerificationCodeSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// HumanInitCodeSent mocks base method.
func (m *MockCommands) HumanInitCodeSent(ctx context.Context, orgID, userID string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HumanInitCodeSent", ctx, orgID, userID)
ret0, _ := ret[0].(error)
return ret0
}
// HumanInitCodeSent indicates an expected call of HumanInitCodeSent.
func (mr *MockCommandsMockRecorder) HumanInitCodeSent(ctx, orgID, userID any) *MockCommandsHumanInitCodeSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanInitCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanInitCodeSent), ctx, orgID, userID)
return &MockCommandsHumanInitCodeSentCall{Call: call}
}
// MockCommandsHumanInitCodeSentCall wrap *gomock.Call
type MockCommandsHumanInitCodeSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsHumanInitCodeSentCall) Return(arg0 error) *MockCommandsHumanInitCodeSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsHumanInitCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsHumanInitCodeSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsHumanInitCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsHumanInitCodeSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// HumanOTPEmailCodeSent mocks base method.
func (m *MockCommands) HumanOTPEmailCodeSent(ctx context.Context, userID, resourceOwner string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HumanOTPEmailCodeSent", ctx, userID, resourceOwner)
ret0, _ := ret[0].(error)
return ret0
}
// HumanOTPEmailCodeSent indicates an expected call of HumanOTPEmailCodeSent.
func (mr *MockCommandsMockRecorder) HumanOTPEmailCodeSent(ctx, userID, resourceOwner any) *MockCommandsHumanOTPEmailCodeSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanOTPEmailCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanOTPEmailCodeSent), ctx, userID, resourceOwner)
return &MockCommandsHumanOTPEmailCodeSentCall{Call: call}
}
// MockCommandsHumanOTPEmailCodeSentCall wrap *gomock.Call
type MockCommandsHumanOTPEmailCodeSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsHumanOTPEmailCodeSentCall) Return(arg0 error) *MockCommandsHumanOTPEmailCodeSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsHumanOTPEmailCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsHumanOTPEmailCodeSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsHumanOTPEmailCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsHumanOTPEmailCodeSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// HumanOTPSMSCodeSent mocks base method.
func (m *MockCommands) HumanOTPSMSCodeSent(ctx context.Context, userID, resourceOwner string, generatorInfo *senders.CodeGeneratorInfo) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HumanOTPSMSCodeSent", ctx, userID, resourceOwner, generatorInfo)
ret0, _ := ret[0].(error)
return ret0
}
// HumanOTPSMSCodeSent indicates an expected call of HumanOTPSMSCodeSent.
func (mr *MockCommandsMockRecorder) HumanOTPSMSCodeSent(ctx, userID, resourceOwner, generatorInfo any) *MockCommandsHumanOTPSMSCodeSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanOTPSMSCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanOTPSMSCodeSent), ctx, userID, resourceOwner, generatorInfo)
return &MockCommandsHumanOTPSMSCodeSentCall{Call: call}
}
// MockCommandsHumanOTPSMSCodeSentCall wrap *gomock.Call
type MockCommandsHumanOTPSMSCodeSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsHumanOTPSMSCodeSentCall) Return(arg0 error) *MockCommandsHumanOTPSMSCodeSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsHumanOTPSMSCodeSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanOTPSMSCodeSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsHumanOTPSMSCodeSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanOTPSMSCodeSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// HumanPasswordlessInitCodeSent mocks base method.
func (m *MockCommands) HumanPasswordlessInitCodeSent(ctx context.Context, userID, resourceOwner, codeID string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HumanPasswordlessInitCodeSent", ctx, userID, resourceOwner, codeID)
ret0, _ := ret[0].(error)
return ret0
}
// HumanPasswordlessInitCodeSent indicates an expected call of HumanPasswordlessInitCodeSent.
func (mr *MockCommandsMockRecorder) HumanPasswordlessInitCodeSent(ctx, userID, resourceOwner, codeID any) *MockCommandsHumanPasswordlessInitCodeSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanPasswordlessInitCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanPasswordlessInitCodeSent), ctx, userID, resourceOwner, codeID)
return &MockCommandsHumanPasswordlessInitCodeSentCall{Call: call}
}
// MockCommandsHumanPasswordlessInitCodeSentCall wrap *gomock.Call
type MockCommandsHumanPasswordlessInitCodeSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsHumanPasswordlessInitCodeSentCall) Return(arg0 error) *MockCommandsHumanPasswordlessInitCodeSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsHumanPasswordlessInitCodeSentCall) Do(f func(context.Context, string, string, string) error) *MockCommandsHumanPasswordlessInitCodeSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsHumanPasswordlessInitCodeSentCall) DoAndReturn(f func(context.Context, string, string, string) error) *MockCommandsHumanPasswordlessInitCodeSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// HumanPhoneVerificationCodeSent mocks base method.
func (m *MockCommands) HumanPhoneVerificationCodeSent(ctx context.Context, orgID, userID string, generatorInfo *senders.CodeGeneratorInfo) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "HumanPhoneVerificationCodeSent", ctx, orgID, userID, generatorInfo)
ret0, _ := ret[0].(error)
return ret0
}
// HumanPhoneVerificationCodeSent indicates an expected call of HumanPhoneVerificationCodeSent.
func (mr *MockCommandsMockRecorder) HumanPhoneVerificationCodeSent(ctx, orgID, userID, generatorInfo any) *MockCommandsHumanPhoneVerificationCodeSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HumanPhoneVerificationCodeSent", reflect.TypeOf((*MockCommands)(nil).HumanPhoneVerificationCodeSent), ctx, orgID, userID, generatorInfo)
return &MockCommandsHumanPhoneVerificationCodeSentCall{Call: call}
}
// MockCommandsHumanPhoneVerificationCodeSentCall wrap *gomock.Call
type MockCommandsHumanPhoneVerificationCodeSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsHumanPhoneVerificationCodeSentCall) Return(arg0 error) *MockCommandsHumanPhoneVerificationCodeSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsHumanPhoneVerificationCodeSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanPhoneVerificationCodeSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsHumanPhoneVerificationCodeSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsHumanPhoneVerificationCodeSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// InviteCodeSent mocks base method.
func (m *MockCommands) InviteCodeSent(ctx context.Context, orgID, userID string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "InviteCodeSent", ctx, orgID, userID)
ret0, _ := ret[0].(error)
return ret0
}
// InviteCodeSent indicates an expected call of InviteCodeSent.
func (mr *MockCommandsMockRecorder) InviteCodeSent(ctx, orgID, userID any) *MockCommandsInviteCodeSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InviteCodeSent", reflect.TypeOf((*MockCommands)(nil).InviteCodeSent), ctx, orgID, userID)
return &MockCommandsInviteCodeSentCall{Call: call}
}
// MockCommandsInviteCodeSentCall wrap *gomock.Call
type MockCommandsInviteCodeSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsInviteCodeSentCall) Return(arg0 error) *MockCommandsInviteCodeSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsInviteCodeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsInviteCodeSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsInviteCodeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsInviteCodeSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// MilestonePushed mocks base method.
func (m *MockCommands) MilestonePushed(ctx context.Context, instanceID string, msType milestone.Type, endpoints []string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "MilestonePushed", ctx, instanceID, msType, endpoints)
ret0, _ := ret[0].(error)
return ret0
}
// MilestonePushed indicates an expected call of MilestonePushed.
func (mr *MockCommandsMockRecorder) MilestonePushed(ctx, instanceID, msType, endpoints any) *MockCommandsMilestonePushedCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MilestonePushed", reflect.TypeOf((*MockCommands)(nil).MilestonePushed), ctx, instanceID, msType, endpoints)
return &MockCommandsMilestonePushedCall{Call: call}
}
// MockCommandsMilestonePushedCall wrap *gomock.Call
type MockCommandsMilestonePushedCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsMilestonePushedCall) Return(arg0 error) *MockCommandsMilestonePushedCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsMilestonePushedCall) Do(f func(context.Context, string, milestone.Type, []string) error) *MockCommandsMilestonePushedCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsMilestonePushedCall) DoAndReturn(f func(context.Context, string, milestone.Type, []string) error) *MockCommandsMilestonePushedCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// OTPEmailSent mocks base method.
func (m *MockCommands) OTPEmailSent(ctx context.Context, sessionID, resourceOwner string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "OTPEmailSent", ctx, sessionID, resourceOwner)
ret0, _ := ret[0].(error)
return ret0
}
// OTPEmailSent indicates an expected call of OTPEmailSent.
func (mr *MockCommandsMockRecorder) OTPEmailSent(ctx, sessionID, resourceOwner any) *MockCommandsOTPEmailSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OTPEmailSent", reflect.TypeOf((*MockCommands)(nil).OTPEmailSent), ctx, sessionID, resourceOwner)
return &MockCommandsOTPEmailSentCall{Call: call}
}
// MockCommandsOTPEmailSentCall wrap *gomock.Call
type MockCommandsOTPEmailSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsOTPEmailSentCall) Return(arg0 error) *MockCommandsOTPEmailSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsOTPEmailSentCall) Do(f func(context.Context, string, string) error) *MockCommandsOTPEmailSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsOTPEmailSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsOTPEmailSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// OTPSMSSent mocks base method.
func (m *MockCommands) OTPSMSSent(ctx context.Context, sessionID, resourceOwner string, generatorInfo *senders.CodeGeneratorInfo) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "OTPSMSSent", ctx, sessionID, resourceOwner, generatorInfo)
ret0, _ := ret[0].(error)
return ret0
}
// OTPSMSSent indicates an expected call of OTPSMSSent.
func (mr *MockCommandsMockRecorder) OTPSMSSent(ctx, sessionID, resourceOwner, generatorInfo any) *MockCommandsOTPSMSSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OTPSMSSent", reflect.TypeOf((*MockCommands)(nil).OTPSMSSent), ctx, sessionID, resourceOwner, generatorInfo)
return &MockCommandsOTPSMSSentCall{Call: call}
}
// MockCommandsOTPSMSSentCall wrap *gomock.Call
type MockCommandsOTPSMSSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsOTPSMSSentCall) Return(arg0 error) *MockCommandsOTPSMSSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsOTPSMSSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsOTPSMSSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsOTPSMSSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsOTPSMSSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// PasswordChangeSent mocks base method.
func (m *MockCommands) PasswordChangeSent(ctx context.Context, orgID, userID string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PasswordChangeSent", ctx, orgID, userID)
ret0, _ := ret[0].(error)
return ret0
}
// PasswordChangeSent indicates an expected call of PasswordChangeSent.
func (mr *MockCommandsMockRecorder) PasswordChangeSent(ctx, orgID, userID any) *MockCommandsPasswordChangeSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PasswordChangeSent", reflect.TypeOf((*MockCommands)(nil).PasswordChangeSent), ctx, orgID, userID)
return &MockCommandsPasswordChangeSentCall{Call: call}
}
// MockCommandsPasswordChangeSentCall wrap *gomock.Call
type MockCommandsPasswordChangeSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsPasswordChangeSentCall) Return(arg0 error) *MockCommandsPasswordChangeSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsPasswordChangeSentCall) Do(f func(context.Context, string, string) error) *MockCommandsPasswordChangeSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsPasswordChangeSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsPasswordChangeSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// PasswordCodeSent mocks base method.
func (m *MockCommands) PasswordCodeSent(ctx context.Context, orgID, userID string, generatorInfo *senders.CodeGeneratorInfo) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "PasswordCodeSent", ctx, orgID, userID, generatorInfo)
ret0, _ := ret[0].(error)
return ret0
}
// PasswordCodeSent indicates an expected call of PasswordCodeSent.
func (mr *MockCommandsMockRecorder) PasswordCodeSent(ctx, orgID, userID, generatorInfo any) *MockCommandsPasswordCodeSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PasswordCodeSent", reflect.TypeOf((*MockCommands)(nil).PasswordCodeSent), ctx, orgID, userID, generatorInfo)
return &MockCommandsPasswordCodeSentCall{Call: call}
}
// MockCommandsPasswordCodeSentCall wrap *gomock.Call
type MockCommandsPasswordCodeSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsPasswordCodeSentCall) Return(arg0 error) *MockCommandsPasswordCodeSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsPasswordCodeSentCall) Do(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsPasswordCodeSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsPasswordCodeSentCall) DoAndReturn(f func(context.Context, string, string, *senders.CodeGeneratorInfo) error) *MockCommandsPasswordCodeSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// UsageNotificationSent mocks base method.
func (m *MockCommands) UsageNotificationSent(ctx context.Context, dueEvent *quota.NotificationDueEvent) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UsageNotificationSent", ctx, dueEvent)
ret0, _ := ret[0].(error)
return ret0
}
// UsageNotificationSent indicates an expected call of UsageNotificationSent.
func (mr *MockCommandsMockRecorder) UsageNotificationSent(ctx, dueEvent any) *MockCommandsUsageNotificationSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UsageNotificationSent", reflect.TypeOf((*MockCommands)(nil).UsageNotificationSent), ctx, dueEvent)
return &MockCommandsUsageNotificationSentCall{Call: call}
}
// MockCommandsUsageNotificationSentCall wrap *gomock.Call
type MockCommandsUsageNotificationSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsUsageNotificationSentCall) Return(arg0 error) *MockCommandsUsageNotificationSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsUsageNotificationSentCall) Do(f func(context.Context, *quota.NotificationDueEvent) error) *MockCommandsUsageNotificationSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsUsageNotificationSentCall) DoAndReturn(f func(context.Context, *quota.NotificationDueEvent) error) *MockCommandsUsageNotificationSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}
// UserDomainClaimedSent mocks base method.
func (m *MockCommands) UserDomainClaimedSent(ctx context.Context, orgID, userID string) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "UserDomainClaimedSent", ctx, orgID, userID)
ret0, _ := ret[0].(error)
return ret0
}
// UserDomainClaimedSent indicates an expected call of UserDomainClaimedSent.
func (mr *MockCommandsMockRecorder) UserDomainClaimedSent(ctx, orgID, userID any) *MockCommandsUserDomainClaimedSentCall {
mr.mock.ctrl.T.Helper()
call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UserDomainClaimedSent", reflect.TypeOf((*MockCommands)(nil).UserDomainClaimedSent), ctx, orgID, userID)
return &MockCommandsUserDomainClaimedSentCall{Call: call}
}
// MockCommandsUserDomainClaimedSentCall wrap *gomock.Call
type MockCommandsUserDomainClaimedSentCall struct {
*gomock.Call
}
// Return rewrite *gomock.Call.Return
func (c *MockCommandsUserDomainClaimedSentCall) Return(arg0 error) *MockCommandsUserDomainClaimedSentCall {
c.Call = c.Call.Return(arg0)
return c
}
// Do rewrite *gomock.Call.Do
func (c *MockCommandsUserDomainClaimedSentCall) Do(f func(context.Context, string, string) error) *MockCommandsUserDomainClaimedSentCall {
c.Call = c.Call.Do(f)
return c
}
// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockCommandsUserDomainClaimedSentCall) DoAndReturn(f func(context.Context, string, string) error) *MockCommandsUserDomainClaimedSentCall {
c.Call = c.Call.DoAndReturn(f)
return c
}