db

package
v0.0.0-...-96f7096 Latest Latest
Warning

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

 Go to latest Published: Jan 26, 2024 License: MIT Imports: 20 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func MarshalUUID 

func MarshalUUID(uid *uuid.UUID) graphql.Marshaler

func UnmarshalUUID 

func UnmarshalUUID(v interface{}) (*uuid.UUID, error)

Types

type AuditLog 

type AuditLog struct {
	*sqlc.AuditLog
}

type AuthenticatedUser 

type AuthenticatedUser interface {
	GetID() uuid.UUID
	Identity() string
	IsServiceAccount() bool
}

type Database 

type Database interface {
	CreateRepositoryAuthorization(ctx context.Context, teamSlug slug.Slug, repoName string, authorization sqlc.RepositoryAuthorizationEnum) error
	RemoveRepositoryAuthorization(ctx context.Context, teamSlug slug.Slug, repoName string, authorization sqlc.RepositoryAuthorizationEnum) error
	CreateAuditLogEntry(ctx context.Context, correlationID uuid.UUID, componentName types.ComponentName, actor *string, targetType types.AuditLogsTargetType, targetIdentifier string, action types.AuditAction, message string) error
	CreateUser(ctx context.Context, name, email, externalID string) (*User, error)
	CreateServiceAccount(ctx context.Context, name string) (*ServiceAccount, error)
	GetServiceAccountByName(ctx context.Context, name string) (*ServiceAccount, error)
	GetUserByID(ctx context.Context, ID uuid.UUID) (*User, error)
	GetUserByEmail(ctx context.Context, email string) (*User, error)
	GetServiceAccountByApiKey(ctx context.Context, APIKey string) (*ServiceAccount, error)
	DeleteUser(ctx context.Context, userID uuid.UUID) error
	GetUsers(ctx context.Context) ([]*User, error)
	GetUserTeams(ctx context.Context, userID uuid.UUID) ([]*Team, error)
	CreateTeam(ctx context.Context, slug slug.Slug, purpose, slackChannel string) (*Team, error)
	UpdateTeam(ctx context.Context, teamSlug slug.Slug, purpose, slackChannel *string) (*Team, error)
	GetActiveTeamBySlug(ctx context.Context, slug slug.Slug) (*Team, error)
	GetTeamBySlug(ctx context.Context, slug slug.Slug) (*Team, error)
	GetActiveTeams(ctx context.Context) ([]*Team, error)
	GetTeams(ctx context.Context) ([]*Team, error)
	GetTeamMembers(ctx context.Context, teamSlug slug.Slug) ([]*User, error)
	GetTeamMember(ctx context.Context, teamSlug slug.Slug, userID uuid.UUID) (*User, error)
	UserIsTeamOwner(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug) (bool, error)
	SetTeamMemberRole(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug, role sqlc.RoleName) error
	GetAuditLogsForTeam(ctx context.Context, slug slug.Slug) ([]*AuditLog, error)
	AssignGlobalRoleToUser(ctx context.Context, userID uuid.UUID, roleName sqlc.RoleName) error
	AssignGlobalRoleToServiceAccount(ctx context.Context, serviceAccountID uuid.UUID, roleName sqlc.RoleName) error
	AssignTeamRoleToServiceAccount(ctx context.Context, serviceAccountID uuid.UUID, roleName sqlc.RoleName, teamSlug slug.Slug) error
	RemoveUserFromTeam(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug) error
	CreateAPIKey(ctx context.Context, apiKey string, serviceAccountID uuid.UUID) error
	RemoveAllServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) error
	RemoveApiKeysFromServiceAccount(ctx context.Context, serviceAccountID uuid.UUID) error
	GetUserRoles(ctx context.Context, userID uuid.UUID) ([]*Role, error)
	GetAllUserRoles(ctx context.Context) ([]*UserRole, error)
	GetServiceAccountRoles(ctx context.Context, serviceAccountID uuid.UUID) ([]*Role, error)
	Transaction(ctx context.Context, fn DatabaseTransactionFunc) error
	LoadReconcilerStateForTeam(ctx context.Context, reconcilerName sqlc.ReconcilerName, slug slug.Slug, state interface{}) error
	SetReconcilerStateForTeam(ctx context.Context, reconcilerName sqlc.ReconcilerName, slug slug.Slug, state interface{}) error
	RemoveReconcilerStateForTeam(ctx context.Context, reconcilerName sqlc.ReconcilerName, slug slug.Slug) error
	UpdateUser(ctx context.Context, userID uuid.UUID, name, email, externalID string) (*User, error)
	SetReconcilerErrorForTeam(ctx context.Context, correlationID uuid.UUID, slug slug.Slug, reconcilerName sqlc.ReconcilerName, err error) error
	GetTeamReconcilerErrors(ctx context.Context, slug slug.Slug) ([]*ReconcilerError, error)
	ClearReconcilerErrorsForTeam(ctx context.Context, slug slug.Slug, reconcilerName sqlc.ReconcilerName) error
	GetServiceAccounts(ctx context.Context) ([]*ServiceAccount, error)
	DeleteServiceAccount(ctx context.Context, serviceAccountID uuid.UUID) error
	GetUserByExternalID(ctx context.Context, externalID string) (*User, error)
	CreateSession(ctx context.Context, userID uuid.UUID) (*Session, error)
	DeleteSession(ctx context.Context, sessionID uuid.UUID) error
	GetSessionByID(ctx context.Context, sessionID uuid.UUID) (*Session, error)
	ExtendSession(ctx context.Context, sessionID uuid.UUID) (*Session, error)
	GetReconciler(ctx context.Context, reconcilerName sqlc.ReconcilerName) (*Reconciler, error)
	GetReconcilers(ctx context.Context) ([]*Reconciler, error)
	GetEnabledReconcilers(ctx context.Context) ([]*Reconciler, error)
	ConfigureReconciler(ctx context.Context, reconcilerName sqlc.ReconcilerName, key sqlc.ReconcilerConfigKey, value string) error
	GetReconcilerConfig(ctx context.Context, reconcilerName sqlc.ReconcilerName) ([]*ReconcilerConfig, error)
	ResetReconcilerConfig(ctx context.Context, reconcilerName sqlc.ReconcilerName) (*Reconciler, error)
	EnableReconciler(ctx context.Context, reconcilerName sqlc.ReconcilerName) (*Reconciler, error)
	DisableReconciler(ctx context.Context, reconcilerName sqlc.ReconcilerName) (*Reconciler, error)
	DangerousGetReconcilerConfigValues(ctx context.Context, reconcilerName sqlc.ReconcilerName) (*ReconcilerConfigValues, error)
	GetAuditLogsForReconciler(ctx context.Context, reconcilerName sqlc.ReconcilerName) ([]*AuditLog, error)
	SetLastSuccessfulSyncForTeam(ctx context.Context, teamSlug slug.Slug) error
	RevokeGlobalUserRole(ctx context.Context, userID uuid.UUID, roleName sqlc.RoleName) error
	GetUsersWithGloballyAssignedRole(ctx context.Context, roleName sqlc.RoleName) ([]*User, error)
	IsFirstRun(ctx context.Context) (bool, error)
	FirstRunComplete(ctx context.Context) error
	GetSlackAlertsChannels(ctx context.Context, teamSlug slug.Slug) (map[string]string, error)
	SetSlackAlertsChannel(ctx context.Context, teamSlug slug.Slug, environment, channelName string) error
	RemoveSlackAlertsChannel(ctx context.Context, teamSlug slug.Slug, environment string) error
	CreateTeamDeleteKey(ctx context.Context, teamSlug slug.Slug, userID uuid.UUID) (*TeamDeleteKey, error)
	GetTeamDeleteKey(ctx context.Context, key uuid.UUID) (*TeamDeleteKey, error)
	ConfirmTeamDeleteKey(ctx context.Context, key uuid.UUID) error
	DeleteTeam(ctx context.Context, teamSlug slug.Slug) error
	GetAuditLogsForCorrelationID(ctx context.Context, correlationID uuid.UUID) ([]*AuditLog, error)
	AddReconcilerOptOut(ctx context.Context, userID *uuid.UUID, teamSlug *slug.Slug, reconcilerName sqlc.ReconcilerName) error
	RemoveReconcilerOptOut(ctx context.Context, userID *uuid.UUID, teamSlug *slug.Slug, reconcilerName sqlc.ReconcilerName) error
	GetTeamMembersForReconciler(ctx context.Context, teamSlug slug.Slug, reconcilerName sqlc.ReconcilerName) ([]*User, error)
	GetTeamMemberOptOuts(ctx context.Context, userID uuid.UUID, teamSlug slug.Slug) ([]*sqlc.GetTeamMemberOptOutsRow, error)
	GetTeamsWithPermissionInGitHubRepo(ctx context.Context, repoName, permission string) ([]*Team, error)
	GetRepositoryAuthorizations(ctx context.Context, teamSlug slug.Slug, repo string) ([]sqlc.RepositoryAuthorizationEnum, error)
}

func New 

func New(ctx context.Context, dbUrl string) (Database, error)

type DatabaseTransactionFunc 

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

type MockAuthenticatedUser 

type MockAuthenticatedUser struct {
	mock.Mock
}

MockAuthenticatedUser is an autogenerated mock type for the AuthenticatedUser type

func NewMockAuthenticatedUser 

func NewMockAuthenticatedUser(t interface {
	mock.TestingT
	Cleanup(func())
},
) *MockAuthenticatedUser

NewMockAuthenticatedUser creates a new instance of MockAuthenticatedUser. 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 (*MockAuthenticatedUser) EXPECT 

func (_m *MockAuthenticatedUser) EXPECT() *MockAuthenticatedUser_Expecter

func (*MockAuthenticatedUser) GetID 

func (_m *MockAuthenticatedUser) GetID() uuid.UUID

GetID provides a mock function with given fields:

func (*MockAuthenticatedUser) Identity 

func (_m *MockAuthenticatedUser) Identity() string

Identity provides a mock function with given fields:

func (*MockAuthenticatedUser) IsServiceAccount 

func (_m *MockAuthenticatedUser) IsServiceAccount() bool

IsServiceAccount provides a mock function with given fields:

type MockAuthenticatedUser_Expecter 

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

func (*MockAuthenticatedUser_Expecter) GetID 

func (_e *MockAuthenticatedUser_Expecter) GetID() *MockAuthenticatedUser_GetID_Call

GetID is a helper method to define mock.On call

func (*MockAuthenticatedUser_Expecter) Identity 

func (_e *MockAuthenticatedUser_Expecter) Identity() *MockAuthenticatedUser_Identity_Call

Identity is a helper method to define mock.On call

func (*MockAuthenticatedUser_Expecter) IsServiceAccount 

func (_e *MockAuthenticatedUser_Expecter) IsServiceAccount() *MockAuthenticatedUser_IsServiceAccount_Call

IsServiceAccount is a helper method to define mock.On call

type MockAuthenticatedUser_GetID_Call 

type MockAuthenticatedUser_GetID_Call struct {
	*mock.Call
}

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

func (*MockAuthenticatedUser_GetID_Call) Return 

func (_c *MockAuthenticatedUser_GetID_Call) Return(_a0 uuid.UUID) *MockAuthenticatedUser_GetID_Call

func (*MockAuthenticatedUser_GetID_Call) Run 

func (_c *MockAuthenticatedUser_GetID_Call) Run(run func()) *MockAuthenticatedUser_GetID_Call

func (*MockAuthenticatedUser_GetID_Call) RunAndReturn 

func (_c *MockAuthenticatedUser_GetID_Call) RunAndReturn(run func() uuid.UUID) *MockAuthenticatedUser_GetID_Call

type MockAuthenticatedUser_Identity_Call 

type MockAuthenticatedUser_Identity_Call struct {
	*mock.Call
}

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

func (*MockAuthenticatedUser_Identity_Call) Return 

func (_c *MockAuthenticatedUser_Identity_Call) Return(_a0 string) *MockAuthenticatedUser_Identity_Call

func (*MockAuthenticatedUser_Identity_Call) Run 

func (_c *MockAuthenticatedUser_Identity_Call) Run(run func()) *MockAuthenticatedUser_Identity_Call

func (*MockAuthenticatedUser_Identity_Call) RunAndReturn 

func (_c *MockAuthenticatedUser_Identity_Call) RunAndReturn(run func() string) *MockAuthenticatedUser_Identity_Call

type MockAuthenticatedUser_IsServiceAccount_Call 

type MockAuthenticatedUser_IsServiceAccount_Call struct {
	*mock.Call
}

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

func (*MockAuthenticatedUser_IsServiceAccount_Call) Return 

func (_c *MockAuthenticatedUser_IsServiceAccount_Call) Return(_a0 bool) *MockAuthenticatedUser_IsServiceAccount_Call

func (*MockAuthenticatedUser_IsServiceAccount_Call) Run 

func (_c *MockAuthenticatedUser_IsServiceAccount_Call) Run(run func()) *MockAuthenticatedUser_IsServiceAccount_Call

func (*MockAuthenticatedUser_IsServiceAccount_Call) RunAndReturn 

func (_c *MockAuthenticatedUser_IsServiceAccount_Call) RunAndReturn(run func() bool) *MockAuthenticatedUser_IsServiceAccount_Call

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 sqlc.ReconcilerName) 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 sqlc.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 sqlc.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 sqlc.RoleName, teamSlug slug.Slug) error

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

func (*MockDatabase) ClearReconcilerErrorsForTeam 

func (_m *MockDatabase) ClearReconcilerErrorsForTeam(ctx context.Context, _a1 slug.Slug, reconcilerName sqlc.ReconcilerName) error

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

func (*MockDatabase) ConfigureReconciler 

func (_m *MockDatabase) ConfigureReconciler(ctx context.Context, reconcilerName sqlc.ReconcilerName, key sqlc.ReconcilerConfigKey, 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) 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, componentName types.ComponentName, actor *string, targetType types.AuditLogsTargetType, targetIdentifier string, action types.AuditAction, message string) error

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

func (*MockDatabase) CreateRepositoryAuthorization 

func (_m *MockDatabase) CreateRepositoryAuthorization(ctx context.Context, teamSlug slug.Slug, repoName string, authorization sqlc.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, _a1 slug.Slug, purpose string, slackChannel string) (*Team, error)

CreateTeam provides a mock function with given fields: ctx, _a1, 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) DangerousGetReconcilerConfigValues 

func (_m *MockDatabase) DangerousGetReconcilerConfigValues(ctx context.Context, reconcilerName sqlc.ReconcilerName) (*ReconcilerConfigValues, error)

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

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 sqlc.ReconcilerName) (*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 sqlc.ReconcilerName) (*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) FirstRunComplete 

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

FirstRunComplete provides a mock function with given fields: ctx

func (*MockDatabase) GetActiveTeamBySlug 

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

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

func (*MockDatabase) GetActiveTeams 

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

GetActiveTeams provides a mock function with given fields: ctx

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) ([]*AuditLog, error)

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

func (*MockDatabase) GetAuditLogsForReconciler 

func (_m *MockDatabase) GetAuditLogsForReconciler(ctx context.Context, reconcilerName sqlc.ReconcilerName) ([]*AuditLog, error)

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

func (*MockDatabase) GetAuditLogsForTeam 

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

GetAuditLogsForTeam provides a mock function with given fields: ctx, _a1

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 sqlc.ReconcilerName) (*Reconciler, error)

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

func (*MockDatabase) GetReconcilerConfig 

func (_m *MockDatabase) GetReconcilerConfig(ctx context.Context, reconcilerName sqlc.ReconcilerName) ([]*ReconcilerConfig, error)

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

func (*MockDatabase) GetReconcilers 

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

GetReconcilers provides a mock function with given fields: ctx

func (*MockDatabase) GetRepositoryAuthorizations 

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

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

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) ([]*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) 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) GetSlackAlertsChannels 

func (_m *MockDatabase) GetSlackAlertsChannels(ctx context.Context, teamSlug slug.Slug) (map[string]string, error)

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

func (*MockDatabase) GetTeamBySlug 

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

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

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) 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) ([]*sqlc.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) ([]*User, error)

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

func (*MockDatabase) GetTeamMembersForReconciler 

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

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

func (*MockDatabase) GetTeamReconcilerErrors 

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

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

func (*MockDatabase) GetTeams 

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

GetTeams provides a mock function with given fields: ctx

func (*MockDatabase) GetTeamsWithPermissionInGitHubRepo 

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

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

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) ([]*Role, error)

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

func (*MockDatabase) GetUserTeams 

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

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

func (*MockDatabase) GetUsers 

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

GetUsers provides a mock function with given fields: ctx

func (*MockDatabase) GetUsersWithGloballyAssignedRole 

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

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

func (*MockDatabase) IsFirstRun 

func (_m *MockDatabase) IsFirstRun(ctx context.Context) (bool, error)

IsFirstRun provides a mock function with given fields: ctx

func (*MockDatabase) LoadReconcilerStateForTeam 

func (_m *MockDatabase) LoadReconcilerStateForTeam(ctx context.Context, reconcilerName sqlc.ReconcilerName, _a2 slug.Slug, state interface{}) error

LoadReconcilerStateForTeam provides a mock function with given fields: ctx, reconcilerName, _a2, state

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 sqlc.ReconcilerName) error

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

func (*MockDatabase) RemoveReconcilerStateForTeam 

func (_m *MockDatabase) RemoveReconcilerStateForTeam(ctx context.Context, reconcilerName sqlc.ReconcilerName, _a2 slug.Slug) error

RemoveReconcilerStateForTeam provides a mock function with given fields: ctx, reconcilerName, _a2

func (*MockDatabase) RemoveRepositoryAuthorization 

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

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

func (*MockDatabase) RemoveSlackAlertsChannel 

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

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

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 sqlc.ReconcilerName) (*Reconciler, error)

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

func (*MockDatabase) RevokeGlobalUserRole 

func (_m *MockDatabase) RevokeGlobalUserRole(ctx context.Context, userID uuid.UUID, roleName sqlc.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, _a2 slug.Slug, reconcilerName sqlc.ReconcilerName, err error) error

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

func (*MockDatabase) SetReconcilerStateForTeam 

func (_m *MockDatabase) SetReconcilerStateForTeam(ctx context.Context, reconcilerName sqlc.ReconcilerName, _a2 slug.Slug, state interface{}) error

SetReconcilerStateForTeam provides a mock function with given fields: ctx, reconcilerName, _a2, state

func (*MockDatabase) SetSlackAlertsChannel 

func (_m *MockDatabase) SetSlackAlertsChannel(ctx context.Context, teamSlug slug.Slug, environment string, channelName string) error

SetSlackAlertsChannel provides a mock function with given fields: ctx, teamSlug, environment, channelName

func (*MockDatabase) SetTeamMemberRole 

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

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

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) 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) 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 sqlc.ReconcilerName)) *MockDatabase_AddReconcilerOptOut_Call

func (*MockDatabase_AddReconcilerOptOut_Call) RunAndReturn 

func (_c *MockDatabase_AddReconcilerOptOut_Call) RunAndReturn(run func(context.Context, *uuid.UUID, *slug.Slug, sqlc.ReconcilerName) 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 sqlc.RoleName)) *MockDatabase_AssignGlobalRoleToServiceAccount_Call

func (*MockDatabase_AssignGlobalRoleToServiceAccount_Call) RunAndReturn 

func (_c *MockDatabase_AssignGlobalRoleToServiceAccount_Call) RunAndReturn(run func(context.Context, uuid.UUID, sqlc.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 sqlc.RoleName)) *MockDatabase_AssignGlobalRoleToUser_Call

func (*MockDatabase_AssignGlobalRoleToUser_Call) RunAndReturn 

func (_c *MockDatabase_AssignGlobalRoleToUser_Call) RunAndReturn(run func(context.Context, uuid.UUID, sqlc.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 sqlc.RoleName, teamSlug slug.Slug)) *MockDatabase_AssignTeamRoleToServiceAccount_Call

func (*MockDatabase_AssignTeamRoleToServiceAccount_Call) RunAndReturn 

func (_c *MockDatabase_AssignTeamRoleToServiceAccount_Call) RunAndReturn(run func(context.Context, uuid.UUID, sqlc.RoleName, slug.Slug) error) *MockDatabase_AssignTeamRoleToServiceAccount_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, _a1 slug.Slug, reconcilerName sqlc.ReconcilerName)) *MockDatabase_ClearReconcilerErrorsForTeam_Call

func (*MockDatabase_ClearReconcilerErrorsForTeam_Call) RunAndReturn 

func (_c *MockDatabase_ClearReconcilerErrorsForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug, sqlc.ReconcilerName) 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 sqlc.ReconcilerName, key sqlc.ReconcilerConfigKey, value string)) *MockDatabase_ConfigureReconciler_Call

func (*MockDatabase_ConfigureReconciler_Call) RunAndReturn 

func (_c *MockDatabase_ConfigureReconciler_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName, sqlc.ReconcilerConfigKey, 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_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, componentName types.ComponentName, actor *string, targetType types.AuditLogsTargetType, targetIdentifier string, action types.AuditAction, message string)) *MockDatabase_CreateAuditLogEntry_Call

func (*MockDatabase_CreateAuditLogEntry_Call) RunAndReturn 

func (_c *MockDatabase_CreateAuditLogEntry_Call) RunAndReturn(run func(context.Context, uuid.UUID, types.ComponentName, *string, types.AuditLogsTargetType, string, types.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 sqlc.RepositoryAuthorizationEnum)) *MockDatabase_CreateRepositoryAuthorization_Call

func (*MockDatabase_CreateRepositoryAuthorization_Call) RunAndReturn 

func (_c *MockDatabase_CreateRepositoryAuthorization_Call) RunAndReturn(run func(context.Context, slug.Slug, string, sqlc.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, _a1 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_DangerousGetReconcilerConfigValues_Call 

type MockDatabase_DangerousGetReconcilerConfigValues_Call struct {
	*mock.Call
}

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

func (*MockDatabase_DangerousGetReconcilerConfigValues_Call) Return 

func (_c *MockDatabase_DangerousGetReconcilerConfigValues_Call) Return(_a0 *ReconcilerConfigValues, _a1 error) *MockDatabase_DangerousGetReconcilerConfigValues_Call

func (*MockDatabase_DangerousGetReconcilerConfigValues_Call) Run 

func (_c *MockDatabase_DangerousGetReconcilerConfigValues_Call) Run(run func(ctx context.Context, reconcilerName sqlc.ReconcilerName)) *MockDatabase_DangerousGetReconcilerConfigValues_Call

func (*MockDatabase_DangerousGetReconcilerConfigValues_Call) RunAndReturn 

func (_c *MockDatabase_DangerousGetReconcilerConfigValues_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName) (*ReconcilerConfigValues, error)) *MockDatabase_DangerousGetReconcilerConfigValues_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 sqlc.ReconcilerName)) *MockDatabase_DisableReconciler_Call

func (*MockDatabase_DisableReconciler_Call) RunAndReturn 

func (_c *MockDatabase_DisableReconciler_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName) (*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 sqlc.ReconcilerName)) *MockDatabase_EnableReconciler_Call

func (*MockDatabase_EnableReconciler_Call) RunAndReturn 

func (_c *MockDatabase_EnableReconciler_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName) (*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 sqlc.ReconcilerName

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 sqlc.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 sqlc.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 sqlc.RoleName
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) ClearReconcilerErrorsForTeam 

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

ClearReconcilerErrorsForTeam is a helper method to define mock.On call

  • ctx context.Context
  • _a1 slug.Slug
  • reconcilerName sqlc.ReconcilerName

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 sqlc.ReconcilerName
  • key sqlc.ReconcilerConfigKey
  • 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) 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{}, componentName 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
  • componentName types.ComponentName
  • actor *string
  • targetType types.AuditLogsTargetType
  • targetIdentifier string
  • action types.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 sqlc.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{}, _a1 interface{}, purpose interface{}, slackChannel interface{}) *MockDatabase_CreateTeam_Call

CreateTeam is a helper method to define mock.On call

  • ctx context.Context
  • _a1 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) DangerousGetReconcilerConfigValues 

func (_e *MockDatabase_Expecter) DangerousGetReconcilerConfigValues(ctx interface{}, reconcilerName interface{}) *MockDatabase_DangerousGetReconcilerConfigValues_Call

DangerousGetReconcilerConfigValues is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName sqlc.ReconcilerName

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 sqlc.ReconcilerName

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 sqlc.ReconcilerName

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) FirstRunComplete 

func (_e *MockDatabase_Expecter) FirstRunComplete(ctx interface{}) *MockDatabase_FirstRunComplete_Call

FirstRunComplete is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) GetActiveTeamBySlug 

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

GetActiveTeamBySlug is a helper method to define mock.On call

  • ctx context.Context
  • _a1 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) 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{}) *MockDatabase_GetAuditLogsForCorrelationID_Call

GetAuditLogsForCorrelationID is a helper method to define mock.On call

  • ctx context.Context
  • correlationID uuid.UUID

func (*MockDatabase_Expecter) GetAuditLogsForReconciler 

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

GetAuditLogsForReconciler is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName sqlc.ReconcilerName

func (*MockDatabase_Expecter) GetAuditLogsForTeam 

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

GetAuditLogsForTeam is a helper method to define mock.On call

  • ctx context.Context
  • _a1 slug.Slug

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 sqlc.ReconcilerName

func (*MockDatabase_Expecter) GetReconcilerConfig 

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

GetReconcilerConfig is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName sqlc.ReconcilerName

func (*MockDatabase_Expecter) GetReconcilers 

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

GetReconcilers is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) GetRepositoryAuthorizations 

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

GetRepositoryAuthorizations is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug
  • repo 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) 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) GetSlackAlertsChannels 

func (_e *MockDatabase_Expecter) GetSlackAlertsChannels(ctx interface{}, teamSlug interface{}) *MockDatabase_GetSlackAlertsChannels_Call

GetSlackAlertsChannels is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

func (*MockDatabase_Expecter) GetTeamBySlug 

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

GetTeamBySlug is a helper method to define mock.On call

  • ctx context.Context
  • _a1 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) 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{}) *MockDatabase_GetTeamMembers_Call

GetTeamMembers is a helper method to define mock.On call

  • ctx context.Context
  • teamSlug slug.Slug

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 sqlc.ReconcilerName

func (*MockDatabase_Expecter) GetTeamReconcilerErrors 

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

GetTeamReconcilerErrors is a helper method to define mock.On call

  • ctx context.Context
  • _a1 slug.Slug

func (*MockDatabase_Expecter) GetTeams 

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

GetTeams is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) GetTeamsWithPermissionInGitHubRepo 

func (_e *MockDatabase_Expecter) GetTeamsWithPermissionInGitHubRepo(ctx interface{}, repoName interface{}, permission interface{}) *MockDatabase_GetTeamsWithPermissionInGitHubRepo_Call

GetTeamsWithPermissionInGitHubRepo is a helper method to define mock.On call

  • ctx context.Context
  • repoName string
  • permission string

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) 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) GetUsers 

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

GetUsers is a helper method to define mock.On call

  • ctx context.Context

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 sqlc.RoleName

func (*MockDatabase_Expecter) IsFirstRun 

func (_e *MockDatabase_Expecter) IsFirstRun(ctx interface{}) *MockDatabase_IsFirstRun_Call

IsFirstRun is a helper method to define mock.On call

  • ctx context.Context

func (*MockDatabase_Expecter) LoadReconcilerStateForTeam 

func (_e *MockDatabase_Expecter) LoadReconcilerStateForTeam(ctx interface{}, reconcilerName interface{}, _a2 interface{}, state interface{}) *MockDatabase_LoadReconcilerStateForTeam_Call

LoadReconcilerStateForTeam is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName sqlc.ReconcilerName
  • _a2 slug.Slug
  • state interface{}

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 sqlc.ReconcilerName

func (*MockDatabase_Expecter) RemoveReconcilerStateForTeam 

func (_e *MockDatabase_Expecter) RemoveReconcilerStateForTeam(ctx interface{}, reconcilerName interface{}, _a2 interface{}) *MockDatabase_RemoveReconcilerStateForTeam_Call

RemoveReconcilerStateForTeam is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName sqlc.ReconcilerName
  • _a2 slug.Slug

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 sqlc.RepositoryAuthorizationEnum

func (*MockDatabase_Expecter) RemoveSlackAlertsChannel 

func (_e *MockDatabase_Expecter) RemoveSlackAlertsChannel(ctx interface{}, teamSlug interface{}, environment interface{}) *MockDatabase_RemoveSlackAlertsChannel_Call

RemoveSlackAlertsChannel is a helper method to define mock.On call

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

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 sqlc.ReconcilerName

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 sqlc.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{}, _a2 interface{}, reconcilerName interface{}, err interface{}) *MockDatabase_SetReconcilerErrorForTeam_Call

SetReconcilerErrorForTeam is a helper method to define mock.On call

  • ctx context.Context
  • correlationID uuid.UUID
  • _a2 slug.Slug
  • reconcilerName sqlc.ReconcilerName
  • err error

func (*MockDatabase_Expecter) SetReconcilerStateForTeam 

func (_e *MockDatabase_Expecter) SetReconcilerStateForTeam(ctx interface{}, reconcilerName interface{}, _a2 interface{}, state interface{}) *MockDatabase_SetReconcilerStateForTeam_Call

SetReconcilerStateForTeam is a helper method to define mock.On call

  • ctx context.Context
  • reconcilerName sqlc.ReconcilerName
  • _a2 slug.Slug
  • state interface{}

func (*MockDatabase_Expecter) SetSlackAlertsChannel 

func (_e *MockDatabase_Expecter) SetSlackAlertsChannel(ctx interface{}, teamSlug interface{}, environment interface{}, channelName interface{}) *MockDatabase_SetSlackAlertsChannel_Call

SetSlackAlertsChannel is a helper method to define mock.On call

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

func (*MockDatabase_Expecter) SetTeamMemberRole 

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

SetTeamMemberRole is a helper method to define mock.On call

  • ctx context.Context
  • userID uuid.UUID
  • teamSlug slug.Slug
  • role sqlc.RoleName

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) 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) 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_FirstRunComplete_Call 

type MockDatabase_FirstRunComplete_Call struct {
	*mock.Call
}

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

func (*MockDatabase_FirstRunComplete_Call) Return 

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

func (*MockDatabase_FirstRunComplete_Call) Run 

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

func (*MockDatabase_FirstRunComplete_Call) RunAndReturn 

func (_c *MockDatabase_FirstRunComplete_Call) RunAndReturn(run func(context.Context) error) *MockDatabase_FirstRunComplete_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, _a1 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_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 error) *MockDatabase_GetAuditLogsForCorrelationID_Call

func (*MockDatabase_GetAuditLogsForCorrelationID_Call) Run 

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

func (*MockDatabase_GetAuditLogsForCorrelationID_Call) RunAndReturn 

func (_c *MockDatabase_GetAuditLogsForCorrelationID_Call) RunAndReturn(run func(context.Context, uuid.UUID) ([]*AuditLog, 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 error) *MockDatabase_GetAuditLogsForReconciler_Call

func (*MockDatabase_GetAuditLogsForReconciler_Call) Run 

func (_c *MockDatabase_GetAuditLogsForReconciler_Call) Run(run func(ctx context.Context, reconcilerName sqlc.ReconcilerName)) *MockDatabase_GetAuditLogsForReconciler_Call

func (*MockDatabase_GetAuditLogsForReconciler_Call) RunAndReturn 

func (_c *MockDatabase_GetAuditLogsForReconciler_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName) ([]*AuditLog, 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 error) *MockDatabase_GetAuditLogsForTeam_Call

func (*MockDatabase_GetAuditLogsForTeam_Call) Run 

func (_c *MockDatabase_GetAuditLogsForTeam_Call) Run(run func(ctx context.Context, _a1 slug.Slug)) *MockDatabase_GetAuditLogsForTeam_Call

func (*MockDatabase_GetAuditLogsForTeam_Call) RunAndReturn 

func (_c *MockDatabase_GetAuditLogsForTeam_Call) RunAndReturn(run func(context.Context, slug.Slug) ([]*AuditLog, 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 sqlc.ReconcilerName)) *MockDatabase_GetReconcilerConfig_Call

func (*MockDatabase_GetReconcilerConfig_Call) RunAndReturn 

func (_c *MockDatabase_GetReconcilerConfig_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName) ([]*ReconcilerConfig, error)) *MockDatabase_GetReconcilerConfig_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 sqlc.ReconcilerName)) *MockDatabase_GetReconciler_Call

func (*MockDatabase_GetReconciler_Call) RunAndReturn 

func (_c *MockDatabase_GetReconciler_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName) (*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 error) *MockDatabase_GetReconcilers_Call

func (*MockDatabase_GetReconcilers_Call) Run 

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

func (*MockDatabase_GetReconcilers_Call) RunAndReturn 

func (_c *MockDatabase_GetReconcilers_Call) RunAndReturn(run func(context.Context) ([]*Reconciler, 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 []sqlc.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, repo string)) *MockDatabase_GetRepositoryAuthorizations_Call

func (*MockDatabase_GetRepositoryAuthorizations_Call) RunAndReturn 

func (_c *MockDatabase_GetRepositoryAuthorizations_Call) RunAndReturn(run func(context.Context, slug.Slug, string) ([]sqlc.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 []*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) ([]*Role, error)) *MockDatabase_GetServiceAccountRoles_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_GetSlackAlertsChannels_Call 

type MockDatabase_GetSlackAlertsChannels_Call struct {
	*mock.Call
}

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

func (*MockDatabase_GetSlackAlertsChannels_Call) Return 

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

func (*MockDatabase_GetSlackAlertsChannels_Call) Run 

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

func (*MockDatabase_GetSlackAlertsChannels_Call) RunAndReturn 

func (_c *MockDatabase_GetSlackAlertsChannels_Call) RunAndReturn(run func(context.Context, slug.Slug) (map[string]string, error)) *MockDatabase_GetSlackAlertsChannels_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, _a1 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_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 []*sqlc.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) ([]*sqlc.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 sqlc.ReconcilerName)) *MockDatabase_GetTeamMembersForReconciler_Call

func (*MockDatabase_GetTeamMembersForReconciler_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamMembersForReconciler_Call) RunAndReturn(run func(context.Context, slug.Slug, sqlc.ReconcilerName) ([]*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 error) *MockDatabase_GetTeamMembers_Call

func (*MockDatabase_GetTeamMembers_Call) Run 

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

func (*MockDatabase_GetTeamMembers_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamMembers_Call) RunAndReturn(run func(context.Context, slug.Slug) ([]*User, 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, _a1 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_GetTeamsWithPermissionInGitHubRepo_Call 

type MockDatabase_GetTeamsWithPermissionInGitHubRepo_Call struct {
	*mock.Call
}

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

func (*MockDatabase_GetTeamsWithPermissionInGitHubRepo_Call) Return 

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

func (*MockDatabase_GetTeamsWithPermissionInGitHubRepo_Call) Run 

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

func (*MockDatabase_GetTeamsWithPermissionInGitHubRepo_Call) RunAndReturn 

func (_c *MockDatabase_GetTeamsWithPermissionInGitHubRepo_Call) RunAndReturn(run func(context.Context, string, string) ([]*Team, error)) *MockDatabase_GetTeamsWithPermissionInGitHubRepo_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 error) *MockDatabase_GetTeams_Call

func (*MockDatabase_GetTeams_Call) Run 

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

func (*MockDatabase_GetTeams_Call) RunAndReturn 

func (_c *MockDatabase_GetTeams_Call) RunAndReturn(run func(context.Context) ([]*Team, 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_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 []*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) ([]*Role, error)) *MockDatabase_GetUserRoles_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 []*Team, _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) ([]*Team, error)) *MockDatabase_GetUserTeams_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 sqlc.RoleName)) *MockDatabase_GetUsersWithGloballyAssignedRole_Call

func (*MockDatabase_GetUsersWithGloballyAssignedRole_Call) RunAndReturn 

func (_c *MockDatabase_GetUsersWithGloballyAssignedRole_Call) RunAndReturn(run func(context.Context, sqlc.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 error) *MockDatabase_GetUsers_Call

func (*MockDatabase_GetUsers_Call) Run 

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

func (*MockDatabase_GetUsers_Call) RunAndReturn 

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

type MockDatabase_IsFirstRun_Call 

type MockDatabase_IsFirstRun_Call struct {
	*mock.Call
}

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

func (*MockDatabase_IsFirstRun_Call) Return 

func (_c *MockDatabase_IsFirstRun_Call) Return(_a0 bool, _a1 error) *MockDatabase_IsFirstRun_Call

func (*MockDatabase_IsFirstRun_Call) Run 

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

func (*MockDatabase_IsFirstRun_Call) RunAndReturn 

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

type MockDatabase_LoadReconcilerStateForTeam_Call 

type MockDatabase_LoadReconcilerStateForTeam_Call struct {
	*mock.Call
}

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

func (*MockDatabase_LoadReconcilerStateForTeam_Call) Return 

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

func (*MockDatabase_LoadReconcilerStateForTeam_Call) Run 

func (_c *MockDatabase_LoadReconcilerStateForTeam_Call) Run(run func(ctx context.Context, reconcilerName sqlc.ReconcilerName, _a2 slug.Slug, state interface{})) *MockDatabase_LoadReconcilerStateForTeam_Call

func (*MockDatabase_LoadReconcilerStateForTeam_Call) RunAndReturn 

func (_c *MockDatabase_LoadReconcilerStateForTeam_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName, slug.Slug, interface{}) error) *MockDatabase_LoadReconcilerStateForTeam_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 sqlc.ReconcilerName)) *MockDatabase_RemoveReconcilerOptOut_Call

func (*MockDatabase_RemoveReconcilerOptOut_Call) RunAndReturn 

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

type MockDatabase_RemoveReconcilerStateForTeam_Call 

type MockDatabase_RemoveReconcilerStateForTeam_Call struct {
	*mock.Call
}

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

func (*MockDatabase_RemoveReconcilerStateForTeam_Call) Return 

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

func (*MockDatabase_RemoveReconcilerStateForTeam_Call) Run 

func (_c *MockDatabase_RemoveReconcilerStateForTeam_Call) Run(run func(ctx context.Context, reconcilerName sqlc.ReconcilerName, _a2 slug.Slug)) *MockDatabase_RemoveReconcilerStateForTeam_Call

func (*MockDatabase_RemoveReconcilerStateForTeam_Call) RunAndReturn 

func (_c *MockDatabase_RemoveReconcilerStateForTeam_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName, slug.Slug) error) *MockDatabase_RemoveReconcilerStateForTeam_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 sqlc.RepositoryAuthorizationEnum)) *MockDatabase_RemoveRepositoryAuthorization_Call

func (*MockDatabase_RemoveRepositoryAuthorization_Call) RunAndReturn 

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

type MockDatabase_RemoveSlackAlertsChannel_Call 

type MockDatabase_RemoveSlackAlertsChannel_Call struct {
	*mock.Call
}

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

func (*MockDatabase_RemoveSlackAlertsChannel_Call) Return 

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

func (*MockDatabase_RemoveSlackAlertsChannel_Call) Run 

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

func (*MockDatabase_RemoveSlackAlertsChannel_Call) RunAndReturn 

func (_c *MockDatabase_RemoveSlackAlertsChannel_Call) RunAndReturn(run func(context.Context, slug.Slug, string) error) *MockDatabase_RemoveSlackAlertsChannel_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 sqlc.ReconcilerName)) *MockDatabase_ResetReconcilerConfig_Call

func (*MockDatabase_ResetReconcilerConfig_Call) RunAndReturn 

func (_c *MockDatabase_ResetReconcilerConfig_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName) (*Reconciler, error)) *MockDatabase_ResetReconcilerConfig_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 sqlc.RoleName)) *MockDatabase_RevokeGlobalUserRole_Call

func (*MockDatabase_RevokeGlobalUserRole_Call) RunAndReturn 

func (_c *MockDatabase_RevokeGlobalUserRole_Call) RunAndReturn(run func(context.Context, uuid.UUID, sqlc.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, _a2 slug.Slug, reconcilerName sqlc.ReconcilerName, err error)) *MockDatabase_SetReconcilerErrorForTeam_Call

func (*MockDatabase_SetReconcilerErrorForTeam_Call) RunAndReturn 

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

type MockDatabase_SetReconcilerStateForTeam_Call 

type MockDatabase_SetReconcilerStateForTeam_Call struct {
	*mock.Call
}

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

func (*MockDatabase_SetReconcilerStateForTeam_Call) Return 

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

func (*MockDatabase_SetReconcilerStateForTeam_Call) Run 

func (_c *MockDatabase_SetReconcilerStateForTeam_Call) Run(run func(ctx context.Context, reconcilerName sqlc.ReconcilerName, _a2 slug.Slug, state interface{})) *MockDatabase_SetReconcilerStateForTeam_Call

func (*MockDatabase_SetReconcilerStateForTeam_Call) RunAndReturn 

func (_c *MockDatabase_SetReconcilerStateForTeam_Call) RunAndReturn(run func(context.Context, sqlc.ReconcilerName, slug.Slug, interface{}) error) *MockDatabase_SetReconcilerStateForTeam_Call

type MockDatabase_SetSlackAlertsChannel_Call 

type MockDatabase_SetSlackAlertsChannel_Call struct {
	*mock.Call
}

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

func (*MockDatabase_SetSlackAlertsChannel_Call) Return 

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

func (*MockDatabase_SetSlackAlertsChannel_Call) Run 

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

func (*MockDatabase_SetSlackAlertsChannel_Call) RunAndReturn 

func (_c *MockDatabase_SetSlackAlertsChannel_Call) RunAndReturn(run func(context.Context, slug.Slug, string, string) error) *MockDatabase_SetSlackAlertsChannel_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, role sqlc.RoleName)) *MockDatabase_SetTeamMemberRole_Call

func (*MockDatabase_SetTeamMemberRole_Call) RunAndReturn 

func (_c *MockDatabase_SetTeamMemberRole_Call) RunAndReturn(run func(context.Context, uuid.UUID, slug.Slug, sqlc.RoleName) error) *MockDatabase_SetTeamMemberRole_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_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_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 Querier 

type Querier interface {
	sqlc.Querier
	Transaction(ctx context.Context, callback QuerierTransactionFunc) error
}

type QuerierTransactionFunc 

type QuerierTransactionFunc func(ctx context.Context, querier Querier) error

type Queries 

type Queries struct {
	*sqlc.Queries
	// contains filtered or unexported fields
}

func (*Queries) Transaction 

func (q *Queries) Transaction(ctx context.Context, callback QuerierTransactionFunc) error

type Reconciler 

type Reconciler struct {
	*sqlc.Reconciler
}

type ReconcilerConfig 

type ReconcilerConfig struct {
	*sqlc.GetReconcilerConfigRow
}

type ReconcilerConfigValues 

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

func (ReconcilerConfigValues) GetValue 

func (v ReconcilerConfigValues) GetValue(s sqlc.ReconcilerConfigKey) string

type ReconcilerError 

type ReconcilerError struct {
	*sqlc.ReconcilerError
}

type Role 

type Role struct {
	Authorizations         []roles.Authorization
	RoleName               sqlc.RoleName
	TargetServiceAccountID *uuid.UUID
	TargetTeamSlug         *slug.Slug
}

func (Role) IsGlobal 

func (r Role) IsGlobal() bool

IsGlobal Check if the role is globally assigned or not

func (Role) TargetsServiceAccount 

func (r Role) TargetsServiceAccount(targetServiceAccountID uuid.UUID) bool

TargetsServiceAccount Check if the role targets a specific service account

func (Role) TargetsTeam 

func (r Role) TargetsTeam(targetsTeamSlug slug.Slug) bool

TargetsTeam Check if the role targets a specific team

type ServiceAccount 

type ServiceAccount struct {
	*sqlc.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 Session 

type Session struct {
	*sqlc.Session
}

type Team 

type Team struct {
	*sqlc.Team
}

type TeamDeleteKey 

type TeamDeleteKey struct {
	*sqlc.TeamDeleteKey
}

func (TeamDeleteKey) Expires 

func (k TeamDeleteKey) Expires() time.Time

func (TeamDeleteKey) HasExpired 

func (k TeamDeleteKey) HasExpired() bool

type User 

type User struct {
	*sqlc.User
}

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 UserRole 

type UserRole struct {
	*sqlc.UserRole
}

Source Files

View all Source files

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.