diff --git a/backend/v3/api/session/v2/convert/session_check_password.go b/backend/v3/api/session/v2/convert/session_check_password.go new file mode 100644 index 000000000..196508fcb --- /dev/null +++ b/backend/v3/api/session/v2/convert/session_check_password.go @@ -0,0 +1,16 @@ +package convert + +import ( + "github.com/zitadel/zitadel/backend/v3/domain" + session_grpc "github.com/zitadel/zitadel/pkg/grpc/session/v2" +) + +func CheckPasswordGRPCToDomain(checkPsw *session_grpc.CheckPassword) *domain.CheckPasswordType { + if checkPsw == nil { + return nil + } + + return &domain.CheckPasswordType{ + Password: checkPsw.GetPassword(), + } +} diff --git a/backend/v3/api/session/v2/convert/session_check_password_test.go b/backend/v3/api/session/v2/convert/session_check_password_test.go new file mode 100644 index 000000000..822e3fc01 --- /dev/null +++ b/backend/v3/api/session/v2/convert/session_check_password_test.go @@ -0,0 +1,38 @@ +package convert + +import ( + "testing" + + "github.com/stretchr/testify/assert" + + "github.com/zitadel/zitadel/backend/v3/domain" + session_grpc "github.com/zitadel/zitadel/pkg/grpc/session/v2" +) + +func TestCheckPasswordGRPCToDomain(t *testing.T) { + t.Parallel() + tt := []struct { + testName string + inputCheckPsw *session_grpc.CheckPassword + expected *domain.CheckPasswordType + }{ + {testName: "when nil input should return nil output"}, + { + testName: "when not nil input should return valid output", + inputCheckPsw: &session_grpc.CheckPassword{Password: "pw"}, + expected: &domain.CheckPasswordType{Password: "pw"}, + }, + } + + for _, tc := range tt { + t.Run(tc.testName, func(t *testing.T) { + t.Parallel() + + // Test + res := CheckPasswordGRPCToDomain(tc.inputCheckPsw) + + // Verify + assert.Equal(t, tc.expected, res) + }) + } +} diff --git a/backend/v3/api/session/v2/convert/session_check_user.go b/backend/v3/api/session/v2/convert/session_check_user.go index e40ec40cf..fe4ae4720 100644 --- a/backend/v3/api/session/v2/convert/session_check_user.go +++ b/backend/v3/api/session/v2/convert/session_check_user.go @@ -6,7 +6,7 @@ import ( session_grpc "github.com/zitadel/zitadel/pkg/grpc/session/v2" ) -func CheckUserGRPCToQueryOpt(checkUser *session_grpc.CheckUser) (*domain.CheckUserType, error) { +func CheckUserGRPCToDomain(checkUser *session_grpc.CheckUser) (*domain.CheckUserType, error) { var toReturn *domain.CheckUserType if checkUser == nil { return toReturn, nil diff --git a/backend/v3/api/session/v2/convert/session_check_user_test.go b/backend/v3/api/session/v2/convert/session_check_user_test.go index 0e6bb178f..c43a10f15 100644 --- a/backend/v3/api/session/v2/convert/session_check_user_test.go +++ b/backend/v3/api/session/v2/convert/session_check_user_test.go @@ -47,7 +47,7 @@ func TestCheckUserGRPCToQueryOpt(t *testing.T) { t.Parallel() // Test - res, err := CheckUserGRPCToQueryOpt(tc.inputCheckUser) + res, err := CheckUserGRPCToDomain(tc.inputCheckUser) // Verify assert.ErrorIs(t, err, tc.expectedError) diff --git a/backend/v3/domain/defaults.go b/backend/v3/domain/defaults.go index 627d4583b..e08177425 100644 --- a/backend/v3/domain/defaults.go +++ b/backend/v3/domain/defaults.go @@ -3,11 +3,15 @@ package domain import ( "github.com/zitadel/zitadel/backend/v3/storage/database" "github.com/zitadel/zitadel/backend/v3/storage/eventstore" + "github.com/zitadel/zitadel/internal/config/systemdefaults" + "github.com/zitadel/zitadel/internal/crypto" ) var ( pool database.Pool legacyEventstore eventstore.LegacyEventstore + sysConfig systemdefaults.SystemDefaults + passwordHasher *crypto.Hasher ) func SetPool(p database.Pool) { @@ -17,3 +21,11 @@ func SetPool(p database.Pool) { func SetLegacyEventstore(es eventstore.LegacyEventstore) { legacyEventstore = es } + +func SetSystemConfig(cfg systemdefaults.SystemDefaults) { + sysConfig = cfg +} + +func SetPasswordHasher(hasher *crypto.Hasher) { + passwordHasher = hasher +} diff --git a/backend/v3/domain/domain_test.go b/backend/v3/domain/domain_test.go index 19769aae1..a3e837341 100644 --- a/backend/v3/domain/domain_test.go +++ b/backend/v3/domain/domain_test.go @@ -3,10 +3,16 @@ package domain_test import ( "os" "testing" + + "github.com/zitadel/passwap" + + "github.com/zitadel/zitadel/backend/v3/domain" + "github.com/zitadel/zitadel/internal/crypto" ) func TestMain(m *testing.M) { os.Exit(func() int { + domain.SetPasswordHasher(&crypto.Hasher{Swapper: &passwap.Swapper{}}) return m.Run() }()) } diff --git a/backend/v3/domain/errors.go b/backend/v3/domain/errors.go index 6d31b51ad..a07303408 100644 --- a/backend/v3/domain/errors.go +++ b/backend/v3/domain/errors.go @@ -74,3 +74,44 @@ func NewUnexpectedTextQueryOperationError[T any](assertedType T) error { func (u *UnexpectedTextQueryOperationError[T]) Error() string { return fmt.Sprintf("Message=unexpected text query operation type '%T'", u.assertedType) } + +type PasswordVerificationError struct { + failedAttempts uint8 +} + +func NewPasswordVerificationError(failedPassAttempts uint8) error { + return &PasswordVerificationError{ + failedAttempts: failedPassAttempts, + } +} + +func (e *PasswordVerificationError) Error() string { + return fmt.Sprintf("Message=failed password attempts (%d)", e.failedAttempts) +} + +func (err *PasswordVerificationError) Is(target error) bool { + _, ok := target.(*PasswordVerificationError) + return ok +} + +type RowsReturnedMismatchError struct { + Msg string + Expected int64 + Actual int64 +} + +func NewRowsReturnedMismatchError(expected, actual int64) error { + return &RowsReturnedMismatchError{ + Expected: expected, + Actual: actual, + } +} + +func (err *RowsReturnedMismatchError) Error() string { + return fmt.Sprintf("Message=expecting %d row(s) returned, got %d", err.Expected, err.Actual) +} + +func (err *RowsReturnedMismatchError) Is(target error) bool { + _, ok := target.(*RowsReturnedMismatchError) + return ok +} diff --git a/backend/v3/domain/invoke_option.go b/backend/v3/domain/invoke_option.go index 1fb8a1fbf..4d307e61b 100644 --- a/backend/v3/domain/invoke_option.go +++ b/backend/v3/domain/invoke_option.go @@ -51,6 +51,12 @@ func WithUserRepo(repo UserRepository) InvokeOpt { } } +func WithLockoutSettingsRepo(repo LockoutSettingsRepository) InvokeOpt { + return func(opts *InvokeOpts) { + opts.lockoutSettingRepo = repo + } +} + func WithPermissionChecker(checker PermissionChecker) InvokeOpt { return func(opts *InvokeOpts) { opts.Permissions = checker @@ -93,6 +99,9 @@ type InvokeOpts struct { instanceDomainRepo InstanceDomainRepository sessionRepo SessionRepository userRepo UserRepository + + // Settings repos + lockoutSettingRepo LockoutSettingsRepository } func (o *InvokeOpts) DB() database.QueryExecutor { diff --git a/backend/v3/domain/invoker_transaction.go b/backend/v3/domain/invoker_transaction.go index 5516a4c0d..0a71e70a4 100644 --- a/backend/v3/domain/invoker_transaction.go +++ b/backend/v3/domain/invoker_transaction.go @@ -19,6 +19,9 @@ func NewTransactionInvoker(next Invoker) *transactionInvoker { // Transactional is implemented by [Commander]s and [Querier]s wishing to access the DB inside a transaction. // +// It is NOT recommended to use this when non-DB operation inside a transaction take time (e.g. password hash verification). +// In that case, it is advisable to manually manage the transaction by type asserting [database.Beginner] on db.DB() +// //go:generate mockgen -destination=mock/transactional.mock.go -package=domainmock . Transactional type Transactional interface { RequiresTransaction() diff --git a/backend/v3/domain/mock/branding_settings.mock.go b/backend/v3/domain/mock/branding_settings.mock.go new file mode 100644 index 000000000..9f4c2df9e --- /dev/null +++ b/backend/v3/domain/mock/branding_settings.mock.go @@ -0,0 +1,1662 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: BrandingSettingsRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/branding_settings.mock.go . BrandingSettingsRepository +// + +// Package domainmock is a generated GoMock package. +package domainmock + +import ( + context "context" + url "net/url" + reflect "reflect" + time "time" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + json "github.com/zitadel/zitadel/backend/v3/storage/database/json" + gomock "go.uber.org/mock/gomock" +) + +// MockBrandingSettingsRepository is a mock of BrandingSettingsRepository interface. +type MockBrandingSettingsRepository struct { + ctrl *gomock.Controller + recorder *MockBrandingSettingsRepositoryMockRecorder + isgomock struct{} +} + +// MockBrandingSettingsRepositoryMockRecorder is the mock recorder for MockBrandingSettingsRepository. +type MockBrandingSettingsRepositoryMockRecorder struct { + mock *MockBrandingSettingsRepository +} + +// NewMockBrandingSettingsRepository creates a new mock instance. +func NewMockBrandingSettingsRepository(ctrl *gomock.Controller) *MockBrandingSettingsRepository { + mock := &MockBrandingSettingsRepository{ctrl: ctrl} + mock.recorder = &MockBrandingSettingsRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockBrandingSettingsRepository) EXPECT() *MockBrandingSettingsRepositoryMockRecorder { + return m.recorder +} + +// Activate mocks base method. +func (m *MockBrandingSettingsRepository) Activate(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Activate", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Activate indicates an expected call of Activate. +func (mr *MockBrandingSettingsRepositoryMockRecorder) Activate(ctx, client, condition any) *MockBrandingSettingsRepositoryActivateCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Activate", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).Activate), ctx, client, condition) + return &MockBrandingSettingsRepositoryActivateCall{Call: call} +} + +// MockBrandingSettingsRepositoryActivateCall wrap *gomock.Call +type MockBrandingSettingsRepositoryActivateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryActivateCall) Return(arg0 int64, arg1 error) *MockBrandingSettingsRepositoryActivateCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryActivateCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockBrandingSettingsRepositoryActivateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryActivateCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockBrandingSettingsRepositoryActivateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ActivateAt mocks base method. +func (m *MockBrandingSettingsRepository) ActivateAt(ctx context.Context, client database.QueryExecutor, condition database.Condition, updatedAt time.Time) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ActivateAt", ctx, client, condition, updatedAt) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ActivateAt indicates an expected call of ActivateAt. +func (mr *MockBrandingSettingsRepositoryMockRecorder) ActivateAt(ctx, client, condition, updatedAt any) *MockBrandingSettingsRepositoryActivateAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateAt", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).ActivateAt), ctx, client, condition, updatedAt) + return &MockBrandingSettingsRepositoryActivateAtCall{Call: call} +} + +// MockBrandingSettingsRepositoryActivateAtCall wrap *gomock.Call +type MockBrandingSettingsRepositoryActivateAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryActivateAtCall) Return(arg0 int64, arg1 error) *MockBrandingSettingsRepositoryActivateAtCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryActivateAtCall) Do(f func(context.Context, database.QueryExecutor, database.Condition, time.Time) (int64, error)) *MockBrandingSettingsRepositoryActivateAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryActivateAtCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition, time.Time) (int64, error)) *MockBrandingSettingsRepositoryActivateAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreatedAtColumn mocks base method. +func (m *MockBrandingSettingsRepository) CreatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// CreatedAtColumn indicates an expected call of CreatedAtColumn. +func (mr *MockBrandingSettingsRepositoryMockRecorder) CreatedAtColumn() *MockBrandingSettingsRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).CreatedAtColumn)) + return &MockBrandingSettingsRepositoryCreatedAtColumnCall{Call: call} +} + +// MockBrandingSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockBrandingSettingsRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockBrandingSettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockBrandingSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockBrandingSettingsRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).Delete), ctx, client, condition) + return &MockBrandingSettingsRepositoryDeleteCall{Call: call} +} + +// MockBrandingSettingsRepositoryDeleteCall wrap *gomock.Call +type MockBrandingSettingsRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockBrandingSettingsRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockBrandingSettingsRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockBrandingSettingsRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockBrandingSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.BrandingSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.BrandingSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockBrandingSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockBrandingSettingsRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).Get), varargs...) + return &MockBrandingSettingsRepositoryGetCall{Call: call} +} + +// MockBrandingSettingsRepositoryGetCall wrap *gomock.Call +type MockBrandingSettingsRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryGetCall) Return(arg0 *domain.BrandingSettings, arg1 error) *MockBrandingSettingsRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.BrandingSettings, error)) *MockBrandingSettingsRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.BrandingSettings, error)) *MockBrandingSettingsRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockBrandingSettingsRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockBrandingSettingsRepositoryMockRecorder) IDColumn() *MockBrandingSettingsRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).IDColumn)) + return &MockBrandingSettingsRepositoryIDColumnCall{Call: call} +} + +// MockBrandingSettingsRepositoryIDColumnCall wrap *gomock.Call +type MockBrandingSettingsRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockBrandingSettingsRepository) IDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockBrandingSettingsRepositoryMockRecorder) IDCondition(id any) *MockBrandingSettingsRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).IDCondition), id) + return &MockBrandingSettingsRepositoryIDConditionCall{Call: call} +} + +// MockBrandingSettingsRepositoryIDConditionCall wrap *gomock.Call +type MockBrandingSettingsRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockBrandingSettingsRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockBrandingSettingsRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockBrandingSettingsRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockBrandingSettingsRepositoryMockRecorder) InstanceIDColumn() *MockBrandingSettingsRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).InstanceIDColumn)) + return &MockBrandingSettingsRepositoryInstanceIDColumnCall{Call: call} +} + +// MockBrandingSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockBrandingSettingsRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockBrandingSettingsRepository) InstanceIDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// InstanceIDCondition indicates an expected call of InstanceIDCondition. +func (mr *MockBrandingSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockBrandingSettingsRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).InstanceIDCondition), id) + return &MockBrandingSettingsRepositoryInstanceIDConditionCall{Call: call} +} + +// MockBrandingSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockBrandingSettingsRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockBrandingSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockBrandingSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockBrandingSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.BrandingSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.BrandingSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockBrandingSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockBrandingSettingsRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).List), varargs...) + return &MockBrandingSettingsRepositoryListCall{Call: call} +} + +// MockBrandingSettingsRepositoryListCall wrap *gomock.Call +type MockBrandingSettingsRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryListCall) Return(arg0 []*domain.BrandingSettings, arg1 error) *MockBrandingSettingsRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.BrandingSettings, error)) *MockBrandingSettingsRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.BrandingSettings, error)) *MockBrandingSettingsRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDColumn mocks base method. +func (m *MockBrandingSettingsRepository) OrganizationIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// OrganizationIDColumn indicates an expected call of OrganizationIDColumn. +func (mr *MockBrandingSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockBrandingSettingsRepositoryOrganizationIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).OrganizationIDColumn)) + return &MockBrandingSettingsRepositoryOrganizationIDColumnCall{Call: call} +} + +// MockBrandingSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call +type MockBrandingSettingsRepositoryOrganizationIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDCondition mocks base method. +func (m *MockBrandingSettingsRepository) OrganizationIDCondition(id *string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// OrganizationIDCondition indicates an expected call of OrganizationIDCondition. +func (mr *MockBrandingSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockBrandingSettingsRepositoryOrganizationIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).OrganizationIDCondition), id) + return &MockBrandingSettingsRepositoryOrganizationIDConditionCall{Call: call} +} + +// MockBrandingSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call +type MockBrandingSettingsRepositoryOrganizationIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockBrandingSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockBrandingSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockBrandingSettingsRepository) PrimaryKeyColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns. +func (mr *MockBrandingSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).PrimaryKeyColumns)) + return &MockBrandingSettingsRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockBrandingSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockBrandingSettingsRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockBrandingSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockBrandingSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockBrandingSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockBrandingSettingsRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id) + return &MockBrandingSettingsRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockBrandingSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockBrandingSettingsRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockBrandingSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockBrandingSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Set mocks base method. +func (m *MockBrandingSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.BrandingSettings) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, client, settings) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockBrandingSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockBrandingSettingsRepositorySetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).Set), ctx, client, settings) + return &MockBrandingSettingsRepositorySetCall{Call: call} +} + +// MockBrandingSettingsRepositorySetCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetCall) Return(arg0 error) *MockBrandingSettingsRepositorySetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.BrandingSettings) error) *MockBrandingSettingsRepositorySetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.BrandingSettings) error) *MockBrandingSettingsRepositorySetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetBackgroundColorDark mocks base method. +func (m *MockBrandingSettingsRepository) SetBackgroundColorDark(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetBackgroundColorDark", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetBackgroundColorDark indicates an expected call of SetBackgroundColorDark. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetBackgroundColorDark(value any) *MockBrandingSettingsRepositorySetBackgroundColorDarkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBackgroundColorDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetBackgroundColorDark), value) + return &MockBrandingSettingsRepositorySetBackgroundColorDarkCall{Call: call} +} + +// MockBrandingSettingsRepositorySetBackgroundColorDarkCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetBackgroundColorDarkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetBackgroundColorDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorDarkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetBackgroundColorDarkCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorDarkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetBackgroundColorDarkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorDarkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetBackgroundColorLight mocks base method. +func (m *MockBrandingSettingsRepository) SetBackgroundColorLight(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetBackgroundColorLight", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetBackgroundColorLight indicates an expected call of SetBackgroundColorLight. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetBackgroundColorLight(value any) *MockBrandingSettingsRepositorySetBackgroundColorLightCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBackgroundColorLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetBackgroundColorLight), value) + return &MockBrandingSettingsRepositorySetBackgroundColorLightCall{Call: call} +} + +// MockBrandingSettingsRepositorySetBackgroundColorLightCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetBackgroundColorLightCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetBackgroundColorLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorLightCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetBackgroundColorLightCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorLightCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetBackgroundColorLightCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetBackgroundColorLightCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetColumns mocks base method. +func (m *MockBrandingSettingsRepository) SetColumns(ctx context.Context, client database.QueryExecutor, settings *domain.Settings, changes ...database.Change) error { + m.ctrl.T.Helper() + varargs := []any{ctx, client, settings} + for _, a := range changes { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetColumns", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetColumns indicates an expected call of SetColumns. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetColumns(ctx, client, settings any, changes ...any) *MockBrandingSettingsRepositorySetColumnsCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client, settings}, changes...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetColumns", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetColumns), varargs...) + return &MockBrandingSettingsRepositorySetColumnsCall{Call: call} +} + +// MockBrandingSettingsRepositorySetColumnsCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetColumnsCall) Return(arg0 error) *MockBrandingSettingsRepositorySetColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetColumnsCall) Do(f func(context.Context, database.QueryExecutor, *domain.Settings, ...database.Change) error) *MockBrandingSettingsRepositorySetColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetColumnsCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.Settings, ...database.Change) error) *MockBrandingSettingsRepositorySetColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetDisableWatermark mocks base method. +func (m *MockBrandingSettingsRepository) SetDisableWatermark(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDisableWatermark", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetDisableWatermark indicates an expected call of SetDisableWatermark. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetDisableWatermark(value any) *MockBrandingSettingsRepositorySetDisableWatermarkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDisableWatermark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetDisableWatermark), value) + return &MockBrandingSettingsRepositorySetDisableWatermarkCall{Call: call} +} + +// MockBrandingSettingsRepositorySetDisableWatermarkCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetDisableWatermarkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetDisableWatermarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetDisableWatermarkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetDisableWatermarkCall) Do(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetDisableWatermarkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetDisableWatermarkCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetDisableWatermarkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetErrorMsgPopup mocks base method. +func (m *MockBrandingSettingsRepository) SetErrorMsgPopup(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetErrorMsgPopup", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetErrorMsgPopup indicates an expected call of SetErrorMsgPopup. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetErrorMsgPopup(value any) *MockBrandingSettingsRepositorySetErrorMsgPopupCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetErrorMsgPopup", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetErrorMsgPopup), value) + return &MockBrandingSettingsRepositorySetErrorMsgPopupCall{Call: call} +} + +// MockBrandingSettingsRepositorySetErrorMsgPopupCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetErrorMsgPopupCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetErrorMsgPopupCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetErrorMsgPopupCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetErrorMsgPopupCall) Do(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetErrorMsgPopupCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetErrorMsgPopupCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetErrorMsgPopupCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetFontColorDark mocks base method. +func (m *MockBrandingSettingsRepository) SetFontColorDark(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetFontColorDark", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetFontColorDark indicates an expected call of SetFontColorDark. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetFontColorDark(value any) *MockBrandingSettingsRepositorySetFontColorDarkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFontColorDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetFontColorDark), value) + return &MockBrandingSettingsRepositorySetFontColorDarkCall{Call: call} +} + +// MockBrandingSettingsRepositorySetFontColorDarkCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetFontColorDarkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetFontColorDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorDarkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetFontColorDarkCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorDarkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetFontColorDarkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorDarkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetFontColorLight mocks base method. +func (m *MockBrandingSettingsRepository) SetFontColorLight(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetFontColorLight", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetFontColorLight indicates an expected call of SetFontColorLight. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetFontColorLight(value any) *MockBrandingSettingsRepositorySetFontColorLightCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFontColorLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetFontColorLight), value) + return &MockBrandingSettingsRepositorySetFontColorLightCall{Call: call} +} + +// MockBrandingSettingsRepositorySetFontColorLightCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetFontColorLightCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetFontColorLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorLightCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetFontColorLightCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorLightCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetFontColorLightCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontColorLightCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetFontURL mocks base method. +func (m *MockBrandingSettingsRepository) SetFontURL(value url.URL) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetFontURL", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetFontURL indicates an expected call of SetFontURL. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetFontURL(value any) *MockBrandingSettingsRepositorySetFontURLCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFontURL", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetFontURL), value) + return &MockBrandingSettingsRepositorySetFontURLCall{Call: call} +} + +// MockBrandingSettingsRepositorySetFontURLCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetFontURLCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetFontURLCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetFontURLCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetFontURLCall) Do(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontURLCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetFontURLCall) DoAndReturn(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetFontURLCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetHideLoginNameSuffix mocks base method. +func (m *MockBrandingSettingsRepository) SetHideLoginNameSuffix(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHideLoginNameSuffix", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetHideLoginNameSuffix indicates an expected call of SetHideLoginNameSuffix. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetHideLoginNameSuffix(value any) *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHideLoginNameSuffix", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetHideLoginNameSuffix), value) + return &MockBrandingSettingsRepositorySetHideLoginNameSuffixCall{Call: call} +} + +// MockBrandingSettingsRepositorySetHideLoginNameSuffixCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetHideLoginNameSuffixCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall) Do(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockBrandingSettingsRepositorySetHideLoginNameSuffixCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetIconURLDark mocks base method. +func (m *MockBrandingSettingsRepository) SetIconURLDark(value url.URL) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetIconURLDark", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetIconURLDark indicates an expected call of SetIconURLDark. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetIconURLDark(value any) *MockBrandingSettingsRepositorySetIconURLDarkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIconURLDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetIconURLDark), value) + return &MockBrandingSettingsRepositorySetIconURLDarkCall{Call: call} +} + +// MockBrandingSettingsRepositorySetIconURLDarkCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetIconURLDarkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetIconURLDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLDarkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetIconURLDarkCall) Do(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLDarkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetIconURLDarkCall) DoAndReturn(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLDarkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetIconURLLight mocks base method. +func (m *MockBrandingSettingsRepository) SetIconURLLight(value url.URL) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetIconURLLight", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetIconURLLight indicates an expected call of SetIconURLLight. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetIconURLLight(value any) *MockBrandingSettingsRepositorySetIconURLLightCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIconURLLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetIconURLLight), value) + return &MockBrandingSettingsRepositorySetIconURLLightCall{Call: call} +} + +// MockBrandingSettingsRepositorySetIconURLLightCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetIconURLLightCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetIconURLLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLLightCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetIconURLLightCall) Do(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLLightCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetIconURLLightCall) DoAndReturn(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetIconURLLightCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetLogoURLDark mocks base method. +func (m *MockBrandingSettingsRepository) SetLogoURLDark(value url.URL) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetLogoURLDark", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetLogoURLDark indicates an expected call of SetLogoURLDark. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetLogoURLDark(value any) *MockBrandingSettingsRepositorySetLogoURLDarkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogoURLDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetLogoURLDark), value) + return &MockBrandingSettingsRepositorySetLogoURLDarkCall{Call: call} +} + +// MockBrandingSettingsRepositorySetLogoURLDarkCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetLogoURLDarkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetLogoURLDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLDarkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetLogoURLDarkCall) Do(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLDarkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetLogoURLDarkCall) DoAndReturn(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLDarkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetLogoURLLight mocks base method. +func (m *MockBrandingSettingsRepository) SetLogoURLLight(value url.URL) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetLogoURLLight", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetLogoURLLight indicates an expected call of SetLogoURLLight. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetLogoURLLight(value any) *MockBrandingSettingsRepositorySetLogoURLLightCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogoURLLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetLogoURLLight), value) + return &MockBrandingSettingsRepositorySetLogoURLLightCall{Call: call} +} + +// MockBrandingSettingsRepositorySetLogoURLLightCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetLogoURLLightCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetLogoURLLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLLightCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetLogoURLLightCall) Do(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLLightCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetLogoURLLightCall) DoAndReturn(f func(url.URL) json.JsonUpdate) *MockBrandingSettingsRepositorySetLogoURLLightCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetPrimaryColorDark mocks base method. +func (m *MockBrandingSettingsRepository) SetPrimaryColorDark(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetPrimaryColorDark", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetPrimaryColorDark indicates an expected call of SetPrimaryColorDark. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetPrimaryColorDark(value any) *MockBrandingSettingsRepositorySetPrimaryColorDarkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPrimaryColorDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetPrimaryColorDark), value) + return &MockBrandingSettingsRepositorySetPrimaryColorDarkCall{Call: call} +} + +// MockBrandingSettingsRepositorySetPrimaryColorDarkCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetPrimaryColorDarkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetPrimaryColorDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorDarkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetPrimaryColorDarkCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorDarkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetPrimaryColorDarkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorDarkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetPrimaryColorLight mocks base method. +func (m *MockBrandingSettingsRepository) SetPrimaryColorLight(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetPrimaryColorLight", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetPrimaryColorLight indicates an expected call of SetPrimaryColorLight. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetPrimaryColorLight(value any) *MockBrandingSettingsRepositorySetPrimaryColorLightCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPrimaryColorLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetPrimaryColorLight), value) + return &MockBrandingSettingsRepositorySetPrimaryColorLightCall{Call: call} +} + +// MockBrandingSettingsRepositorySetPrimaryColorLightCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetPrimaryColorLightCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetPrimaryColorLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorLightCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetPrimaryColorLightCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorLightCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetPrimaryColorLightCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetPrimaryColorLightCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSettingFields mocks base method. +func (m *MockBrandingSettingsRepository) SetSettingFields(value domain.BrandingSettingsAttributes) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSettingFields", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSettingFields indicates an expected call of SetSettingFields. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockBrandingSettingsRepositorySetSettingFieldsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetSettingFields), value) + return &MockBrandingSettingsRepositorySetSettingFieldsCall{Call: call} +} + +// MockBrandingSettingsRepositorySetSettingFieldsCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetSettingFieldsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockBrandingSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetSettingFieldsCall) Do(f func(domain.BrandingSettingsAttributes) database.Change) *MockBrandingSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.BrandingSettingsAttributes) database.Change) *MockBrandingSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetThemeMode mocks base method. +func (m *MockBrandingSettingsRepository) SetThemeMode(value domain.BrandingPolicyThemeMode) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetThemeMode", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetThemeMode indicates an expected call of SetThemeMode. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetThemeMode(value any) *MockBrandingSettingsRepositorySetThemeModeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetThemeMode", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetThemeMode), value) + return &MockBrandingSettingsRepositorySetThemeModeCall{Call: call} +} + +// MockBrandingSettingsRepositorySetThemeModeCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetThemeModeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetThemeModeCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetThemeModeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetThemeModeCall) Do(f func(domain.BrandingPolicyThemeMode) json.JsonUpdate) *MockBrandingSettingsRepositorySetThemeModeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetThemeModeCall) DoAndReturn(f func(domain.BrandingPolicyThemeMode) json.JsonUpdate) *MockBrandingSettingsRepositorySetThemeModeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockBrandingSettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUpdatedAt indicates an expected call of SetUpdatedAt. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockBrandingSettingsRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetUpdatedAt), updatedAt) + return &MockBrandingSettingsRepositorySetUpdatedAtCall{Call: call} +} + +// MockBrandingSettingsRepositorySetUpdatedAtCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockBrandingSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockBrandingSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockBrandingSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetWarnColorDark mocks base method. +func (m *MockBrandingSettingsRepository) SetWarnColorDark(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetWarnColorDark", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetWarnColorDark indicates an expected call of SetWarnColorDark. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetWarnColorDark(value any) *MockBrandingSettingsRepositorySetWarnColorDarkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWarnColorDark", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetWarnColorDark), value) + return &MockBrandingSettingsRepositorySetWarnColorDarkCall{Call: call} +} + +// MockBrandingSettingsRepositorySetWarnColorDarkCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetWarnColorDarkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetWarnColorDarkCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorDarkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetWarnColorDarkCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorDarkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetWarnColorDarkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorDarkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetWarnColorLight mocks base method. +func (m *MockBrandingSettingsRepository) SetWarnColorLight(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetWarnColorLight", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetWarnColorLight indicates an expected call of SetWarnColorLight. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SetWarnColorLight(value any) *MockBrandingSettingsRepositorySetWarnColorLightCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWarnColorLight", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SetWarnColorLight), value) + return &MockBrandingSettingsRepositorySetWarnColorLightCall{Call: call} +} + +// MockBrandingSettingsRepositorySetWarnColorLightCall wrap *gomock.Call +type MockBrandingSettingsRepositorySetWarnColorLightCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySetWarnColorLightCall) Return(arg0 json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorLightCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySetWarnColorLightCall) Do(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorLightCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySetWarnColorLightCall) DoAndReturn(f func(string) json.JsonUpdate) *MockBrandingSettingsRepositorySetWarnColorLightCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SettingsColumn mocks base method. +func (m *MockBrandingSettingsRepository) SettingsColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SettingsColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// SettingsColumn indicates an expected call of SettingsColumn. +func (mr *MockBrandingSettingsRepositoryMockRecorder) SettingsColumn() *MockBrandingSettingsRepositorySettingsColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).SettingsColumn)) + return &MockBrandingSettingsRepositorySettingsColumnCall{Call: call} +} + +// MockBrandingSettingsRepositorySettingsColumnCall wrap *gomock.Call +type MockBrandingSettingsRepositorySettingsColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositorySettingsColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockBrandingSettingsRepository) StateColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// StateColumn indicates an expected call of StateColumn. +func (mr *MockBrandingSettingsRepositoryMockRecorder) StateColumn() *MockBrandingSettingsRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).StateColumn)) + return &MockBrandingSettingsRepositoryStateColumnCall{Call: call} +} + +// MockBrandingSettingsRepositoryStateColumnCall wrap *gomock.Call +type MockBrandingSettingsRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateCondition mocks base method. +func (m *MockBrandingSettingsRepository) StateCondition(typ domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateCondition", typ) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// StateCondition indicates an expected call of StateCondition. +func (mr *MockBrandingSettingsRepositoryMockRecorder) StateCondition(typ any) *MockBrandingSettingsRepositoryStateConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).StateCondition), typ) + return &MockBrandingSettingsRepositoryStateConditionCall{Call: call} +} + +// MockBrandingSettingsRepositoryStateConditionCall wrap *gomock.Call +type MockBrandingSettingsRepositoryStateConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryStateConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryStateConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryStateConditionCall) Do(f func(domain.SettingState) database.Condition) *MockBrandingSettingsRepositoryStateConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryStateConditionCall) DoAndReturn(f func(domain.SettingState) database.Condition) *MockBrandingSettingsRepositoryStateConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeColumn mocks base method. +func (m *MockBrandingSettingsRepository) TypeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TypeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TypeColumn indicates an expected call of TypeColumn. +func (mr *MockBrandingSettingsRepositoryMockRecorder) TypeColumn() *MockBrandingSettingsRepositoryTypeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).TypeColumn)) + return &MockBrandingSettingsRepositoryTypeColumnCall{Call: call} +} + +// MockBrandingSettingsRepositoryTypeColumnCall wrap *gomock.Call +type MockBrandingSettingsRepositoryTypeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryTypeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueColumns mocks base method. +func (m *MockBrandingSettingsRepository) UniqueColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// UniqueColumns indicates an expected call of UniqueColumns. +func (mr *MockBrandingSettingsRepositoryMockRecorder) UniqueColumns() *MockBrandingSettingsRepositoryUniqueColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).UniqueColumns)) + return &MockBrandingSettingsRepositoryUniqueColumnsCall{Call: call} +} + +// MockBrandingSettingsRepositoryUniqueColumnsCall wrap *gomock.Call +type MockBrandingSettingsRepositoryUniqueColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockBrandingSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockBrandingSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockBrandingSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueCondition mocks base method. +func (m *MockBrandingSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UniqueCondition indicates an expected call of UniqueCondition. +func (mr *MockBrandingSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockBrandingSettingsRepositoryUniqueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state) + return &MockBrandingSettingsRepositoryUniqueConditionCall{Call: call} +} + +// MockBrandingSettingsRepositoryUniqueConditionCall wrap *gomock.Call +type MockBrandingSettingsRepositoryUniqueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockBrandingSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockBrandingSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockBrandingSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockBrandingSettingsRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockBrandingSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockBrandingSettingsRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockBrandingSettingsRepository)(nil).UpdatedAtColumn)) + return &MockBrandingSettingsRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockBrandingSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockBrandingSettingsRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBrandingSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockBrandingSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBrandingSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockBrandingSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBrandingSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockBrandingSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/domain_settings.mock.go b/backend/v3/domain/mock/domain_settings.mock.go new file mode 100644 index 000000000..771bc9ecc --- /dev/null +++ b/backend/v3/domain/mock/domain_settings.mock.go @@ -0,0 +1,970 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: DomainSettingsRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/domain_settings.mock.go . DomainSettingsRepository +// + +// Package domainmock is a generated GoMock package. +package domainmock + +import ( + context "context" + reflect "reflect" + time "time" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + json "github.com/zitadel/zitadel/backend/v3/storage/database/json" + gomock "go.uber.org/mock/gomock" +) + +// MockDomainSettingsRepository is a mock of DomainSettingsRepository interface. +type MockDomainSettingsRepository struct { + ctrl *gomock.Controller + recorder *MockDomainSettingsRepositoryMockRecorder + isgomock struct{} +} + +// MockDomainSettingsRepositoryMockRecorder is the mock recorder for MockDomainSettingsRepository. +type MockDomainSettingsRepositoryMockRecorder struct { + mock *MockDomainSettingsRepository +} + +// NewMockDomainSettingsRepository creates a new mock instance. +func NewMockDomainSettingsRepository(ctrl *gomock.Controller) *MockDomainSettingsRepository { + mock := &MockDomainSettingsRepository{ctrl: ctrl} + mock.recorder = &MockDomainSettingsRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockDomainSettingsRepository) EXPECT() *MockDomainSettingsRepositoryMockRecorder { + return m.recorder +} + +// CreatedAtColumn mocks base method. +func (m *MockDomainSettingsRepository) CreatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// CreatedAtColumn indicates an expected call of CreatedAtColumn. +func (mr *MockDomainSettingsRepositoryMockRecorder) CreatedAtColumn() *MockDomainSettingsRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).CreatedAtColumn)) + return &MockDomainSettingsRepositoryCreatedAtColumnCall{Call: call} +} + +// MockDomainSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockDomainSettingsRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockDomainSettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockDomainSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockDomainSettingsRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockDomainSettingsRepository)(nil).Delete), ctx, client, condition) + return &MockDomainSettingsRepositoryDeleteCall{Call: call} +} + +// MockDomainSettingsRepositoryDeleteCall wrap *gomock.Call +type MockDomainSettingsRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockDomainSettingsRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockDomainSettingsRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockDomainSettingsRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockDomainSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.DomainSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.DomainSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockDomainSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockDomainSettingsRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockDomainSettingsRepository)(nil).Get), varargs...) + return &MockDomainSettingsRepositoryGetCall{Call: call} +} + +// MockDomainSettingsRepositoryGetCall wrap *gomock.Call +type MockDomainSettingsRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryGetCall) Return(arg0 *domain.DomainSettings, arg1 error) *MockDomainSettingsRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.DomainSettings, error)) *MockDomainSettingsRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.DomainSettings, error)) *MockDomainSettingsRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockDomainSettingsRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockDomainSettingsRepositoryMockRecorder) IDColumn() *MockDomainSettingsRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).IDColumn)) + return &MockDomainSettingsRepositoryIDColumnCall{Call: call} +} + +// MockDomainSettingsRepositoryIDColumnCall wrap *gomock.Call +type MockDomainSettingsRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockDomainSettingsRepository) IDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockDomainSettingsRepositoryMockRecorder) IDCondition(id any) *MockDomainSettingsRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).IDCondition), id) + return &MockDomainSettingsRepositoryIDConditionCall{Call: call} +} + +// MockDomainSettingsRepositoryIDConditionCall wrap *gomock.Call +type MockDomainSettingsRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockDomainSettingsRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockDomainSettingsRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockDomainSettingsRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockDomainSettingsRepositoryMockRecorder) InstanceIDColumn() *MockDomainSettingsRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).InstanceIDColumn)) + return &MockDomainSettingsRepositoryInstanceIDColumnCall{Call: call} +} + +// MockDomainSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockDomainSettingsRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockDomainSettingsRepository) InstanceIDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// InstanceIDCondition indicates an expected call of InstanceIDCondition. +func (mr *MockDomainSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockDomainSettingsRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).InstanceIDCondition), id) + return &MockDomainSettingsRepositoryInstanceIDConditionCall{Call: call} +} + +// MockDomainSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockDomainSettingsRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockDomainSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockDomainSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockDomainSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.DomainSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.DomainSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockDomainSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockDomainSettingsRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockDomainSettingsRepository)(nil).List), varargs...) + return &MockDomainSettingsRepositoryListCall{Call: call} +} + +// MockDomainSettingsRepositoryListCall wrap *gomock.Call +type MockDomainSettingsRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryListCall) Return(arg0 []*domain.DomainSettings, arg1 error) *MockDomainSettingsRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.DomainSettings, error)) *MockDomainSettingsRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.DomainSettings, error)) *MockDomainSettingsRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDColumn mocks base method. +func (m *MockDomainSettingsRepository) OrganizationIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// OrganizationIDColumn indicates an expected call of OrganizationIDColumn. +func (mr *MockDomainSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockDomainSettingsRepositoryOrganizationIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).OrganizationIDColumn)) + return &MockDomainSettingsRepositoryOrganizationIDColumnCall{Call: call} +} + +// MockDomainSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call +type MockDomainSettingsRepositoryOrganizationIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDCondition mocks base method. +func (m *MockDomainSettingsRepository) OrganizationIDCondition(id *string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// OrganizationIDCondition indicates an expected call of OrganizationIDCondition. +func (mr *MockDomainSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockDomainSettingsRepositoryOrganizationIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).OrganizationIDCondition), id) + return &MockDomainSettingsRepositoryOrganizationIDConditionCall{Call: call} +} + +// MockDomainSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call +type MockDomainSettingsRepositoryOrganizationIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockDomainSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockDomainSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockDomainSettingsRepository) PrimaryKeyColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns. +func (mr *MockDomainSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockDomainSettingsRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockDomainSettingsRepository)(nil).PrimaryKeyColumns)) + return &MockDomainSettingsRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockDomainSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockDomainSettingsRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockDomainSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockDomainSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockDomainSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockDomainSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockDomainSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockDomainSettingsRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id) + return &MockDomainSettingsRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockDomainSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockDomainSettingsRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockDomainSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockDomainSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Set mocks base method. +func (m *MockDomainSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.DomainSettings) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, client, settings) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockDomainSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockDomainSettingsRepositorySetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockDomainSettingsRepository)(nil).Set), ctx, client, settings) + return &MockDomainSettingsRepositorySetCall{Call: call} +} + +// MockDomainSettingsRepositorySetCall wrap *gomock.Call +type MockDomainSettingsRepositorySetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositorySetCall) Return(arg0 error) *MockDomainSettingsRepositorySetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.DomainSettings) error) *MockDomainSettingsRepositorySetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.DomainSettings) error) *MockDomainSettingsRepositorySetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetLoginNameIncludesDomain mocks base method. +func (m *MockDomainSettingsRepository) SetLoginNameIncludesDomain(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetLoginNameIncludesDomain", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetLoginNameIncludesDomain indicates an expected call of SetLoginNameIncludesDomain. +func (mr *MockDomainSettingsRepositoryMockRecorder) SetLoginNameIncludesDomain(value any) *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLoginNameIncludesDomain", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetLoginNameIncludesDomain), value) + return &MockDomainSettingsRepositorySetLoginNameIncludesDomainCall{Call: call} +} + +// MockDomainSettingsRepositorySetLoginNameIncludesDomainCall wrap *gomock.Call +type MockDomainSettingsRepositorySetLoginNameIncludesDomainCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall) Return(arg0 json.JsonUpdate) *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall) Do(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetLoginNameIncludesDomainCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetRequireOrgDomainVerification mocks base method. +func (m *MockDomainSettingsRepository) SetRequireOrgDomainVerification(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRequireOrgDomainVerification", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetRequireOrgDomainVerification indicates an expected call of SetRequireOrgDomainVerification. +func (mr *MockDomainSettingsRepositoryMockRecorder) SetRequireOrgDomainVerification(value any) *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRequireOrgDomainVerification", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetRequireOrgDomainVerification), value) + return &MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall{Call: call} +} + +// MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall wrap *gomock.Call +type MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall) Return(arg0 json.JsonUpdate) *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall) Do(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetRequireOrgDomainVerificationCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSMTPSenderAddressMatchesInstanceDomain mocks base method. +func (m *MockDomainSettingsRepository) SetSMTPSenderAddressMatchesInstanceDomain(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSMTPSenderAddressMatchesInstanceDomain", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetSMTPSenderAddressMatchesInstanceDomain indicates an expected call of SetSMTPSenderAddressMatchesInstanceDomain. +func (mr *MockDomainSettingsRepositoryMockRecorder) SetSMTPSenderAddressMatchesInstanceDomain(value any) *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSMTPSenderAddressMatchesInstanceDomain", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetSMTPSenderAddressMatchesInstanceDomain), value) + return &MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall{Call: call} +} + +// MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall wrap *gomock.Call +type MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall) Return(arg0 json.JsonUpdate) *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall) Do(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockDomainSettingsRepositorySetSMTPSenderAddressMatchesInstanceDomainCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSettingFields mocks base method. +func (m *MockDomainSettingsRepository) SetSettingFields(value domain.DomainSettingsAttributes) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSettingFields", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSettingFields indicates an expected call of SetSettingFields. +func (mr *MockDomainSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockDomainSettingsRepositorySetSettingFieldsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetSettingFields), value) + return &MockDomainSettingsRepositorySetSettingFieldsCall{Call: call} +} + +// MockDomainSettingsRepositorySetSettingFieldsCall wrap *gomock.Call +type MockDomainSettingsRepositorySetSettingFieldsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockDomainSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositorySetSettingFieldsCall) Do(f func(domain.DomainSettingsAttributes) database.Change) *MockDomainSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.DomainSettingsAttributes) database.Change) *MockDomainSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockDomainSettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUpdatedAt indicates an expected call of SetUpdatedAt. +func (mr *MockDomainSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockDomainSettingsRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SetUpdatedAt), updatedAt) + return &MockDomainSettingsRepositorySetUpdatedAtCall{Call: call} +} + +// MockDomainSettingsRepositorySetUpdatedAtCall wrap *gomock.Call +type MockDomainSettingsRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockDomainSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockDomainSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockDomainSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SettingsColumn mocks base method. +func (m *MockDomainSettingsRepository) SettingsColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SettingsColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// SettingsColumn indicates an expected call of SettingsColumn. +func (mr *MockDomainSettingsRepositoryMockRecorder) SettingsColumn() *MockDomainSettingsRepositorySettingsColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).SettingsColumn)) + return &MockDomainSettingsRepositorySettingsColumnCall{Call: call} +} + +// MockDomainSettingsRepositorySettingsColumnCall wrap *gomock.Call +type MockDomainSettingsRepositorySettingsColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositorySettingsColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockDomainSettingsRepository) StateColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// StateColumn indicates an expected call of StateColumn. +func (mr *MockDomainSettingsRepositoryMockRecorder) StateColumn() *MockDomainSettingsRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).StateColumn)) + return &MockDomainSettingsRepositoryStateColumnCall{Call: call} +} + +// MockDomainSettingsRepositoryStateColumnCall wrap *gomock.Call +type MockDomainSettingsRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeColumn mocks base method. +func (m *MockDomainSettingsRepository) TypeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TypeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TypeColumn indicates an expected call of TypeColumn. +func (mr *MockDomainSettingsRepositoryMockRecorder) TypeColumn() *MockDomainSettingsRepositoryTypeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).TypeColumn)) + return &MockDomainSettingsRepositoryTypeColumnCall{Call: call} +} + +// MockDomainSettingsRepositoryTypeColumnCall wrap *gomock.Call +type MockDomainSettingsRepositoryTypeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryTypeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueColumns mocks base method. +func (m *MockDomainSettingsRepository) UniqueColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// UniqueColumns indicates an expected call of UniqueColumns. +func (mr *MockDomainSettingsRepositoryMockRecorder) UniqueColumns() *MockDomainSettingsRepositoryUniqueColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockDomainSettingsRepository)(nil).UniqueColumns)) + return &MockDomainSettingsRepositoryUniqueColumnsCall{Call: call} +} + +// MockDomainSettingsRepositoryUniqueColumnsCall wrap *gomock.Call +type MockDomainSettingsRepositoryUniqueColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockDomainSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockDomainSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockDomainSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueCondition mocks base method. +func (m *MockDomainSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UniqueCondition indicates an expected call of UniqueCondition. +func (mr *MockDomainSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockDomainSettingsRepositoryUniqueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockDomainSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state) + return &MockDomainSettingsRepositoryUniqueConditionCall{Call: call} +} + +// MockDomainSettingsRepositoryUniqueConditionCall wrap *gomock.Call +type MockDomainSettingsRepositoryUniqueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockDomainSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockDomainSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockDomainSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockDomainSettingsRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockDomainSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockDomainSettingsRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockDomainSettingsRepository)(nil).UpdatedAtColumn)) + return &MockDomainSettingsRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockDomainSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockDomainSettingsRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockDomainSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockDomainSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockDomainSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockDomainSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockDomainSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockDomainSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/human_repo.go b/backend/v3/domain/mock/human_repo.go new file mode 100644 index 000000000..fd9eee125 --- /dev/null +++ b/backend/v3/domain/mock/human_repo.go @@ -0,0 +1,31 @@ +package domainmock + +import ( + context "context" + + gomock "go.uber.org/mock/gomock" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + "github.com/zitadel/zitadel/backend/v3/storage/database/repository" +) + +func NewHumanRepo(ctrl *gomock.Controller) *HumanRepo { + return &HumanRepo{ + mock: NewMockHumanUserRepository(ctrl), + HumanUserRepository: repository.HumanUserRepository(), + } +} + +type HumanRepo struct { + domain.HumanUserRepository + mock *MockHumanUserRepository +} + +func (u *HumanRepo) EXPECT() *MockHumanUserRepositoryMockRecorder { + return u.mock.EXPECT() +} + +func (u *HumanRepo) Update(ctx context.Context, client database.QueryExecutor, condition database.Condition, changes ...database.Change) (int64, error) { + return u.mock.Update(ctx, client, condition, changes...) +} diff --git a/backend/v3/domain/mock/legal_and_support_settings.mock.go b/backend/v3/domain/mock/legal_and_support_settings.mock.go new file mode 100644 index 000000000..afcf006c1 --- /dev/null +++ b/backend/v3/domain/mock/legal_and_support_settings.mock.go @@ -0,0 +1,1122 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: LegalAndSupportSettingsRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/legal_and_support_settings.mock.go . LegalAndSupportSettingsRepository +// + +// Package domainmock is a generated GoMock package. +package domainmock + +import ( + context "context" + reflect "reflect" + time "time" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + json "github.com/zitadel/zitadel/backend/v3/storage/database/json" + gomock "go.uber.org/mock/gomock" +) + +// MockLegalAndSupportSettingsRepository is a mock of LegalAndSupportSettingsRepository interface. +type MockLegalAndSupportSettingsRepository struct { + ctrl *gomock.Controller + recorder *MockLegalAndSupportSettingsRepositoryMockRecorder + isgomock struct{} +} + +// MockLegalAndSupportSettingsRepositoryMockRecorder is the mock recorder for MockLegalAndSupportSettingsRepository. +type MockLegalAndSupportSettingsRepositoryMockRecorder struct { + mock *MockLegalAndSupportSettingsRepository +} + +// NewMockLegalAndSupportSettingsRepository creates a new mock instance. +func NewMockLegalAndSupportSettingsRepository(ctrl *gomock.Controller) *MockLegalAndSupportSettingsRepository { + mock := &MockLegalAndSupportSettingsRepository{ctrl: ctrl} + mock.recorder = &MockLegalAndSupportSettingsRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockLegalAndSupportSettingsRepository) EXPECT() *MockLegalAndSupportSettingsRepositoryMockRecorder { + return m.recorder +} + +// CreatedAtColumn mocks base method. +func (m *MockLegalAndSupportSettingsRepository) CreatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// CreatedAtColumn indicates an expected call of CreatedAtColumn. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) CreatedAtColumn() *MockLegalAndSupportSettingsRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).CreatedAtColumn)) + return &MockLegalAndSupportSettingsRepositoryCreatedAtColumnCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockLegalAndSupportSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockLegalAndSupportSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockLegalAndSupportSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockLegalAndSupportSettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockLegalAndSupportSettingsRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).Delete), ctx, client, condition) + return &MockLegalAndSupportSettingsRepositoryDeleteCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryDeleteCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockLegalAndSupportSettingsRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockLegalAndSupportSettingsRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockLegalAndSupportSettingsRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockLegalAndSupportSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.LegalAndSupportSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.LegalAndSupportSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockLegalAndSupportSettingsRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).Get), varargs...) + return &MockLegalAndSupportSettingsRepositoryGetCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryGetCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryGetCall) Return(arg0 *domain.LegalAndSupportSettings, arg1 error) *MockLegalAndSupportSettingsRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.LegalAndSupportSettings, error)) *MockLegalAndSupportSettingsRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.LegalAndSupportSettings, error)) *MockLegalAndSupportSettingsRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockLegalAndSupportSettingsRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) IDColumn() *MockLegalAndSupportSettingsRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).IDColumn)) + return &MockLegalAndSupportSettingsRepositoryIDColumnCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryIDColumnCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockLegalAndSupportSettingsRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockLegalAndSupportSettingsRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockLegalAndSupportSettingsRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockLegalAndSupportSettingsRepository) IDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) IDCondition(id any) *MockLegalAndSupportSettingsRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).IDCondition), id) + return &MockLegalAndSupportSettingsRepositoryIDConditionCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryIDConditionCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockLegalAndSupportSettingsRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockLegalAndSupportSettingsRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockLegalAndSupportSettingsRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockLegalAndSupportSettingsRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) InstanceIDColumn() *MockLegalAndSupportSettingsRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).InstanceIDColumn)) + return &MockLegalAndSupportSettingsRepositoryInstanceIDColumnCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockLegalAndSupportSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockLegalAndSupportSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockLegalAndSupportSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockLegalAndSupportSettingsRepository) InstanceIDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// InstanceIDCondition indicates an expected call of InstanceIDCondition. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockLegalAndSupportSettingsRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).InstanceIDCondition), id) + return &MockLegalAndSupportSettingsRepositoryInstanceIDConditionCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockLegalAndSupportSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockLegalAndSupportSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockLegalAndSupportSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockLegalAndSupportSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.LegalAndSupportSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.LegalAndSupportSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockLegalAndSupportSettingsRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).List), varargs...) + return &MockLegalAndSupportSettingsRepositoryListCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryListCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryListCall) Return(arg0 []*domain.LegalAndSupportSettings, arg1 error) *MockLegalAndSupportSettingsRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.LegalAndSupportSettings, error)) *MockLegalAndSupportSettingsRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.LegalAndSupportSettings, error)) *MockLegalAndSupportSettingsRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDColumn mocks base method. +func (m *MockLegalAndSupportSettingsRepository) OrganizationIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// OrganizationIDColumn indicates an expected call of OrganizationIDColumn. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockLegalAndSupportSettingsRepositoryOrganizationIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).OrganizationIDColumn)) + return &MockLegalAndSupportSettingsRepositoryOrganizationIDColumnCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryOrganizationIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockLegalAndSupportSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockLegalAndSupportSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockLegalAndSupportSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDCondition mocks base method. +func (m *MockLegalAndSupportSettingsRepository) OrganizationIDCondition(id *string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// OrganizationIDCondition indicates an expected call of OrganizationIDCondition. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockLegalAndSupportSettingsRepositoryOrganizationIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).OrganizationIDCondition), id) + return &MockLegalAndSupportSettingsRepositoryOrganizationIDConditionCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryOrganizationIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockLegalAndSupportSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockLegalAndSupportSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockLegalAndSupportSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockLegalAndSupportSettingsRepository) PrimaryKeyColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockLegalAndSupportSettingsRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).PrimaryKeyColumns)) + return &MockLegalAndSupportSettingsRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockLegalAndSupportSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockLegalAndSupportSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockLegalAndSupportSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockLegalAndSupportSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockLegalAndSupportSettingsRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id) + return &MockLegalAndSupportSettingsRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockLegalAndSupportSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockLegalAndSupportSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockLegalAndSupportSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Set mocks base method. +func (m *MockLegalAndSupportSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.LegalAndSupportSettings) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, client, settings) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockLegalAndSupportSettingsRepositorySetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).Set), ctx, client, settings) + return &MockLegalAndSupportSettingsRepositorySetCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySetCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySetCall) Return(arg0 error) *MockLegalAndSupportSettingsRepositorySetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.LegalAndSupportSettings) error) *MockLegalAndSupportSettingsRepositorySetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.LegalAndSupportSettings) error) *MockLegalAndSupportSettingsRepositorySetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetCustomLink mocks base method. +func (m *MockLegalAndSupportSettingsRepository) SetCustomLink(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetCustomLink", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetCustomLink indicates an expected call of SetCustomLink. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) SetCustomLink(value any) *MockLegalAndSupportSettingsRepositorySetCustomLinkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCustomLink", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).SetCustomLink), value) + return &MockLegalAndSupportSettingsRepositorySetCustomLinkCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySetCustomLinkCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySetCustomLinkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySetCustomLinkCall) Return(arg0 json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetCustomLinkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySetCustomLinkCall) Do(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetCustomLinkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySetCustomLinkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetCustomLinkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetCustomLinkText mocks base method. +func (m *MockLegalAndSupportSettingsRepository) SetCustomLinkText(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetCustomLinkText", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetCustomLinkText indicates an expected call of SetCustomLinkText. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) SetCustomLinkText(value any) *MockLegalAndSupportSettingsRepositorySetCustomLinkTextCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCustomLinkText", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).SetCustomLinkText), value) + return &MockLegalAndSupportSettingsRepositorySetCustomLinkTextCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySetCustomLinkTextCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySetCustomLinkTextCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySetCustomLinkTextCall) Return(arg0 json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetCustomLinkTextCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySetCustomLinkTextCall) Do(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetCustomLinkTextCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySetCustomLinkTextCall) DoAndReturn(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetCustomLinkTextCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetDocsLink mocks base method. +func (m *MockLegalAndSupportSettingsRepository) SetDocsLink(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDocsLink", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetDocsLink indicates an expected call of SetDocsLink. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) SetDocsLink(value any) *MockLegalAndSupportSettingsRepositorySetDocsLinkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDocsLink", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).SetDocsLink), value) + return &MockLegalAndSupportSettingsRepositorySetDocsLinkCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySetDocsLinkCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySetDocsLinkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySetDocsLinkCall) Return(arg0 json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetDocsLinkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySetDocsLinkCall) Do(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetDocsLinkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySetDocsLinkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetDocsLinkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetHelpLink mocks base method. +func (m *MockLegalAndSupportSettingsRepository) SetHelpLink(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHelpLink", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetHelpLink indicates an expected call of SetHelpLink. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) SetHelpLink(value any) *MockLegalAndSupportSettingsRepositorySetHelpLinkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHelpLink", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).SetHelpLink), value) + return &MockLegalAndSupportSettingsRepositorySetHelpLinkCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySetHelpLinkCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySetHelpLinkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySetHelpLinkCall) Return(arg0 json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetHelpLinkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySetHelpLinkCall) Do(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetHelpLinkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySetHelpLinkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetHelpLinkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetPrivacyPolicyLink mocks base method. +func (m *MockLegalAndSupportSettingsRepository) SetPrivacyPolicyLink(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetPrivacyPolicyLink", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetPrivacyPolicyLink indicates an expected call of SetPrivacyPolicyLink. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) SetPrivacyPolicyLink(value any) *MockLegalAndSupportSettingsRepositorySetPrivacyPolicyLinkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPrivacyPolicyLink", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).SetPrivacyPolicyLink), value) + return &MockLegalAndSupportSettingsRepositorySetPrivacyPolicyLinkCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySetPrivacyPolicyLinkCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySetPrivacyPolicyLinkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySetPrivacyPolicyLinkCall) Return(arg0 json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetPrivacyPolicyLinkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySetPrivacyPolicyLinkCall) Do(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetPrivacyPolicyLinkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySetPrivacyPolicyLinkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetPrivacyPolicyLinkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSettingFields mocks base method. +func (m *MockLegalAndSupportSettingsRepository) SetSettingFields(value domain.LegalAndSupportSettingsAttributes) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSettingFields", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSettingFields indicates an expected call of SetSettingFields. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockLegalAndSupportSettingsRepositorySetSettingFieldsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).SetSettingFields), value) + return &MockLegalAndSupportSettingsRepositorySetSettingFieldsCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySetSettingFieldsCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySetSettingFieldsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockLegalAndSupportSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySetSettingFieldsCall) Do(f func(domain.LegalAndSupportSettingsAttributes) database.Change) *MockLegalAndSupportSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.LegalAndSupportSettingsAttributes) database.Change) *MockLegalAndSupportSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSupportEmail mocks base method. +func (m *MockLegalAndSupportSettingsRepository) SetSupportEmail(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSupportEmail", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetSupportEmail indicates an expected call of SetSupportEmail. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) SetSupportEmail(value any) *MockLegalAndSupportSettingsRepositorySetSupportEmailCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSupportEmail", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).SetSupportEmail), value) + return &MockLegalAndSupportSettingsRepositorySetSupportEmailCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySetSupportEmailCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySetSupportEmailCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySetSupportEmailCall) Return(arg0 json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetSupportEmailCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySetSupportEmailCall) Do(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetSupportEmailCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySetSupportEmailCall) DoAndReturn(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetSupportEmailCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetTOSLink mocks base method. +func (m *MockLegalAndSupportSettingsRepository) SetTOSLink(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetTOSLink", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetTOSLink indicates an expected call of SetTOSLink. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) SetTOSLink(value any) *MockLegalAndSupportSettingsRepositorySetTOSLinkCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetTOSLink", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).SetTOSLink), value) + return &MockLegalAndSupportSettingsRepositorySetTOSLinkCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySetTOSLinkCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySetTOSLinkCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySetTOSLinkCall) Return(arg0 json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetTOSLinkCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySetTOSLinkCall) Do(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetTOSLinkCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySetTOSLinkCall) DoAndReturn(f func(string) json.JsonUpdate) *MockLegalAndSupportSettingsRepositorySetTOSLinkCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockLegalAndSupportSettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUpdatedAt indicates an expected call of SetUpdatedAt. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockLegalAndSupportSettingsRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).SetUpdatedAt), updatedAt) + return &MockLegalAndSupportSettingsRepositorySetUpdatedAtCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySetUpdatedAtCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockLegalAndSupportSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockLegalAndSupportSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockLegalAndSupportSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SettingsColumn mocks base method. +func (m *MockLegalAndSupportSettingsRepository) SettingsColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SettingsColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// SettingsColumn indicates an expected call of SettingsColumn. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) SettingsColumn() *MockLegalAndSupportSettingsRepositorySettingsColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).SettingsColumn)) + return &MockLegalAndSupportSettingsRepositorySettingsColumnCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositorySettingsColumnCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositorySettingsColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockLegalAndSupportSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockLegalAndSupportSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockLegalAndSupportSettingsRepositorySettingsColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockLegalAndSupportSettingsRepository) StateColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// StateColumn indicates an expected call of StateColumn. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) StateColumn() *MockLegalAndSupportSettingsRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).StateColumn)) + return &MockLegalAndSupportSettingsRepositoryStateColumnCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryStateColumnCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockLegalAndSupportSettingsRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockLegalAndSupportSettingsRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockLegalAndSupportSettingsRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeColumn mocks base method. +func (m *MockLegalAndSupportSettingsRepository) TypeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TypeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TypeColumn indicates an expected call of TypeColumn. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) TypeColumn() *MockLegalAndSupportSettingsRepositoryTypeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).TypeColumn)) + return &MockLegalAndSupportSettingsRepositoryTypeColumnCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryTypeColumnCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryTypeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockLegalAndSupportSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockLegalAndSupportSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockLegalAndSupportSettingsRepositoryTypeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueColumns mocks base method. +func (m *MockLegalAndSupportSettingsRepository) UniqueColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// UniqueColumns indicates an expected call of UniqueColumns. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) UniqueColumns() *MockLegalAndSupportSettingsRepositoryUniqueColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).UniqueColumns)) + return &MockLegalAndSupportSettingsRepositoryUniqueColumnsCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryUniqueColumnsCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryUniqueColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockLegalAndSupportSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockLegalAndSupportSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockLegalAndSupportSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueCondition mocks base method. +func (m *MockLegalAndSupportSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UniqueCondition indicates an expected call of UniqueCondition. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockLegalAndSupportSettingsRepositoryUniqueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state) + return &MockLegalAndSupportSettingsRepositoryUniqueConditionCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryUniqueConditionCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryUniqueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockLegalAndSupportSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockLegalAndSupportSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockLegalAndSupportSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockLegalAndSupportSettingsRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockLegalAndSupportSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockLegalAndSupportSettingsRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockLegalAndSupportSettingsRepository)(nil).UpdatedAtColumn)) + return &MockLegalAndSupportSettingsRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockLegalAndSupportSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockLegalAndSupportSettingsRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLegalAndSupportSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockLegalAndSupportSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLegalAndSupportSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockLegalAndSupportSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLegalAndSupportSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockLegalAndSupportSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/lockout_settings.mock.go b/backend/v3/domain/mock/lockout_settings.mock.go new file mode 100644 index 000000000..5b7bedaf3 --- /dev/null +++ b/backend/v3/domain/mock/lockout_settings.mock.go @@ -0,0 +1,970 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: LockoutSettingsRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/lockout_settings.mock.go . LockoutSettingsRepository +// + +// Package domainmock is a generated GoMock package. +package domainmock + +import ( + context "context" + reflect "reflect" + time "time" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + json "github.com/zitadel/zitadel/backend/v3/storage/database/json" + gomock "go.uber.org/mock/gomock" +) + +// MockLockoutSettingsRepository is a mock of LockoutSettingsRepository interface. +type MockLockoutSettingsRepository struct { + ctrl *gomock.Controller + recorder *MockLockoutSettingsRepositoryMockRecorder + isgomock struct{} +} + +// MockLockoutSettingsRepositoryMockRecorder is the mock recorder for MockLockoutSettingsRepository. +type MockLockoutSettingsRepositoryMockRecorder struct { + mock *MockLockoutSettingsRepository +} + +// NewMockLockoutSettingsRepository creates a new mock instance. +func NewMockLockoutSettingsRepository(ctrl *gomock.Controller) *MockLockoutSettingsRepository { + mock := &MockLockoutSettingsRepository{ctrl: ctrl} + mock.recorder = &MockLockoutSettingsRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockLockoutSettingsRepository) EXPECT() *MockLockoutSettingsRepositoryMockRecorder { + return m.recorder +} + +// CreatedAtColumn mocks base method. +func (m *MockLockoutSettingsRepository) CreatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// CreatedAtColumn indicates an expected call of CreatedAtColumn. +func (mr *MockLockoutSettingsRepositoryMockRecorder) CreatedAtColumn() *MockLockoutSettingsRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).CreatedAtColumn)) + return &MockLockoutSettingsRepositoryCreatedAtColumnCall{Call: call} +} + +// MockLockoutSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockLockoutSettingsRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockLockoutSettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockLockoutSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockLockoutSettingsRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).Delete), ctx, client, condition) + return &MockLockoutSettingsRepositoryDeleteCall{Call: call} +} + +// MockLockoutSettingsRepositoryDeleteCall wrap *gomock.Call +type MockLockoutSettingsRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockLockoutSettingsRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockLockoutSettingsRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockLockoutSettingsRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockLockoutSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.LockoutSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.LockoutSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockLockoutSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockLockoutSettingsRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).Get), varargs...) + return &MockLockoutSettingsRepositoryGetCall{Call: call} +} + +// MockLockoutSettingsRepositoryGetCall wrap *gomock.Call +type MockLockoutSettingsRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryGetCall) Return(arg0 *domain.LockoutSettings, arg1 error) *MockLockoutSettingsRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.LockoutSettings, error)) *MockLockoutSettingsRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.LockoutSettings, error)) *MockLockoutSettingsRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockLockoutSettingsRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockLockoutSettingsRepositoryMockRecorder) IDColumn() *MockLockoutSettingsRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).IDColumn)) + return &MockLockoutSettingsRepositoryIDColumnCall{Call: call} +} + +// MockLockoutSettingsRepositoryIDColumnCall wrap *gomock.Call +type MockLockoutSettingsRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockLockoutSettingsRepository) IDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockLockoutSettingsRepositoryMockRecorder) IDCondition(id any) *MockLockoutSettingsRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).IDCondition), id) + return &MockLockoutSettingsRepositoryIDConditionCall{Call: call} +} + +// MockLockoutSettingsRepositoryIDConditionCall wrap *gomock.Call +type MockLockoutSettingsRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockLockoutSettingsRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockLockoutSettingsRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockLockoutSettingsRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockLockoutSettingsRepositoryMockRecorder) InstanceIDColumn() *MockLockoutSettingsRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).InstanceIDColumn)) + return &MockLockoutSettingsRepositoryInstanceIDColumnCall{Call: call} +} + +// MockLockoutSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockLockoutSettingsRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockLockoutSettingsRepository) InstanceIDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// InstanceIDCondition indicates an expected call of InstanceIDCondition. +func (mr *MockLockoutSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockLockoutSettingsRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).InstanceIDCondition), id) + return &MockLockoutSettingsRepositoryInstanceIDConditionCall{Call: call} +} + +// MockLockoutSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockLockoutSettingsRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockLockoutSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockLockoutSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockLockoutSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.LockoutSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.LockoutSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockLockoutSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockLockoutSettingsRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).List), varargs...) + return &MockLockoutSettingsRepositoryListCall{Call: call} +} + +// MockLockoutSettingsRepositoryListCall wrap *gomock.Call +type MockLockoutSettingsRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryListCall) Return(arg0 []*domain.LockoutSettings, arg1 error) *MockLockoutSettingsRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.LockoutSettings, error)) *MockLockoutSettingsRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.LockoutSettings, error)) *MockLockoutSettingsRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDColumn mocks base method. +func (m *MockLockoutSettingsRepository) OrganizationIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// OrganizationIDColumn indicates an expected call of OrganizationIDColumn. +func (mr *MockLockoutSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockLockoutSettingsRepositoryOrganizationIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).OrganizationIDColumn)) + return &MockLockoutSettingsRepositoryOrganizationIDColumnCall{Call: call} +} + +// MockLockoutSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call +type MockLockoutSettingsRepositoryOrganizationIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDCondition mocks base method. +func (m *MockLockoutSettingsRepository) OrganizationIDCondition(id *string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// OrganizationIDCondition indicates an expected call of OrganizationIDCondition. +func (mr *MockLockoutSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockLockoutSettingsRepositoryOrganizationIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).OrganizationIDCondition), id) + return &MockLockoutSettingsRepositoryOrganizationIDConditionCall{Call: call} +} + +// MockLockoutSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call +type MockLockoutSettingsRepositoryOrganizationIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockLockoutSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockLockoutSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockLockoutSettingsRepository) PrimaryKeyColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns. +func (mr *MockLockoutSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).PrimaryKeyColumns)) + return &MockLockoutSettingsRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockLockoutSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockLockoutSettingsRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockLockoutSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockLockoutSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockLockoutSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockLockoutSettingsRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id) + return &MockLockoutSettingsRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockLockoutSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockLockoutSettingsRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockLockoutSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockLockoutSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Set mocks base method. +func (m *MockLockoutSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.LockoutSettings) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, client, settings) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockLockoutSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockLockoutSettingsRepositorySetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).Set), ctx, client, settings) + return &MockLockoutSettingsRepositorySetCall{Call: call} +} + +// MockLockoutSettingsRepositorySetCall wrap *gomock.Call +type MockLockoutSettingsRepositorySetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositorySetCall) Return(arg0 error) *MockLockoutSettingsRepositorySetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.LockoutSettings) error) *MockLockoutSettingsRepositorySetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.LockoutSettings) error) *MockLockoutSettingsRepositorySetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetMaxOTPAttempts mocks base method. +func (m *MockLockoutSettingsRepository) SetMaxOTPAttempts(value uint64) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetMaxOTPAttempts", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetMaxOTPAttempts indicates an expected call of SetMaxOTPAttempts. +func (mr *MockLockoutSettingsRepositoryMockRecorder) SetMaxOTPAttempts(value any) *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxOTPAttempts", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SetMaxOTPAttempts), value) + return &MockLockoutSettingsRepositorySetMaxOTPAttemptsCall{Call: call} +} + +// MockLockoutSettingsRepositorySetMaxOTPAttemptsCall wrap *gomock.Call +type MockLockoutSettingsRepositorySetMaxOTPAttemptsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall) Return(arg0 json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall) Do(f func(uint64) json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall) DoAndReturn(f func(uint64) json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxOTPAttemptsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetMaxPasswordAttempts mocks base method. +func (m *MockLockoutSettingsRepository) SetMaxPasswordAttempts(value uint64) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetMaxPasswordAttempts", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetMaxPasswordAttempts indicates an expected call of SetMaxPasswordAttempts. +func (mr *MockLockoutSettingsRepositoryMockRecorder) SetMaxPasswordAttempts(value any) *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxPasswordAttempts", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SetMaxPasswordAttempts), value) + return &MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall{Call: call} +} + +// MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall wrap *gomock.Call +type MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall) Return(arg0 json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall) Do(f func(uint64) json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall) DoAndReturn(f func(uint64) json.JsonUpdate) *MockLockoutSettingsRepositorySetMaxPasswordAttemptsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSettingFields mocks base method. +func (m *MockLockoutSettingsRepository) SetSettingFields(value domain.LockoutSettingsAttributes) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSettingFields", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSettingFields indicates an expected call of SetSettingFields. +func (mr *MockLockoutSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockLockoutSettingsRepositorySetSettingFieldsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SetSettingFields), value) + return &MockLockoutSettingsRepositorySetSettingFieldsCall{Call: call} +} + +// MockLockoutSettingsRepositorySetSettingFieldsCall wrap *gomock.Call +type MockLockoutSettingsRepositorySetSettingFieldsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockLockoutSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositorySetSettingFieldsCall) Do(f func(domain.LockoutSettingsAttributes) database.Change) *MockLockoutSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.LockoutSettingsAttributes) database.Change) *MockLockoutSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetShowLockOutFailures mocks base method. +func (m *MockLockoutSettingsRepository) SetShowLockOutFailures(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetShowLockOutFailures", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetShowLockOutFailures indicates an expected call of SetShowLockOutFailures. +func (mr *MockLockoutSettingsRepositoryMockRecorder) SetShowLockOutFailures(value any) *MockLockoutSettingsRepositorySetShowLockOutFailuresCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetShowLockOutFailures", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SetShowLockOutFailures), value) + return &MockLockoutSettingsRepositorySetShowLockOutFailuresCall{Call: call} +} + +// MockLockoutSettingsRepositorySetShowLockOutFailuresCall wrap *gomock.Call +type MockLockoutSettingsRepositorySetShowLockOutFailuresCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositorySetShowLockOutFailuresCall) Return(arg0 json.JsonUpdate) *MockLockoutSettingsRepositorySetShowLockOutFailuresCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositorySetShowLockOutFailuresCall) Do(f func(bool) json.JsonUpdate) *MockLockoutSettingsRepositorySetShowLockOutFailuresCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositorySetShowLockOutFailuresCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLockoutSettingsRepositorySetShowLockOutFailuresCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockLockoutSettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUpdatedAt indicates an expected call of SetUpdatedAt. +func (mr *MockLockoutSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockLockoutSettingsRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SetUpdatedAt), updatedAt) + return &MockLockoutSettingsRepositorySetUpdatedAtCall{Call: call} +} + +// MockLockoutSettingsRepositorySetUpdatedAtCall wrap *gomock.Call +type MockLockoutSettingsRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockLockoutSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockLockoutSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockLockoutSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SettingsColumn mocks base method. +func (m *MockLockoutSettingsRepository) SettingsColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SettingsColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// SettingsColumn indicates an expected call of SettingsColumn. +func (mr *MockLockoutSettingsRepositoryMockRecorder) SettingsColumn() *MockLockoutSettingsRepositorySettingsColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).SettingsColumn)) + return &MockLockoutSettingsRepositorySettingsColumnCall{Call: call} +} + +// MockLockoutSettingsRepositorySettingsColumnCall wrap *gomock.Call +type MockLockoutSettingsRepositorySettingsColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositorySettingsColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockLockoutSettingsRepository) StateColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// StateColumn indicates an expected call of StateColumn. +func (mr *MockLockoutSettingsRepositoryMockRecorder) StateColumn() *MockLockoutSettingsRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).StateColumn)) + return &MockLockoutSettingsRepositoryStateColumnCall{Call: call} +} + +// MockLockoutSettingsRepositoryStateColumnCall wrap *gomock.Call +type MockLockoutSettingsRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeColumn mocks base method. +func (m *MockLockoutSettingsRepository) TypeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TypeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TypeColumn indicates an expected call of TypeColumn. +func (mr *MockLockoutSettingsRepositoryMockRecorder) TypeColumn() *MockLockoutSettingsRepositoryTypeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).TypeColumn)) + return &MockLockoutSettingsRepositoryTypeColumnCall{Call: call} +} + +// MockLockoutSettingsRepositoryTypeColumnCall wrap *gomock.Call +type MockLockoutSettingsRepositoryTypeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryTypeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueColumns mocks base method. +func (m *MockLockoutSettingsRepository) UniqueColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// UniqueColumns indicates an expected call of UniqueColumns. +func (mr *MockLockoutSettingsRepositoryMockRecorder) UniqueColumns() *MockLockoutSettingsRepositoryUniqueColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).UniqueColumns)) + return &MockLockoutSettingsRepositoryUniqueColumnsCall{Call: call} +} + +// MockLockoutSettingsRepositoryUniqueColumnsCall wrap *gomock.Call +type MockLockoutSettingsRepositoryUniqueColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockLockoutSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockLockoutSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockLockoutSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueCondition mocks base method. +func (m *MockLockoutSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UniqueCondition indicates an expected call of UniqueCondition. +func (mr *MockLockoutSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockLockoutSettingsRepositoryUniqueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state) + return &MockLockoutSettingsRepositoryUniqueConditionCall{Call: call} +} + +// MockLockoutSettingsRepositoryUniqueConditionCall wrap *gomock.Call +type MockLockoutSettingsRepositoryUniqueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockLockoutSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockLockoutSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockLockoutSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockLockoutSettingsRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockLockoutSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockLockoutSettingsRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockLockoutSettingsRepository)(nil).UpdatedAtColumn)) + return &MockLockoutSettingsRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockLockoutSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockLockoutSettingsRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLockoutSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockLockoutSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLockoutSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockLockoutSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLockoutSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockLockoutSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/lockout_settings_repo.go b/backend/v3/domain/mock/lockout_settings_repo.go new file mode 100644 index 000000000..f508338bc --- /dev/null +++ b/backend/v3/domain/mock/lockout_settings_repo.go @@ -0,0 +1,48 @@ +package domainmock + +import ( + context "context" + + gomock "go.uber.org/mock/gomock" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + "github.com/zitadel/zitadel/backend/v3/storage/database/repository" +) + +type LockoutSettingsRepo struct { + domain.LockoutSettingsRepository + mock *MockLockoutSettingsRepository +} + +func NewLockoutSettingsRepo(ctrl *gomock.Controller) *LockoutSettingsRepo { + return &LockoutSettingsRepo{ + mock: NewMockLockoutSettingsRepository(ctrl), + LockoutSettingsRepository: repository.LockoutSettingsRepository(), + } +} + +func (lsr *LockoutSettingsRepo) EXPECT() *MockLockoutSettingsRepositoryMockRecorder { + lsr.mock.ctrl.T.Helper() + return lsr.mock.EXPECT() +} + +func (lsr *LockoutSettingsRepo) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.LockoutSettings, error) { + lsr.mock.ctrl.T.Helper() + return lsr.mock.Get(ctx, client, opts...) +} + +func (lsr *LockoutSettingsRepo) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.LockoutSettings, error) { + lsr.mock.ctrl.T.Helper() + return lsr.mock.List(ctx, client, opts...) +} + +func (lsr *LockoutSettingsRepo) Set(ctx context.Context, client database.QueryExecutor, settings *domain.LockoutSettings) error { + lsr.mock.ctrl.T.Helper() + return lsr.mock.Set(ctx, client, settings) +} + +func (lsr *LockoutSettingsRepo) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + lsr.mock.ctrl.T.Helper() + return lsr.mock.Delete(ctx, client, condition) +} diff --git a/backend/v3/domain/mock/login_settings.mock.go b/backend/v3/domain/mock/login_settings.mock.go new file mode 100644 index 000000000..f5c3a66f1 --- /dev/null +++ b/backend/v3/domain/mock/login_settings.mock.go @@ -0,0 +1,1697 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: LoginSettingsRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/login_settings.mock.go . LoginSettingsRepository +// + +// Package domainmock is a generated GoMock package. +package domainmock + +import ( + context "context" + reflect "reflect" + time "time" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + json "github.com/zitadel/zitadel/backend/v3/storage/database/json" + gomock "go.uber.org/mock/gomock" +) + +// MockLoginSettingsRepository is a mock of LoginSettingsRepository interface. +type MockLoginSettingsRepository struct { + ctrl *gomock.Controller + recorder *MockLoginSettingsRepositoryMockRecorder + isgomock struct{} +} + +// MockLoginSettingsRepositoryMockRecorder is the mock recorder for MockLoginSettingsRepository. +type MockLoginSettingsRepositoryMockRecorder struct { + mock *MockLoginSettingsRepository +} + +// NewMockLoginSettingsRepository creates a new mock instance. +func NewMockLoginSettingsRepository(ctrl *gomock.Controller) *MockLoginSettingsRepository { + mock := &MockLoginSettingsRepository{ctrl: ctrl} + mock.recorder = &MockLoginSettingsRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockLoginSettingsRepository) EXPECT() *MockLoginSettingsRepositoryMockRecorder { + return m.recorder +} + +// AddMFAType mocks base method. +func (m *MockLoginSettingsRepository) AddMFAType(value domain.MultiFactorType) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddMFAType", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// AddMFAType indicates an expected call of AddMFAType. +func (mr *MockLoginSettingsRepositoryMockRecorder) AddMFAType(value any) *MockLoginSettingsRepositoryAddMFATypeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddMFAType", reflect.TypeOf((*MockLoginSettingsRepository)(nil).AddMFAType), value) + return &MockLoginSettingsRepositoryAddMFATypeCall{Call: call} +} + +// MockLoginSettingsRepositoryAddMFATypeCall wrap *gomock.Call +type MockLoginSettingsRepositoryAddMFATypeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryAddMFATypeCall) Return(arg0 database.Change) *MockLoginSettingsRepositoryAddMFATypeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryAddMFATypeCall) Do(f func(domain.MultiFactorType) database.Change) *MockLoginSettingsRepositoryAddMFATypeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryAddMFATypeCall) DoAndReturn(f func(domain.MultiFactorType) database.Change) *MockLoginSettingsRepositoryAddMFATypeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// AddSecondFactorTypes mocks base method. +func (m *MockLoginSettingsRepository) AddSecondFactorTypes(value domain.SecondFactorType) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddSecondFactorTypes", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// AddSecondFactorTypes indicates an expected call of AddSecondFactorTypes. +func (mr *MockLoginSettingsRepositoryMockRecorder) AddSecondFactorTypes(value any) *MockLoginSettingsRepositoryAddSecondFactorTypesCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSecondFactorTypes", reflect.TypeOf((*MockLoginSettingsRepository)(nil).AddSecondFactorTypes), value) + return &MockLoginSettingsRepositoryAddSecondFactorTypesCall{Call: call} +} + +// MockLoginSettingsRepositoryAddSecondFactorTypesCall wrap *gomock.Call +type MockLoginSettingsRepositoryAddSecondFactorTypesCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryAddSecondFactorTypesCall) Return(arg0 database.Change) *MockLoginSettingsRepositoryAddSecondFactorTypesCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryAddSecondFactorTypesCall) Do(f func(domain.SecondFactorType) database.Change) *MockLoginSettingsRepositoryAddSecondFactorTypesCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryAddSecondFactorTypesCall) DoAndReturn(f func(domain.SecondFactorType) database.Change) *MockLoginSettingsRepositoryAddSecondFactorTypesCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreatedAtColumn mocks base method. +func (m *MockLoginSettingsRepository) CreatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// CreatedAtColumn indicates an expected call of CreatedAtColumn. +func (mr *MockLoginSettingsRepositoryMockRecorder) CreatedAtColumn() *MockLoginSettingsRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).CreatedAtColumn)) + return &MockLoginSettingsRepositoryCreatedAtColumnCall{Call: call} +} + +// MockLoginSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockLoginSettingsRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockLoginSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockLoginSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockLoginSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockLoginSettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockLoginSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockLoginSettingsRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLoginSettingsRepository)(nil).Delete), ctx, client, condition) + return &MockLoginSettingsRepositoryDeleteCall{Call: call} +} + +// MockLoginSettingsRepositoryDeleteCall wrap *gomock.Call +type MockLoginSettingsRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockLoginSettingsRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockLoginSettingsRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockLoginSettingsRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockLoginSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.LoginSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.LoginSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockLoginSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockLoginSettingsRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLoginSettingsRepository)(nil).Get), varargs...) + return &MockLoginSettingsRepositoryGetCall{Call: call} +} + +// MockLoginSettingsRepositoryGetCall wrap *gomock.Call +type MockLoginSettingsRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryGetCall) Return(arg0 *domain.LoginSettings, arg1 error) *MockLoginSettingsRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.LoginSettings, error)) *MockLoginSettingsRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.LoginSettings, error)) *MockLoginSettingsRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockLoginSettingsRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockLoginSettingsRepositoryMockRecorder) IDColumn() *MockLoginSettingsRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).IDColumn)) + return &MockLoginSettingsRepositoryIDColumnCall{Call: call} +} + +// MockLoginSettingsRepositoryIDColumnCall wrap *gomock.Call +type MockLoginSettingsRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockLoginSettingsRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockLoginSettingsRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockLoginSettingsRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockLoginSettingsRepository) IDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockLoginSettingsRepositoryMockRecorder) IDCondition(id any) *MockLoginSettingsRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).IDCondition), id) + return &MockLoginSettingsRepositoryIDConditionCall{Call: call} +} + +// MockLoginSettingsRepositoryIDConditionCall wrap *gomock.Call +type MockLoginSettingsRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockLoginSettingsRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockLoginSettingsRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockLoginSettingsRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockLoginSettingsRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockLoginSettingsRepositoryMockRecorder) InstanceIDColumn() *MockLoginSettingsRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).InstanceIDColumn)) + return &MockLoginSettingsRepositoryInstanceIDColumnCall{Call: call} +} + +// MockLoginSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockLoginSettingsRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockLoginSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockLoginSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockLoginSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockLoginSettingsRepository) InstanceIDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// InstanceIDCondition indicates an expected call of InstanceIDCondition. +func (mr *MockLoginSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockLoginSettingsRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).InstanceIDCondition), id) + return &MockLoginSettingsRepositoryInstanceIDConditionCall{Call: call} +} + +// MockLoginSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockLoginSettingsRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockLoginSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockLoginSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockLoginSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockLoginSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.LoginSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.LoginSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockLoginSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockLoginSettingsRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLoginSettingsRepository)(nil).List), varargs...) + return &MockLoginSettingsRepositoryListCall{Call: call} +} + +// MockLoginSettingsRepositoryListCall wrap *gomock.Call +type MockLoginSettingsRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryListCall) Return(arg0 []*domain.LoginSettings, arg1 error) *MockLoginSettingsRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.LoginSettings, error)) *MockLoginSettingsRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.LoginSettings, error)) *MockLoginSettingsRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDColumn mocks base method. +func (m *MockLoginSettingsRepository) OrganizationIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// OrganizationIDColumn indicates an expected call of OrganizationIDColumn. +func (mr *MockLoginSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockLoginSettingsRepositoryOrganizationIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).OrganizationIDColumn)) + return &MockLoginSettingsRepositoryOrganizationIDColumnCall{Call: call} +} + +// MockLoginSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call +type MockLoginSettingsRepositoryOrganizationIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockLoginSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockLoginSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockLoginSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDCondition mocks base method. +func (m *MockLoginSettingsRepository) OrganizationIDCondition(id *string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// OrganizationIDCondition indicates an expected call of OrganizationIDCondition. +func (mr *MockLoginSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockLoginSettingsRepositoryOrganizationIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).OrganizationIDCondition), id) + return &MockLoginSettingsRepositoryOrganizationIDConditionCall{Call: call} +} + +// MockLoginSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call +type MockLoginSettingsRepositoryOrganizationIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockLoginSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockLoginSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockLoginSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockLoginSettingsRepository) PrimaryKeyColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns. +func (mr *MockLoginSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockLoginSettingsRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockLoginSettingsRepository)(nil).PrimaryKeyColumns)) + return &MockLoginSettingsRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockLoginSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockLoginSettingsRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockLoginSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockLoginSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockLoginSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockLoginSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockLoginSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockLoginSettingsRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id) + return &MockLoginSettingsRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockLoginSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockLoginSettingsRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockLoginSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockLoginSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockLoginSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveMFAType mocks base method. +func (m *MockLoginSettingsRepository) RemoveMFAType(value domain.MultiFactorType) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveMFAType", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// RemoveMFAType indicates an expected call of RemoveMFAType. +func (mr *MockLoginSettingsRepositoryMockRecorder) RemoveMFAType(value any) *MockLoginSettingsRepositoryRemoveMFATypeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveMFAType", reflect.TypeOf((*MockLoginSettingsRepository)(nil).RemoveMFAType), value) + return &MockLoginSettingsRepositoryRemoveMFATypeCall{Call: call} +} + +// MockLoginSettingsRepositoryRemoveMFATypeCall wrap *gomock.Call +type MockLoginSettingsRepositoryRemoveMFATypeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryRemoveMFATypeCall) Return(arg0 database.Change) *MockLoginSettingsRepositoryRemoveMFATypeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryRemoveMFATypeCall) Do(f func(domain.MultiFactorType) database.Change) *MockLoginSettingsRepositoryRemoveMFATypeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryRemoveMFATypeCall) DoAndReturn(f func(domain.MultiFactorType) database.Change) *MockLoginSettingsRepositoryRemoveMFATypeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RemoveSecondFactorTypes mocks base method. +func (m *MockLoginSettingsRepository) RemoveSecondFactorTypes(value domain.SecondFactorType) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RemoveSecondFactorTypes", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// RemoveSecondFactorTypes indicates an expected call of RemoveSecondFactorTypes. +func (mr *MockLoginSettingsRepositoryMockRecorder) RemoveSecondFactorTypes(value any) *MockLoginSettingsRepositoryRemoveSecondFactorTypesCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveSecondFactorTypes", reflect.TypeOf((*MockLoginSettingsRepository)(nil).RemoveSecondFactorTypes), value) + return &MockLoginSettingsRepositoryRemoveSecondFactorTypesCall{Call: call} +} + +// MockLoginSettingsRepositoryRemoveSecondFactorTypesCall wrap *gomock.Call +type MockLoginSettingsRepositoryRemoveSecondFactorTypesCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryRemoveSecondFactorTypesCall) Return(arg0 database.Change) *MockLoginSettingsRepositoryRemoveSecondFactorTypesCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryRemoveSecondFactorTypesCall) Do(f func(domain.SecondFactorType) database.Change) *MockLoginSettingsRepositoryRemoveSecondFactorTypesCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryRemoveSecondFactorTypesCall) DoAndReturn(f func(domain.SecondFactorType) database.Change) *MockLoginSettingsRepositoryRemoveSecondFactorTypesCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Set mocks base method. +func (m *MockLoginSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.LoginSettings) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, client, settings) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockLoginSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockLoginSettingsRepositorySetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockLoginSettingsRepository)(nil).Set), ctx, client, settings) + return &MockLoginSettingsRepositorySetCall{Call: call} +} + +// MockLoginSettingsRepositorySetCall wrap *gomock.Call +type MockLoginSettingsRepositorySetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetCall) Return(arg0 error) *MockLoginSettingsRepositorySetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.LoginSettings) error) *MockLoginSettingsRepositorySetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.LoginSettings) error) *MockLoginSettingsRepositorySetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetAllowDomainDiscovery mocks base method. +func (m *MockLoginSettingsRepository) SetAllowDomainDiscovery(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetAllowDomainDiscovery", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetAllowDomainDiscovery indicates an expected call of SetAllowDomainDiscovery. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetAllowDomainDiscovery(value any) *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowDomainDiscovery", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetAllowDomainDiscovery), value) + return &MockLoginSettingsRepositorySetAllowDomainDiscoveryCall{Call: call} +} + +// MockLoginSettingsRepositorySetAllowDomainDiscoveryCall wrap *gomock.Call +type MockLoginSettingsRepositorySetAllowDomainDiscoveryCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowDomainDiscoveryCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetAllowExternalIDP mocks base method. +func (m *MockLoginSettingsRepository) SetAllowExternalIDP(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetAllowExternalIDP", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetAllowExternalIDP indicates an expected call of SetAllowExternalIDP. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetAllowExternalIDP(value any) *MockLoginSettingsRepositorySetAllowExternalIDPCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowExternalIDP", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetAllowExternalIDP), value) + return &MockLoginSettingsRepositorySetAllowExternalIDPCall{Call: call} +} + +// MockLoginSettingsRepositorySetAllowExternalIDPCall wrap *gomock.Call +type MockLoginSettingsRepositorySetAllowExternalIDPCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetAllowExternalIDPCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetAllowExternalIDPCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetAllowExternalIDPCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowExternalIDPCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetAllowExternalIDPCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowExternalIDPCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetAllowRegister mocks base method. +func (m *MockLoginSettingsRepository) SetAllowRegister(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetAllowRegister", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetAllowRegister indicates an expected call of SetAllowRegister. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetAllowRegister(value any) *MockLoginSettingsRepositorySetAllowRegisterCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowRegister", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetAllowRegister), value) + return &MockLoginSettingsRepositorySetAllowRegisterCall{Call: call} +} + +// MockLoginSettingsRepositorySetAllowRegisterCall wrap *gomock.Call +type MockLoginSettingsRepositorySetAllowRegisterCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetAllowRegisterCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetAllowRegisterCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetAllowRegisterCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowRegisterCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetAllowRegisterCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowRegisterCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetAllowUserNamePassword mocks base method. +func (m *MockLoginSettingsRepository) SetAllowUserNamePassword(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetAllowUserNamePassword", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetAllowUserNamePassword indicates an expected call of SetAllowUserNamePassword. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetAllowUserNamePassword(value any) *MockLoginSettingsRepositorySetAllowUserNamePasswordCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowUserNamePassword", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetAllowUserNamePassword), value) + return &MockLoginSettingsRepositorySetAllowUserNamePasswordCall{Call: call} +} + +// MockLoginSettingsRepositorySetAllowUserNamePasswordCall wrap *gomock.Call +type MockLoginSettingsRepositorySetAllowUserNamePasswordCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetAllowUserNamePasswordCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetAllowUserNamePasswordCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetAllowUserNamePasswordCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowUserNamePasswordCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetAllowUserNamePasswordCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetAllowUserNamePasswordCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetColumns mocks base method. +func (m *MockLoginSettingsRepository) SetColumns(ctx context.Context, client database.QueryExecutor, settings *domain.Settings, changes ...database.Change) error { + m.ctrl.T.Helper() + varargs := []any{ctx, client, settings} + for _, a := range changes { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetColumns", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetColumns indicates an expected call of SetColumns. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetColumns(ctx, client, settings any, changes ...any) *MockLoginSettingsRepositorySetColumnsCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client, settings}, changes...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetColumns", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetColumns), varargs...) + return &MockLoginSettingsRepositorySetColumnsCall{Call: call} +} + +// MockLoginSettingsRepositorySetColumnsCall wrap *gomock.Call +type MockLoginSettingsRepositorySetColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetColumnsCall) Return(arg0 error) *MockLoginSettingsRepositorySetColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetColumnsCall) Do(f func(context.Context, database.QueryExecutor, *domain.Settings, ...database.Change) error) *MockLoginSettingsRepositorySetColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetColumnsCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.Settings, ...database.Change) error) *MockLoginSettingsRepositorySetColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetDefaultRedirectURI mocks base method. +func (m *MockLoginSettingsRepository) SetDefaultRedirectURI(value string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDefaultRedirectURI", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetDefaultRedirectURI indicates an expected call of SetDefaultRedirectURI. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetDefaultRedirectURI(value any) *MockLoginSettingsRepositorySetDefaultRedirectURICall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDefaultRedirectURI", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetDefaultRedirectURI), value) + return &MockLoginSettingsRepositorySetDefaultRedirectURICall{Call: call} +} + +// MockLoginSettingsRepositorySetDefaultRedirectURICall wrap *gomock.Call +type MockLoginSettingsRepositorySetDefaultRedirectURICall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetDefaultRedirectURICall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetDefaultRedirectURICall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetDefaultRedirectURICall) Do(f func(string) json.JsonUpdate) *MockLoginSettingsRepositorySetDefaultRedirectURICall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetDefaultRedirectURICall) DoAndReturn(f func(string) json.JsonUpdate) *MockLoginSettingsRepositorySetDefaultRedirectURICall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetDisableLoginWithEmail mocks base method. +func (m *MockLoginSettingsRepository) SetDisableLoginWithEmail(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDisableLoginWithEmail", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetDisableLoginWithEmail indicates an expected call of SetDisableLoginWithEmail. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetDisableLoginWithEmail(value any) *MockLoginSettingsRepositorySetDisableLoginWithEmailCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDisableLoginWithEmail", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetDisableLoginWithEmail), value) + return &MockLoginSettingsRepositorySetDisableLoginWithEmailCall{Call: call} +} + +// MockLoginSettingsRepositorySetDisableLoginWithEmailCall wrap *gomock.Call +type MockLoginSettingsRepositorySetDisableLoginWithEmailCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetDisableLoginWithEmailCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithEmailCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetDisableLoginWithEmailCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithEmailCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetDisableLoginWithEmailCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithEmailCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetDisableLoginWithPhone mocks base method. +func (m *MockLoginSettingsRepository) SetDisableLoginWithPhone(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDisableLoginWithPhone", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetDisableLoginWithPhone indicates an expected call of SetDisableLoginWithPhone. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetDisableLoginWithPhone(value any) *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDisableLoginWithPhone", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetDisableLoginWithPhone), value) + return &MockLoginSettingsRepositorySetDisableLoginWithPhoneCall{Call: call} +} + +// MockLoginSettingsRepositorySetDisableLoginWithPhoneCall wrap *gomock.Call +type MockLoginSettingsRepositorySetDisableLoginWithPhoneCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetDisableLoginWithPhoneCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetExternalLoginCheckLifetime mocks base method. +func (m *MockLoginSettingsRepository) SetExternalLoginCheckLifetime(value time.Duration) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetExternalLoginCheckLifetime", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetExternalLoginCheckLifetime indicates an expected call of SetExternalLoginCheckLifetime. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetExternalLoginCheckLifetime(value any) *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExternalLoginCheckLifetime", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetExternalLoginCheckLifetime), value) + return &MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall{Call: call} +} + +// MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall wrap *gomock.Call +type MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall) Do(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall) DoAndReturn(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetExternalLoginCheckLifetimeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetForceMFA mocks base method. +func (m *MockLoginSettingsRepository) SetForceMFA(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetForceMFA", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetForceMFA indicates an expected call of SetForceMFA. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetForceMFA(value any) *MockLoginSettingsRepositorySetForceMFACall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetForceMFA", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetForceMFA), value) + return &MockLoginSettingsRepositorySetForceMFACall{Call: call} +} + +// MockLoginSettingsRepositorySetForceMFACall wrap *gomock.Call +type MockLoginSettingsRepositorySetForceMFACall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetForceMFACall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFACall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetForceMFACall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFACall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetForceMFACall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFACall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetForceMFALocalOnly mocks base method. +func (m *MockLoginSettingsRepository) SetForceMFALocalOnly(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetForceMFALocalOnly", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetForceMFALocalOnly indicates an expected call of SetForceMFALocalOnly. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetForceMFALocalOnly(value any) *MockLoginSettingsRepositorySetForceMFALocalOnlyCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetForceMFALocalOnly", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetForceMFALocalOnly), value) + return &MockLoginSettingsRepositorySetForceMFALocalOnlyCall{Call: call} +} + +// MockLoginSettingsRepositorySetForceMFALocalOnlyCall wrap *gomock.Call +type MockLoginSettingsRepositorySetForceMFALocalOnlyCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetForceMFALocalOnlyCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFALocalOnlyCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetForceMFALocalOnlyCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFALocalOnlyCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetForceMFALocalOnlyCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetForceMFALocalOnlyCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetHidePasswordReset mocks base method. +func (m *MockLoginSettingsRepository) SetHidePasswordReset(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHidePasswordReset", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetHidePasswordReset indicates an expected call of SetHidePasswordReset. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetHidePasswordReset(value any) *MockLoginSettingsRepositorySetHidePasswordResetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHidePasswordReset", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetHidePasswordReset), value) + return &MockLoginSettingsRepositorySetHidePasswordResetCall{Call: call} +} + +// MockLoginSettingsRepositorySetHidePasswordResetCall wrap *gomock.Call +type MockLoginSettingsRepositorySetHidePasswordResetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetHidePasswordResetCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetHidePasswordResetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetHidePasswordResetCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetHidePasswordResetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetHidePasswordResetCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetHidePasswordResetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetIgnoreUnknownUsernames mocks base method. +func (m *MockLoginSettingsRepository) SetIgnoreUnknownUsernames(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetIgnoreUnknownUsernames", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetIgnoreUnknownUsernames indicates an expected call of SetIgnoreUnknownUsernames. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetIgnoreUnknownUsernames(value any) *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIgnoreUnknownUsernames", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetIgnoreUnknownUsernames), value) + return &MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall{Call: call} +} + +// MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall wrap *gomock.Call +type MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall) Do(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockLoginSettingsRepositorySetIgnoreUnknownUsernamesCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetMFAInitSkipLifetime mocks base method. +func (m *MockLoginSettingsRepository) SetMFAInitSkipLifetime(value time.Duration) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetMFAInitSkipLifetime", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetMFAInitSkipLifetime indicates an expected call of SetMFAInitSkipLifetime. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetMFAInitSkipLifetime(value any) *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMFAInitSkipLifetime", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetMFAInitSkipLifetime), value) + return &MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall{Call: call} +} + +// MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall wrap *gomock.Call +type MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall) Do(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall) DoAndReturn(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetMFAInitSkipLifetimeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetMultiFactorCheckLifetime mocks base method. +func (m *MockLoginSettingsRepository) SetMultiFactorCheckLifetime(value time.Duration) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetMultiFactorCheckLifetime", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetMultiFactorCheckLifetime indicates an expected call of SetMultiFactorCheckLifetime. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetMultiFactorCheckLifetime(value any) *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMultiFactorCheckLifetime", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetMultiFactorCheckLifetime), value) + return &MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall{Call: call} +} + +// MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall wrap *gomock.Call +type MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall) Do(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall) DoAndReturn(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetMultiFactorCheckLifetimeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetPasswordCheckLifetime mocks base method. +func (m *MockLoginSettingsRepository) SetPasswordCheckLifetime(value time.Duration) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetPasswordCheckLifetime", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetPasswordCheckLifetime indicates an expected call of SetPasswordCheckLifetime. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetPasswordCheckLifetime(value any) *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordCheckLifetime", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetPasswordCheckLifetime), value) + return &MockLoginSettingsRepositorySetPasswordCheckLifetimeCall{Call: call} +} + +// MockLoginSettingsRepositorySetPasswordCheckLifetimeCall wrap *gomock.Call +type MockLoginSettingsRepositorySetPasswordCheckLifetimeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall) Do(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall) DoAndReturn(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordCheckLifetimeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetPasswordlessType mocks base method. +func (m *MockLoginSettingsRepository) SetPasswordlessType(value domain.PasswordlessType) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetPasswordlessType", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetPasswordlessType indicates an expected call of SetPasswordlessType. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetPasswordlessType(value any) *MockLoginSettingsRepositorySetPasswordlessTypeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordlessType", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetPasswordlessType), value) + return &MockLoginSettingsRepositorySetPasswordlessTypeCall{Call: call} +} + +// MockLoginSettingsRepositorySetPasswordlessTypeCall wrap *gomock.Call +type MockLoginSettingsRepositorySetPasswordlessTypeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetPasswordlessTypeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordlessTypeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetPasswordlessTypeCall) Do(f func(domain.PasswordlessType) json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordlessTypeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetPasswordlessTypeCall) DoAndReturn(f func(domain.PasswordlessType) json.JsonUpdate) *MockLoginSettingsRepositorySetPasswordlessTypeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSecondFactorCheckLifetime mocks base method. +func (m *MockLoginSettingsRepository) SetSecondFactorCheckLifetime(value time.Duration) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSecondFactorCheckLifetime", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetSecondFactorCheckLifetime indicates an expected call of SetSecondFactorCheckLifetime. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetSecondFactorCheckLifetime(value any) *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecondFactorCheckLifetime", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetSecondFactorCheckLifetime), value) + return &MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall{Call: call} +} + +// MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall wrap *gomock.Call +type MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall) Return(arg0 json.JsonUpdate) *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall) Do(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall) DoAndReturn(f func(time.Duration) json.JsonUpdate) *MockLoginSettingsRepositorySetSecondFactorCheckLifetimeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSettingFields mocks base method. +func (m *MockLoginSettingsRepository) SetSettingFields(value domain.LoginSettingsAttributes) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSettingFields", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSettingFields indicates an expected call of SetSettingFields. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockLoginSettingsRepositorySetSettingFieldsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetSettingFields), value) + return &MockLoginSettingsRepositorySetSettingFieldsCall{Call: call} +} + +// MockLoginSettingsRepositorySetSettingFieldsCall wrap *gomock.Call +type MockLoginSettingsRepositorySetSettingFieldsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockLoginSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetSettingFieldsCall) Do(f func(domain.LoginSettingsAttributes) database.Change) *MockLoginSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.LoginSettingsAttributes) database.Change) *MockLoginSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockLoginSettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUpdatedAt indicates an expected call of SetUpdatedAt. +func (mr *MockLoginSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockLoginSettingsRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SetUpdatedAt), updatedAt) + return &MockLoginSettingsRepositorySetUpdatedAtCall{Call: call} +} + +// MockLoginSettingsRepositorySetUpdatedAtCall wrap *gomock.Call +type MockLoginSettingsRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockLoginSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockLoginSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockLoginSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SettingsColumn mocks base method. +func (m *MockLoginSettingsRepository) SettingsColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SettingsColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// SettingsColumn indicates an expected call of SettingsColumn. +func (mr *MockLoginSettingsRepositoryMockRecorder) SettingsColumn() *MockLoginSettingsRepositorySettingsColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).SettingsColumn)) + return &MockLoginSettingsRepositorySettingsColumnCall{Call: call} +} + +// MockLoginSettingsRepositorySettingsColumnCall wrap *gomock.Call +type MockLoginSettingsRepositorySettingsColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockLoginSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockLoginSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockLoginSettingsRepositorySettingsColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockLoginSettingsRepository) StateColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// StateColumn indicates an expected call of StateColumn. +func (mr *MockLoginSettingsRepositoryMockRecorder) StateColumn() *MockLoginSettingsRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).StateColumn)) + return &MockLoginSettingsRepositoryStateColumnCall{Call: call} +} + +// MockLoginSettingsRepositoryStateColumnCall wrap *gomock.Call +type MockLoginSettingsRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockLoginSettingsRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockLoginSettingsRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockLoginSettingsRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeColumn mocks base method. +func (m *MockLoginSettingsRepository) TypeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TypeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TypeColumn indicates an expected call of TypeColumn. +func (mr *MockLoginSettingsRepositoryMockRecorder) TypeColumn() *MockLoginSettingsRepositoryTypeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).TypeColumn)) + return &MockLoginSettingsRepositoryTypeColumnCall{Call: call} +} + +// MockLoginSettingsRepositoryTypeColumnCall wrap *gomock.Call +type MockLoginSettingsRepositoryTypeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockLoginSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockLoginSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockLoginSettingsRepositoryTypeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueColumns mocks base method. +func (m *MockLoginSettingsRepository) UniqueColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// UniqueColumns indicates an expected call of UniqueColumns. +func (mr *MockLoginSettingsRepositoryMockRecorder) UniqueColumns() *MockLoginSettingsRepositoryUniqueColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockLoginSettingsRepository)(nil).UniqueColumns)) + return &MockLoginSettingsRepositoryUniqueColumnsCall{Call: call} +} + +// MockLoginSettingsRepositoryUniqueColumnsCall wrap *gomock.Call +type MockLoginSettingsRepositoryUniqueColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockLoginSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockLoginSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockLoginSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueCondition mocks base method. +func (m *MockLoginSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UniqueCondition indicates an expected call of UniqueCondition. +func (mr *MockLoginSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockLoginSettingsRepositoryUniqueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockLoginSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state) + return &MockLoginSettingsRepositoryUniqueConditionCall{Call: call} +} + +// MockLoginSettingsRepositoryUniqueConditionCall wrap *gomock.Call +type MockLoginSettingsRepositoryUniqueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockLoginSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockLoginSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockLoginSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockLoginSettingsRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockLoginSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockLoginSettingsRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockLoginSettingsRepository)(nil).UpdatedAtColumn)) + return &MockLoginSettingsRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockLoginSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockLoginSettingsRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockLoginSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockLoginSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockLoginSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockLoginSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockLoginSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockLoginSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/notification_settings.mock.go b/backend/v3/domain/mock/notification_settings.mock.go new file mode 100644 index 000000000..b7447f669 --- /dev/null +++ b/backend/v3/domain/mock/notification_settings.mock.go @@ -0,0 +1,894 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: NotificationSettingsRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/notification_settings.mock.go . NotificationSettingsRepository +// + +// Package domainmock is a generated GoMock package. +package domainmock + +import ( + context "context" + reflect "reflect" + time "time" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + json "github.com/zitadel/zitadel/backend/v3/storage/database/json" + gomock "go.uber.org/mock/gomock" +) + +// MockNotificationSettingsRepository is a mock of NotificationSettingsRepository interface. +type MockNotificationSettingsRepository struct { + ctrl *gomock.Controller + recorder *MockNotificationSettingsRepositoryMockRecorder + isgomock struct{} +} + +// MockNotificationSettingsRepositoryMockRecorder is the mock recorder for MockNotificationSettingsRepository. +type MockNotificationSettingsRepositoryMockRecorder struct { + mock *MockNotificationSettingsRepository +} + +// NewMockNotificationSettingsRepository creates a new mock instance. +func NewMockNotificationSettingsRepository(ctrl *gomock.Controller) *MockNotificationSettingsRepository { + mock := &MockNotificationSettingsRepository{ctrl: ctrl} + mock.recorder = &MockNotificationSettingsRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockNotificationSettingsRepository) EXPECT() *MockNotificationSettingsRepositoryMockRecorder { + return m.recorder +} + +// CreatedAtColumn mocks base method. +func (m *MockNotificationSettingsRepository) CreatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// CreatedAtColumn indicates an expected call of CreatedAtColumn. +func (mr *MockNotificationSettingsRepositoryMockRecorder) CreatedAtColumn() *MockNotificationSettingsRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).CreatedAtColumn)) + return &MockNotificationSettingsRepositoryCreatedAtColumnCall{Call: call} +} + +// MockNotificationSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockNotificationSettingsRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockNotificationSettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockNotificationSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockNotificationSettingsRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).Delete), ctx, client, condition) + return &MockNotificationSettingsRepositoryDeleteCall{Call: call} +} + +// MockNotificationSettingsRepositoryDeleteCall wrap *gomock.Call +type MockNotificationSettingsRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockNotificationSettingsRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockNotificationSettingsRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockNotificationSettingsRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockNotificationSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.NotificationSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.NotificationSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockNotificationSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockNotificationSettingsRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).Get), varargs...) + return &MockNotificationSettingsRepositoryGetCall{Call: call} +} + +// MockNotificationSettingsRepositoryGetCall wrap *gomock.Call +type MockNotificationSettingsRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryGetCall) Return(arg0 *domain.NotificationSettings, arg1 error) *MockNotificationSettingsRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.NotificationSettings, error)) *MockNotificationSettingsRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.NotificationSettings, error)) *MockNotificationSettingsRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockNotificationSettingsRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockNotificationSettingsRepositoryMockRecorder) IDColumn() *MockNotificationSettingsRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).IDColumn)) + return &MockNotificationSettingsRepositoryIDColumnCall{Call: call} +} + +// MockNotificationSettingsRepositoryIDColumnCall wrap *gomock.Call +type MockNotificationSettingsRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockNotificationSettingsRepository) IDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockNotificationSettingsRepositoryMockRecorder) IDCondition(id any) *MockNotificationSettingsRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).IDCondition), id) + return &MockNotificationSettingsRepositoryIDConditionCall{Call: call} +} + +// MockNotificationSettingsRepositoryIDConditionCall wrap *gomock.Call +type MockNotificationSettingsRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockNotificationSettingsRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockNotificationSettingsRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockNotificationSettingsRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockNotificationSettingsRepositoryMockRecorder) InstanceIDColumn() *MockNotificationSettingsRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).InstanceIDColumn)) + return &MockNotificationSettingsRepositoryInstanceIDColumnCall{Call: call} +} + +// MockNotificationSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockNotificationSettingsRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockNotificationSettingsRepository) InstanceIDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// InstanceIDCondition indicates an expected call of InstanceIDCondition. +func (mr *MockNotificationSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockNotificationSettingsRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).InstanceIDCondition), id) + return &MockNotificationSettingsRepositoryInstanceIDConditionCall{Call: call} +} + +// MockNotificationSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockNotificationSettingsRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockNotificationSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockNotificationSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockNotificationSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.NotificationSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.NotificationSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockNotificationSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockNotificationSettingsRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).List), varargs...) + return &MockNotificationSettingsRepositoryListCall{Call: call} +} + +// MockNotificationSettingsRepositoryListCall wrap *gomock.Call +type MockNotificationSettingsRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryListCall) Return(arg0 []*domain.NotificationSettings, arg1 error) *MockNotificationSettingsRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.NotificationSettings, error)) *MockNotificationSettingsRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.NotificationSettings, error)) *MockNotificationSettingsRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDColumn mocks base method. +func (m *MockNotificationSettingsRepository) OrganizationIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// OrganizationIDColumn indicates an expected call of OrganizationIDColumn. +func (mr *MockNotificationSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockNotificationSettingsRepositoryOrganizationIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).OrganizationIDColumn)) + return &MockNotificationSettingsRepositoryOrganizationIDColumnCall{Call: call} +} + +// MockNotificationSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call +type MockNotificationSettingsRepositoryOrganizationIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDCondition mocks base method. +func (m *MockNotificationSettingsRepository) OrganizationIDCondition(id *string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// OrganizationIDCondition indicates an expected call of OrganizationIDCondition. +func (mr *MockNotificationSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockNotificationSettingsRepositoryOrganizationIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).OrganizationIDCondition), id) + return &MockNotificationSettingsRepositoryOrganizationIDConditionCall{Call: call} +} + +// MockNotificationSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call +type MockNotificationSettingsRepositoryOrganizationIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockNotificationSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockNotificationSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockNotificationSettingsRepository) PrimaryKeyColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns. +func (mr *MockNotificationSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).PrimaryKeyColumns)) + return &MockNotificationSettingsRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockNotificationSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockNotificationSettingsRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockNotificationSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockNotificationSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockNotificationSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockNotificationSettingsRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id) + return &MockNotificationSettingsRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockNotificationSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockNotificationSettingsRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockNotificationSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockNotificationSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Set mocks base method. +func (m *MockNotificationSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.NotificationSettings) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, client, settings) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockNotificationSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockNotificationSettingsRepositorySetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).Set), ctx, client, settings) + return &MockNotificationSettingsRepositorySetCall{Call: call} +} + +// MockNotificationSettingsRepositorySetCall wrap *gomock.Call +type MockNotificationSettingsRepositorySetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositorySetCall) Return(arg0 error) *MockNotificationSettingsRepositorySetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.NotificationSettings) error) *MockNotificationSettingsRepositorySetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.NotificationSettings) error) *MockNotificationSettingsRepositorySetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetPasswordChange mocks base method. +func (m *MockNotificationSettingsRepository) SetPasswordChange(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetPasswordChange", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetPasswordChange indicates an expected call of SetPasswordChange. +func (mr *MockNotificationSettingsRepositoryMockRecorder) SetPasswordChange(value any) *MockNotificationSettingsRepositorySetPasswordChangeCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPasswordChange", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).SetPasswordChange), value) + return &MockNotificationSettingsRepositorySetPasswordChangeCall{Call: call} +} + +// MockNotificationSettingsRepositorySetPasswordChangeCall wrap *gomock.Call +type MockNotificationSettingsRepositorySetPasswordChangeCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositorySetPasswordChangeCall) Return(arg0 json.JsonUpdate) *MockNotificationSettingsRepositorySetPasswordChangeCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositorySetPasswordChangeCall) Do(f func(bool) json.JsonUpdate) *MockNotificationSettingsRepositorySetPasswordChangeCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositorySetPasswordChangeCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockNotificationSettingsRepositorySetPasswordChangeCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSettingFields mocks base method. +func (m *MockNotificationSettingsRepository) SetSettingFields(value domain.NotificationSettingsAttributes) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSettingFields", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSettingFields indicates an expected call of SetSettingFields. +func (mr *MockNotificationSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockNotificationSettingsRepositorySetSettingFieldsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).SetSettingFields), value) + return &MockNotificationSettingsRepositorySetSettingFieldsCall{Call: call} +} + +// MockNotificationSettingsRepositorySetSettingFieldsCall wrap *gomock.Call +type MockNotificationSettingsRepositorySetSettingFieldsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockNotificationSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositorySetSettingFieldsCall) Do(f func(domain.NotificationSettingsAttributes) database.Change) *MockNotificationSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.NotificationSettingsAttributes) database.Change) *MockNotificationSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockNotificationSettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUpdatedAt indicates an expected call of SetUpdatedAt. +func (mr *MockNotificationSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockNotificationSettingsRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).SetUpdatedAt), updatedAt) + return &MockNotificationSettingsRepositorySetUpdatedAtCall{Call: call} +} + +// MockNotificationSettingsRepositorySetUpdatedAtCall wrap *gomock.Call +type MockNotificationSettingsRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockNotificationSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockNotificationSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockNotificationSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SettingsColumn mocks base method. +func (m *MockNotificationSettingsRepository) SettingsColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SettingsColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// SettingsColumn indicates an expected call of SettingsColumn. +func (mr *MockNotificationSettingsRepositoryMockRecorder) SettingsColumn() *MockNotificationSettingsRepositorySettingsColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).SettingsColumn)) + return &MockNotificationSettingsRepositorySettingsColumnCall{Call: call} +} + +// MockNotificationSettingsRepositorySettingsColumnCall wrap *gomock.Call +type MockNotificationSettingsRepositorySettingsColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositorySettingsColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockNotificationSettingsRepository) StateColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// StateColumn indicates an expected call of StateColumn. +func (mr *MockNotificationSettingsRepositoryMockRecorder) StateColumn() *MockNotificationSettingsRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).StateColumn)) + return &MockNotificationSettingsRepositoryStateColumnCall{Call: call} +} + +// MockNotificationSettingsRepositoryStateColumnCall wrap *gomock.Call +type MockNotificationSettingsRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeColumn mocks base method. +func (m *MockNotificationSettingsRepository) TypeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TypeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TypeColumn indicates an expected call of TypeColumn. +func (mr *MockNotificationSettingsRepositoryMockRecorder) TypeColumn() *MockNotificationSettingsRepositoryTypeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).TypeColumn)) + return &MockNotificationSettingsRepositoryTypeColumnCall{Call: call} +} + +// MockNotificationSettingsRepositoryTypeColumnCall wrap *gomock.Call +type MockNotificationSettingsRepositoryTypeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryTypeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueColumns mocks base method. +func (m *MockNotificationSettingsRepository) UniqueColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// UniqueColumns indicates an expected call of UniqueColumns. +func (mr *MockNotificationSettingsRepositoryMockRecorder) UniqueColumns() *MockNotificationSettingsRepositoryUniqueColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).UniqueColumns)) + return &MockNotificationSettingsRepositoryUniqueColumnsCall{Call: call} +} + +// MockNotificationSettingsRepositoryUniqueColumnsCall wrap *gomock.Call +type MockNotificationSettingsRepositoryUniqueColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockNotificationSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockNotificationSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockNotificationSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueCondition mocks base method. +func (m *MockNotificationSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UniqueCondition indicates an expected call of UniqueCondition. +func (mr *MockNotificationSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockNotificationSettingsRepositoryUniqueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state) + return &MockNotificationSettingsRepositoryUniqueConditionCall{Call: call} +} + +// MockNotificationSettingsRepositoryUniqueConditionCall wrap *gomock.Call +type MockNotificationSettingsRepositoryUniqueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockNotificationSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockNotificationSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockNotificationSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockNotificationSettingsRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockNotificationSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockNotificationSettingsRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockNotificationSettingsRepository)(nil).UpdatedAtColumn)) + return &MockNotificationSettingsRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockNotificationSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockNotificationSettingsRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockNotificationSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockNotificationSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockNotificationSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockNotificationSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockNotificationSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockNotificationSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/organization_settings.mock.go b/backend/v3/domain/mock/organization_settings.mock.go new file mode 100644 index 000000000..6a5953fa9 --- /dev/null +++ b/backend/v3/domain/mock/organization_settings.mock.go @@ -0,0 +1,894 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: OrganizationSettingsRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/organization_settings.mock.go . OrganizationSettingsRepository +// + +// Package domainmock is a generated GoMock package. +package domainmock + +import ( + context "context" + reflect "reflect" + time "time" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + json "github.com/zitadel/zitadel/backend/v3/storage/database/json" + gomock "go.uber.org/mock/gomock" +) + +// MockOrganizationSettingsRepository is a mock of OrganizationSettingsRepository interface. +type MockOrganizationSettingsRepository struct { + ctrl *gomock.Controller + recorder *MockOrganizationSettingsRepositoryMockRecorder + isgomock struct{} +} + +// MockOrganizationSettingsRepositoryMockRecorder is the mock recorder for MockOrganizationSettingsRepository. +type MockOrganizationSettingsRepositoryMockRecorder struct { + mock *MockOrganizationSettingsRepository +} + +// NewMockOrganizationSettingsRepository creates a new mock instance. +func NewMockOrganizationSettingsRepository(ctrl *gomock.Controller) *MockOrganizationSettingsRepository { + mock := &MockOrganizationSettingsRepository{ctrl: ctrl} + mock.recorder = &MockOrganizationSettingsRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockOrganizationSettingsRepository) EXPECT() *MockOrganizationSettingsRepositoryMockRecorder { + return m.recorder +} + +// CreatedAtColumn mocks base method. +func (m *MockOrganizationSettingsRepository) CreatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// CreatedAtColumn indicates an expected call of CreatedAtColumn. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) CreatedAtColumn() *MockOrganizationSettingsRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).CreatedAtColumn)) + return &MockOrganizationSettingsRepositoryCreatedAtColumnCall{Call: call} +} + +// MockOrganizationSettingsRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockOrganizationSettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockOrganizationSettingsRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).Delete), ctx, client, condition) + return &MockOrganizationSettingsRepositoryDeleteCall{Call: call} +} + +// MockOrganizationSettingsRepositoryDeleteCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockOrganizationSettingsRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockOrganizationSettingsRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockOrganizationSettingsRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockOrganizationSettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.OrganizationSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.OrganizationSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockOrganizationSettingsRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).Get), varargs...) + return &MockOrganizationSettingsRepositoryGetCall{Call: call} +} + +// MockOrganizationSettingsRepositoryGetCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryGetCall) Return(arg0 *domain.OrganizationSettings, arg1 error) *MockOrganizationSettingsRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.OrganizationSettings, error)) *MockOrganizationSettingsRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.OrganizationSettings, error)) *MockOrganizationSettingsRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockOrganizationSettingsRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) IDColumn() *MockOrganizationSettingsRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).IDColumn)) + return &MockOrganizationSettingsRepositoryIDColumnCall{Call: call} +} + +// MockOrganizationSettingsRepositoryIDColumnCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockOrganizationSettingsRepository) IDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) IDCondition(id any) *MockOrganizationSettingsRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).IDCondition), id) + return &MockOrganizationSettingsRepositoryIDConditionCall{Call: call} +} + +// MockOrganizationSettingsRepositoryIDConditionCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockOrganizationSettingsRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockOrganizationSettingsRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockOrganizationSettingsRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) InstanceIDColumn() *MockOrganizationSettingsRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).InstanceIDColumn)) + return &MockOrganizationSettingsRepositoryInstanceIDColumnCall{Call: call} +} + +// MockOrganizationSettingsRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockOrganizationSettingsRepository) InstanceIDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// InstanceIDCondition indicates an expected call of InstanceIDCondition. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockOrganizationSettingsRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).InstanceIDCondition), id) + return &MockOrganizationSettingsRepositoryInstanceIDConditionCall{Call: call} +} + +// MockOrganizationSettingsRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockOrganizationSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockOrganizationSettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockOrganizationSettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.OrganizationSettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.OrganizationSettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockOrganizationSettingsRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).List), varargs...) + return &MockOrganizationSettingsRepositoryListCall{Call: call} +} + +// MockOrganizationSettingsRepositoryListCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryListCall) Return(arg0 []*domain.OrganizationSettings, arg1 error) *MockOrganizationSettingsRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.OrganizationSettings, error)) *MockOrganizationSettingsRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.OrganizationSettings, error)) *MockOrganizationSettingsRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDColumn mocks base method. +func (m *MockOrganizationSettingsRepository) OrganizationIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// OrganizationIDColumn indicates an expected call of OrganizationIDColumn. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) OrganizationIDColumn() *MockOrganizationSettingsRepositoryOrganizationIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).OrganizationIDColumn)) + return &MockOrganizationSettingsRepositoryOrganizationIDColumnCall{Call: call} +} + +// MockOrganizationSettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryOrganizationIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDCondition mocks base method. +func (m *MockOrganizationSettingsRepository) OrganizationIDCondition(id *string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// OrganizationIDCondition indicates an expected call of OrganizationIDCondition. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockOrganizationSettingsRepositoryOrganizationIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).OrganizationIDCondition), id) + return &MockOrganizationSettingsRepositoryOrganizationIDConditionCall{Call: call} +} + +// MockOrganizationSettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryOrganizationIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockOrganizationSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockOrganizationSettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockOrganizationSettingsRepository) PrimaryKeyColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).PrimaryKeyColumns)) + return &MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockOrganizationSettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockOrganizationSettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).PrimaryKeyCondition), instanceID, id) + return &MockOrganizationSettingsRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockOrganizationSettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockOrganizationSettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Set mocks base method. +func (m *MockOrganizationSettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.OrganizationSettings) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, client, settings) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockOrganizationSettingsRepositorySetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).Set), ctx, client, settings) + return &MockOrganizationSettingsRepositorySetCall{Call: call} +} + +// MockOrganizationSettingsRepositorySetCall wrap *gomock.Call +type MockOrganizationSettingsRepositorySetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositorySetCall) Return(arg0 error) *MockOrganizationSettingsRepositorySetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.OrganizationSettings) error) *MockOrganizationSettingsRepositorySetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.OrganizationSettings) error) *MockOrganizationSettingsRepositorySetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetOrganizationScopedUsernames mocks base method. +func (m *MockOrganizationSettingsRepository) SetOrganizationScopedUsernames(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetOrganizationScopedUsernames", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetOrganizationScopedUsernames indicates an expected call of SetOrganizationScopedUsernames. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) SetOrganizationScopedUsernames(value any) *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOrganizationScopedUsernames", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).SetOrganizationScopedUsernames), value) + return &MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall{Call: call} +} + +// MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall wrap *gomock.Call +type MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall) Return(arg0 json.JsonUpdate) *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall) Do(f func(bool) json.JsonUpdate) *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockOrganizationSettingsRepositorySetOrganizationScopedUsernamesCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSettingFields mocks base method. +func (m *MockOrganizationSettingsRepository) SetSettingFields(value domain.OrganizationSettingsAttributes) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSettingFields", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSettingFields indicates an expected call of SetSettingFields. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) SetSettingFields(value any) *MockOrganizationSettingsRepositorySetSettingFieldsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).SetSettingFields), value) + return &MockOrganizationSettingsRepositorySetSettingFieldsCall{Call: call} +} + +// MockOrganizationSettingsRepositorySetSettingFieldsCall wrap *gomock.Call +type MockOrganizationSettingsRepositorySetSettingFieldsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockOrganizationSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositorySetSettingFieldsCall) Do(f func(domain.OrganizationSettingsAttributes) database.Change) *MockOrganizationSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.OrganizationSettingsAttributes) database.Change) *MockOrganizationSettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockOrganizationSettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUpdatedAt indicates an expected call of SetUpdatedAt. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockOrganizationSettingsRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).SetUpdatedAt), updatedAt) + return &MockOrganizationSettingsRepositorySetUpdatedAtCall{Call: call} +} + +// MockOrganizationSettingsRepositorySetUpdatedAtCall wrap *gomock.Call +type MockOrganizationSettingsRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockOrganizationSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockOrganizationSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockOrganizationSettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SettingsColumn mocks base method. +func (m *MockOrganizationSettingsRepository) SettingsColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SettingsColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// SettingsColumn indicates an expected call of SettingsColumn. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) SettingsColumn() *MockOrganizationSettingsRepositorySettingsColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).SettingsColumn)) + return &MockOrganizationSettingsRepositorySettingsColumnCall{Call: call} +} + +// MockOrganizationSettingsRepositorySettingsColumnCall wrap *gomock.Call +type MockOrganizationSettingsRepositorySettingsColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositorySettingsColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositorySettingsColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockOrganizationSettingsRepository) StateColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// StateColumn indicates an expected call of StateColumn. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) StateColumn() *MockOrganizationSettingsRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).StateColumn)) + return &MockOrganizationSettingsRepositoryStateColumnCall{Call: call} +} + +// MockOrganizationSettingsRepositoryStateColumnCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeColumn mocks base method. +func (m *MockOrganizationSettingsRepository) TypeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TypeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TypeColumn indicates an expected call of TypeColumn. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) TypeColumn() *MockOrganizationSettingsRepositoryTypeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).TypeColumn)) + return &MockOrganizationSettingsRepositoryTypeColumnCall{Call: call} +} + +// MockOrganizationSettingsRepositoryTypeColumnCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryTypeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryTypeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryTypeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueColumns mocks base method. +func (m *MockOrganizationSettingsRepository) UniqueColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// UniqueColumns indicates an expected call of UniqueColumns. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) UniqueColumns() *MockOrganizationSettingsRepositoryUniqueColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).UniqueColumns)) + return &MockOrganizationSettingsRepositoryUniqueColumnsCall{Call: call} +} + +// MockOrganizationSettingsRepositoryUniqueColumnsCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryUniqueColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockOrganizationSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockOrganizationSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockOrganizationSettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueCondition mocks base method. +func (m *MockOrganizationSettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UniqueCondition indicates an expected call of UniqueCondition. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockOrganizationSettingsRepositoryUniqueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state) + return &MockOrganizationSettingsRepositoryUniqueConditionCall{Call: call} +} + +// MockOrganizationSettingsRepositoryUniqueConditionCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryUniqueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockOrganizationSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockOrganizationSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockOrganizationSettingsRepositoryUniqueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockOrganizationSettingsRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockOrganizationSettingsRepositoryMockRecorder) UpdatedAtColumn() *MockOrganizationSettingsRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockOrganizationSettingsRepository)(nil).UpdatedAtColumn)) + return &MockOrganizationSettingsRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockOrganizationSettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockOrganizationSettingsRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockOrganizationSettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockOrganizationSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockOrganizationSettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockOrganizationSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockOrganizationSettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockOrganizationSettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/password_complexity_settings.mock.go b/backend/v3/domain/mock/password_complexity_settings.mock.go new file mode 100644 index 000000000..16f00b748 --- /dev/null +++ b/backend/v3/domain/mock/password_complexity_settings.mock.go @@ -0,0 +1,1046 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: PasswordComplexitySettingsRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/password_complexity_settings.mock.go . PasswordComplexitySettingsRepository +// + +// Package domainmock is a generated GoMock package. +package domainmock + +import ( + context "context" + reflect "reflect" + time "time" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + json "github.com/zitadel/zitadel/backend/v3/storage/database/json" + gomock "go.uber.org/mock/gomock" +) + +// MockPasswordComplexitySettingsRepository is a mock of PasswordComplexitySettingsRepository interface. +type MockPasswordComplexitySettingsRepository struct { + ctrl *gomock.Controller + recorder *MockPasswordComplexitySettingsRepositoryMockRecorder + isgomock struct{} +} + +// MockPasswordComplexitySettingsRepositoryMockRecorder is the mock recorder for MockPasswordComplexitySettingsRepository. +type MockPasswordComplexitySettingsRepositoryMockRecorder struct { + mock *MockPasswordComplexitySettingsRepository +} + +// NewMockPasswordComplexitySettingsRepository creates a new mock instance. +func NewMockPasswordComplexitySettingsRepository(ctrl *gomock.Controller) *MockPasswordComplexitySettingsRepository { + mock := &MockPasswordComplexitySettingsRepository{ctrl: ctrl} + mock.recorder = &MockPasswordComplexitySettingsRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockPasswordComplexitySettingsRepository) EXPECT() *MockPasswordComplexitySettingsRepositoryMockRecorder { + return m.recorder +} + +// CreatedAtColumn mocks base method. +func (m *MockPasswordComplexitySettingsRepository) CreatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// CreatedAtColumn indicates an expected call of CreatedAtColumn. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) CreatedAtColumn() *MockPasswordComplexitySettingsRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).CreatedAtColumn)) + return &MockPasswordComplexitySettingsRepositoryCreatedAtColumnCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockPasswordComplexitySettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockPasswordComplexitySettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockPasswordComplexitySettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockPasswordComplexitySettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockPasswordComplexitySettingsRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).Delete), ctx, client, condition) + return &MockPasswordComplexitySettingsRepositoryDeleteCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryDeleteCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockPasswordComplexitySettingsRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockPasswordComplexitySettingsRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockPasswordComplexitySettingsRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockPasswordComplexitySettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.PasswordComplexitySettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.PasswordComplexitySettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockPasswordComplexitySettingsRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).Get), varargs...) + return &MockPasswordComplexitySettingsRepositoryGetCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryGetCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryGetCall) Return(arg0 *domain.PasswordComplexitySettings, arg1 error) *MockPasswordComplexitySettingsRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.PasswordComplexitySettings, error)) *MockPasswordComplexitySettingsRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.PasswordComplexitySettings, error)) *MockPasswordComplexitySettingsRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockPasswordComplexitySettingsRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) IDColumn() *MockPasswordComplexitySettingsRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).IDColumn)) + return &MockPasswordComplexitySettingsRepositoryIDColumnCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryIDColumnCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockPasswordComplexitySettingsRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockPasswordComplexitySettingsRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockPasswordComplexitySettingsRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockPasswordComplexitySettingsRepository) IDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) IDCondition(id any) *MockPasswordComplexitySettingsRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).IDCondition), id) + return &MockPasswordComplexitySettingsRepositoryIDConditionCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryIDConditionCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockPasswordComplexitySettingsRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockPasswordComplexitySettingsRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockPasswordComplexitySettingsRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockPasswordComplexitySettingsRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) InstanceIDColumn() *MockPasswordComplexitySettingsRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).InstanceIDColumn)) + return &MockPasswordComplexitySettingsRepositoryInstanceIDColumnCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockPasswordComplexitySettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockPasswordComplexitySettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockPasswordComplexitySettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockPasswordComplexitySettingsRepository) InstanceIDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// InstanceIDCondition indicates an expected call of InstanceIDCondition. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockPasswordComplexitySettingsRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).InstanceIDCondition), id) + return &MockPasswordComplexitySettingsRepositoryInstanceIDConditionCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockPasswordComplexitySettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockPasswordComplexitySettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockPasswordComplexitySettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockPasswordComplexitySettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.PasswordComplexitySettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.PasswordComplexitySettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockPasswordComplexitySettingsRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).List), varargs...) + return &MockPasswordComplexitySettingsRepositoryListCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryListCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryListCall) Return(arg0 []*domain.PasswordComplexitySettings, arg1 error) *MockPasswordComplexitySettingsRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.PasswordComplexitySettings, error)) *MockPasswordComplexitySettingsRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.PasswordComplexitySettings, error)) *MockPasswordComplexitySettingsRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDColumn mocks base method. +func (m *MockPasswordComplexitySettingsRepository) OrganizationIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// OrganizationIDColumn indicates an expected call of OrganizationIDColumn. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) OrganizationIDColumn() *MockPasswordComplexitySettingsRepositoryOrganizationIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).OrganizationIDColumn)) + return &MockPasswordComplexitySettingsRepositoryOrganizationIDColumnCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryOrganizationIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockPasswordComplexitySettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockPasswordComplexitySettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockPasswordComplexitySettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDCondition mocks base method. +func (m *MockPasswordComplexitySettingsRepository) OrganizationIDCondition(id *string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// OrganizationIDCondition indicates an expected call of OrganizationIDCondition. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockPasswordComplexitySettingsRepositoryOrganizationIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).OrganizationIDCondition), id) + return &MockPasswordComplexitySettingsRepositoryOrganizationIDConditionCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryOrganizationIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockPasswordComplexitySettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockPasswordComplexitySettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockPasswordComplexitySettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockPasswordComplexitySettingsRepository) PrimaryKeyColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockPasswordComplexitySettingsRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).PrimaryKeyColumns)) + return &MockPasswordComplexitySettingsRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockPasswordComplexitySettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockPasswordComplexitySettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockPasswordComplexitySettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockPasswordComplexitySettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockPasswordComplexitySettingsRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).PrimaryKeyCondition), instanceID, id) + return &MockPasswordComplexitySettingsRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockPasswordComplexitySettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockPasswordComplexitySettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockPasswordComplexitySettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Set mocks base method. +func (m *MockPasswordComplexitySettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.PasswordComplexitySettings) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, client, settings) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockPasswordComplexitySettingsRepositorySetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).Set), ctx, client, settings) + return &MockPasswordComplexitySettingsRepositorySetCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositorySetCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositorySetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositorySetCall) Return(arg0 error) *MockPasswordComplexitySettingsRepositorySetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.PasswordComplexitySettings) error) *MockPasswordComplexitySettingsRepositorySetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.PasswordComplexitySettings) error) *MockPasswordComplexitySettingsRepositorySetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetHasLowercase mocks base method. +func (m *MockPasswordComplexitySettingsRepository) SetHasLowercase(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHasLowercase", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetHasLowercase indicates an expected call of SetHasLowercase. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetHasLowercase(value any) *MockPasswordComplexitySettingsRepositorySetHasLowercaseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHasLowercase", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetHasLowercase), value) + return &MockPasswordComplexitySettingsRepositorySetHasLowercaseCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositorySetHasLowercaseCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositorySetHasLowercaseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositorySetHasLowercaseCall) Return(arg0 json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasLowercaseCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositorySetHasLowercaseCall) Do(f func(bool) json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasLowercaseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositorySetHasLowercaseCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasLowercaseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetHasNumber mocks base method. +func (m *MockPasswordComplexitySettingsRepository) SetHasNumber(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHasNumber", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetHasNumber indicates an expected call of SetHasNumber. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetHasNumber(value any) *MockPasswordComplexitySettingsRepositorySetHasNumberCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHasNumber", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetHasNumber), value) + return &MockPasswordComplexitySettingsRepositorySetHasNumberCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositorySetHasNumberCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositorySetHasNumberCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositorySetHasNumberCall) Return(arg0 json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasNumberCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositorySetHasNumberCall) Do(f func(bool) json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasNumberCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositorySetHasNumberCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasNumberCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetHasSymbol mocks base method. +func (m *MockPasswordComplexitySettingsRepository) SetHasSymbol(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHasSymbol", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetHasSymbol indicates an expected call of SetHasSymbol. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetHasSymbol(value any) *MockPasswordComplexitySettingsRepositorySetHasSymbolCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHasSymbol", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetHasSymbol), value) + return &MockPasswordComplexitySettingsRepositorySetHasSymbolCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositorySetHasSymbolCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositorySetHasSymbolCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositorySetHasSymbolCall) Return(arg0 json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasSymbolCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositorySetHasSymbolCall) Do(f func(bool) json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasSymbolCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositorySetHasSymbolCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasSymbolCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetHasUppercase mocks base method. +func (m *MockPasswordComplexitySettingsRepository) SetHasUppercase(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetHasUppercase", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetHasUppercase indicates an expected call of SetHasUppercase. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetHasUppercase(value any) *MockPasswordComplexitySettingsRepositorySetHasUppercaseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHasUppercase", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetHasUppercase), value) + return &MockPasswordComplexitySettingsRepositorySetHasUppercaseCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositorySetHasUppercaseCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositorySetHasUppercaseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositorySetHasUppercaseCall) Return(arg0 json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasUppercaseCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositorySetHasUppercaseCall) Do(f func(bool) json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasUppercaseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositorySetHasUppercaseCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetHasUppercaseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetMinLength mocks base method. +func (m *MockPasswordComplexitySettingsRepository) SetMinLength(value uint64) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetMinLength", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetMinLength indicates an expected call of SetMinLength. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetMinLength(value any) *MockPasswordComplexitySettingsRepositorySetMinLengthCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMinLength", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetMinLength), value) + return &MockPasswordComplexitySettingsRepositorySetMinLengthCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositorySetMinLengthCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositorySetMinLengthCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositorySetMinLengthCall) Return(arg0 json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetMinLengthCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositorySetMinLengthCall) Do(f func(uint64) json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetMinLengthCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositorySetMinLengthCall) DoAndReturn(f func(uint64) json.JsonUpdate) *MockPasswordComplexitySettingsRepositorySetMinLengthCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSettingFields mocks base method. +func (m *MockPasswordComplexitySettingsRepository) SetSettingFields(value domain.PasswordComplexitySettingsAttributes) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSettingFields", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSettingFields indicates an expected call of SetSettingFields. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetSettingFields(value any) *MockPasswordComplexitySettingsRepositorySetSettingFieldsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetSettingFields), value) + return &MockPasswordComplexitySettingsRepositorySetSettingFieldsCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositorySetSettingFieldsCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositorySetSettingFieldsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockPasswordComplexitySettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositorySetSettingFieldsCall) Do(f func(domain.PasswordComplexitySettingsAttributes) database.Change) *MockPasswordComplexitySettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.PasswordComplexitySettingsAttributes) database.Change) *MockPasswordComplexitySettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockPasswordComplexitySettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUpdatedAt indicates an expected call of SetUpdatedAt. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockPasswordComplexitySettingsRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SetUpdatedAt), updatedAt) + return &MockPasswordComplexitySettingsRepositorySetUpdatedAtCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositorySetUpdatedAtCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockPasswordComplexitySettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockPasswordComplexitySettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockPasswordComplexitySettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SettingsColumn mocks base method. +func (m *MockPasswordComplexitySettingsRepository) SettingsColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SettingsColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// SettingsColumn indicates an expected call of SettingsColumn. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) SettingsColumn() *MockPasswordComplexitySettingsRepositorySettingsColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).SettingsColumn)) + return &MockPasswordComplexitySettingsRepositorySettingsColumnCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositorySettingsColumnCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositorySettingsColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockPasswordComplexitySettingsRepositorySettingsColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockPasswordComplexitySettingsRepositorySettingsColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockPasswordComplexitySettingsRepositorySettingsColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockPasswordComplexitySettingsRepository) StateColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// StateColumn indicates an expected call of StateColumn. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) StateColumn() *MockPasswordComplexitySettingsRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).StateColumn)) + return &MockPasswordComplexitySettingsRepositoryStateColumnCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryStateColumnCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockPasswordComplexitySettingsRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockPasswordComplexitySettingsRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockPasswordComplexitySettingsRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeColumn mocks base method. +func (m *MockPasswordComplexitySettingsRepository) TypeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TypeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TypeColumn indicates an expected call of TypeColumn. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) TypeColumn() *MockPasswordComplexitySettingsRepositoryTypeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).TypeColumn)) + return &MockPasswordComplexitySettingsRepositoryTypeColumnCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryTypeColumnCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryTypeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockPasswordComplexitySettingsRepositoryTypeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockPasswordComplexitySettingsRepositoryTypeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockPasswordComplexitySettingsRepositoryTypeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueColumns mocks base method. +func (m *MockPasswordComplexitySettingsRepository) UniqueColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// UniqueColumns indicates an expected call of UniqueColumns. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) UniqueColumns() *MockPasswordComplexitySettingsRepositoryUniqueColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).UniqueColumns)) + return &MockPasswordComplexitySettingsRepositoryUniqueColumnsCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryUniqueColumnsCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryUniqueColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockPasswordComplexitySettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockPasswordComplexitySettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockPasswordComplexitySettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueCondition mocks base method. +func (m *MockPasswordComplexitySettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UniqueCondition indicates an expected call of UniqueCondition. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockPasswordComplexitySettingsRepositoryUniqueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state) + return &MockPasswordComplexitySettingsRepositoryUniqueConditionCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryUniqueConditionCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryUniqueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockPasswordComplexitySettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockPasswordComplexitySettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockPasswordComplexitySettingsRepositoryUniqueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockPasswordComplexitySettingsRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockPasswordComplexitySettingsRepositoryMockRecorder) UpdatedAtColumn() *MockPasswordComplexitySettingsRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockPasswordComplexitySettingsRepository)(nil).UpdatedAtColumn)) + return &MockPasswordComplexitySettingsRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockPasswordComplexitySettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockPasswordComplexitySettingsRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordComplexitySettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockPasswordComplexitySettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordComplexitySettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockPasswordComplexitySettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordComplexitySettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockPasswordComplexitySettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/password_expiry_settings.mock.go b/backend/v3/domain/mock/password_expiry_settings.mock.go new file mode 100644 index 000000000..50c94d76c --- /dev/null +++ b/backend/v3/domain/mock/password_expiry_settings.mock.go @@ -0,0 +1,932 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: PasswordExpirySettingsRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/password_expiry_settings.mock.go . PasswordExpirySettingsRepository +// + +// Package domainmock is a generated GoMock package. +package domainmock + +import ( + context "context" + reflect "reflect" + time "time" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + json "github.com/zitadel/zitadel/backend/v3/storage/database/json" + gomock "go.uber.org/mock/gomock" +) + +// MockPasswordExpirySettingsRepository is a mock of PasswordExpirySettingsRepository interface. +type MockPasswordExpirySettingsRepository struct { + ctrl *gomock.Controller + recorder *MockPasswordExpirySettingsRepositoryMockRecorder + isgomock struct{} +} + +// MockPasswordExpirySettingsRepositoryMockRecorder is the mock recorder for MockPasswordExpirySettingsRepository. +type MockPasswordExpirySettingsRepositoryMockRecorder struct { + mock *MockPasswordExpirySettingsRepository +} + +// NewMockPasswordExpirySettingsRepository creates a new mock instance. +func NewMockPasswordExpirySettingsRepository(ctrl *gomock.Controller) *MockPasswordExpirySettingsRepository { + mock := &MockPasswordExpirySettingsRepository{ctrl: ctrl} + mock.recorder = &MockPasswordExpirySettingsRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockPasswordExpirySettingsRepository) EXPECT() *MockPasswordExpirySettingsRepositoryMockRecorder { + return m.recorder +} + +// CreatedAtColumn mocks base method. +func (m *MockPasswordExpirySettingsRepository) CreatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// CreatedAtColumn indicates an expected call of CreatedAtColumn. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) CreatedAtColumn() *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).CreatedAtColumn)) + return &MockPasswordExpirySettingsRepositoryCreatedAtColumnCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockPasswordExpirySettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockPasswordExpirySettingsRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).Delete), ctx, client, condition) + return &MockPasswordExpirySettingsRepositoryDeleteCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryDeleteCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockPasswordExpirySettingsRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockPasswordExpirySettingsRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockPasswordExpirySettingsRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockPasswordExpirySettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.PasswordExpirySettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.PasswordExpirySettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockPasswordExpirySettingsRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).Get), varargs...) + return &MockPasswordExpirySettingsRepositoryGetCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryGetCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryGetCall) Return(arg0 *domain.PasswordExpirySettings, arg1 error) *MockPasswordExpirySettingsRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.PasswordExpirySettings, error)) *MockPasswordExpirySettingsRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.PasswordExpirySettings, error)) *MockPasswordExpirySettingsRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockPasswordExpirySettingsRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) IDColumn() *MockPasswordExpirySettingsRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).IDColumn)) + return &MockPasswordExpirySettingsRepositoryIDColumnCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryIDColumnCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockPasswordExpirySettingsRepository) IDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) IDCondition(id any) *MockPasswordExpirySettingsRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).IDCondition), id) + return &MockPasswordExpirySettingsRepositoryIDConditionCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryIDConditionCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockPasswordExpirySettingsRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockPasswordExpirySettingsRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockPasswordExpirySettingsRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) InstanceIDColumn() *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).InstanceIDColumn)) + return &MockPasswordExpirySettingsRepositoryInstanceIDColumnCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockPasswordExpirySettingsRepository) InstanceIDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// InstanceIDCondition indicates an expected call of InstanceIDCondition. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).InstanceIDCondition), id) + return &MockPasswordExpirySettingsRepositoryInstanceIDConditionCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockPasswordExpirySettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockPasswordExpirySettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.PasswordExpirySettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.PasswordExpirySettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockPasswordExpirySettingsRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).List), varargs...) + return &MockPasswordExpirySettingsRepositoryListCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryListCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryListCall) Return(arg0 []*domain.PasswordExpirySettings, arg1 error) *MockPasswordExpirySettingsRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.PasswordExpirySettings, error)) *MockPasswordExpirySettingsRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.PasswordExpirySettings, error)) *MockPasswordExpirySettingsRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDColumn mocks base method. +func (m *MockPasswordExpirySettingsRepository) OrganizationIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// OrganizationIDColumn indicates an expected call of OrganizationIDColumn. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) OrganizationIDColumn() *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).OrganizationIDColumn)) + return &MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDCondition mocks base method. +func (m *MockPasswordExpirySettingsRepository) OrganizationIDCondition(id *string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// OrganizationIDCondition indicates an expected call of OrganizationIDCondition. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).OrganizationIDCondition), id) + return &MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockPasswordExpirySettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockPasswordExpirySettingsRepository) PrimaryKeyColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).PrimaryKeyColumns)) + return &MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockPasswordExpirySettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockPasswordExpirySettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).PrimaryKeyCondition), instanceID, id) + return &MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockPasswordExpirySettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Set mocks base method. +func (m *MockPasswordExpirySettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.PasswordExpirySettings) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, client, settings) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockPasswordExpirySettingsRepositorySetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).Set), ctx, client, settings) + return &MockPasswordExpirySettingsRepositorySetCall{Call: call} +} + +// MockPasswordExpirySettingsRepositorySetCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositorySetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositorySetCall) Return(arg0 error) *MockPasswordExpirySettingsRepositorySetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.PasswordExpirySettings) error) *MockPasswordExpirySettingsRepositorySetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.PasswordExpirySettings) error) *MockPasswordExpirySettingsRepositorySetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetExpireWarnDays mocks base method. +func (m *MockPasswordExpirySettingsRepository) SetExpireWarnDays(value uint64) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetExpireWarnDays", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetExpireWarnDays indicates an expected call of SetExpireWarnDays. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetExpireWarnDays(value any) *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExpireWarnDays", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetExpireWarnDays), value) + return &MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall{Call: call} +} + +// MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall) Return(arg0 json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall) Do(f func(uint64) json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall) DoAndReturn(f func(uint64) json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetExpireWarnDaysCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetMaxAgeDays mocks base method. +func (m *MockPasswordExpirySettingsRepository) SetMaxAgeDays(value uint64) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetMaxAgeDays", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetMaxAgeDays indicates an expected call of SetMaxAgeDays. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetMaxAgeDays(value any) *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxAgeDays", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetMaxAgeDays), value) + return &MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall{Call: call} +} + +// MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall) Return(arg0 json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall) Do(f func(uint64) json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall) DoAndReturn(f func(uint64) json.JsonUpdate) *MockPasswordExpirySettingsRepositorySetMaxAgeDaysCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSettingFields mocks base method. +func (m *MockPasswordExpirySettingsRepository) SetSettingFields(value domain.PasswordExpirySettingsAttributes) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSettingFields", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSettingFields indicates an expected call of SetSettingFields. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetSettingFields(value any) *MockPasswordExpirySettingsRepositorySetSettingFieldsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetSettingFields), value) + return &MockPasswordExpirySettingsRepositorySetSettingFieldsCall{Call: call} +} + +// MockPasswordExpirySettingsRepositorySetSettingFieldsCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositorySetSettingFieldsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockPasswordExpirySettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositorySetSettingFieldsCall) Do(f func(domain.PasswordExpirySettingsAttributes) database.Change) *MockPasswordExpirySettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.PasswordExpirySettingsAttributes) database.Change) *MockPasswordExpirySettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockPasswordExpirySettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUpdatedAt indicates an expected call of SetUpdatedAt. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockPasswordExpirySettingsRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SetUpdatedAt), updatedAt) + return &MockPasswordExpirySettingsRepositorySetUpdatedAtCall{Call: call} +} + +// MockPasswordExpirySettingsRepositorySetUpdatedAtCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockPasswordExpirySettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockPasswordExpirySettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockPasswordExpirySettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SettingsColumn mocks base method. +func (m *MockPasswordExpirySettingsRepository) SettingsColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SettingsColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// SettingsColumn indicates an expected call of SettingsColumn. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) SettingsColumn() *MockPasswordExpirySettingsRepositorySettingsColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).SettingsColumn)) + return &MockPasswordExpirySettingsRepositorySettingsColumnCall{Call: call} +} + +// MockPasswordExpirySettingsRepositorySettingsColumnCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositorySettingsColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositorySettingsColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositorySettingsColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositorySettingsColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockPasswordExpirySettingsRepository) StateColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// StateColumn indicates an expected call of StateColumn. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) StateColumn() *MockPasswordExpirySettingsRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).StateColumn)) + return &MockPasswordExpirySettingsRepositoryStateColumnCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryStateColumnCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeColumn mocks base method. +func (m *MockPasswordExpirySettingsRepository) TypeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TypeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TypeColumn indicates an expected call of TypeColumn. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) TypeColumn() *MockPasswordExpirySettingsRepositoryTypeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).TypeColumn)) + return &MockPasswordExpirySettingsRepositoryTypeColumnCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryTypeColumnCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryTypeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryTypeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryTypeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryTypeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueColumns mocks base method. +func (m *MockPasswordExpirySettingsRepository) UniqueColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// UniqueColumns indicates an expected call of UniqueColumns. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) UniqueColumns() *MockPasswordExpirySettingsRepositoryUniqueColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).UniqueColumns)) + return &MockPasswordExpirySettingsRepositoryUniqueColumnsCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryUniqueColumnsCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryUniqueColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockPasswordExpirySettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockPasswordExpirySettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockPasswordExpirySettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueCondition mocks base method. +func (m *MockPasswordExpirySettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UniqueCondition indicates an expected call of UniqueCondition. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockPasswordExpirySettingsRepositoryUniqueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state) + return &MockPasswordExpirySettingsRepositoryUniqueConditionCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryUniqueConditionCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryUniqueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockPasswordExpirySettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockPasswordExpirySettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockPasswordExpirySettingsRepositoryUniqueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockPasswordExpirySettingsRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockPasswordExpirySettingsRepositoryMockRecorder) UpdatedAtColumn() *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockPasswordExpirySettingsRepository)(nil).UpdatedAtColumn)) + return &MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockPasswordExpirySettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/mock/security_settings.mock.go b/backend/v3/domain/mock/security_settings.mock.go new file mode 100644 index 000000000..1102d3992 --- /dev/null +++ b/backend/v3/domain/mock/security_settings.mock.go @@ -0,0 +1,970 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: github.com/zitadel/zitadel/backend/v3/domain (interfaces: SecuritySettingsRepository) +// +// Generated by this command: +// +// mockgen -typed -package domainmock -destination ./mock/security_settings.mock.go . SecuritySettingsRepository +// + +// Package domainmock is a generated GoMock package. +package domainmock + +import ( + context "context" + reflect "reflect" + time "time" + + domain "github.com/zitadel/zitadel/backend/v3/domain" + database "github.com/zitadel/zitadel/backend/v3/storage/database" + json "github.com/zitadel/zitadel/backend/v3/storage/database/json" + gomock "go.uber.org/mock/gomock" +) + +// MockSecuritySettingsRepository is a mock of SecuritySettingsRepository interface. +type MockSecuritySettingsRepository struct { + ctrl *gomock.Controller + recorder *MockSecuritySettingsRepositoryMockRecorder + isgomock struct{} +} + +// MockSecuritySettingsRepositoryMockRecorder is the mock recorder for MockSecuritySettingsRepository. +type MockSecuritySettingsRepositoryMockRecorder struct { + mock *MockSecuritySettingsRepository +} + +// NewMockSecuritySettingsRepository creates a new mock instance. +func NewMockSecuritySettingsRepository(ctrl *gomock.Controller) *MockSecuritySettingsRepository { + mock := &MockSecuritySettingsRepository{ctrl: ctrl} + mock.recorder = &MockSecuritySettingsRepositoryMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockSecuritySettingsRepository) EXPECT() *MockSecuritySettingsRepositoryMockRecorder { + return m.recorder +} + +// CreatedAtColumn mocks base method. +func (m *MockSecuritySettingsRepository) CreatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// CreatedAtColumn indicates an expected call of CreatedAtColumn. +func (mr *MockSecuritySettingsRepositoryMockRecorder) CreatedAtColumn() *MockSecuritySettingsRepositoryCreatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatedAtColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).CreatedAtColumn)) + return &MockSecuritySettingsRepositoryCreatedAtColumnCall{Call: call} +} + +// MockSecuritySettingsRepositoryCreatedAtColumnCall wrap *gomock.Call +type MockSecuritySettingsRepositoryCreatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryCreatedAtColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryCreatedAtColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryCreatedAtColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryCreatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Delete mocks base method. +func (m *MockSecuritySettingsRepository) Delete(ctx context.Context, client database.QueryExecutor, condition database.Condition) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Delete", ctx, client, condition) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Delete indicates an expected call of Delete. +func (mr *MockSecuritySettingsRepositoryMockRecorder) Delete(ctx, client, condition any) *MockSecuritySettingsRepositoryDeleteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).Delete), ctx, client, condition) + return &MockSecuritySettingsRepositoryDeleteCall{Call: call} +} + +// MockSecuritySettingsRepositoryDeleteCall wrap *gomock.Call +type MockSecuritySettingsRepositoryDeleteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryDeleteCall) Return(arg0 int64, arg1 error) *MockSecuritySettingsRepositoryDeleteCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryDeleteCall) Do(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockSecuritySettingsRepositoryDeleteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryDeleteCall) DoAndReturn(f func(context.Context, database.QueryExecutor, database.Condition) (int64, error)) *MockSecuritySettingsRepositoryDeleteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Get mocks base method. +func (m *MockSecuritySettingsRepository) Get(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) (*domain.SecuritySettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "Get", varargs...) + ret0, _ := ret[0].(*domain.SecuritySettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *MockSecuritySettingsRepositoryMockRecorder) Get(ctx, client any, opts ...any) *MockSecuritySettingsRepositoryGetCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).Get), varargs...) + return &MockSecuritySettingsRepositoryGetCall{Call: call} +} + +// MockSecuritySettingsRepositoryGetCall wrap *gomock.Call +type MockSecuritySettingsRepositoryGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryGetCall) Return(arg0 *domain.SecuritySettings, arg1 error) *MockSecuritySettingsRepositoryGetCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryGetCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.SecuritySettings, error)) *MockSecuritySettingsRepositoryGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryGetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) (*domain.SecuritySettings, error)) *MockSecuritySettingsRepositoryGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDColumn mocks base method. +func (m *MockSecuritySettingsRepository) IDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// IDColumn indicates an expected call of IDColumn. +func (mr *MockSecuritySettingsRepositoryMockRecorder) IDColumn() *MockSecuritySettingsRepositoryIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).IDColumn)) + return &MockSecuritySettingsRepositoryIDColumnCall{Call: call} +} + +// MockSecuritySettingsRepositoryIDColumnCall wrap *gomock.Call +type MockSecuritySettingsRepositoryIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryIDColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryIDColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryIDColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// IDCondition mocks base method. +func (m *MockSecuritySettingsRepository) IDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// IDCondition indicates an expected call of IDCondition. +func (mr *MockSecuritySettingsRepositoryMockRecorder) IDCondition(id any) *MockSecuritySettingsRepositoryIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IDCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).IDCondition), id) + return &MockSecuritySettingsRepositoryIDConditionCall{Call: call} +} + +// MockSecuritySettingsRepositoryIDConditionCall wrap *gomock.Call +type MockSecuritySettingsRepositoryIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryIDConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryIDConditionCall) Do(f func(string) database.Condition) *MockSecuritySettingsRepositoryIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSecuritySettingsRepositoryIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDColumn mocks base method. +func (m *MockSecuritySettingsRepository) InstanceIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// InstanceIDColumn indicates an expected call of InstanceIDColumn. +func (mr *MockSecuritySettingsRepositoryMockRecorder) InstanceIDColumn() *MockSecuritySettingsRepositoryInstanceIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).InstanceIDColumn)) + return &MockSecuritySettingsRepositoryInstanceIDColumnCall{Call: call} +} + +// MockSecuritySettingsRepositoryInstanceIDColumnCall wrap *gomock.Call +type MockSecuritySettingsRepositoryInstanceIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryInstanceIDColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryInstanceIDColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryInstanceIDColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryInstanceIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// InstanceIDCondition mocks base method. +func (m *MockSecuritySettingsRepository) InstanceIDCondition(id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "InstanceIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// InstanceIDCondition indicates an expected call of InstanceIDCondition. +func (mr *MockSecuritySettingsRepositoryMockRecorder) InstanceIDCondition(id any) *MockSecuritySettingsRepositoryInstanceIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceIDCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).InstanceIDCondition), id) + return &MockSecuritySettingsRepositoryInstanceIDConditionCall{Call: call} +} + +// MockSecuritySettingsRepositoryInstanceIDConditionCall wrap *gomock.Call +type MockSecuritySettingsRepositoryInstanceIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryInstanceIDConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryInstanceIDConditionCall) Do(f func(string) database.Condition) *MockSecuritySettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryInstanceIDConditionCall) DoAndReturn(f func(string) database.Condition) *MockSecuritySettingsRepositoryInstanceIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// List mocks base method. +func (m *MockSecuritySettingsRepository) List(ctx context.Context, client database.QueryExecutor, opts ...database.QueryOption) ([]*domain.SecuritySettings, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, client} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "List", varargs...) + ret0, _ := ret[0].([]*domain.SecuritySettings) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// List indicates an expected call of List. +func (mr *MockSecuritySettingsRepositoryMockRecorder) List(ctx, client any, opts ...any) *MockSecuritySettingsRepositoryListCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, client}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).List), varargs...) + return &MockSecuritySettingsRepositoryListCall{Call: call} +} + +// MockSecuritySettingsRepositoryListCall wrap *gomock.Call +type MockSecuritySettingsRepositoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryListCall) Return(arg0 []*domain.SecuritySettings, arg1 error) *MockSecuritySettingsRepositoryListCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryListCall) Do(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.SecuritySettings, error)) *MockSecuritySettingsRepositoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryListCall) DoAndReturn(f func(context.Context, database.QueryExecutor, ...database.QueryOption) ([]*domain.SecuritySettings, error)) *MockSecuritySettingsRepositoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDColumn mocks base method. +func (m *MockSecuritySettingsRepository) OrganizationIDColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// OrganizationIDColumn indicates an expected call of OrganizationIDColumn. +func (mr *MockSecuritySettingsRepositoryMockRecorder) OrganizationIDColumn() *MockSecuritySettingsRepositoryOrganizationIDColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).OrganizationIDColumn)) + return &MockSecuritySettingsRepositoryOrganizationIDColumnCall{Call: call} +} + +// MockSecuritySettingsRepositoryOrganizationIDColumnCall wrap *gomock.Call +type MockSecuritySettingsRepositoryOrganizationIDColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryOrganizationIDColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryOrganizationIDColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryOrganizationIDColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryOrganizationIDColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// OrganizationIDCondition mocks base method. +func (m *MockSecuritySettingsRepository) OrganizationIDCondition(id *string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "OrganizationIDCondition", id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// OrganizationIDCondition indicates an expected call of OrganizationIDCondition. +func (mr *MockSecuritySettingsRepositoryMockRecorder) OrganizationIDCondition(id any) *MockSecuritySettingsRepositoryOrganizationIDConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OrganizationIDCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).OrganizationIDCondition), id) + return &MockSecuritySettingsRepositoryOrganizationIDConditionCall{Call: call} +} + +// MockSecuritySettingsRepositoryOrganizationIDConditionCall wrap *gomock.Call +type MockSecuritySettingsRepositoryOrganizationIDConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryOrganizationIDConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryOrganizationIDConditionCall) Do(f func(*string) database.Condition) *MockSecuritySettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryOrganizationIDConditionCall) DoAndReturn(f func(*string) database.Condition) *MockSecuritySettingsRepositoryOrganizationIDConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyColumns mocks base method. +func (m *MockSecuritySettingsRepository) PrimaryKeyColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// PrimaryKeyColumns indicates an expected call of PrimaryKeyColumns. +func (mr *MockSecuritySettingsRepositoryMockRecorder) PrimaryKeyColumns() *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyColumns", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).PrimaryKeyColumns)) + return &MockSecuritySettingsRepositoryPrimaryKeyColumnsCall{Call: call} +} + +// MockSecuritySettingsRepositoryPrimaryKeyColumnsCall wrap *gomock.Call +type MockSecuritySettingsRepositoryPrimaryKeyColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall) Return(arg0 []database.Column) *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall) Do(f func() []database.Column) *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall) DoAndReturn(f func() []database.Column) *MockSecuritySettingsRepositoryPrimaryKeyColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// PrimaryKeyCondition mocks base method. +func (m *MockSecuritySettingsRepository) PrimaryKeyCondition(instanceID, id string) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrimaryKeyCondition", instanceID, id) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// PrimaryKeyCondition indicates an expected call of PrimaryKeyCondition. +func (mr *MockSecuritySettingsRepositoryMockRecorder) PrimaryKeyCondition(instanceID, id any) *MockSecuritySettingsRepositoryPrimaryKeyConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrimaryKeyCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).PrimaryKeyCondition), instanceID, id) + return &MockSecuritySettingsRepositoryPrimaryKeyConditionCall{Call: call} +} + +// MockSecuritySettingsRepositoryPrimaryKeyConditionCall wrap *gomock.Call +type MockSecuritySettingsRepositoryPrimaryKeyConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryPrimaryKeyConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryPrimaryKeyConditionCall) Do(f func(string, string) database.Condition) *MockSecuritySettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryPrimaryKeyConditionCall) DoAndReturn(f func(string, string) database.Condition) *MockSecuritySettingsRepositoryPrimaryKeyConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Set mocks base method. +func (m *MockSecuritySettingsRepository) Set(ctx context.Context, client database.QueryExecutor, settings *domain.SecuritySettings) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Set", ctx, client, settings) + ret0, _ := ret[0].(error) + return ret0 +} + +// Set indicates an expected call of Set. +func (mr *MockSecuritySettingsRepositoryMockRecorder) Set(ctx, client, settings any) *MockSecuritySettingsRepositorySetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).Set), ctx, client, settings) + return &MockSecuritySettingsRepositorySetCall{Call: call} +} + +// MockSecuritySettingsRepositorySetCall wrap *gomock.Call +type MockSecuritySettingsRepositorySetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositorySetCall) Return(arg0 error) *MockSecuritySettingsRepositorySetCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositorySetCall) Do(f func(context.Context, database.QueryExecutor, *domain.SecuritySettings) error) *MockSecuritySettingsRepositorySetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositorySetCall) DoAndReturn(f func(context.Context, database.QueryExecutor, *domain.SecuritySettings) error) *MockSecuritySettingsRepositorySetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetAllowedOrigins mocks base method. +func (m *MockSecuritySettingsRepository) SetAllowedOrigins(values []string) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetAllowedOrigins", values) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetAllowedOrigins indicates an expected call of SetAllowedOrigins. +func (mr *MockSecuritySettingsRepositoryMockRecorder) SetAllowedOrigins(values any) *MockSecuritySettingsRepositorySetAllowedOriginsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowedOrigins", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetAllowedOrigins), values) + return &MockSecuritySettingsRepositorySetAllowedOriginsCall{Call: call} +} + +// MockSecuritySettingsRepositorySetAllowedOriginsCall wrap *gomock.Call +type MockSecuritySettingsRepositorySetAllowedOriginsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositorySetAllowedOriginsCall) Return(arg0 json.JsonUpdate) *MockSecuritySettingsRepositorySetAllowedOriginsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositorySetAllowedOriginsCall) Do(f func([]string) json.JsonUpdate) *MockSecuritySettingsRepositorySetAllowedOriginsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositorySetAllowedOriginsCall) DoAndReturn(f func([]string) json.JsonUpdate) *MockSecuritySettingsRepositorySetAllowedOriginsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetEnableIframeEmbedding mocks base method. +func (m *MockSecuritySettingsRepository) SetEnableIframeEmbedding(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetEnableIframeEmbedding", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetEnableIframeEmbedding indicates an expected call of SetEnableIframeEmbedding. +func (mr *MockSecuritySettingsRepositoryMockRecorder) SetEnableIframeEmbedding(value any) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEnableIframeEmbedding", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetEnableIframeEmbedding), value) + return &MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall{Call: call} +} + +// MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall wrap *gomock.Call +type MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall) Return(arg0 json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall) Do(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableIframeEmbeddingCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetEnableImpersonation mocks base method. +func (m *MockSecuritySettingsRepository) SetEnableImpersonation(value bool) json.JsonUpdate { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetEnableImpersonation", value) + ret0, _ := ret[0].(json.JsonUpdate) + return ret0 +} + +// SetEnableImpersonation indicates an expected call of SetEnableImpersonation. +func (mr *MockSecuritySettingsRepositoryMockRecorder) SetEnableImpersonation(value any) *MockSecuritySettingsRepositorySetEnableImpersonationCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEnableImpersonation", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetEnableImpersonation), value) + return &MockSecuritySettingsRepositorySetEnableImpersonationCall{Call: call} +} + +// MockSecuritySettingsRepositorySetEnableImpersonationCall wrap *gomock.Call +type MockSecuritySettingsRepositorySetEnableImpersonationCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositorySetEnableImpersonationCall) Return(arg0 json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableImpersonationCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositorySetEnableImpersonationCall) Do(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableImpersonationCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositorySetEnableImpersonationCall) DoAndReturn(f func(bool) json.JsonUpdate) *MockSecuritySettingsRepositorySetEnableImpersonationCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetSettingFields mocks base method. +func (m *MockSecuritySettingsRepository) SetSettingFields(value domain.SecuritySettingsAttributes) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetSettingFields", value) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetSettingFields indicates an expected call of SetSettingFields. +func (mr *MockSecuritySettingsRepositoryMockRecorder) SetSettingFields(value any) *MockSecuritySettingsRepositorySetSettingFieldsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSettingFields", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetSettingFields), value) + return &MockSecuritySettingsRepositorySetSettingFieldsCall{Call: call} +} + +// MockSecuritySettingsRepositorySetSettingFieldsCall wrap *gomock.Call +type MockSecuritySettingsRepositorySetSettingFieldsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositorySetSettingFieldsCall) Return(arg0 database.Change) *MockSecuritySettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositorySetSettingFieldsCall) Do(f func(domain.SecuritySettingsAttributes) database.Change) *MockSecuritySettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositorySetSettingFieldsCall) DoAndReturn(f func(domain.SecuritySettingsAttributes) database.Change) *MockSecuritySettingsRepositorySetSettingFieldsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetUpdatedAt mocks base method. +func (m *MockSecuritySettingsRepository) SetUpdatedAt(updatedAt *time.Time) database.Change { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetUpdatedAt", updatedAt) + ret0, _ := ret[0].(database.Change) + return ret0 +} + +// SetUpdatedAt indicates an expected call of SetUpdatedAt. +func (mr *MockSecuritySettingsRepositoryMockRecorder) SetUpdatedAt(updatedAt any) *MockSecuritySettingsRepositorySetUpdatedAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUpdatedAt", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SetUpdatedAt), updatedAt) + return &MockSecuritySettingsRepositorySetUpdatedAtCall{Call: call} +} + +// MockSecuritySettingsRepositorySetUpdatedAtCall wrap *gomock.Call +type MockSecuritySettingsRepositorySetUpdatedAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositorySetUpdatedAtCall) Return(arg0 database.Change) *MockSecuritySettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositorySetUpdatedAtCall) Do(f func(*time.Time) database.Change) *MockSecuritySettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositorySetUpdatedAtCall) DoAndReturn(f func(*time.Time) database.Change) *MockSecuritySettingsRepositorySetUpdatedAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SettingsColumn mocks base method. +func (m *MockSecuritySettingsRepository) SettingsColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SettingsColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// SettingsColumn indicates an expected call of SettingsColumn. +func (mr *MockSecuritySettingsRepositoryMockRecorder) SettingsColumn() *MockSecuritySettingsRepositorySettingsColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettingsColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).SettingsColumn)) + return &MockSecuritySettingsRepositorySettingsColumnCall{Call: call} +} + +// MockSecuritySettingsRepositorySettingsColumnCall wrap *gomock.Call +type MockSecuritySettingsRepositorySettingsColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositorySettingsColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositorySettingsColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositorySettingsColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositorySettingsColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositorySettingsColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositorySettingsColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// StateColumn mocks base method. +func (m *MockSecuritySettingsRepository) StateColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StateColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// StateColumn indicates an expected call of StateColumn. +func (mr *MockSecuritySettingsRepositoryMockRecorder) StateColumn() *MockSecuritySettingsRepositoryStateColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).StateColumn)) + return &MockSecuritySettingsRepositoryStateColumnCall{Call: call} +} + +// MockSecuritySettingsRepositoryStateColumnCall wrap *gomock.Call +type MockSecuritySettingsRepositoryStateColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryStateColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryStateColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryStateColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryStateColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryStateColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryStateColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// TypeColumn mocks base method. +func (m *MockSecuritySettingsRepository) TypeColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TypeColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// TypeColumn indicates an expected call of TypeColumn. +func (mr *MockSecuritySettingsRepositoryMockRecorder) TypeColumn() *MockSecuritySettingsRepositoryTypeColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TypeColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).TypeColumn)) + return &MockSecuritySettingsRepositoryTypeColumnCall{Call: call} +} + +// MockSecuritySettingsRepositoryTypeColumnCall wrap *gomock.Call +type MockSecuritySettingsRepositoryTypeColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryTypeColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryTypeColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryTypeColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryTypeColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryTypeColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryTypeColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueColumns mocks base method. +func (m *MockSecuritySettingsRepository) UniqueColumns() []database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueColumns") + ret0, _ := ret[0].([]database.Column) + return ret0 +} + +// UniqueColumns indicates an expected call of UniqueColumns. +func (mr *MockSecuritySettingsRepositoryMockRecorder) UniqueColumns() *MockSecuritySettingsRepositoryUniqueColumnsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueColumns", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).UniqueColumns)) + return &MockSecuritySettingsRepositoryUniqueColumnsCall{Call: call} +} + +// MockSecuritySettingsRepositoryUniqueColumnsCall wrap *gomock.Call +type MockSecuritySettingsRepositoryUniqueColumnsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryUniqueColumnsCall) Return(arg0 []database.Column) *MockSecuritySettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryUniqueColumnsCall) Do(f func() []database.Column) *MockSecuritySettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryUniqueColumnsCall) DoAndReturn(f func() []database.Column) *MockSecuritySettingsRepositoryUniqueColumnsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UniqueCondition mocks base method. +func (m *MockSecuritySettingsRepository) UniqueCondition(instanceID string, orgID *string, typ domain.SettingType, state domain.SettingState) database.Condition { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UniqueCondition", instanceID, orgID, typ, state) + ret0, _ := ret[0].(database.Condition) + return ret0 +} + +// UniqueCondition indicates an expected call of UniqueCondition. +func (mr *MockSecuritySettingsRepositoryMockRecorder) UniqueCondition(instanceID, orgID, typ, state any) *MockSecuritySettingsRepositoryUniqueConditionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UniqueCondition", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).UniqueCondition), instanceID, orgID, typ, state) + return &MockSecuritySettingsRepositoryUniqueConditionCall{Call: call} +} + +// MockSecuritySettingsRepositoryUniqueConditionCall wrap *gomock.Call +type MockSecuritySettingsRepositoryUniqueConditionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryUniqueConditionCall) Return(arg0 database.Condition) *MockSecuritySettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryUniqueConditionCall) Do(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockSecuritySettingsRepositoryUniqueConditionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryUniqueConditionCall) DoAndReturn(f func(string, *string, domain.SettingType, domain.SettingState) database.Condition) *MockSecuritySettingsRepositoryUniqueConditionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatedAtColumn mocks base method. +func (m *MockSecuritySettingsRepository) UpdatedAtColumn() database.Column { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatedAtColumn") + ret0, _ := ret[0].(database.Column) + return ret0 +} + +// UpdatedAtColumn indicates an expected call of UpdatedAtColumn. +func (mr *MockSecuritySettingsRepositoryMockRecorder) UpdatedAtColumn() *MockSecuritySettingsRepositoryUpdatedAtColumnCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatedAtColumn", reflect.TypeOf((*MockSecuritySettingsRepository)(nil).UpdatedAtColumn)) + return &MockSecuritySettingsRepositoryUpdatedAtColumnCall{Call: call} +} + +// MockSecuritySettingsRepositoryUpdatedAtColumnCall wrap *gomock.Call +type MockSecuritySettingsRepositoryUpdatedAtColumnCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockSecuritySettingsRepositoryUpdatedAtColumnCall) Return(arg0 database.Column) *MockSecuritySettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockSecuritySettingsRepositoryUpdatedAtColumnCall) Do(f func() database.Column) *MockSecuritySettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockSecuritySettingsRepositoryUpdatedAtColumnCall) DoAndReturn(f func() database.Column) *MockSecuritySettingsRepositoryUpdatedAtColumnCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/backend/v3/domain/session_check_password.go b/backend/v3/domain/session_check_password.go new file mode 100644 index 000000000..089455fda --- /dev/null +++ b/backend/v3/domain/session_check_password.go @@ -0,0 +1,340 @@ +package domain + +import ( + "context" + "errors" + "strings" + "time" + + "github.com/muhlemmer/gu" + "github.com/zitadel/passwap" + + "github.com/zitadel/zitadel/backend/v3/storage/database" + "github.com/zitadel/zitadel/internal/eventstore" + "github.com/zitadel/zitadel/internal/repository/session" + "github.com/zitadel/zitadel/internal/repository/user" + "github.com/zitadel/zitadel/internal/zerrors" +) + +// tarpitFn represents a tarpit function +// +// The input is the number of failed attempts after which the tarpit is started +type tarpitFn func(failedAttempts uint64) + +type CheckPasswordType struct { + Password string +} + +type PasswordCheckCommand struct { + CheckPassword *CheckPasswordType + + SessionID string + InstanceID string + TarpitFunc tarpitFn + VerifierFn func(encoded, password string) (updated string, err error) + + FetchedUser User + UpdatedHashedPsw string + CheckTime time.Time + + // IsValidated indicates if the password check has completed (no transaction errors) + IsValidated bool + + // IsValidationSuccessful indicates if the completed password check is successful + // (i.e. no functional error is returned) + IsValidationSuccessful bool + + // IsUserLocked indicates if the user has been locked (i.e. lockout policy check failed) + IsUserLocked bool +} + +// NewPasswordCheckCommand initializes a new [PasswordCheckCommand] +// +// If tarpitFunc is nil, the default tarpit will be used. +// +// verifyFn is a function that takes as input a target encoded password +// and an input password to verify. It returns an updated hash and an error. +// It defaults to [passwap.Swapper.Verify] +// +// The command does not implement [Transactional] due verifyFn that might take a long time to execute. +// So the DB transaction will be started only after verifyFn has been run. +// +// Moreover, the command may return a functional error so manual management of the transaction is needed +// to avoid rollbacking a transaction despite having only a functional error. +func NewPasswordCheckCommand(sessionID, instanceID string, tarpitFunc tarpitFn, verifyFn func(encoded, password string) (updated string, err error), request *CheckPasswordType) *PasswordCheckCommand { + tf := sysConfig.Tarpit.Tarpit() + if tarpitFunc != nil { + tf = tarpitFunc + } + + verifierFunction := passwordHasher.Verify + if verifyFn != nil { + verifierFunction = verifyFn + } + + return &PasswordCheckCommand{ + CheckPassword: request, + SessionID: strings.TrimSpace(sessionID), + InstanceID: strings.TrimSpace(instanceID), + TarpitFunc: tf, + VerifierFn: verifierFunction, + } +} + +// Events implements [Commander]. +func (p *PasswordCheckCommand) Events(ctx context.Context, opts *InvokeOpts) ([]eventstore.Command, error) { + if p.CheckPassword == nil || !p.IsValidated { + return nil, nil + } + + toReturn := make([]eventstore.Command, 1, 3) + userAgg := &user.NewAggregate(p.FetchedUser.ID, p.FetchedUser.OrganizationID).Aggregate + + if p.IsValidationSuccessful { + toReturn[0] = user.NewHumanPasswordCheckSucceededEvent(ctx, userAgg, nil) + if p.UpdatedHashedPsw != "" { + toReturn = append(toReturn, user.NewHumanPasswordHashUpdatedEvent(ctx, userAgg, p.UpdatedHashedPsw)) + } + } else { + toReturn[0] = user.NewHumanPasswordCheckFailedEvent(ctx, userAgg, nil) + if p.IsUserLocked { + toReturn = append(toReturn, user.NewUserLockedEvent(ctx, userAgg)) + } + } + + toReturn = append(toReturn, session.NewPasswordCheckedEvent(ctx, &session.NewAggregate(p.SessionID, p.InstanceID).Aggregate, p.CheckTime)) + + return toReturn, nil +} + +// Execute implements [Commander]. +func (p *PasswordCheckCommand) Execute(ctx context.Context, opts *InvokeOpts) (err error) { + if p.CheckPassword == nil { + return nil + } + + humanRepo := opts.userRepo.Human() + sessionRepo := opts.sessionRepo + + updatedHash, verifyErr := p.VerifierFn(p.FetchedUser.Human.Password.Hash, p.CheckPassword.Password) + pswCheckType, err := p.GetPasswordCheckAndError(verifyErr) + changes, changesErr := p.GetPasswordCheckChanges(ctx, opts, humanRepo, updatedHash, pswCheckType) + if changesErr != nil { + return changesErr + } + beginner, ok := opts.DB().(database.Beginner) + if !ok { + return zerrors.ThrowInternal(nil, "DOM-fEhd79", "database doesn't implement database.Beginner") + } + + tx, txErr := beginner.Begin(ctx, nil) + if txErr != nil { + return zerrors.ThrowInternal(txErr, "DOM-IR1vH2", "failed starting transaction") + } + + defer func() { + if endErr := tx.End(ctx, txErr); endErr != nil { + err = endErr + } + }() + + updateCount, updateErr := humanRepo.Update( + ctx, + tx, + + humanRepo.IDCondition(p.FetchedUser.ID), + + changes, + ) + if updateErr != nil { + txErr = zerrors.ThrowInternal(updateErr, "DOM-netNam", "failed updating user") + return txErr + } + + if updateCount == 0 { + txErr = zerrors.ThrowNotFound(nil, "DOM-8wVrNc", "user not found") + return txErr + } + if updateCount > 1 { + txErr = zerrors.ThrowInternal(NewMultipleObjectsUpdatedError(1, updateCount), "DOM-D4hy9C", "unexpected number of rows updated") + return txErr + } + + var passwordFactor SessionFactor + if err == nil { + passwordFactor = &SessionFactorPassword{LastVerifiedAt: p.CheckTime} + } else { + passwordFactor = &SessionFactorPassword{LastFailedAt: p.CheckTime} + } + + updateCount, updateErr = sessionRepo.Update(ctx, tx, sessionRepo.IDCondition(p.SessionID), sessionRepo.SetFactor(passwordFactor)) + if updateErr != nil { + txErr = zerrors.ThrowInternal(updateErr, "DOM-IZagay", "failed updating session") + return txErr + } + + if updateCount == 0 { + txErr = zerrors.ThrowNotFound(nil, "DOM-H9Q59c", "session not found") + return txErr + } + if updateCount > 1 { + txErr = zerrors.ThrowInternal(NewMultipleObjectsUpdatedError(1, updateCount), "DOM-Tbvpy8", "unexpected number of rows updated") + return txErr + } + + if err != nil && p.TarpitFunc != nil { + p.TarpitFunc(uint64(p.FetchedUser.Human.Password.FailedAttempts + 1)) + } + + p.IsValidated = true + p.IsValidationSuccessful = err == nil + + // This error is functional so it should be returned AND the transaction should succeed. + // Hence, do not use [Transactional] and make sure txErr = nil + return err +} + +func (p *PasswordCheckCommand) getLockoutPolicy(ctx context.Context, opts *InvokeOpts, orgID string) (*LockoutSettings, error) { + lockoutSettingRepo := opts.lockoutSettingRepo + + // We need the organization lockout policy first, and if not available, the instance (default) policy. + // So we retrieve all records with a matching instance ID and organization ID OR + // all records with a matching instance ID and NULL (or empty) organization ID. + // Then we assume NULLs are sorted as largest numbers (that's the case in Postgres), + // so we sort ascending by organization ID. + // We limit the result to 1 so that we get either the org policy or the instance one. + settings, err := lockoutSettingRepo.List(ctx, opts.DB(), + p.listLockoutSettingCondition(lockoutSettingRepo, orgID), + database.WithOrderByAscending(lockoutSettingRepo.OrganizationIDColumn(), lockoutSettingRepo.InstanceIDColumn()), + database.WithLimit(1), + ) + if err != nil { + return nil, zerrors.ThrowInternal(err, "DOM-3B8Z6s", "failed fetching lockout settings") + } + + if rowsReturned := len(settings); rowsReturned != 1 { + return nil, zerrors.ThrowInternal(NewRowsReturnedMismatchError(1, int64(rowsReturned)), "DOM-mmsrCt", "unexpected number of rows returned") + } + + return settings[0], nil +} + +func (p *PasswordCheckCommand) listLockoutSettingCondition(repo LockoutSettingsRepository, orgID string) database.QueryOption { + instanceAndOrg := database.And(repo.InstanceIDCondition(p.InstanceID), repo.OrganizationIDCondition(&orgID)) + orgNullOrEmpty := database.Or(repo.OrganizationIDCondition(nil), repo.OrganizationIDCondition(gu.Ptr(""))) + onlyInstance := database.And(repo.InstanceIDCondition(p.InstanceID), orgNullOrEmpty) + + return database.WithCondition(database.Or(instanceAndOrg, onlyInstance)) +} + +func (p *PasswordCheckCommand) GetPasswordCheckChanges(ctx context.Context, opts *InvokeOpts, humanRepo HumanUserRepository, updatedHash string, checkType VerificationType) (database.Changes, error) { + dbUpdates := make(database.Changes, 1) + switch ct := checkType.(type) { + case *VerificationTypeSucceeded: + dbUpdates[0] = humanRepo.SetLastSuccessfulPasswordCheck(ct.VerifiedAt) + if updatedHash != "" { + p.UpdatedHashedPsw = updatedHash + dbUpdates = append(dbUpdates, humanRepo.SetPassword(updatedHash)) + } + case *VerificationTypeFailed: + dbUpdates[0] = humanRepo.IncrementPasswordFailedAttempts() + lockoutPolicy, err := p.getLockoutPolicy(ctx, opts, p.FetchedUser.OrganizationID) + if err != nil { + return nil, err + } + + if lockoutPolicy != nil && + lockoutPolicy.MaxPasswordAttempts != nil && *lockoutPolicy.MaxPasswordAttempts > 0 && + uint64(p.FetchedUser.Human.Password.FailedAttempts+1) >= *lockoutPolicy.MaxPasswordAttempts { + + dbUpdates = append(dbUpdates, humanRepo.SetState(UserStateLocked)) + p.IsUserLocked = true + } + } + + return dbUpdates, nil +} + +func (p *PasswordCheckCommand) GetPasswordCheckAndError(err error) (VerificationType, error) { + p.CheckTime = time.Now() + if err == nil { + return &VerificationTypeSucceeded{VerifiedAt: p.CheckTime}, nil + } + + // TODO(IAM-Marco): Do we actually want to differentiate? I feel that it's giving away relevant info + // about the password + if errors.Is(err, passwap.ErrPasswordMismatch) { + err = zerrors.ThrowInvalidArgument( + NewPasswordVerificationError(p.FetchedUser.Human.Password.FailedAttempts+1), + "DOM-3gcfDV", + "Errors.User.Password.Invalid", + ) + return &VerificationTypeFailed{FailedAt: p.CheckTime}, err + } + + return &VerificationTypeFailed{FailedAt: p.CheckTime}, zerrors.ThrowInternal(err, "DOM-xceNzI", "Errors.Internal") +} + +// String implements [Commander]. +func (p *PasswordCheckCommand) String() string { + return "PasswordCheckCommand" +} + +// Validate implements [Commander]. +func (p *PasswordCheckCommand) Validate(ctx context.Context, opts *InvokeOpts) (err error) { + if p.CheckPassword == nil { + return nil + } + + if p.SessionID == "" { + return zerrors.ThrowPreconditionFailed(nil, "DOM-cRKWNx", "Errors.Missing.SessionID") + } + if p.InstanceID == "" { + return zerrors.ThrowPreconditionFailed(nil, "DOM-JnEtcJ", "Errors.Missing.InstanceID") + } + + sessionRepo := opts.sessionRepo + userRepo := opts.userRepo + + session, err := sessionRepo.Get(ctx, opts.DB(), database.WithCondition(sessionRepo.IDCondition(p.SessionID))) + if err != nil { + if errors.Is(err, &database.NoRowFoundError{}) { + return zerrors.ThrowNotFound(err, "DOM-0XRmp8", "session not found") + } + return zerrors.ThrowInternal(err, "DOM-qAoQrg", "failed fetching session") + } + + if session.UserID == "" { + return zerrors.ThrowPreconditionFailed(nil, "DOM-hord0Z", "Errors.User.UserIDMissing") + } + + user, err := userRepo.Get(ctx, opts.DB(), database.WithCondition(userRepo.IDCondition(session.UserID))) + if err != nil { + if errors.Is(err, &database.NoRowFoundError{}) { + return zerrors.ThrowNotFound(err, "DOM-zxKosn", "Errors.User.NotFound") + } + return zerrors.ThrowInternal(err, "DOM-nKD4Gq", "failed fetching user") + } + if user.Human == nil { + return zerrors.ThrowPreconditionFailed(nil, "DOM-ADhxAx", "user not human") + } + human := user.Human + + if user.State == UserStateLocked { + return zerrors.ThrowPreconditionFailedf( + NewPasswordVerificationError(user.Human.Password.FailedAttempts), + "DOM-D804Sj", + "Errors.User.Locked", + ) + } + + if human.Password.Hash == "" { + return zerrors.ThrowPreconditionFailed(nil, "DOM-gklgos", "Errors.User.Password.NotSet") + } + + p.FetchedUser = *user + + return nil +} + +var _ Commander = (*PasswordCheckCommand)(nil) diff --git a/backend/v3/domain/session_check_password_test.go b/backend/v3/domain/session_check_password_test.go new file mode 100644 index 000000000..d312c9276 --- /dev/null +++ b/backend/v3/domain/session_check_password_test.go @@ -0,0 +1,1214 @@ +package domain_test + +import ( + "errors" + "testing" + "time" + + "github.com/muhlemmer/gu" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/zitadel/passwap" + "go.uber.org/mock/gomock" + + "github.com/zitadel/zitadel/backend/v3/domain" + domainmock "github.com/zitadel/zitadel/backend/v3/domain/mock" + "github.com/zitadel/zitadel/backend/v3/storage/database" + "github.com/zitadel/zitadel/backend/v3/storage/database/dbmock" + noopdb "github.com/zitadel/zitadel/backend/v3/storage/database/dialect/noop" + "github.com/zitadel/zitadel/internal/api/authz" + "github.com/zitadel/zitadel/internal/crypto" + "github.com/zitadel/zitadel/internal/eventstore" + "github.com/zitadel/zitadel/internal/repository/session" + "github.com/zitadel/zitadel/internal/repository/user" + "github.com/zitadel/zitadel/internal/zerrors" +) + +func TestPasswordCheckCommand_Validate(t *testing.T) { + t.Parallel() + sessionGetErr := errors.New("session get error") + userGetErr := errors.New("user get error") + notFoundErr := database.NewNoRowFoundError(nil) + + tt := []struct { + testName string + sessionRepo func(ctrl *gomock.Controller) domain.SessionRepository + userRepo func(ctrl *gomock.Controller) domain.UserRepository + cmd *domain.PasswordCheckCommand + expectedError error + expectedUser domain.User + }{ + { + testName: "when checkPassword is nil should return no error", + cmd: &domain.PasswordCheckCommand{}, + expectedError: nil, + }, + { + testName: "when session ID is not set should return error", + cmd: &domain.PasswordCheckCommand{CheckPassword: &domain.CheckPasswordType{Password: "test-password"}}, + expectedError: zerrors.ThrowPreconditionFailed(nil, "DOM-cRKWNx", "Errors.Missing.SessionID"), + }, + { + testName: "when instance ID is not set should return error", + cmd: domain.NewPasswordCheckCommand("session-1", "", nil, nil, &domain.CheckPasswordType{Password: "test-password"}), + expectedError: zerrors.ThrowPreconditionFailed(nil, "DOM-JnEtcJ", "Errors.Missing.InstanceID"), + }, + { + testName: "when retrieving session fails should return error", + cmd: domain.NewPasswordCheckCommand("session-1", "instance-1", nil, nil, &domain.CheckPasswordType{Password: "test-password"}), + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(nil, sessionGetErr) + return repo + }, + expectedError: zerrors.ThrowInternal(sessionGetErr, "DOM-qAoQrg", "failed fetching session"), + }, + { + testName: "when session not found should return not found error", + cmd: domain.NewPasswordCheckCommand("session-1", "instance-1", nil, nil, &domain.CheckPasswordType{Password: "test-password"}), + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(nil, notFoundErr) + return repo + }, + expectedError: zerrors.ThrowNotFound(notFoundErr, "DOM-0XRmp8", "session not found"), + }, + { + testName: "when session userID is empty should return precondition failed error", + cmd: domain.NewPasswordCheckCommand("session-1", "instance-1", nil, nil, &domain.CheckPasswordType{Password: "test-password"}), + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.Session{ + ID: "session-1", + UserID: "", + }, nil) + return repo + }, + expectedError: zerrors.ThrowPreconditionFailed(nil, "DOM-hord0Z", "Errors.User.UserIDMissing"), + }, + { + testName: "when retrieving user fails should return error", + cmd: domain.NewPasswordCheckCommand("session-1", "instance-1", nil, nil, &domain.CheckPasswordType{Password: "test-password"}), + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.Session{ + ID: "session-1", + UserID: "user-1", + }, nil) + return repo + }, + userRepo: func(ctrl *gomock.Controller) domain.UserRepository { + repo := domainmock.NewUserRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(nil, userGetErr) + return repo + }, + expectedError: zerrors.ThrowInternal(userGetErr, "DOM-nKD4Gq", "failed fetching user"), + }, + { + testName: "when user not found should return not found error", + cmd: domain.NewPasswordCheckCommand("session-1", "instance-1", nil, nil, &domain.CheckPasswordType{Password: "test-password"}), + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.Session{ + ID: "session-1", + UserID: "user-1", + }, nil) + return repo + }, + userRepo: func(ctrl *gomock.Controller) domain.UserRepository { + repo := domainmock.NewUserRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(nil, notFoundErr) + return repo + }, + expectedError: zerrors.ThrowNotFound(notFoundErr, "DOM-zxKosn", "Errors.User.NotFound"), + }, + { + testName: "when user is not human should return precondition failed error", + cmd: domain.NewPasswordCheckCommand("session-1", "instance-1", nil, nil, &domain.CheckPasswordType{Password: "test-password"}), + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.Session{ + ID: "session-1", + UserID: "user-1", + }, nil) + return repo + }, + userRepo: func(ctrl *gomock.Controller) domain.UserRepository { + repo := domainmock.NewUserRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.User{ + ID: "user-1", + Human: nil, + }, nil) + return repo + }, + expectedError: zerrors.ThrowPreconditionFailed(nil, "DOM-ADhxAx", "user not human"), + }, + { + testName: "when user is locked should return precondition failed error", + cmd: domain.NewPasswordCheckCommand("session-1", "instance-1", nil, nil, &domain.CheckPasswordType{Password: "test-password"}), + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.Session{ + ID: "session-1", + UserID: "user-1", + }, nil) + return repo + }, + userRepo: func(ctrl *gomock.Controller) domain.UserRepository { + repo := domainmock.NewUserRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.User{ + ID: "user-1", + State: domain.UserStateLocked, + Human: &domain.HumanUser{ + Password: domain.HumanPassword{ + FailedAttempts: 5, + }, + }, + }, nil) + return repo + }, + expectedError: zerrors.ThrowPreconditionFailed(domain.NewPasswordVerificationError(5), "DOM-D804Sj", "Errors.User.Locked"), + }, + { + testName: "when user password is not set should return precondition failed error", + cmd: domain.NewPasswordCheckCommand("session-1", "instance-1", nil, nil, &domain.CheckPasswordType{Password: "test-password"}), + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.Session{ + ID: "session-1", + UserID: "user-1", + }, nil) + return repo + }, + userRepo: func(ctrl *gomock.Controller) domain.UserRepository { + repo := domainmock.NewUserRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.User{ + ID: "user-1", + State: domain.UserStateActive, + Human: &domain.HumanUser{ + Password: domain.HumanPassword{ + Hash: "", + }, + }, + }, nil) + return repo + }, + expectedError: zerrors.ThrowPreconditionFailed(nil, "DOM-gklgos", "Errors.User.Password.NotSet"), + }, + { + testName: "when all validations pass should return no error and set user", + cmd: domain.NewPasswordCheckCommand("session-1", "instance-1", nil, nil, &domain.CheckPasswordType{Password: "test-password"}), + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.Session{ + ID: "session-1", + UserID: "user-1", + }, nil) + return repo + }, + userRepo: func(ctrl *gomock.Controller) domain.UserRepository { + repo := domainmock.NewUserRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Get(gomock.Any(), gomock.Any(), dbmock.QueryOptions( + database.WithCondition( + idCondition, + ), + )). + Times(1). + Return(&domain.User{ + ID: "user-1", + State: domain.UserStateActive, + Human: &domain.HumanUser{ + Password: domain.HumanPassword{ + Hash: "hashed-password", + FailedAttempts: 0, + }, + }, + }, nil) + return repo + }, + expectedUser: domain.User{ + ID: "user-1", + State: domain.UserStateActive, + Human: &domain.HumanUser{ + Password: domain.HumanPassword{ + Hash: "hashed-password", + FailedAttempts: 0, + }, + }, + }, + }, + } + + for _, tc := range tt { + t.Run(tc.testName, func(t *testing.T) { + t.Parallel() + // Given + ctx := authz.NewMockContext(tc.cmd.InstanceID, "", "") + ctrl := gomock.NewController(t) + + opts := &domain.InvokeOpts{ + Invoker: domain.NewTransactionInvoker(nil), + } + domain.WithQueryExecutor(new(noopdb.Pool))(opts) + if tc.sessionRepo != nil { + domain.WithSessionRepo(tc.sessionRepo(ctrl))(opts) + } + if tc.userRepo != nil { + domain.WithUserRepo(tc.userRepo(ctrl))(opts) + } + + // Test + err := tc.cmd.Validate(ctx, opts) + + // Verify + assert.ErrorIs(t, err, tc.expectedError) + assert.Equal(t, tc.expectedUser, tc.cmd.FetchedUser) + }) + } +} + +func TestPasswordCheckCommand_GetPasswordCheckAndError(t *testing.T) { + t.Parallel() + otherErr := errors.New("some other error") + + tt := []struct { + testName string + inputErr error + fetchedUser domain.User + expectedCheckType domain.VerificationType + expectedError error + }{ + { + testName: "when error is nil should return CheckTypeSucceeded with no error", + inputErr: nil, + fetchedUser: domain.User{}, + expectedCheckType: &domain.VerificationTypeSucceeded{}, + expectedError: nil, + }, + { + testName: "when error is password mismatch should return CheckTypeFailed with invalid argument error", + inputErr: passwap.ErrPasswordMismatch, + fetchedUser: domain.User{ + Human: &domain.HumanUser{ + Password: domain.HumanPassword{ + FailedAttempts: 2, + }, + }, + }, + expectedCheckType: &domain.VerificationTypeFailed{}, + expectedError: zerrors.ThrowInvalidArgument(domain.NewPasswordVerificationError(3), "DOM-3gcfDV", "Errors.User.Password.Invalid"), + }, + { + testName: "when error is other error should return CheckTypeFailed with internal error", + inputErr: otherErr, + fetchedUser: domain.User{ + Human: &domain.HumanUser{ + Password: domain.HumanPassword{ + FailedAttempts: 0, + }, + }, + }, + expectedCheckType: &domain.VerificationTypeFailed{}, + expectedError: zerrors.ThrowInternal(otherErr, "DOM-xceNzI", "Errors.Internal"), + }, + } + + for _, tc := range tt { + t.Run(tc.testName, func(t *testing.T) { + t.Parallel() + // Given + cmd := domain.NewPasswordCheckCommand("session-1", "instance-1", nil, nil, &domain.CheckPasswordType{Password: "test"}) + cmd.FetchedUser = tc.fetchedUser + + // Test + checkType, err := cmd.GetPasswordCheckAndError(tc.inputErr) + + // Verify + assert.IsType(t, tc.expectedCheckType, checkType) + assert.ErrorIs(t, err, tc.expectedError) + if tc.expectedError != nil { + checkFailed := checkType.(*domain.VerificationTypeFailed) + assert.NotZero(t, checkFailed.FailedAt) + } else { + checkSuccess := checkType.(*domain.VerificationTypeSucceeded) + assert.NotZero(t, checkSuccess.VerifiedAt) + } + }) + } +} + +func TestPasswordCheckCommand_GetPasswordCheckChanges(t *testing.T) { + t.Parallel() + listErr := errors.New("list error") + + tt := []struct { + testName string + humanRepo func(ctrl *gomock.Controller, checkTime time.Time) domain.HumanUserRepository + lockoutRepo func(ctrl *gomock.Controller) domain.LockoutSettingsRepository + updatedHash string + checkType domain.VerificationType + cmd *domain.PasswordCheckCommand + + expectedChanges int + expectedError error + expectedHashedPsw string + expectedUserLocked bool + }{ + { + testName: "when check type succeeded with empty hash should return only check password change", + humanRepo: func(ctrl *gomock.Controller, checkTime time.Time) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + return repo + }, + cmd: &domain.PasswordCheckCommand{ + CheckTime: time.Now(), + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(_, _ string) (_ string, _ error) { return "", nil }, + CheckPassword: &domain.CheckPasswordType{Password: "test"}, + }, + updatedHash: "", + checkType: &domain.VerificationTypeSucceeded{}, + expectedChanges: 1, + }, + { + testName: "when check type succeeded with hash should return check password and set password changes", + humanRepo: func(ctrl *gomock.Controller, checkTime time.Time) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + return repo + }, + cmd: &domain.PasswordCheckCommand{ + CheckTime: time.Now(), + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(_, _ string) (_ string, _ error) { return "", nil }, + CheckPassword: &domain.CheckPasswordType{Password: "test"}, + }, + updatedHash: "new-hash", + checkType: &domain.VerificationTypeSucceeded{}, + expectedChanges: 2, + expectedHashedPsw: "new-hash", + }, + { + testName: "when check type failed and no lockout policy should return internal error", + humanRepo: func(ctrl *gomock.Controller, checkTime time.Time) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + return repo + }, + lockoutRepo: func(ctrl *gomock.Controller) domain.LockoutSettingsRepository { + repo := domainmock.NewLockoutSettingsRepo(ctrl) + + instanceAndOrg := database.And(repo.InstanceIDCondition("instance-1"), repo.OrganizationIDCondition(gu.Ptr("org-1"))) + orgNullOrEmpty := database.Or(repo.OrganizationIDCondition(nil), repo.OrganizationIDCondition(gu.Ptr(""))) + onlyInstance := database.And(repo.InstanceIDCondition("instance-1"), orgNullOrEmpty) + orCondition := database.Or(instanceAndOrg, onlyInstance) + + repo.EXPECT(). + List(gomock.Any(), gomock.Any(), + dbmock.QueryOptions(database.WithCondition(orCondition)), + dbmock.QueryOptions(database.WithOrderByAscending(repo.OrganizationIDColumn(), repo.InstanceIDColumn())), + dbmock.QueryOptions(database.WithLimit(1)), + ).Times(1). + Return(nil, nil) + + return repo + }, + updatedHash: "", + checkType: &domain.VerificationTypeFailed{}, + cmd: &domain.PasswordCheckCommand{ + CheckTime: time.Now(), + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(_, _ string) (_ string, _ error) { return "", nil }, + CheckPassword: &domain.CheckPasswordType{Password: "test"}, + FetchedUser: domain.User{OrganizationID: "org-1"}, + }, + expectedError: zerrors.ThrowInternal(domain.NewRowsReturnedMismatchError(1, 0), "DOM-mmsrCt", "unexpected number of rows returned"), + }, + { + testName: "when check type failed and get lockout policy returns error should return error", + humanRepo: func(ctrl *gomock.Controller, checkTime time.Time) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + return repo + }, + lockoutRepo: func(ctrl *gomock.Controller) domain.LockoutSettingsRepository { + repo := domainmock.NewLockoutSettingsRepo(ctrl) + + instanceAndOrg := database.And(repo.InstanceIDCondition("instance-1"), repo.OrganizationIDCondition(gu.Ptr("org-1"))) + orgNullOrEmpty := database.Or(repo.OrganizationIDCondition(nil), repo.OrganizationIDCondition(gu.Ptr(""))) + onlyInstance := database.And(repo.InstanceIDCondition("instance-1"), orgNullOrEmpty) + orCondition := database.Or(instanceAndOrg, onlyInstance) + + repo.EXPECT(). + List(gomock.Any(), gomock.Any(), + dbmock.QueryOptions(database.WithCondition(orCondition)), + dbmock.QueryOptions(database.WithOrderByAscending(repo.OrganizationIDColumn(), repo.InstanceIDColumn())), + dbmock.QueryOptions(database.WithLimit(1)), + ).Times(1). + Return(nil, listErr) + + return repo + }, + cmd: &domain.PasswordCheckCommand{ + CheckTime: time.Now(), + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(_, _ string) (_ string, _ error) { return "", nil }, + CheckPassword: &domain.CheckPasswordType{Password: "test"}, + FetchedUser: domain.User{OrganizationID: "org-1"}, + }, + updatedHash: "", + checkType: &domain.VerificationTypeFailed{}, + expectedError: zerrors.ThrowInternal(listErr, "DOM-3B8Z6s", "failed fetching lockout settings"), + }, + { + testName: "when check type failed with nil max attempts should return check type failed change", + humanRepo: func(ctrl *gomock.Controller, checkTime time.Time) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + return repo + }, + lockoutRepo: func(ctrl *gomock.Controller) domain.LockoutSettingsRepository { + repo := domainmock.NewLockoutSettingsRepo(ctrl) + + instanceAndOrg := database.And(repo.InstanceIDCondition("instance-1"), repo.OrganizationIDCondition(gu.Ptr("org-1"))) + orgNullOrEmpty := database.Or(repo.OrganizationIDCondition(nil), repo.OrganizationIDCondition(gu.Ptr(""))) + onlyInstance := database.And(repo.InstanceIDCondition("instance-1"), orgNullOrEmpty) + orCondition := database.Or(instanceAndOrg, onlyInstance) + + setting := &domain.LockoutSettings{ + Settings: domain.Settings{}, + LockoutSettingsAttributes: domain.LockoutSettingsAttributes{}, + } + + repo.EXPECT(). + List(gomock.Any(), gomock.Any(), + dbmock.QueryOptions(database.WithCondition(orCondition)), + dbmock.QueryOptions(database.WithOrderByAscending(repo.OrganizationIDColumn(), repo.InstanceIDColumn())), + dbmock.QueryOptions(database.WithLimit(1)), + ).Times(1). + Return([]*domain.LockoutSettings{ + setting, + }, nil) + + return repo + }, + updatedHash: "", + checkType: &domain.VerificationTypeFailed{}, + cmd: &domain.PasswordCheckCommand{ + CheckTime: time.Now(), + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(_, _ string) (_ string, _ error) { return "", nil }, + CheckPassword: &domain.CheckPasswordType{Password: "test"}, + FetchedUser: domain.User{OrganizationID: "org-1"}, + }, + expectedChanges: 1, + }, + { + testName: "when check type failed and user max attempts >= lockout policy max attempts should return check type and user locked changes", + humanRepo: func(ctrl *gomock.Controller, checkTime time.Time) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + return repo + }, + lockoutRepo: func(ctrl *gomock.Controller) domain.LockoutSettingsRepository { + repo := domainmock.NewLockoutSettingsRepo(ctrl) + + instanceAndOrg := database.And(repo.InstanceIDCondition("instance-1"), repo.OrganizationIDCondition(gu.Ptr("org-1"))) + orgNullOrEmpty := database.Or(repo.OrganizationIDCondition(nil), repo.OrganizationIDCondition(gu.Ptr(""))) + onlyInstance := database.And(repo.InstanceIDCondition("instance-1"), orgNullOrEmpty) + orCondition := database.Or(instanceAndOrg, onlyInstance) + + setting := &domain.LockoutSettings{ + Settings: domain.Settings{}, + LockoutSettingsAttributes: domain.LockoutSettingsAttributes{ + MaxPasswordAttempts: gu.Ptr(uint64(1)), + }, + } + + repo.EXPECT(). + List(gomock.Any(), gomock.Any(), + dbmock.QueryOptions(database.WithCondition(orCondition)), + dbmock.QueryOptions(database.WithOrderByAscending(repo.OrganizationIDColumn(), repo.InstanceIDColumn())), + dbmock.QueryOptions(database.WithLimit(1)), + ).Times(1). + Return([]*domain.LockoutSettings{ + setting, + }, nil) + + return repo + }, + updatedHash: "", + checkType: &domain.VerificationTypeFailed{}, + cmd: &domain.PasswordCheckCommand{ + CheckTime: time.Now(), + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(_, _ string) (_ string, _ error) { return "", nil }, + CheckPassword: &domain.CheckPasswordType{Password: "test"}, + FetchedUser: domain.User{ + OrganizationID: "org-1", + Human: &domain.HumanUser{Password: domain.HumanPassword{FailedAttempts: 2}}, + }, + }, + expectedChanges: 2, + expectedUserLocked: true, + }, + } + + for _, tc := range tt { + t.Run(tc.testName, func(t *testing.T) { + t.Parallel() + + // Given + ctx := authz.NewMockContext("instance-1", "", "") + ctrl := gomock.NewController(t) + + opts := &domain.InvokeOpts{ + Invoker: domain.NewTransactionInvoker(nil), + } + domain.WithQueryExecutor(new(noopdb.Pool))(opts) + if tc.lockoutRepo != nil { + domain.WithLockoutSettingsRepo(tc.lockoutRepo(ctrl))(opts) + } + + // Test + changes, err := tc.cmd.GetPasswordCheckChanges(ctx, opts, tc.humanRepo(ctrl, tc.cmd.CheckTime), tc.updatedHash, tc.checkType) + + // Verify + assert.ErrorIs(t, err, tc.expectedError) + assert.Equal(t, tc.expectedHashedPsw, tc.cmd.UpdatedHashedPsw) + assert.Equal(t, tc.expectedUserLocked, tc.cmd.IsUserLocked) + assert.Len(t, changes, tc.expectedChanges) + }) + } +} + +func TestPasswordCheckCommand_Execute(t *testing.T) { + t.Parallel() + + userUpdateErr := errors.New("user update error") + sessionUpdateErr := errors.New("session update error") + + tt := []struct { + testName string + humanRepo func(ctrl *gomock.Controller) domain.HumanUserRepository + lockoutRepo func(ctrl *gomock.Controller) domain.LockoutSettingsRepository + sessionRepo func(ctrl *gomock.Controller) domain.SessionRepository + + cmd *domain.PasswordCheckCommand + + expectTarpitCalled bool + expectedError error + expectedValidated bool + expectedValidationSuccess bool + expectedUserLocked bool + }{ + { + testName: "when checkPassword is nil should return no error", + cmd: &domain.PasswordCheckCommand{}, + expectedError: nil, + }, + { + testName: "when user update fails should return error", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "test-password"}, + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(password string, hash string) (string, error) { return "", nil }, + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + Human: &domain.HumanUser{Password: domain.HumanPassword{ + Hash: "hashed-password", + FailedAttempts: 0, + }}, + }, + }, + humanRepo: func(ctrl *gomock.Controller) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, gomock.Any()). + Times(1). + Return(int64(0), userUpdateErr) + return repo + }, + expectedError: zerrors.ThrowInternal(userUpdateErr, "DOM-netNam", "failed updating user"), + }, + { + testName: "when user not found should return not found error", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "test-password"}, + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(password string, hash string) (string, error) { return "", nil }, + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + Human: &domain.HumanUser{Password: domain.HumanPassword{ + Hash: "hashed-password", + FailedAttempts: 0, + }}, + }, + }, + humanRepo: func(ctrl *gomock.Controller) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, gomock.Any()). + Times(1). + Return(int64(0), nil) + return repo + }, + expectedError: zerrors.ThrowNotFound(nil, "DOM-8wVrNc", "user not found"), + }, + { + testName: "when user update returns multiple rows should return internal error", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "test-password"}, + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(password string, hash string) (string, error) { return "", nil }, + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + Human: &domain.HumanUser{Password: domain.HumanPassword{ + Hash: "hashed-password", + FailedAttempts: 0, + }}, + }, + }, + humanRepo: func(ctrl *gomock.Controller) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, gomock.Any()). + Times(1). + Return(int64(2), nil) + return repo + }, + expectedError: zerrors.ThrowInternal(domain.NewMultipleObjectsUpdatedError(1, 2), "DOM-D4hy9C", "unexpected number of rows updated"), + }, + { + testName: "when session update fails should return error", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "test-password"}, + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(password string, hash string) (string, error) { return "", nil }, + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + Human: &domain.HumanUser{Password: domain.HumanPassword{ + Hash: "hashed-password", + FailedAttempts: 0, + }}, + }, + }, + humanRepo: func(ctrl *gomock.Controller) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, gomock.Any()). + Times(1). + Return(int64(1), nil) + return repo + }, + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + sessionFactorChange := repo.SetFactor(&domain.SessionFactorPassword{LastVerifiedAt: time.Now()}) + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, sessionFactorChange). + Times(1). + Return(int64(0), sessionUpdateErr) + return repo + }, + expectedError: zerrors.ThrowInternal(sessionUpdateErr, "DOM-IZagay", "failed updating session"), + }, + { + testName: "when session not found should return not found error", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "test-password"}, + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(password string, hash string) (string, error) { return "", nil }, + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + Human: &domain.HumanUser{Password: domain.HumanPassword{ + Hash: "hashed-password", + FailedAttempts: 0, + }}, + }, + }, + humanRepo: func(ctrl *gomock.Controller) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, gomock.Any()). + Times(1). + Return(int64(1), nil) + return repo + }, + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + sessionFactorChange := repo.SetFactor(&domain.SessionFactorPassword{LastVerifiedAt: time.Now()}) + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, sessionFactorChange). + Times(1). + Return(int64(0), nil) + return repo + }, + expectedError: zerrors.ThrowNotFound(nil, "DOM-H9Q59c", "session not found"), + }, + { + testName: "when session update returns multiple rows should return internal error", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "test-password"}, + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(password string, hash string) (string, error) { return "", nil }, + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + Human: &domain.HumanUser{Password: domain.HumanPassword{ + Hash: "hashed-password", + FailedAttempts: 0, + }}, + }, + }, + humanRepo: func(ctrl *gomock.Controller) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, gomock.Any()). + Times(1). + Return(int64(1), nil) + return repo + }, + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + sessionFactorChange := repo.SetFactor(&domain.SessionFactorPassword{LastVerifiedAt: time.Now()}) + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, sessionFactorChange). + Times(1). + Return(int64(2), nil) + return repo + }, + expectedError: zerrors.ThrowInternal(domain.NewMultipleObjectsUpdatedError(1, 2), "DOM-Tbvpy8", "unexpected number of rows updated"), + }, + { + testName: "when password check succeeds should execute successfully", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "test-password"}, + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(password string, hash string) (string, error) { return "", nil }, + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + Human: &domain.HumanUser{Password: domain.HumanPassword{ + Hash: "hashed-password", + FailedAttempts: 0, + }}, + }, + }, + humanRepo: func(ctrl *gomock.Controller) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, gomock.Any()). + Times(1). + Return(int64(1), nil) + return repo + }, + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + sessionFactorChange := repo.SetFactor(&domain.SessionFactorPassword{LastVerifiedAt: time.Now()}) + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, sessionFactorChange). + Times(1). + Return(int64(1), nil) + return repo + }, + expectedError: nil, + expectedValidated: true, + expectedValidationSuccess: true, + }, + { + testName: "when password check fails should execute successfully with failed state", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "wrong-password"}, + SessionID: "session-1", + InstanceID: "instance-1", + VerifierFn: func(password string, hash string) (string, error) { + return "", passwap.ErrPasswordMismatch + }, + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + Human: &domain.HumanUser{Password: domain.HumanPassword{ + Hash: "hashed-password", + FailedAttempts: 2, + }}, + }, + }, + lockoutRepo: func(ctrl *gomock.Controller) domain.LockoutSettingsRepository { + repo := domainmock.NewLockoutSettingsRepo(ctrl) + + instanceAndOrg := database.And(repo.InstanceIDCondition("instance-1"), repo.OrganizationIDCondition(gu.Ptr("org-1"))) + orgNullOrEmpty := database.Or(repo.OrganizationIDCondition(nil), repo.OrganizationIDCondition(gu.Ptr(""))) + onlyInstance := database.And(repo.InstanceIDCondition("instance-1"), orgNullOrEmpty) + orCondition := database.Or(instanceAndOrg, onlyInstance) + + setting := &domain.LockoutSettings{ + Settings: domain.Settings{}, + LockoutSettingsAttributes: domain.LockoutSettingsAttributes{ + MaxPasswordAttempts: gu.Ptr(uint64(1)), + }, + } + + repo.EXPECT(). + List(gomock.Any(), gomock.Any(), + dbmock.QueryOptions(database.WithCondition(orCondition)), + dbmock.QueryOptions(database.WithOrderByAscending(repo.OrganizationIDColumn(), repo.InstanceIDColumn())), + dbmock.QueryOptions(database.WithLimit(1)), + ).Times(1). + Return([]*domain.LockoutSettings{ + setting, + }, nil) + + return repo + }, + humanRepo: func(ctrl *gomock.Controller) domain.HumanUserRepository { + repo := domainmock.NewHumanRepo(ctrl) + idCondition := repo.IDCondition("user-1") + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, gomock.Any()). + Times(1). + Return(int64(1), nil) + return repo + }, + sessionRepo: func(ctrl *gomock.Controller) domain.SessionRepository { + repo := domainmock.NewSessionRepo(ctrl) + idCondition := repo.IDCondition("session-1") + sessionFactorChange := repo.SetFactor(&domain.SessionFactorPassword{LastFailedAt: time.Now()}) + repo.EXPECT(). + Update(gomock.Any(), gomock.Any(), idCondition, sessionFactorChange). + Times(1). + Return(int64(1), nil) + return repo + }, + expectTarpitCalled: true, + expectedError: zerrors.ThrowInvalidArgument(domain.NewPasswordVerificationError(3), "DOM-3gcfDV", "Errors.User.Password.Invalid"), + expectedValidated: true, + expectedValidationSuccess: false, + expectedUserLocked: true, + }, + } + + for _, tc := range tt { + t.Run(tc.testName, func(t *testing.T) { + t.Parallel() + // Given + ctx := authz.NewMockContext("instance-1", "", "") + ctrl := gomock.NewController(t) + + tarpitCalled := false + tc.cmd.TarpitFunc = func(_ uint64) { + tarpitCalled = true + } + + opts := &domain.InvokeOpts{ + Invoker: domain.NewTransactionInvoker(nil), + } + domain.WithQueryExecutor(new(noopdb.Pool))(opts) + if tc.sessionRepo != nil { + domain.WithSessionRepo(tc.sessionRepo(ctrl))(opts) + } + if tc.lockoutRepo != nil { + domain.WithLockoutSettingsRepo(tc.lockoutRepo(ctrl))(opts) + } + if tc.humanRepo != nil { + humanRepo := tc.humanRepo(ctrl) + userRepo := domainmock.NewMockUserRepository(ctrl) + userRepo.EXPECT().Human().Times(1).Return(humanRepo) + domain.WithUserRepo(userRepo)(opts) + } + + // Test + err := tc.cmd.Execute(ctx, opts) + + // Verify + assert.ErrorIs(t, err, tc.expectedError) + if tc.cmd.CheckPassword != nil { + assert.Equal(t, tc.expectedValidated, tc.cmd.IsValidated) + assert.Equal(t, tc.expectedValidationSuccess, tc.cmd.IsValidationSuccessful) + assert.Equal(t, tc.expectedUserLocked, tc.cmd.IsUserLocked) + assert.Equal(t, tc.expectTarpitCalled, tarpitCalled) + } + }) + } +} + +func TestPasswordCheckCommand_Events(t *testing.T) { + t.Parallel() + domain.SetPasswordHasher(&crypto.Hasher{}) + userAgg := user.NewAggregate("user-1", "org-1").Aggregate + sessAgg := session.NewAggregate("session-1", "instance-1").Aggregate + + tt := []struct { + testName string + cmd *domain.PasswordCheckCommand + expectedEventTypes []eventstore.Command + }{ + { + testName: "when checkPassword is nil should return nil", + cmd: &domain.PasswordCheckCommand{IsValidated: true}, + }, + { + testName: "when not validated should return nil", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "test"}, + IsValidated: false, + }, + }, + { + testName: "when validation successful with no hash update should return check succeeded and password checked events", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "test"}, + IsValidated: true, + IsValidationSuccessful: true, + UpdatedHashedPsw: "", + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + }, + SessionID: "session-1", + InstanceID: "instance-1", + CheckTime: time.Now(), + }, + expectedEventTypes: []eventstore.Command{ + user.NewHumanPasswordCheckSucceededEvent(t.Context(), &userAgg, nil), + session.NewPasswordCheckedEvent(t.Context(), &sessAgg, time.Now()), + }, + }, + { + testName: "when validation successful with hash update should return check succeeded, hash updated, and password checked events", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "test"}, + IsValidated: true, + IsValidationSuccessful: true, + UpdatedHashedPsw: "new-hash", + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + }, + SessionID: "session-1", + InstanceID: "instance-1", + CheckTime: time.Now(), + }, + expectedEventTypes: []eventstore.Command{ + user.NewHumanPasswordCheckSucceededEvent(t.Context(), &userAgg, nil), + user.NewHumanPasswordHashUpdatedEvent(t.Context(), &userAgg, "new-hash"), + session.NewPasswordCheckedEvent(t.Context(), &sessAgg, time.Now()), + }, + }, + { + testName: "when validation failed without user locked should return check failed and password checked events", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "wrong"}, + IsValidated: true, + IsValidationSuccessful: false, + IsUserLocked: false, + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + }, + SessionID: "session-1", + InstanceID: "instance-1", + CheckTime: time.Now(), + }, + expectedEventTypes: []eventstore.Command{ + user.NewHumanPasswordCheckFailedEvent(t.Context(), &userAgg, nil), + session.NewPasswordCheckedEvent(t.Context(), &sessAgg, time.Now()), + }, + }, + { + testName: "when validation failed with user locked should return check failed, user locked, and password checked events", + cmd: &domain.PasswordCheckCommand{ + CheckPassword: &domain.CheckPasswordType{Password: "wrong"}, + IsValidated: true, + IsValidationSuccessful: false, + IsUserLocked: true, + FetchedUser: domain.User{ + ID: "user-1", + OrganizationID: "org-1", + }, + SessionID: "session-1", + InstanceID: "instance-1", + CheckTime: time.Now(), + }, + expectedEventTypes: []eventstore.Command{ + user.NewHumanPasswordCheckFailedEvent(t.Context(), &userAgg, nil), + user.NewUserLockedEvent(t.Context(), &userAgg), + session.NewPasswordCheckedEvent(t.Context(), &sessAgg, time.Now())}, + }, + } + + for _, tc := range tt { + t.Run(tc.testName, func(t *testing.T) { + t.Parallel() + // Given + ctx := authz.NewMockContext(tc.cmd.InstanceID, "", "") + + // Test + events, err := tc.cmd.Events(ctx, &domain.InvokeOpts{}) + + // Verify + assert.NoError(t, err) + require.Len(t, events, len(tc.expectedEventTypes)) + for i, expectedType := range tc.expectedEventTypes { + assert.IsType(t, expectedType, events[i]) + switch expectedAssertedType := expectedType.(type) { + case *user.HumanPasswordCheckSucceededEvent: + actualAssertedType, ok := events[i].(*user.HumanPasswordCheckSucceededEvent) + require.True(t, ok) + assert.Equal(t, expectedAssertedType.AuthRequestInfo, actualAssertedType.AuthRequestInfo) + case *user.HumanPasswordCheckFailedEvent: + actualAssertedType, ok := events[i].(*user.HumanPasswordCheckFailedEvent) + require.True(t, ok) + assert.Equal(t, expectedAssertedType.AuthRequestInfo, actualAssertedType.AuthRequestInfo) + case *user.UserLockedEvent: + continue + case *user.HumanPasswordHashUpdatedEvent: + actualAssertedType, ok := events[i].(*user.HumanPasswordHashUpdatedEvent) + require.True(t, ok) + assert.Equal(t, expectedAssertedType.EncodedHash, actualAssertedType.EncodedHash) + case *session.PasswordCheckedEvent: + actualAssertedType, ok := events[i].(*session.PasswordCheckedEvent) + require.True(t, ok) + assert.InDelta(t, expectedAssertedType.CheckedAt.UnixMilli(), actualAssertedType.CheckedAt.UnixMilli(), 10) + } + } + }) + } +} diff --git a/backend/v3/domain/settings.go b/backend/v3/domain/settings.go index e60ad650b..f479e919f 100644 --- a/backend/v3/domain/settings.go +++ b/backend/v3/domain/settings.go @@ -162,6 +162,7 @@ type LoginSettingsAttributes struct { SecondFactorTypes []SecondFactorType `json:"secondFactors,omitempty"` } +//go:generate mockgen -typed -package domainmock -destination ./mock/login_settings.mock.go . LoginSettingsRepository type LoginSettingsRepository interface { settingsRepository[LoginSettings] loginSettingsJSONChanges @@ -228,6 +229,7 @@ type BrandingSettingsAttributes struct { FontURL *url.URL `json:"fontUrl,omitempty"` } +//go:generate mockgen -typed -package domainmock -destination ./mock/branding_settings.mock.go . BrandingSettingsRepository type BrandingSettingsRepository interface { settingsRepository[BrandingSettings] brandingSettingsJSONChanges @@ -261,6 +263,7 @@ type PasswordComplexitySettingsAttributes struct { HasSymbol *bool `json:"hasSymbol,omitempty"` } +//go:generate mockgen -typed -package domainmock -destination ./mock/password_complexity_settings.mock.go . PasswordComplexitySettingsRepository type PasswordComplexitySettingsRepository interface { settingsRepository[PasswordComplexitySettings] passwordComplexitySettingsJSONChanges @@ -283,6 +286,7 @@ type PasswordExpirySettingsAttributes struct { MaxAgeDays *uint64 `json:"maxAgeDays,omitempty"` } +//go:generate mockgen -typed -package domainmock -destination ./mock/password_expiry_settings.mock.go . PasswordExpirySettingsRepository type PasswordExpirySettingsRepository interface { settingsRepository[PasswordExpirySettings] passwordExpirySettingsJSONChanges @@ -307,6 +311,7 @@ type LockoutSettingsAttributes struct { ShowLockOutFailures *bool `json:"showLockOutFailures,omitempty"` } +//go:generate mockgen -typed -package domainmock -destination ./mock/lockout_settings.mock.go . LockoutSettingsRepository type LockoutSettingsRepository interface { settingsRepository[LockoutSettings] lockoutSettingsJSONChanges @@ -331,6 +336,7 @@ type SecuritySettingsAttributes struct { EnableImpersonation *bool `json:"enableImpersonation,omitempty"` } +//go:generate mockgen -typed -package domainmock -destination ./mock/security_settings.mock.go . SecuritySettingsRepository type SecuritySettingsRepository interface { settingsRepository[SecuritySettings] securitySettingsJSONChanges @@ -354,6 +360,7 @@ type DomainSettingsAttributes struct { SMTPSenderAddressMatchesInstanceDomain *bool `json:"smtpSenderAddressMatchesInstanceDomain,omitempty"` } +//go:generate mockgen -typed -package domainmock -destination ./mock/domain_settings.mock.go . DomainSettingsRepository type DomainSettingsRepository interface { settingsRepository[DomainSettings] domainSettingsJSONChanges @@ -373,6 +380,7 @@ type OrganizationSettingsAttributes struct { OrganizationScopedUsernames *bool `json:"organizationScopedUsernames,omitempty"` } +//go:generate mockgen -typed -package domainmock -destination ./mock/organization_settings.mock.go . OrganizationSettingsRepository type OrganizationSettingsRepository interface { settingsRepository[OrganizationSettings] organizationSettingsJSONChanges @@ -393,6 +401,7 @@ type NotificationSettingsAttributes struct { PasswordChange *bool `json:"passwordChange,omitempty"` } +//go:generate mockgen -typed -package domainmock -destination ./mock/notification_settings.mock.go . NotificationSettingsRepository type NotificationSettingsRepository interface { settingsRepository[NotificationSettings] notificationSettingsJSONChanges @@ -425,6 +434,7 @@ type LegalAndSupportSettingsAttributes struct { CustomLinkText *string `json:"customLinkText,omitempty"` } +//go:generate mockgen -typed -package domainmock -destination ./mock/legal_and_support_settings.mock.go . LegalAndSupportSettingsRepository type LegalAndSupportSettingsRepository interface { settingsRepository[LegalAndSupportSettings] legalAndSupportSettingsJSONChanges diff --git a/cmd/start/start.go b/cmd/start/start.go index 0d37a915f..4e0dbc766 100644 --- a/cmd/start/start.go +++ b/cmd/start/start.go @@ -208,6 +208,7 @@ func startZitadel(ctx context.Context, config *Config, masterKey string, server })) new_domain.SetLegacyEventstore(eventstoreClient) + new_domain.SetSystemConfig(config.SystemDefaults) sessionTokenVerifier := internal_authz.SessionTokenVerifier(keys.OIDC) cacheConnectors, err := connector.StartConnectors(config.Caches, dbClient) diff --git a/internal/command/command.go b/internal/command/command.go index 3a03016c0..f235100d0 100644 --- a/internal/command/command.go +++ b/internal/command/command.go @@ -19,6 +19,7 @@ import ( "github.com/go-jose/go-jose/v4" "github.com/zitadel/logging" + new_domain "github.com/zitadel/zitadel/backend/v3/domain" "github.com/zitadel/zitadel/internal/api/authz" api_http "github.com/zitadel/zitadel/internal/api/http" "github.com/zitadel/zitadel/internal/cache/connector" @@ -152,6 +153,9 @@ func StartCommands( if err != nil { return nil, fmt.Errorf("password hasher: %w", err) } + + new_domain.SetPasswordHasher(userPasswordHasher) + caches, err := startCaches(ctx, cacheConnectors) if err != nil { return nil, fmt.Errorf("caches: %w", err)