database

package
v0.0.0-...-f033388 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 13, 2024 License: MIT Imports: 24 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AuditLog 

type AuditLog struct {
	*gensql.AuditLog
}

type AuditLogsRepo 

type AuditLogsRepo interface {
	CreateAuditLogEntry(ctx context.Context, correlationID uuid.UUID, actor *string, targetType audittype.AuditLogsTargetType, targetIdentifier string, action audittype.AuditAction, message string) error
	GetAuditLogsForCorrelationID(ctx context.Context, correlationID uuid.UUID, p Page) ([]*AuditLog, int, error)
	GetAuditLogsForReconciler(ctx context.Context, reconcilerName string, p Page) ([]*AuditLog, int, error)
	GetAuditLogsForTeam(ctx context.Context, teamSlug slug.Slug, p Page) ([]*AuditLog, int, error)
}

type CostRepo 

type CostRepo interface {
	CostForInstance(ctx context.Context, costType string, fromDate, toDate pgtype.Date, teamSlug slug.Slug, appName, environment string) (float32, error)
	CostRefresh(ctx context.Context) error
	CostUpsert(ctx context.Context, arg []gensql.CostUpsertParams) *gensql.CostUpsertBatchResults
	CurrentSqlInstancesCostForTeam(ctx context.Context, teamSlug slug.Slug) (float32, error)
	DailyCostForApp(ctx context.Context, fromDate pgtype.Date, toDate pgtype.Date, environment string, teamSlug slug.Slug, app string) ([]*gensql.Cost, error)
	DailyCostForTeam(ctx context.Context, fromDate pgtype.Date, toDate pgtype.Date, teamSlug slug.Slug) ([]*gensql.Cost, error)
	DailyEnvCostForTeam(ctx context.Context, fromDate pgtype.Date, toDate pgtype.Date, environment *string, teamSlug slug.Slug) ([]*gensql.DailyEnvCostForTeamRow, error)
	LastCostDate(ctx context.Context) (pgtype.Date, error)
	MonthlyCostForApp(ctx context.Context, teamSlug slug.Slug, app string, environment string) ([]*gensql.MonthlyCostForAppRow, error)
	MonthlyCostForTeam(ctx context.Context, teamSlug slug.Slug) ([]*gensql.CostMonthlyTeam, error)
}

type Database 

type Database interface {
	AuditLogsRepo
	CostRepo
	EnvironmentRepo
	ReconcilerErrorRepo
	ReconcilerRepo
	ReconcilerStateRepo
	RepositoryAuthorizationRepo
	ResourceUtilizationRepo
	RoleRepo
	ServiceAccountRepo
	SessionRepo
	TeamRepo
	UserRepo
	UsersyncRepo
	Transactioner
}

func New 

func New(ctx context.Context, dsn string, log logrus.FieldLogger) (db Database, closer func(), err error)

New connects to the database, runs migrations and returns a database instance. The caller must call the returned closer function when the database connection is no longer needed

type DatabaseTransactionFunc 

type DatabaseTransactionFunc func(ctx context.Context, dbtx Database) error

type EnvSlugName 

type EnvSlugName struct {
	Slug    slug.Slug
	EnvName string
}

type Environment 

type Environment struct {
	Name string
	GCP  bool
}

type EnvironmentRepo 

type EnvironmentRepo interface {
	DeleteAllEnvironments(ctx context.Context) error
	InsertEnvironment(ctx context.Context, name string, gcp bool) error
	SyncEnvironments(ctx context.Context, envs []*Environment) error
}

type GitHubRepository 

type GitHubRepository struct {
	Name        string                        `json:"name"`
	Permissions []*GitHubRepositoryPermission `json:"permissions"`
	Archived    bool                          `json:"archived"`
	RoleName    string                        `json:"roleName"`
}

func GetGitHubRepos 

func GetGitHubRepos(b []byte) ([]*GitHubRepository, error)

type GitHubRepositoryPermission 

type GitHubRepositoryPermission struct {
	Name    string `json:"name"`
	Granted bool   `json:"granted"`
}

type MockDatabase 

type MockDatabase struct {
	mock.Mock
}

MockDatabase is an autogenerated mock type for the Database type

func NewMockDatabase 

func NewMockDatabase(t interface {
	mock.TestingT
	Cleanup(func())
},
) *MockDatabase

NewMockDatabase creates a new instance of MockDatabase. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. The first argument is typically a *testing.T value.

func (*MockDatabase) AddReconcilerOptOut 

func (_m *MockDatabase) AddReconcilerOptOut(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug, reconcilerName string) error

AddReconcilerOptOut provides a mock function with given fields: ctx, userID, teamSlug, reconcilerName

func (*MockDatabase) AssignGlobalRoleToServiceAccount 

func (_m *MockDatabase) AssignGlobalRoleToServiceAccount(ctx context.Context, serviceAccountID uuid.UUID, roleName gensql.RoleName) error

AssignGlobalRoleToServiceAccount provides a mock function with given fields: ctx, serviceAccountID, roleName

func (*MockDatabase) AssignGlobalRoleToUser 

func (_m *MockDatabase) AssignGlobalRoleToUser(ctx context.Context, userID uuid.UUID, roleName gensql.RoleName) error

AssignGlobalRoleToUser provides a mock function with given fields: ctx, userID, roleName

func (*MockDatabase) AssignTeamRoleToServiceAccount 

func (_m *MockDatabase) AssignTeamRoleToServiceAccount(ctx context.Context, serviceAccountID uuid.UUID, roleName gensql.RoleName, teamSlug slug.Slug) error

AssignTeamRoleToServiceAccount provides a mock function with given fields: ctx, serviceAccountID, roleName, teamSlug

func (*MockDatabase) AverageResourceUtilizationForTeam 

func (_m *MockDatabase) AverageResourceUtilizationForTeam(ctx context.Context, teamSlug slug.Slug, resourceType gensql.ResourceType, timestamp pgtype.Timestamptz) (*gensql.AverageResourceUtilizationForTeamRow, error)

AverageResourceUtilizationForTeam provides a mock function with given fields: ctx, teamSlug, resourceType, timestamp

func (*MockDatabase) ClearReconcilerErrorsForTeam 

func (_m *MockDatabase) ClearReconcilerErrorsForTeam(ctx context.Context, teamSlug slug.Slug, reconcilerName string) error

ClearReconcilerErrorsForTeam provides a mock function with given fields: ctx, teamSlug, reconcilerName

func (*MockDatabase) ConfigureReconciler 

func (_m *MockDatabase) ConfigureReconciler(ctx context.Context, reconcilerName string, key string, value string) error

ConfigureReconciler provides a mock function with given fields: ctx, reconcilerName, key, value

func (*MockDatabase) ConfirmTeamDeleteKey 

func (_m *MockDatabase) ConfirmTeamDeleteKey(ctx context.Context, key uuid.UUID) error

ConfirmTeamDeleteKey provides a mock function with given fields: ctx, key

func (*MockDatabase) CostForInstance 

func (_m *MockDatabase) CostForInstance(ctx context.Context, costType string, fromDate pgtype.Date, toDate pgtype.Date, teamSlug slug.Slug, appName string, environment string) (float32, error)

CostForInstance provides a mock function with given fields: ctx, costType, fromDate, toDate, teamSlug, appName, environment

func (*MockDatabase) CostRefresh 

func (_m *MockDatabase) CostRefresh(ctx context.Context) error

CostRefresh provides a mock function with given fields: ctx

func (*MockDatabase) CostUpsert 

func (_m *MockDatabase) CostUpsert(ctx context.Context, arg []gensql.CostUpsertParams) *gensql.CostUpsertBatchResults

CostUpsert provides a mock function with given fields: ctx, arg

func (*MockDatabase) CreateAPIKey 

func (_m *MockDatabase) CreateAPIKey(ctx context.Context, apiKey string, serviceAccountID uuid.UUID) error

CreateAPIKey provides a mock function with given fields: ctx, apiKey, serviceAccountID

func (*MockDatabase) CreateAuditLogEntry 

func (_m *MockDatabase) CreateAuditLogEntry(ctx context.Context, correlationID uuid.UUID, actor *string, targetType audittype.AuditLogsTargetType, targetIdentifier string, action audittype.AuditAction, message string) error

CreateAuditLogEntry provides a mock function with given fields: ctx, correlationID, actor, targetType, targetIdentifier, action, message

func (*MockDatabase) CreateRepositoryAuthorization 

func (_m *MockDatabase) CreateRepositoryAuthorization(ctx context.Context, teamSlug slug.Slug, repoName string, authorization gensql.RepositoryAuthorizationEnum) error

CreateRepositoryAuthorization provides a mock function with given fields: ctx, teamSlug, repoName, authorization

func (*MockDatabase) CreateServiceAccount 

func (_m *MockDatabase) CreateServiceAccount(ctx context.Context, name string) (*ServiceAccount, error)

CreateServiceAccount provides a mock function with given fields: ctx, name

func (*MockDatabase) CreateSession 

func (_m *MockDatabase) CreateSession(ctx context.Context, userID uuid.UUID) (*Session, error)

CreateSession provides a mock function with given fields: ctx, userID

func (*MockDatabase) CreateTeam 

func (_m *MockDatabase) CreateTeam(ctx context.Context, teamSlug slug.Slug, purpose string, slackChannel string) (*Team, error)

CreateTeam provides a mock function with given fields: ctx, teamSlug, purpose, slackChannel

func (*MockDatabase) CreateTeamDeleteKey 

func (_m *MockDatabase) CreateTeamDeleteKey(ctx context.Context, teamSlug slug.Slug, userID uuid.UUID) (*TeamDeleteKey, error)

CreateTeamDeleteKey provides a mock function with given fields: ctx, teamSlug, userID

func (*MockDatabase) CreateUser 

func (_m *MockDatabase) CreateUser(ctx context.Context, name string, email string, externalID string) (*User, error)

CreateUser provides a mock function with given fields: ctx, name, email, externalID

func (*MockDatabase) CreateUsersyncRun 

func (_m *MockDatabase) CreateUsersyncRun(ctx context.Context, id uuid.UUID, startedAt time.Time, finishedAt time.Time, err error) error

CreateUsersyncRun provides a mock function with given fields: ctx, id, startedAt, finishedAt, err

func (*MockDatabase) CurrentSqlInstancesCostForTeam 

func (_m *MockDatabase) CurrentSqlInstancesCostForTeam(ctx context.Context, teamSlug slug.Slug) (float32, error)

CurrentSqlInstancesCostForTeam provides a mock function with given fields: ctx, teamSlug

func (*MockDatabase) DailyCostForApp 

func (_m *MockDatabase) DailyCostForApp(ctx context.Context, fromDate pgtype.Date, toDate pgtype.Date, environment string, teamSlug slug.Slug, app string) ([]*gensql.Cost, error)

DailyCostForApp provides a mock function with given fields: ctx, fromDate, toDate, environment, teamSlug, app

func (*MockDatabase) DailyCostForTeam 

func (_m *MockDatabase) DailyCostForTeam(ctx context.Context, fromDate pgtype.Date, toDate pgtype.Date, teamSlug slug.Slug) ([]*gensql.Cost, error)

DailyCostForTeam provides a mock function with given fields: ctx, fromDate, toDate, teamSlug

func (*MockDatabase) DailyEnvCostForTeam 

func (_m *MockDatabase) DailyEnvCostForTeam(ctx context.Context, fromDate pgtype.Date, toDate pgtype.Date, environment *string, teamSlug slug.Slug) ([]*gensql.DailyEnvCostForTeamRow, error)

DailyEnvCostForTeam provides a mock function with given fields: ctx, fromDate, toDate, environment, teamSlug

func (*MockDatabase) DeleteAllEnvironments 

func (_m *MockDatabase) DeleteAllEnvironments(ctx context.Context) error

DeleteAllEnvironments provides a mock function with given fields: ctx

func (*MockDatabase) DeleteReconcilerConfig 

func (_m *MockDatabase) DeleteReconcilerConfig(ctx context.Context, reconcilerName string, keysToDelete []string) error

DeleteReconcilerConfig provides a mock function with given fields: ctx, reconcilerName, keysToDelete

func (*MockDatabase) DeleteReconcilerStateForTeam 

func (_m *MockDatabase) DeleteReconcilerStateForTeam(ctx context.Context, reconcilerName string, teamSlug slug.Slug) error

DeleteReconcilerStateForTeam provides a mock function with given fields: ctx, reconcilerName, teamSlug

func (*MockDatabase) DeleteServiceAccount 

func (_m *MockDatabase) DeleteServiceAccount(ctx context.Context, serviceAccountID uuid.UUID) error

DeleteServiceAccount provides a mock function with given fields: ctx, serviceAccountID

func (*MockDatabase) DeleteSession 

func (_m *MockDatabase) DeleteSession(ctx context.Context, sessionID uuid.UUID) error

DeleteSession provides a mock function with given fields: ctx, sessionID

func (*MockDatabase) DeleteTeam 

func (_m *MockDatabase) DeleteTeam(ctx context.Context, teamSlug slug.Slug) error

DeleteTeam provides a mock function with given fields: ctx, teamSlug

func (*MockDatabase) DeleteUser 

func (_m *MockDatabase) DeleteUser(ctx context.Context, userID uuid.UUID) error

DeleteUser provides a mock function with given fields: ctx, userID

func (*MockDatabase) DisableReconciler 

func (_m *MockDatabase) DisableReconciler(ctx context.Context, reconcilerName string) (*Reconciler, error)

DisableReconciler provides a mock function with given fields: ctx, reconcilerName

func (*MockDatabase) EXPECT 

func (_m *MockDatabase) EXPECT() *MockDatabase_Expecter

func (*MockDatabase) EnableReconciler 

func (_m *MockDatabase) EnableReconciler(ctx context.Context, reconcilerName string) (*Reconciler, error)

EnableReconciler provides a mock function with given fields: ctx, reconcilerName

func (*MockDatabase) ExtendSession 

func (_m *MockDatabase) ExtendSession(ctx context.Context, sessionID uuid.UUID) (*Session, error)

ExtendSession provides a mock function with given fields: ctx, sessionID

func (*MockDatabase) GetActiveTeamBySlug 

func (_m *MockDatabase) GetActiveTeamBySlug(ctx context.Context, teamSlug slug.Slug) (*Team, error)

GetActiveTeamBySlug provides a mock function with given fields: ctx, teamSlug

func (*MockDatabase) GetActiveTeams 

func (_m *MockDatabase) GetActiveTeams(ctx context.Context) ([]*Team, error)

GetActiveTeams provides a mock function with given fields: ctx

func (*MockDatabase) GetAllTeamMembers 

func (_m *MockDatabase) GetAllTeamMembers(ctx context.Context, teamSlug slug.Slug) ([]*User, error)

GetAllTeamMembers provides a mock function with given fields: ctx, teamSlug

func (*MockDatabase) GetAllTeamSlugs 

func (_m *MockDatabase) GetAllTeamSlugs(ctx context.Context) ([]slug.Slug, error)

GetAllTeamSlugs provides a mock function with given fields: ctx

func (*MockDatabase) GetAllTeamsWithPermissionInGitHubRepo 

func (_m *MockDatabase) GetAllTeamsWithPermissionInGitHubRepo(ctx context.Context, repoName string, permission string) ([]*Team, error)

GetAllTeamsWithPermissionInGitHubRepo provides a mock function with given fields: ctx, repoName, permission

func (*MockDatabase) GetAllUserRoles 

func (_m *MockDatabase) GetAllUserRoles(ctx context.Context) ([]*UserRole, error)

GetAllUserRoles provides a mock function with given fields: ctx

func (*MockDatabase) GetAuditLogsForCorrelationID 

func (_m *MockDatabase) GetAuditLogsForCorrelationID(ctx context.Context, correlationID uuid.UUID, p Page) ([]*AuditLog, int, error)

GetAuditLogsForCorrelationID provides a mock function with given fields: ctx, correlationID, p

func (*MockDatabase) GetAuditLogsForReconciler 

func (_m *MockDatabase) GetAuditLogsForReconciler(ctx context.Context, reconcilerName string, p Page) ([]*AuditLog, int, error)

GetAuditLogsForReconciler provides a mock function with given fields: ctx, reconcilerName, p

func (*MockDatabase) GetAuditLogsForTeam 

func (_m *MockDatabase) GetAuditLogsForTeam(ctx context.Context, teamSlug slug.Slug, p Page) ([]*AuditLog, int, error)

GetAuditLogsForTeam provides a mock function with given fields: ctx, teamSlug, p

func (*MockDatabase) GetEnabledReconcilers 

func (_m *MockDatabase) GetEnabledReconcilers(ctx context.Context) ([]*Reconciler, error)

GetEnabledReconcilers provides a mock function with given fields: ctx

func (*MockDatabase) GetReconciler 

func (_m *MockDatabase) GetReconciler(ctx context.Context, reconcilerName string) (*Reconciler, error)

GetReconciler provides a mock function with given fields: ctx, reconcilerName

func (*MockDatabase) GetReconcilerConfig 

func (_m *MockDatabase) GetReconcilerConfig(ctx context.Context, reconcilerName string, includeSecrets bool) ([]*ReconcilerConfig, error)

GetReconcilerConfig provides a mock function with given fields: ctx, reconcilerName, includeSecrets

func (*MockDatabase) GetReconcilerErrors 

func (_m *MockDatabase) GetReconcilerErrors(ctx context.Context, reconcilerName string, p Page) ([]*ReconcilerError, int, error)

GetReconcilerErrors provides a mock function with given fields: ctx, reconcilerName, p

func (*MockDatabase) GetReconcilerState 

func (_m *MockDatabase) GetReconcilerState(ctx context.Context, reconcilerName string) ([]*ReconcilerStateWithTeam, error)

GetReconcilerState provides a mock function with given fields: ctx, reconcilerName

func (*MockDatabase) GetReconcilerStateForTeam 

func (_m *MockDatabase) GetReconcilerStateForTeam(ctx context.Context, reconcilerName string, teamSlug slug.Slug) (*ReconcilerState, error)

GetReconcilerStateForTeam provides a mock function with given fields: ctx, reconcilerName, teamSlug

func (*MockDatabase) GetReconcilers 

func (_m *MockDatabase) GetReconcilers(ctx context.Context, p Page) ([]*Reconciler, int, error)

GetReconcilers provides a mock function with given fields: ctx, p

func (*MockDatabase) GetRepositoryAuthorizations 

func (_m *MockDatabase) GetRepositoryAuthorizations(ctx context.Context, teamSlug slug.Slug, repoName string) ([]gensql.RepositoryAuthorizationEnum, error)

GetRepositoryAuthorizations provides a mock function with given fields: ctx, teamSlug, repoName

func (*MockDatabase) GetServiceAccountByApiKey 

func (_m *MockDatabase) GetServiceAccountByApiKey(ctx context.Context, apiKey string) (*ServiceAccount, error)

GetServiceAccountByApiKey provides a mock function with given fields: ctx, apiKey

func (*MockDatabase) GetServiceAccountByName 

func (_m *MockDatabase) GetServiceAccountByName(ctx context.Context, name string) (*ServiceAccount, error)

GetServiceAccountByName provides a mock function with given fields: ctx, name

func (*MockDatabase) GetServiceAccountRoles 

func (_m *MockDatabase) GetServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) ([]*authz.Role, error)

GetServiceAccountRoles provides a mock function with given fields: ctx, serviceAccountID

func (*MockDatabase) GetServiceAccounts 

func (_m *MockDatabase) GetServiceAccounts(ctx context.Context) ([]*ServiceAccount, error)

GetServiceAccounts provides a mock function with given fields: ctx

func (*MockDatabase) GetServiceAccountsByIDs 

func (_m *MockDatabase) GetServiceAccountsByIDs(ctx context.Context, ids []uuid.UUID) ([]*ServiceAccount, error)

GetServiceAccountsByIDs provides a mock function with given fields: ctx, ids

func (*MockDatabase) GetSessionByID 

func (_m *MockDatabase) GetSessionByID(ctx context.Context, sessionID uuid.UUID) (*Session, error)

GetSessionByID provides a mock function with given fields: ctx, sessionID

func (*MockDatabase) GetTeamBySlug 

func (_m *MockDatabase) GetTeamBySlug(ctx context.Context, teamSlug slug.Slug) (*Team, error)

GetTeamBySlug provides a mock function with given fields: ctx, teamSlug

func (*MockDatabase) GetTeamDeleteKey 

func (_m *MockDatabase) GetTeamDeleteKey(ctx context.Context, key uuid.UUID) (*TeamDeleteKey, error)

GetTeamDeleteKey provides a mock function with given fields: ctx, key

func (*MockDatabase) GetTeamEnvironments 

func (_m *MockDatabase) GetTeamEnvironments(ctx context.Context, teamSlug slug.Slug, p Page) ([]*TeamEnvironment, int, error)

GetTeamEnvironments provides a mock function with given fields: ctx, teamSlug, p

func (*MockDatabase) GetTeamEnvironmentsBySlugsAndEnvNames 

func (_m *MockDatabase) GetTeamEnvironmentsBySlugsAndEnvNames(ctx context.Context, keys []EnvSlugName) ([]*TeamEnvironment, error)

GetTeamEnvironmentsBySlugsAndEnvNames provides a mock function with given fields: ctx, keys

func (*MockDatabase) GetTeamMember 

func (_m *MockDatabase) GetTeamMember(ctx context.Context, teamSlug slug.Slug, userID uuid.UUID) (*User, error)

GetTeamMember provides a mock function with given fields: ctx, teamSlug, userID

func (*MockDatabase) GetTeamMemberOptOuts 

func (_m *MockDatabase) GetTeamMemberOptOuts(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug) ([]*gensql.GetTeamMemberOptOutsRow, error)

GetTeamMemberOptOuts provides a mock function with given fields: ctx, userID, teamSlug

func (*MockDatabase) GetTeamMembers 

func (_m *MockDatabase) GetTeamMembers(ctx context.Context, teamSlug slug.Slug, p Page) ([]*User, int, error)

GetTeamMembers provides a mock function with given fields: ctx, teamSlug, p

func (*MockDatabase) GetTeamMembersForReconciler 

func (_m *MockDatabase) GetTeamMembersForReconciler(ctx context.Context, teamSlug slug.Slug, reconcilerName string) ([]*User, error)

GetTeamMembersForReconciler provides a mock function with given fields: ctx, teamSlug, reconcilerName

func (*MockDatabase) GetTeamReconcilerErrors 

func (_m *MockDatabase) GetTeamReconcilerErrors(ctx context.Context, teamSlug slug.Slug) ([]*ReconcilerError, error)

GetTeamReconcilerErrors provides a mock function with given fields: ctx, teamSlug

func (*MockDatabase) GetTeams 

func (_m *MockDatabase) GetTeams(ctx context.Context, p Page) ([]*Team, int, error)

GetTeams provides a mock function with given fields: ctx, p

func (*MockDatabase) GetTeamsBySlugs 

func (_m *MockDatabase) GetTeamsBySlugs(ctx context.Context, teamSlugs []slug.Slug) ([]*Team, error)

GetTeamsBySlugs provides a mock function with given fields: ctx, teamSlugs

func (*MockDatabase) GetUserByEmail 

func (_m *MockDatabase) GetUserByEmail(ctx context.Context, email string) (*User, error)

GetUserByEmail provides a mock function with given fields: ctx, email

func (*MockDatabase) GetUserByExternalID 

func (_m *MockDatabase) GetUserByExternalID(ctx context.Context, externalID string) (*User, error)

GetUserByExternalID provides a mock function with given fields: ctx, externalID

func (*MockDatabase) GetUserByID 

func (_m *MockDatabase) GetUserByID(ctx context.Context, id uuid.UUID) (*User, error)

GetUserByID provides a mock function with given fields: ctx, id

func (*MockDatabase) GetUserRoles 

func (_m *MockDatabase) GetUserRoles(ctx context.Context, userID uuid.UUID) ([]*authz.Role, error)

GetUserRoles provides a mock function with given fields: ctx, userID

func (*MockDatabase) GetUserRolesForUsers 

func (_m *MockDatabase) GetUserRolesForUsers(ctx context.Context, userIDs []uuid.UUID) (map[uuid.UUID][]*authz.Role, error)

GetUserRolesForUsers provides a mock function with given fields: ctx, userIDs

func (*MockDatabase) GetUserTeams 

func (_m *MockDatabase) GetUserTeams(ctx context.Context, userID uuid.UUID) ([]*UserTeam, error)

GetUserTeams provides a mock function with given fields: ctx, userID

func (*MockDatabase) GetUserTeamsPaginated 

func (_m *MockDatabase) GetUserTeamsPaginated(ctx context.Context, userID uuid.UUID, p Page) ([]*UserTeam, int, error)

GetUserTeamsPaginated provides a mock function with given fields: ctx, userID, p

func (*MockDatabase) GetUsers 

func (_m *MockDatabase) GetUsers(ctx context.Context, p Page) ([]*User, int, error)

GetUsers provides a mock function with given fields: ctx, p

func (*MockDatabase) GetUsersByIDs 

func (_m *MockDatabase) GetUsersByIDs(ctx context.Context, ids []uuid.UUID) ([]*User, error)

GetUsersByIDs provides a mock function with given fields: ctx, ids

func (*MockDatabase) GetUsersWithGloballyAssignedRole 

func (_m *MockDatabase) GetUsersWithGloballyAssignedRole(ctx context.Context, roleName gensql.RoleName) ([]*User, error)

GetUsersWithGloballyAssignedRole provides a mock function with given fields: ctx, roleName

func (*MockDatabase) GetUsersyncRuns 

func (_m *MockDatabase) GetUsersyncRuns(ctx context.Context, p Page) ([]*UsersyncRun, int, error)

GetUsersyncRuns provides a mock function with given fields: ctx, p

func (*MockDatabase) InsertEnvironment 

func (_m *MockDatabase) InsertEnvironment(ctx context.Context, name string, gcp bool) error

InsertEnvironment provides a mock function with given fields: ctx, name, gcp

func (*MockDatabase) LastCostDate 

func (_m *MockDatabase) LastCostDate(ctx context.Context) (pgtype.Date, error)

LastCostDate provides a mock function with given fields: ctx

func (*MockDatabase) ListRepositoriesByAuthorization 

func (_m *MockDatabase) ListRepositoriesByAuthorization(ctx context.Context, teamSlug slug.Slug, authorization gensql.RepositoryAuthorizationEnum) ([]string, error)

ListRepositoriesByAuthorization provides a mock function with given fields: ctx, teamSlug, authorization

func (*MockDatabase) MaxResourceUtilizationDate 

func (_m *MockDatabase) MaxResourceUtilizationDate(ctx context.Context) (pgtype.Timestamptz, error)

MaxResourceUtilizationDate provides a mock function with given fields: ctx

func (*MockDatabase) MonthlyCostForApp 

func (_m *MockDatabase) MonthlyCostForApp(ctx context.Context, teamSlug slug.Slug, app string, environment string) ([]*gensql.MonthlyCostForAppRow, error)

MonthlyCostForApp provides a mock function with given fields: ctx, teamSlug, app, environment

func (*MockDatabase) MonthlyCostForTeam 

func (_m *MockDatabase) MonthlyCostForTeam(ctx context.Context, teamSlug slug.Slug) ([]*gensql.CostMonthlyTeam, error)

MonthlyCostForTeam provides a mock function with given fields: ctx, teamSlug

func (*MockDatabase) RemoveAllServiceAccountRoles 

func (_m *MockDatabase) RemoveAllServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) error

RemoveAllServiceAccountRoles provides a mock function with given fields: ctx, serviceAccountID

func (*MockDatabase) RemoveApiKeysFromServiceAccount 

func (_m *MockDatabase) RemoveApiKeysFromServiceAccount(ctx context.Context, serviceAccountID uuid.UUID) error

RemoveApiKeysFromServiceAccount provides a mock function with given fields: ctx, serviceAccountID

func (*MockDatabase) RemoveReconcilerOptOut 

func (_m *MockDatabase) RemoveReconcilerOptOut(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug, reconcilerName string) error

RemoveReconcilerOptOut provides a mock function with given fields: ctx, userID, teamSlug, reconcilerName

func (*MockDatabase) RemoveRepositoryAuthorization 

func (_m *MockDatabase) RemoveRepositoryAuthorization(ctx context.Context, teamSlug slug.Slug, repoName string, authorization gensql.RepositoryAuthorizationEnum) error

RemoveRepositoryAuthorization provides a mock function with given fields: ctx, teamSlug, repoName, authorization

func (*MockDatabase) RemoveUserFromTeam 

func (_m *MockDatabase) RemoveUserFromTeam(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug) error

RemoveUserFromTeam provides a mock function with given fields: ctx, userID, teamSlug

func (*MockDatabase) ResetReconcilerConfig 

func (_m *MockDatabase) ResetReconcilerConfig(ctx context.Context, reconcilerName string) (*Reconciler, error)

ResetReconcilerConfig provides a mock function with given fields: ctx, reconcilerName

func (*MockDatabase) ResourceUtilizationForApp 

func (_m *MockDatabase) ResourceUtilizationForApp(ctx context.Context, arg gensql.ResourceUtilizationForAppParams) ([]*gensql.ResourceUtilizationMetric, error)

ResourceUtilizationForApp provides a mock function with given fields: ctx, arg

func (*MockDatabase) ResourceUtilizationForTeam 

func (_m *MockDatabase) ResourceUtilizationForTeam(ctx context.Context, environment string, teamSlug slug.Slug, resourceType gensql.ResourceType, start pgtype.Timestamptz, end pgtype.Timestamptz) ([]*gensql.ResourceUtilizationForTeamRow, error)

ResourceUtilizationForTeam provides a mock function with given fields: ctx, environment, teamSlug, resourceType, start, end

func (*MockDatabase) ResourceUtilizationOverageForTeam 

func (_m *MockDatabase) ResourceUtilizationOverageForTeam(ctx context.Context, teamSlug slug.Slug, timestamp pgtype.Timestamptz, resourceType gensql.ResourceType) ([]*gensql.ResourceUtilizationOverageForTeamRow, error)

ResourceUtilizationOverageForTeam provides a mock function with given fields: ctx, teamSlug, timestamp, resourceType

func (*MockDatabase) ResourceUtilizationRangeForApp 

func (_m *MockDatabase) ResourceUtilizationRangeForApp(ctx context.Context, environment string, teamSlug slug.Slug, app string) (*gensql.ResourceUtilizationRangeForAppRow, error)

ResourceUtilizationRangeForApp provides a mock function with given fields: ctx, environment, teamSlug, app

func (*MockDatabase) ResourceUtilizationRangeForTeam 

func (_m *MockDatabase) ResourceUtilizationRangeForTeam(ctx context.Context, teamSlug slug.Slug) (*gensql.ResourceUtilizationRangeForTeamRow, error)

ResourceUtilizationRangeForTeam provides a mock function with given fields: ctx, teamSlug

func (*MockDatabase) ResourceUtilizationRefresh 

func (_m *MockDatabase) ResourceUtilizationRefresh(ctx context.Context) error

ResourceUtilizationRefresh provides a mock function with given fields: ctx

func (*MockDatabase) ResourceUtilizationUpsert 

func (_m *MockDatabase) ResourceUtilizationUpsert(ctx context.Context, arg []gensql.ResourceUtilizationUpsertParams) *gensql.ResourceUtilizationUpsertBatchResults

ResourceUtilizationUpsert provides a mock function with given fields: ctx, arg

func (*MockDatabase) RevokeGlobalUserRole 

func (_m *MockDatabase) RevokeGlobalUserRole(ctx context.Context, userID uuid.UUID, roleName gensql.RoleName) error

RevokeGlobalUserRole provides a mock function with given fields: ctx, userID, roleName

func (*MockDatabase) SetLastSuccessfulSyncForTeam 

func (_m *MockDatabase) SetLastSuccessfulSyncForTeam(ctx context.Context, teamSlug slug.Slug) error

SetLastSuccessfulSyncForTeam provides a mock function with given fields: ctx, teamSlug

func (*MockDatabase) SetReconcilerErrorForTeam 

func (_m *MockDatabase) SetReconcilerErrorForTeam(ctx context.Context, correlationID uuid.UUID, teamSlug slug.Slug, reconcilerName string, err error) error

SetReconcilerErrorForTeam provides a mock function with given fields: ctx, correlationID, teamSlug, reconcilerName, err

func (*MockDatabase) SetTeamMemberRole 

func (_m *MockDatabase) SetTeamMemberRole(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug, roleName gensql.RoleName) error

SetTeamMemberRole provides a mock function with given fields: ctx, userID, teamSlug, roleName

func (*MockDatabase) SpecificResourceUtilizationForApp 

func (_m *MockDatabase) SpecificResourceUtilizationForApp(ctx context.Context, environment string, teamSlug slug.Slug, app string, resourceType gensql.ResourceType, timestamp pgtype.Timestamptz) (*gensql.SpecificResourceUtilizationForAppRow, error)

SpecificResourceUtilizationForApp provides a mock function with given fields: ctx, environment, teamSlug, app, resourceType, timestamp

func (*MockDatabase) SpecificResourceUtilizationForTeam 

func (_m *MockDatabase) SpecificResourceUtilizationForTeam(ctx context.Context, teamSlug slug.Slug, resourceType gensql.ResourceType, timestamp pgtype.Timestamptz) ([]*gensql.SpecificResourceUtilizationForTeamRow, error)

SpecificResourceUtilizationForTeam provides a mock function with given fields: ctx, teamSlug, resourceType, timestamp

func (*MockDatabase) SyncEnvironments 

func (_m *MockDatabase) SyncEnvironments(ctx context.Context, envs []*Environment) error

SyncEnvironments provides a mock function with given fields: ctx, envs

func (*MockDatabase) SyncReconcilerConfig 

func (_m *MockDatabase) SyncReconcilerConfig(ctx context.Context, reconcilerName string, configs []*protoapi.ReconcilerConfigSpec) error

SyncReconcilerConfig provides a mock function with given fields: ctx, reconcilerName, configs

func (*MockDatabase) TeamExists 

func (_m *MockDatabase) TeamExists(ctx context.Context, team slug.Slug) (bool, error)

TeamExists provides a mock function with given fields: ctx, team

func (*MockDatabase) Transaction 

func (_m *MockDatabase) Transaction(ctx context.Context, fn DatabaseTransactionFunc) error

Transaction provides a mock function with given fields: ctx, fn

func (*MockDatabase) UpdateTeam 

func (_m *MockDatabase) UpdateTeam(ctx context.Context, teamSlug slug.Slug, purpose *string, slackChannel *string) (*Team, error)

UpdateTeam provides a mock function with given fields: ctx, teamSlug, purpose, slackChannel

func (*MockDatabase) UpdateTeamExternalReferences 

func (_m *MockDatabase) UpdateTeamExternalReferences(ctx context.Context, params gensql.UpdateTeamExternalReferencesParams) (*Team, error)

UpdateTeamExternalReferences provides a mock function with given fields: ctx, params

func (*MockDatabase) UpdateUser 

func (_m *MockDatabase) UpdateUser(ctx context.Context, userID uuid.UUID, name string, email string, externalID string) (*User, error)

UpdateUser provides a mock function with given fields: ctx, userID, name, email, externalID

func (*MockDatabase) UpsertReconciler 

func (_m *MockDatabase) UpsertReconciler(ctx context.Context, name string, displayName string, description string, memberAware bool, enableIfNew bool) (*Reconciler, error)

UpsertReconciler provides a mock function with given fields: ctx, name, displayName, description, memberAware, enableIfNew

func (*MockDatabase) UpsertReconcilerConfig 

func (_m *MockDatabase) UpsertReconcilerConfig(ctx context.Context, reconciler string, key string, displayName string, description string, secret bool) error

UpsertReconcilerConfig provides a mock function with given fields: ctx, reconciler, key, displayName, description, secret

func (*MockDatabase) UpsertReconcilerState 

func (_m *MockDatabase) UpsertReconcilerState(ctx context.Context, reconcilerName string, teamSlug slug.Slug, value []byte) (*ReconcilerState, error)

UpsertReconcilerState provides a mock function with given fields: ctx, reconcilerName, teamSlug, value

func (*MockDatabase) UpsertTeamEnvironment 

func (_m *MockDatabase) UpsertTeamEnvironment(ctx context.Context, teamSlug slug.Slug, environment string, slackChannel *string, gcpProjectID *string) error

UpsertTeamEnvironment provides a mock function with given fields: ctx, teamSlug, environment, slackChannel, gcpProjectID

func (*MockDatabase) UserIsTeamOwner 

func (_m *MockDatabase) UserIsTeamOwner(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug) (bool, error)

UserIsTeamOwner provides a mock function with given fields: ctx, userID, teamSlug

type MockDatabase_AddReconcilerOptOut_Call 

type MockDatabase_AddReconcilerOptOut_Call struct {
	*mock.Call
}

MockDatabase_AddReconcilerOptOut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddReconcilerOptOut'

func (*MockDatabase_AddReconcilerOptOut_Call) Return 

func (_c *MockDatabase_AddReconcilerOptOut_Call) Return(_a0 error) *MockDatabase_AddReconcilerOptOut_Call

func (*MockDatabase_AddReconcilerOptOut_Call) Run 

func (_c *MockDatabase_AddReconcilerOptOut_Call) Run(run func(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug, reconcilerName string)) *MockDatabase_AddReconcilerOptOut_Call

func (*MockDatabase_AddReconcilerOptOut_Call) RunAndReturn 

func (_c *MockDatabase_AddReconcilerOptOut_Call) RunAndReturn(run func(context.Context, uuid.UUID, slug.Slug, string) error) *MockDatabase_AddReconcilerOptOut_Call

type MockDatabase_AssignGlobalRoleToServiceAccount_Call 

type MockDatabase_AssignGlobalRoleToServiceAccount_Call struct {
	*mock.Call
}

MockDatabase_AssignGlobalRoleToServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignGlobalRoleToServiceAccount'

func (*MockDatabase_AssignGlobalRoleToServiceAccount_Call) Return 

func (_c *MockDatabase_AssignGlobalRoleToServiceAccount_Call) Return(_a0 error) *MockDatabase_AssignGlobalRoleToServiceAccount_Call

func (*MockDatabase_AssignGlobalRoleToServiceAccount_Call) Run 

func (_c *MockDatabase_AssignGlobalRoleToServiceAccount_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID, roleName gensql.RoleName)) *MockDatabase_AssignGlobalRoleToServiceAccount_Call

func (*MockDatabase_AssignGlobalRoleToServiceAccount_Call) RunAndReturn 

func (_c *MockDatabase_AssignGlobalRoleToServiceAccount_Call) RunAndReturn(run func(context.Context, uuid.UUID, gensql.RoleName) error) *MockDatabase_AssignGlobalRoleToServiceAccount_Call

type MockDatabase_AssignGlobalRoleToUser_Call 

type MockDatabase_AssignGlobalRoleToUser_Call struct {
	*mock.Call
}

MockDatabase_AssignGlobalRoleToUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignGlobalRoleToUser'

func (*MockDatabase_AssignGlobalRoleToUser_Call) Return 

func (_c *MockDatabase_AssignGlobalRoleToUser_Call) Return(_a0 error) *MockDatabase_AssignGlobalRoleToUser_Call

func (*MockDatabase_AssignGlobalRoleToUser_Call) Run 

func (_c *MockDatabase_AssignGlobalRoleToUser_Call) Run(run func(ctx context.Context, userID uuid.UUID, roleName gensql.RoleName)) *MockDatabase_AssignGlobalRoleToUser_Call

func (*MockDatabase_AssignGlobalRoleToUser_Call) RunAndReturn 

func (_c *MockDatabase_AssignGlobalRoleToUser_Call) RunAndReturn(run func(context.Context, uuid.UUID, gensql.RoleName) error) *MockDatabase_AssignGlobalRoleToUser_Call

type MockDatabase_AssignTeamRoleToServiceAccount_Call 

type MockDatabase_AssignTeamRoleToServiceAccount_Call struct {
	*mock.Call
}

MockDatabase_AssignTeamRoleToServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AssignTeamRoleToServiceAccount'

func (*MockDatabase_AssignTeamRoleToServiceAccount_Call) Return 

func (_c *MockDatabase_AssignTeamRoleToServiceAccount_Call) Return(_a0 error) *MockDatabase_AssignTeamRoleToServiceAccount_Call

func (*MockDatabase_AssignTeamRoleToServiceAccount_Call) Run 

func (_c *MockDatabase_AssignTeamRoleToServiceAccount_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID, roleName gensql.RoleName, teamSlug slug.Slug)) *MockDatabase_AssignTeamRoleToServiceAccount_Call

func (*MockDatabase_AssignTeamRoleToServiceAccount_Call) RunAndReturn 

func (_c *MockDatabase_AssignTeamRoleToServiceAccount_Call) RunAndReturn(run func(context.Context, uuid.UUID, gensql.RoleName, slug.Slug) error) *MockDatabase_AssignTeamRoleToServiceAccount_Call

type MockDatabase_AverageResourceUtilizationForTeam_Call 

type MockDatabase_AverageResourceUtilizationForTeam_Call struct {
	*mock.Call
}

MockDatabase_AverageResourceUtilizationForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AverageResourceUtilizationForTeam'

func (*MockDatabase_AverageResourceUtilizationForTeam_Call) Return 

func (_c *MockDatabase_AverageResourceUtilizationForTeam_Call) Return(_a0 *gensql.AverageResourceUtilizationForTeamRow, _a1 error) *MockDatabase_AverageResourceUtilizationForTeam_Call

func (*MockDatabase_AverageResourceUtilizationForTeam_Call) Run 

func (_c *MockDatabase_AverageResourceUtilizationForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, resourceType gensql.ResourceType, timestamp pgtype.Timestamptz)) *MockDatabase_AverageResourceUtilizationForTeam_Call

func (*MockDatabase_AverageResourceUtilizationForTeam_Call) RunAndReturn 

func (_c *MockDatabase_AverageResourceUtilizationForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug, gensql.ResourceType, pgtype.Timestamptz) (*gensql.AverageResourceUtilizationForTeamRow, error)) *MockDatabase_AverageResourceUtilizationForTeam_Call

type MockDatabase_ClearReconcilerErrorsForTeam_Call 

type MockDatabase_ClearReconcilerErrorsForTeam_Call struct {
	*mock.Call
}

MockDatabase_ClearReconcilerErrorsForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearReconcilerErrorsForTeam'

func (*MockDatabase_ClearReconcilerErrorsForTeam_Call) Return 

func (_c *MockDatabase_ClearReconcilerErrorsForTeam_Call) Return(_a0 error) *MockDatabase_ClearReconcilerErrorsForTeam_Call

func (*MockDatabase_ClearReconcilerErrorsForTeam_Call) Run 

func (_c *MockDatabase_ClearReconcilerErrorsForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, reconcilerName string)) *MockDatabase_ClearReconcilerErrorsForTeam_Call

func (*MockDatabase_ClearReconcilerErrorsForTeam_Call) RunAndReturn 

func (_c *MockDatabase_ClearReconcilerErrorsForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug, string) error) *MockDatabase_ClearReconcilerErrorsForTeam_Call

type MockDatabase_ConfigureReconciler_Call 

type MockDatabase_ConfigureReconciler_Call struct {
	*mock.Call
}

MockDatabase_ConfigureReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfigureReconciler'

func (*MockDatabase_ConfigureReconciler_Call) Return 

func (_c *MockDatabase_ConfigureReconciler_Call) Return(_a0 error) *MockDatabase_ConfigureReconciler_Call

func (*MockDatabase_ConfigureReconciler_Call) Run 

func (_c *MockDatabase_ConfigureReconciler_Call) Run(run func(ctx context.Context, reconcilerName string, key string, value string)) *MockDatabase_ConfigureReconciler_Call

func (*MockDatabase_ConfigureReconciler_Call) RunAndReturn 

func (_c *MockDatabase_ConfigureReconciler_Call) RunAndReturn(run func(context.Context, string, string, string) error) *MockDatabase_ConfigureReconciler_Call

type MockDatabase_ConfirmTeamDeleteKey_Call 

type MockDatabase_ConfirmTeamDeleteKey_Call struct {
	*mock.Call
}

MockDatabase_ConfirmTeamDeleteKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConfirmTeamDeleteKey'

func (*MockDatabase_ConfirmTeamDeleteKey_Call) Return 

func (_c *MockDatabase_ConfirmTeamDeleteKey_Call) Return(_a0 error) *MockDatabase_ConfirmTeamDeleteKey_Call

func (*MockDatabase_ConfirmTeamDeleteKey_Call) Run 

func (_c *MockDatabase_ConfirmTeamDeleteKey_Call) Run(run func(ctx context.Context, key uuid.UUID)) *MockDatabase_ConfirmTeamDeleteKey_Call

func (*MockDatabase_ConfirmTeamDeleteKey_Call) RunAndReturn 

func (_c *MockDatabase_ConfirmTeamDeleteKey_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockDatabase_ConfirmTeamDeleteKey_Call

type MockDatabase_CostForInstance_Call 

type MockDatabase_CostForInstance_Call struct {
	*mock.Call
}

MockDatabase_CostForInstance_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CostForInstance'

func (*MockDatabase_CostForInstance_Call) Return 

func (_c *MockDatabase_CostForInstance_Call) Return(_a0 float32, _a1 error) *MockDatabase_CostForInstance_Call

func (*MockDatabase_CostForInstance_Call) Run 

func (_c *MockDatabase_CostForInstance_Call) Run(run func(ctx context.Context, costType string, fromDate pgtype.Date, toDate pgtype.Date, teamSlug slug.Slug, appName string, environment string)) *MockDatabase_CostForInstance_Call

func (*MockDatabase_CostForInstance_Call) RunAndReturn 

func (_c *MockDatabase_CostForInstance_Call) RunAndReturn(run func(context.Context, string, pgtype.Date, pgtype.Date, slug.Slug, string, string) (float32, error)) *MockDatabase_CostForInstance_Call

type MockDatabase_CostRefresh_Call 

type MockDatabase_CostRefresh_Call struct {
	*mock.Call
}

MockDatabase_CostRefresh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CostRefresh'

func (*MockDatabase_CostRefresh_Call) Return 

func (_c *MockDatabase_CostRefresh_Call) Return(_a0 error) *MockDatabase_CostRefresh_Call

func (*MockDatabase_CostRefresh_Call) Run 

func (_c *MockDatabase_CostRefresh_Call) Run(run func(ctx context.Context)) *MockDatabase_CostRefresh_Call

func (*MockDatabase_CostRefresh_Call) RunAndReturn 

func (_c *MockDatabase_CostRefresh_Call) RunAndReturn(run func(context.Context) error) *MockDatabase_CostRefresh_Call

type MockDatabase_CostUpsert_Call 

type MockDatabase_CostUpsert_Call struct {
	*mock.Call
}

MockDatabase_CostUpsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CostUpsert'

func (*MockDatabase_CostUpsert_Call) Return 

func (_c *MockDatabase_CostUpsert_Call) Return(_a0 *gensql.CostUpsertBatchResults) *MockDatabase_CostUpsert_Call

func (*MockDatabase_CostUpsert_Call) Run 

func (_c *MockDatabase_CostUpsert_Call) Run(run func(ctx context.Context, arg []gensql.CostUpsertParams)) *MockDatabase_CostUpsert_Call

func (*MockDatabase_CostUpsert_Call) RunAndReturn 

func (_c *MockDatabase_CostUpsert_Call) RunAndReturn(run func(context.Context, []gensql.CostUpsertParams) *gensql.CostUpsertBatchResults) *MockDatabase_CostUpsert_Call

type MockDatabase_CreateAPIKey_Call 

type MockDatabase_CreateAPIKey_Call struct {
	*mock.Call
}

MockDatabase_CreateAPIKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAPIKey'

func (*MockDatabase_CreateAPIKey_Call) Return 

func (_c *MockDatabase_CreateAPIKey_Call) Return(_a0 error) *MockDatabase_CreateAPIKey_Call

func (*MockDatabase_CreateAPIKey_Call) Run 

func (_c *MockDatabase_CreateAPIKey_Call) Run(run func(ctx context.Context, apiKey string, serviceAccountID uuid.UUID)) *MockDatabase_CreateAPIKey_Call

func (*MockDatabase_CreateAPIKey_Call) RunAndReturn 

func (_c *MockDatabase_CreateAPIKey_Call) RunAndReturn(run func(context.Context, string, uuid.UUID) error) *MockDatabase_CreateAPIKey_Call

type MockDatabase_CreateAuditLogEntry_Call 

type MockDatabase_CreateAuditLogEntry_Call struct {
	*mock.Call
}

MockDatabase_CreateAuditLogEntry_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAuditLogEntry'

func (*MockDatabase_CreateAuditLogEntry_Call) Return 

func (_c *MockDatabase_CreateAuditLogEntry_Call) Return(_a0 error) *MockDatabase_CreateAuditLogEntry_Call

func (*MockDatabase_CreateAuditLogEntry_Call) Run 

func (_c *MockDatabase_CreateAuditLogEntry_Call) Run(run func(ctx context.Context, correlationID uuid.UUID, actor *string, targetType audittype.AuditLogsTargetType, targetIdentifier string, action audittype.AuditAction, message string)) *MockDatabase_CreateAuditLogEntry_Call

func (*MockDatabase_CreateAuditLogEntry_Call) RunAndReturn 

func (_c *MockDatabase_CreateAuditLogEntry_Call) RunAndReturn(run func(context.Context, uuid.UUID, *string, audittype.AuditLogsTargetType, string, audittype.AuditAction, string) error) *MockDatabase_CreateAuditLogEntry_Call

type MockDatabase_CreateRepositoryAuthorization_Call 

type MockDatabase_CreateRepositoryAuthorization_Call struct {
	*mock.Call
}

MockDatabase_CreateRepositoryAuthorization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateRepositoryAuthorization'

func (*MockDatabase_CreateRepositoryAuthorization_Call) Return 

func (_c *MockDatabase_CreateRepositoryAuthorization_Call) Return(_a0 error) *MockDatabase_CreateRepositoryAuthorization_Call

func (*MockDatabase_CreateRepositoryAuthorization_Call) Run 

func (_c *MockDatabase_CreateRepositoryAuthorization_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, repoName string, authorization gensql.RepositoryAuthorizationEnum)) *MockDatabase_CreateRepositoryAuthorization_Call

func (*MockDatabase_CreateRepositoryAuthorization_Call) RunAndReturn 

func (_c *MockDatabase_CreateRepositoryAuthorization_Call) RunAndReturn(run func(context.Context, slug.Slug, string, gensql.RepositoryAuthorizationEnum) error) *MockDatabase_CreateRepositoryAuthorization_Call

type MockDatabase_CreateServiceAccount_Call 

type MockDatabase_CreateServiceAccount_Call struct {
	*mock.Call
}

MockDatabase_CreateServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateServiceAccount'

func (*MockDatabase_CreateServiceAccount_Call) Return 

func (_c *MockDatabase_CreateServiceAccount_Call) Return(_a0 *ServiceAccount, _a1 error) *MockDatabase_CreateServiceAccount_Call

func (*MockDatabase_CreateServiceAccount_Call) Run 

func (_c *MockDatabase_CreateServiceAccount_Call) Run(run func(ctx context.Context, name string)) *MockDatabase_CreateServiceAccount_Call

func (*MockDatabase_CreateServiceAccount_Call) RunAndReturn 

func (_c *MockDatabase_CreateServiceAccount_Call) RunAndReturn(run func(context.Context, string) (*ServiceAccount, error)) *MockDatabase_CreateServiceAccount_Call

type MockDatabase_CreateSession_Call 

type MockDatabase_CreateSession_Call struct {
	*mock.Call
}

MockDatabase_CreateSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSession'

func (*MockDatabase_CreateSession_Call) Return 

func (_c *MockDatabase_CreateSession_Call) Return(_a0 *Session, _a1 error) *MockDatabase_CreateSession_Call

func (*MockDatabase_CreateSession_Call) Run 

func (_c *MockDatabase_CreateSession_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockDatabase_CreateSession_Call

func (*MockDatabase_CreateSession_Call) RunAndReturn 

func (_c *MockDatabase_CreateSession_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*Session, error)) *MockDatabase_CreateSession_Call

type MockDatabase_CreateTeamDeleteKey_Call 

type MockDatabase_CreateTeamDeleteKey_Call struct {
	*mock.Call
}

MockDatabase_CreateTeamDeleteKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeamDeleteKey'

func (*MockDatabase_CreateTeamDeleteKey_Call) Return 

func (_c *MockDatabase_CreateTeamDeleteKey_Call) Return(_a0 *TeamDeleteKey, _a1 error) *MockDatabase_CreateTeamDeleteKey_Call

func (*MockDatabase_CreateTeamDeleteKey_Call) Run 

func (_c *MockDatabase_CreateTeamDeleteKey_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, userID uuid.UUID)) *MockDatabase_CreateTeamDeleteKey_Call

func (*MockDatabase_CreateTeamDeleteKey_Call) RunAndReturn 

func (_c *MockDatabase_CreateTeamDeleteKey_Call) RunAndReturn(run func(context.Context, slug.Slug, uuid.UUID) (*TeamDeleteKey, error)) *MockDatabase_CreateTeamDeleteKey_Call

type MockDatabase_CreateTeam_Call 

type MockDatabase_CreateTeam_Call struct {
	*mock.Call
}

MockDatabase_CreateTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTeam'

func (*MockDatabase_CreateTeam_Call) Return 

func (_c *MockDatabase_CreateTeam_Call) Return(_a0 *Team, _a1 error) *MockDatabase_CreateTeam_Call

func (*MockDatabase_CreateTeam_Call) Run 

func (_c *MockDatabase_CreateTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, purpose string, slackChannel string)) *MockDatabase_CreateTeam_Call

func (*MockDatabase_CreateTeam_Call) RunAndReturn 

func (_c *MockDatabase_CreateTeam_Call) RunAndReturn(run func(context.Context, slug.Slug, string, string) (*Team, error)) *MockDatabase_CreateTeam_Call

type MockDatabase_CreateUser_Call 

type MockDatabase_CreateUser_Call struct {
	*mock.Call
}

MockDatabase_CreateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUser'

func (*MockDatabase_CreateUser_Call) Return 

func (_c *MockDatabase_CreateUser_Call) Return(_a0 *User, _a1 error) *MockDatabase_CreateUser_Call

func (*MockDatabase_CreateUser_Call) Run 

func (_c *MockDatabase_CreateUser_Call) Run(run func(ctx context.Context, name string, email string, externalID string)) *MockDatabase_CreateUser_Call

func (*MockDatabase_CreateUser_Call) RunAndReturn 

func (_c *MockDatabase_CreateUser_Call) RunAndReturn(run func(context.Context, string, string, string) (*User, error)) *MockDatabase_CreateUser_Call

type MockDatabase_CreateUsersyncRun_Call 

type MockDatabase_CreateUsersyncRun_Call struct {
	*mock.Call
}

MockDatabase_CreateUsersyncRun_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUsersyncRun'

func (*MockDatabase_CreateUsersyncRun_Call) Return 

func (_c *MockDatabase_CreateUsersyncRun_Call) Return(_a0 error) *MockDatabase_CreateUsersyncRun_Call

func (*MockDatabase_CreateUsersyncRun_Call) Run 

func (_c *MockDatabase_CreateUsersyncRun_Call) Run(run func(ctx context.Context, id uuid.UUID, startedAt time.Time, finishedAt time.Time, err error)) *MockDatabase_CreateUsersyncRun_Call

func (*MockDatabase_CreateUsersyncRun_Call) RunAndReturn 

func (_c *MockDatabase_CreateUsersyncRun_Call) RunAndReturn(run func(context.Context, uuid.UUID, time.Time, time.Time, error) error) *MockDatabase_CreateUsersyncRun_Call

type MockDatabase_CurrentSqlInstancesCostForTeam_Call 

type MockDatabase_CurrentSqlInstancesCostForTeam_Call struct {
	*mock.Call
}

MockDatabase_CurrentSqlInstancesCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentSqlInstancesCostForTeam'

func (*MockDatabase_CurrentSqlInstancesCostForTeam_Call) Return 

func (_c *MockDatabase_CurrentSqlInstancesCostForTeam_Call) Return(_a0 float32, _a1 error) *MockDatabase_CurrentSqlInstancesCostForTeam_Call

func (*MockDatabase_CurrentSqlInstancesCostForTeam_Call) Run 

func (_c *MockDatabase_CurrentSqlInstancesCostForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockDatabase_CurrentSqlInstancesCostForTeam_Call

func (*MockDatabase_CurrentSqlInstancesCostForTeam_Call) RunAndReturn 

func (_c *MockDatabase_CurrentSqlInstancesCostForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) (float32, error)) *MockDatabase_CurrentSqlInstancesCostForTeam_Call

type MockDatabase_DailyCostForApp_Call 

type MockDatabase_DailyCostForApp_Call struct {
	*mock.Call
}

MockDatabase_DailyCostForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyCostForApp'

func (*MockDatabase_DailyCostForApp_Call) Return 

func (_c *MockDatabase_DailyCostForApp_Call) Return(_a0 []*gensql.Cost, _a1 error) *MockDatabase_DailyCostForApp_Call

func (*MockDatabase_DailyCostForApp_Call) Run 

func (_c *MockDatabase_DailyCostForApp_Call) Run(run func(ctx context.Context, fromDate pgtype.Date, toDate pgtype.Date, environment string, teamSlug slug.Slug, app string)) *MockDatabase_DailyCostForApp_Call

func (*MockDatabase_DailyCostForApp_Call) RunAndReturn 

func (_c *MockDatabase_DailyCostForApp_Call) RunAndReturn(run func(context.Context, pgtype.Date, pgtype.Date, string, slug.Slug, string) ([]*gensql.Cost, error)) *MockDatabase_DailyCostForApp_Call

type MockDatabase_DailyCostForTeam_Call 

type MockDatabase_DailyCostForTeam_Call struct {
	*mock.Call
}

MockDatabase_DailyCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyCostForTeam'

func (*MockDatabase_DailyCostForTeam_Call) Return 

func (_c *MockDatabase_DailyCostForTeam_Call) Return(_a0 []*gensql.Cost, _a1 error) *MockDatabase_DailyCostForTeam_Call

func (*MockDatabase_DailyCostForTeam_Call) Run 

func (_c *MockDatabase_DailyCostForTeam_Call) Run(run func(ctx context.Context, fromDate pgtype.Date, toDate pgtype.Date, teamSlug slug.Slug)) *MockDatabase_DailyCostForTeam_Call

func (*MockDatabase_DailyCostForTeam_Call) RunAndReturn 

func (_c *MockDatabase_DailyCostForTeam_Call) RunAndReturn(run func(context.Context, pgtype.Date, pgtype.Date, slug.Slug) ([]*gensql.Cost, error)) *MockDatabase_DailyCostForTeam_Call

type MockDatabase_DailyEnvCostForTeam_Call 

type MockDatabase_DailyEnvCostForTeam_Call struct {
	*mock.Call
}

MockDatabase_DailyEnvCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DailyEnvCostForTeam'

func (*MockDatabase_DailyEnvCostForTeam_Call) Return 

func (_c *MockDatabase_DailyEnvCostForTeam_Call) Return(_a0 []*gensql.DailyEnvCostForTeamRow, _a1 error) *MockDatabase_DailyEnvCostForTeam_Call

func (*MockDatabase_DailyEnvCostForTeam_Call) Run 

func (_c *MockDatabase_DailyEnvCostForTeam_Call) Run(run func(ctx context.Context, fromDate pgtype.Date, toDate pgtype.Date, environment *string, teamSlug slug.Slug)) *MockDatabase_DailyEnvCostForTeam_Call

func (*MockDatabase_DailyEnvCostForTeam_Call) RunAndReturn 

func (_c *MockDatabase_DailyEnvCostForTeam_Call) RunAndReturn(run func(context.Context, pgtype.Date, pgtype.Date, *string, slug.Slug) ([]*gensql.DailyEnvCostForTeamRow, error)) *MockDatabase_DailyEnvCostForTeam_Call

type MockDatabase_DeleteAllEnvironments_Call 

type MockDatabase_DeleteAllEnvironments_Call struct {
	*mock.Call
}

MockDatabase_DeleteAllEnvironments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAllEnvironments'

func (*MockDatabase_DeleteAllEnvironments_Call) Return 

func (_c *MockDatabase_DeleteAllEnvironments_Call) Return(_a0 error) *MockDatabase_DeleteAllEnvironments_Call

func (*MockDatabase_DeleteAllEnvironments_Call) Run 

func (_c *MockDatabase_DeleteAllEnvironments_Call) Run(run func(ctx context.Context)) *MockDatabase_DeleteAllEnvironments_Call

func (*MockDatabase_DeleteAllEnvironments_Call) RunAndReturn 

func (_c *MockDatabase_DeleteAllEnvironments_Call) RunAndReturn(run func(context.Context) error) *MockDatabase_DeleteAllEnvironments_Call

type MockDatabase_DeleteReconcilerConfig_Call 

type MockDatabase_DeleteReconcilerConfig_Call struct {
	*mock.Call
}

MockDatabase_DeleteReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReconcilerConfig'

func (*MockDatabase_DeleteReconcilerConfig_Call) Return 

func (_c *MockDatabase_DeleteReconcilerConfig_Call) Return(_a0 error) *MockDatabase_DeleteReconcilerConfig_Call

func (*MockDatabase_DeleteReconcilerConfig_Call) Run 

func (_c *MockDatabase_DeleteReconcilerConfig_Call) Run(run func(ctx context.Context, reconcilerName string, keysToDelete []string)) *MockDatabase_DeleteReconcilerConfig_Call

func (*MockDatabase_DeleteReconcilerConfig_Call) RunAndReturn 

func (_c *MockDatabase_DeleteReconcilerConfig_Call) RunAndReturn(run func(context.Context, string, []string) error) *MockDatabase_DeleteReconcilerConfig_Call

type MockDatabase_DeleteReconcilerStateForTeam_Call 

type MockDatabase_DeleteReconcilerStateForTeam_Call struct {
	*mock.Call
}

MockDatabase_DeleteReconcilerStateForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReconcilerStateForTeam'

func (*MockDatabase_DeleteReconcilerStateForTeam_Call) Return 

func (_c *MockDatabase_DeleteReconcilerStateForTeam_Call) Return(_a0 error) *MockDatabase_DeleteReconcilerStateForTeam_Call

func (*MockDatabase_DeleteReconcilerStateForTeam_Call) Run 

func (_c *MockDatabase_DeleteReconcilerStateForTeam_Call) Run(run func(ctx context.Context, reconcilerName string, teamSlug slug.Slug)) *MockDatabase_DeleteReconcilerStateForTeam_Call

func (*MockDatabase_DeleteReconcilerStateForTeam_Call) RunAndReturn 

func (_c *MockDatabase_DeleteReconcilerStateForTeam_Call) RunAndReturn(run func(context.Context, string, slug.Slug) error) *MockDatabase_DeleteReconcilerStateForTeam_Call

type MockDatabase_DeleteServiceAccount_Call 

type MockDatabase_DeleteServiceAccount_Call struct {
	*mock.Call
}

MockDatabase_DeleteServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteServiceAccount'

func (*MockDatabase_DeleteServiceAccount_Call) Return 

func (_c *MockDatabase_DeleteServiceAccount_Call) Return(_a0 error) *MockDatabase_DeleteServiceAccount_Call

func (*MockDatabase_DeleteServiceAccount_Call) Run 

func (_c *MockDatabase_DeleteServiceAccount_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID)) *MockDatabase_DeleteServiceAccount_Call

func (*MockDatabase_DeleteServiceAccount_Call) RunAndReturn 

func (_c *MockDatabase_DeleteServiceAccount_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockDatabase_DeleteServiceAccount_Call

type MockDatabase_DeleteSession_Call 

type MockDatabase_DeleteSession_Call struct {
	*mock.Call
}

MockDatabase_DeleteSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteSession'

func (*MockDatabase_DeleteSession_Call) Return 

func (_c *MockDatabase_DeleteSession_Call) Return(_a0 error) *MockDatabase_DeleteSession_Call

func (*MockDatabase_DeleteSession_Call) Run 

func (_c *MockDatabase_DeleteSession_Call) Run(run func(ctx context.Context, sessionID uuid.UUID)) *MockDatabase_DeleteSession_Call

func (*MockDatabase_DeleteSession_Call) RunAndReturn 

func (_c *MockDatabase_DeleteSession_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockDatabase_DeleteSession_Call

type MockDatabase_DeleteTeam_Call 

type MockDatabase_DeleteTeam_Call struct {
	*mock.Call
}

MockDatabase_DeleteTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTeam'

func (*MockDatabase_DeleteTeam_Call) Return 

func (_c *MockDatabase_DeleteTeam_Call) Return(_a0 error) *MockDatabase_DeleteTeam_Call

func (*MockDatabase_DeleteTeam_Call) Run 

func (_c *MockDatabase_DeleteTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockDatabase_DeleteTeam_Call

func (*MockDatabase_DeleteTeam_Call) RunAndReturn 

func (_c *MockDatabase_DeleteTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) error) *MockDatabase_DeleteTeam_Call

type MockDatabase_DeleteUser_Call 

type MockDatabase_DeleteUser_Call struct {
	*mock.Call
}

MockDatabase_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser'

func (*MockDatabase_DeleteUser_Call) Return 

func (_c *MockDatabase_DeleteUser_Call) Return(_a0 error) *MockDatabase_DeleteUser_Call

func (*MockDatabase_DeleteUser_Call) Run 

func (_c *MockDatabase_DeleteUser_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockDatabase_DeleteUser_Call

func (*MockDatabase_DeleteUser_Call) RunAndReturn 

func (_c *MockDatabase_DeleteUser_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockDatabase_DeleteUser_Call

type MockDatabase_DisableReconciler_Call 

type MockDatabase_DisableReconciler_Call struct {
	*mock.Call
}

MockDatabase_DisableReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableReconciler'

func (*MockDatabase_DisableReconciler_Call) Return 

func (_c *MockDatabase_DisableReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockDatabase_DisableReconciler_Call

func (*MockDatabase_DisableReconciler_Call) Run 

func (_c *MockDatabase_DisableReconciler_Call) Run(run func(ctx context.Context, reconcilerName string)) *MockDatabase_DisableReconciler_Call

func (*MockDatabase_DisableReconciler_Call) RunAndReturn 

func (_c *MockDatabase_DisableReconciler_Call) RunAndReturn(run func(context.Context, string) (*Reconciler, error)) *MockDatabase_DisableReconciler_Call

type MockDatabase_EnableReconciler_Call 

type MockDatabase_EnableReconciler_Call struct {
	*mock.Call
}

MockDatabase_EnableReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableReconciler'

func (*MockDatabase_EnableReconciler_Call) Return 

func (_c *MockDatabase_EnableReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockDatabase_EnableReconciler_Call

func (*MockDatabase_EnableReconciler_Call) Run 

func (_c *MockDatabase_EnableReconciler_Call) Run(run func(ctx context.Context, reconcilerName string)) *MockDatabase_EnableReconciler_Call

func (*MockDatabase_EnableReconciler_Call) RunAndReturn 

func (_c *MockDatabase_EnableReconciler_Call) RunAndReturn(run func(context.Context, string) (*Reconciler, error)) *MockDatabase_EnableReconciler_Call

type MockDatabase_Expecter 

type MockDatabase_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockDatabase_Expecter) AddReconcilerOptOut 

func (_e *MockDatabase_Expecter) AddReconcilerOptOut(ctx interface{}, userID interface{}, teamSlug interface{}, reconcilerName interface{}) *MockDatabase_AddReconcilerOptOut_Call

AddReconcilerOptOut is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • teamSlug slug.Slug
  • reconcilerName string

func (*MockDatabase_Expecter) AssignGlobalRoleToServiceAccount 

func (_e *MockDatabase_Expecter) AssignGlobalRoleToServiceAccount(ctx interface{}, serviceAccountID interface{}, roleName interface{}) *MockDatabase_AssignGlobalRoleToServiceAccount_Call

AssignGlobalRoleToServiceAccount is a helper method to define mock.On call

  • ctx context.Context
  • serviceAccountID uuid.UUID
  • roleName gensql.RoleName

func (*MockDatabase_Expecter) AssignGlobalRoleToUser 

func (_e *MockDatabase_Expecter) AssignGlobalRoleToUser(ctx interface{}, userID interface{}, roleName interface{}) *MockDatabase_AssignGlobalRoleToUser_Call

AssignGlobalRoleToUser is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • roleName gensql.RoleName

func (*MockDatabase_Expecter) AssignTeamRoleToServiceAccount 

func (_e *MockDatabase_Expecter) AssignTeamRoleToServiceAccount(ctx interface{}, serviceAccountID interface{}, roleName interface{}, teamSlug interface{}) *MockDatabase_AssignTeamRoleToServiceAccount_Call

AssignTeamRoleToServiceAccount is a helper method to define mock.On call

  • ctx context.Context
  • serviceAccountID uuid.UUID
  • roleName gensql.RoleName
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) AverageResourceUtilizationForTeam 

func (_e *MockDatabase_Expecter) AverageResourceUtilizationForTeam(ctx interface{}, teamSlug interface{}, resourceType interface{}, timestamp interface{}) *MockDatabase_AverageResourceUtilizationForTeam_Call

AverageResourceUtilizationForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • resourceType gensql.ResourceType
  • timestamp pgtype.Timestamptz

func (*MockDatabase_Expecter) ClearReconcilerErrorsForTeam 

func (_e *MockDatabase_Expecter) ClearReconcilerErrorsForTeam(ctx interface{}, teamSlug interface{}, reconcilerName interface{}) *MockDatabase_ClearReconcilerErrorsForTeam_Call

ClearReconcilerErrorsForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • reconcilerName string

func (*MockDatabase_Expecter) ConfigureReconciler 

func (_e *MockDatabase_Expecter) ConfigureReconciler(ctx interface{}, reconcilerName interface{}, key interface{}, value interface{}) *MockDatabase_ConfigureReconciler_Call

ConfigureReconciler is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string
  • key string
  • value string

func (*MockDatabase_Expecter) ConfirmTeamDeleteKey 

func (_e *MockDatabase_Expecter) ConfirmTeamDeleteKey(ctx interface{}, key interface{}) *MockDatabase_ConfirmTeamDeleteKey_Call

ConfirmTeamDeleteKey is a helper method to define mock.On call

  • ctx context.Context
  • key uuid.UUID

func (*MockDatabase_Expecter) CostForInstance 

func (_e *MockDatabase_Expecter) CostForInstance(ctx interface{}, costType interface{}, fromDate interface{}, toDate interface{}, teamSlug interface{}, appName interface{}, environment interface{}) *MockDatabase_CostForInstance_Call

CostForInstance is a helper method to define mock.On call

  • ctx context.Context
  • costType string
  • fromDate pgtype.Date
  • toDate pgtype.Date
  • teamSlug slug.Slug
  • appName string
  • environment string

func (*MockDatabase_Expecter) CostRefresh 

func (_e *MockDatabase_Expecter) CostRefresh(ctx interface{}) *MockDatabase_CostRefresh_Call

CostRefresh is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) CostUpsert 

func (_e *MockDatabase_Expecter) CostUpsert(ctx interface{}, arg interface{}) *MockDatabase_CostUpsert_Call

CostUpsert is a helper method to define mock.On call

  • ctx context.Context
  • arg []gensql.CostUpsertParams

func (*MockDatabase_Expecter) CreateAPIKey 

func (_e *MockDatabase_Expecter) CreateAPIKey(ctx interface{}, apiKey interface{}, serviceAccountID interface{}) *MockDatabase_CreateAPIKey_Call

CreateAPIKey is a helper method to define mock.On call

  • ctx context.Context
  • apiKey string
  • serviceAccountID uuid.UUID

func (*MockDatabase_Expecter) CreateAuditLogEntry 

func (_e *MockDatabase_Expecter) CreateAuditLogEntry(ctx interface{}, correlationID interface{}, actor interface{}, targetType interface{}, targetIdentifier interface{}, action interface{}, message interface{}) *MockDatabase_CreateAuditLogEntry_Call

CreateAuditLogEntry is a helper method to define mock.On call

  • ctx context.Context
  • correlationID uuid.UUID
  • actor *string
  • targetType audittype.AuditLogsTargetType
  • targetIdentifier string
  • action audittype.AuditAction
  • message string

func (*MockDatabase_Expecter) CreateRepositoryAuthorization 

func (_e *MockDatabase_Expecter) CreateRepositoryAuthorization(ctx interface{}, teamSlug interface{}, repoName interface{}, authorization interface{}) *MockDatabase_CreateRepositoryAuthorization_Call

CreateRepositoryAuthorization is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • repoName string
  • authorization gensql.RepositoryAuthorizationEnum

func (*MockDatabase_Expecter) CreateServiceAccount 

func (_e *MockDatabase_Expecter) CreateServiceAccount(ctx interface{}, name interface{}) *MockDatabase_CreateServiceAccount_Call

CreateServiceAccount is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockDatabase_Expecter) CreateSession 

func (_e *MockDatabase_Expecter) CreateSession(ctx interface{}, userID interface{}) *MockDatabase_CreateSession_Call

CreateSession is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID

func (*MockDatabase_Expecter) CreateTeam 

func (_e *MockDatabase_Expecter) CreateTeam(ctx interface{}, teamSlug interface{}, purpose interface{}, slackChannel interface{}) *MockDatabase_CreateTeam_Call

CreateTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • purpose string
  • slackChannel string

func (*MockDatabase_Expecter) CreateTeamDeleteKey 

func (_e *MockDatabase_Expecter) CreateTeamDeleteKey(ctx interface{}, teamSlug interface{}, userID interface{}) *MockDatabase_CreateTeamDeleteKey_Call

CreateTeamDeleteKey is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • userID uuid.UUID

func (*MockDatabase_Expecter) CreateUser 

func (_e *MockDatabase_Expecter) CreateUser(ctx interface{}, name interface{}, email interface{}, externalID interface{}) *MockDatabase_CreateUser_Call

CreateUser is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • email string
  • externalID string

func (*MockDatabase_Expecter) CreateUsersyncRun 

func (_e *MockDatabase_Expecter) CreateUsersyncRun(ctx interface{}, id interface{}, startedAt interface{}, finishedAt interface{}, err interface{}) *MockDatabase_CreateUsersyncRun_Call

CreateUsersyncRun is a helper method to define mock.On call

  • ctx context.Context
  • id uuid.UUID
  • startedAt time.Time
  • finishedAt time.Time
  • err error

func (*MockDatabase_Expecter) CurrentSqlInstancesCostForTeam 

func (_e *MockDatabase_Expecter) CurrentSqlInstancesCostForTeam(ctx interface{}, teamSlug interface{}) *MockDatabase_CurrentSqlInstancesCostForTeam_Call

CurrentSqlInstancesCostForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) DailyCostForApp 

func (_e *MockDatabase_Expecter) DailyCostForApp(ctx interface{}, fromDate interface{}, toDate interface{}, environment interface{}, teamSlug interface{}, app interface{}) *MockDatabase_DailyCostForApp_Call

DailyCostForApp is a helper method to define mock.On call

  • ctx context.Context
  • fromDate pgtype.Date
  • toDate pgtype.Date
  • environment string
  • teamSlug slug.Slug
  • app string

func (*MockDatabase_Expecter) DailyCostForTeam 

func (_e *MockDatabase_Expecter) DailyCostForTeam(ctx interface{}, fromDate interface{}, toDate interface{}, teamSlug interface{}) *MockDatabase_DailyCostForTeam_Call

DailyCostForTeam is a helper method to define mock.On call

  • ctx context.Context
  • fromDate pgtype.Date
  • toDate pgtype.Date
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) DailyEnvCostForTeam 

func (_e *MockDatabase_Expecter) DailyEnvCostForTeam(ctx interface{}, fromDate interface{}, toDate interface{}, environment interface{}, teamSlug interface{}) *MockDatabase_DailyEnvCostForTeam_Call

DailyEnvCostForTeam is a helper method to define mock.On call

  • ctx context.Context
  • fromDate pgtype.Date
  • toDate pgtype.Date
  • environment *string
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) DeleteAllEnvironments 

func (_e *MockDatabase_Expecter) DeleteAllEnvironments(ctx interface{}) *MockDatabase_DeleteAllEnvironments_Call

DeleteAllEnvironments is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) DeleteReconcilerConfig 

func (_e *MockDatabase_Expecter) DeleteReconcilerConfig(ctx interface{}, reconcilerName interface{}, keysToDelete interface{}) *MockDatabase_DeleteReconcilerConfig_Call

DeleteReconcilerConfig is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string
  • keysToDelete []string

func (*MockDatabase_Expecter) DeleteReconcilerStateForTeam 

func (_e *MockDatabase_Expecter) DeleteReconcilerStateForTeam(ctx interface{}, reconcilerName interface{}, teamSlug interface{}) *MockDatabase_DeleteReconcilerStateForTeam_Call

DeleteReconcilerStateForTeam is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) DeleteServiceAccount 

func (_e *MockDatabase_Expecter) DeleteServiceAccount(ctx interface{}, serviceAccountID interface{}) *MockDatabase_DeleteServiceAccount_Call

DeleteServiceAccount is a helper method to define mock.On call

  • ctx context.Context
  • serviceAccountID uuid.UUID

func (*MockDatabase_Expecter) DeleteSession 

func (_e *MockDatabase_Expecter) DeleteSession(ctx interface{}, sessionID interface{}) *MockDatabase_DeleteSession_Call

DeleteSession is a helper method to define mock.On call

  • ctx context.Context
  • sessionID uuid.UUID

func (*MockDatabase_Expecter) DeleteTeam 

func (_e *MockDatabase_Expecter) DeleteTeam(ctx interface{}, teamSlug interface{}) *MockDatabase_DeleteTeam_Call

DeleteTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) DeleteUser 

func (_e *MockDatabase_Expecter) DeleteUser(ctx interface{}, userID interface{}) *MockDatabase_DeleteUser_Call

DeleteUser is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID

func (*MockDatabase_Expecter) DisableReconciler 

func (_e *MockDatabase_Expecter) DisableReconciler(ctx interface{}, reconcilerName interface{}) *MockDatabase_DisableReconciler_Call

DisableReconciler is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string

func (*MockDatabase_Expecter) EnableReconciler 

func (_e *MockDatabase_Expecter) EnableReconciler(ctx interface{}, reconcilerName interface{}) *MockDatabase_EnableReconciler_Call

EnableReconciler is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string

func (*MockDatabase_Expecter) ExtendSession 

func (_e *MockDatabase_Expecter) ExtendSession(ctx interface{}, sessionID interface{}) *MockDatabase_ExtendSession_Call

ExtendSession is a helper method to define mock.On call

  • ctx context.Context
  • sessionID uuid.UUID

func (*MockDatabase_Expecter) GetActiveTeamBySlug 

func (_e *MockDatabase_Expecter) GetActiveTeamBySlug(ctx interface{}, teamSlug interface{}) *MockDatabase_GetActiveTeamBySlug_Call

GetActiveTeamBySlug is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) GetActiveTeams 

func (_e *MockDatabase_Expecter) GetActiveTeams(ctx interface{}) *MockDatabase_GetActiveTeams_Call

GetActiveTeams is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) GetAllTeamMembers 

func (_e *MockDatabase_Expecter) GetAllTeamMembers(ctx interface{}, teamSlug interface{}) *MockDatabase_GetAllTeamMembers_Call

GetAllTeamMembers is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) GetAllTeamSlugs 

func (_e *MockDatabase_Expecter) GetAllTeamSlugs(ctx interface{}) *MockDatabase_GetAllTeamSlugs_Call

GetAllTeamSlugs is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) GetAllTeamsWithPermissionInGitHubRepo 

func (_e *MockDatabase_Expecter) GetAllTeamsWithPermissionInGitHubRepo(ctx interface{}, repoName interface{}, permission interface{}) *MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call

GetAllTeamsWithPermissionInGitHubRepo is a helper method to define mock.On call

  • ctx context.Context
  • repoName string
  • permission string

func (*MockDatabase_Expecter) GetAllUserRoles 

func (_e *MockDatabase_Expecter) GetAllUserRoles(ctx interface{}) *MockDatabase_GetAllUserRoles_Call

GetAllUserRoles is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) GetAuditLogsForCorrelationID 

func (_e *MockDatabase_Expecter) GetAuditLogsForCorrelationID(ctx interface{}, correlationID interface{}, p interface{}) *MockDatabase_GetAuditLogsForCorrelationID_Call

GetAuditLogsForCorrelationID is a helper method to define mock.On call

  • ctx context.Context
  • correlationID uuid.UUID
  • p Page

func (*MockDatabase_Expecter) GetAuditLogsForReconciler 

func (_e *MockDatabase_Expecter) GetAuditLogsForReconciler(ctx interface{}, reconcilerName interface{}, p interface{}) *MockDatabase_GetAuditLogsForReconciler_Call

GetAuditLogsForReconciler is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string
  • p Page

func (*MockDatabase_Expecter) GetAuditLogsForTeam 

func (_e *MockDatabase_Expecter) GetAuditLogsForTeam(ctx interface{}, teamSlug interface{}, p interface{}) *MockDatabase_GetAuditLogsForTeam_Call

GetAuditLogsForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • p Page

func (*MockDatabase_Expecter) GetEnabledReconcilers 

func (_e *MockDatabase_Expecter) GetEnabledReconcilers(ctx interface{}) *MockDatabase_GetEnabledReconcilers_Call

GetEnabledReconcilers is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) GetReconciler 

func (_e *MockDatabase_Expecter) GetReconciler(ctx interface{}, reconcilerName interface{}) *MockDatabase_GetReconciler_Call

GetReconciler is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string

func (*MockDatabase_Expecter) GetReconcilerConfig 

func (_e *MockDatabase_Expecter) GetReconcilerConfig(ctx interface{}, reconcilerName interface{}, includeSecrets interface{}) *MockDatabase_GetReconcilerConfig_Call

GetReconcilerConfig is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string
  • includeSecrets bool

func (*MockDatabase_Expecter) GetReconcilerErrors 

func (_e *MockDatabase_Expecter) GetReconcilerErrors(ctx interface{}, reconcilerName interface{}, p interface{}) *MockDatabase_GetReconcilerErrors_Call

GetReconcilerErrors is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string
  • p Page

func (*MockDatabase_Expecter) GetReconcilerState 

func (_e *MockDatabase_Expecter) GetReconcilerState(ctx interface{}, reconcilerName interface{}) *MockDatabase_GetReconcilerState_Call

GetReconcilerState is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string

func (*MockDatabase_Expecter) GetReconcilerStateForTeam 

func (_e *MockDatabase_Expecter) GetReconcilerStateForTeam(ctx interface{}, reconcilerName interface{}, teamSlug interface{}) *MockDatabase_GetReconcilerStateForTeam_Call

GetReconcilerStateForTeam is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) GetReconcilers 

func (_e *MockDatabase_Expecter) GetReconcilers(ctx interface{}, p interface{}) *MockDatabase_GetReconcilers_Call

GetReconcilers is a helper method to define mock.On call

  • ctx context.Context
  • p Page

func (*MockDatabase_Expecter) GetRepositoryAuthorizations 

func (_e *MockDatabase_Expecter) GetRepositoryAuthorizations(ctx interface{}, teamSlug interface{}, repoName interface{}) *MockDatabase_GetRepositoryAuthorizations_Call

GetRepositoryAuthorizations is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • repoName string

func (*MockDatabase_Expecter) GetServiceAccountByApiKey 

func (_e *MockDatabase_Expecter) GetServiceAccountByApiKey(ctx interface{}, apiKey interface{}) *MockDatabase_GetServiceAccountByApiKey_Call

GetServiceAccountByApiKey is a helper method to define mock.On call

  • ctx context.Context
  • apiKey string

func (*MockDatabase_Expecter) GetServiceAccountByName 

func (_e *MockDatabase_Expecter) GetServiceAccountByName(ctx interface{}, name interface{}) *MockDatabase_GetServiceAccountByName_Call

GetServiceAccountByName is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*MockDatabase_Expecter) GetServiceAccountRoles 

func (_e *MockDatabase_Expecter) GetServiceAccountRoles(ctx interface{}, serviceAccountID interface{}) *MockDatabase_GetServiceAccountRoles_Call

GetServiceAccountRoles is a helper method to define mock.On call

  • ctx context.Context
  • serviceAccountID uuid.UUID

func (*MockDatabase_Expecter) GetServiceAccounts 

func (_e *MockDatabase_Expecter) GetServiceAccounts(ctx interface{}) *MockDatabase_GetServiceAccounts_Call

GetServiceAccounts is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) GetServiceAccountsByIDs 

func (_e *MockDatabase_Expecter) GetServiceAccountsByIDs(ctx interface{}, ids interface{}) *MockDatabase_GetServiceAccountsByIDs_Call

GetServiceAccountsByIDs is a helper method to define mock.On call

  • ctx context.Context
  • ids []uuid.UUID

func (*MockDatabase_Expecter) GetSessionByID 

func (_e *MockDatabase_Expecter) GetSessionByID(ctx interface{}, sessionID interface{}) *MockDatabase_GetSessionByID_Call

GetSessionByID is a helper method to define mock.On call

  • ctx context.Context
  • sessionID uuid.UUID

func (*MockDatabase_Expecter) GetTeamBySlug 

func (_e *MockDatabase_Expecter) GetTeamBySlug(ctx interface{}, teamSlug interface{}) *MockDatabase_GetTeamBySlug_Call

GetTeamBySlug is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) GetTeamDeleteKey 

func (_e *MockDatabase_Expecter) GetTeamDeleteKey(ctx interface{}, key interface{}) *MockDatabase_GetTeamDeleteKey_Call

GetTeamDeleteKey is a helper method to define mock.On call

  • ctx context.Context
  • key uuid.UUID

func (*MockDatabase_Expecter) GetTeamEnvironments 

func (_e *MockDatabase_Expecter) GetTeamEnvironments(ctx interface{}, teamSlug interface{}, p interface{}) *MockDatabase_GetTeamEnvironments_Call

GetTeamEnvironments is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • p Page

func (*MockDatabase_Expecter) GetTeamEnvironmentsBySlugsAndEnvNames 

func (_e *MockDatabase_Expecter) GetTeamEnvironmentsBySlugsAndEnvNames(ctx interface{}, keys interface{}) *MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call

GetTeamEnvironmentsBySlugsAndEnvNames is a helper method to define mock.On call

  • ctx context.Context
  • keys []EnvSlugName

func (*MockDatabase_Expecter) GetTeamMember 

func (_e *MockDatabase_Expecter) GetTeamMember(ctx interface{}, teamSlug interface{}, userID interface{}) *MockDatabase_GetTeamMember_Call

GetTeamMember is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • userID uuid.UUID

func (*MockDatabase_Expecter) GetTeamMemberOptOuts 

func (_e *MockDatabase_Expecter) GetTeamMemberOptOuts(ctx interface{}, userID interface{}, teamSlug interface{}) *MockDatabase_GetTeamMemberOptOuts_Call

GetTeamMemberOptOuts is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) GetTeamMembers 

func (_e *MockDatabase_Expecter) GetTeamMembers(ctx interface{}, teamSlug interface{}, p interface{}) *MockDatabase_GetTeamMembers_Call

GetTeamMembers is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • p Page

func (*MockDatabase_Expecter) GetTeamMembersForReconciler 

func (_e *MockDatabase_Expecter) GetTeamMembersForReconciler(ctx interface{}, teamSlug interface{}, reconcilerName interface{}) *MockDatabase_GetTeamMembersForReconciler_Call

GetTeamMembersForReconciler is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • reconcilerName string

func (*MockDatabase_Expecter) GetTeamReconcilerErrors 

func (_e *MockDatabase_Expecter) GetTeamReconcilerErrors(ctx interface{}, teamSlug interface{}) *MockDatabase_GetTeamReconcilerErrors_Call

GetTeamReconcilerErrors is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) GetTeams 

func (_e *MockDatabase_Expecter) GetTeams(ctx interface{}, p interface{}) *MockDatabase_GetTeams_Call

GetTeams is a helper method to define mock.On call

  • ctx context.Context
  • p Page

func (*MockDatabase_Expecter) GetTeamsBySlugs 

func (_e *MockDatabase_Expecter) GetTeamsBySlugs(ctx interface{}, teamSlugs interface{}) *MockDatabase_GetTeamsBySlugs_Call

GetTeamsBySlugs is a helper method to define mock.On call

  • ctx context.Context
  • teamSlugs []slug.Slug

func (*MockDatabase_Expecter) GetUserByEmail 

func (_e *MockDatabase_Expecter) GetUserByEmail(ctx interface{}, email interface{}) *MockDatabase_GetUserByEmail_Call

GetUserByEmail is a helper method to define mock.On call

  • ctx context.Context
  • email string

func (*MockDatabase_Expecter) GetUserByExternalID 

func (_e *MockDatabase_Expecter) GetUserByExternalID(ctx interface{}, externalID interface{}) *MockDatabase_GetUserByExternalID_Call

GetUserByExternalID is a helper method to define mock.On call

  • ctx context.Context
  • externalID string

func (*MockDatabase_Expecter) GetUserByID 

func (_e *MockDatabase_Expecter) GetUserByID(ctx interface{}, id interface{}) *MockDatabase_GetUserByID_Call

GetUserByID is a helper method to define mock.On call

  • ctx context.Context
  • id uuid.UUID

func (*MockDatabase_Expecter) GetUserRoles 

func (_e *MockDatabase_Expecter) GetUserRoles(ctx interface{}, userID interface{}) *MockDatabase_GetUserRoles_Call

GetUserRoles is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID

func (*MockDatabase_Expecter) GetUserRolesForUsers 

func (_e *MockDatabase_Expecter) GetUserRolesForUsers(ctx interface{}, userIDs interface{}) *MockDatabase_GetUserRolesForUsers_Call

GetUserRolesForUsers is a helper method to define mock.On call

  • ctx context.Context
  • userIDs []uuid.UUID

func (*MockDatabase_Expecter) GetUserTeams 

func (_e *MockDatabase_Expecter) GetUserTeams(ctx interface{}, userID interface{}) *MockDatabase_GetUserTeams_Call

GetUserTeams is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID

func (*MockDatabase_Expecter) GetUserTeamsPaginated 

func (_e *MockDatabase_Expecter) GetUserTeamsPaginated(ctx interface{}, userID interface{}, p interface{}) *MockDatabase_GetUserTeamsPaginated_Call

GetUserTeamsPaginated is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • p Page

func (*MockDatabase_Expecter) GetUsers 

func (_e *MockDatabase_Expecter) GetUsers(ctx interface{}, p interface{}) *MockDatabase_GetUsers_Call

GetUsers is a helper method to define mock.On call

  • ctx context.Context
  • p Page

func (*MockDatabase_Expecter) GetUsersByIDs 

func (_e *MockDatabase_Expecter) GetUsersByIDs(ctx interface{}, ids interface{}) *MockDatabase_GetUsersByIDs_Call

GetUsersByIDs is a helper method to define mock.On call

  • ctx context.Context
  • ids []uuid.UUID

func (*MockDatabase_Expecter) GetUsersWithGloballyAssignedRole 

func (_e *MockDatabase_Expecter) GetUsersWithGloballyAssignedRole(ctx interface{}, roleName interface{}) *MockDatabase_GetUsersWithGloballyAssignedRole_Call

GetUsersWithGloballyAssignedRole is a helper method to define mock.On call

  • ctx context.Context
  • roleName gensql.RoleName

func (*MockDatabase_Expecter) GetUsersyncRuns 

func (_e *MockDatabase_Expecter) GetUsersyncRuns(ctx interface{}, p interface{}) *MockDatabase_GetUsersyncRuns_Call

GetUsersyncRuns is a helper method to define mock.On call

  • ctx context.Context
  • p Page

func (*MockDatabase_Expecter) InsertEnvironment 

func (_e *MockDatabase_Expecter) InsertEnvironment(ctx interface{}, name interface{}, gcp interface{}) *MockDatabase_InsertEnvironment_Call

InsertEnvironment is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • gcp bool

func (*MockDatabase_Expecter) LastCostDate 

func (_e *MockDatabase_Expecter) LastCostDate(ctx interface{}) *MockDatabase_LastCostDate_Call

LastCostDate is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) ListRepositoriesByAuthorization 

func (_e *MockDatabase_Expecter) ListRepositoriesByAuthorization(ctx interface{}, teamSlug interface{}, authorization interface{}) *MockDatabase_ListRepositoriesByAuthorization_Call

ListRepositoriesByAuthorization is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • authorization gensql.RepositoryAuthorizationEnum

func (*MockDatabase_Expecter) MaxResourceUtilizationDate 

func (_e *MockDatabase_Expecter) MaxResourceUtilizationDate(ctx interface{}) *MockDatabase_MaxResourceUtilizationDate_Call

MaxResourceUtilizationDate is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) MonthlyCostForApp 

func (_e *MockDatabase_Expecter) MonthlyCostForApp(ctx interface{}, teamSlug interface{}, app interface{}, environment interface{}) *MockDatabase_MonthlyCostForApp_Call

MonthlyCostForApp is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • app string
  • environment string

func (*MockDatabase_Expecter) MonthlyCostForTeam 

func (_e *MockDatabase_Expecter) MonthlyCostForTeam(ctx interface{}, teamSlug interface{}) *MockDatabase_MonthlyCostForTeam_Call

MonthlyCostForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) RemoveAllServiceAccountRoles 

func (_e *MockDatabase_Expecter) RemoveAllServiceAccountRoles(ctx interface{}, serviceAccountID interface{}) *MockDatabase_RemoveAllServiceAccountRoles_Call

RemoveAllServiceAccountRoles is a helper method to define mock.On call

  • ctx context.Context
  • serviceAccountID uuid.UUID

func (*MockDatabase_Expecter) RemoveApiKeysFromServiceAccount 

func (_e *MockDatabase_Expecter) RemoveApiKeysFromServiceAccount(ctx interface{}, serviceAccountID interface{}) *MockDatabase_RemoveApiKeysFromServiceAccount_Call

RemoveApiKeysFromServiceAccount is a helper method to define mock.On call

  • ctx context.Context
  • serviceAccountID uuid.UUID

func (*MockDatabase_Expecter) RemoveReconcilerOptOut 

func (_e *MockDatabase_Expecter) RemoveReconcilerOptOut(ctx interface{}, userID interface{}, teamSlug interface{}, reconcilerName interface{}) *MockDatabase_RemoveReconcilerOptOut_Call

RemoveReconcilerOptOut is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • teamSlug slug.Slug
  • reconcilerName string

func (*MockDatabase_Expecter) RemoveRepositoryAuthorization 

func (_e *MockDatabase_Expecter) RemoveRepositoryAuthorization(ctx interface{}, teamSlug interface{}, repoName interface{}, authorization interface{}) *MockDatabase_RemoveRepositoryAuthorization_Call

RemoveRepositoryAuthorization is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • repoName string
  • authorization gensql.RepositoryAuthorizationEnum

func (*MockDatabase_Expecter) RemoveUserFromTeam 

func (_e *MockDatabase_Expecter) RemoveUserFromTeam(ctx interface{}, userID interface{}, teamSlug interface{}) *MockDatabase_RemoveUserFromTeam_Call

RemoveUserFromTeam is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) ResetReconcilerConfig 

func (_e *MockDatabase_Expecter) ResetReconcilerConfig(ctx interface{}, reconcilerName interface{}) *MockDatabase_ResetReconcilerConfig_Call

ResetReconcilerConfig is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string

func (*MockDatabase_Expecter) ResourceUtilizationForApp 

func (_e *MockDatabase_Expecter) ResourceUtilizationForApp(ctx interface{}, arg interface{}) *MockDatabase_ResourceUtilizationForApp_Call

ResourceUtilizationForApp is a helper method to define mock.On call

  • ctx context.Context
  • arg gensql.ResourceUtilizationForAppParams

func (*MockDatabase_Expecter) ResourceUtilizationForTeam 

func (_e *MockDatabase_Expecter) ResourceUtilizationForTeam(ctx interface{}, environment interface{}, teamSlug interface{}, resourceType interface{}, start interface{}, end interface{}) *MockDatabase_ResourceUtilizationForTeam_Call

ResourceUtilizationForTeam is a helper method to define mock.On call

  • ctx context.Context
  • environment string
  • teamSlug slug.Slug
  • resourceType gensql.ResourceType
  • start pgtype.Timestamptz
  • end pgtype.Timestamptz

func (*MockDatabase_Expecter) ResourceUtilizationOverageForTeam 

func (_e *MockDatabase_Expecter) ResourceUtilizationOverageForTeam(ctx interface{}, teamSlug interface{}, timestamp interface{}, resourceType interface{}) *MockDatabase_ResourceUtilizationOverageForTeam_Call

ResourceUtilizationOverageForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • timestamp pgtype.Timestamptz
  • resourceType gensql.ResourceType

func (*MockDatabase_Expecter) ResourceUtilizationRangeForApp 

func (_e *MockDatabase_Expecter) ResourceUtilizationRangeForApp(ctx interface{}, environment interface{}, teamSlug interface{}, app interface{}) *MockDatabase_ResourceUtilizationRangeForApp_Call

ResourceUtilizationRangeForApp is a helper method to define mock.On call

  • ctx context.Context
  • environment string
  • teamSlug slug.Slug
  • app string

func (*MockDatabase_Expecter) ResourceUtilizationRangeForTeam 

func (_e *MockDatabase_Expecter) ResourceUtilizationRangeForTeam(ctx interface{}, teamSlug interface{}) *MockDatabase_ResourceUtilizationRangeForTeam_Call

ResourceUtilizationRangeForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) ResourceUtilizationRefresh 

func (_e *MockDatabase_Expecter) ResourceUtilizationRefresh(ctx interface{}) *MockDatabase_ResourceUtilizationRefresh_Call

ResourceUtilizationRefresh is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) ResourceUtilizationUpsert 

func (_e *MockDatabase_Expecter) ResourceUtilizationUpsert(ctx interface{}, arg interface{}) *MockDatabase_ResourceUtilizationUpsert_Call

ResourceUtilizationUpsert is a helper method to define mock.On call

  • ctx context.Context
  • arg []gensql.ResourceUtilizationUpsertParams

func (*MockDatabase_Expecter) RevokeGlobalUserRole 

func (_e *MockDatabase_Expecter) RevokeGlobalUserRole(ctx interface{}, userID interface{}, roleName interface{}) *MockDatabase_RevokeGlobalUserRole_Call

RevokeGlobalUserRole is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • roleName gensql.RoleName

func (*MockDatabase_Expecter) SetLastSuccessfulSyncForTeam 

func (_e *MockDatabase_Expecter) SetLastSuccessfulSyncForTeam(ctx interface{}, teamSlug interface{}) *MockDatabase_SetLastSuccessfulSyncForTeam_Call

SetLastSuccessfulSyncForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) SetReconcilerErrorForTeam 

func (_e *MockDatabase_Expecter) SetReconcilerErrorForTeam(ctx interface{}, correlationID interface{}, teamSlug interface{}, reconcilerName interface{}, err interface{}) *MockDatabase_SetReconcilerErrorForTeam_Call

SetReconcilerErrorForTeam is a helper method to define mock.On call

  • ctx context.Context
  • correlationID uuid.UUID
  • teamSlug slug.Slug
  • reconcilerName string
  • err error

func (*MockDatabase_Expecter) SetTeamMemberRole 

func (_e *MockDatabase_Expecter) SetTeamMemberRole(ctx interface{}, userID interface{}, teamSlug interface{}, roleName interface{}) *MockDatabase_SetTeamMemberRole_Call

SetTeamMemberRole is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • teamSlug slug.Slug
  • roleName gensql.RoleName

func (*MockDatabase_Expecter) SpecificResourceUtilizationForApp 

func (_e *MockDatabase_Expecter) SpecificResourceUtilizationForApp(ctx interface{}, environment interface{}, teamSlug interface{}, app interface{}, resourceType interface{}, timestamp interface{}) *MockDatabase_SpecificResourceUtilizationForApp_Call

SpecificResourceUtilizationForApp is a helper method to define mock.On call

  • ctx context.Context
  • environment string
  • teamSlug slug.Slug
  • app string
  • resourceType gensql.ResourceType
  • timestamp pgtype.Timestamptz

func (*MockDatabase_Expecter) SpecificResourceUtilizationForTeam 

func (_e *MockDatabase_Expecter) SpecificResourceUtilizationForTeam(ctx interface{}, teamSlug interface{}, resourceType interface{}, timestamp interface{}) *MockDatabase_SpecificResourceUtilizationForTeam_Call

SpecificResourceUtilizationForTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • resourceType gensql.ResourceType
  • timestamp pgtype.Timestamptz

func (*MockDatabase_Expecter) SyncEnvironments 

func (_e *MockDatabase_Expecter) SyncEnvironments(ctx interface{}, envs interface{}) *MockDatabase_SyncEnvironments_Call

SyncEnvironments is a helper method to define mock.On call

  • ctx context.Context
  • envs []*Environment

func (*MockDatabase_Expecter) SyncReconcilerConfig 

func (_e *MockDatabase_Expecter) SyncReconcilerConfig(ctx interface{}, reconcilerName interface{}, configs interface{}) *MockDatabase_SyncReconcilerConfig_Call

SyncReconcilerConfig is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string
  • configs []*protoapi.ReconcilerConfigSpec

func (*MockDatabase_Expecter) TeamExists 

func (_e *MockDatabase_Expecter) TeamExists(ctx interface{}, team interface{}) *MockDatabase_TeamExists_Call

TeamExists is a helper method to define mock.On call

  • ctx context.Context
  • team slug.Slug

func (*MockDatabase_Expecter) Transaction 

func (_e *MockDatabase_Expecter) Transaction(ctx interface{}, fn interface{}) *MockDatabase_Transaction_Call

Transaction is a helper method to define mock.On call

  • ctx context.Context
  • fn DatabaseTransactionFunc

func (*MockDatabase_Expecter) UpdateTeam 

func (_e *MockDatabase_Expecter) UpdateTeam(ctx interface{}, teamSlug interface{}, purpose interface{}, slackChannel interface{}) *MockDatabase_UpdateTeam_Call

UpdateTeam is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • purpose *string
  • slackChannel *string

func (*MockDatabase_Expecter) UpdateTeamExternalReferences 

func (_e *MockDatabase_Expecter) UpdateTeamExternalReferences(ctx interface{}, params interface{}) *MockDatabase_UpdateTeamExternalReferences_Call

UpdateTeamExternalReferences is a helper method to define mock.On call

  • ctx context.Context
  • params gensql.UpdateTeamExternalReferencesParams

func (*MockDatabase_Expecter) UpdateUser 

func (_e *MockDatabase_Expecter) UpdateUser(ctx interface{}, userID interface{}, name interface{}, email interface{}, externalID interface{}) *MockDatabase_UpdateUser_Call

UpdateUser is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • name string
  • email string
  • externalID string

func (*MockDatabase_Expecter) UpsertReconciler 

func (_e *MockDatabase_Expecter) UpsertReconciler(ctx interface{}, name interface{}, displayName interface{}, description interface{}, memberAware interface{}, enableIfNew interface{}) *MockDatabase_UpsertReconciler_Call

UpsertReconciler is a helper method to define mock.On call

  • ctx context.Context
  • name string
  • displayName string
  • description string
  • memberAware bool
  • enableIfNew bool

func (*MockDatabase_Expecter) UpsertReconcilerConfig 

func (_e *MockDatabase_Expecter) UpsertReconcilerConfig(ctx interface{}, reconciler interface{}, key interface{}, displayName interface{}, description interface{}, secret interface{}) *MockDatabase_UpsertReconcilerConfig_Call

UpsertReconcilerConfig is a helper method to define mock.On call

  • ctx context.Context
  • reconciler string
  • key string
  • displayName string
  • description string
  • secret bool

func (*MockDatabase_Expecter) UpsertReconcilerState 

func (_e *MockDatabase_Expecter) UpsertReconcilerState(ctx interface{}, reconcilerName interface{}, teamSlug interface{}, value interface{}) *MockDatabase_UpsertReconcilerState_Call

UpsertReconcilerState is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName string
  • teamSlug slug.Slug
  • value []byte

func (*MockDatabase_Expecter) UpsertTeamEnvironment 

func (_e *MockDatabase_Expecter) UpsertTeamEnvironment(ctx interface{}, teamSlug interface{}, environment interface{}, slackChannel interface{}, gcpProjectID interface{}) *MockDatabase_UpsertTeamEnvironment_Call

UpsertTeamEnvironment is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • environment string
  • slackChannel *string
  • gcpProjectID *string

func (*MockDatabase_Expecter) UserIsTeamOwner 

func (_e *MockDatabase_Expecter) UserIsTeamOwner(ctx interface{}, userID interface{}, teamSlug interface{}) *MockDatabase_UserIsTeamOwner_Call

UserIsTeamOwner is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • teamSlug slug.Slug

type MockDatabase_ExtendSession_Call 

type MockDatabase_ExtendSession_Call struct {
	*mock.Call
}

MockDatabase_ExtendSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExtendSession'

func (*MockDatabase_ExtendSession_Call) Return 

func (_c *MockDatabase_ExtendSession_Call) Return(_a0 *Session, _a1 error) *MockDatabase_ExtendSession_Call

func (*MockDatabase_ExtendSession_Call) Run 

func (_c *MockDatabase_ExtendSession_Call) Run(run func(ctx context.Context, sessionID uuid.UUID)) *MockDatabase_ExtendSession_Call

func (*MockDatabase_ExtendSession_Call) RunAndReturn 

func (_c *MockDatabase_ExtendSession_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*Session, error)) *MockDatabase_ExtendSession_Call

type MockDatabase_GetActiveTeamBySlug_Call 

type MockDatabase_GetActiveTeamBySlug_Call struct {
	*mock.Call
}

MockDatabase_GetActiveTeamBySlug_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActiveTeamBySlug'

func (*MockDatabase_GetActiveTeamBySlug_Call) Return 

func (_c *MockDatabase_GetActiveTeamBySlug_Call) Return(_a0 *Team, _a1 error) *MockDatabase_GetActiveTeamBySlug_Call

func (*MockDatabase_GetActiveTeamBySlug_Call) Run 

func (_c *MockDatabase_GetActiveTeamBySlug_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockDatabase_GetActiveTeamBySlug_Call

func (*MockDatabase_GetActiveTeamBySlug_Call) RunAndReturn 

func (_c *MockDatabase_GetActiveTeamBySlug_Call) RunAndReturn(run func(context.Context, slug.Slug) (*Team, error)) *MockDatabase_GetActiveTeamBySlug_Call

type MockDatabase_GetActiveTeams_Call 

type MockDatabase_GetActiveTeams_Call struct {
	*mock.Call
}

MockDatabase_GetActiveTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActiveTeams'

func (*MockDatabase_GetActiveTeams_Call) Return 

func (_c *MockDatabase_GetActiveTeams_Call) Return(_a0 []*Team, _a1 error) *MockDatabase_GetActiveTeams_Call

func (*MockDatabase_GetActiveTeams_Call) Run 

func (_c *MockDatabase_GetActiveTeams_Call) Run(run func(ctx context.Context)) *MockDatabase_GetActiveTeams_Call

func (*MockDatabase_GetActiveTeams_Call) RunAndReturn 

func (_c *MockDatabase_GetActiveTeams_Call) RunAndReturn(run func(context.Context) ([]*Team, error)) *MockDatabase_GetActiveTeams_Call

type MockDatabase_GetAllTeamMembers_Call 

type MockDatabase_GetAllTeamMembers_Call struct {
	*mock.Call
}

MockDatabase_GetAllTeamMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllTeamMembers'

func (*MockDatabase_GetAllTeamMembers_Call) Return 

func (_c *MockDatabase_GetAllTeamMembers_Call) Return(_a0 []*User, _a1 error) *MockDatabase_GetAllTeamMembers_Call

func (*MockDatabase_GetAllTeamMembers_Call) Run 

func (_c *MockDatabase_GetAllTeamMembers_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockDatabase_GetAllTeamMembers_Call

func (*MockDatabase_GetAllTeamMembers_Call) RunAndReturn 

func (_c *MockDatabase_GetAllTeamMembers_Call) RunAndReturn(run func(context.Context, slug.Slug) ([]*User, error)) *MockDatabase_GetAllTeamMembers_Call

type MockDatabase_GetAllTeamSlugs_Call 

type MockDatabase_GetAllTeamSlugs_Call struct {
	*mock.Call
}

MockDatabase_GetAllTeamSlugs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllTeamSlugs'

func (*MockDatabase_GetAllTeamSlugs_Call) Return 

func (_c *MockDatabase_GetAllTeamSlugs_Call) Return(_a0 []slug.Slug, _a1 error) *MockDatabase_GetAllTeamSlugs_Call

func (*MockDatabase_GetAllTeamSlugs_Call) Run 

func (_c *MockDatabase_GetAllTeamSlugs_Call) Run(run func(ctx context.Context)) *MockDatabase_GetAllTeamSlugs_Call

func (*MockDatabase_GetAllTeamSlugs_Call) RunAndReturn 

func (_c *MockDatabase_GetAllTeamSlugs_Call) RunAndReturn(run func(context.Context) ([]slug.Slug, error)) *MockDatabase_GetAllTeamSlugs_Call

type MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call 

type MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call struct {
	*mock.Call
}

MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllTeamsWithPermissionInGitHubRepo'

func (*MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call) Return 

func (_c *MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call) Return(_a0 []*Team, _a1 error) *MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call

func (*MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call) Run 

func (_c *MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call) Run(run func(ctx context.Context, repoName string, permission string)) *MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call

func (*MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call) RunAndReturn 

func (_c *MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call) RunAndReturn(run func(context.Context, string, string) ([]*Team, error)) *MockDatabase_GetAllTeamsWithPermissionInGitHubRepo_Call

type MockDatabase_GetAllUserRoles_Call 

type MockDatabase_GetAllUserRoles_Call struct {
	*mock.Call
}

MockDatabase_GetAllUserRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAllUserRoles'

func (*MockDatabase_GetAllUserRoles_Call) Return 

func (_c *MockDatabase_GetAllUserRoles_Call) Return(_a0 []*UserRole, _a1 error) *MockDatabase_GetAllUserRoles_Call

func (*MockDatabase_GetAllUserRoles_Call) Run 

func (_c *MockDatabase_GetAllUserRoles_Call) Run(run func(ctx context.Context)) *MockDatabase_GetAllUserRoles_Call

func (*MockDatabase_GetAllUserRoles_Call) RunAndReturn 

func (_c *MockDatabase_GetAllUserRoles_Call) RunAndReturn(run func(context.Context) ([]*UserRole, error)) *MockDatabase_GetAllUserRoles_Call

type MockDatabase_GetAuditLogsForCorrelationID_Call 

type MockDatabase_GetAuditLogsForCorrelationID_Call struct {
	*mock.Call
}

MockDatabase_GetAuditLogsForCorrelationID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForCorrelationID'

func (*MockDatabase_GetAuditLogsForCorrelationID_Call) Return 

func (_c *MockDatabase_GetAuditLogsForCorrelationID_Call) Return(_a0 []*AuditLog, _a1 int, _a2 error) *MockDatabase_GetAuditLogsForCorrelationID_Call

func (*MockDatabase_GetAuditLogsForCorrelationID_Call) Run 

func (_c *MockDatabase_GetAuditLogsForCorrelationID_Call) Run(run func(ctx context.Context, correlationID uuid.UUID, p Page)) *MockDatabase_GetAuditLogsForCorrelationID_Call

func (*MockDatabase_GetAuditLogsForCorrelationID_Call) RunAndReturn 

func (_c *MockDatabase_GetAuditLogsForCorrelationID_Call) RunAndReturn(run func(context.Context, uuid.UUID, Page) ([]*AuditLog, int, error)) *MockDatabase_GetAuditLogsForCorrelationID_Call

type MockDatabase_GetAuditLogsForReconciler_Call 

type MockDatabase_GetAuditLogsForReconciler_Call struct {
	*mock.Call
}

MockDatabase_GetAuditLogsForReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForReconciler'

func (*MockDatabase_GetAuditLogsForReconciler_Call) Return 

func (_c *MockDatabase_GetAuditLogsForReconciler_Call) Return(_a0 []*AuditLog, _a1 int, _a2 error) *MockDatabase_GetAuditLogsForReconciler_Call

func (*MockDatabase_GetAuditLogsForReconciler_Call) Run 

func (_c *MockDatabase_GetAuditLogsForReconciler_Call) Run(run func(ctx context.Context, reconcilerName string, p Page)) *MockDatabase_GetAuditLogsForReconciler_Call

func (*MockDatabase_GetAuditLogsForReconciler_Call) RunAndReturn 

func (_c *MockDatabase_GetAuditLogsForReconciler_Call) RunAndReturn(run func(context.Context, string, Page) ([]*AuditLog, int, error)) *MockDatabase_GetAuditLogsForReconciler_Call

type MockDatabase_GetAuditLogsForTeam_Call 

type MockDatabase_GetAuditLogsForTeam_Call struct {
	*mock.Call
}

MockDatabase_GetAuditLogsForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAuditLogsForTeam'

func (*MockDatabase_GetAuditLogsForTeam_Call) Return 

func (_c *MockDatabase_GetAuditLogsForTeam_Call) Return(_a0 []*AuditLog, _a1 int, _a2 error) *MockDatabase_GetAuditLogsForTeam_Call

func (*MockDatabase_GetAuditLogsForTeam_Call) Run 

func (_c *MockDatabase_GetAuditLogsForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, p Page)) *MockDatabase_GetAuditLogsForTeam_Call

func (*MockDatabase_GetAuditLogsForTeam_Call) RunAndReturn 

func (_c *MockDatabase_GetAuditLogsForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug, Page) ([]*AuditLog, int, error)) *MockDatabase_GetAuditLogsForTeam_Call

type MockDatabase_GetEnabledReconcilers_Call 

type MockDatabase_GetEnabledReconcilers_Call struct {
	*mock.Call
}

MockDatabase_GetEnabledReconcilers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEnabledReconcilers'

func (*MockDatabase_GetEnabledReconcilers_Call) Return 

func (_c *MockDatabase_GetEnabledReconcilers_Call) Return(_a0 []*Reconciler, _a1 error) *MockDatabase_GetEnabledReconcilers_Call

func (*MockDatabase_GetEnabledReconcilers_Call) Run 

func (_c *MockDatabase_GetEnabledReconcilers_Call) Run(run func(ctx context.Context)) *MockDatabase_GetEnabledReconcilers_Call

func (*MockDatabase_GetEnabledReconcilers_Call) RunAndReturn 

func (_c *MockDatabase_GetEnabledReconcilers_Call) RunAndReturn(run func(context.Context) ([]*Reconciler, error)) *MockDatabase_GetEnabledReconcilers_Call

type MockDatabase_GetReconcilerConfig_Call 

type MockDatabase_GetReconcilerConfig_Call struct {
	*mock.Call
}

MockDatabase_GetReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilerConfig'

func (*MockDatabase_GetReconcilerConfig_Call) Return 

func (_c *MockDatabase_GetReconcilerConfig_Call) Return(_a0 []*ReconcilerConfig, _a1 error) *MockDatabase_GetReconcilerConfig_Call

func (*MockDatabase_GetReconcilerConfig_Call) Run 

func (_c *MockDatabase_GetReconcilerConfig_Call) Run(run func(ctx context.Context, reconcilerName string, includeSecrets bool)) *MockDatabase_GetReconcilerConfig_Call

func (*MockDatabase_GetReconcilerConfig_Call) RunAndReturn 

func (_c *MockDatabase_GetReconcilerConfig_Call) RunAndReturn(run func(context.Context, string, bool) ([]*ReconcilerConfig, error)) *MockDatabase_GetReconcilerConfig_Call

type MockDatabase_GetReconcilerErrors_Call 

type MockDatabase_GetReconcilerErrors_Call struct {
	*mock.Call
}

MockDatabase_GetReconcilerErrors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilerErrors'

func (*MockDatabase_GetReconcilerErrors_Call) Return 

func (_c *MockDatabase_GetReconcilerErrors_Call) Return(_a0 []*ReconcilerError, _a1 int, _a2 error) *MockDatabase_GetReconcilerErrors_Call

func (*MockDatabase_GetReconcilerErrors_Call) Run 

func (_c *MockDatabase_GetReconcilerErrors_Call) Run(run func(ctx context.Context, reconcilerName string, p Page)) *MockDatabase_GetReconcilerErrors_Call

func (*MockDatabase_GetReconcilerErrors_Call) RunAndReturn 

func (_c *MockDatabase_GetReconcilerErrors_Call) RunAndReturn(run func(context.Context, string, Page) ([]*ReconcilerError, int, error)) *MockDatabase_GetReconcilerErrors_Call

type MockDatabase_GetReconcilerStateForTeam_Call 

type MockDatabase_GetReconcilerStateForTeam_Call struct {
	*mock.Call
}

MockDatabase_GetReconcilerStateForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilerStateForTeam'

func (*MockDatabase_GetReconcilerStateForTeam_Call) Return 

func (_c *MockDatabase_GetReconcilerStateForTeam_Call) Return(_a0 *ReconcilerState, _a1 error) *MockDatabase_GetReconcilerStateForTeam_Call

func (*MockDatabase_GetReconcilerStateForTeam_Call) Run 

func (_c *MockDatabase_GetReconcilerStateForTeam_Call) Run(run func(ctx context.Context, reconcilerName string, teamSlug slug.Slug)) *MockDatabase_GetReconcilerStateForTeam_Call

func (*MockDatabase_GetReconcilerStateForTeam_Call) RunAndReturn 

func (_c *MockDatabase_GetReconcilerStateForTeam_Call) RunAndReturn(run func(context.Context, string, slug.Slug) (*ReconcilerState, error)) *MockDatabase_GetReconcilerStateForTeam_Call

type MockDatabase_GetReconcilerState_Call 

type MockDatabase_GetReconcilerState_Call struct {
	*mock.Call
}

MockDatabase_GetReconcilerState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilerState'

func (*MockDatabase_GetReconcilerState_Call) Return 

func (_c *MockDatabase_GetReconcilerState_Call) Return(_a0 []*ReconcilerStateWithTeam, _a1 error) *MockDatabase_GetReconcilerState_Call

func (*MockDatabase_GetReconcilerState_Call) Run 

func (_c *MockDatabase_GetReconcilerState_Call) Run(run func(ctx context.Context, reconcilerName string)) *MockDatabase_GetReconcilerState_Call

func (*MockDatabase_GetReconcilerState_Call) RunAndReturn 

func (_c *MockDatabase_GetReconcilerState_Call) RunAndReturn(run func(context.Context, string) ([]*ReconcilerStateWithTeam, error)) *MockDatabase_GetReconcilerState_Call

type MockDatabase_GetReconciler_Call 

type MockDatabase_GetReconciler_Call struct {
	*mock.Call
}

MockDatabase_GetReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconciler'

func (*MockDatabase_GetReconciler_Call) Return 

func (_c *MockDatabase_GetReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockDatabase_GetReconciler_Call

func (*MockDatabase_GetReconciler_Call) Run 

func (_c *MockDatabase_GetReconciler_Call) Run(run func(ctx context.Context, reconcilerName string)) *MockDatabase_GetReconciler_Call

func (*MockDatabase_GetReconciler_Call) RunAndReturn 

func (_c *MockDatabase_GetReconciler_Call) RunAndReturn(run func(context.Context, string) (*Reconciler, error)) *MockDatabase_GetReconciler_Call

type MockDatabase_GetReconcilers_Call 

type MockDatabase_GetReconcilers_Call struct {
	*mock.Call
}

MockDatabase_GetReconcilers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReconcilers'

func (*MockDatabase_GetReconcilers_Call) Return 

func (_c *MockDatabase_GetReconcilers_Call) Return(_a0 []*Reconciler, _a1 int, _a2 error) *MockDatabase_GetReconcilers_Call

func (*MockDatabase_GetReconcilers_Call) Run 

func (_c *MockDatabase_GetReconcilers_Call) Run(run func(ctx context.Context, p Page)) *MockDatabase_GetReconcilers_Call

func (*MockDatabase_GetReconcilers_Call) RunAndReturn 

func (_c *MockDatabase_GetReconcilers_Call) RunAndReturn(run func(context.Context, Page) ([]*Reconciler, int, error)) *MockDatabase_GetReconcilers_Call

type MockDatabase_GetRepositoryAuthorizations_Call 

type MockDatabase_GetRepositoryAuthorizations_Call struct {
	*mock.Call
}

MockDatabase_GetRepositoryAuthorizations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRepositoryAuthorizations'

func (*MockDatabase_GetRepositoryAuthorizations_Call) Return 

func (_c *MockDatabase_GetRepositoryAuthorizations_Call) Return(_a0 []gensql.RepositoryAuthorizationEnum, _a1 error) *MockDatabase_GetRepositoryAuthorizations_Call

func (*MockDatabase_GetRepositoryAuthorizations_Call) Run 

func (_c *MockDatabase_GetRepositoryAuthorizations_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, repoName string)) *MockDatabase_GetRepositoryAuthorizations_Call

func (*MockDatabase_GetRepositoryAuthorizations_Call) RunAndReturn 

func (_c *MockDatabase_GetRepositoryAuthorizations_Call) RunAndReturn(run func(context.Context, slug.Slug, string) ([]gensql.RepositoryAuthorizationEnum, error)) *MockDatabase_GetRepositoryAuthorizations_Call

type MockDatabase_GetServiceAccountByApiKey_Call 

type MockDatabase_GetServiceAccountByApiKey_Call struct {
	*mock.Call
}

MockDatabase_GetServiceAccountByApiKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountByApiKey'

func (*MockDatabase_GetServiceAccountByApiKey_Call) Return 

func (_c *MockDatabase_GetServiceAccountByApiKey_Call) Return(_a0 *ServiceAccount, _a1 error) *MockDatabase_GetServiceAccountByApiKey_Call

func (*MockDatabase_GetServiceAccountByApiKey_Call) Run 

func (_c *MockDatabase_GetServiceAccountByApiKey_Call) Run(run func(ctx context.Context, apiKey string)) *MockDatabase_GetServiceAccountByApiKey_Call

func (*MockDatabase_GetServiceAccountByApiKey_Call) RunAndReturn 

func (_c *MockDatabase_GetServiceAccountByApiKey_Call) RunAndReturn(run func(context.Context, string) (*ServiceAccount, error)) *MockDatabase_GetServiceAccountByApiKey_Call

type MockDatabase_GetServiceAccountByName_Call 

type MockDatabase_GetServiceAccountByName_Call struct {
	*mock.Call
}

MockDatabase_GetServiceAccountByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountByName'

func (*MockDatabase_GetServiceAccountByName_Call) Return 

func (_c *MockDatabase_GetServiceAccountByName_Call) Return(_a0 *ServiceAccount, _a1 error) *MockDatabase_GetServiceAccountByName_Call

func (*MockDatabase_GetServiceAccountByName_Call) Run 

func (_c *MockDatabase_GetServiceAccountByName_Call) Run(run func(ctx context.Context, name string)) *MockDatabase_GetServiceAccountByName_Call

func (*MockDatabase_GetServiceAccountByName_Call) RunAndReturn 

func (_c *MockDatabase_GetServiceAccountByName_Call) RunAndReturn(run func(context.Context, string) (*ServiceAccount, error)) *MockDatabase_GetServiceAccountByName_Call

type MockDatabase_GetServiceAccountRoles_Call 

type MockDatabase_GetServiceAccountRoles_Call struct {
	*mock.Call
}

MockDatabase_GetServiceAccountRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountRoles'

func (*MockDatabase_GetServiceAccountRoles_Call) Return 

func (_c *MockDatabase_GetServiceAccountRoles_Call) Return(_a0 []*authz.Role, _a1 error) *MockDatabase_GetServiceAccountRoles_Call

func (*MockDatabase_GetServiceAccountRoles_Call) Run 

func (_c *MockDatabase_GetServiceAccountRoles_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID)) *MockDatabase_GetServiceAccountRoles_Call

func (*MockDatabase_GetServiceAccountRoles_Call) RunAndReturn 

func (_c *MockDatabase_GetServiceAccountRoles_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*authz.Role, error)) *MockDatabase_GetServiceAccountRoles_Call

type MockDatabase_GetServiceAccountsByIDs_Call 

type MockDatabase_GetServiceAccountsByIDs_Call struct {
	*mock.Call
}

MockDatabase_GetServiceAccountsByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccountsByIDs'

func (*MockDatabase_GetServiceAccountsByIDs_Call) Return 

func (_c *MockDatabase_GetServiceAccountsByIDs_Call) Return(_a0 []*ServiceAccount, _a1 error) *MockDatabase_GetServiceAccountsByIDs_Call

func (*MockDatabase_GetServiceAccountsByIDs_Call) Run 

func (_c *MockDatabase_GetServiceAccountsByIDs_Call) Run(run func(ctx context.Context, ids []uuid.UUID)) *MockDatabase_GetServiceAccountsByIDs_Call

func (*MockDatabase_GetServiceAccountsByIDs_Call) RunAndReturn 

func (_c *MockDatabase_GetServiceAccountsByIDs_Call) RunAndReturn(run func(context.Context, []uuid.UUID) ([]*ServiceAccount, error)) *MockDatabase_GetServiceAccountsByIDs_Call

type MockDatabase_GetServiceAccounts_Call 

type MockDatabase_GetServiceAccounts_Call struct {
	*mock.Call
}

MockDatabase_GetServiceAccounts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetServiceAccounts'

func (*MockDatabase_GetServiceAccounts_Call) Return 

func (_c *MockDatabase_GetServiceAccounts_Call) Return(_a0 []*ServiceAccount, _a1 error) *MockDatabase_GetServiceAccounts_Call

func (*MockDatabase_GetServiceAccounts_Call) Run 

func (_c *MockDatabase_GetServiceAccounts_Call) Run(run func(ctx context.Context)) *MockDatabase_GetServiceAccounts_Call

func (*MockDatabase_GetServiceAccounts_Call) RunAndReturn 

func (_c *MockDatabase_GetServiceAccounts_Call) RunAndReturn(run func(context.Context) ([]*ServiceAccount, error)) *MockDatabase_GetServiceAccounts_Call

type MockDatabase_GetSessionByID_Call 

type MockDatabase_GetSessionByID_Call struct {
	*mock.Call
}

MockDatabase_GetSessionByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSessionByID'

func (*MockDatabase_GetSessionByID_Call) Return 

func (_c *MockDatabase_GetSessionByID_Call) Return(_a0 *Session, _a1 error) *MockDatabase_GetSessionByID_Call

func (*MockDatabase_GetSessionByID_Call) Run 

func (_c *MockDatabase_GetSessionByID_Call) Run(run func(ctx context.Context, sessionID uuid.UUID)) *MockDatabase_GetSessionByID_Call

func (*MockDatabase_GetSessionByID_Call) RunAndReturn 

func (_c *MockDatabase_GetSessionByID_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*Session, error)) *MockDatabase_GetSessionByID_Call

type MockDatabase_GetTeamBySlug_Call 

type MockDatabase_GetTeamBySlug_Call struct {
	*mock.Call
}

MockDatabase_GetTeamBySlug_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamBySlug'

func (*MockDatabase_GetTeamBySlug_Call) Return 

func (_c *MockDatabase_GetTeamBySlug_Call) Return(_a0 *Team, _a1 error) *MockDatabase_GetTeamBySlug_Call

func (*MockDatabase_GetTeamBySlug_Call) Run 

func (_c *MockDatabase_GetTeamBySlug_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockDatabase_GetTeamBySlug_Call

func (*MockDatabase_GetTeamBySlug_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamBySlug_Call) RunAndReturn(run func(context.Context, slug.Slug) (*Team, error)) *MockDatabase_GetTeamBySlug_Call

type MockDatabase_GetTeamDeleteKey_Call 

type MockDatabase_GetTeamDeleteKey_Call struct {
	*mock.Call
}

MockDatabase_GetTeamDeleteKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamDeleteKey'

func (*MockDatabase_GetTeamDeleteKey_Call) Return 

func (_c *MockDatabase_GetTeamDeleteKey_Call) Return(_a0 *TeamDeleteKey, _a1 error) *MockDatabase_GetTeamDeleteKey_Call

func (*MockDatabase_GetTeamDeleteKey_Call) Run 

func (_c *MockDatabase_GetTeamDeleteKey_Call) Run(run func(ctx context.Context, key uuid.UUID)) *MockDatabase_GetTeamDeleteKey_Call

func (*MockDatabase_GetTeamDeleteKey_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamDeleteKey_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*TeamDeleteKey, error)) *MockDatabase_GetTeamDeleteKey_Call

type MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call 

type MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call struct {
	*mock.Call
}

MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamEnvironmentsBySlugsAndEnvNames'

func (*MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call) Return 

func (_c *MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call) Return(_a0 []*TeamEnvironment, _a1 error) *MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call

func (*MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call) Run 

func (_c *MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call) Run(run func(ctx context.Context, keys []EnvSlugName)) *MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call

func (*MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call) RunAndReturn(run func(context.Context, []EnvSlugName) ([]*TeamEnvironment, error)) *MockDatabase_GetTeamEnvironmentsBySlugsAndEnvNames_Call

type MockDatabase_GetTeamEnvironments_Call 

type MockDatabase_GetTeamEnvironments_Call struct {
	*mock.Call
}

MockDatabase_GetTeamEnvironments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamEnvironments'

func (*MockDatabase_GetTeamEnvironments_Call) Return 

func (_c *MockDatabase_GetTeamEnvironments_Call) Return(_a0 []*TeamEnvironment, _a1 int, _a2 error) *MockDatabase_GetTeamEnvironments_Call

func (*MockDatabase_GetTeamEnvironments_Call) Run 

func (_c *MockDatabase_GetTeamEnvironments_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, p Page)) *MockDatabase_GetTeamEnvironments_Call

func (*MockDatabase_GetTeamEnvironments_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamEnvironments_Call) RunAndReturn(run func(context.Context, slug.Slug, Page) ([]*TeamEnvironment, int, error)) *MockDatabase_GetTeamEnvironments_Call

type MockDatabase_GetTeamMemberOptOuts_Call 

type MockDatabase_GetTeamMemberOptOuts_Call struct {
	*mock.Call
}

MockDatabase_GetTeamMemberOptOuts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMemberOptOuts'

func (*MockDatabase_GetTeamMemberOptOuts_Call) Return 

func (_c *MockDatabase_GetTeamMemberOptOuts_Call) Return(_a0 []*gensql.GetTeamMemberOptOutsRow, _a1 error) *MockDatabase_GetTeamMemberOptOuts_Call

func (*MockDatabase_GetTeamMemberOptOuts_Call) Run 

func (_c *MockDatabase_GetTeamMemberOptOuts_Call) Run(run func(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug)) *MockDatabase_GetTeamMemberOptOuts_Call

func (*MockDatabase_GetTeamMemberOptOuts_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamMemberOptOuts_Call) RunAndReturn(run func(context.Context, uuid.UUID, slug.Slug) ([]*gensql.GetTeamMemberOptOutsRow, error)) *MockDatabase_GetTeamMemberOptOuts_Call

type MockDatabase_GetTeamMember_Call 

type MockDatabase_GetTeamMember_Call struct {
	*mock.Call
}

MockDatabase_GetTeamMember_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMember'

func (*MockDatabase_GetTeamMember_Call) Return 

func (_c *MockDatabase_GetTeamMember_Call) Return(_a0 *User, _a1 error) *MockDatabase_GetTeamMember_Call

func (*MockDatabase_GetTeamMember_Call) Run 

func (_c *MockDatabase_GetTeamMember_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, userID uuid.UUID)) *MockDatabase_GetTeamMember_Call

func (*MockDatabase_GetTeamMember_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamMember_Call) RunAndReturn(run func(context.Context, slug.Slug, uuid.UUID) (*User, error)) *MockDatabase_GetTeamMember_Call

type MockDatabase_GetTeamMembersForReconciler_Call 

type MockDatabase_GetTeamMembersForReconciler_Call struct {
	*mock.Call
}

MockDatabase_GetTeamMembersForReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMembersForReconciler'

func (*MockDatabase_GetTeamMembersForReconciler_Call) Return 

func (_c *MockDatabase_GetTeamMembersForReconciler_Call) Return(_a0 []*User, _a1 error) *MockDatabase_GetTeamMembersForReconciler_Call

func (*MockDatabase_GetTeamMembersForReconciler_Call) Run 

func (_c *MockDatabase_GetTeamMembersForReconciler_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, reconcilerName string)) *MockDatabase_GetTeamMembersForReconciler_Call

func (*MockDatabase_GetTeamMembersForReconciler_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamMembersForReconciler_Call) RunAndReturn(run func(context.Context, slug.Slug, string) ([]*User, error)) *MockDatabase_GetTeamMembersForReconciler_Call

type MockDatabase_GetTeamMembers_Call 

type MockDatabase_GetTeamMembers_Call struct {
	*mock.Call
}

MockDatabase_GetTeamMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamMembers'

func (*MockDatabase_GetTeamMembers_Call) Return 

func (_c *MockDatabase_GetTeamMembers_Call) Return(_a0 []*User, _a1 int, _a2 error) *MockDatabase_GetTeamMembers_Call

func (*MockDatabase_GetTeamMembers_Call) Run 

func (_c *MockDatabase_GetTeamMembers_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, p Page)) *MockDatabase_GetTeamMembers_Call

func (*MockDatabase_GetTeamMembers_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamMembers_Call) RunAndReturn(run func(context.Context, slug.Slug, Page) ([]*User, int, error)) *MockDatabase_GetTeamMembers_Call

type MockDatabase_GetTeamReconcilerErrors_Call 

type MockDatabase_GetTeamReconcilerErrors_Call struct {
	*mock.Call
}

MockDatabase_GetTeamReconcilerErrors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamReconcilerErrors'

func (*MockDatabase_GetTeamReconcilerErrors_Call) Return 

func (_c *MockDatabase_GetTeamReconcilerErrors_Call) Return(_a0 []*ReconcilerError, _a1 error) *MockDatabase_GetTeamReconcilerErrors_Call

func (*MockDatabase_GetTeamReconcilerErrors_Call) Run 

func (_c *MockDatabase_GetTeamReconcilerErrors_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockDatabase_GetTeamReconcilerErrors_Call

func (*MockDatabase_GetTeamReconcilerErrors_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamReconcilerErrors_Call) RunAndReturn(run func(context.Context, slug.Slug) ([]*ReconcilerError, error)) *MockDatabase_GetTeamReconcilerErrors_Call

type MockDatabase_GetTeamsBySlugs_Call 

type MockDatabase_GetTeamsBySlugs_Call struct {
	*mock.Call
}

MockDatabase_GetTeamsBySlugs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeamsBySlugs'

func (*MockDatabase_GetTeamsBySlugs_Call) Return 

func (_c *MockDatabase_GetTeamsBySlugs_Call) Return(_a0 []*Team, _a1 error) *MockDatabase_GetTeamsBySlugs_Call

func (*MockDatabase_GetTeamsBySlugs_Call) Run 

func (_c *MockDatabase_GetTeamsBySlugs_Call) Run(run func(ctx context.Context, teamSlugs []slug.Slug)) *MockDatabase_GetTeamsBySlugs_Call

func (*MockDatabase_GetTeamsBySlugs_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamsBySlugs_Call) RunAndReturn(run func(context.Context, []slug.Slug) ([]*Team, error)) *MockDatabase_GetTeamsBySlugs_Call

type MockDatabase_GetTeams_Call 

type MockDatabase_GetTeams_Call struct {
	*mock.Call
}

MockDatabase_GetTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTeams'

func (*MockDatabase_GetTeams_Call) Return 

func (_c *MockDatabase_GetTeams_Call) Return(_a0 []*Team, _a1 int, _a2 error) *MockDatabase_GetTeams_Call

func (*MockDatabase_GetTeams_Call) Run 

func (_c *MockDatabase_GetTeams_Call) Run(run func(ctx context.Context, p Page)) *MockDatabase_GetTeams_Call

func (*MockDatabase_GetTeams_Call) RunAndReturn 

func (_c *MockDatabase_GetTeams_Call) RunAndReturn(run func(context.Context, Page) ([]*Team, int, error)) *MockDatabase_GetTeams_Call

type MockDatabase_GetUserByEmail_Call 

type MockDatabase_GetUserByEmail_Call struct {
	*mock.Call
}

MockDatabase_GetUserByEmail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByEmail'

func (*MockDatabase_GetUserByEmail_Call) Return 

func (_c *MockDatabase_GetUserByEmail_Call) Return(_a0 *User, _a1 error) *MockDatabase_GetUserByEmail_Call

func (*MockDatabase_GetUserByEmail_Call) Run 

func (_c *MockDatabase_GetUserByEmail_Call) Run(run func(ctx context.Context, email string)) *MockDatabase_GetUserByEmail_Call

func (*MockDatabase_GetUserByEmail_Call) RunAndReturn 

func (_c *MockDatabase_GetUserByEmail_Call) RunAndReturn(run func(context.Context, string) (*User, error)) *MockDatabase_GetUserByEmail_Call

type MockDatabase_GetUserByExternalID_Call 

type MockDatabase_GetUserByExternalID_Call struct {
	*mock.Call
}

MockDatabase_GetUserByExternalID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByExternalID'

func (*MockDatabase_GetUserByExternalID_Call) Return 

func (_c *MockDatabase_GetUserByExternalID_Call) Return(_a0 *User, _a1 error) *MockDatabase_GetUserByExternalID_Call

func (*MockDatabase_GetUserByExternalID_Call) Run 

func (_c *MockDatabase_GetUserByExternalID_Call) Run(run func(ctx context.Context, externalID string)) *MockDatabase_GetUserByExternalID_Call

func (*MockDatabase_GetUserByExternalID_Call) RunAndReturn 

func (_c *MockDatabase_GetUserByExternalID_Call) RunAndReturn(run func(context.Context, string) (*User, error)) *MockDatabase_GetUserByExternalID_Call

type MockDatabase_GetUserByID_Call 

type MockDatabase_GetUserByID_Call struct {
	*mock.Call
}

MockDatabase_GetUserByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByID'

func (*MockDatabase_GetUserByID_Call) Return 

func (_c *MockDatabase_GetUserByID_Call) Return(_a0 *User, _a1 error) *MockDatabase_GetUserByID_Call

func (*MockDatabase_GetUserByID_Call) Run 

func (_c *MockDatabase_GetUserByID_Call) Run(run func(ctx context.Context, id uuid.UUID)) *MockDatabase_GetUserByID_Call

func (*MockDatabase_GetUserByID_Call) RunAndReturn 

func (_c *MockDatabase_GetUserByID_Call) RunAndReturn(run func(context.Context, uuid.UUID) (*User, error)) *MockDatabase_GetUserByID_Call

type MockDatabase_GetUserRolesForUsers_Call 

type MockDatabase_GetUserRolesForUsers_Call struct {
	*mock.Call
}

MockDatabase_GetUserRolesForUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserRolesForUsers'

func (*MockDatabase_GetUserRolesForUsers_Call) Return 

func (_c *MockDatabase_GetUserRolesForUsers_Call) Return(_a0 map[uuid.UUID][]*authz.Role, _a1 error) *MockDatabase_GetUserRolesForUsers_Call

func (*MockDatabase_GetUserRolesForUsers_Call) Run 

func (_c *MockDatabase_GetUserRolesForUsers_Call) Run(run func(ctx context.Context, userIDs []uuid.UUID)) *MockDatabase_GetUserRolesForUsers_Call

func (*MockDatabase_GetUserRolesForUsers_Call) RunAndReturn 

func (_c *MockDatabase_GetUserRolesForUsers_Call) RunAndReturn(run func(context.Context, []uuid.UUID) (map[uuid.UUID][]*authz.Role, error)) *MockDatabase_GetUserRolesForUsers_Call

type MockDatabase_GetUserRoles_Call 

type MockDatabase_GetUserRoles_Call struct {
	*mock.Call
}

MockDatabase_GetUserRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserRoles'

func (*MockDatabase_GetUserRoles_Call) Return 

func (_c *MockDatabase_GetUserRoles_Call) Return(_a0 []*authz.Role, _a1 error) *MockDatabase_GetUserRoles_Call

func (*MockDatabase_GetUserRoles_Call) Run 

func (_c *MockDatabase_GetUserRoles_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockDatabase_GetUserRoles_Call

func (*MockDatabase_GetUserRoles_Call) RunAndReturn 

func (_c *MockDatabase_GetUserRoles_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*authz.Role, error)) *MockDatabase_GetUserRoles_Call

type MockDatabase_GetUserTeamsPaginated_Call 

type MockDatabase_GetUserTeamsPaginated_Call struct {
	*mock.Call
}

MockDatabase_GetUserTeamsPaginated_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserTeamsPaginated'

func (*MockDatabase_GetUserTeamsPaginated_Call) Return 

func (_c *MockDatabase_GetUserTeamsPaginated_Call) Return(_a0 []*UserTeam, _a1 int, _a2 error) *MockDatabase_GetUserTeamsPaginated_Call

func (*MockDatabase_GetUserTeamsPaginated_Call) Run 

func (_c *MockDatabase_GetUserTeamsPaginated_Call) Run(run func(ctx context.Context, userID uuid.UUID, p Page)) *MockDatabase_GetUserTeamsPaginated_Call

func (*MockDatabase_GetUserTeamsPaginated_Call) RunAndReturn 

func (_c *MockDatabase_GetUserTeamsPaginated_Call) RunAndReturn(run func(context.Context, uuid.UUID, Page) ([]*UserTeam, int, error)) *MockDatabase_GetUserTeamsPaginated_Call

type MockDatabase_GetUserTeams_Call 

type MockDatabase_GetUserTeams_Call struct {
	*mock.Call
}

MockDatabase_GetUserTeams_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserTeams'

func (*MockDatabase_GetUserTeams_Call) Return 

func (_c *MockDatabase_GetUserTeams_Call) Return(_a0 []*UserTeam, _a1 error) *MockDatabase_GetUserTeams_Call

func (*MockDatabase_GetUserTeams_Call) Run 

func (_c *MockDatabase_GetUserTeams_Call) Run(run func(ctx context.Context, userID uuid.UUID)) *MockDatabase_GetUserTeams_Call

func (*MockDatabase_GetUserTeams_Call) RunAndReturn 

func (_c *MockDatabase_GetUserTeams_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*UserTeam, error)) *MockDatabase_GetUserTeams_Call

type MockDatabase_GetUsersByIDs_Call 

type MockDatabase_GetUsersByIDs_Call struct {
	*mock.Call
}

MockDatabase_GetUsersByIDs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersByIDs'

func (*MockDatabase_GetUsersByIDs_Call) Return 

func (_c *MockDatabase_GetUsersByIDs_Call) Return(_a0 []*User, _a1 error) *MockDatabase_GetUsersByIDs_Call

func (*MockDatabase_GetUsersByIDs_Call) Run 

func (_c *MockDatabase_GetUsersByIDs_Call) Run(run func(ctx context.Context, ids []uuid.UUID)) *MockDatabase_GetUsersByIDs_Call

func (*MockDatabase_GetUsersByIDs_Call) RunAndReturn 

func (_c *MockDatabase_GetUsersByIDs_Call) RunAndReturn(run func(context.Context, []uuid.UUID) ([]*User, error)) *MockDatabase_GetUsersByIDs_Call

type MockDatabase_GetUsersWithGloballyAssignedRole_Call 

type MockDatabase_GetUsersWithGloballyAssignedRole_Call struct {
	*mock.Call
}

MockDatabase_GetUsersWithGloballyAssignedRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersWithGloballyAssignedRole'

func (*MockDatabase_GetUsersWithGloballyAssignedRole_Call) Return 

func (_c *MockDatabase_GetUsersWithGloballyAssignedRole_Call) Return(_a0 []*User, _a1 error) *MockDatabase_GetUsersWithGloballyAssignedRole_Call

func (*MockDatabase_GetUsersWithGloballyAssignedRole_Call) Run 

func (_c *MockDatabase_GetUsersWithGloballyAssignedRole_Call) Run(run func(ctx context.Context, roleName gensql.RoleName)) *MockDatabase_GetUsersWithGloballyAssignedRole_Call

func (*MockDatabase_GetUsersWithGloballyAssignedRole_Call) RunAndReturn 

func (_c *MockDatabase_GetUsersWithGloballyAssignedRole_Call) RunAndReturn(run func(context.Context, gensql.RoleName) ([]*User, error)) *MockDatabase_GetUsersWithGloballyAssignedRole_Call

type MockDatabase_GetUsers_Call 

type MockDatabase_GetUsers_Call struct {
	*mock.Call
}

MockDatabase_GetUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsers'

func (*MockDatabase_GetUsers_Call) Return 

func (_c *MockDatabase_GetUsers_Call) Return(_a0 []*User, _a1 int, _a2 error) *MockDatabase_GetUsers_Call

func (*MockDatabase_GetUsers_Call) Run 

func (_c *MockDatabase_GetUsers_Call) Run(run func(ctx context.Context, p Page)) *MockDatabase_GetUsers_Call

func (*MockDatabase_GetUsers_Call) RunAndReturn 

func (_c *MockDatabase_GetUsers_Call) RunAndReturn(run func(context.Context, Page) ([]*User, int, error)) *MockDatabase_GetUsers_Call

type MockDatabase_GetUsersyncRuns_Call 

type MockDatabase_GetUsersyncRuns_Call struct {
	*mock.Call
}

MockDatabase_GetUsersyncRuns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsersyncRuns'

func (*MockDatabase_GetUsersyncRuns_Call) Return 

func (_c *MockDatabase_GetUsersyncRuns_Call) Return(_a0 []*UsersyncRun, _a1 int, _a2 error) *MockDatabase_GetUsersyncRuns_Call

func (*MockDatabase_GetUsersyncRuns_Call) Run 

func (_c *MockDatabase_GetUsersyncRuns_Call) Run(run func(ctx context.Context, p Page)) *MockDatabase_GetUsersyncRuns_Call

func (*MockDatabase_GetUsersyncRuns_Call) RunAndReturn 

func (_c *MockDatabase_GetUsersyncRuns_Call) RunAndReturn(run func(context.Context, Page) ([]*UsersyncRun, int, error)) *MockDatabase_GetUsersyncRuns_Call

type MockDatabase_InsertEnvironment_Call 

type MockDatabase_InsertEnvironment_Call struct {
	*mock.Call
}

MockDatabase_InsertEnvironment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InsertEnvironment'

func (*MockDatabase_InsertEnvironment_Call) Return 

func (_c *MockDatabase_InsertEnvironment_Call) Return(_a0 error) *MockDatabase_InsertEnvironment_Call

func (*MockDatabase_InsertEnvironment_Call) Run 

func (_c *MockDatabase_InsertEnvironment_Call) Run(run func(ctx context.Context, name string, gcp bool)) *MockDatabase_InsertEnvironment_Call

func (*MockDatabase_InsertEnvironment_Call) RunAndReturn 

func (_c *MockDatabase_InsertEnvironment_Call) RunAndReturn(run func(context.Context, string, bool) error) *MockDatabase_InsertEnvironment_Call

type MockDatabase_LastCostDate_Call 

type MockDatabase_LastCostDate_Call struct {
	*mock.Call
}

MockDatabase_LastCostDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastCostDate'

func (*MockDatabase_LastCostDate_Call) Return 

func (_c *MockDatabase_LastCostDate_Call) Return(_a0 pgtype.Date, _a1 error) *MockDatabase_LastCostDate_Call

func (*MockDatabase_LastCostDate_Call) Run 

func (_c *MockDatabase_LastCostDate_Call) Run(run func(ctx context.Context)) *MockDatabase_LastCostDate_Call

func (*MockDatabase_LastCostDate_Call) RunAndReturn 

func (_c *MockDatabase_LastCostDate_Call) RunAndReturn(run func(context.Context) (pgtype.Date, error)) *MockDatabase_LastCostDate_Call

type MockDatabase_ListRepositoriesByAuthorization_Call 

type MockDatabase_ListRepositoriesByAuthorization_Call struct {
	*mock.Call
}

MockDatabase_ListRepositoriesByAuthorization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRepositoriesByAuthorization'

func (*MockDatabase_ListRepositoriesByAuthorization_Call) Return 

func (_c *MockDatabase_ListRepositoriesByAuthorization_Call) Return(_a0 []string, _a1 error) *MockDatabase_ListRepositoriesByAuthorization_Call

func (*MockDatabase_ListRepositoriesByAuthorization_Call) Run 

func (_c *MockDatabase_ListRepositoriesByAuthorization_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, authorization gensql.RepositoryAuthorizationEnum)) *MockDatabase_ListRepositoriesByAuthorization_Call

func (*MockDatabase_ListRepositoriesByAuthorization_Call) RunAndReturn 

func (_c *MockDatabase_ListRepositoriesByAuthorization_Call) RunAndReturn(run func(context.Context, slug.Slug, gensql.RepositoryAuthorizationEnum) ([]string, error)) *MockDatabase_ListRepositoriesByAuthorization_Call

type MockDatabase_MaxResourceUtilizationDate_Call 

type MockDatabase_MaxResourceUtilizationDate_Call struct {
	*mock.Call
}

MockDatabase_MaxResourceUtilizationDate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MaxResourceUtilizationDate'

func (*MockDatabase_MaxResourceUtilizationDate_Call) Return 

func (_c *MockDatabase_MaxResourceUtilizationDate_Call) Return(_a0 pgtype.Timestamptz, _a1 error) *MockDatabase_MaxResourceUtilizationDate_Call

func (*MockDatabase_MaxResourceUtilizationDate_Call) Run 

func (_c *MockDatabase_MaxResourceUtilizationDate_Call) Run(run func(ctx context.Context)) *MockDatabase_MaxResourceUtilizationDate_Call

func (*MockDatabase_MaxResourceUtilizationDate_Call) RunAndReturn 

func (_c *MockDatabase_MaxResourceUtilizationDate_Call) RunAndReturn(run func(context.Context) (pgtype.Timestamptz, error)) *MockDatabase_MaxResourceUtilizationDate_Call

type MockDatabase_MonthlyCostForApp_Call 

type MockDatabase_MonthlyCostForApp_Call struct {
	*mock.Call
}

MockDatabase_MonthlyCostForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MonthlyCostForApp'

func (*MockDatabase_MonthlyCostForApp_Call) Return 

func (_c *MockDatabase_MonthlyCostForApp_Call) Return(_a0 []*gensql.MonthlyCostForAppRow, _a1 error) *MockDatabase_MonthlyCostForApp_Call

func (*MockDatabase_MonthlyCostForApp_Call) Run 

func (_c *MockDatabase_MonthlyCostForApp_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, app string, environment string)) *MockDatabase_MonthlyCostForApp_Call

func (*MockDatabase_MonthlyCostForApp_Call) RunAndReturn 

func (_c *MockDatabase_MonthlyCostForApp_Call) RunAndReturn(run func(context.Context, slug.Slug, string, string) ([]*gensql.MonthlyCostForAppRow, error)) *MockDatabase_MonthlyCostForApp_Call

type MockDatabase_MonthlyCostForTeam_Call 

type MockDatabase_MonthlyCostForTeam_Call struct {
	*mock.Call
}

MockDatabase_MonthlyCostForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MonthlyCostForTeam'

func (*MockDatabase_MonthlyCostForTeam_Call) Return 

func (_c *MockDatabase_MonthlyCostForTeam_Call) Return(_a0 []*gensql.CostMonthlyTeam, _a1 error) *MockDatabase_MonthlyCostForTeam_Call

func (*MockDatabase_MonthlyCostForTeam_Call) Run 

func (_c *MockDatabase_MonthlyCostForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockDatabase_MonthlyCostForTeam_Call

func (*MockDatabase_MonthlyCostForTeam_Call) RunAndReturn 

func (_c *MockDatabase_MonthlyCostForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) ([]*gensql.CostMonthlyTeam, error)) *MockDatabase_MonthlyCostForTeam_Call

type MockDatabase_RemoveAllServiceAccountRoles_Call 

type MockDatabase_RemoveAllServiceAccountRoles_Call struct {
	*mock.Call
}

MockDatabase_RemoveAllServiceAccountRoles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllServiceAccountRoles'

func (*MockDatabase_RemoveAllServiceAccountRoles_Call) Return 

func (_c *MockDatabase_RemoveAllServiceAccountRoles_Call) Return(_a0 error) *MockDatabase_RemoveAllServiceAccountRoles_Call

func (*MockDatabase_RemoveAllServiceAccountRoles_Call) Run 

func (_c *MockDatabase_RemoveAllServiceAccountRoles_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID)) *MockDatabase_RemoveAllServiceAccountRoles_Call

func (*MockDatabase_RemoveAllServiceAccountRoles_Call) RunAndReturn 

func (_c *MockDatabase_RemoveAllServiceAccountRoles_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockDatabase_RemoveAllServiceAccountRoles_Call

type MockDatabase_RemoveApiKeysFromServiceAccount_Call 

type MockDatabase_RemoveApiKeysFromServiceAccount_Call struct {
	*mock.Call
}

MockDatabase_RemoveApiKeysFromServiceAccount_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveApiKeysFromServiceAccount'

func (*MockDatabase_RemoveApiKeysFromServiceAccount_Call) Return 

func (_c *MockDatabase_RemoveApiKeysFromServiceAccount_Call) Return(_a0 error) *MockDatabase_RemoveApiKeysFromServiceAccount_Call

func (*MockDatabase_RemoveApiKeysFromServiceAccount_Call) Run 

func (_c *MockDatabase_RemoveApiKeysFromServiceAccount_Call) Run(run func(ctx context.Context, serviceAccountID uuid.UUID)) *MockDatabase_RemoveApiKeysFromServiceAccount_Call

func (*MockDatabase_RemoveApiKeysFromServiceAccount_Call) RunAndReturn 

func (_c *MockDatabase_RemoveApiKeysFromServiceAccount_Call) RunAndReturn(run func(context.Context, uuid.UUID) error) *MockDatabase_RemoveApiKeysFromServiceAccount_Call

type MockDatabase_RemoveReconcilerOptOut_Call 

type MockDatabase_RemoveReconcilerOptOut_Call struct {
	*mock.Call
}

MockDatabase_RemoveReconcilerOptOut_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveReconcilerOptOut'

func (*MockDatabase_RemoveReconcilerOptOut_Call) Return 

func (_c *MockDatabase_RemoveReconcilerOptOut_Call) Return(_a0 error) *MockDatabase_RemoveReconcilerOptOut_Call

func (*MockDatabase_RemoveReconcilerOptOut_Call) Run 

func (_c *MockDatabase_RemoveReconcilerOptOut_Call) Run(run func(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug, reconcilerName string)) *MockDatabase_RemoveReconcilerOptOut_Call

func (*MockDatabase_RemoveReconcilerOptOut_Call) RunAndReturn 

func (_c *MockDatabase_RemoveReconcilerOptOut_Call) RunAndReturn(run func(context.Context, uuid.UUID, slug.Slug, string) error) *MockDatabase_RemoveReconcilerOptOut_Call

type MockDatabase_RemoveRepositoryAuthorization_Call 

type MockDatabase_RemoveRepositoryAuthorization_Call struct {
	*mock.Call
}

MockDatabase_RemoveRepositoryAuthorization_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRepositoryAuthorization'

func (*MockDatabase_RemoveRepositoryAuthorization_Call) Return 

func (_c *MockDatabase_RemoveRepositoryAuthorization_Call) Return(_a0 error) *MockDatabase_RemoveRepositoryAuthorization_Call

func (*MockDatabase_RemoveRepositoryAuthorization_Call) Run 

func (_c *MockDatabase_RemoveRepositoryAuthorization_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, repoName string, authorization gensql.RepositoryAuthorizationEnum)) *MockDatabase_RemoveRepositoryAuthorization_Call

func (*MockDatabase_RemoveRepositoryAuthorization_Call) RunAndReturn 

func (_c *MockDatabase_RemoveRepositoryAuthorization_Call) RunAndReturn(run func(context.Context, slug.Slug, string, gensql.RepositoryAuthorizationEnum) error) *MockDatabase_RemoveRepositoryAuthorization_Call

type MockDatabase_RemoveUserFromTeam_Call 

type MockDatabase_RemoveUserFromTeam_Call struct {
	*mock.Call
}

MockDatabase_RemoveUserFromTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUserFromTeam'

func (*MockDatabase_RemoveUserFromTeam_Call) Return 

func (_c *MockDatabase_RemoveUserFromTeam_Call) Return(_a0 error) *MockDatabase_RemoveUserFromTeam_Call

func (*MockDatabase_RemoveUserFromTeam_Call) Run 

func (_c *MockDatabase_RemoveUserFromTeam_Call) Run(run func(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug)) *MockDatabase_RemoveUserFromTeam_Call

func (*MockDatabase_RemoveUserFromTeam_Call) RunAndReturn 

func (_c *MockDatabase_RemoveUserFromTeam_Call) RunAndReturn(run func(context.Context, uuid.UUID, slug.Slug) error) *MockDatabase_RemoveUserFromTeam_Call

type MockDatabase_ResetReconcilerConfig_Call 

type MockDatabase_ResetReconcilerConfig_Call struct {
	*mock.Call
}

MockDatabase_ResetReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResetReconcilerConfig'

func (*MockDatabase_ResetReconcilerConfig_Call) Return 

func (_c *MockDatabase_ResetReconcilerConfig_Call) Return(_a0 *Reconciler, _a1 error) *MockDatabase_ResetReconcilerConfig_Call

func (*MockDatabase_ResetReconcilerConfig_Call) Run 

func (_c *MockDatabase_ResetReconcilerConfig_Call) Run(run func(ctx context.Context, reconcilerName string)) *MockDatabase_ResetReconcilerConfig_Call

func (*MockDatabase_ResetReconcilerConfig_Call) RunAndReturn 

func (_c *MockDatabase_ResetReconcilerConfig_Call) RunAndReturn(run func(context.Context, string) (*Reconciler, error)) *MockDatabase_ResetReconcilerConfig_Call

type MockDatabase_ResourceUtilizationForApp_Call 

type MockDatabase_ResourceUtilizationForApp_Call struct {
	*mock.Call
}

MockDatabase_ResourceUtilizationForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationForApp'

func (*MockDatabase_ResourceUtilizationForApp_Call) Return 

func (_c *MockDatabase_ResourceUtilizationForApp_Call) Return(_a0 []*gensql.ResourceUtilizationMetric, _a1 error) *MockDatabase_ResourceUtilizationForApp_Call

func (*MockDatabase_ResourceUtilizationForApp_Call) Run 

func (_c *MockDatabase_ResourceUtilizationForApp_Call) Run(run func(ctx context.Context, arg gensql.ResourceUtilizationForAppParams)) *MockDatabase_ResourceUtilizationForApp_Call

func (*MockDatabase_ResourceUtilizationForApp_Call) RunAndReturn 

func (_c *MockDatabase_ResourceUtilizationForApp_Call) RunAndReturn(run func(context.Context, gensql.ResourceUtilizationForAppParams) ([]*gensql.ResourceUtilizationMetric, error)) *MockDatabase_ResourceUtilizationForApp_Call

type MockDatabase_ResourceUtilizationForTeam_Call 

type MockDatabase_ResourceUtilizationForTeam_Call struct {
	*mock.Call
}

MockDatabase_ResourceUtilizationForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationForTeam'

func (*MockDatabase_ResourceUtilizationForTeam_Call) Return 

func (_c *MockDatabase_ResourceUtilizationForTeam_Call) Return(_a0 []*gensql.ResourceUtilizationForTeamRow, _a1 error) *MockDatabase_ResourceUtilizationForTeam_Call

func (*MockDatabase_ResourceUtilizationForTeam_Call) Run 

func (_c *MockDatabase_ResourceUtilizationForTeam_Call) Run(run func(ctx context.Context, environment string, teamSlug slug.Slug, resourceType gensql.ResourceType, start pgtype.Timestamptz, end pgtype.Timestamptz)) *MockDatabase_ResourceUtilizationForTeam_Call

func (*MockDatabase_ResourceUtilizationForTeam_Call) RunAndReturn 

func (_c *MockDatabase_ResourceUtilizationForTeam_Call) RunAndReturn(run func(context.Context, string, slug.Slug, gensql.ResourceType, pgtype.Timestamptz, pgtype.Timestamptz) ([]*gensql.ResourceUtilizationForTeamRow, error)) *MockDatabase_ResourceUtilizationForTeam_Call

type MockDatabase_ResourceUtilizationOverageForTeam_Call 

type MockDatabase_ResourceUtilizationOverageForTeam_Call struct {
	*mock.Call
}

MockDatabase_ResourceUtilizationOverageForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationOverageForTeam'

func (*MockDatabase_ResourceUtilizationOverageForTeam_Call) Return 

func (_c *MockDatabase_ResourceUtilizationOverageForTeam_Call) Return(_a0 []*gensql.ResourceUtilizationOverageForTeamRow, _a1 error) *MockDatabase_ResourceUtilizationOverageForTeam_Call

func (*MockDatabase_ResourceUtilizationOverageForTeam_Call) Run 

func (_c *MockDatabase_ResourceUtilizationOverageForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, timestamp pgtype.Timestamptz, resourceType gensql.ResourceType)) *MockDatabase_ResourceUtilizationOverageForTeam_Call

func (*MockDatabase_ResourceUtilizationOverageForTeam_Call) RunAndReturn 

func (_c *MockDatabase_ResourceUtilizationOverageForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug, pgtype.Timestamptz, gensql.ResourceType) ([]*gensql.ResourceUtilizationOverageForTeamRow, error)) *MockDatabase_ResourceUtilizationOverageForTeam_Call

type MockDatabase_ResourceUtilizationRangeForApp_Call 

type MockDatabase_ResourceUtilizationRangeForApp_Call struct {
	*mock.Call
}

MockDatabase_ResourceUtilizationRangeForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationRangeForApp'

func (*MockDatabase_ResourceUtilizationRangeForApp_Call) Return 

func (_c *MockDatabase_ResourceUtilizationRangeForApp_Call) Return(_a0 *gensql.ResourceUtilizationRangeForAppRow, _a1 error) *MockDatabase_ResourceUtilizationRangeForApp_Call

func (*MockDatabase_ResourceUtilizationRangeForApp_Call) Run 

func (_c *MockDatabase_ResourceUtilizationRangeForApp_Call) Run(run func(ctx context.Context, environment string, teamSlug slug.Slug, app string)) *MockDatabase_ResourceUtilizationRangeForApp_Call

func (*MockDatabase_ResourceUtilizationRangeForApp_Call) RunAndReturn 

func (_c *MockDatabase_ResourceUtilizationRangeForApp_Call) RunAndReturn(run func(context.Context, string, slug.Slug, string) (*gensql.ResourceUtilizationRangeForAppRow, error)) *MockDatabase_ResourceUtilizationRangeForApp_Call

type MockDatabase_ResourceUtilizationRangeForTeam_Call 

type MockDatabase_ResourceUtilizationRangeForTeam_Call struct {
	*mock.Call
}

MockDatabase_ResourceUtilizationRangeForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationRangeForTeam'

func (*MockDatabase_ResourceUtilizationRangeForTeam_Call) Return 

func (_c *MockDatabase_ResourceUtilizationRangeForTeam_Call) Return(_a0 *gensql.ResourceUtilizationRangeForTeamRow, _a1 error) *MockDatabase_ResourceUtilizationRangeForTeam_Call

func (*MockDatabase_ResourceUtilizationRangeForTeam_Call) Run 

func (_c *MockDatabase_ResourceUtilizationRangeForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockDatabase_ResourceUtilizationRangeForTeam_Call

func (*MockDatabase_ResourceUtilizationRangeForTeam_Call) RunAndReturn 

func (_c *MockDatabase_ResourceUtilizationRangeForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) (*gensql.ResourceUtilizationRangeForTeamRow, error)) *MockDatabase_ResourceUtilizationRangeForTeam_Call

type MockDatabase_ResourceUtilizationRefresh_Call 

type MockDatabase_ResourceUtilizationRefresh_Call struct {
	*mock.Call
}

MockDatabase_ResourceUtilizationRefresh_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationRefresh'

func (*MockDatabase_ResourceUtilizationRefresh_Call) Return 

func (_c *MockDatabase_ResourceUtilizationRefresh_Call) Return(_a0 error) *MockDatabase_ResourceUtilizationRefresh_Call

func (*MockDatabase_ResourceUtilizationRefresh_Call) Run 

func (_c *MockDatabase_ResourceUtilizationRefresh_Call) Run(run func(ctx context.Context)) *MockDatabase_ResourceUtilizationRefresh_Call

func (*MockDatabase_ResourceUtilizationRefresh_Call) RunAndReturn 

func (_c *MockDatabase_ResourceUtilizationRefresh_Call) RunAndReturn(run func(context.Context) error) *MockDatabase_ResourceUtilizationRefresh_Call

type MockDatabase_ResourceUtilizationUpsert_Call 

type MockDatabase_ResourceUtilizationUpsert_Call struct {
	*mock.Call
}

MockDatabase_ResourceUtilizationUpsert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResourceUtilizationUpsert'

func (*MockDatabase_ResourceUtilizationUpsert_Call) Return 

func (_c *MockDatabase_ResourceUtilizationUpsert_Call) Return(_a0 *gensql.ResourceUtilizationUpsertBatchResults) *MockDatabase_ResourceUtilizationUpsert_Call

func (*MockDatabase_ResourceUtilizationUpsert_Call) Run 

func (_c *MockDatabase_ResourceUtilizationUpsert_Call) Run(run func(ctx context.Context, arg []gensql.ResourceUtilizationUpsertParams)) *MockDatabase_ResourceUtilizationUpsert_Call

func (*MockDatabase_ResourceUtilizationUpsert_Call) RunAndReturn 

func (_c *MockDatabase_ResourceUtilizationUpsert_Call) RunAndReturn(run func(context.Context, []gensql.ResourceUtilizationUpsertParams) *gensql.ResourceUtilizationUpsertBatchResults) *MockDatabase_ResourceUtilizationUpsert_Call

type MockDatabase_RevokeGlobalUserRole_Call 

type MockDatabase_RevokeGlobalUserRole_Call struct {
	*mock.Call
}

MockDatabase_RevokeGlobalUserRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RevokeGlobalUserRole'

func (*MockDatabase_RevokeGlobalUserRole_Call) Return 

func (_c *MockDatabase_RevokeGlobalUserRole_Call) Return(_a0 error) *MockDatabase_RevokeGlobalUserRole_Call

func (*MockDatabase_RevokeGlobalUserRole_Call) Run 

func (_c *MockDatabase_RevokeGlobalUserRole_Call) Run(run func(ctx context.Context, userID uuid.UUID, roleName gensql.RoleName)) *MockDatabase_RevokeGlobalUserRole_Call

func (*MockDatabase_RevokeGlobalUserRole_Call) RunAndReturn 

func (_c *MockDatabase_RevokeGlobalUserRole_Call) RunAndReturn(run func(context.Context, uuid.UUID, gensql.RoleName) error) *MockDatabase_RevokeGlobalUserRole_Call

type MockDatabase_SetLastSuccessfulSyncForTeam_Call 

type MockDatabase_SetLastSuccessfulSyncForTeam_Call struct {
	*mock.Call
}

MockDatabase_SetLastSuccessfulSyncForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetLastSuccessfulSyncForTeam'

func (*MockDatabase_SetLastSuccessfulSyncForTeam_Call) Return 

func (_c *MockDatabase_SetLastSuccessfulSyncForTeam_Call) Return(_a0 error) *MockDatabase_SetLastSuccessfulSyncForTeam_Call

func (*MockDatabase_SetLastSuccessfulSyncForTeam_Call) Run 

func (_c *MockDatabase_SetLastSuccessfulSyncForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug)) *MockDatabase_SetLastSuccessfulSyncForTeam_Call

func (*MockDatabase_SetLastSuccessfulSyncForTeam_Call) RunAndReturn 

func (_c *MockDatabase_SetLastSuccessfulSyncForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) error) *MockDatabase_SetLastSuccessfulSyncForTeam_Call

type MockDatabase_SetReconcilerErrorForTeam_Call 

type MockDatabase_SetReconcilerErrorForTeam_Call struct {
	*mock.Call
}

MockDatabase_SetReconcilerErrorForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetReconcilerErrorForTeam'

func (*MockDatabase_SetReconcilerErrorForTeam_Call) Return 

func (_c *MockDatabase_SetReconcilerErrorForTeam_Call) Return(_a0 error) *MockDatabase_SetReconcilerErrorForTeam_Call

func (*MockDatabase_SetReconcilerErrorForTeam_Call) Run 

func (_c *MockDatabase_SetReconcilerErrorForTeam_Call) Run(run func(ctx context.Context, correlationID uuid.UUID, teamSlug slug.Slug, reconcilerName string, err error)) *MockDatabase_SetReconcilerErrorForTeam_Call

func (*MockDatabase_SetReconcilerErrorForTeam_Call) RunAndReturn 

func (_c *MockDatabase_SetReconcilerErrorForTeam_Call) RunAndReturn(run func(context.Context, uuid.UUID, slug.Slug, string, error) error) *MockDatabase_SetReconcilerErrorForTeam_Call

type MockDatabase_SetTeamMemberRole_Call 

type MockDatabase_SetTeamMemberRole_Call struct {
	*mock.Call
}

MockDatabase_SetTeamMemberRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTeamMemberRole'

func (*MockDatabase_SetTeamMemberRole_Call) Return 

func (_c *MockDatabase_SetTeamMemberRole_Call) Return(_a0 error) *MockDatabase_SetTeamMemberRole_Call

func (*MockDatabase_SetTeamMemberRole_Call) Run 

func (_c *MockDatabase_SetTeamMemberRole_Call) Run(run func(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug, roleName gensql.RoleName)) *MockDatabase_SetTeamMemberRole_Call

func (*MockDatabase_SetTeamMemberRole_Call) RunAndReturn 

func (_c *MockDatabase_SetTeamMemberRole_Call) RunAndReturn(run func(context.Context, uuid.UUID, slug.Slug, gensql.RoleName) error) *MockDatabase_SetTeamMemberRole_Call

type MockDatabase_SpecificResourceUtilizationForApp_Call 

type MockDatabase_SpecificResourceUtilizationForApp_Call struct {
	*mock.Call
}

MockDatabase_SpecificResourceUtilizationForApp_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpecificResourceUtilizationForApp'

func (*MockDatabase_SpecificResourceUtilizationForApp_Call) Return 

func (_c *MockDatabase_SpecificResourceUtilizationForApp_Call) Return(_a0 *gensql.SpecificResourceUtilizationForAppRow, _a1 error) *MockDatabase_SpecificResourceUtilizationForApp_Call

func (*MockDatabase_SpecificResourceUtilizationForApp_Call) Run 

func (_c *MockDatabase_SpecificResourceUtilizationForApp_Call) Run(run func(ctx context.Context, environment string, teamSlug slug.Slug, app string, resourceType gensql.ResourceType, timestamp pgtype.Timestamptz)) *MockDatabase_SpecificResourceUtilizationForApp_Call

func (*MockDatabase_SpecificResourceUtilizationForApp_Call) RunAndReturn 

func (_c *MockDatabase_SpecificResourceUtilizationForApp_Call) RunAndReturn(run func(context.Context, string, slug.Slug, string, gensql.ResourceType, pgtype.Timestamptz) (*gensql.SpecificResourceUtilizationForAppRow, error)) *MockDatabase_SpecificResourceUtilizationForApp_Call

type MockDatabase_SpecificResourceUtilizationForTeam_Call 

type MockDatabase_SpecificResourceUtilizationForTeam_Call struct {
	*mock.Call
}

MockDatabase_SpecificResourceUtilizationForTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SpecificResourceUtilizationForTeam'

func (*MockDatabase_SpecificResourceUtilizationForTeam_Call) Return 

func (_c *MockDatabase_SpecificResourceUtilizationForTeam_Call) Return(_a0 []*gensql.SpecificResourceUtilizationForTeamRow, _a1 error) *MockDatabase_SpecificResourceUtilizationForTeam_Call

func (*MockDatabase_SpecificResourceUtilizationForTeam_Call) Run 

func (_c *MockDatabase_SpecificResourceUtilizationForTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, resourceType gensql.ResourceType, timestamp pgtype.Timestamptz)) *MockDatabase_SpecificResourceUtilizationForTeam_Call

func (*MockDatabase_SpecificResourceUtilizationForTeam_Call) RunAndReturn 

func (_c *MockDatabase_SpecificResourceUtilizationForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug, gensql.ResourceType, pgtype.Timestamptz) ([]*gensql.SpecificResourceUtilizationForTeamRow, error)) *MockDatabase_SpecificResourceUtilizationForTeam_Call

type MockDatabase_SyncEnvironments_Call 

type MockDatabase_SyncEnvironments_Call struct {
	*mock.Call
}

MockDatabase_SyncEnvironments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SyncEnvironments'

func (*MockDatabase_SyncEnvironments_Call) Return 

func (_c *MockDatabase_SyncEnvironments_Call) Return(_a0 error) *MockDatabase_SyncEnvironments_Call

func (*MockDatabase_SyncEnvironments_Call) Run 

func (_c *MockDatabase_SyncEnvironments_Call) Run(run func(ctx context.Context, envs []*Environment)) *MockDatabase_SyncEnvironments_Call

func (*MockDatabase_SyncEnvironments_Call) RunAndReturn 

func (_c *MockDatabase_SyncEnvironments_Call) RunAndReturn(run func(context.Context, []*Environment) error) *MockDatabase_SyncEnvironments_Call

type MockDatabase_SyncReconcilerConfig_Call 

type MockDatabase_SyncReconcilerConfig_Call struct {
	*mock.Call
}

MockDatabase_SyncReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SyncReconcilerConfig'

func (*MockDatabase_SyncReconcilerConfig_Call) Return 

func (_c *MockDatabase_SyncReconcilerConfig_Call) Return(_a0 error) *MockDatabase_SyncReconcilerConfig_Call

func (*MockDatabase_SyncReconcilerConfig_Call) Run 

func (_c *MockDatabase_SyncReconcilerConfig_Call) Run(run func(ctx context.Context, reconcilerName string, configs []*protoapi.ReconcilerConfigSpec)) *MockDatabase_SyncReconcilerConfig_Call

func (*MockDatabase_SyncReconcilerConfig_Call) RunAndReturn 

func (_c *MockDatabase_SyncReconcilerConfig_Call) RunAndReturn(run func(context.Context, string, []*protoapi.ReconcilerConfigSpec) error) *MockDatabase_SyncReconcilerConfig_Call

type MockDatabase_TeamExists_Call 

type MockDatabase_TeamExists_Call struct {
	*mock.Call
}

MockDatabase_TeamExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TeamExists'

func (*MockDatabase_TeamExists_Call) Return 

func (_c *MockDatabase_TeamExists_Call) Return(_a0 bool, _a1 error) *MockDatabase_TeamExists_Call

func (*MockDatabase_TeamExists_Call) Run 

func (_c *MockDatabase_TeamExists_Call) Run(run func(ctx context.Context, team slug.Slug)) *MockDatabase_TeamExists_Call

func (*MockDatabase_TeamExists_Call) RunAndReturn 

func (_c *MockDatabase_TeamExists_Call) RunAndReturn(run func(context.Context, slug.Slug) (bool, error)) *MockDatabase_TeamExists_Call

type MockDatabase_Transaction_Call 

type MockDatabase_Transaction_Call struct {
	*mock.Call
}

MockDatabase_Transaction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Transaction'

func (*MockDatabase_Transaction_Call) Return 

func (_c *MockDatabase_Transaction_Call) Return(_a0 error) *MockDatabase_Transaction_Call

func (*MockDatabase_Transaction_Call) Run 

func (_c *MockDatabase_Transaction_Call) Run(run func(ctx context.Context, fn DatabaseTransactionFunc)) *MockDatabase_Transaction_Call

func (*MockDatabase_Transaction_Call) RunAndReturn 

func (_c *MockDatabase_Transaction_Call) RunAndReturn(run func(context.Context, DatabaseTransactionFunc) error) *MockDatabase_Transaction_Call

type MockDatabase_UpdateTeamExternalReferences_Call 

type MockDatabase_UpdateTeamExternalReferences_Call struct {
	*mock.Call
}

MockDatabase_UpdateTeamExternalReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeamExternalReferences'

func (*MockDatabase_UpdateTeamExternalReferences_Call) Return 

func (_c *MockDatabase_UpdateTeamExternalReferences_Call) Return(_a0 *Team, _a1 error) *MockDatabase_UpdateTeamExternalReferences_Call

func (*MockDatabase_UpdateTeamExternalReferences_Call) Run 

func (_c *MockDatabase_UpdateTeamExternalReferences_Call) Run(run func(ctx context.Context, params gensql.UpdateTeamExternalReferencesParams)) *MockDatabase_UpdateTeamExternalReferences_Call

func (*MockDatabase_UpdateTeamExternalReferences_Call) RunAndReturn 

func (_c *MockDatabase_UpdateTeamExternalReferences_Call) RunAndReturn(run func(context.Context, gensql.UpdateTeamExternalReferencesParams) (*Team, error)) *MockDatabase_UpdateTeamExternalReferences_Call

type MockDatabase_UpdateTeam_Call 

type MockDatabase_UpdateTeam_Call struct {
	*mock.Call
}

MockDatabase_UpdateTeam_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTeam'

func (*MockDatabase_UpdateTeam_Call) Return 

func (_c *MockDatabase_UpdateTeam_Call) Return(_a0 *Team, _a1 error) *MockDatabase_UpdateTeam_Call

func (*MockDatabase_UpdateTeam_Call) Run 

func (_c *MockDatabase_UpdateTeam_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, purpose *string, slackChannel *string)) *MockDatabase_UpdateTeam_Call

func (*MockDatabase_UpdateTeam_Call) RunAndReturn 

func (_c *MockDatabase_UpdateTeam_Call) RunAndReturn(run func(context.Context, slug.Slug, *string, *string) (*Team, error)) *MockDatabase_UpdateTeam_Call

type MockDatabase_UpdateUser_Call 

type MockDatabase_UpdateUser_Call struct {
	*mock.Call
}

MockDatabase_UpdateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUser'

func (*MockDatabase_UpdateUser_Call) Return 

func (_c *MockDatabase_UpdateUser_Call) Return(_a0 *User, _a1 error) *MockDatabase_UpdateUser_Call

func (*MockDatabase_UpdateUser_Call) Run 

func (_c *MockDatabase_UpdateUser_Call) Run(run func(ctx context.Context, userID uuid.UUID, name string, email string, externalID string)) *MockDatabase_UpdateUser_Call

func (*MockDatabase_UpdateUser_Call) RunAndReturn 

func (_c *MockDatabase_UpdateUser_Call) RunAndReturn(run func(context.Context, uuid.UUID, string, string, string) (*User, error)) *MockDatabase_UpdateUser_Call

type MockDatabase_UpsertReconcilerConfig_Call 

type MockDatabase_UpsertReconcilerConfig_Call struct {
	*mock.Call
}

MockDatabase_UpsertReconcilerConfig_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertReconcilerConfig'

func (*MockDatabase_UpsertReconcilerConfig_Call) Return 

func (_c *MockDatabase_UpsertReconcilerConfig_Call) Return(_a0 error) *MockDatabase_UpsertReconcilerConfig_Call

func (*MockDatabase_UpsertReconcilerConfig_Call) Run 

func (_c *MockDatabase_UpsertReconcilerConfig_Call) Run(run func(ctx context.Context, reconciler string, key string, displayName string, description string, secret bool)) *MockDatabase_UpsertReconcilerConfig_Call

func (*MockDatabase_UpsertReconcilerConfig_Call) RunAndReturn 

func (_c *MockDatabase_UpsertReconcilerConfig_Call) RunAndReturn(run func(context.Context, string, string, string, string, bool) error) *MockDatabase_UpsertReconcilerConfig_Call

type MockDatabase_UpsertReconcilerState_Call 

type MockDatabase_UpsertReconcilerState_Call struct {
	*mock.Call
}

MockDatabase_UpsertReconcilerState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertReconcilerState'

func (*MockDatabase_UpsertReconcilerState_Call) Return 

func (_c *MockDatabase_UpsertReconcilerState_Call) Return(_a0 *ReconcilerState, _a1 error) *MockDatabase_UpsertReconcilerState_Call

func (*MockDatabase_UpsertReconcilerState_Call) Run 

func (_c *MockDatabase_UpsertReconcilerState_Call) Run(run func(ctx context.Context, reconcilerName string, teamSlug slug.Slug, value []byte)) *MockDatabase_UpsertReconcilerState_Call

func (*MockDatabase_UpsertReconcilerState_Call) RunAndReturn 

func (_c *MockDatabase_UpsertReconcilerState_Call) RunAndReturn(run func(context.Context, string, slug.Slug, []byte) (*ReconcilerState, error)) *MockDatabase_UpsertReconcilerState_Call

type MockDatabase_UpsertReconciler_Call 

type MockDatabase_UpsertReconciler_Call struct {
	*mock.Call
}

MockDatabase_UpsertReconciler_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertReconciler'

func (*MockDatabase_UpsertReconciler_Call) Return 

func (_c *MockDatabase_UpsertReconciler_Call) Return(_a0 *Reconciler, _a1 error) *MockDatabase_UpsertReconciler_Call

func (*MockDatabase_UpsertReconciler_Call) Run 

func (_c *MockDatabase_UpsertReconciler_Call) Run(run func(ctx context.Context, name string, displayName string, description string, memberAware bool, enableIfNew bool)) *MockDatabase_UpsertReconciler_Call

func (*MockDatabase_UpsertReconciler_Call) RunAndReturn 

func (_c *MockDatabase_UpsertReconciler_Call) RunAndReturn(run func(context.Context, string, string, string, bool, bool) (*Reconciler, error)) *MockDatabase_UpsertReconciler_Call

type MockDatabase_UpsertTeamEnvironment_Call 

type MockDatabase_UpsertTeamEnvironment_Call struct {
	*mock.Call
}

MockDatabase_UpsertTeamEnvironment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertTeamEnvironment'

func (*MockDatabase_UpsertTeamEnvironment_Call) Return 

func (_c *MockDatabase_UpsertTeamEnvironment_Call) Return(_a0 error) *MockDatabase_UpsertTeamEnvironment_Call

func (*MockDatabase_UpsertTeamEnvironment_Call) Run 

func (_c *MockDatabase_UpsertTeamEnvironment_Call) Run(run func(ctx context.Context, teamSlug slug.Slug, environment string, slackChannel *string, gcpProjectID *string)) *MockDatabase_UpsertTeamEnvironment_Call

func (*MockDatabase_UpsertTeamEnvironment_Call) RunAndReturn 

func (_c *MockDatabase_UpsertTeamEnvironment_Call) RunAndReturn(run func(context.Context, slug.Slug, string, *string, *string) error) *MockDatabase_UpsertTeamEnvironment_Call

type MockDatabase_UserIsTeamOwner_Call 

type MockDatabase_UserIsTeamOwner_Call struct {
	*mock.Call
}

MockDatabase_UserIsTeamOwner_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UserIsTeamOwner'

func (*MockDatabase_UserIsTeamOwner_Call) Return 

func (_c *MockDatabase_UserIsTeamOwner_Call) Return(_a0 bool, _a1 error) *MockDatabase_UserIsTeamOwner_Call

func (*MockDatabase_UserIsTeamOwner_Call) Run 

func (_c *MockDatabase_UserIsTeamOwner_Call) Run(run func(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug)) *MockDatabase_UserIsTeamOwner_Call

func (*MockDatabase_UserIsTeamOwner_Call) RunAndReturn 

func (_c *MockDatabase_UserIsTeamOwner_Call) RunAndReturn(run func(context.Context, uuid.UUID, slug.Slug) (bool, error)) *MockDatabase_UserIsTeamOwner_Call

type Page 

type Page struct {
	Limit  int
	Offset int
}

type Querier 

type Querier interface {
	gensql.Querier
	Transaction(ctx context.Context, callback QuerierTransactionFunc) error
}

type QuerierTransactionFunc 

type QuerierTransactionFunc func(ctx context.Context, querier Querier) error

type Queries 

type Queries struct {
	*gensql.Queries
	// contains filtered or unexported fields
}

func (*Queries) Transaction 

func (q *Queries) Transaction(ctx context.Context, callback QuerierTransactionFunc) error

type Reconciler 

type Reconciler struct {
	*gensql.Reconciler
}

type ReconcilerConfig 

type ReconcilerConfig struct {
	*gensql.GetReconcilerConfigRow
}

type ReconcilerError 

type ReconcilerError struct {
	*gensql.ReconcilerError
}

type ReconcilerErrorRepo 

type ReconcilerErrorRepo interface {
	ClearReconcilerErrorsForTeam(ctx context.Context, teamSlug slug.Slug, reconcilerName string) error
	GetTeamReconcilerErrors(ctx context.Context, teamSlug slug.Slug) ([]*ReconcilerError, error)
	SetReconcilerErrorForTeam(ctx context.Context, correlationID uuid.UUID, teamSlug slug.Slug, reconcilerName string, err error) error
	GetReconcilerErrors(ctx context.Context, reconcilerName string, p Page) ([]*ReconcilerError, int, error)
}

type ReconcilerRepo 

type ReconcilerRepo interface {
	AddReconcilerOptOut(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug, reconcilerName string) error
	ConfigureReconciler(ctx context.Context, reconcilerName string, key string, value string) error
	DeleteReconcilerConfig(ctx context.Context, reconcilerName string, keysToDelete []string) error
	DisableReconciler(ctx context.Context, reconcilerName string) (*Reconciler, error)
	EnableReconciler(ctx context.Context, reconcilerName string) (*Reconciler, error)
	GetEnabledReconcilers(ctx context.Context) ([]*Reconciler, error)
	GetReconciler(ctx context.Context, reconcilerName string) (*Reconciler, error)
	GetReconcilerConfig(ctx context.Context, reconcilerName string, includeSecrets bool) ([]*ReconcilerConfig, error)
	GetReconcilers(ctx context.Context, p Page) ([]*Reconciler, int, error)
	RemoveReconcilerOptOut(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug, reconcilerName string) error
	ResetReconcilerConfig(ctx context.Context, reconcilerName string) (*Reconciler, error)
	SyncReconcilerConfig(ctx context.Context, reconcilerName string, configs []*protoapi.ReconcilerConfigSpec) error
	UpsertReconciler(ctx context.Context, name, displayName, description string, memberAware, enableIfNew bool) (*Reconciler, error)
	UpsertReconcilerConfig(ctx context.Context, reconciler, key, displayName, description string, secret bool) error
}

type ReconcilerState 

type ReconcilerState struct {
	*gensql.ReconcilerState
}

type ReconcilerStateRepo 

type ReconcilerStateRepo interface {
	GetReconcilerState(ctx context.Context, reconcilerName string) ([]*ReconcilerStateWithTeam, error)
	GetReconcilerStateForTeam(ctx context.Context, reconcilerName string, teamSlug slug.Slug) (*ReconcilerState, error)
	UpsertReconcilerState(ctx context.Context, reconcilerName string, teamSlug slug.Slug, value []byte) (*ReconcilerState, error)
	DeleteReconcilerStateForTeam(ctx context.Context, reconcilerName string, teamSlug slug.Slug) error
}

type ReconcilerStateWithTeam 

type ReconcilerStateWithTeam struct {
	*Team
	*gensql.ReconcilerState
}

type RepositoryAuthorizationRepo 

type RepositoryAuthorizationRepo interface {
	CreateRepositoryAuthorization(ctx context.Context, teamSlug slug.Slug, repoName string, authorization gensql.RepositoryAuthorizationEnum) error
	GetRepositoryAuthorizations(ctx context.Context, teamSlug slug.Slug, repoName string) ([]gensql.RepositoryAuthorizationEnum, error)
	RemoveRepositoryAuthorization(ctx context.Context, teamSlug slug.Slug, repoName string, authorization gensql.RepositoryAuthorizationEnum) error
	ListRepositoriesByAuthorization(ctx context.Context, teamSlug slug.Slug, authorization gensql.RepositoryAuthorizationEnum) ([]string, error)
}

type ResourceUtilizationRepo 

type ResourceUtilizationRepo interface {
	AverageResourceUtilizationForTeam(ctx context.Context, teamSlug slug.Slug, resourceType gensql.ResourceType, timestamp pgtype.Timestamptz) (*gensql.AverageResourceUtilizationForTeamRow, error)
	MaxResourceUtilizationDate(ctx context.Context) (pgtype.Timestamptz, error)
	ResourceUtilizationForApp(ctx context.Context, arg gensql.ResourceUtilizationForAppParams) ([]*gensql.ResourceUtilizationMetric, error)
	ResourceUtilizationForTeam(ctx context.Context, environment string, teamSlug slug.Slug, resourceType gensql.ResourceType, start pgtype.Timestamptz, end pgtype.Timestamptz) ([]*gensql.ResourceUtilizationForTeamRow, error)
	ResourceUtilizationOverageForTeam(ctx context.Context, teamSlug slug.Slug, timestamp pgtype.Timestamptz, resourceType gensql.ResourceType) ([]*gensql.ResourceUtilizationOverageForTeamRow, error)
	ResourceUtilizationRangeForApp(ctx context.Context, environment string, teamSlug slug.Slug, app string) (*gensql.ResourceUtilizationRangeForAppRow, error)
	ResourceUtilizationRangeForTeam(ctx context.Context, teamSlug slug.Slug) (*gensql.ResourceUtilizationRangeForTeamRow, error)
	ResourceUtilizationRefresh(ctx context.Context) error
	ResourceUtilizationUpsert(ctx context.Context, arg []gensql.ResourceUtilizationUpsertParams) *gensql.ResourceUtilizationUpsertBatchResults
	SpecificResourceUtilizationForApp(ctx context.Context, environment string, teamSlug slug.Slug, app string, resourceType gensql.ResourceType, timestamp pgtype.Timestamptz) (*gensql.SpecificResourceUtilizationForAppRow, error)
	SpecificResourceUtilizationForTeam(ctx context.Context, teamSlug slug.Slug, resourceType gensql.ResourceType, timestamp pgtype.Timestamptz) ([]*gensql.SpecificResourceUtilizationForTeamRow, error)
}

type RoleRepo 

type RoleRepo interface {
	AssignGlobalRoleToServiceAccount(ctx context.Context, serviceAccountID uuid.UUID, roleName gensql.RoleName) error
	AssignGlobalRoleToUser(ctx context.Context, userID uuid.UUID, roleName gensql.RoleName) error
	AssignTeamRoleToServiceAccount(ctx context.Context, serviceAccountID uuid.UUID, roleName gensql.RoleName, teamSlug slug.Slug) error
	GetAllUserRoles(ctx context.Context) ([]*UserRole, error)
	GetUserRolesForUsers(ctx context.Context, userIDs []uuid.UUID) (map[uuid.UUID][]*authz.Role, error)
	GetUsersWithGloballyAssignedRole(ctx context.Context, roleName gensql.RoleName) ([]*User, error)
	RevokeGlobalUserRole(ctx context.Context, userID uuid.UUID, roleName gensql.RoleName) error
	SetTeamMemberRole(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug, roleName gensql.RoleName) error
	UserIsTeamOwner(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug) (bool, error)
}

type ServiceAccount 

type ServiceAccount struct {
	*gensql.ServiceAccount
}

func (ServiceAccount) GetID 

func (s ServiceAccount) GetID() uuid.UUID

func (ServiceAccount) Identity 

func (s ServiceAccount) Identity() string

func (ServiceAccount) IsServiceAccount 

func (s ServiceAccount) IsServiceAccount() bool

type ServiceAccountRepo 

type ServiceAccountRepo interface {
	CreateAPIKey(ctx context.Context, apiKey string, serviceAccountID uuid.UUID) error
	CreateServiceAccount(ctx context.Context, name string) (*ServiceAccount, error)
	DeleteServiceAccount(ctx context.Context, serviceAccountID uuid.UUID) error
	GetServiceAccountByApiKey(ctx context.Context, apiKey string) (*ServiceAccount, error)
	GetServiceAccountByName(ctx context.Context, name string) (*ServiceAccount, error)
	GetServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) ([]*authz.Role, error)
	GetServiceAccounts(ctx context.Context) ([]*ServiceAccount, error)
	GetServiceAccountsByIDs(ctx context.Context, ids []uuid.UUID) ([]*ServiceAccount, error)
	RemoveAllServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) error
	RemoveApiKeysFromServiceAccount(ctx context.Context, serviceAccountID uuid.UUID) error
}

type Session 

type Session struct {
	*gensql.Session
}

type SessionRepo 

type SessionRepo interface {
	CreateSession(ctx context.Context, userID uuid.UUID) (*Session, error)
	DeleteSession(ctx context.Context, sessionID uuid.UUID) error
	ExtendSession(ctx context.Context, sessionID uuid.UUID) (*Session, error)
	GetSessionByID(ctx context.Context, sessionID uuid.UUID) (*Session, error)
}

type Team 

type Team struct {
	*gensql.Team
}

type TeamDeleteKey 

type TeamDeleteKey struct {
	*gensql.TeamDeleteKey
}

func (TeamDeleteKey) Expires 

func (k TeamDeleteKey) Expires() time.Time

func (TeamDeleteKey) HasExpired 

func (k TeamDeleteKey) HasExpired() bool

type TeamEnvironment 

type TeamEnvironment struct {
	*gensql.TeamAllEnvironment
}

type TeamRepo 

type TeamRepo interface {
	ConfirmTeamDeleteKey(ctx context.Context, key uuid.UUID) error
	CreateTeam(ctx context.Context, teamSlug slug.Slug, purpose, slackChannel string) (*Team, error)
	CreateTeamDeleteKey(ctx context.Context, teamSlug slug.Slug, userID uuid.UUID) (*TeamDeleteKey, error)
	DeleteTeam(ctx context.Context, teamSlug slug.Slug) error
	GetActiveTeamBySlug(ctx context.Context, teamSlug slug.Slug) (*Team, error)
	GetActiveTeams(ctx context.Context) ([]*Team, error)
	GetAllTeamMembers(ctx context.Context, teamSlug slug.Slug) ([]*User, error)
	GetAllTeamSlugs(ctx context.Context) ([]slug.Slug, error)
	GetTeamBySlug(ctx context.Context, teamSlug slug.Slug) (*Team, error)
	GetTeamDeleteKey(ctx context.Context, key uuid.UUID) (*TeamDeleteKey, error)
	GetTeamEnvironments(ctx context.Context, teamSlug slug.Slug, p Page) ([]*TeamEnvironment, int, error)
	GetTeamEnvironmentsBySlugsAndEnvNames(ctx context.Context, keys []EnvSlugName) ([]*TeamEnvironment, error)
	GetTeamMember(ctx context.Context, teamSlug slug.Slug, userID uuid.UUID) (*User, error)
	GetTeamMemberOptOuts(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug) ([]*gensql.GetTeamMemberOptOutsRow, error)
	GetTeamMembers(ctx context.Context, teamSlug slug.Slug, p Page) ([]*User, int, error)
	GetTeamMembersForReconciler(ctx context.Context, teamSlug slug.Slug, reconcilerName string) ([]*User, error)
	GetTeams(ctx context.Context, p Page) ([]*Team, int, error)
	GetTeamsBySlugs(ctx context.Context, teamSlugs []slug.Slug) ([]*Team, error)
	GetAllTeamsWithPermissionInGitHubRepo(ctx context.Context, repoName, permission string) ([]*Team, error)
	GetUserTeams(ctx context.Context, userID uuid.UUID) ([]*UserTeam, error)
	GetUserTeamsPaginated(ctx context.Context, userID uuid.UUID, p Page) ([]*UserTeam, int, error)
	RemoveUserFromTeam(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug) error
	SetLastSuccessfulSyncForTeam(ctx context.Context, teamSlug slug.Slug) error
	TeamExists(ctx context.Context, team slug.Slug) (bool, error)
	UpdateTeam(ctx context.Context, teamSlug slug.Slug, purpose, slackChannel *string) (*Team, error)
	UpdateTeamExternalReferences(ctx context.Context, params gensql.UpdateTeamExternalReferencesParams) (*Team, error)
	UpsertTeamEnvironment(ctx context.Context, teamSlug slug.Slug, environment string, slackChannel, gcpProjectID *string) error
}

type Transactioner 

type Transactioner interface {
	Transaction(ctx context.Context, fn DatabaseTransactionFunc) error
}

type User 

type User struct {
	*gensql.User
	IsAdmin *bool
}

func (User) GetID 

func (u User) GetID() uuid.UUID

func (User) Identity 

func (u User) Identity() string

func (User) IsServiceAccount 

func (u User) IsServiceAccount() bool

type UserRepo 

type UserRepo interface {
	CreateUser(ctx context.Context, name, email, externalID string) (*User, error)
	DeleteUser(ctx context.Context, userID uuid.UUID) error
	GetUserByEmail(ctx context.Context, email string) (*User, error)
	GetUserByExternalID(ctx context.Context, externalID string) (*User, error)
	GetUserByID(ctx context.Context, id uuid.UUID) (*User, error)
	GetUserRoles(ctx context.Context, userID uuid.UUID) ([]*authz.Role, error)
	GetUsers(ctx context.Context, p Page) ([]*User, int, error)
	GetUsersByIDs(ctx context.Context, ids []uuid.UUID) ([]*User, error)
	UpdateUser(ctx context.Context, userID uuid.UUID, name, email, externalID string) (*User, error)
}

type UserRole 

type UserRole struct {
	*gensql.UserRole
}

type UserTeam 

type UserTeam struct {
	*gensql.Team
	RoleName gensql.RoleName
}

type UsersyncRepo 

type UsersyncRepo interface {
	CreateUsersyncRun(ctx context.Context, id uuid.UUID, startedAt, finishedAt time.Time, err error) error
	GetUsersyncRuns(ctx context.Context, p Page) ([]*UsersyncRun, int, error)
}

type UsersyncRun 

type UsersyncRun struct {
	*gensql.UsersyncRun
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.