mocks

package

Go to main page

Versions in this module

v1

v1.7.11

Feb 24, 2025

v1.7.10

Feb 5, 2025

v1.7.4

Jan 13, 2025

v1.7.3

Jan 12, 2025

v1.7.1

Dec 13, 2024

v1.7.0

Dec 12, 2024

v1.6.39

Nov 19, 2024

v1.6.36

Nov 17, 2024

v1.6.35

Nov 17, 2024

v1.6.32

Oct 26, 2024

v1.6.27

Oct 24, 2024

Changes in this version

+ type AWSFactory struct

+ func NewAWSFactory(t interface{ ... }) *AWSFactory

+ func (_m *AWSFactory) EXPECT() *AWSFactory_Expecter

+ func (_m *AWSFactory) GetCfg() aws.Config

+ func (_m *AWSFactory) GetDynamoDBClient() *dynamodb.Client

+ func (_m *AWSFactory) GetS3Client() *s3.Client

+ func (_m *AWSFactory) GetSNSClient() *sns.Client

+ func (_m *AWSFactory) GetSQSClient() *sqs.Client

+ type AWSFactory_Expecter struct

+ func (_e *AWSFactory_Expecter) GetCfg() *AWSFactory_GetCfg_Call

+ func (_e *AWSFactory_Expecter) GetDynamoDBClient() *AWSFactory_GetDynamoDBClient_Call

+ func (_e *AWSFactory_Expecter) GetS3Client() *AWSFactory_GetS3Client_Call

+ func (_e *AWSFactory_Expecter) GetSNSClient() *AWSFactory_GetSNSClient_Call

+ func (_e *AWSFactory_Expecter) GetSQSClient() *AWSFactory_GetSQSClient_Call

+ type AWSFactory_GetCfg_Call struct

+ func (_c *AWSFactory_GetCfg_Call) Return(_a0 aws.Config) *AWSFactory_GetCfg_Call

+ func (_c *AWSFactory_GetCfg_Call) Run(run func()) *AWSFactory_GetCfg_Call

+ func (_c *AWSFactory_GetCfg_Call) RunAndReturn(run func() aws.Config) *AWSFactory_GetCfg_Call

+ type AWSFactory_GetDynamoDBClient_Call struct

+ func (_c *AWSFactory_GetDynamoDBClient_Call) Return(_a0 *dynamodb.Client) *AWSFactory_GetDynamoDBClient_Call

+ func (_c *AWSFactory_GetDynamoDBClient_Call) Run(run func()) *AWSFactory_GetDynamoDBClient_Call

+ func (_c *AWSFactory_GetDynamoDBClient_Call) RunAndReturn(run func() *dynamodb.Client) *AWSFactory_GetDynamoDBClient_Call

+ type AWSFactory_GetS3Client_Call struct

+ func (_c *AWSFactory_GetS3Client_Call) Return(_a0 *s3.Client) *AWSFactory_GetS3Client_Call

+ func (_c *AWSFactory_GetS3Client_Call) Run(run func()) *AWSFactory_GetS3Client_Call

+ func (_c *AWSFactory_GetS3Client_Call) RunAndReturn(run func() *s3.Client) *AWSFactory_GetS3Client_Call

+ type AWSFactory_GetSNSClient_Call struct

+ func (_c *AWSFactory_GetSNSClient_Call) Return(_a0 *sns.Client) *AWSFactory_GetSNSClient_Call

+ func (_c *AWSFactory_GetSNSClient_Call) Run(run func()) *AWSFactory_GetSNSClient_Call

+ func (_c *AWSFactory_GetSNSClient_Call) RunAndReturn(run func() *sns.Client) *AWSFactory_GetSNSClient_Call

+ type AWSFactory_GetSQSClient_Call struct

+ func (_c *AWSFactory_GetSQSClient_Call) Return(_a0 *sqs.Client) *AWSFactory_GetSQSClient_Call

+ func (_c *AWSFactory_GetSQSClient_Call) Run(run func()) *AWSFactory_GetSQSClient_Call

+ func (_c *AWSFactory_GetSQSClient_Call) RunAndReturn(run func() *sqs.Client) *AWSFactory_GetSQSClient_Call

+ type AnalysedMediaObserver struct

+ func NewAnalysedMediaObserver(t interface{ ... }) *AnalysedMediaObserver

+ func (_m *AnalysedMediaObserver) EXPECT() *AnalysedMediaObserver_Expecter

+ func (_m *AnalysedMediaObserver) OnAnalysedMedia(ctx context.Context, media *backup.AnalysedMedia) error

+ type AnalysedMediaObserver_Expecter struct

+ func (_e *AnalysedMediaObserver_Expecter) OnAnalysedMedia(ctx interface{}, media interface{}) *AnalysedMediaObserver_OnAnalysedMedia_Call

+ type AnalysedMediaObserver_OnAnalysedMedia_Call struct

+ func (_c *AnalysedMediaObserver_OnAnalysedMedia_Call) Return(_a0 error) *AnalysedMediaObserver_OnAnalysedMedia_Call

+ func (_c *AnalysedMediaObserver_OnAnalysedMedia_Call) Run(run func(ctx context.Context, media *backup.AnalysedMedia)) *AnalysedMediaObserver_OnAnalysedMedia_Call

+ func (_c *AnalysedMediaObserver_OnAnalysedMedia_Call) RunAndReturn(run func(context.Context, *backup.AnalysedMedia) error) *AnalysedMediaObserver_OnAnalysedMedia_Call

+ type Analyser struct

+ func NewAnalyser(t interface{ ... }) *Analyser

+ func (_m *Analyser) Analyse(ctx context.Context, found backup.FoundMedia, ...) error

+ func (_m *Analyser) EXPECT() *Analyser_Expecter

+ type AnalyserAsync struct

+ func NewAnalyserAsync(t interface{ ... }) *AnalyserAsync

+ func (_m *AnalyserAsync) Analyse(ctx context.Context, found backup.FoundMedia, ...)

+ func (_m *AnalyserAsync) EXPECT() *AnalyserAsync_Expecter

+ type AnalyserAsync_Analyse_Call struct

+ func (_c *AnalyserAsync_Analyse_Call) Return() *AnalyserAsync_Analyse_Call

+ func (_c *AnalyserAsync_Analyse_Call) Run(run func(ctx context.Context, found backup.FoundMedia, ...)) *AnalyserAsync_Analyse_Call

+ func (_c *AnalyserAsync_Analyse_Call) RunAndReturn(...) *AnalyserAsync_Analyse_Call

+ type AnalyserAsync_Expecter struct

+ func (_e *AnalyserAsync_Expecter) Analyse(ctx interface{}, found interface{}, analysedMediaObserver interface{}, ...) *AnalyserAsync_Analyse_Call

+ type AnalyserDecoratorObserver struct

+ func NewAnalyserDecoratorObserver(t interface{ ... }) *AnalyserDecoratorObserver

+ func (_m *AnalyserDecoratorObserver) EXPECT() *AnalyserDecoratorObserver_Expecter

+ func (_m *AnalyserDecoratorObserver) OnDecoratedAnalyser(ctx context.Context, found backup.FoundMedia, cacheHit bool) error

+ type AnalyserDecoratorObserver_Expecter struct

+ func (_e *AnalyserDecoratorObserver_Expecter) OnDecoratedAnalyser(ctx interface{}, found interface{}, cacheHit interface{}) *AnalyserDecoratorObserver_OnDecoratedAnalyser_Call

+ type AnalyserDecoratorObserver_OnDecoratedAnalyser_Call struct

+ func (_c *AnalyserDecoratorObserver_OnDecoratedAnalyser_Call) Return(_a0 error) *AnalyserDecoratorObserver_OnDecoratedAnalyser_Call

+ func (_c *AnalyserDecoratorObserver_OnDecoratedAnalyser_Call) Run(run func(ctx context.Context, found backup.FoundMedia, cacheHit bool)) *AnalyserDecoratorObserver_OnDecoratedAnalyser_Call

+ func (_c *AnalyserDecoratorObserver_OnDecoratedAnalyser_Call) RunAndReturn(run func(context.Context, backup.FoundMedia, bool) error) *AnalyserDecoratorObserver_OnDecoratedAnalyser_Call

+ type Analyser_Analyse_Call struct

+ func (_c *Analyser_Analyse_Call) Return(_a0 error) *Analyser_Analyse_Call

+ func (_c *Analyser_Analyse_Call) Run(run func(ctx context.Context, found backup.FoundMedia, ...)) *Analyser_Analyse_Call

+ func (_c *Analyser_Analyse_Call) RunAndReturn(...) *Analyser_Analyse_Call

+ type Analyser_Expecter struct

+ func (_e *Analyser_Expecter) Analyse(ctx interface{}, found interface{}, analysedMediaObserver interface{}) *Analyser_Analyse_Call

+ type ArchiveFactory struct

+ func NewArchiveFactory(t interface{ ... }) *ArchiveFactory

+ func (_m *ArchiveFactory) ArchiveAsyncJobAdapter(ctx context.Context) archive.AsyncJobAdapter

+ func (_m *ArchiveFactory) EXPECT() *ArchiveFactory_Expecter

+ type ArchiveFactory_ArchiveAsyncJobAdapter_Call struct

+ func (_c *ArchiveFactory_ArchiveAsyncJobAdapter_Call) Return(_a0 archive.AsyncJobAdapter) *ArchiveFactory_ArchiveAsyncJobAdapter_Call

+ func (_c *ArchiveFactory_ArchiveAsyncJobAdapter_Call) Run(run func(ctx context.Context)) *ArchiveFactory_ArchiveAsyncJobAdapter_Call

+ func (_c *ArchiveFactory_ArchiveAsyncJobAdapter_Call) RunAndReturn(run func(context.Context) archive.AsyncJobAdapter) *ArchiveFactory_ArchiveAsyncJobAdapter_Call

+ type ArchiveFactory_Expecter struct

+ func (_e *ArchiveFactory_Expecter) ArchiveAsyncJobAdapter(ctx interface{}) *ArchiveFactory_ArchiveAsyncJobAdapter_Call

+ type CatalogQueriesPort struct

+ func NewCatalogQueriesPort(t interface{ ... }) *CatalogQueriesPort

+ func (_m *CatalogQueriesPort) EXPECT() *CatalogQueriesPort_Expecter

+ func (_m *CatalogQueriesPort) FindMediaOwnership(ctx context.Context, owner ownermodel.Owner, mediaId catalog.MediaId) (*catalog.AlbumId, error)

+ type CatalogQueriesPort_Expecter struct

+ func (_e *CatalogQueriesPort_Expecter) FindMediaOwnership(ctx interface{}, owner interface{}, mediaId interface{}) *CatalogQueriesPort_FindMediaOwnership_Call

+ type CatalogQueriesPort_FindMediaOwnership_Call struct

+ func (_c *CatalogQueriesPort_FindMediaOwnership_Call) Return(_a0 *catalog.AlbumId, _a1 error) *CatalogQueriesPort_FindMediaOwnership_Call

+ func (_c *CatalogQueriesPort_FindMediaOwnership_Call) Run(run func(ctx context.Context, owner ownermodel.Owner, mediaId catalog.MediaId)) *CatalogQueriesPort_FindMediaOwnership_Call

+ func (_c *CatalogQueriesPort_FindMediaOwnership_Call) RunAndReturn(...) *CatalogQueriesPort_FindMediaOwnership_Call

+ type DeleteAlbumSizePort struct

+ func NewDeleteAlbumSizePort(t interface{ ... }) *DeleteAlbumSizePort

+ func (_m *DeleteAlbumSizePort) DeleteAlbumSize(ctx context.Context, availability catalogviews.Availability, ...) error

+ func (_m *DeleteAlbumSizePort) EXPECT() *DeleteAlbumSizePort_Expecter

+ type DeleteAlbumSizePort_DeleteAlbumSize_Call struct

+ func (_c *DeleteAlbumSizePort_DeleteAlbumSize_Call) Return(_a0 error) *DeleteAlbumSizePort_DeleteAlbumSize_Call

+ func (_c *DeleteAlbumSizePort_DeleteAlbumSize_Call) Run(run func(ctx context.Context, availability catalogviews.Availability, ...)) *DeleteAlbumSizePort_DeleteAlbumSize_Call

+ func (_c *DeleteAlbumSizePort_DeleteAlbumSize_Call) RunAndReturn(run func(context.Context, catalogviews.Availability, catalog.AlbumId) error) *DeleteAlbumSizePort_DeleteAlbumSize_Call

+ type DeleteAlbumSizePort_Expecter struct

+ func (_e *DeleteAlbumSizePort_Expecter) DeleteAlbumSize(ctx interface{}, availability interface{}, albumId interface{}) *DeleteAlbumSizePort_DeleteAlbumSize_Call

+ type DriftObserver struct

+ func NewDriftObserver(t interface{ ... }) *DriftObserver

+ func (_m *DriftObserver) EXPECT() *DriftObserver_Expecter

+ func (_m *DriftObserver) OnDetectedDrifts(ctx context.Context, drifts []catalogviews.Drift) error

+ type DriftObserver_Expecter struct

+ func (_e *DriftObserver_Expecter) OnDetectedDrifts(ctx interface{}, drifts interface{}) *DriftObserver_OnDetectedDrifts_Call

+ type DriftObserver_OnDetectedDrifts_Call struct

+ func (_c *DriftObserver_OnDetectedDrifts_Call) Return(_a0 error) *DriftObserver_OnDetectedDrifts_Call

+ func (_c *DriftObserver_OnDetectedDrifts_Call) Run(run func(ctx context.Context, drifts []catalogviews.Drift)) *DriftObserver_OnDetectedDrifts_Call

+ func (_c *DriftObserver_OnDetectedDrifts_Call) RunAndReturn(run func(context.Context, []catalogviews.Drift) error) *DriftObserver_OnDetectedDrifts_Call

+ type DriftSynchronizerPort struct

+ func NewDriftSynchronizerPort(t interface{ ... }) *DriftSynchronizerPort

+ func (_m *DriftSynchronizerPort) DeleteAlbumSize(ctx context.Context, availability catalogviews.Availability, ...) error

+ func (_m *DriftSynchronizerPort) EXPECT() *DriftSynchronizerPort_Expecter

+ func (_m *DriftSynchronizerPort) InsertAlbumSize(ctx context.Context, albumSize []catalogviews.MultiUserAlbumSize) error

+ type DriftSynchronizerPort_DeleteAlbumSize_Call struct

+ func (_c *DriftSynchronizerPort_DeleteAlbumSize_Call) Return(_a0 error) *DriftSynchronizerPort_DeleteAlbumSize_Call

+ func (_c *DriftSynchronizerPort_DeleteAlbumSize_Call) Run(run func(ctx context.Context, availability catalogviews.Availability, ...)) *DriftSynchronizerPort_DeleteAlbumSize_Call

+ func (_c *DriftSynchronizerPort_DeleteAlbumSize_Call) RunAndReturn(run func(context.Context, catalogviews.Availability, catalog.AlbumId) error) *DriftSynchronizerPort_DeleteAlbumSize_Call

+ type DriftSynchronizerPort_Expecter struct

+ func (_e *DriftSynchronizerPort_Expecter) DeleteAlbumSize(ctx interface{}, availability interface{}, albumId interface{}) *DriftSynchronizerPort_DeleteAlbumSize_Call

+ func (_e *DriftSynchronizerPort_Expecter) InsertAlbumSize(ctx interface{}, albumSize interface{}) *DriftSynchronizerPort_InsertAlbumSize_Call

+ type DriftSynchronizerPort_InsertAlbumSize_Call struct

+ func (_c *DriftSynchronizerPort_InsertAlbumSize_Call) Return(_a0 error) *DriftSynchronizerPort_InsertAlbumSize_Call

+ func (_c *DriftSynchronizerPort_InsertAlbumSize_Call) Run(run func(ctx context.Context, albumSize []catalogviews.MultiUserAlbumSize)) *DriftSynchronizerPort_InsertAlbumSize_Call

+ func (_c *DriftSynchronizerPort_InsertAlbumSize_Call) RunAndReturn(run func(context.Context, []catalogviews.MultiUserAlbumSize) error) *DriftSynchronizerPort_InsertAlbumSize_Call

+ type Factory struct

+ func NewFactory(t interface{ ... }) *Factory

+ func (_m *Factory) ArchiveAsyncJobAdapter(ctx context.Context) archive.AsyncJobAdapter

+ func (_m *Factory) EXPECT() *Factory_Expecter

+ func (_m *Factory) InitArchive(ctx context.Context)

+ type Factory_ArchiveAsyncJobAdapter_Call struct

+ func (_c *Factory_ArchiveAsyncJobAdapter_Call) Return(_a0 archive.AsyncJobAdapter) *Factory_ArchiveAsyncJobAdapter_Call

+ func (_c *Factory_ArchiveAsyncJobAdapter_Call) Run(run func(ctx context.Context)) *Factory_ArchiveAsyncJobAdapter_Call

+ func (_c *Factory_ArchiveAsyncJobAdapter_Call) RunAndReturn(run func(context.Context) archive.AsyncJobAdapter) *Factory_ArchiveAsyncJobAdapter_Call

+ type Factory_Expecter struct

+ func (_e *Factory_Expecter) ArchiveAsyncJobAdapter(ctx interface{}) *Factory_ArchiveAsyncJobAdapter_Call

+ func (_e *Factory_Expecter) InitArchive(ctx interface{}) *Factory_InitArchive_Call

+ type Factory_InitArchive_Call struct

+ func (_c *Factory_InitArchive_Call) Return() *Factory_InitArchive_Call

+ func (_c *Factory_InitArchive_Call) Run(run func(ctx context.Context)) *Factory_InitArchive_Call

+ func (_c *Factory_InitArchive_Call) RunAndReturn(run func(context.Context)) *Factory_InitArchive_Call

+ type GetCurrentAlbumSizesPort struct

+ func NewGetCurrentAlbumSizesPort(t interface{ ... }) *GetCurrentAlbumSizesPort

+ func (_m *GetCurrentAlbumSizesPort) EXPECT() *GetCurrentAlbumSizesPort_Expecter

+ func (_m *GetCurrentAlbumSizesPort) GetAlbumSizes(ctx context.Context, userId usermodel.UserId, owner ...ownermodel.Owner) ([]catalogviews.UserAlbumSize, error)

+ type GetCurrentAlbumSizesPort_Expecter struct

+ func (_e *GetCurrentAlbumSizesPort_Expecter) GetAlbumSizes(ctx interface{}, userId interface{}, owner ...interface{}) *GetCurrentAlbumSizesPort_GetAlbumSizes_Call

+ type GetCurrentAlbumSizesPort_GetAlbumSizes_Call struct

+ func (_c *GetCurrentAlbumSizesPort_GetAlbumSizes_Call) Return(_a0 []catalogviews.UserAlbumSize, _a1 error) *GetCurrentAlbumSizesPort_GetAlbumSizes_Call

+ func (_c *GetCurrentAlbumSizesPort_GetAlbumSizes_Call) Run(...) *GetCurrentAlbumSizesPort_GetAlbumSizes_Call

+ func (_c *GetCurrentAlbumSizesPort_GetAlbumSizes_Call) RunAndReturn(...) *GetCurrentAlbumSizesPort_GetAlbumSizes_Call

type GrantRepository

+ func (_m *GrantRepository) FindScopesByIdCtx(ctx context.Context, ids ...aclcore.ScopeId) ([]*aclcore.Scope, error)

type GrantRepository_Expecter

+ func (_e *GrantRepository_Expecter) FindScopesByIdCtx(ctx interface{}, ids ...interface{}) *GrantRepository_FindScopesByIdCtx_Call

+ type GrantRepository_FindScopesByIdCtx_Call struct

+ func (_c *GrantRepository_FindScopesByIdCtx_Call) Return(_a0 []*aclcore.Scope, _a1 error) *GrantRepository_FindScopesByIdCtx_Call

+ func (_c *GrantRepository_FindScopesByIdCtx_Call) Run(run func(ctx context.Context, ids ...aclcore.ScopeId)) *GrantRepository_FindScopesByIdCtx_Call

+ func (_c *GrantRepository_FindScopesByIdCtx_Call) RunAndReturn(run func(context.Context, ...aclcore.ScopeId) ([]*aclcore.Scope, error)) *GrantRepository_FindScopesByIdCtx_Call

+ type HasPermissionPort struct

+ func NewHasPermissionPort(t interface{ ... }) *HasPermissionPort

+ func (_m *HasPermissionPort) EXPECT() *HasPermissionPort_Expecter

+ func (_m *HasPermissionPort) FindScopesByIdCtx(ctx context.Context, ids ...aclcore.ScopeId) ([]*aclcore.Scope, error)

+ type HasPermissionPort_Expecter struct

+ func (_e *HasPermissionPort_Expecter) FindScopesByIdCtx(ctx interface{}, ids ...interface{}) *HasPermissionPort_FindScopesByIdCtx_Call

+ type HasPermissionPort_FindScopesByIdCtx_Call struct

+ func (_c *HasPermissionPort_FindScopesByIdCtx_Call) Return(_a0 []*aclcore.Scope, _a1 error) *HasPermissionPort_FindScopesByIdCtx_Call

+ func (_c *HasPermissionPort_FindScopesByIdCtx_Call) Run(run func(ctx context.Context, ids ...aclcore.ScopeId)) *HasPermissionPort_FindScopesByIdCtx_Call

+ func (_c *HasPermissionPort_FindScopesByIdCtx_Call) RunAndReturn(run func(context.Context, ...aclcore.ScopeId) ([]*aclcore.Scope, error)) *HasPermissionPort_FindScopesByIdCtx_Call

+ type IErrorCollectorObserver struct

+ func NewIErrorCollectorObserver(t interface{ ... }) *IErrorCollectorObserver

+ func (_m *IErrorCollectorObserver) EXPECT() *IErrorCollectorObserver_Expecter

+ func (_m *IErrorCollectorObserver) Errors() []error

+ func (_m *IErrorCollectorObserver) OnRejectedMedia(ctx context.Context, found backup.FoundMedia, cause error)

+ type IErrorCollectorObserver_Errors_Call struct

+ func (_c *IErrorCollectorObserver_Errors_Call) Return(_a0 []error) *IErrorCollectorObserver_Errors_Call

+ func (_c *IErrorCollectorObserver_Errors_Call) Run(run func()) *IErrorCollectorObserver_Errors_Call

+ func (_c *IErrorCollectorObserver_Errors_Call) RunAndReturn(run func() []error) *IErrorCollectorObserver_Errors_Call

+ type IErrorCollectorObserver_Expecter struct

+ func (_e *IErrorCollectorObserver_Expecter) Errors() *IErrorCollectorObserver_Errors_Call

+ func (_e *IErrorCollectorObserver_Expecter) OnRejectedMedia(ctx interface{}, found interface{}, cause interface{}) *IErrorCollectorObserver_OnRejectedMedia_Call

+ type IErrorCollectorObserver_OnRejectedMedia_Call struct

+ func (_c *IErrorCollectorObserver_OnRejectedMedia_Call) Return() *IErrorCollectorObserver_OnRejectedMedia_Call

+ func (_c *IErrorCollectorObserver_OnRejectedMedia_Call) Run(run func(ctx context.Context, found backup.FoundMedia, cause error)) *IErrorCollectorObserver_OnRejectedMedia_Call

+ func (_c *IErrorCollectorObserver_OnRejectedMedia_Call) RunAndReturn(run func(context.Context, backup.FoundMedia, error)) *IErrorCollectorObserver_OnRejectedMedia_Call

+ type IErrorCollectorObserver_appendError_Call struct

+ func (_c *IErrorCollectorObserver_appendError_Call) Return() *IErrorCollectorObserver_appendError_Call

+ func (_c *IErrorCollectorObserver_appendError_Call) Run(run func(err error)) *IErrorCollectorObserver_appendError_Call

+ func (_c *IErrorCollectorObserver_appendError_Call) RunAndReturn(run func(error)) *IErrorCollectorObserver_appendError_Call

+ type IErrorCollectorObserver_hasAnyErrors_Call struct

+ func (_c *IErrorCollectorObserver_hasAnyErrors_Call) Return(_a0 int) *IErrorCollectorObserver_hasAnyErrors_Call

+ func (_c *IErrorCollectorObserver_hasAnyErrors_Call) Run(run func()) *IErrorCollectorObserver_hasAnyErrors_Call

+ func (_c *IErrorCollectorObserver_hasAnyErrors_Call) RunAndReturn(run func() int) *IErrorCollectorObserver_hasAnyErrors_Call

+ type InsertAlbumSizePort struct

+ func NewInsertAlbumSizePort(t interface{ ... }) *InsertAlbumSizePort

+ func (_m *InsertAlbumSizePort) EXPECT() *InsertAlbumSizePort_Expecter

+ func (_m *InsertAlbumSizePort) InsertAlbumSize(ctx context.Context, albumSize []catalogviews.MultiUserAlbumSize) error

+ type InsertAlbumSizePort_Expecter struct

+ func (_e *InsertAlbumSizePort_Expecter) InsertAlbumSize(ctx interface{}, albumSize interface{}) *InsertAlbumSizePort_InsertAlbumSize_Call

+ type InsertAlbumSizePort_InsertAlbumSize_Call struct

+ func (_c *InsertAlbumSizePort_InsertAlbumSize_Call) Return(_a0 error) *InsertAlbumSizePort_InsertAlbumSize_Call

+ func (_c *InsertAlbumSizePort_InsertAlbumSize_Call) Run(run func(ctx context.Context, albumSize []catalogviews.MultiUserAlbumSize)) *InsertAlbumSizePort_InsertAlbumSize_Call

+ func (_c *InsertAlbumSizePort_InsertAlbumSize_Call) RunAndReturn(run func(context.Context, []catalogviews.MultiUserAlbumSize) error) *InsertAlbumSizePort_InsertAlbumSize_Call

+ type Interrupter struct

+ func NewInterrupter(t interface{ ... }) *Interrupter

+ func (_m *Interrupter) Cancel()

+ func (_m *Interrupter) EXPECT() *Interrupter_Expecter

+ func (_m *Interrupter) OnRejectedMedia(ctx context.Context, found backup.FoundMedia, cause error)

+ type Interrupter_Cancel_Call struct

+ func (_c *Interrupter_Cancel_Call) Return() *Interrupter_Cancel_Call

+ func (_c *Interrupter_Cancel_Call) Run(run func()) *Interrupter_Cancel_Call

+ func (_c *Interrupter_Cancel_Call) RunAndReturn(run func()) *Interrupter_Cancel_Call

+ type Interrupter_Expecter struct

+ func (_e *Interrupter_Expecter) Cancel() *Interrupter_Cancel_Call

+ func (_e *Interrupter_Expecter) OnRejectedMedia(ctx interface{}, found interface{}, cause interface{}) *Interrupter_OnRejectedMedia_Call

+ type Interrupter_OnRejectedMedia_Call struct

+ func (_c *Interrupter_OnRejectedMedia_Call) Return() *Interrupter_OnRejectedMedia_Call

+ func (_c *Interrupter_OnRejectedMedia_Call) Run(run func(ctx context.Context, found backup.FoundMedia, cause error)) *Interrupter_OnRejectedMedia_Call

+ func (_c *Interrupter_OnRejectedMedia_Call) RunAndReturn(run func(context.Context, backup.FoundMedia, error)) *Interrupter_OnRejectedMedia_Call

+ type MediaReadRepository struct

+ func NewMediaReadRepository(t interface{ ... }) *MediaReadRepository

+ func (_m *MediaReadRepository) EXPECT() *MediaReadRepository_Expecter

+ func (_m *MediaReadRepository) FindMediaCurrentAlbum(ctx context.Context, owner ownermodel.Owner, mediaId catalog.MediaId) (*catalog.AlbumId, error)

+ func (_m *MediaReadRepository) FindMedias(ctx context.Context, request *catalog.FindMediaRequest) ([]*catalog.MediaMeta, error)

+ type MediaReadRepository_Expecter struct

+ func (_e *MediaReadRepository_Expecter) FindMediaCurrentAlbum(ctx interface{}, owner interface{}, mediaId interface{}) *MediaReadRepository_FindMediaCurrentAlbum_Call

+ func (_e *MediaReadRepository_Expecter) FindMedias(ctx interface{}, request interface{}) *MediaReadRepository_FindMedias_Call

+ type MediaReadRepository_FindMediaCurrentAlbum_Call struct

+ func (_c *MediaReadRepository_FindMediaCurrentAlbum_Call) Return(id *catalog.AlbumId, err error) *MediaReadRepository_FindMediaCurrentAlbum_Call

+ func (_c *MediaReadRepository_FindMediaCurrentAlbum_Call) Run(run func(ctx context.Context, owner ownermodel.Owner, mediaId catalog.MediaId)) *MediaReadRepository_FindMediaCurrentAlbum_Call

+ func (_c *MediaReadRepository_FindMediaCurrentAlbum_Call) RunAndReturn(...) *MediaReadRepository_FindMediaCurrentAlbum_Call

+ type MediaReadRepository_FindMedias_Call struct

+ func (_c *MediaReadRepository_FindMedias_Call) Return(medias []*catalog.MediaMeta, err error) *MediaReadRepository_FindMedias_Call

+ func (_c *MediaReadRepository_FindMedias_Call) Run(run func(ctx context.Context, request *catalog.FindMediaRequest)) *MediaReadRepository_FindMedias_Call

+ func (_c *MediaReadRepository_FindMedias_Call) RunAndReturn(...) *MediaReadRepository_FindMedias_Call

+ type MultiFilesBackup struct

+ func NewMultiFilesBackup(t interface{ ... }) *MultiFilesBackup

+ func (_m *MultiFilesBackup) EXPECT() *MultiFilesBackup_Expecter

+ func (_m *MultiFilesBackup) Execute(ctx context.Context, owner ownermodel.Owner, volumeSource backup.SourceVolume, ...) (backup.CompletionReport, error)

+ type MultiFilesBackup_Execute_Call struct

+ func (_c *MultiFilesBackup_Execute_Call) Return(_a0 backup.CompletionReport, _a1 error) *MultiFilesBackup_Execute_Call

+ func (_c *MultiFilesBackup_Execute_Call) Run(...) *MultiFilesBackup_Execute_Call

+ func (_c *MultiFilesBackup_Execute_Call) RunAndReturn(...) *MultiFilesBackup_Execute_Call

+ type MultiFilesBackup_Expecter struct

+ func (_e *MultiFilesBackup_Expecter) Execute(ctx interface{}, owner interface{}, volumeSource interface{}, ...) *MultiFilesBackup_Execute_Call

+ type MultiFilesScanner struct

+ func NewMultiFilesScanner(t interface{ ... }) *MultiFilesScanner

+ func (_m *MultiFilesScanner) EXPECT() *MultiFilesScanner_Expecter

+ func (_m *MultiFilesScanner) Execute(ctx context.Context, owner string, volume backup.SourceVolume, ...) ([]*backup.ScannedFolder, []backup.FoundMedia, error)

+ type MultiFilesScanner_Execute_Call struct

+ func (_c *MultiFilesScanner_Execute_Call) Return(_a0 []*backup.ScannedFolder, _a1 []backup.FoundMedia, _a2 error) *MultiFilesScanner_Execute_Call

+ func (_c *MultiFilesScanner_Execute_Call) Run(run func(ctx context.Context, owner string, volume backup.SourceVolume, ...)) *MultiFilesScanner_Execute_Call

+ func (_c *MultiFilesScanner_Execute_Call) RunAndReturn(...) *MultiFilesScanner_Execute_Call

+ type MultiFilesScanner_Expecter struct

+ func (_e *MultiFilesScanner_Expecter) Execute(ctx interface{}, owner interface{}, volume interface{}, ...) *MultiFilesScanner_Execute_Call

+ type RejectedMediaObserver struct

+ func NewRejectedMediaObserver(t interface{ ... }) *RejectedMediaObserver

+ func (_m *RejectedMediaObserver) EXPECT() *RejectedMediaObserver_Expecter

+ func (_m *RejectedMediaObserver) OnRejectedMedia(ctx context.Context, found backup.FoundMedia, cause error)

+ type RejectedMediaObserver_Expecter struct

+ func (_e *RejectedMediaObserver_Expecter) OnRejectedMedia(ctx interface{}, found interface{}, cause interface{}) *RejectedMediaObserver_OnRejectedMedia_Call

+ type RejectedMediaObserver_OnRejectedMedia_Call struct

+ func (_c *RejectedMediaObserver_OnRejectedMedia_Call) Return() *RejectedMediaObserver_OnRejectedMedia_Call

+ func (_c *RejectedMediaObserver_OnRejectedMedia_Call) Run(run func(ctx context.Context, found backup.FoundMedia, cause error)) *RejectedMediaObserver_OnRejectedMedia_Call

+ func (_c *RejectedMediaObserver_OnRejectedMedia_Call) RunAndReturn(run func(context.Context, backup.FoundMedia, error)) *RejectedMediaObserver_OnRejectedMedia_Call

type ScopeReadRepository

+ func (_m *ScopeReadRepository) FindScopesByIdCtx(ctx context.Context, ids ...aclcore.ScopeId) ([]*aclcore.Scope, error)

type ScopeReadRepository_Expecter

+ func (_e *ScopeReadRepository_Expecter) FindScopesByIdCtx(ctx interface{}, ids ...interface{}) *ScopeReadRepository_FindScopesByIdCtx_Call

+ type ScopeReadRepository_FindScopesByIdCtx_Call struct

+ func (_c *ScopeReadRepository_FindScopesByIdCtx_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopeReadRepository_FindScopesByIdCtx_Call

+ func (_c *ScopeReadRepository_FindScopesByIdCtx_Call) Run(run func(ctx context.Context, ids ...aclcore.ScopeId)) *ScopeReadRepository_FindScopesByIdCtx_Call

+ func (_c *ScopeReadRepository_FindScopesByIdCtx_Call) RunAndReturn(run func(context.Context, ...aclcore.ScopeId) ([]*aclcore.Scope, error)) *ScopeReadRepository_FindScopesByIdCtx_Call

v1.6.26

Oct 22, 2024

v1.6.23

Oct 19, 2024

v1.6.22

Oct 19, 2024

v1.6.21

Oct 19, 2024

v1.6.20

Oct 19, 2024

v1.6.19

Oct 19, 2024

v1.6.18

Aug 19, 2024

v1.6.15

Aug 8, 2024

v1.6.14

Aug 4, 2024

v1.6.13

Aug 4, 2024

v1.6.11

Jul 10, 2024

v1.6.10

Jul 9, 2024

v1.6.9

Jul 9, 2024

v1.6.8

Jul 8, 2024

v1.6.7

Jun 30, 2024

v1.6.6

Jun 27, 2024

v1.6.5

Jun 17, 2024

v1.6.4

Jun 15, 2024

Changes in this version

+ type AlbumDatesAmendedObserver struct

+ func NewAlbumDatesAmendedObserver(t interface{ ... }) *AlbumDatesAmendedObserver

+ func (_m *AlbumDatesAmendedObserver) EXPECT() *AlbumDatesAmendedObserver_Expecter

+ func (_m *AlbumDatesAmendedObserver) OnAlbumDatesAmended(ctx context.Context, amendedAlbum catalog.DatesUpdate) error

+ type AlbumDatesAmendedObserverFunc struct

+ func NewAlbumDatesAmendedObserverFunc(t interface{ ... }) *AlbumDatesAmendedObserverFunc

+ func (_m *AlbumDatesAmendedObserverFunc) EXPECT() *AlbumDatesAmendedObserverFunc_Expecter

+ func (_m *AlbumDatesAmendedObserverFunc) Execute(ctx context.Context, amendedAlbum catalog.DatesUpdate) error

+ type AlbumDatesAmendedObserverFunc_Execute_Call struct

+ func (_c *AlbumDatesAmendedObserverFunc_Execute_Call) Return(_a0 error) *AlbumDatesAmendedObserverFunc_Execute_Call

+ func (_c *AlbumDatesAmendedObserverFunc_Execute_Call) Run(run func(ctx context.Context, amendedAlbum catalog.DatesUpdate)) *AlbumDatesAmendedObserverFunc_Execute_Call

+ func (_c *AlbumDatesAmendedObserverFunc_Execute_Call) RunAndReturn(run func(context.Context, catalog.DatesUpdate) error) *AlbumDatesAmendedObserverFunc_Execute_Call

+ type AlbumDatesAmendedObserverFunc_Expecter struct

+ func (_e *AlbumDatesAmendedObserverFunc_Expecter) Execute(ctx interface{}, amendedAlbum interface{}) *AlbumDatesAmendedObserverFunc_Execute_Call

+ type AlbumDatesAmendedObserverWithTimeline struct

+ func NewAlbumDatesAmendedObserverWithTimeline(t interface{ ... }) *AlbumDatesAmendedObserverWithTimeline

+ func (_m *AlbumDatesAmendedObserverWithTimeline) EXPECT() *AlbumDatesAmendedObserverWithTimeline_Expecter

+ func (_m *AlbumDatesAmendedObserverWithTimeline) OnAlbumDatesAmendedWithTimeline(ctx context.Context, timeline *catalog.TimelineAggregate, ...) error

+ type AlbumDatesAmendedObserverWithTimeline_Expecter struct

+ func (_e *AlbumDatesAmendedObserverWithTimeline_Expecter) OnAlbumDatesAmendedWithTimeline(ctx interface{}, timeline interface{}, amendedAlbum interface{}) *AlbumDatesAmendedObserverWithTimeline_OnAlbumDatesAmendedWithTimeline_Call

+ type AlbumDatesAmendedObserverWithTimeline_OnAlbumDatesAmendedWithTimeline_Call struct

+ func (_c *AlbumDatesAmendedObserverWithTimeline_OnAlbumDatesAmendedWithTimeline_Call) Return(_a0 error) *AlbumDatesAmendedObserverWithTimeline_OnAlbumDatesAmendedWithTimeline_Call

+ func (_c *AlbumDatesAmendedObserverWithTimeline_OnAlbumDatesAmendedWithTimeline_Call) Run(run func(ctx context.Context, timeline *catalog.TimelineAggregate, ...)) *AlbumDatesAmendedObserverWithTimeline_OnAlbumDatesAmendedWithTimeline_Call

+ func (_c *AlbumDatesAmendedObserverWithTimeline_OnAlbumDatesAmendedWithTimeline_Call) RunAndReturn(...) *AlbumDatesAmendedObserverWithTimeline_OnAlbumDatesAmendedWithTimeline_Call

+ type AlbumDatesAmendedObserver_Expecter struct

+ func (_e *AlbumDatesAmendedObserver_Expecter) OnAlbumDatesAmended(ctx interface{}, amendedAlbum interface{}) *AlbumDatesAmendedObserver_OnAlbumDatesAmended_Call

+ type AlbumDatesAmendedObserver_OnAlbumDatesAmended_Call struct

+ func (_c *AlbumDatesAmendedObserver_OnAlbumDatesAmended_Call) Return(_a0 error) *AlbumDatesAmendedObserver_OnAlbumDatesAmended_Call

+ func (_c *AlbumDatesAmendedObserver_OnAlbumDatesAmended_Call) Run(run func(ctx context.Context, amendedAlbum catalog.DatesUpdate)) *AlbumDatesAmendedObserver_OnAlbumDatesAmended_Call

+ func (_c *AlbumDatesAmendedObserver_OnAlbumDatesAmended_Call) RunAndReturn(run func(context.Context, catalog.DatesUpdate) error) *AlbumDatesAmendedObserver_OnAlbumDatesAmended_Call

+ type AlbumLookupStrategy struct

+ func NewAlbumLookupStrategy(t interface{ ... }) *AlbumLookupStrategy

+ func (_m *AlbumLookupStrategy) EXPECT() *AlbumLookupStrategy_Expecter

+ func (_m *AlbumLookupStrategy) LookupAlbum(ctx context.Context, owner ownermodel.Owner, ...) (catalog.AlbumReference, error)

+ type AlbumLookupStrategy_Expecter struct

+ func (_e *AlbumLookupStrategy_Expecter) LookupAlbum(ctx interface{}, owner interface{}, timeline interface{}, ...) *AlbumLookupStrategy_LookupAlbum_Call

+ type AlbumLookupStrategy_LookupAlbum_Call struct

+ func (_c *AlbumLookupStrategy_LookupAlbum_Call) Return(_a0 catalog.AlbumReference, _a1 error) *AlbumLookupStrategy_LookupAlbum_Call

+ func (_c *AlbumLookupStrategy_LookupAlbum_Call) Run(run func(ctx context.Context, owner ownermodel.Owner, ...)) *AlbumLookupStrategy_LookupAlbum_Call

+ func (_c *AlbumLookupStrategy_LookupAlbum_Call) RunAndReturn(...) *AlbumLookupStrategy_LookupAlbum_Call

+ type AlbumSharedObserver struct

+ func NewAlbumSharedObserver(t interface{ ... }) *AlbumSharedObserver

+ func (_m *AlbumSharedObserver) AlbumShared(ctx context.Context, albumId catalog.AlbumId, userEmail usermodel.UserId) error

+ func (_m *AlbumSharedObserver) EXPECT() *AlbumSharedObserver_Expecter

+ type AlbumSharedObserver_AlbumShared_Call struct

+ func (_c *AlbumSharedObserver_AlbumShared_Call) Return(_a0 error) *AlbumSharedObserver_AlbumShared_Call

+ func (_c *AlbumSharedObserver_AlbumShared_Call) Run(...) *AlbumSharedObserver_AlbumShared_Call

+ func (_c *AlbumSharedObserver_AlbumShared_Call) RunAndReturn(run func(context.Context, catalog.AlbumId, usermodel.UserId) error) *AlbumSharedObserver_AlbumShared_Call

+ type AlbumSharedObserver_Expecter struct

+ func (_e *AlbumSharedObserver_Expecter) AlbumShared(ctx interface{}, albumId interface{}, userEmail interface{}) *AlbumSharedObserver_AlbumShared_Call

+ type AlbumUnSharedObserver struct

+ func NewAlbumUnSharedObserver(t interface{ ... }) *AlbumUnSharedObserver

+ func (_m *AlbumUnSharedObserver) AlbumUnShared(ctx context.Context, albumId catalog.AlbumId, userEmail usermodel.UserId) error

+ func (_m *AlbumUnSharedObserver) EXPECT() *AlbumUnSharedObserver_Expecter

+ type AlbumUnSharedObserver_AlbumUnShared_Call struct

+ func (_c *AlbumUnSharedObserver_AlbumUnShared_Call) Return(_a0 error) *AlbumUnSharedObserver_AlbumUnShared_Call

+ func (_c *AlbumUnSharedObserver_AlbumUnShared_Call) Run(...) *AlbumUnSharedObserver_AlbumUnShared_Call

+ func (_c *AlbumUnSharedObserver_AlbumUnShared_Call) RunAndReturn(run func(context.Context, catalog.AlbumId, usermodel.UserId) error) *AlbumUnSharedObserver_AlbumUnShared_Call

+ type AlbumUnSharedObserver_Expecter struct

+ func (_e *AlbumUnSharedObserver_Expecter) AlbumUnShared(ctx interface{}, albumId interface{}, userEmail interface{}) *AlbumUnSharedObserver_AlbumUnShared_Call

+ type AmendAlbumDatesWithTimeline struct

+ func NewAmendAlbumDatesWithTimeline(t interface{ ... }) *AmendAlbumDatesWithTimeline

+ func (_m *AmendAlbumDatesWithTimeline) AmendAlbumDates(ctx context.Context, timeline *catalog.TimelineAggregate, ...) error

+ func (_m *AmendAlbumDatesWithTimeline) EXPECT() *AmendAlbumDatesWithTimeline_Expecter

+ type AmendAlbumDatesWithTimeline_AmendAlbumDates_Call struct

+ func (_c *AmendAlbumDatesWithTimeline_AmendAlbumDates_Call) Return(_a0 error) *AmendAlbumDatesWithTimeline_AmendAlbumDates_Call

+ func (_c *AmendAlbumDatesWithTimeline_AmendAlbumDates_Call) Run(run func(ctx context.Context, timeline *catalog.TimelineAggregate, ...)) *AmendAlbumDatesWithTimeline_AmendAlbumDates_Call

+ func (_c *AmendAlbumDatesWithTimeline_AmendAlbumDates_Call) RunAndReturn(...) *AmendAlbumDatesWithTimeline_AmendAlbumDates_Call

+ type AmendAlbumDatesWithTimeline_Expecter struct

+ func (_e *AmendAlbumDatesWithTimeline_Expecter) AmendAlbumDates(ctx interface{}, timeline interface{}, albumId interface{}, start interface{}, ...) *AmendAlbumDatesWithTimeline_AmendAlbumDates_Call

+ type CatalogInsertMedia struct

+ func NewCatalogInsertMedia(t interface{ ... }) *CatalogInsertMedia

+ func (_m *CatalogInsertMedia) EXPECT() *CatalogInsertMedia_Expecter

+ func (_m *CatalogInsertMedia) Insert(ctx context.Context, owner ownermodel.Owner, ...) error

+ type CatalogInsertMedia_Expecter struct

+ func (_e *CatalogInsertMedia_Expecter) Insert(ctx interface{}, owner interface{}, medias interface{}) *CatalogInsertMedia_Insert_Call

+ type CatalogInsertMedia_Insert_Call struct

+ func (_c *CatalogInsertMedia_Insert_Call) Return(_a0 error) *CatalogInsertMedia_Insert_Call

+ func (_c *CatalogInsertMedia_Insert_Call) Run(run func(ctx context.Context, owner ownermodel.Owner, ...)) *CatalogInsertMedia_Insert_Call

+ func (_c *CatalogInsertMedia_Insert_Call) RunAndReturn(...) *CatalogInsertMedia_Insert_Call

type CatalogReference_Expecter

+ func (_e *CatalogReference_Expecter) UniqueIdentifier() *CatalogReference_UniqueIdentifier_Call

+ type CatalogReference_UniqueIdentifier_Call struct

+ func (_c *CatalogReference_UniqueIdentifier_Call) Return(_a0 string) *CatalogReference_UniqueIdentifier_Call

+ func (_c *CatalogReference_UniqueIdentifier_Call) Run(run func()) *CatalogReference_UniqueIdentifier_Call

+ func (_c *CatalogReference_UniqueIdentifier_Call) RunAndReturn(run func() string) *CatalogReference_UniqueIdentifier_Call

+ type CreateAlbumObserverWithTimeline struct

+ func NewCreateAlbumObserverWithTimeline(t interface{ ... }) *CreateAlbumObserverWithTimeline

+ func (_m *CreateAlbumObserverWithTimeline) EXPECT() *CreateAlbumObserverWithTimeline_Expecter

+ func (_m *CreateAlbumObserverWithTimeline) ObserveCreateAlbum(ctx context.Context, timeline *catalog.TimelineAggregate, ...) error

+ type CreateAlbumObserverWithTimeline_Expecter struct

+ func (_e *CreateAlbumObserverWithTimeline_Expecter) ObserveCreateAlbum(ctx interface{}, timeline interface{}, createdAlbum interface{}) *CreateAlbumObserverWithTimeline_ObserveCreateAlbum_Call

+ type CreateAlbumObserverWithTimeline_ObserveCreateAlbum_Call struct

+ func (_c *CreateAlbumObserverWithTimeline_ObserveCreateAlbum_Call) Return(_a0 error) *CreateAlbumObserverWithTimeline_ObserveCreateAlbum_Call

+ func (_c *CreateAlbumObserverWithTimeline_ObserveCreateAlbum_Call) Run(run func(ctx context.Context, timeline *catalog.TimelineAggregate, ...)) *CreateAlbumObserverWithTimeline_ObserveCreateAlbum_Call

+ func (_c *CreateAlbumObserverWithTimeline_ObserveCreateAlbum_Call) RunAndReturn(run func(context.Context, *catalog.TimelineAggregate, catalog.Album) error) *CreateAlbumObserverWithTimeline_ObserveCreateAlbum_Call

+ type CreateAlbumWithTimeline struct

+ func NewCreateAlbumWithTimeline(t interface{ ... }) *CreateAlbumWithTimeline

+ func (_m *CreateAlbumWithTimeline) Create(ctx context.Context, timeline *catalog.TimelineAggregate, ...) (*catalog.AlbumId, error)

+ func (_m *CreateAlbumWithTimeline) EXPECT() *CreateAlbumWithTimeline_Expecter

+ type CreateAlbumWithTimeline_Create_Call struct

+ func (_c *CreateAlbumWithTimeline_Create_Call) Return(_a0 *catalog.AlbumId, _a1 error) *CreateAlbumWithTimeline_Create_Call

+ func (_c *CreateAlbumWithTimeline_Create_Call) Run(run func(ctx context.Context, timeline *catalog.TimelineAggregate, ...)) *CreateAlbumWithTimeline_Create_Call

+ func (_c *CreateAlbumWithTimeline_Create_Call) RunAndReturn(...) *CreateAlbumWithTimeline_Create_Call

+ type CreateAlbumWithTimeline_Expecter struct

+ func (_e *CreateAlbumWithTimeline_Expecter) Create(ctx interface{}, timeline interface{}, request interface{}) *CreateAlbumWithTimeline_Create_Call

+ type FindAlbumPort struct

+ func NewFindAlbumPort(t interface{ ... }) *FindAlbumPort

+ func (_m *FindAlbumPort) EXPECT() *FindAlbumPort_Expecter

+ func (_m *FindAlbumPort) FindAlbum(ctx context.Context, albumId catalog.AlbumId) (*catalog.Album, error)

+ type FindAlbumPort_Expecter struct

+ func (_e *FindAlbumPort_Expecter) FindAlbum(ctx interface{}, albumId interface{}) *FindAlbumPort_FindAlbum_Call

+ type FindAlbumPort_FindAlbum_Call struct

+ func (_c *FindAlbumPort_FindAlbum_Call) Return(_a0 *catalog.Album, _a1 error) *FindAlbumPort_FindAlbum_Call

+ func (_c *FindAlbumPort_FindAlbum_Call) Run(run func(ctx context.Context, albumId catalog.AlbumId)) *FindAlbumPort_FindAlbum_Call

+ func (_c *FindAlbumPort_FindAlbum_Call) RunAndReturn(run func(context.Context, catalog.AlbumId) (*catalog.Album, error)) *FindAlbumPort_FindAlbum_Call

+ type GetAvailabilitiesByUserFunc struct

+ func NewGetAvailabilitiesByUserFunc(t interface{ ... }) *GetAvailabilitiesByUserFunc

+ func (_m *GetAvailabilitiesByUserFunc) EXPECT() *GetAvailabilitiesByUserFunc_Expecter

+ func (_m *GetAvailabilitiesByUserFunc) Execute(ctx context.Context, user usermodel.UserId) ([]catalogviews.AlbumSize, error)

+ type GetAvailabilitiesByUserFunc_Execute_Call struct

+ func (_c *GetAvailabilitiesByUserFunc_Execute_Call) Return(_a0 []catalogviews.AlbumSize, _a1 error) *GetAvailabilitiesByUserFunc_Execute_Call

+ func (_c *GetAvailabilitiesByUserFunc_Execute_Call) Run(run func(ctx context.Context, user usermodel.UserId)) *GetAvailabilitiesByUserFunc_Execute_Call

+ func (_c *GetAvailabilitiesByUserFunc_Execute_Call) RunAndReturn(run func(context.Context, usermodel.UserId) ([]catalogviews.AlbumSize, error)) *GetAvailabilitiesByUserFunc_Execute_Call

+ type GetAvailabilitiesByUserFunc_Expecter struct

+ func (_e *GetAvailabilitiesByUserFunc_Expecter) Execute(ctx interface{}, user interface{}) *GetAvailabilitiesByUserFunc_Execute_Call

+ type GetAvailabilitiesByUserPort struct

+ func NewGetAvailabilitiesByUserPort(t interface{ ... }) *GetAvailabilitiesByUserPort

+ func (_m *GetAvailabilitiesByUserPort) EXPECT() *GetAvailabilitiesByUserPort_Expecter

+ func (_m *GetAvailabilitiesByUserPort) GetAvailabilitiesByUser(ctx context.Context, user usermodel.UserId) ([]catalogviews.AlbumSize, error)

+ type GetAvailabilitiesByUserPort_Expecter struct

+ func (_e *GetAvailabilitiesByUserPort_Expecter) GetAvailabilitiesByUser(ctx interface{}, user interface{}) *GetAvailabilitiesByUserPort_GetAvailabilitiesByUser_Call

+ type GetAvailabilitiesByUserPort_GetAvailabilitiesByUser_Call struct

+ func (_c *GetAvailabilitiesByUserPort_GetAvailabilitiesByUser_Call) Return(_a0 []catalogviews.AlbumSize, _a1 error) *GetAvailabilitiesByUserPort_GetAvailabilitiesByUser_Call

+ func (_c *GetAvailabilitiesByUserPort_GetAvailabilitiesByUser_Call) Run(run func(ctx context.Context, user usermodel.UserId)) *GetAvailabilitiesByUserPort_GetAvailabilitiesByUser_Call

+ func (_c *GetAvailabilitiesByUserPort_GetAvailabilitiesByUser_Call) RunAndReturn(run func(context.Context, usermodel.UserId) ([]catalogviews.AlbumSize, error)) *GetAvailabilitiesByUserPort_GetAvailabilitiesByUser_Call

+ type InsertMediaPort struct

+ func NewInsertMediaPort(t interface{ ... }) *InsertMediaPort

+ func (_m *InsertMediaPort) EXPECT() *InsertMediaPort_Expecter

+ func (_m *InsertMediaPort) IndexMedias(ctx context.Context, owner ownermodel.Owner, ...) error

+ type InsertMediaPort_Expecter struct

+ func (_e *InsertMediaPort_Expecter) IndexMedias(ctx interface{}, owner interface{}, requests interface{}) *InsertMediaPort_IndexMedias_Call

+ type InsertMediaPort_IndexMedias_Call struct

+ func (_c *InsertMediaPort_IndexMedias_Call) Return(_a0 error) *InsertMediaPort_IndexMedias_Call

+ func (_c *InsertMediaPort_IndexMedias_Call) Run(run func(ctx context.Context, owner ownermodel.Owner, ...)) *InsertMediaPort_IndexMedias_Call

+ func (_c *InsertMediaPort_IndexMedias_Call) RunAndReturn(...) *InsertMediaPort_IndexMedias_Call

+ type ListUserWhoCanAccessAlbumPort struct

+ func NewListUserWhoCanAccessAlbumPort(t interface{ ... }) *ListUserWhoCanAccessAlbumPort

+ func (_m *ListUserWhoCanAccessAlbumPort) EXPECT() *ListUserWhoCanAccessAlbumPort_Expecter

+ func (_m *ListUserWhoCanAccessAlbumPort) ListUsersWhoCanAccessAlbum(ctx context.Context, albumId ...catalog.AlbumId) (map[catalog.AlbumId][]catalogviews.Availability, error)

+ type ListUserWhoCanAccessAlbumPort_Expecter struct

+ func (_e *ListUserWhoCanAccessAlbumPort_Expecter) ListUsersWhoCanAccessAlbum(ctx interface{}, albumId ...interface{}) *ListUserWhoCanAccessAlbumPort_ListUsersWhoCanAccessAlbum_Call

+ type ListUserWhoCanAccessAlbumPort_ListUsersWhoCanAccessAlbum_Call struct

+ func (_c *ListUserWhoCanAccessAlbumPort_ListUsersWhoCanAccessAlbum_Call) Return(_a0 map[catalog.AlbumId][]catalogviews.Availability, _a1 error) *ListUserWhoCanAccessAlbumPort_ListUsersWhoCanAccessAlbum_Call

+ func (_c *ListUserWhoCanAccessAlbumPort_ListUsersWhoCanAccessAlbum_Call) Run(run func(ctx context.Context, albumId ...catalog.AlbumId)) *ListUserWhoCanAccessAlbumPort_ListUsersWhoCanAccessAlbum_Call

+ func (_c *ListUserWhoCanAccessAlbumPort_ListUsersWhoCanAccessAlbum_Call) RunAndReturn(...) *ListUserWhoCanAccessAlbumPort_ListUsersWhoCanAccessAlbum_Call

+ type ProviderFactory struct

+ func NewProviderFactory(t interface{ ... }) *ProviderFactory

+ func (_m *ProviderFactory) EXPECT() *ProviderFactory_Expecter

+ func (_m *ProviderFactory) NewProvider(ctx context.Context, mediaCounterPort catalogviews.MediaCounterPort) catalogviews.ListAlbumsProvider

+ type ProviderFactoryFunc struct

+ func NewProviderFactoryFunc(t interface{ ... }) *ProviderFactoryFunc

+ func (_m *ProviderFactoryFunc) EXPECT() *ProviderFactoryFunc_Expecter

+ func (_m *ProviderFactoryFunc) Execute(ctx context.Context, mediaCounterPort catalogviews.MediaCounterPort) catalogviews.ListAlbumsProvider

+ type ProviderFactoryFunc_Execute_Call struct

+ func (_c *ProviderFactoryFunc_Execute_Call) Return(_a0 catalogviews.ListAlbumsProvider) *ProviderFactoryFunc_Execute_Call

+ func (_c *ProviderFactoryFunc_Execute_Call) Run(run func(ctx context.Context, mediaCounterPort catalogviews.MediaCounterPort)) *ProviderFactoryFunc_Execute_Call

+ func (_c *ProviderFactoryFunc_Execute_Call) RunAndReturn(...) *ProviderFactoryFunc_Execute_Call

+ type ProviderFactoryFunc_Expecter struct

+ func (_e *ProviderFactoryFunc_Expecter) Execute(ctx interface{}, mediaCounterPort interface{}) *ProviderFactoryFunc_Execute_Call

+ type ProviderFactory_Expecter struct

+ func (_e *ProviderFactory_Expecter) NewProvider(ctx interface{}, mediaCounterPort interface{}) *ProviderFactory_NewProvider_Call

+ type ProviderFactory_NewProvider_Call struct

+ func (_c *ProviderFactory_NewProvider_Call) Return(_a0 catalogviews.ListAlbumsProvider) *ProviderFactory_NewProvider_Call

+ func (_c *ProviderFactory_NewProvider_Call) Run(run func(ctx context.Context, mediaCounterPort catalogviews.MediaCounterPort)) *ProviderFactory_NewProvider_Call

+ func (_c *ProviderFactory_NewProvider_Call) RunAndReturn(...) *ProviderFactory_NewProvider_Call

+ type RunnerUploader struct

+ func NewRunnerUploader(t interface{ ... }) *RunnerUploader

+ func (_m *RunnerUploader) EXPECT() *RunnerUploader_Expecter

+ func (_m *RunnerUploader) Upload(buffer []*backup.BackingUpMediaRequest, ...) error

+ type RunnerUploaderFunc struct

+ func NewRunnerUploaderFunc(t interface{ ... }) *RunnerUploaderFunc

+ func (_m *RunnerUploaderFunc) EXPECT() *RunnerUploaderFunc_Expecter

+ func (_m *RunnerUploaderFunc) Execute(buffer []*backup.BackingUpMediaRequest, ...) error

+ type RunnerUploaderFunc_Execute_Call struct

+ func (_c *RunnerUploaderFunc_Execute_Call) Return(_a0 error) *RunnerUploaderFunc_Execute_Call

+ func (_c *RunnerUploaderFunc_Execute_Call) Run(run func(buffer []*backup.BackingUpMediaRequest, ...)) *RunnerUploaderFunc_Execute_Call

+ func (_c *RunnerUploaderFunc_Execute_Call) RunAndReturn(run func([]*backup.BackingUpMediaRequest, chan *backup.ProgressEvent) error) *RunnerUploaderFunc_Execute_Call

+ type RunnerUploaderFunc_Expecter struct

+ func (_e *RunnerUploaderFunc_Expecter) Execute(buffer interface{}, progressChannel interface{}) *RunnerUploaderFunc_Execute_Call

+ type RunnerUploader_Expecter struct

+ func (_e *RunnerUploader_Expecter) Upload(buffer interface{}, progressChannel interface{}) *RunnerUploader_Upload_Call

+ type RunnerUploader_Upload_Call struct

+ func (_c *RunnerUploader_Upload_Call) Return(_a0 error) *RunnerUploader_Upload_Call

+ func (_c *RunnerUploader_Upload_Call) Run(run func(buffer []*backup.BackingUpMediaRequest, ...)) *RunnerUploader_Upload_Call

+ func (_c *RunnerUploader_Upload_Call) RunAndReturn(run func([]*backup.BackingUpMediaRequest, chan *backup.ProgressEvent) error) *RunnerUploader_Upload_Call

type TimelineMutationObserver

+ func (_m *TimelineMutationObserver) OnTransferredMedias(ctx context.Context, transfers catalog.TransferredMedias) error

type TimelineMutationObserver_Expecter

+ func (_e *TimelineMutationObserver_Expecter) OnTransferredMedias(ctx interface{}, transfers interface{}) *TimelineMutationObserver_OnTransferredMedias_Call

+ type TimelineMutationObserver_OnTransferredMedias_Call struct

+ func (_c *TimelineMutationObserver_OnTransferredMedias_Call) Return(_a0 error) *TimelineMutationObserver_OnTransferredMedias_Call

+ func (_c *TimelineMutationObserver_OnTransferredMedias_Call) Run(run func(ctx context.Context, transfers catalog.TransferredMedias)) *TimelineMutationObserver_OnTransferredMedias_Call

+ func (_c *TimelineMutationObserver_OnTransferredMedias_Call) RunAndReturn(run func(context.Context, catalog.TransferredMedias) error) *TimelineMutationObserver_OnTransferredMedias_Call

+ type ViewWriteRepository struct

+ func NewViewWriteRepository(t interface{ ... }) *ViewWriteRepository

+ func (_m *ViewWriteRepository) DeleteAlbumSize(ctx context.Context, availability catalogviews.Availability, ...) error

+ func (_m *ViewWriteRepository) EXPECT() *ViewWriteRepository_Expecter

+ func (_m *ViewWriteRepository) InsertAlbumSize(ctx context.Context, albumSize []catalogviews.AlbumSize) error

+ func (_m *ViewWriteRepository) UpdateAlbumSize(ctx context.Context, albumCountUpdates []catalogviews.AlbumSizeDiff) error

+ type ViewWriteRepository_DeleteAlbumSize_Call struct

+ func (_c *ViewWriteRepository_DeleteAlbumSize_Call) Return(_a0 error) *ViewWriteRepository_DeleteAlbumSize_Call

+ func (_c *ViewWriteRepository_DeleteAlbumSize_Call) Run(run func(ctx context.Context, availability catalogviews.Availability, ...)) *ViewWriteRepository_DeleteAlbumSize_Call

+ func (_c *ViewWriteRepository_DeleteAlbumSize_Call) RunAndReturn(run func(context.Context, catalogviews.Availability, catalog.AlbumId) error) *ViewWriteRepository_DeleteAlbumSize_Call

+ type ViewWriteRepository_Expecter struct

+ func (_e *ViewWriteRepository_Expecter) DeleteAlbumSize(ctx interface{}, availability interface{}, albumId interface{}) *ViewWriteRepository_DeleteAlbumSize_Call

+ func (_e *ViewWriteRepository_Expecter) InsertAlbumSize(ctx interface{}, albumSize interface{}) *ViewWriteRepository_InsertAlbumSize_Call

+ func (_e *ViewWriteRepository_Expecter) UpdateAlbumSize(ctx interface{}, albumCountUpdates interface{}) *ViewWriteRepository_UpdateAlbumSize_Call

+ type ViewWriteRepository_InsertAlbumSize_Call struct

+ func (_c *ViewWriteRepository_InsertAlbumSize_Call) Return(_a0 error) *ViewWriteRepository_InsertAlbumSize_Call

+ func (_c *ViewWriteRepository_InsertAlbumSize_Call) Run(run func(ctx context.Context, albumSize []catalogviews.AlbumSize)) *ViewWriteRepository_InsertAlbumSize_Call

+ func (_c *ViewWriteRepository_InsertAlbumSize_Call) RunAndReturn(run func(context.Context, []catalogviews.AlbumSize) error) *ViewWriteRepository_InsertAlbumSize_Call

+ type ViewWriteRepository_UpdateAlbumSize_Call struct

+ func (_c *ViewWriteRepository_UpdateAlbumSize_Call) Return(_a0 error) *ViewWriteRepository_UpdateAlbumSize_Call

+ func (_c *ViewWriteRepository_UpdateAlbumSize_Call) Run(run func(ctx context.Context, albumCountUpdates []catalogviews.AlbumSizeDiff)) *ViewWriteRepository_UpdateAlbumSize_Call

+ func (_c *ViewWriteRepository_UpdateAlbumSize_Call) RunAndReturn(run func(context.Context, []catalogviews.AlbumSizeDiff) error) *ViewWriteRepository_UpdateAlbumSize_Call

v1.5.58

Jun 3, 2024

v1.5.57

Jun 1, 2024

Changes in this version

type CatalogReference

+ func (_m *CatalogReference) UniqueIdentifier() string

v1.5.54

May 31, 2024

Changes in this version

+ type AlbumLookupPort struct

+ func NewAlbumLookupPort(t interface{ ... }) *AlbumLookupPort

+ func (_m *AlbumLookupPort) EXPECT() *AlbumLookupPort_Expecter

+ func (_m *AlbumLookupPort) FindOrCreateAlbum(owner ownermodel.Owner, mediaTime time.Time) (string, bool, error)

+ type AlbumLookupPort_Expecter struct

+ func (_e *AlbumLookupPort_Expecter) FindOrCreateAlbum(owner interface{}, mediaTime interface{}) *AlbumLookupPort_FindOrCreateAlbum_Call

+ type AlbumLookupPort_FindOrCreateAlbum_Call struct

+ func (_c *AlbumLookupPort_FindOrCreateAlbum_Call) Return(folderName string, created bool, err error) *AlbumLookupPort_FindOrCreateAlbum_Call

+ func (_c *AlbumLookupPort_FindOrCreateAlbum_Call) Run(run func(owner ownermodel.Owner, mediaTime time.Time)) *AlbumLookupPort_FindOrCreateAlbum_Call

+ func (_c *AlbumLookupPort_FindOrCreateAlbum_Call) RunAndReturn(run func(ownermodel.Owner, time.Time) (string, bool, error)) *AlbumLookupPort_FindOrCreateAlbum_Call

+ type AutoCreateAlbumObserver struct

+ func NewAutoCreateAlbumObserver(t interface{ ... }) *AutoCreateAlbumObserver

+ func (_m *AutoCreateAlbumObserver) Create(ctx context.Context, request catalog.CreateAlbumRequest) (*catalog.AlbumId, error)

+ func (_m *AutoCreateAlbumObserver) EXPECT() *AutoCreateAlbumObserver_Expecter

+ type AutoCreateAlbumObserver_Create_Call struct

+ func (_c *AutoCreateAlbumObserver_Create_Call) Return(_a0 *catalog.AlbumId, _a1 error) *AutoCreateAlbumObserver_Create_Call

+ func (_c *AutoCreateAlbumObserver_Create_Call) Run(run func(ctx context.Context, request catalog.CreateAlbumRequest)) *AutoCreateAlbumObserver_Create_Call

+ func (_c *AutoCreateAlbumObserver_Create_Call) RunAndReturn(...) *AutoCreateAlbumObserver_Create_Call

+ type AutoCreateAlbumObserver_Expecter struct

+ func (_e *AutoCreateAlbumObserver_Expecter) Create(ctx interface{}, request interface{}) *AutoCreateAlbumObserver_Create_Call

+ type CatalogReference struct

+ func NewCatalogReference(t interface{ ... }) *CatalogReference

+ func (_m *CatalogReference) AlbumCreated() bool

+ func (_m *CatalogReference) AlbumFolderName() string

+ func (_m *CatalogReference) EXPECT() *CatalogReference_Expecter

+ func (_m *CatalogReference) Exists() bool

+ func (_m *CatalogReference) MediaId() string

+ type CatalogReference_AlbumCreated_Call struct

+ func (_c *CatalogReference_AlbumCreated_Call) Return(_a0 bool) *CatalogReference_AlbumCreated_Call

+ func (_c *CatalogReference_AlbumCreated_Call) Run(run func()) *CatalogReference_AlbumCreated_Call

+ func (_c *CatalogReference_AlbumCreated_Call) RunAndReturn(run func() bool) *CatalogReference_AlbumCreated_Call

+ type CatalogReference_AlbumFolderName_Call struct

+ func (_c *CatalogReference_AlbumFolderName_Call) Return(_a0 string) *CatalogReference_AlbumFolderName_Call

+ func (_c *CatalogReference_AlbumFolderName_Call) Run(run func()) *CatalogReference_AlbumFolderName_Call

+ func (_c *CatalogReference_AlbumFolderName_Call) RunAndReturn(run func() string) *CatalogReference_AlbumFolderName_Call

+ type CatalogReference_Exists_Call struct

+ func (_c *CatalogReference_Exists_Call) Return(_a0 bool) *CatalogReference_Exists_Call

+ func (_c *CatalogReference_Exists_Call) Run(run func()) *CatalogReference_Exists_Call

+ func (_c *CatalogReference_Exists_Call) RunAndReturn(run func() bool) *CatalogReference_Exists_Call

+ type CatalogReference_Expecter struct

+ func (_e *CatalogReference_Expecter) AlbumCreated() *CatalogReference_AlbumCreated_Call

+ func (_e *CatalogReference_Expecter) AlbumFolderName() *CatalogReference_AlbumFolderName_Call

+ func (_e *CatalogReference_Expecter) Exists() *CatalogReference_Exists_Call

+ func (_e *CatalogReference_Expecter) MediaId() *CatalogReference_MediaId_Call

+ type CatalogReference_MediaId_Call struct

+ func (_c *CatalogReference_MediaId_Call) Return(_a0 string) *CatalogReference_MediaId_Call

+ func (_c *CatalogReference_MediaId_Call) Run(run func()) *CatalogReference_MediaId_Call

+ func (_c *CatalogReference_MediaId_Call) RunAndReturn(run func() string) *CatalogReference_MediaId_Call

+ type CatalogReferencer struct

+ func NewCatalogReferencer(t interface{ ... }) *CatalogReferencer

+ func (_m *CatalogReferencer) EXPECT() *CatalogReferencer_Expecter

+ func (_m *CatalogReferencer) Reference(ctx context.Context, medias []*backup.AnalysedMedia) (map[*backup.AnalysedMedia]backup.CatalogReference, error)

+ type CatalogReferencer_Expecter struct

+ func (_e *CatalogReferencer_Expecter) Reference(ctx interface{}, medias interface{}) *CatalogReferencer_Reference_Call

+ type CatalogReferencer_Reference_Call struct

+ func (_c *CatalogReferencer_Reference_Call) Return(_a0 map[*backup.AnalysedMedia]backup.CatalogReference, _a1 error) *CatalogReferencer_Reference_Call

+ func (_c *CatalogReferencer_Reference_Call) Run(run func(ctx context.Context, medias []*backup.AnalysedMedia)) *CatalogReferencer_Reference_Call

+ func (_c *CatalogReferencer_Reference_Call) RunAndReturn(...) *CatalogReferencer_Reference_Call

+ type CatalogerFilter struct

+ func NewCatalogerFilter(t interface{ ... }) *CatalogerFilter

+ func (_m *CatalogerFilter) EXPECT() *CatalogerFilter_Expecter

+ func (_m *CatalogerFilter) FilterOut(media backup.AnalysedMedia, reference backup.CatalogReference) (backup.ProgressEventType, bool)

+ type CatalogerFilterFunc struct

+ func NewCatalogerFilterFunc(t interface{ ... }) *CatalogerFilterFunc

+ func (_m *CatalogerFilterFunc) EXPECT() *CatalogerFilterFunc_Expecter

+ func (_m *CatalogerFilterFunc) Execute(media backup.AnalysedMedia, reference backup.CatalogReference) (backup.ProgressEventType, bool)

+ type CatalogerFilterFunc_Execute_Call struct

+ func (_c *CatalogerFilterFunc_Execute_Call) Return(_a0 backup.ProgressEventType, _a1 bool) *CatalogerFilterFunc_Execute_Call

+ func (_c *CatalogerFilterFunc_Execute_Call) Run(run func(media backup.AnalysedMedia, reference backup.CatalogReference)) *CatalogerFilterFunc_Execute_Call

+ func (_c *CatalogerFilterFunc_Execute_Call) RunAndReturn(...) *CatalogerFilterFunc_Execute_Call

+ type CatalogerFilterFunc_Expecter struct

+ func (_e *CatalogerFilterFunc_Expecter) Execute(media interface{}, reference interface{}) *CatalogerFilterFunc_Execute_Call

+ type CatalogerFilter_Expecter struct

+ func (_e *CatalogerFilter_Expecter) FilterOut(media interface{}, reference interface{}) *CatalogerFilter_FilterOut_Call

+ type CatalogerFilter_FilterOut_Call struct

+ func (_c *CatalogerFilter_FilterOut_Call) Return(_a0 backup.ProgressEventType, _a1 bool) *CatalogerFilter_FilterOut_Call

+ func (_c *CatalogerFilter_FilterOut_Call) Run(run func(media backup.AnalysedMedia, reference backup.CatalogReference)) *CatalogerFilter_FilterOut_Call

+ func (_c *CatalogerFilter_FilterOut_Call) RunAndReturn(...) *CatalogerFilter_FilterOut_Call

+ type FindExistingSignaturePort struct

+ func NewFindExistingSignaturePort(t interface{ ... }) *FindExistingSignaturePort

+ func (_m *FindExistingSignaturePort) EXPECT() *FindExistingSignaturePort_Expecter

+ func (_m *FindExistingSignaturePort) FindSignatures(ctx context.Context, owner ownermodel.Owner, ...) (map[catalog.MediaSignature]catalog.MediaId, error)

+ type FindExistingSignaturePort_Expecter struct

+ func (_e *FindExistingSignaturePort_Expecter) FindSignatures(ctx interface{}, owner interface{}, signatures interface{}) *FindExistingSignaturePort_FindSignatures_Call

+ type FindExistingSignaturePort_FindSignatures_Call struct

+ func (_c *FindExistingSignaturePort_FindSignatures_Call) Return(_a0 map[catalog.MediaSignature]catalog.MediaId, _a1 error) *FindExistingSignaturePort_FindSignatures_Call

+ func (_c *FindExistingSignaturePort_FindSignatures_Call) Run(run func(ctx context.Context, owner ownermodel.Owner, ...)) *FindExistingSignaturePort_FindSignatures_Call

+ func (_c *FindExistingSignaturePort_FindSignatures_Call) RunAndReturn(...) *FindExistingSignaturePort_FindSignatures_Call

+ type InsertMediaSimulator struct

+ func NewInsertMediaSimulator(t interface{ ... }) *InsertMediaSimulator

+ func (_m *InsertMediaSimulator) EXPECT() *InsertMediaSimulator_Expecter

+ func (_m *InsertMediaSimulator) SimulateInsertingMedia(ctx context.Context, owner ownermodel.Owner, ...) ([]catalog.MediaFutureReference, error)

+ type InsertMediaSimulator_Expecter struct

+ func (_e *InsertMediaSimulator_Expecter) SimulateInsertingMedia(ctx interface{}, owner interface{}, signatures interface{}) *InsertMediaSimulator_SimulateInsertingMedia_Call

+ type InsertMediaSimulator_SimulateInsertingMedia_Call struct

+ func (_c *InsertMediaSimulator_SimulateInsertingMedia_Call) Return(_a0 []catalog.MediaFutureReference, _a1 error) *InsertMediaSimulator_SimulateInsertingMedia_Call

+ func (_c *InsertMediaSimulator_SimulateInsertingMedia_Call) Run(run func(ctx context.Context, owner ownermodel.Owner, ...)) *InsertMediaSimulator_SimulateInsertingMedia_Call

+ func (_c *InsertMediaSimulator_SimulateInsertingMedia_Call) RunAndReturn(...) *InsertMediaSimulator_SimulateInsertingMedia_Call

+ type ReferencerFactory struct

+ func NewReferencerFactory(t interface{ ... }) *ReferencerFactory

+ func (_m *ReferencerFactory) EXPECT() *ReferencerFactory_Expecter

+ func (_m *ReferencerFactory) NewCreatorReferencer(ctx context.Context, owner ownermodel.Owner) (backup.CatalogReferencer, error)

+ func (_m *ReferencerFactory) NewDryRunReferencer(ctx context.Context, owner string) (backup.CatalogReferencer, error)

+ type ReferencerFactory_Expecter struct

+ func (_e *ReferencerFactory_Expecter) NewCreatorReferencer(ctx interface{}, owner interface{}) *ReferencerFactory_NewCreatorReferencer_Call

+ func (_e *ReferencerFactory_Expecter) NewDryRunReferencer(ctx interface{}, owner interface{}) *ReferencerFactory_NewDryRunReferencer_Call

+ type ReferencerFactory_NewCreatorReferencer_Call struct

+ func (_c *ReferencerFactory_NewCreatorReferencer_Call) Return(_a0 backup.CatalogReferencer, _a1 error) *ReferencerFactory_NewCreatorReferencer_Call

+ func (_c *ReferencerFactory_NewCreatorReferencer_Call) Run(run func(ctx context.Context, owner ownermodel.Owner)) *ReferencerFactory_NewCreatorReferencer_Call

+ func (_c *ReferencerFactory_NewCreatorReferencer_Call) RunAndReturn(run func(context.Context, ownermodel.Owner) (backup.CatalogReferencer, error)) *ReferencerFactory_NewCreatorReferencer_Call

+ type ReferencerFactory_NewDryRunReferencer_Call struct

+ func (_c *ReferencerFactory_NewDryRunReferencer_Call) Return(_a0 backup.CatalogReferencer, _a1 error) *ReferencerFactory_NewDryRunReferencer_Call

+ func (_c *ReferencerFactory_NewDryRunReferencer_Call) Run(run func(ctx context.Context, owner string)) *ReferencerFactory_NewDryRunReferencer_Call

+ func (_c *ReferencerFactory_NewDryRunReferencer_Call) RunAndReturn(run func(context.Context, string) (backup.CatalogReferencer, error)) *ReferencerFactory_NewDryRunReferencer_Call

+ type RunnerCataloger struct

+ func NewRunnerCataloger(t interface{ ... }) *RunnerCataloger

+ func (_m *RunnerCataloger) Catalog(ctx context.Context, medias []*backup.AnalysedMedia, ...) ([]*backup.BackingUpMediaRequest, error)

+ func (_m *RunnerCataloger) EXPECT() *RunnerCataloger_Expecter

+ type RunnerCatalogerFunc struct

+ func NewRunnerCatalogerFunc(t interface{ ... }) *RunnerCatalogerFunc

+ func (_m *RunnerCatalogerFunc) EXPECT() *RunnerCatalogerFunc_Expecter

+ func (_m *RunnerCatalogerFunc) Execute(ctx context.Context, medias []*backup.AnalysedMedia, ...) ([]*backup.BackingUpMediaRequest, error)

+ type RunnerCatalogerFunc_Execute_Call struct

+ func (_c *RunnerCatalogerFunc_Execute_Call) Return(_a0 []*backup.BackingUpMediaRequest, _a1 error) *RunnerCatalogerFunc_Execute_Call

+ func (_c *RunnerCatalogerFunc_Execute_Call) Run(run func(ctx context.Context, medias []*backup.AnalysedMedia, ...)) *RunnerCatalogerFunc_Execute_Call

+ func (_c *RunnerCatalogerFunc_Execute_Call) RunAndReturn(...) *RunnerCatalogerFunc_Execute_Call

+ type RunnerCatalogerFunc_Expecter struct

+ func (_e *RunnerCatalogerFunc_Expecter) Execute(ctx interface{}, medias interface{}, progressChannel interface{}) *RunnerCatalogerFunc_Execute_Call

+ type RunnerCataloger_Catalog_Call struct

+ func (_c *RunnerCataloger_Catalog_Call) Return(_a0 []*backup.BackingUpMediaRequest, _a1 error) *RunnerCataloger_Catalog_Call

+ func (_c *RunnerCataloger_Catalog_Call) Run(run func(ctx context.Context, medias []*backup.AnalysedMedia, ...)) *RunnerCataloger_Catalog_Call

+ func (_c *RunnerCataloger_Catalog_Call) RunAndReturn(...) *RunnerCataloger_Catalog_Call

+ type RunnerCataloger_Expecter struct

+ func (_e *RunnerCataloger_Expecter) Catalog(ctx interface{}, medias interface{}, progressChannel interface{}) *RunnerCataloger_Catalog_Call

+ type StatefulAlbumReferencer struct

+ func NewStatefulAlbumReferencer(t interface{ ... }) *StatefulAlbumReferencer

+ func (_m *StatefulAlbumReferencer) EXPECT() *StatefulAlbumReferencer_Expecter

+ func (_m *StatefulAlbumReferencer) FindReference(ctx context.Context, mediaTime time.Time) (catalog.AlbumReference, error)

+ type StatefulAlbumReferencer_Expecter struct

+ func (_e *StatefulAlbumReferencer_Expecter) FindReference(ctx interface{}, mediaTime interface{}) *StatefulAlbumReferencer_FindReference_Call

+ type StatefulAlbumReferencer_FindReference_Call struct

+ func (_c *StatefulAlbumReferencer_FindReference_Call) Return(_a0 catalog.AlbumReference, _a1 error) *StatefulAlbumReferencer_FindReference_Call

+ func (_c *StatefulAlbumReferencer_FindReference_Call) Run(run func(ctx context.Context, mediaTime time.Time)) *StatefulAlbumReferencer_FindReference_Call

+ func (_c *StatefulAlbumReferencer_FindReference_Call) RunAndReturn(run func(context.Context, time.Time) (catalog.AlbumReference, error)) *StatefulAlbumReferencer_FindReference_Call

v1.5.53

May 23, 2024

v1.5.50

May 18, 2024

Changes in this version

+ type MediaCounterFunc struct

+ func NewMediaCounterFunc(t interface{ ... }) *MediaCounterFunc

+ func (_m *MediaCounterFunc) EXPECT() *MediaCounterFunc_Expecter

+ func (_m *MediaCounterFunc) Execute(ctx context.Context, album ...catalog.AlbumId) (map[catalog.AlbumId]int, error)

+ type MediaCounterFunc_Execute_Call struct

+ func (_c *MediaCounterFunc_Execute_Call) Return(_a0 map[catalog.AlbumId]int, _a1 error) *MediaCounterFunc_Execute_Call

+ func (_c *MediaCounterFunc_Execute_Call) Run(run func(ctx context.Context, album ...catalog.AlbumId)) *MediaCounterFunc_Execute_Call

+ func (_c *MediaCounterFunc_Execute_Call) RunAndReturn(run func(context.Context, ...catalog.AlbumId) (map[catalog.AlbumId]int, error)) *MediaCounterFunc_Execute_Call

+ type MediaCounterFunc_Expecter struct

+ func (_e *MediaCounterFunc_Expecter) Execute(ctx interface{}, album ...interface{}) *MediaCounterFunc_Execute_Call

+ type MediaCounterPort struct

+ func NewMediaCounterPort(t interface{ ... }) *MediaCounterPort

+ func (_m *MediaCounterPort) CountMedia(ctx context.Context, album ...catalog.AlbumId) (map[catalog.AlbumId]int, error)

+ func (_m *MediaCounterPort) EXPECT() *MediaCounterPort_Expecter

+ type MediaCounterPort_CountMedia_Call struct

+ func (_c *MediaCounterPort_CountMedia_Call) Return(_a0 map[catalog.AlbumId]int, _a1 error) *MediaCounterPort_CountMedia_Call

+ func (_c *MediaCounterPort_CountMedia_Call) Run(run func(ctx context.Context, album ...catalog.AlbumId)) *MediaCounterPort_CountMedia_Call

+ func (_c *MediaCounterPort_CountMedia_Call) RunAndReturn(run func(context.Context, ...catalog.AlbumId) (map[catalog.AlbumId]int, error)) *MediaCounterPort_CountMedia_Call

+ type MediaCounterPort_Expecter struct

+ func (_e *MediaCounterPort_Expecter) CountMedia(ctx interface{}, album ...interface{}) *MediaCounterPort_CountMedia_Call

type RepositoryAdapter

+ func (_m *RepositoryAdapter) CountMedia(ctx context.Context, album ...catalog.AlbumId) (map[catalog.AlbumId]int, error)

+ type RepositoryAdapter_CountMedia_Call struct

+ func (_c *RepositoryAdapter_CountMedia_Call) Return(_a0 map[catalog.AlbumId]int, _a1 error) *RepositoryAdapter_CountMedia_Call

+ func (_c *RepositoryAdapter_CountMedia_Call) Run(run func(ctx context.Context, album ...catalog.AlbumId)) *RepositoryAdapter_CountMedia_Call

+ func (_c *RepositoryAdapter_CountMedia_Call) RunAndReturn(run func(context.Context, ...catalog.AlbumId) (map[catalog.AlbumId]int, error)) *RepositoryAdapter_CountMedia_Call

type RepositoryAdapter_Expecter

+ func (_e *RepositoryAdapter_Expecter) CountMedia(ctx interface{}, album ...interface{}) *RepositoryAdapter_CountMedia_Call

v1.5.49

May 18, 2024

Changes in this version

+ type FindAlbumByOwnerFunc struct

+ func NewFindAlbumByOwnerFunc(t interface{ ... }) *FindAlbumByOwnerFunc

+ func (_m *FindAlbumByOwnerFunc) EXPECT() *FindAlbumByOwnerFunc_Expecter

+ func (_m *FindAlbumByOwnerFunc) Execute(ctx context.Context, owner ownermodel.Owner) ([]*catalog.Album, error)

+ type FindAlbumByOwnerFunc_Execute_Call struct

+ func (_c *FindAlbumByOwnerFunc_Execute_Call) Return(_a0 []*catalog.Album, _a1 error) *FindAlbumByOwnerFunc_Execute_Call

+ func (_c *FindAlbumByOwnerFunc_Execute_Call) Run(run func(ctx context.Context, owner ownermodel.Owner)) *FindAlbumByOwnerFunc_Execute_Call

+ func (_c *FindAlbumByOwnerFunc_Execute_Call) RunAndReturn(run func(context.Context, ownermodel.Owner) ([]*catalog.Album, error)) *FindAlbumByOwnerFunc_Execute_Call

+ type FindAlbumByOwnerFunc_Expecter struct

+ func (_e *FindAlbumByOwnerFunc_Expecter) Execute(ctx interface{}, owner interface{}) *FindAlbumByOwnerFunc_Execute_Call

+ type FindAlbumsByIdsFunc struct

+ func NewFindAlbumsByIdsFunc(t interface{ ... }) *FindAlbumsByIdsFunc

+ func (_m *FindAlbumsByIdsFunc) EXPECT() *FindAlbumsByIdsFunc_Expecter

+ func (_m *FindAlbumsByIdsFunc) Execute(ctx context.Context, ids []catalog.AlbumId) ([]*catalog.Album, error)

+ type FindAlbumsByIdsFunc_Execute_Call struct

+ func (_c *FindAlbumsByIdsFunc_Execute_Call) Return(_a0 []*catalog.Album, _a1 error) *FindAlbumsByIdsFunc_Execute_Call

+ func (_c *FindAlbumsByIdsFunc_Execute_Call) Run(run func(ctx context.Context, ids []catalog.AlbumId)) *FindAlbumsByIdsFunc_Execute_Call

+ func (_c *FindAlbumsByIdsFunc_Execute_Call) RunAndReturn(run func(context.Context, []catalog.AlbumId) ([]*catalog.Album, error)) *FindAlbumsByIdsFunc_Execute_Call

+ type FindAlbumsByIdsFunc_Expecter struct

+ func (_e *FindAlbumsByIdsFunc_Expecter) Execute(ctx interface{}, ids interface{}) *FindAlbumsByIdsFunc_Execute_Call

+ type GetAlbumSharingGridFunc struct

+ func NewGetAlbumSharingGridFunc(t interface{ ... }) *GetAlbumSharingGridFunc

+ func (_m *GetAlbumSharingGridFunc) EXPECT() *GetAlbumSharingGridFunc_Expecter

+ func (_m *GetAlbumSharingGridFunc) Execute(ctx context.Context, owner ownermodel.Owner) (map[catalog.AlbumId][]usermodel.UserId, error)

+ type GetAlbumSharingGridFunc_Execute_Call struct

+ func (_c *GetAlbumSharingGridFunc_Execute_Call) Return(_a0 map[catalog.AlbumId][]usermodel.UserId, _a1 error) *GetAlbumSharingGridFunc_Execute_Call

+ func (_c *GetAlbumSharingGridFunc_Execute_Call) Run(run func(ctx context.Context, owner ownermodel.Owner)) *GetAlbumSharingGridFunc_Execute_Call

+ func (_c *GetAlbumSharingGridFunc_Execute_Call) RunAndReturn(...) *GetAlbumSharingGridFunc_Execute_Call

+ type GetAlbumSharingGridFunc_Expecter struct

+ func (_e *GetAlbumSharingGridFunc_Expecter) Execute(ctx interface{}, owner interface{}) *GetAlbumSharingGridFunc_Execute_Call

+ type GetAlbumSharingGridPort struct

+ func NewGetAlbumSharingGridPort(t interface{ ... }) *GetAlbumSharingGridPort

+ func (_m *GetAlbumSharingGridPort) EXPECT() *GetAlbumSharingGridPort_Expecter

+ func (_m *GetAlbumSharingGridPort) GetAlbumSharingGrid(ctx context.Context, owner ownermodel.Owner) (map[catalog.AlbumId][]usermodel.UserId, error)

+ type GetAlbumSharingGridPort_Expecter struct

+ func (_e *GetAlbumSharingGridPort_Expecter) GetAlbumSharingGrid(ctx interface{}, owner interface{}) *GetAlbumSharingGridPort_GetAlbumSharingGrid_Call

+ type GetAlbumSharingGridPort_GetAlbumSharingGrid_Call struct

+ func (_c *GetAlbumSharingGridPort_GetAlbumSharingGrid_Call) Return(_a0 map[catalog.AlbumId][]usermodel.UserId, _a1 error) *GetAlbumSharingGridPort_GetAlbumSharingGrid_Call

+ func (_c *GetAlbumSharingGridPort_GetAlbumSharingGrid_Call) Run(run func(ctx context.Context, owner ownermodel.Owner)) *GetAlbumSharingGridPort_GetAlbumSharingGrid_Call

+ func (_c *GetAlbumSharingGridPort_GetAlbumSharingGrid_Call) RunAndReturn(...) *GetAlbumSharingGridPort_GetAlbumSharingGrid_Call

type GrantRepository

+ func (_m *GrantRepository) ListScopesByOwner(ctx context.Context, owner ownermodel.Owner, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ func (_m *GrantRepository) ListScopesByUser(ctx context.Context, email usermodel.UserId, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

type GrantRepository_Expecter

+ func (_e *GrantRepository_Expecter) ListScopesByOwner(ctx interface{}, owner interface{}, types ...interface{}) *GrantRepository_ListScopesByOwner_Call

+ func (_e *GrantRepository_Expecter) ListScopesByUser(ctx interface{}, email interface{}, types ...interface{}) *GrantRepository_ListScopesByUser_Call

+ type GrantRepository_ListScopesByOwner_Call struct

+ func (_c *GrantRepository_ListScopesByOwner_Call) Return(_a0 []*aclcore.Scope, _a1 error) *GrantRepository_ListScopesByOwner_Call

+ func (_c *GrantRepository_ListScopesByOwner_Call) Run(...) *GrantRepository_ListScopesByOwner_Call

+ func (_c *GrantRepository_ListScopesByOwner_Call) RunAndReturn(...) *GrantRepository_ListScopesByOwner_Call

+ type GrantRepository_ListScopesByUser_Call struct

+ func (_c *GrantRepository_ListScopesByUser_Call) Return(_a0 []*aclcore.Scope, _a1 error) *GrantRepository_ListScopesByUser_Call

+ func (_c *GrantRepository_ListScopesByUser_Call) Run(...) *GrantRepository_ListScopesByUser_Call

+ func (_c *GrantRepository_ListScopesByUser_Call) RunAndReturn(...) *GrantRepository_ListScopesByUser_Call

+ type ListAlbumsProvider struct

+ func NewListAlbumsProvider(t interface{ ... }) *ListAlbumsProvider

+ func (_m *ListAlbumsProvider) EXPECT() *ListAlbumsProvider_Expecter

+ func (_m *ListAlbumsProvider) ListAlbums(ctx context.Context, user usermodel.CurrentUser, ...) ([]*catalogviews.VisibleAlbum, error)

+ type ListAlbumsProviderFunc struct

+ func NewListAlbumsProviderFunc(t interface{ ... }) *ListAlbumsProviderFunc

+ func (_m *ListAlbumsProviderFunc) EXPECT() *ListAlbumsProviderFunc_Expecter

+ func (_m *ListAlbumsProviderFunc) Execute(ctx context.Context, user usermodel.CurrentUser, ...) ([]*catalogviews.VisibleAlbum, error)

+ type ListAlbumsProviderFunc_Execute_Call struct

+ func (_c *ListAlbumsProviderFunc_Execute_Call) Return(_a0 []*catalogviews.VisibleAlbum, _a1 error) *ListAlbumsProviderFunc_Execute_Call

+ func (_c *ListAlbumsProviderFunc_Execute_Call) Run(run func(ctx context.Context, user usermodel.CurrentUser, ...)) *ListAlbumsProviderFunc_Execute_Call

+ func (_c *ListAlbumsProviderFunc_Execute_Call) RunAndReturn(...) *ListAlbumsProviderFunc_Execute_Call

+ type ListAlbumsProviderFunc_Expecter struct

+ func (_e *ListAlbumsProviderFunc_Expecter) Execute(ctx interface{}, user interface{}, filter interface{}) *ListAlbumsProviderFunc_Execute_Call

+ type ListAlbumsProvider_Expecter struct

+ func (_e *ListAlbumsProvider_Expecter) ListAlbums(ctx interface{}, user interface{}, filter interface{}) *ListAlbumsProvider_ListAlbums_Call

+ type ListAlbumsProvider_ListAlbums_Call struct

+ func (_c *ListAlbumsProvider_ListAlbums_Call) Return(_a0 []*catalogviews.VisibleAlbum, _a1 error) *ListAlbumsProvider_ListAlbums_Call

+ func (_c *ListAlbumsProvider_ListAlbums_Call) Run(run func(ctx context.Context, user usermodel.CurrentUser, ...)) *ListAlbumsProvider_ListAlbums_Call

+ func (_c *ListAlbumsProvider_ListAlbums_Call) RunAndReturn(...) *ListAlbumsProvider_ListAlbums_Call

type ReverseScopesReader

+ func (_m *ReverseScopesReader) ListScopesByOwner(ctx context.Context, owner ownermodel.Owner, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

type ReverseScopesReader_Expecter

+ func (_e *ReverseScopesReader_Expecter) ListScopesByOwner(ctx interface{}, owner interface{}, types ...interface{}) *ReverseScopesReader_ListScopesByOwner_Call

+ type ReverseScopesReader_ListScopesByOwner_Call struct

+ func (_c *ReverseScopesReader_ListScopesByOwner_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ReverseScopesReader_ListScopesByOwner_Call

+ func (_c *ReverseScopesReader_ListScopesByOwner_Call) Run(...) *ReverseScopesReader_ListScopesByOwner_Call

+ func (_c *ReverseScopesReader_ListScopesByOwner_Call) RunAndReturn(...) *ReverseScopesReader_ListScopesByOwner_Call

+ type ScopeReadRepository struct

+ func NewScopeReadRepository(t interface{ ... }) *ScopeReadRepository

+ func (_m *ScopeReadRepository) EXPECT() *ScopeReadRepository_Expecter

+ func (_m *ScopeReadRepository) ListScopesByOwner(ctx context.Context, owner ownermodel.Owner, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ func (_m *ScopeReadRepository) ListScopesByUser(ctx context.Context, email usermodel.UserId, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ type ScopeReadRepositoryPort struct

+ func NewScopeReadRepositoryPort(t interface{ ... }) *ScopeReadRepositoryPort

+ func (_m *ScopeReadRepositoryPort) EXPECT() *ScopeReadRepositoryPort_Expecter

+ func (_m *ScopeReadRepositoryPort) ListScopesByOwner(ctx context.Context, owner ownermodel.Owner, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ func (_m *ScopeReadRepositoryPort) ListScopesByUser(ctx context.Context, id usermodel.UserId, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ type ScopeReadRepositoryPort_Expecter struct

+ func (_e *ScopeReadRepositoryPort_Expecter) ListScopesByOwner(ctx interface{}, owner interface{}, types ...interface{}) *ScopeReadRepositoryPort_ListScopesByOwner_Call

+ func (_e *ScopeReadRepositoryPort_Expecter) ListScopesByUser(ctx interface{}, id interface{}, types ...interface{}) *ScopeReadRepositoryPort_ListScopesByUser_Call

+ type ScopeReadRepositoryPort_ListScopesByOwner_Call struct

+ func (_c *ScopeReadRepositoryPort_ListScopesByOwner_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopeReadRepositoryPort_ListScopesByOwner_Call

+ func (_c *ScopeReadRepositoryPort_ListScopesByOwner_Call) Run(...) *ScopeReadRepositoryPort_ListScopesByOwner_Call

+ func (_c *ScopeReadRepositoryPort_ListScopesByOwner_Call) RunAndReturn(...) *ScopeReadRepositoryPort_ListScopesByOwner_Call

+ type ScopeReadRepositoryPort_ListScopesByUser_Call struct

+ func (_c *ScopeReadRepositoryPort_ListScopesByUser_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopeReadRepositoryPort_ListScopesByUser_Call

+ func (_c *ScopeReadRepositoryPort_ListScopesByUser_Call) Run(run func(ctx context.Context, id usermodel.UserId, types ...aclcore.ScopeType)) *ScopeReadRepositoryPort_ListScopesByUser_Call

+ func (_c *ScopeReadRepositoryPort_ListScopesByUser_Call) RunAndReturn(...) *ScopeReadRepositoryPort_ListScopesByUser_Call

+ type ScopeReadRepository_Expecter struct

+ func (_e *ScopeReadRepository_Expecter) ListScopesByOwner(ctx interface{}, owner interface{}, types ...interface{}) *ScopeReadRepository_ListScopesByOwner_Call

+ func (_e *ScopeReadRepository_Expecter) ListScopesByUser(ctx interface{}, email interface{}, types ...interface{}) *ScopeReadRepository_ListScopesByUser_Call

+ type ScopeReadRepository_ListScopesByOwner_Call struct

+ func (_c *ScopeReadRepository_ListScopesByOwner_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopeReadRepository_ListScopesByOwner_Call

+ func (_c *ScopeReadRepository_ListScopesByOwner_Call) Run(...) *ScopeReadRepository_ListScopesByOwner_Call

+ func (_c *ScopeReadRepository_ListScopesByOwner_Call) RunAndReturn(...) *ScopeReadRepository_ListScopesByOwner_Call

+ type ScopeReadRepository_ListScopesByUser_Call struct

+ func (_c *ScopeReadRepository_ListScopesByUser_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopeReadRepository_ListScopesByUser_Call

+ func (_c *ScopeReadRepository_ListScopesByUser_Call) Run(...) *ScopeReadRepository_ListScopesByUser_Call

+ func (_c *ScopeReadRepository_ListScopesByUser_Call) RunAndReturn(...) *ScopeReadRepository_ListScopesByUser_Call

type ScopeRepository

+ func (_m *ScopeRepository) ListScopesByOwner(ctx context.Context, owner ownermodel.Owner, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ func (_m *ScopeRepository) ListScopesByUser(ctx context.Context, email usermodel.UserId, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

type ScopeRepository_Expecter

+ func (_e *ScopeRepository_Expecter) ListScopesByOwner(ctx interface{}, owner interface{}, types ...interface{}) *ScopeRepository_ListScopesByOwner_Call

+ func (_e *ScopeRepository_Expecter) ListScopesByUser(ctx interface{}, email interface{}, types ...interface{}) *ScopeRepository_ListScopesByUser_Call

+ type ScopeRepository_ListScopesByOwner_Call struct

+ func (_c *ScopeRepository_ListScopesByOwner_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopeRepository_ListScopesByOwner_Call

+ func (_c *ScopeRepository_ListScopesByOwner_Call) Run(...) *ScopeRepository_ListScopesByOwner_Call

+ func (_c *ScopeRepository_ListScopesByOwner_Call) RunAndReturn(...) *ScopeRepository_ListScopesByOwner_Call

+ type ScopeRepository_ListScopesByUser_Call struct

+ func (_c *ScopeRepository_ListScopesByUser_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopeRepository_ListScopesByUser_Call

+ func (_c *ScopeRepository_ListScopesByUser_Call) Run(...) *ScopeRepository_ListScopesByUser_Call

+ func (_c *ScopeRepository_ListScopesByUser_Call) RunAndReturn(...) *ScopeRepository_ListScopesByUser_Call

type ScopesReader

+ func (_m *ScopesReader) ListScopesByUser(ctx context.Context, email usermodel.UserId, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

type ScopesReader_Expecter

+ func (_e *ScopesReader_Expecter) ListScopesByUser(ctx interface{}, email interface{}, types ...interface{}) *ScopesReader_ListScopesByUser_Call

+ type ScopesReader_ListScopesByUser_Call struct

+ func (_c *ScopesReader_ListScopesByUser_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopesReader_ListScopesByUser_Call

+ func (_c *ScopesReader_ListScopesByUser_Call) Run(...) *ScopesReader_ListScopesByUser_Call

+ func (_c *ScopesReader_ListScopesByUser_Call) RunAndReturn(...) *ScopesReader_ListScopesByUser_Call

+ type SharedWithUserFunc struct

+ func NewSharedWithUserFunc(t interface{ ... }) *SharedWithUserFunc

+ func (_m *SharedWithUserFunc) EXPECT() *SharedWithUserFunc_Expecter

+ func (_m *SharedWithUserFunc) Execute(ctx context.Context, userId usermodel.UserId) ([]catalog.AlbumId, error)

+ type SharedWithUserFunc_Execute_Call struct

+ func (_c *SharedWithUserFunc_Execute_Call) Return(_a0 []catalog.AlbumId, _a1 error) *SharedWithUserFunc_Execute_Call

+ func (_c *SharedWithUserFunc_Execute_Call) Run(run func(ctx context.Context, userId usermodel.UserId)) *SharedWithUserFunc_Execute_Call

+ func (_c *SharedWithUserFunc_Execute_Call) RunAndReturn(run func(context.Context, usermodel.UserId) ([]catalog.AlbumId, error)) *SharedWithUserFunc_Execute_Call

+ type SharedWithUserFunc_Expecter struct

+ func (_e *SharedWithUserFunc_Expecter) Execute(ctx interface{}, userId interface{}) *SharedWithUserFunc_Execute_Call

v1.5.48

May 16, 2024

Changes in this version

+ type FindAlbumByOwnerPort struct

+ func NewFindAlbumByOwnerPort(t interface{ ... }) *FindAlbumByOwnerPort

+ func (_m *FindAlbumByOwnerPort) EXPECT() *FindAlbumByOwnerPort_Expecter

+ func (_m *FindAlbumByOwnerPort) FindAlbumsByOwner(ctx context.Context, owner ownermodel.Owner) ([]*catalog.Album, error)

+ type FindAlbumByOwnerPort_Expecter struct

+ func (_e *FindAlbumByOwnerPort_Expecter) FindAlbumsByOwner(ctx interface{}, owner interface{}) *FindAlbumByOwnerPort_FindAlbumsByOwner_Call

+ type FindAlbumByOwnerPort_FindAlbumsByOwner_Call struct

+ func (_c *FindAlbumByOwnerPort_FindAlbumsByOwner_Call) Return(_a0 []*catalog.Album, _a1 error) *FindAlbumByOwnerPort_FindAlbumsByOwner_Call

+ func (_c *FindAlbumByOwnerPort_FindAlbumsByOwner_Call) Run(run func(ctx context.Context, owner ownermodel.Owner)) *FindAlbumByOwnerPort_FindAlbumsByOwner_Call

+ func (_c *FindAlbumByOwnerPort_FindAlbumsByOwner_Call) RunAndReturn(run func(context.Context, ownermodel.Owner) ([]*catalog.Album, error)) *FindAlbumByOwnerPort_FindAlbumsByOwner_Call

+ type FindAlbumSharingToPort struct

+ func NewFindAlbumSharingToPort(t interface{ ... }) *FindAlbumSharingToPort

+ func (_m *FindAlbumSharingToPort) EXPECT() *FindAlbumSharingToPort_Expecter

+ func (_m *FindAlbumSharingToPort) GetAlbumSharingGrid(ctx context.Context, owner ownermodel.Owner) (map[catalog.AlbumId][]usermodel.UserId, error)

+ type FindAlbumSharingToPort_Expecter struct

+ func (_e *FindAlbumSharingToPort_Expecter) GetAlbumSharingGrid(ctx interface{}, owner interface{}) *FindAlbumSharingToPort_GetAlbumSharingGrid_Call

+ type FindAlbumSharingToPort_GetAlbumSharingGrid_Call struct

+ func (_c *FindAlbumSharingToPort_GetAlbumSharingGrid_Call) Return(_a0 map[catalog.AlbumId][]usermodel.UserId, _a1 error) *FindAlbumSharingToPort_GetAlbumSharingGrid_Call

+ func (_c *FindAlbumSharingToPort_GetAlbumSharingGrid_Call) Run(run func(ctx context.Context, owner ownermodel.Owner)) *FindAlbumSharingToPort_GetAlbumSharingGrid_Call

+ func (_c *FindAlbumSharingToPort_GetAlbumSharingGrid_Call) RunAndReturn(...) *FindAlbumSharingToPort_GetAlbumSharingGrid_Call

+ type FindAlbumsByIdsPort struct

+ func NewFindAlbumsByIdsPort(t interface{ ... }) *FindAlbumsByIdsPort

+ func (_m *FindAlbumsByIdsPort) EXPECT() *FindAlbumsByIdsPort_Expecter

+ func (_m *FindAlbumsByIdsPort) FindAlbumsById(ctx context.Context, ids []catalog.AlbumId) ([]*catalog.Album, error)

+ type FindAlbumsByIdsPort_Expecter struct

+ func (_e *FindAlbumsByIdsPort_Expecter) FindAlbumsById(ctx interface{}, ids interface{}) *FindAlbumsByIdsPort_FindAlbumsById_Call

+ type FindAlbumsByIdsPort_FindAlbumsById_Call struct

+ func (_c *FindAlbumsByIdsPort_FindAlbumsById_Call) Return(_a0 []*catalog.Album, _a1 error) *FindAlbumsByIdsPort_FindAlbumsById_Call

+ func (_c *FindAlbumsByIdsPort_FindAlbumsById_Call) Run(run func(ctx context.Context, ids []catalog.AlbumId)) *FindAlbumsByIdsPort_FindAlbumsById_Call

+ func (_c *FindAlbumsByIdsPort_FindAlbumsById_Call) RunAndReturn(run func(context.Context, []catalog.AlbumId) ([]*catalog.Album, error)) *FindAlbumsByIdsPort_FindAlbumsById_Call

+ type InsertMediasObserver struct

+ func NewInsertMediasObserver(t interface{ ... }) *InsertMediasObserver

+ func (_m *InsertMediasObserver) EXPECT() *InsertMediasObserver_Expecter

+ func (_m *InsertMediasObserver) OnMediasInserted(_a0 context.Context, _a1 map[catalog.AlbumId][]catalog.MediaId) error

+ type InsertMediasObserver_Expecter struct

+ func (_e *InsertMediasObserver_Expecter) OnMediasInserted(_a0 interface{}, _a1 interface{}) *InsertMediasObserver_OnMediasInserted_Call

+ type InsertMediasObserver_OnMediasInserted_Call struct

+ func (_c *InsertMediasObserver_OnMediasInserted_Call) Return(_a0 error) *InsertMediasObserver_OnMediasInserted_Call

+ func (_c *InsertMediasObserver_OnMediasInserted_Call) Run(run func(_a0 context.Context, _a1 map[catalog.AlbumId][]catalog.MediaId)) *InsertMediasObserver_OnMediasInserted_Call

+ func (_c *InsertMediasObserver_OnMediasInserted_Call) RunAndReturn(run func(context.Context, map[catalog.AlbumId][]catalog.MediaId) error) *InsertMediasObserver_OnMediasInserted_Call

+ type InsertMediasRepositoryPort struct

+ func NewInsertMediasRepositoryPort(t interface{ ... }) *InsertMediasRepositoryPort

+ func (_m *InsertMediasRepositoryPort) EXPECT() *InsertMediasRepositoryPort_Expecter

+ func (_m *InsertMediasRepositoryPort) InsertMedias(ctx context.Context, owner ownermodel.Owner, ...) error

+ type InsertMediasRepositoryPort_Expecter struct

+ func (_e *InsertMediasRepositoryPort_Expecter) InsertMedias(ctx interface{}, owner interface{}, media interface{}) *InsertMediasRepositoryPort_InsertMedias_Call

+ type InsertMediasRepositoryPort_InsertMedias_Call struct

+ func (_c *InsertMediasRepositoryPort_InsertMedias_Call) Return(_a0 error) *InsertMediasRepositoryPort_InsertMedias_Call

+ func (_c *InsertMediasRepositoryPort_InsertMedias_Call) Run(run func(ctx context.Context, owner ownermodel.Owner, ...)) *InsertMediasRepositoryPort_InsertMedias_Call

+ func (_c *InsertMediasRepositoryPort_InsertMedias_Call) RunAndReturn(...) *InsertMediasRepositoryPort_InsertMedias_Call

+ type ListScopesByOwnerPort struct

+ func NewListScopesByOwnerPort(t interface{ ... }) *ListScopesByOwnerPort

+ func (_m *ListScopesByOwnerPort) EXPECT() *ListScopesByOwnerPort_Expecter

+ func (_m *ListScopesByOwnerPort) ListScopesByOwner(owner ownermodel.Owner, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ type ListScopesByOwnerPort_Expecter struct

+ func (_e *ListScopesByOwnerPort_Expecter) ListScopesByOwner(owner interface{}, types ...interface{}) *ListScopesByOwnerPort_ListScopesByOwner_Call

+ type ListScopesByOwnerPort_ListScopesByOwner_Call struct

+ func (_c *ListScopesByOwnerPort_ListScopesByOwner_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ListScopesByOwnerPort_ListScopesByOwner_Call

+ func (_c *ListScopesByOwnerPort_ListScopesByOwner_Call) Run(run func(owner ownermodel.Owner, types ...aclcore.ScopeType)) *ListScopesByOwnerPort_ListScopesByOwner_Call

+ func (_c *ListScopesByOwnerPort_ListScopesByOwner_Call) RunAndReturn(run func(ownermodel.Owner, ...aclcore.ScopeType) ([]*aclcore.Scope, error)) *ListScopesByOwnerPort_ListScopesByOwner_Call

+ type SharedWithUserPort struct

+ func NewSharedWithUserPort(t interface{ ... }) *SharedWithUserPort

+ func (_m *SharedWithUserPort) EXPECT() *SharedWithUserPort_Expecter

+ func (_m *SharedWithUserPort) ListAlbumIdsSharedWithUser(ctx context.Context, userId usermodel.UserId) ([]catalog.AlbumId, error)

+ type SharedWithUserPort_Expecter struct

+ func (_e *SharedWithUserPort_Expecter) ListAlbumIdsSharedWithUser(ctx interface{}, userId interface{}) *SharedWithUserPort_ListAlbumIdsSharedWithUser_Call

+ type SharedWithUserPort_ListAlbumIdsSharedWithUser_Call struct

+ func (_c *SharedWithUserPort_ListAlbumIdsSharedWithUser_Call) Return(_a0 []catalog.AlbumId, _a1 error) *SharedWithUserPort_ListAlbumIdsSharedWithUser_Call

+ func (_c *SharedWithUserPort_ListAlbumIdsSharedWithUser_Call) Run(run func(ctx context.Context, userId usermodel.UserId)) *SharedWithUserPort_ListAlbumIdsSharedWithUser_Call

+ func (_c *SharedWithUserPort_ListAlbumIdsSharedWithUser_Call) RunAndReturn(run func(context.Context, usermodel.UserId) ([]catalog.AlbumId, error)) *SharedWithUserPort_ListAlbumIdsSharedWithUser_Call

v1.5.47

May 15, 2024

v1.5.46

May 13, 2024

v1.5.45

May 13, 2024

Changes in this version

+ type AmendAlbumDateRepositoryPort struct

+ func NewAmendAlbumDateRepositoryPort(t interface{ ... }) *AmendAlbumDateRepositoryPort

+ func (_m *AmendAlbumDateRepositoryPort) AmendDates(ctx context.Context, album catalog.AlbumId, start time.Time, end time.Time) error

+ func (_m *AmendAlbumDateRepositoryPort) EXPECT() *AmendAlbumDateRepositoryPort_Expecter

+ type AmendAlbumDateRepositoryPort_AmendDates_Call struct

+ func (_c *AmendAlbumDateRepositoryPort_AmendDates_Call) Return(_a0 error) *AmendAlbumDateRepositoryPort_AmendDates_Call

+ func (_c *AmendAlbumDateRepositoryPort_AmendDates_Call) Run(...) *AmendAlbumDateRepositoryPort_AmendDates_Call

+ func (_c *AmendAlbumDateRepositoryPort_AmendDates_Call) RunAndReturn(run func(context.Context, catalog.AlbumId, time.Time, time.Time) error) *AmendAlbumDateRepositoryPort_AmendDates_Call

+ type AmendAlbumDateRepositoryPort_Expecter struct

+ func (_e *AmendAlbumDateRepositoryPort_Expecter) AmendDates(ctx interface{}, album interface{}, start interface{}, end interface{}) *AmendAlbumDateRepositoryPort_AmendDates_Call

+ type AmendAlbumDatesObserver struct

+ func NewAmendAlbumDatesObserver(t interface{ ... }) *AmendAlbumDatesObserver

+ func (_m *AmendAlbumDatesObserver) EXPECT() *AmendAlbumDatesObserver_Expecter

+ func (_m *AmendAlbumDatesObserver) OnAlbumDatesAmended(ctx context.Context, existingTimeline []*catalog.Album, ...) error

+ type AmendAlbumDatesObserverFunc struct

+ func NewAmendAlbumDatesObserverFunc(t interface{ ... }) *AmendAlbumDatesObserverFunc

+ func (_m *AmendAlbumDatesObserverFunc) EXPECT() *AmendAlbumDatesObserverFunc_Expecter

+ func (_m *AmendAlbumDatesObserverFunc) Execute(ctx context.Context, existingTimeline []*catalog.Album, ...) error

+ type AmendAlbumDatesObserverFunc_Execute_Call struct

+ func (_c *AmendAlbumDatesObserverFunc_Execute_Call) Return(_a0 error) *AmendAlbumDatesObserverFunc_Execute_Call

+ func (_c *AmendAlbumDatesObserverFunc_Execute_Call) Run(run func(ctx context.Context, existingTimeline []*catalog.Album, ...)) *AmendAlbumDatesObserverFunc_Execute_Call

+ func (_c *AmendAlbumDatesObserverFunc_Execute_Call) RunAndReturn(run func(context.Context, []*catalog.Album, catalog.Album) error) *AmendAlbumDatesObserverFunc_Execute_Call

+ type AmendAlbumDatesObserverFunc_Expecter struct

+ func (_e *AmendAlbumDatesObserverFunc_Expecter) Execute(ctx interface{}, existingTimeline interface{}, updatedAlbum interface{}) *AmendAlbumDatesObserverFunc_Execute_Call

+ type AmendAlbumDatesObserver_Expecter struct

+ func (_e *AmendAlbumDatesObserver_Expecter) OnAlbumDatesAmended(ctx interface{}, existingTimeline interface{}, updatedAlbum interface{}) *AmendAlbumDatesObserver_OnAlbumDatesAmended_Call

+ type AmendAlbumDatesObserver_OnAlbumDatesAmended_Call struct

+ func (_c *AmendAlbumDatesObserver_OnAlbumDatesAmended_Call) Return(_a0 error) *AmendAlbumDatesObserver_OnAlbumDatesAmended_Call

+ func (_c *AmendAlbumDatesObserver_OnAlbumDatesAmended_Call) Run(run func(ctx context.Context, existingTimeline []*catalog.Album, ...)) *AmendAlbumDatesObserver_OnAlbumDatesAmended_Call

+ func (_c *AmendAlbumDatesObserver_OnAlbumDatesAmended_Call) RunAndReturn(run func(context.Context, []*catalog.Album, catalog.Album) error) *AmendAlbumDatesObserver_OnAlbumDatesAmended_Call

+ type TransferMediasRepositoryPort struct

+ func NewTransferMediasRepositoryPort(t interface{ ... }) *TransferMediasRepositoryPort

+ func (_m *TransferMediasRepositoryPort) EXPECT() *TransferMediasRepositoryPort_Expecter

+ func (_m *TransferMediasRepositoryPort) TransferMediasFromRecords(ctx context.Context, records catalog.MediaTransferRecords) (catalog.TransferredMedias, error)

+ type TransferMediasRepositoryPort_Expecter struct

+ func (_e *TransferMediasRepositoryPort_Expecter) TransferMediasFromRecords(ctx interface{}, records interface{}) *TransferMediasRepositoryPort_TransferMediasFromRecords_Call

+ type TransferMediasRepositoryPort_TransferMediasFromRecords_Call struct

+ func (_c *TransferMediasRepositoryPort_TransferMediasFromRecords_Call) Return(_a0 catalog.TransferredMedias, _a1 error) *TransferMediasRepositoryPort_TransferMediasFromRecords_Call

+ func (_c *TransferMediasRepositoryPort_TransferMediasFromRecords_Call) Run(run func(ctx context.Context, records catalog.MediaTransferRecords)) *TransferMediasRepositoryPort_TransferMediasFromRecords_Call

+ func (_c *TransferMediasRepositoryPort_TransferMediasFromRecords_Call) RunAndReturn(...) *TransferMediasRepositoryPort_TransferMediasFromRecords_Call

v1.5.43

May 11, 2024

Changes in this version

+ type FindAlbumByIdFunc struct

+ func NewFindAlbumByIdFunc(t interface{ ... }) *FindAlbumByIdFunc

+ func (_m *FindAlbumByIdFunc) EXPECT() *FindAlbumByIdFunc_Expecter

+ func (_m *FindAlbumByIdFunc) Execute(ctx context.Context, id catalog.AlbumId) (*catalog.Album, error)

+ type FindAlbumByIdFunc_Execute_Call struct

+ func (_c *FindAlbumByIdFunc_Execute_Call) Return(_a0 *catalog.Album, _a1 error) *FindAlbumByIdFunc_Execute_Call

+ func (_c *FindAlbumByIdFunc_Execute_Call) Run(run func(ctx context.Context, id catalog.AlbumId)) *FindAlbumByIdFunc_Execute_Call

+ func (_c *FindAlbumByIdFunc_Execute_Call) RunAndReturn(run func(context.Context, catalog.AlbumId) (*catalog.Album, error)) *FindAlbumByIdFunc_Execute_Call

+ type FindAlbumByIdFunc_Expecter struct

+ func (_e *FindAlbumByIdFunc_Expecter) Execute(ctx interface{}, id interface{}) *FindAlbumByIdFunc_Execute_Call

+ type FindAlbumByIdPort struct

+ func NewFindAlbumByIdPort(t interface{ ... }) *FindAlbumByIdPort

+ func (_m *FindAlbumByIdPort) EXPECT() *FindAlbumByIdPort_Expecter

+ func (_m *FindAlbumByIdPort) FindAlbumById(ctx context.Context, id catalog.AlbumId) (*catalog.Album, error)

+ type FindAlbumByIdPort_Expecter struct

+ func (_e *FindAlbumByIdPort_Expecter) FindAlbumById(ctx interface{}, id interface{}) *FindAlbumByIdPort_FindAlbumById_Call

+ type FindAlbumByIdPort_FindAlbumById_Call struct

+ func (_c *FindAlbumByIdPort_FindAlbumById_Call) Return(_a0 *catalog.Album, _a1 error) *FindAlbumByIdPort_FindAlbumById_Call

+ func (_c *FindAlbumByIdPort_FindAlbumById_Call) Run(run func(ctx context.Context, id catalog.AlbumId)) *FindAlbumByIdPort_FindAlbumById_Call

+ func (_c *FindAlbumByIdPort_FindAlbumById_Call) RunAndReturn(run func(context.Context, catalog.AlbumId) (*catalog.Album, error)) *FindAlbumByIdPort_FindAlbumById_Call

+ type MediaTransfer struct

+ func NewMediaTransfer(t interface{ ... }) *MediaTransfer

+ func (_m *MediaTransfer) EXPECT() *MediaTransfer_Expecter

+ func (_m *MediaTransfer) Transfer(ctx context.Context, records catalog.MediaTransferRecords) error

+ type MediaTransferFunc struct

+ func NewMediaTransferFunc(t interface{ ... }) *MediaTransferFunc

+ func (_m *MediaTransferFunc) EXPECT() *MediaTransferFunc_Expecter

+ func (_m *MediaTransferFunc) Execute(ctx context.Context, records catalog.MediaTransferRecords) error

+ type MediaTransferFunc_Execute_Call struct

+ func (_c *MediaTransferFunc_Execute_Call) Return(_a0 error) *MediaTransferFunc_Execute_Call

+ func (_c *MediaTransferFunc_Execute_Call) Run(run func(ctx context.Context, records catalog.MediaTransferRecords)) *MediaTransferFunc_Execute_Call

+ func (_c *MediaTransferFunc_Execute_Call) RunAndReturn(run func(context.Context, catalog.MediaTransferRecords) error) *MediaTransferFunc_Execute_Call

+ type MediaTransferFunc_Expecter struct

+ func (_e *MediaTransferFunc_Expecter) Execute(ctx interface{}, records interface{}) *MediaTransferFunc_Execute_Call

+ type MediaTransfer_Expecter struct

+ func (_e *MediaTransfer_Expecter) Transfer(ctx interface{}, records interface{}) *MediaTransfer_Transfer_Call

+ type MediaTransfer_Transfer_Call struct

+ func (_c *MediaTransfer_Transfer_Call) Return(_a0 error) *MediaTransfer_Transfer_Call

+ func (_c *MediaTransfer_Transfer_Call) Run(run func(ctx context.Context, records catalog.MediaTransferRecords)) *MediaTransfer_Transfer_Call

+ func (_c *MediaTransfer_Transfer_Call) RunAndReturn(run func(context.Context, catalog.MediaTransferRecords) error) *MediaTransfer_Transfer_Call

+ type RenameAlbumObserver struct

+ func NewRenameAlbumObserver(t interface{ ... }) *RenameAlbumObserver

+ func (_m *RenameAlbumObserver) EXPECT() *RenameAlbumObserver_Expecter

+ func (_m *RenameAlbumObserver) OnRenameAlbum(ctx context.Context, current catalog.AlbumId, ...) error

+ type RenameAlbumObserver_Expecter struct

+ func (_e *RenameAlbumObserver_Expecter) OnRenameAlbum(ctx interface{}, current interface{}, creationRequest interface{}) *RenameAlbumObserver_OnRenameAlbum_Call

+ type RenameAlbumObserver_OnRenameAlbum_Call struct

+ func (_c *RenameAlbumObserver_OnRenameAlbum_Call) Return(_a0 error) *RenameAlbumObserver_OnRenameAlbum_Call

+ func (_c *RenameAlbumObserver_OnRenameAlbum_Call) Run(run func(ctx context.Context, current catalog.AlbumId, ...)) *RenameAlbumObserver_OnRenameAlbum_Call

+ func (_c *RenameAlbumObserver_OnRenameAlbum_Call) RunAndReturn(run func(context.Context, catalog.AlbumId, catalog.CreateAlbumRequest) error) *RenameAlbumObserver_OnRenameAlbum_Call

type RepositoryAdapter

+ func (_m *RepositoryAdapter) FindAlbumByIds(ctx context.Context, ids ...catalog.AlbumId) ([]*catalog.Album, error)

type RepositoryAdapter_Expecter

+ func (_e *RepositoryAdapter_Expecter) FindAlbumByIds(ctx interface{}, ids ...interface{}) *RepositoryAdapter_FindAlbumByIds_Call

+ type RepositoryAdapter_FindAlbumByIds_Call struct

+ func (_c *RepositoryAdapter_FindAlbumByIds_Call) Return(_a0 []*catalog.Album, _a1 error) *RepositoryAdapter_FindAlbumByIds_Call

+ func (_c *RepositoryAdapter_FindAlbumByIds_Call) Run(run func(ctx context.Context, ids ...catalog.AlbumId)) *RepositoryAdapter_FindAlbumByIds_Call

+ func (_c *RepositoryAdapter_FindAlbumByIds_Call) RunAndReturn(run func(context.Context, ...catalog.AlbumId) ([]*catalog.Album, error)) *RepositoryAdapter_FindAlbumByIds_Call

+ type UpdateAlbumNamePort struct

+ func NewUpdateAlbumNamePort(t interface{ ... }) *UpdateAlbumNamePort

+ func (_m *UpdateAlbumNamePort) EXPECT() *UpdateAlbumNamePort_Expecter

+ func (_m *UpdateAlbumNamePort) UpdateAlbumName(ctx context.Context, albumId catalog.AlbumId, newName string) error

+ type UpdateAlbumNamePort_Expecter struct

+ func (_e *UpdateAlbumNamePort_Expecter) UpdateAlbumName(ctx interface{}, albumId interface{}, newName interface{}) *UpdateAlbumNamePort_UpdateAlbumName_Call

+ type UpdateAlbumNamePort_UpdateAlbumName_Call struct

+ func (_c *UpdateAlbumNamePort_UpdateAlbumName_Call) Return(_a0 error) *UpdateAlbumNamePort_UpdateAlbumName_Call

+ func (_c *UpdateAlbumNamePort_UpdateAlbumName_Call) Run(run func(ctx context.Context, albumId catalog.AlbumId, newName string)) *UpdateAlbumNamePort_UpdateAlbumName_Call

+ func (_c *UpdateAlbumNamePort_UpdateAlbumName_Call) RunAndReturn(run func(context.Context, catalog.AlbumId, string) error) *UpdateAlbumNamePort_UpdateAlbumName_Call

v1.5.42

May 10, 2024

Changes in this version

+ type CreateAlbumObserver struct

+ func NewCreateAlbumObserver(t interface{ ... }) *CreateAlbumObserver

+ func (_m *CreateAlbumObserver) EXPECT() *CreateAlbumObserver_Expecter

+ func (_m *CreateAlbumObserver) ObserveCreateAlbum(ctx context.Context, album catalog.Album, records catalog.MediaTransferRecords) error

+ type CreateAlbumObserverFunc struct

+ func NewCreateAlbumObserverFunc(t interface{ ... }) *CreateAlbumObserverFunc

+ func (_m *CreateAlbumObserverFunc) EXPECT() *CreateAlbumObserverFunc_Expecter

+ func (_m *CreateAlbumObserverFunc) Execute(ctx context.Context, album catalog.Album, records catalog.MediaTransferRecords) error

+ type CreateAlbumObserverFunc_Execute_Call struct

+ func (_c *CreateAlbumObserverFunc_Execute_Call) Return(_a0 error) *CreateAlbumObserverFunc_Execute_Call

+ func (_c *CreateAlbumObserverFunc_Execute_Call) Run(...) *CreateAlbumObserverFunc_Execute_Call

+ func (_c *CreateAlbumObserverFunc_Execute_Call) RunAndReturn(run func(context.Context, catalog.Album, catalog.MediaTransferRecords) error) *CreateAlbumObserverFunc_Execute_Call

+ type CreateAlbumObserverFunc_Expecter struct

+ func (_e *CreateAlbumObserverFunc_Expecter) Execute(ctx interface{}, album interface{}, records interface{}) *CreateAlbumObserverFunc_Execute_Call

+ type CreateAlbumObserver_Expecter struct

+ func (_e *CreateAlbumObserver_Expecter) ObserveCreateAlbum(ctx interface{}, album interface{}, records interface{}) *CreateAlbumObserver_ObserveCreateAlbum_Call

+ type CreateAlbumObserver_ObserveCreateAlbum_Call struct

+ func (_c *CreateAlbumObserver_ObserveCreateAlbum_Call) Return(_a0 error) *CreateAlbumObserver_ObserveCreateAlbum_Call

+ func (_c *CreateAlbumObserver_ObserveCreateAlbum_Call) Run(...) *CreateAlbumObserver_ObserveCreateAlbum_Call

+ func (_c *CreateAlbumObserver_ObserveCreateAlbum_Call) RunAndReturn(run func(context.Context, catalog.Album, catalog.MediaTransferRecords) error) *CreateAlbumObserver_ObserveCreateAlbum_Call

+ type DeleteAlbumObserver struct

+ func NewDeleteAlbumObserver(t interface{ ... }) *DeleteAlbumObserver

+ func (_m *DeleteAlbumObserver) EXPECT() *DeleteAlbumObserver_Expecter

+ func (_m *DeleteAlbumObserver) OnDeleteAlbum(ctx context.Context, deletedAlbum catalog.AlbumId, ...) error

+ type DeleteAlbumObserver_Expecter struct

+ func (_e *DeleteAlbumObserver_Expecter) OnDeleteAlbum(ctx interface{}, deletedAlbum interface{}, transfers interface{}) *DeleteAlbumObserver_OnDeleteAlbum_Call

+ type DeleteAlbumObserver_OnDeleteAlbum_Call struct

+ func (_c *DeleteAlbumObserver_OnDeleteAlbum_Call) Return(_a0 error) *DeleteAlbumObserver_OnDeleteAlbum_Call

+ func (_c *DeleteAlbumObserver_OnDeleteAlbum_Call) Run(run func(ctx context.Context, deletedAlbum catalog.AlbumId, ...)) *DeleteAlbumObserver_OnDeleteAlbum_Call

+ func (_c *DeleteAlbumObserver_OnDeleteAlbum_Call) RunAndReturn(run func(context.Context, catalog.AlbumId, catalog.MediaTransferRecords) error) *DeleteAlbumObserver_OnDeleteAlbum_Call

+ type TimelineMutationObserverFunc struct

+ func NewTimelineMutationObserverFunc(t interface{ ... }) *TimelineMutationObserverFunc

+ func (_m *TimelineMutationObserverFunc) EXPECT() *TimelineMutationObserverFunc_Expecter

+ func (_m *TimelineMutationObserverFunc) Execute(ctx context.Context, transfers catalog.TransferredMedias) error

+ type TimelineMutationObserverFunc_Execute_Call struct

+ func (_c *TimelineMutationObserverFunc_Execute_Call) Return(_a0 error) *TimelineMutationObserverFunc_Execute_Call

+ func (_c *TimelineMutationObserverFunc_Execute_Call) Run(run func(ctx context.Context, transfers catalog.TransferredMedias)) *TimelineMutationObserverFunc_Execute_Call

+ func (_c *TimelineMutationObserverFunc_Execute_Call) RunAndReturn(run func(context.Context, catalog.TransferredMedias) error) *TimelineMutationObserverFunc_Execute_Call

+ type TimelineMutationObserverFunc_Expecter struct

+ func (_e *TimelineMutationObserverFunc_Expecter) Execute(ctx interface{}, transfers interface{}) *TimelineMutationObserverFunc_Execute_Call

v1.5.41

May 9, 2024

Changes in this version

type ACLViewCatalogAdapter

+ func (_m *ACLViewCatalogAdapter) EXPECT() *ACLViewCatalogAdapter_Expecter

+ type ACLViewCatalogAdapter_Expecter struct

+ func (_e *ACLViewCatalogAdapter_Expecter) FindAlbums(keys interface{}) *ACLViewCatalogAdapter_FindAlbums_Call

+ func (_e *ACLViewCatalogAdapter_Expecter) FindAllAlbums(owner interface{}) *ACLViewCatalogAdapter_FindAllAlbums_Call

+ func (_e *ACLViewCatalogAdapter_Expecter) ListMedias(owner interface{}, folderName interface{}, request interface{}) *ACLViewCatalogAdapter_ListMedias_Call

+ type ACLViewCatalogAdapter_FindAlbums_Call struct

+ func (_c *ACLViewCatalogAdapter_FindAlbums_Call) Return(_a0 []*catalog.Album, _a1 error) *ACLViewCatalogAdapter_FindAlbums_Call

+ func (_c *ACLViewCatalogAdapter_FindAlbums_Call) Run(run func(keys []catalog.AlbumId)) *ACLViewCatalogAdapter_FindAlbums_Call

+ func (_c *ACLViewCatalogAdapter_FindAlbums_Call) RunAndReturn(run func([]catalog.AlbumId) ([]*catalog.Album, error)) *ACLViewCatalogAdapter_FindAlbums_Call

+ type ACLViewCatalogAdapter_FindAllAlbums_Call struct

+ func (_c *ACLViewCatalogAdapter_FindAllAlbums_Call) Return(_a0 []*catalog.Album, _a1 error) *ACLViewCatalogAdapter_FindAllAlbums_Call

+ func (_c *ACLViewCatalogAdapter_FindAllAlbums_Call) Run(run func(owner string)) *ACLViewCatalogAdapter_FindAllAlbums_Call

+ func (_c *ACLViewCatalogAdapter_FindAllAlbums_Call) RunAndReturn(run func(string) ([]*catalog.Album, error)) *ACLViewCatalogAdapter_FindAllAlbums_Call

+ type ACLViewCatalogAdapter_ListMedias_Call struct

+ func (_c *ACLViewCatalogAdapter_ListMedias_Call) Return(_a0 *catalog.MediaPage, _a1 error) *ACLViewCatalogAdapter_ListMedias_Call

+ func (_c *ACLViewCatalogAdapter_ListMedias_Call) Run(run func(owner string, folderName string, request catalog.PageRequest)) *ACLViewCatalogAdapter_ListMedias_Call

+ func (_c *ACLViewCatalogAdapter_ListMedias_Call) RunAndReturn(run func(string, string, catalog.PageRequest) (*catalog.MediaPage, error)) *ACLViewCatalogAdapter_ListMedias_Call

type ARepositoryAdapter

+ func (_m *ARepositoryAdapter) EXPECT() *ARepositoryAdapter_Expecter

+ type ARepositoryAdapter_AddLocation_Call struct

+ func (_c *ARepositoryAdapter_AddLocation_Call) Return(_a0 error) *ARepositoryAdapter_AddLocation_Call

+ func (_c *ARepositoryAdapter_AddLocation_Call) Run(run func(owner string, id string, key string)) *ARepositoryAdapter_AddLocation_Call

+ func (_c *ARepositoryAdapter_AddLocation_Call) RunAndReturn(run func(string, string, string) error) *ARepositoryAdapter_AddLocation_Call

+ type ARepositoryAdapter_Expecter struct

+ func (_e *ARepositoryAdapter_Expecter) AddLocation(owner interface{}, id interface{}, key interface{}) *ARepositoryAdapter_AddLocation_Call

+ func (_e *ARepositoryAdapter_Expecter) FindById(owner interface{}, id interface{}) *ARepositoryAdapter_FindById_Call

+ func (_e *ARepositoryAdapter_Expecter) FindByIds(owner interface{}, ids interface{}) *ARepositoryAdapter_FindByIds_Call

+ func (_e *ARepositoryAdapter_Expecter) FindIdsFromKeyPrefix(keyPrefix interface{}) *ARepositoryAdapter_FindIdsFromKeyPrefix_Call

+ func (_e *ARepositoryAdapter_Expecter) UpdateLocations(owner interface{}, locations interface{}) *ARepositoryAdapter_UpdateLocations_Call

+ type ARepositoryAdapter_FindById_Call struct

+ func (_c *ARepositoryAdapter_FindById_Call) Return(_a0 string, _a1 error) *ARepositoryAdapter_FindById_Call

+ func (_c *ARepositoryAdapter_FindById_Call) Run(run func(owner string, id string)) *ARepositoryAdapter_FindById_Call

+ func (_c *ARepositoryAdapter_FindById_Call) RunAndReturn(run func(string, string) (string, error)) *ARepositoryAdapter_FindById_Call

+ type ARepositoryAdapter_FindByIds_Call struct

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

+ func (_c *ARepositoryAdapter_FindByIds_Call) Run(run func(owner string, ids []string)) *ARepositoryAdapter_FindByIds_Call

+ func (_c *ARepositoryAdapter_FindByIds_Call) RunAndReturn(run func(string, []string) (map[string]string, error)) *ARepositoryAdapter_FindByIds_Call

+ type ARepositoryAdapter_FindIdsFromKeyPrefix_Call struct

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

+ func (_c *ARepositoryAdapter_FindIdsFromKeyPrefix_Call) Run(run func(keyPrefix string)) *ARepositoryAdapter_FindIdsFromKeyPrefix_Call

+ func (_c *ARepositoryAdapter_FindIdsFromKeyPrefix_Call) RunAndReturn(run func(string) (map[string]string, error)) *ARepositoryAdapter_FindIdsFromKeyPrefix_Call

+ type ARepositoryAdapter_UpdateLocations_Call struct

+ func (_c *ARepositoryAdapter_UpdateLocations_Call) Return(_a0 error) *ARepositoryAdapter_UpdateLocations_Call

+ func (_c *ARepositoryAdapter_UpdateLocations_Call) Run(run func(owner string, locations map[string]string)) *ARepositoryAdapter_UpdateLocations_Call

+ func (_c *ARepositoryAdapter_UpdateLocations_Call) RunAndReturn(run func(string, map[string]string) error) *ARepositoryAdapter_UpdateLocations_Call

type AWSAdapterNames

+ func (_m *AWSAdapterNames) EXPECT() *AWSAdapterNames_Expecter

+ type AWSAdapterNames_ArchiveCacheBucketName_Call struct

+ func (_c *AWSAdapterNames_ArchiveCacheBucketName_Call) Return(_a0 string) *AWSAdapterNames_ArchiveCacheBucketName_Call

+ func (_c *AWSAdapterNames_ArchiveCacheBucketName_Call) Run(run func()) *AWSAdapterNames_ArchiveCacheBucketName_Call

+ func (_c *AWSAdapterNames_ArchiveCacheBucketName_Call) RunAndReturn(run func() string) *AWSAdapterNames_ArchiveCacheBucketName_Call

+ type AWSAdapterNames_ArchiveJobsSNSARN_Call struct

+ func (_c *AWSAdapterNames_ArchiveJobsSNSARN_Call) Return(_a0 string) *AWSAdapterNames_ArchiveJobsSNSARN_Call

+ func (_c *AWSAdapterNames_ArchiveJobsSNSARN_Call) Run(run func()) *AWSAdapterNames_ArchiveJobsSNSARN_Call

+ func (_c *AWSAdapterNames_ArchiveJobsSNSARN_Call) RunAndReturn(run func() string) *AWSAdapterNames_ArchiveJobsSNSARN_Call

+ type AWSAdapterNames_ArchiveJobsSQSURL_Call struct

+ func (_c *AWSAdapterNames_ArchiveJobsSQSURL_Call) Return(_a0 string) *AWSAdapterNames_ArchiveJobsSQSURL_Call

+ func (_c *AWSAdapterNames_ArchiveJobsSQSURL_Call) Run(run func()) *AWSAdapterNames_ArchiveJobsSQSURL_Call

+ func (_c *AWSAdapterNames_ArchiveJobsSQSURL_Call) RunAndReturn(run func() string) *AWSAdapterNames_ArchiveJobsSQSURL_Call

+ type AWSAdapterNames_ArchiveMainBucketName_Call struct

+ func (_c *AWSAdapterNames_ArchiveMainBucketName_Call) Return(_a0 string) *AWSAdapterNames_ArchiveMainBucketName_Call

+ func (_c *AWSAdapterNames_ArchiveMainBucketName_Call) Run(run func()) *AWSAdapterNames_ArchiveMainBucketName_Call

+ func (_c *AWSAdapterNames_ArchiveMainBucketName_Call) RunAndReturn(run func() string) *AWSAdapterNames_ArchiveMainBucketName_Call

+ type AWSAdapterNames_DynamoDBName_Call struct

+ func (_c *AWSAdapterNames_DynamoDBName_Call) Return(_a0 string) *AWSAdapterNames_DynamoDBName_Call

+ func (_c *AWSAdapterNames_DynamoDBName_Call) Run(run func()) *AWSAdapterNames_DynamoDBName_Call

+ func (_c *AWSAdapterNames_DynamoDBName_Call) RunAndReturn(run func() string) *AWSAdapterNames_DynamoDBName_Call

+ type AWSAdapterNames_Expecter struct

+ func (_e *AWSAdapterNames_Expecter) ArchiveCacheBucketName() *AWSAdapterNames_ArchiveCacheBucketName_Call

+ func (_e *AWSAdapterNames_Expecter) ArchiveJobsSNSARN() *AWSAdapterNames_ArchiveJobsSNSARN_Call

+ func (_e *AWSAdapterNames_Expecter) ArchiveJobsSQSURL() *AWSAdapterNames_ArchiveJobsSQSURL_Call

+ func (_e *AWSAdapterNames_Expecter) ArchiveMainBucketName() *AWSAdapterNames_ArchiveMainBucketName_Call

+ func (_e *AWSAdapterNames_Expecter) DynamoDBName() *AWSAdapterNames_DynamoDBName_Call

+ type AlbumCanBeDeletedObserver struct

+ func NewAlbumCanBeDeletedObserver(t interface{ ... }) *AlbumCanBeDeletedObserver

+ func (_m *AlbumCanBeDeletedObserver) EXPECT() *AlbumCanBeDeletedObserver_Expecter

+ func (_m *AlbumCanBeDeletedObserver) Observe(ctx context.Context, deletedAlbum catalog.AlbumId, ...) error

+ type AlbumCanBeDeletedObserver_Expecter struct

+ func (_e *AlbumCanBeDeletedObserver_Expecter) Observe(ctx interface{}, deletedAlbum interface{}, transfers interface{}) *AlbumCanBeDeletedObserver_Observe_Call

+ type AlbumCanBeDeletedObserver_Observe_Call struct

+ func (_c *AlbumCanBeDeletedObserver_Observe_Call) Return(_a0 error) *AlbumCanBeDeletedObserver_Observe_Call

+ func (_c *AlbumCanBeDeletedObserver_Observe_Call) Run(run func(ctx context.Context, deletedAlbum catalog.AlbumId, ...)) *AlbumCanBeDeletedObserver_Observe_Call

+ func (_c *AlbumCanBeDeletedObserver_Observe_Call) RunAndReturn(run func(context.Context, catalog.AlbumId, catalog.MediaTransferRecords) error) *AlbumCanBeDeletedObserver_Observe_Call

type AnalyserDecorator

+ func (_m *AnalyserDecorator) EXPECT() *AnalyserDecorator_Expecter

+ type AnalyserDecorator_Decorate_Call struct

+ func (_c *AnalyserDecorator_Decorate_Call) Return(_a0 backup.RunnerAnalyser) *AnalyserDecorator_Decorate_Call

+ func (_c *AnalyserDecorator_Decorate_Call) Run(run func(analyseFunc backup.RunnerAnalyser)) *AnalyserDecorator_Decorate_Call

+ func (_c *AnalyserDecorator_Decorate_Call) RunAndReturn(run func(backup.RunnerAnalyser) backup.RunnerAnalyser) *AnalyserDecorator_Decorate_Call

+ type AnalyserDecorator_Expecter struct

+ func (_e *AnalyserDecorator_Expecter) Decorate(analyseFunc interface{}) *AnalyserDecorator_Decorate_Call

type AsyncJobAdapter

+ func (_m *AsyncJobAdapter) EXPECT() *AsyncJobAdapter_Expecter

+ type AsyncJobAdapter_Expecter struct

+ func (_e *AsyncJobAdapter_Expecter) LoadImagesInCache(images ...interface{}) *AsyncJobAdapter_LoadImagesInCache_Call

+ func (_e *AsyncJobAdapter_Expecter) WarmUpCacheByFolder(owner interface{}, missedStoreKey interface{}, width interface{}) *AsyncJobAdapter_WarmUpCacheByFolder_Call

+ type AsyncJobAdapter_LoadImagesInCache_Call struct

+ func (_c *AsyncJobAdapter_LoadImagesInCache_Call) Return(_a0 error) *AsyncJobAdapter_LoadImagesInCache_Call

+ func (_c *AsyncJobAdapter_LoadImagesInCache_Call) Run(run func(images ...*archive.ImageToResize)) *AsyncJobAdapter_LoadImagesInCache_Call

+ func (_c *AsyncJobAdapter_LoadImagesInCache_Call) RunAndReturn(run func(...*archive.ImageToResize) error) *AsyncJobAdapter_LoadImagesInCache_Call

+ type AsyncJobAdapter_WarmUpCacheByFolder_Call struct

+ func (_c *AsyncJobAdapter_WarmUpCacheByFolder_Call) Return(_a0 error) *AsyncJobAdapter_WarmUpCacheByFolder_Call

+ func (_c *AsyncJobAdapter_WarmUpCacheByFolder_Call) Run(run func(owner string, missedStoreKey string, width int)) *AsyncJobAdapter_WarmUpCacheByFolder_Call

+ func (_c *AsyncJobAdapter_WarmUpCacheByFolder_Call) RunAndReturn(run func(string, string, int) error) *AsyncJobAdapter_WarmUpCacheByFolder_Call

type BArchiveAdapter

+ func (_m *BArchiveAdapter) EXPECT() *BArchiveAdapter_Expecter

+ type BArchiveAdapter_ArchiveMedia_Call struct

+ func (_c *BArchiveAdapter_ArchiveMedia_Call) Return(_a0 string, _a1 error) *BArchiveAdapter_ArchiveMedia_Call

+ func (_c *BArchiveAdapter_ArchiveMedia_Call) Run(run func(owner string, media *backup.BackingUpMediaRequest)) *BArchiveAdapter_ArchiveMedia_Call

+ func (_c *BArchiveAdapter_ArchiveMedia_Call) RunAndReturn(run func(string, *backup.BackingUpMediaRequest) (string, error)) *BArchiveAdapter_ArchiveMedia_Call

+ type BArchiveAdapter_Expecter struct

+ func (_e *BArchiveAdapter_Expecter) ArchiveMedia(owner interface{}, media interface{}) *BArchiveAdapter_ArchiveMedia_Call

type BackupSuggestionPort

+ func (_m *BackupSuggestionPort) EXPECT() *BackupSuggestionPort_Expecter

+ type BackupSuggestionPort_BackupSuggestion_Call struct

+ func (_c *BackupSuggestionPort_BackupSuggestion_Call) Return(_a0 error) *BackupSuggestionPort_BackupSuggestion_Call

+ func (_c *BackupSuggestionPort_BackupSuggestion_Call) Run(run func(record *ui.SuggestionRecord, existing *ui.ExistingRecord, ...)) *BackupSuggestionPort_BackupSuggestion_Call

+ func (_c *BackupSuggestionPort_BackupSuggestion_Call) RunAndReturn(...) *BackupSuggestionPort_BackupSuggestion_Call

+ type BackupSuggestionPort_Expecter struct

+ func (_e *BackupSuggestionPort_Expecter) BackupSuggestion(record interface{}, existing interface{}, listener interface{}) *BackupSuggestionPort_BackupSuggestion_Call

type CArchiveAdapter

+ func (_m *CArchiveAdapter) EXPECT() *CArchiveAdapter_Expecter

+ type CArchiveAdapter_Expecter struct

+ func (_e *CArchiveAdapter_Expecter) MoveMedias(owner interface{}, ids interface{}, name interface{}) *CArchiveAdapter_MoveMedias_Call

+ func (_e *CArchiveAdapter_Expecter) Observe(ctx interface{}, transfers interface{}) *CArchiveAdapter_Observe_Call

+ type CArchiveAdapter_MoveMedias_Call struct

+ func (_c *CArchiveAdapter_MoveMedias_Call) Return(_a0 error) *CArchiveAdapter_MoveMedias_Call

+ func (_c *CArchiveAdapter_MoveMedias_Call) Run(run func(owner catalog.Owner, ids []catalog.MediaId, name catalog.FolderName)) *CArchiveAdapter_MoveMedias_Call

+ func (_c *CArchiveAdapter_MoveMedias_Call) RunAndReturn(run func(catalog.Owner, []catalog.MediaId, catalog.FolderName) error) *CArchiveAdapter_MoveMedias_Call

+ type CArchiveAdapter_Observe_Call struct

+ func (_c *CArchiveAdapter_Observe_Call) Return(_a0 error) *CArchiveAdapter_Observe_Call

+ func (_c *CArchiveAdapter_Observe_Call) Run(run func(ctx context.Context, transfers catalog.TransferredMedias)) *CArchiveAdapter_Observe_Call

+ func (_c *CArchiveAdapter_Observe_Call) RunAndReturn(run func(context.Context, catalog.TransferredMedias) error) *CArchiveAdapter_Observe_Call

type CacheAdapter

+ func (_m *CacheAdapter) EXPECT() *CacheAdapter_Expecter

+ type CacheAdapter_Expecter struct

+ func (_e *CacheAdapter_Expecter) Get(key interface{}) *CacheAdapter_Get_Call

+ func (_e *CacheAdapter_Expecter) Put(key interface{}, mediaType interface{}, content interface{}) *CacheAdapter_Put_Call

+ func (_e *CacheAdapter_Expecter) SignedURL(key interface{}, duration interface{}) *CacheAdapter_SignedURL_Call

+ func (_e *CacheAdapter_Expecter) WalkCacheByPrefix(prefix interface{}, observer interface{}) *CacheAdapter_WalkCacheByPrefix_Call

+ type CacheAdapter_Get_Call struct

+ func (_c *CacheAdapter_Get_Call) Return(_a0 io.ReadCloser, _a1 int, _a2 string, _a3 error) *CacheAdapter_Get_Call

+ func (_c *CacheAdapter_Get_Call) Run(run func(key string)) *CacheAdapter_Get_Call

+ func (_c *CacheAdapter_Get_Call) RunAndReturn(run func(string) (io.ReadCloser, int, string, error)) *CacheAdapter_Get_Call

+ type CacheAdapter_Put_Call struct

+ func (_c *CacheAdapter_Put_Call) Return(_a0 error) *CacheAdapter_Put_Call

+ func (_c *CacheAdapter_Put_Call) Run(run func(key string, mediaType string, content io.Reader)) *CacheAdapter_Put_Call

+ func (_c *CacheAdapter_Put_Call) RunAndReturn(run func(string, string, io.Reader) error) *CacheAdapter_Put_Call

+ type CacheAdapter_SignedURL_Call struct

+ func (_c *CacheAdapter_SignedURL_Call) Return(_a0 string, _a1 error) *CacheAdapter_SignedURL_Call

+ func (_c *CacheAdapter_SignedURL_Call) Run(run func(key string, duration time.Duration)) *CacheAdapter_SignedURL_Call

+ func (_c *CacheAdapter_SignedURL_Call) RunAndReturn(run func(string, time.Duration) (string, error)) *CacheAdapter_SignedURL_Call

+ type CacheAdapter_WalkCacheByPrefix_Call struct

+ func (_c *CacheAdapter_WalkCacheByPrefix_Call) Return(_a0 error) *CacheAdapter_WalkCacheByPrefix_Call

+ func (_c *CacheAdapter_WalkCacheByPrefix_Call) Run(run func(prefix string, observer func(string))) *CacheAdapter_WalkCacheByPrefix_Call

+ func (_c *CacheAdapter_WalkCacheByPrefix_Call) RunAndReturn(run func(string, func(string)) error) *CacheAdapter_WalkCacheByPrefix_Call

type CatalogAdapter

+ func (_m *CatalogAdapter) EXPECT() *CatalogAdapter_Expecter

+ type CatalogAdapter_AssignIdsToNewMedias_Call struct

+ func (_c *CatalogAdapter_AssignIdsToNewMedias_Call) Return(_a0 map[*backup.AnalysedMedia]string, _a1 error) *CatalogAdapter_AssignIdsToNewMedias_Call

+ func (_c *CatalogAdapter_AssignIdsToNewMedias_Call) Run(run func(owner string, medias []*backup.AnalysedMedia)) *CatalogAdapter_AssignIdsToNewMedias_Call

+ func (_c *CatalogAdapter_AssignIdsToNewMedias_Call) RunAndReturn(...) *CatalogAdapter_AssignIdsToNewMedias_Call

+ type CatalogAdapter_Expecter struct

+ func (_e *CatalogAdapter_Expecter) AssignIdsToNewMedias(owner interface{}, medias interface{}) *CatalogAdapter_AssignIdsToNewMedias_Call

+ func (_e *CatalogAdapter_Expecter) GetAlbumsTimeline(owner interface{}) *CatalogAdapter_GetAlbumsTimeline_Call

+ func (_e *CatalogAdapter_Expecter) IndexMedias(owner interface{}, requests interface{}) *CatalogAdapter_IndexMedias_Call

+ type CatalogAdapter_GetAlbumsTimeline_Call struct

+ func (_c *CatalogAdapter_GetAlbumsTimeline_Call) Return(_a0 backup.TimelineAdapter, _a1 error) *CatalogAdapter_GetAlbumsTimeline_Call

+ func (_c *CatalogAdapter_GetAlbumsTimeline_Call) Run(run func(owner string)) *CatalogAdapter_GetAlbumsTimeline_Call

+ func (_c *CatalogAdapter_GetAlbumsTimeline_Call) RunAndReturn(run func(string) (backup.TimelineAdapter, error)) *CatalogAdapter_GetAlbumsTimeline_Call

+ type CatalogAdapter_IndexMedias_Call struct

+ func (_c *CatalogAdapter_IndexMedias_Call) Return(_a0 error) *CatalogAdapter_IndexMedias_Call

+ func (_c *CatalogAdapter_IndexMedias_Call) Run(run func(owner string, requests []*backup.CatalogMediaRequest)) *CatalogAdapter_IndexMedias_Call

+ func (_c *CatalogAdapter_IndexMedias_Call) RunAndReturn(run func(string, []*backup.CatalogMediaRequest) error) *CatalogAdapter_IndexMedias_Call

type CatalogRules

+ func (_m *CatalogRules) EXPECT() *CatalogRules_Expecter

+ type CatalogRules_CanListMediasFromAlbum_Call struct

+ func (_c *CatalogRules_CanListMediasFromAlbum_Call) Return(_a0 error) *CatalogRules_CanListMediasFromAlbum_Call

+ func (_c *CatalogRules_CanListMediasFromAlbum_Call) Run(run func(owner string, folderName string)) *CatalogRules_CanListMediasFromAlbum_Call

+ func (_c *CatalogRules_CanListMediasFromAlbum_Call) RunAndReturn(run func(string, string) error) *CatalogRules_CanListMediasFromAlbum_Call

+ type CatalogRules_CanManageAlbum_Call struct

+ func (_c *CatalogRules_CanManageAlbum_Call) Return(_a0 error) *CatalogRules_CanManageAlbum_Call

+ func (_c *CatalogRules_CanManageAlbum_Call) Run(run func(owner string, folderName string)) *CatalogRules_CanManageAlbum_Call

+ func (_c *CatalogRules_CanManageAlbum_Call) RunAndReturn(run func(string, string) error) *CatalogRules_CanManageAlbum_Call

+ type CatalogRules_CanReadMedia_Call struct

+ func (_c *CatalogRules_CanReadMedia_Call) Return(_a0 error) *CatalogRules_CanReadMedia_Call

+ func (_c *CatalogRules_CanReadMedia_Call) Run(run func(owner string, id string)) *CatalogRules_CanReadMedia_Call

+ func (_c *CatalogRules_CanReadMedia_Call) RunAndReturn(run func(string, string) error) *CatalogRules_CanReadMedia_Call

+ type CatalogRules_Expecter struct

+ func (_e *CatalogRules_Expecter) CanListMediasFromAlbum(owner interface{}, folderName interface{}) *CatalogRules_CanListMediasFromAlbum_Call

+ func (_e *CatalogRules_Expecter) CanManageAlbum(owner interface{}, folderName interface{}) *CatalogRules_CanManageAlbum_Call

+ func (_e *CatalogRules_Expecter) CanReadMedia(owner interface{}, id interface{}) *CatalogRules_CanReadMedia_Call

+ func (_e *CatalogRules_Expecter) Owner() *CatalogRules_Owner_Call

+ func (_e *CatalogRules_Expecter) SharedByUserGrid(owner interface{}) *CatalogRules_SharedByUserGrid_Call

+ func (_e *CatalogRules_Expecter) SharedWithUserAlbum() *CatalogRules_SharedWithUserAlbum_Call

+ type CatalogRules_Owner_Call struct

+ func (_c *CatalogRules_Owner_Call) Return(_a0 string, _a1 error) *CatalogRules_Owner_Call

+ func (_c *CatalogRules_Owner_Call) Run(run func()) *CatalogRules_Owner_Call

+ func (_c *CatalogRules_Owner_Call) RunAndReturn(run func() (string, error)) *CatalogRules_Owner_Call

+ type CatalogRules_SharedByUserGrid_Call struct

+ func (_c *CatalogRules_SharedByUserGrid_Call) Return(_a0 map[string]map[string]aclcore.ScopeType, _a1 error) *CatalogRules_SharedByUserGrid_Call

+ func (_c *CatalogRules_SharedByUserGrid_Call) Run(run func(owner string)) *CatalogRules_SharedByUserGrid_Call

+ func (_c *CatalogRules_SharedByUserGrid_Call) RunAndReturn(run func(string) (map[string]map[string]aclcore.ScopeType, error)) *CatalogRules_SharedByUserGrid_Call

+ type CatalogRules_SharedWithUserAlbum_Call struct

+ func (_c *CatalogRules_SharedWithUserAlbum_Call) Return(_a0 []catalog.AlbumId, _a1 error) *CatalogRules_SharedWithUserAlbum_Call

+ func (_c *CatalogRules_SharedWithUserAlbum_Call) Run(run func()) *CatalogRules_SharedWithUserAlbum_Call

+ func (_c *CatalogRules_SharedWithUserAlbum_Call) RunAndReturn(run func() ([]catalog.AlbumId, error)) *CatalogRules_SharedWithUserAlbum_Call

type CertificateAuthority

+ func (_m *CertificateAuthority) EXPECT() *CertificateAuthority_Expecter

+ type CertificateAuthority_Expecter struct

+ func (_e *CertificateAuthority_Expecter) RequestCertificate(ctx interface{}, email interface{}, domain interface{}) *CertificateAuthority_RequestCertificate_Call

+ type CertificateAuthority_RequestCertificate_Call struct

+ func (_c *CertificateAuthority_RequestCertificate_Call) Return(_a0 *dnsdomain.CompleteCertificate, _a1 error) *CertificateAuthority_RequestCertificate_Call

+ func (_c *CertificateAuthority_RequestCertificate_Call) Run(run func(ctx context.Context, email string, domain string)) *CertificateAuthority_RequestCertificate_Call

+ func (_c *CertificateAuthority_RequestCertificate_Call) RunAndReturn(...) *CertificateAuthority_RequestCertificate_Call

type CertificateManager

+ func (_m *CertificateManager) EXPECT() *CertificateManager_Expecter

+ type CertificateManager_Expecter struct

+ func (_e *CertificateManager_Expecter) FindCertificate(ctx interface{}, domain interface{}) *CertificateManager_FindCertificate_Call

+ func (_e *CertificateManager_Expecter) InstallCertificate(ctx interface{}, id interface{}, certificate interface{}) *CertificateManager_InstallCertificate_Call

+ type CertificateManager_FindCertificate_Call struct

+ func (_c *CertificateManager_FindCertificate_Call) Return(_a0 *dnsdomain.ExistingCertificate, _a1 error) *CertificateManager_FindCertificate_Call

+ func (_c *CertificateManager_FindCertificate_Call) Run(run func(ctx context.Context, domain string)) *CertificateManager_FindCertificate_Call

+ func (_c *CertificateManager_FindCertificate_Call) RunAndReturn(run func(context.Context, string) (*dnsdomain.ExistingCertificate, error)) *CertificateManager_FindCertificate_Call

+ type CertificateManager_InstallCertificate_Call struct

+ func (_c *CertificateManager_InstallCertificate_Call) Return(_a0 error) *CertificateManager_InstallCertificate_Call

+ func (_c *CertificateManager_InstallCertificate_Call) Run(...) *CertificateManager_InstallCertificate_Call

+ func (_c *CertificateManager_InstallCertificate_Call) RunAndReturn(run func(context.Context, string, dnsdomain.CompleteCertificate) error) *CertificateManager_InstallCertificate_Call

type ClosableFoundMedia

+ func (_m *ClosableFoundMedia) EXPECT() *ClosableFoundMedia_Expecter

+ type ClosableFoundMedia_Close_Call struct

+ func (_c *ClosableFoundMedia_Close_Call) Return(_a0 error) *ClosableFoundMedia_Close_Call

+ func (_c *ClosableFoundMedia_Close_Call) Run(run func()) *ClosableFoundMedia_Close_Call

+ func (_c *ClosableFoundMedia_Close_Call) RunAndReturn(run func() error) *ClosableFoundMedia_Close_Call

+ type ClosableFoundMedia_Expecter struct

+ func (_e *ClosableFoundMedia_Expecter) Close() *ClosableFoundMedia_Close_Call

type CompletionReport

+ func (_m *CompletionReport) EXPECT() *CompletionReport_Expecter

+ type CompletionReport_CountPerAlbum_Call struct

+ func (_c *CompletionReport_CountPerAlbum_Call) Return(_a0 map[string]*backup.TypeCounter) *CompletionReport_CountPerAlbum_Call

+ func (_c *CompletionReport_CountPerAlbum_Call) Run(run func()) *CompletionReport_CountPerAlbum_Call

+ func (_c *CompletionReport_CountPerAlbum_Call) RunAndReturn(run func() map[string]*backup.TypeCounter) *CompletionReport_CountPerAlbum_Call

+ type CompletionReport_Expecter struct

+ func (_e *CompletionReport_Expecter) CountPerAlbum() *CompletionReport_CountPerAlbum_Call

+ func (_e *CompletionReport_Expecter) NewAlbums() *CompletionReport_NewAlbums_Call

+ func (_e *CompletionReport_Expecter) Skipped() *CompletionReport_Skipped_Call

+ type CompletionReport_NewAlbums_Call struct

+ func (_c *CompletionReport_NewAlbums_Call) Return(_a0 []string) *CompletionReport_NewAlbums_Call

+ func (_c *CompletionReport_NewAlbums_Call) Run(run func()) *CompletionReport_NewAlbums_Call

+ func (_c *CompletionReport_NewAlbums_Call) RunAndReturn(run func() []string) *CompletionReport_NewAlbums_Call

+ type CompletionReport_Skipped_Call struct

+ func (_c *CompletionReport_Skipped_Call) Return(_a0 backup.MediaCounter) *CompletionReport_Skipped_Call

+ func (_c *CompletionReport_Skipped_Call) Run(run func()) *CompletionReport_Skipped_Call

+ func (_c *CompletionReport_Skipped_Call) RunAndReturn(run func() backup.MediaCounter) *CompletionReport_Skipped_Call

type Config

+ func (_m *Config) EXPECT() *Config_Expecter

type ConfigFactory

+ func (_m *ConfigFactory) EXPECT() *ConfigFactory_Expecter

type ConfigFactoryFunc

+ func (_m *ConfigFactoryFunc) EXPECT() *ConfigFactoryFunc_Expecter

+ type ConfigFactoryFunc_Execute_Call struct

+ func (_c *ConfigFactoryFunc_Execute_Call) Return(_a0 aws.Config, _a1 error) *ConfigFactoryFunc_Execute_Call

+ func (_c *ConfigFactoryFunc_Execute_Call) Run(run func(ctx context.Context)) *ConfigFactoryFunc_Execute_Call

+ func (_c *ConfigFactoryFunc_Execute_Call) RunAndReturn(run func(context.Context) (aws.Config, error)) *ConfigFactoryFunc_Execute_Call

+ type ConfigFactoryFunc_Expecter struct

+ func (_e *ConfigFactoryFunc_Expecter) Execute(ctx interface{}) *ConfigFactoryFunc_Execute_Call

+ type ConfigFactory_Expecter struct

+ func (_e *ConfigFactory_Expecter) NewConfig(ctx interface{}) *ConfigFactory_NewConfig_Call

+ type ConfigFactory_NewConfig_Call struct

+ func (_c *ConfigFactory_NewConfig_Call) Return(_a0 aws.Config, _a1 error) *ConfigFactory_NewConfig_Call

+ func (_c *ConfigFactory_NewConfig_Call) Run(run func(ctx context.Context)) *ConfigFactory_NewConfig_Call

+ func (_c *ConfigFactory_NewConfig_Call) RunAndReturn(run func(context.Context) (aws.Config, error)) *ConfigFactory_NewConfig_Call

+ type Config_Expecter struct

+ func (_e *Config_Expecter) Get(key interface{}) *Config_Get_Call

+ func (_e *Config_Expecter) GetAWSFactory() *Config_GetAWSFactory_Call

+ func (_e *Config_Expecter) GetAWSV2Config() *Config_GetAWSV2Config_Call

+ func (_e *Config_Expecter) GetBool(key interface{}) *Config_GetBool_Call

+ func (_e *Config_Expecter) GetInt(key interface{}) *Config_GetInt_Call

+ func (_e *Config_Expecter) GetIntOrDefault(key interface{}, defaultValue interface{}) *Config_GetIntOrDefault_Call

+ func (_e *Config_Expecter) GetString(key interface{}) *Config_GetString_Call

+ func (_e *Config_Expecter) GetStringOrDefault(key interface{}, defaultValue interface{}) *Config_GetStringOrDefault_Call

+ type Config_GetAWSFactory_Call struct

+ func (_c *Config_GetAWSFactory_Call) Return(_a0 *awsfactory.AWSFactory) *Config_GetAWSFactory_Call

+ func (_c *Config_GetAWSFactory_Call) Run(run func()) *Config_GetAWSFactory_Call

+ func (_c *Config_GetAWSFactory_Call) RunAndReturn(run func() *awsfactory.AWSFactory) *Config_GetAWSFactory_Call

+ type Config_GetAWSV2Config_Call struct

+ func (_c *Config_GetAWSV2Config_Call) Return(_a0 aws.Config) *Config_GetAWSV2Config_Call

+ func (_c *Config_GetAWSV2Config_Call) Run(run func()) *Config_GetAWSV2Config_Call

+ func (_c *Config_GetAWSV2Config_Call) RunAndReturn(run func() aws.Config) *Config_GetAWSV2Config_Call

+ type Config_GetBool_Call struct

+ func (_c *Config_GetBool_Call) Return(_a0 bool) *Config_GetBool_Call

+ func (_c *Config_GetBool_Call) Run(run func(key string)) *Config_GetBool_Call

+ func (_c *Config_GetBool_Call) RunAndReturn(run func(string) bool) *Config_GetBool_Call

+ type Config_GetIntOrDefault_Call struct

+ func (_c *Config_GetIntOrDefault_Call) Return(_a0 int) *Config_GetIntOrDefault_Call

+ func (_c *Config_GetIntOrDefault_Call) Run(run func(key string, defaultValue int)) *Config_GetIntOrDefault_Call

+ func (_c *Config_GetIntOrDefault_Call) RunAndReturn(run func(string, int) int) *Config_GetIntOrDefault_Call

+ type Config_GetInt_Call struct

+ func (_c *Config_GetInt_Call) Return(_a0 int) *Config_GetInt_Call

+ func (_c *Config_GetInt_Call) Run(run func(key string)) *Config_GetInt_Call

+ func (_c *Config_GetInt_Call) RunAndReturn(run func(string) int) *Config_GetInt_Call

+ type Config_GetStringOrDefault_Call struct

+ func (_c *Config_GetStringOrDefault_Call) Return(_a0 string) *Config_GetStringOrDefault_Call

+ func (_c *Config_GetStringOrDefault_Call) Run(run func(key string, defaultValue string)) *Config_GetStringOrDefault_Call

+ func (_c *Config_GetStringOrDefault_Call) RunAndReturn(run func(string, string) string) *Config_GetStringOrDefault_Call

+ type Config_GetString_Call struct

+ func (_c *Config_GetString_Call) Return(_a0 string) *Config_GetString_Call

+ func (_c *Config_GetString_Call) Run(run func(key string)) *Config_GetString_Call

+ func (_c *Config_GetString_Call) RunAndReturn(run func(string) string) *Config_GetString_Call

+ type Config_Get_Call struct

+ func (_c *Config_Get_Call) Return(_a0 interface{}) *Config_Get_Call

+ func (_c *Config_Get_Call) Run(run func(key string)) *Config_Get_Call

+ func (_c *Config_Get_Call) RunAndReturn(run func(string) interface{}) *Config_Get_Call

+ type CountMediasBySelectorsFunc struct

+ func NewCountMediasBySelectorsFunc(t interface{ ... }) *CountMediasBySelectorsFunc

+ func (_m *CountMediasBySelectorsFunc) EXPECT() *CountMediasBySelectorsFunc_Expecter

+ func (_m *CountMediasBySelectorsFunc) Execute(ctx context.Context, owner catalog.Owner, selectors []catalog.MediaSelector) (int, error)

+ type CountMediasBySelectorsFunc_Execute_Call struct

+ func (_c *CountMediasBySelectorsFunc_Execute_Call) Return(_a0 int, _a1 error) *CountMediasBySelectorsFunc_Execute_Call

+ func (_c *CountMediasBySelectorsFunc_Execute_Call) Run(...) *CountMediasBySelectorsFunc_Execute_Call

+ func (_c *CountMediasBySelectorsFunc_Execute_Call) RunAndReturn(run func(context.Context, catalog.Owner, []catalog.MediaSelector) (int, error)) *CountMediasBySelectorsFunc_Execute_Call

+ type CountMediasBySelectorsFunc_Expecter struct

+ func (_e *CountMediasBySelectorsFunc_Expecter) Execute(ctx interface{}, owner interface{}, selectors interface{}) *CountMediasBySelectorsFunc_Execute_Call

+ type CountMediasBySelectorsPort struct

+ func NewCountMediasBySelectorsPort(t interface{ ... }) *CountMediasBySelectorsPort

+ func (_m *CountMediasBySelectorsPort) CountMediasBySelectors(ctx context.Context, owner catalog.Owner, selectors []catalog.MediaSelector) (int, error)

+ func (_m *CountMediasBySelectorsPort) EXPECT() *CountMediasBySelectorsPort_Expecter

+ type CountMediasBySelectorsPort_CountMediasBySelectors_Call struct

+ func (_c *CountMediasBySelectorsPort_CountMediasBySelectors_Call) Return(_a0 int, _a1 error) *CountMediasBySelectorsPort_CountMediasBySelectors_Call

+ func (_c *CountMediasBySelectorsPort_CountMediasBySelectors_Call) Run(...) *CountMediasBySelectorsPort_CountMediasBySelectors_Call

+ func (_c *CountMediasBySelectorsPort_CountMediasBySelectors_Call) RunAndReturn(run func(context.Context, catalog.Owner, []catalog.MediaSelector) (int, error)) *CountMediasBySelectorsPort_CountMediasBySelectors_Call

+ type CountMediasBySelectorsPort_Expecter struct

+ func (_e *CountMediasBySelectorsPort_Expecter) CountMediasBySelectors(ctx interface{}, owner interface{}, selectors interface{}) *CountMediasBySelectorsPort_CountMediasBySelectors_Call

type CreateAlbumPort

+ func (_m *CreateAlbumPort) EXPECT() *CreateAlbumPort_Expecter

+ type CreateAlbumPort_Create_Call struct

+ func (_c *CreateAlbumPort_Create_Call) Return(_a0 error) *CreateAlbumPort_Create_Call

+ func (_c *CreateAlbumPort_Create_Call) Run(run func(createRequest ui.RecordCreation)) *CreateAlbumPort_Create_Call

+ func (_c *CreateAlbumPort_Create_Call) RunAndReturn(run func(ui.RecordCreation) error) *CreateAlbumPort_Create_Call

+ type CreateAlbumPort_Expecter struct

+ func (_e *CreateAlbumPort_Expecter) Create(createRequest interface{}) *CreateAlbumPort_Create_Call

type DeleteAlbumPort

+ func (_m *DeleteAlbumPort) EXPECT() *DeleteAlbumPort_Expecter

+ type DeleteAlbumPort_DeleteAlbum_Call struct

+ func (_c *DeleteAlbumPort_DeleteAlbum_Call) Return(_a0 error) *DeleteAlbumPort_DeleteAlbum_Call

+ func (_c *DeleteAlbumPort_DeleteAlbum_Call) Run(run func(folderName string)) *DeleteAlbumPort_DeleteAlbum_Call

+ func (_c *DeleteAlbumPort_DeleteAlbum_Call) RunAndReturn(run func(string) error) *DeleteAlbumPort_DeleteAlbum_Call

+ type DeleteAlbumPort_Expecter struct

+ func (_e *DeleteAlbumPort_Expecter) DeleteAlbum(folderName interface{}) *DeleteAlbumPort_DeleteAlbum_Call

+ type DeleteAlbumRepositoryFunc struct

+ func NewDeleteAlbumRepositoryFunc(t interface{ ... }) *DeleteAlbumRepositoryFunc

+ func (_m *DeleteAlbumRepositoryFunc) EXPECT() *DeleteAlbumRepositoryFunc_Expecter

+ func (_m *DeleteAlbumRepositoryFunc) Execute(ctx context.Context, albumId catalog.AlbumId) error

+ type DeleteAlbumRepositoryFunc_Execute_Call struct

+ func (_c *DeleteAlbumRepositoryFunc_Execute_Call) Return(_a0 error) *DeleteAlbumRepositoryFunc_Execute_Call

+ func (_c *DeleteAlbumRepositoryFunc_Execute_Call) Run(run func(ctx context.Context, albumId catalog.AlbumId)) *DeleteAlbumRepositoryFunc_Execute_Call

+ func (_c *DeleteAlbumRepositoryFunc_Execute_Call) RunAndReturn(run func(context.Context, catalog.AlbumId) error) *DeleteAlbumRepositoryFunc_Execute_Call

+ type DeleteAlbumRepositoryFunc_Expecter struct

+ func (_e *DeleteAlbumRepositoryFunc_Expecter) Execute(ctx interface{}, albumId interface{}) *DeleteAlbumRepositoryFunc_Execute_Call

+ type DeleteAlbumRepositoryPort struct

+ func NewDeleteAlbumRepositoryPort(t interface{ ... }) *DeleteAlbumRepositoryPort

+ func (_m *DeleteAlbumRepositoryPort) DeleteAlbum(ctx context.Context, albumId catalog.AlbumId) error

+ func (_m *DeleteAlbumRepositoryPort) EXPECT() *DeleteAlbumRepositoryPort_Expecter

+ type DeleteAlbumRepositoryPort_DeleteAlbum_Call struct

+ func (_c *DeleteAlbumRepositoryPort_DeleteAlbum_Call) Return(_a0 error) *DeleteAlbumRepositoryPort_DeleteAlbum_Call

+ func (_c *DeleteAlbumRepositoryPort_DeleteAlbum_Call) Run(run func(ctx context.Context, albumId catalog.AlbumId)) *DeleteAlbumRepositoryPort_DeleteAlbum_Call

+ func (_c *DeleteAlbumRepositoryPort_DeleteAlbum_Call) RunAndReturn(run func(context.Context, catalog.AlbumId) error) *DeleteAlbumRepositoryPort_DeleteAlbum_Call

+ type DeleteAlbumRepositoryPort_Expecter struct

+ func (_e *DeleteAlbumRepositoryPort_Expecter) DeleteAlbum(ctx interface{}, albumId interface{}) *DeleteAlbumRepositoryPort_DeleteAlbum_Call

type DetailsReaderAdapter

+ func (_m *DetailsReaderAdapter) EXPECT() *DetailsReaderAdapter_Expecter

+ type DetailsReaderAdapter_Expecter struct

+ func (_e *DetailsReaderAdapter_Expecter) ReadDetails(reader interface{}, options interface{}) *DetailsReaderAdapter_ReadDetails_Call

+ func (_e *DetailsReaderAdapter_Expecter) Supports(media interface{}, mediaType interface{}) *DetailsReaderAdapter_Supports_Call

+ type DetailsReaderAdapter_ReadDetails_Call struct

+ func (_c *DetailsReaderAdapter_ReadDetails_Call) Return(_a0 *backup.MediaDetails, _a1 error) *DetailsReaderAdapter_ReadDetails_Call

+ func (_c *DetailsReaderAdapter_ReadDetails_Call) Run(run func(reader io.Reader, options backup.DetailsReaderOptions)) *DetailsReaderAdapter_ReadDetails_Call

+ func (_c *DetailsReaderAdapter_ReadDetails_Call) RunAndReturn(run func(io.Reader, backup.DetailsReaderOptions) (*backup.MediaDetails, error)) *DetailsReaderAdapter_ReadDetails_Call

+ type DetailsReaderAdapter_Supports_Call struct

+ func (_c *DetailsReaderAdapter_Supports_Call) Return(_a0 bool) *DetailsReaderAdapter_Supports_Call

+ func (_c *DetailsReaderAdapter_Supports_Call) Run(run func(media backup.FoundMedia, mediaType backup.MediaType)) *DetailsReaderAdapter_Supports_Call

+ func (_c *DetailsReaderAdapter_Supports_Call) RunAndReturn(run func(backup.FoundMedia, backup.MediaType) bool) *DetailsReaderAdapter_Supports_Call

type DynamoBatchGetItem

+ func (_m *DynamoBatchGetItem) EXPECT() *DynamoBatchGetItem_Expecter

+ type DynamoBatchGetItem_BatchGetItem_Call struct

+ func (_c *DynamoBatchGetItem_BatchGetItem_Call) Return(_a0 *dynamodb.BatchGetItemOutput, _a1 error) *DynamoBatchGetItem_BatchGetItem_Call

+ func (_c *DynamoBatchGetItem_BatchGetItem_Call) Run(run func(ctx context.Context, params *dynamodb.BatchGetItemInput, ...)) *DynamoBatchGetItem_BatchGetItem_Call

+ func (_c *DynamoBatchGetItem_BatchGetItem_Call) RunAndReturn(...) *DynamoBatchGetItem_BatchGetItem_Call

+ type DynamoBatchGetItem_Expecter struct

+ func (_e *DynamoBatchGetItem_Expecter) BatchGetItem(ctx interface{}, params interface{}, optFns ...interface{}) *DynamoBatchGetItem_BatchGetItem_Call

type DynamoBatchWriteItem

+ func (_m *DynamoBatchWriteItem) EXPECT() *DynamoBatchWriteItem_Expecter

+ type DynamoBatchWriteItem_BatchWriteItem_Call struct

+ func (_c *DynamoBatchWriteItem_BatchWriteItem_Call) Return(_a0 *dynamodb.BatchWriteItemOutput, _a1 error) *DynamoBatchWriteItem_BatchWriteItem_Call

+ func (_c *DynamoBatchWriteItem_BatchWriteItem_Call) Run(run func(ctx context.Context, params *dynamodb.BatchWriteItemInput, ...)) *DynamoBatchWriteItem_BatchWriteItem_Call

+ func (_c *DynamoBatchWriteItem_BatchWriteItem_Call) RunAndReturn(...) *DynamoBatchWriteItem_BatchWriteItem_Call

+ type DynamoBatchWriteItem_Expecter struct

+ func (_e *DynamoBatchWriteItem_Expecter) BatchWriteItem(ctx interface{}, params interface{}, optFns ...interface{}) *DynamoBatchWriteItem_BatchWriteItem_Call

type DynamoQuery

+ func (_m *DynamoQuery) EXPECT() *DynamoQuery_Expecter

+ type DynamoQuery_Expecter struct

+ func (_e *DynamoQuery_Expecter) Query(ctx interface{}, d interface{}, optFns ...interface{}) *DynamoQuery_Query_Call

+ type DynamoQuery_Query_Call struct

+ func (_c *DynamoQuery_Query_Call) Return(_a0 *dynamodb.QueryOutput, _a1 error) *DynamoQuery_Query_Call

+ func (_c *DynamoQuery_Query_Call) Run(...) *DynamoQuery_Query_Call

+ func (_c *DynamoQuery_Query_Call) RunAndReturn(...) *DynamoQuery_Query_Call

type ExistingRecordRepositoryPort

+ func (_m *ExistingRecordRepositoryPort) EXPECT() *ExistingRecordRepositoryPort_Expecter

+ type ExistingRecordRepositoryPort_Expecter struct

+ func (_e *ExistingRecordRepositoryPort_Expecter) FindExistingRecords() *ExistingRecordRepositoryPort_FindExistingRecords_Call

+ type ExistingRecordRepositoryPort_FindExistingRecords_Call struct

+ func (_c *ExistingRecordRepositoryPort_FindExistingRecords_Call) Return(_a0 []*ui.ExistingRecord, _a1 error) *ExistingRecordRepositoryPort_FindExistingRecords_Call

+ func (_c *ExistingRecordRepositoryPort_FindExistingRecords_Call) Run(run func()) *ExistingRecordRepositoryPort_FindExistingRecords_Call

+ func (_c *ExistingRecordRepositoryPort_FindExistingRecords_Call) RunAndReturn(run func() ([]*ui.ExistingRecord, error)) *ExistingRecordRepositoryPort_FindExistingRecords_Call

+ type FindAlbumsByOwnerFunc struct

+ func NewFindAlbumsByOwnerFunc(t interface{ ... }) *FindAlbumsByOwnerFunc

+ func (_m *FindAlbumsByOwnerFunc) EXPECT() *FindAlbumsByOwnerFunc_Expecter

+ func (_m *FindAlbumsByOwnerFunc) Execute(ctx context.Context, owner catalog.Owner) ([]*catalog.Album, error)

+ type FindAlbumsByOwnerFunc_Execute_Call struct

+ func (_c *FindAlbumsByOwnerFunc_Execute_Call) Return(_a0 []*catalog.Album, _a1 error) *FindAlbumsByOwnerFunc_Execute_Call

+ func (_c *FindAlbumsByOwnerFunc_Execute_Call) Run(run func(ctx context.Context, owner catalog.Owner)) *FindAlbumsByOwnerFunc_Execute_Call

+ func (_c *FindAlbumsByOwnerFunc_Execute_Call) RunAndReturn(run func(context.Context, catalog.Owner) ([]*catalog.Album, error)) *FindAlbumsByOwnerFunc_Execute_Call

+ type FindAlbumsByOwnerFunc_Expecter struct

+ func (_e *FindAlbumsByOwnerFunc_Expecter) Execute(ctx interface{}, owner interface{}) *FindAlbumsByOwnerFunc_Execute_Call

type FindAlbumsByOwnerPort

+ func (_m *FindAlbumsByOwnerPort) EXPECT() *FindAlbumsByOwnerPort_Expecter

+ type FindAlbumsByOwnerPort_Expecter struct

+ func (_e *FindAlbumsByOwnerPort_Expecter) FindAlbumsByOwner(ctx interface{}, owner interface{}) *FindAlbumsByOwnerPort_FindAlbumsByOwner_Call

+ type FindAlbumsByOwnerPort_FindAlbumsByOwner_Call struct

+ func (_c *FindAlbumsByOwnerPort_FindAlbumsByOwner_Call) Return(_a0 []*catalog.Album, _a1 error) *FindAlbumsByOwnerPort_FindAlbumsByOwner_Call

+ func (_c *FindAlbumsByOwnerPort_FindAlbumsByOwner_Call) Run(run func(ctx context.Context, owner catalog.Owner)) *FindAlbumsByOwnerPort_FindAlbumsByOwner_Call

+ func (_c *FindAlbumsByOwnerPort_FindAlbumsByOwner_Call) RunAndReturn(run func(context.Context, catalog.Owner) ([]*catalog.Album, error)) *FindAlbumsByOwnerPort_FindAlbumsByOwner_Call

type FoundMedia

+ func (_m *FoundMedia) EXPECT() *FoundMedia_Expecter

+ type FoundMedia_Expecter struct

+ func (_e *FoundMedia_Expecter) LastModification() *FoundMedia_LastModification_Call

+ func (_e *FoundMedia_Expecter) MediaPath() *FoundMedia_MediaPath_Call

+ func (_e *FoundMedia_Expecter) ReadMedia() *FoundMedia_ReadMedia_Call

+ func (_e *FoundMedia_Expecter) Size() *FoundMedia_Size_Call

+ func (_e *FoundMedia_Expecter) String() *FoundMedia_String_Call

+ type FoundMedia_LastModification_Call struct

+ func (_c *FoundMedia_LastModification_Call) Return(_a0 time.Time) *FoundMedia_LastModification_Call

+ func (_c *FoundMedia_LastModification_Call) Run(run func()) *FoundMedia_LastModification_Call

+ func (_c *FoundMedia_LastModification_Call) RunAndReturn(run func() time.Time) *FoundMedia_LastModification_Call

+ type FoundMedia_MediaPath_Call struct

+ func (_c *FoundMedia_MediaPath_Call) Return(_a0 backup.MediaPath) *FoundMedia_MediaPath_Call

+ func (_c *FoundMedia_MediaPath_Call) Run(run func()) *FoundMedia_MediaPath_Call

+ func (_c *FoundMedia_MediaPath_Call) RunAndReturn(run func() backup.MediaPath) *FoundMedia_MediaPath_Call

+ type FoundMedia_ReadMedia_Call struct

+ func (_c *FoundMedia_ReadMedia_Call) Return(_a0 io.ReadCloser, _a1 error) *FoundMedia_ReadMedia_Call

+ func (_c *FoundMedia_ReadMedia_Call) Run(run func()) *FoundMedia_ReadMedia_Call

+ func (_c *FoundMedia_ReadMedia_Call) RunAndReturn(run func() (io.ReadCloser, error)) *FoundMedia_ReadMedia_Call

+ type FoundMedia_Size_Call struct

+ func (_c *FoundMedia_Size_Call) Return(_a0 int) *FoundMedia_Size_Call

+ func (_c *FoundMedia_Size_Call) Run(run func()) *FoundMedia_Size_Call

+ func (_c *FoundMedia_Size_Call) RunAndReturn(run func() int) *FoundMedia_Size_Call

+ type FoundMedia_String_Call struct

+ func (_c *FoundMedia_String_Call) Return(_a0 string) *FoundMedia_String_Call

+ func (_c *FoundMedia_String_Call) Run(run func()) *FoundMedia_String_Call

+ func (_c *FoundMedia_String_Call) RunAndReturn(run func() string) *FoundMedia_String_Call

type GetStreamAdapter

+ func (_m *GetStreamAdapter) EXPECT() *GetStreamAdapter_Expecter

+ type GetStreamAdapter_BatchGet_Call struct

+ func (_c *GetStreamAdapter_BatchGet_Call) Return(_a0 *dynamodb.BatchGetItemOutput, _a1 error) *GetStreamAdapter_BatchGet_Call

+ func (_c *GetStreamAdapter_BatchGet_Call) Run(run func(ctx context.Context, key []map[string]types.AttributeValue)) *GetStreamAdapter_BatchGet_Call

+ func (_c *GetStreamAdapter_BatchGet_Call) RunAndReturn(...) *GetStreamAdapter_BatchGet_Call

+ type GetStreamAdapter_Expecter struct

+ func (_e *GetStreamAdapter_Expecter) BatchGet(ctx interface{}, key interface{}) *GetStreamAdapter_BatchGet_Call

type GrantRepository

+ func (_m *GrantRepository) EXPECT() *GrantRepository_Expecter

+ type GrantRepository_DeleteScopes_Call struct

+ func (_c *GrantRepository_DeleteScopes_Call) Return(_a0 error) *GrantRepository_DeleteScopes_Call

+ func (_c *GrantRepository_DeleteScopes_Call) Run(run func(id ...aclcore.ScopeId)) *GrantRepository_DeleteScopes_Call

+ func (_c *GrantRepository_DeleteScopes_Call) RunAndReturn(run func(...aclcore.ScopeId) error) *GrantRepository_DeleteScopes_Call

+ type GrantRepository_Expecter struct

+ func (_e *GrantRepository_Expecter) DeleteScopes(id ...interface{}) *GrantRepository_DeleteScopes_Call

+ func (_e *GrantRepository_Expecter) FindScopesById(ids ...interface{}) *GrantRepository_FindScopesById_Call

+ func (_e *GrantRepository_Expecter) ListOwnerScopes(owner interface{}, types ...interface{}) *GrantRepository_ListOwnerScopes_Call

+ func (_e *GrantRepository_Expecter) ListScopesByOwners(owners interface{}, types ...interface{}) *GrantRepository_ListScopesByOwners_Call

+ func (_e *GrantRepository_Expecter) ListUserScopes(email interface{}, types ...interface{}) *GrantRepository_ListUserScopes_Call

+ func (_e *GrantRepository_Expecter) SaveIfNewScope(scope interface{}) *GrantRepository_SaveIfNewScope_Call

+ type GrantRepository_FindScopesById_Call struct

+ func (_c *GrantRepository_FindScopesById_Call) Return(_a0 []*aclcore.Scope, _a1 error) *GrantRepository_FindScopesById_Call

+ func (_c *GrantRepository_FindScopesById_Call) Run(run func(ids ...aclcore.ScopeId)) *GrantRepository_FindScopesById_Call

+ func (_c *GrantRepository_FindScopesById_Call) RunAndReturn(run func(...aclcore.ScopeId) ([]*aclcore.Scope, error)) *GrantRepository_FindScopesById_Call

+ type GrantRepository_ListOwnerScopes_Call struct

+ func (_c *GrantRepository_ListOwnerScopes_Call) Return(_a0 []*aclcore.Scope, _a1 error) *GrantRepository_ListOwnerScopes_Call

+ func (_c *GrantRepository_ListOwnerScopes_Call) Run(run func(owner string, types ...aclcore.ScopeType)) *GrantRepository_ListOwnerScopes_Call

+ func (_c *GrantRepository_ListOwnerScopes_Call) RunAndReturn(run func(string, ...aclcore.ScopeType) ([]*aclcore.Scope, error)) *GrantRepository_ListOwnerScopes_Call

+ type GrantRepository_ListScopesByOwners_Call struct

+ func (_c *GrantRepository_ListScopesByOwners_Call) Return(_a0 []*aclcore.Scope, _a1 error) *GrantRepository_ListScopesByOwners_Call

+ func (_c *GrantRepository_ListScopesByOwners_Call) Run(run func(owners []string, types ...aclcore.ScopeType)) *GrantRepository_ListScopesByOwners_Call

+ func (_c *GrantRepository_ListScopesByOwners_Call) RunAndReturn(run func([]string, ...aclcore.ScopeType) ([]*aclcore.Scope, error)) *GrantRepository_ListScopesByOwners_Call

+ type GrantRepository_ListUserScopes_Call struct

+ func (_c *GrantRepository_ListUserScopes_Call) Return(_a0 []*aclcore.Scope, _a1 error) *GrantRepository_ListUserScopes_Call

+ func (_c *GrantRepository_ListUserScopes_Call) Run(run func(email string, types ...aclcore.ScopeType)) *GrantRepository_ListUserScopes_Call

+ func (_c *GrantRepository_ListUserScopes_Call) RunAndReturn(run func(string, ...aclcore.ScopeType) ([]*aclcore.Scope, error)) *GrantRepository_ListUserScopes_Call

+ type GrantRepository_SaveIfNewScope_Call struct

+ func (_c *GrantRepository_SaveIfNewScope_Call) Return(_a0 error) *GrantRepository_SaveIfNewScope_Call

+ func (_c *GrantRepository_SaveIfNewScope_Call) Run(run func(scope aclcore.Scope)) *GrantRepository_SaveIfNewScope_Call

+ func (_c *GrantRepository_SaveIfNewScope_Call) RunAndReturn(run func(aclcore.Scope) error) *GrantRepository_SaveIfNewScope_Call

type IAccessTokenGenerator

+ func (_m *IAccessTokenGenerator) EXPECT() *IAccessTokenGenerator_Expecter

+ type IAccessTokenGenerator_Expecter struct

+ func (_e *IAccessTokenGenerator_Expecter) GenerateAccessToken(email interface{}) *IAccessTokenGenerator_GenerateAccessToken_Call

+ type IAccessTokenGenerator_GenerateAccessToken_Call struct

+ func (_c *IAccessTokenGenerator_GenerateAccessToken_Call) Return(_a0 *aclcore.Authentication, _a1 error) *IAccessTokenGenerator_GenerateAccessToken_Call

+ func (_c *IAccessTokenGenerator_GenerateAccessToken_Call) Run(run func(email string)) *IAccessTokenGenerator_GenerateAccessToken_Call

+ func (_c *IAccessTokenGenerator_GenerateAccessToken_Call) RunAndReturn(run func(string) (*aclcore.Authentication, error)) *IAccessTokenGenerator_GenerateAccessToken_Call

type IRefreshTokenGenerator

+ func (_m *IRefreshTokenGenerator) EXPECT() *IRefreshTokenGenerator_Expecter

+ type IRefreshTokenGenerator_Expecter struct

+ func (_e *IRefreshTokenGenerator_Expecter) GenerateRefreshToken(spec interface{}) *IRefreshTokenGenerator_GenerateRefreshToken_Call

+ type IRefreshTokenGenerator_GenerateRefreshToken_Call struct

+ func (_c *IRefreshTokenGenerator_GenerateRefreshToken_Call) Return(_a0 string, _a1 error) *IRefreshTokenGenerator_GenerateRefreshToken_Call

+ func (_c *IRefreshTokenGenerator_GenerateRefreshToken_Call) Run(run func(spec aclcore.RefreshTokenSpec)) *IRefreshTokenGenerator_GenerateRefreshToken_Call

+ func (_c *IRefreshTokenGenerator_GenerateRefreshToken_Call) RunAndReturn(run func(aclcore.RefreshTokenSpec) (string, error)) *IRefreshTokenGenerator_GenerateRefreshToken_Call

type IdentityDetailsStore

+ func (_m *IdentityDetailsStore) EXPECT() *IdentityDetailsStore_Expecter

+ type IdentityDetailsStore_Expecter struct

+ func (_e *IdentityDetailsStore_Expecter) FindIdentity(email interface{}) *IdentityDetailsStore_FindIdentity_Call

+ func (_e *IdentityDetailsStore_Expecter) StoreIdentity(identity interface{}) *IdentityDetailsStore_StoreIdentity_Call

+ type IdentityDetailsStore_FindIdentity_Call struct

+ func (_c *IdentityDetailsStore_FindIdentity_Call) Return(_a0 *aclcore.Identity, _a1 error) *IdentityDetailsStore_FindIdentity_Call

+ func (_c *IdentityDetailsStore_FindIdentity_Call) Run(run func(email string)) *IdentityDetailsStore_FindIdentity_Call

+ func (_c *IdentityDetailsStore_FindIdentity_Call) RunAndReturn(run func(string) (*aclcore.Identity, error)) *IdentityDetailsStore_FindIdentity_Call

+ type IdentityDetailsStore_StoreIdentity_Call struct

+ func (_c *IdentityDetailsStore_StoreIdentity_Call) Return(_a0 error) *IdentityDetailsStore_StoreIdentity_Call

+ func (_c *IdentityDetailsStore_StoreIdentity_Call) Run(run func(identity aclcore.Identity)) *IdentityDetailsStore_StoreIdentity_Call

+ func (_c *IdentityDetailsStore_StoreIdentity_Call) RunAndReturn(run func(aclcore.Identity) error) *IdentityDetailsStore_StoreIdentity_Call

type IdentityQueriesIdentityRepository

+ func (_m *IdentityQueriesIdentityRepository) EXPECT() *IdentityQueriesIdentityRepository_Expecter

+ type IdentityQueriesIdentityRepository_Expecter struct

+ func (_e *IdentityQueriesIdentityRepository_Expecter) FindIdentities(emails interface{}) *IdentityQueriesIdentityRepository_FindIdentities_Call

+ type IdentityQueriesIdentityRepository_FindIdentities_Call struct

+ func (_c *IdentityQueriesIdentityRepository_FindIdentities_Call) Return(_a0 []*aclcore.Identity, _a1 error) *IdentityQueriesIdentityRepository_FindIdentities_Call

+ func (_c *IdentityQueriesIdentityRepository_FindIdentities_Call) Run(run func(emails []string)) *IdentityQueriesIdentityRepository_FindIdentities_Call

+ func (_c *IdentityQueriesIdentityRepository_FindIdentities_Call) RunAndReturn(run func([]string) ([]*aclcore.Identity, error)) *IdentityQueriesIdentityRepository_FindIdentities_Call

type IdentityQueriesScopeRepository

+ func (_m *IdentityQueriesScopeRepository) EXPECT() *IdentityQueriesScopeRepository_Expecter

+ type IdentityQueriesScopeRepository_Expecter struct

+ func (_e *IdentityQueriesScopeRepository_Expecter) ListScopesByOwners(owners interface{}, types ...interface{}) *IdentityQueriesScopeRepository_ListScopesByOwners_Call

+ type IdentityQueriesScopeRepository_ListScopesByOwners_Call struct

+ func (_c *IdentityQueriesScopeRepository_ListScopesByOwners_Call) Return(_a0 []*aclcore.Scope, _a1 error) *IdentityQueriesScopeRepository_ListScopesByOwners_Call

+ func (_c *IdentityQueriesScopeRepository_ListScopesByOwners_Call) Run(run func(owners []string, types ...aclcore.ScopeType)) *IdentityQueriesScopeRepository_ListScopesByOwners_Call

+ func (_c *IdentityQueriesScopeRepository_ListScopesByOwners_Call) RunAndReturn(run func([]string, ...aclcore.ScopeType) ([]*aclcore.Scope, error)) *IdentityQueriesScopeRepository_ListScopesByOwners_Call

type IdentityRepository

+ func (_m *IdentityRepository) EXPECT() *IdentityRepository_Expecter

+ type IdentityRepository_Expecter struct

+ func (_e *IdentityRepository_Expecter) FindIdentities(emails interface{}) *IdentityRepository_FindIdentities_Call

+ func (_e *IdentityRepository_Expecter) FindIdentity(email interface{}) *IdentityRepository_FindIdentity_Call

+ func (_e *IdentityRepository_Expecter) StoreIdentity(identity interface{}) *IdentityRepository_StoreIdentity_Call

+ type IdentityRepository_FindIdentities_Call struct

+ func (_c *IdentityRepository_FindIdentities_Call) Return(_a0 []*aclcore.Identity, _a1 error) *IdentityRepository_FindIdentities_Call

+ func (_c *IdentityRepository_FindIdentities_Call) Run(run func(emails []string)) *IdentityRepository_FindIdentities_Call

+ func (_c *IdentityRepository_FindIdentities_Call) RunAndReturn(run func([]string) ([]*aclcore.Identity, error)) *IdentityRepository_FindIdentities_Call

+ type IdentityRepository_FindIdentity_Call struct

+ func (_c *IdentityRepository_FindIdentity_Call) Return(_a0 *aclcore.Identity, _a1 error) *IdentityRepository_FindIdentity_Call

+ func (_c *IdentityRepository_FindIdentity_Call) Run(run func(email string)) *IdentityRepository_FindIdentity_Call

+ func (_c *IdentityRepository_FindIdentity_Call) RunAndReturn(run func(string) (*aclcore.Identity, error)) *IdentityRepository_FindIdentity_Call

+ type IdentityRepository_StoreIdentity_Call struct

+ func (_c *IdentityRepository_StoreIdentity_Call) Return(_a0 error) *IdentityRepository_StoreIdentity_Call

+ func (_c *IdentityRepository_StoreIdentity_Call) Run(run func(identity aclcore.Identity)) *IdentityRepository_StoreIdentity_Call

+ func (_c *IdentityRepository_StoreIdentity_Call) RunAndReturn(run func(aclcore.Identity) error) *IdentityRepository_StoreIdentity_Call

type InsertAlbumPort

+ func (_m *InsertAlbumPort) EXPECT() *InsertAlbumPort_Expecter

type InsertAlbumPortFunc

+ func (_m *InsertAlbumPortFunc) EXPECT() *InsertAlbumPortFunc_Expecter

+ type InsertAlbumPortFunc_Execute_Call struct

+ func (_c *InsertAlbumPortFunc_Execute_Call) Return(_a0 error) *InsertAlbumPortFunc_Execute_Call

+ func (_c *InsertAlbumPortFunc_Execute_Call) Run(run func(ctx context.Context, album catalog.Album)) *InsertAlbumPortFunc_Execute_Call

+ func (_c *InsertAlbumPortFunc_Execute_Call) RunAndReturn(run func(context.Context, catalog.Album) error) *InsertAlbumPortFunc_Execute_Call

+ type InsertAlbumPortFunc_Expecter struct

+ func (_e *InsertAlbumPortFunc_Expecter) Execute(ctx interface{}, album interface{}) *InsertAlbumPortFunc_Execute_Call

+ type InsertAlbumPort_Expecter struct

+ func (_e *InsertAlbumPort_Expecter) InsertAlbum(ctx interface{}, album interface{}) *InsertAlbumPort_InsertAlbum_Call

+ type InsertAlbumPort_InsertAlbum_Call struct

+ func (_c *InsertAlbumPort_InsertAlbum_Call) Return(_a0 error) *InsertAlbumPort_InsertAlbum_Call

+ func (_c *InsertAlbumPort_InsertAlbum_Call) Run(run func(ctx context.Context, album catalog.Album)) *InsertAlbumPort_InsertAlbum_Call

+ func (_c *InsertAlbumPort_InsertAlbum_Call) RunAndReturn(run func(context.Context, catalog.Album) error) *InsertAlbumPort_InsertAlbum_Call

type InteractiveActionsPort

+ func (_m *InteractiveActionsPort) EXPECT() *InteractiveActionsPort_Expecter

+ type InteractiveActionsPort_BackupSuggestion_Call struct

+ func (_c *InteractiveActionsPort_BackupSuggestion_Call) Return(_a0 error) *InteractiveActionsPort_BackupSuggestion_Call

+ func (_c *InteractiveActionsPort_BackupSuggestion_Call) Run(run func(record *ui.SuggestionRecord, existing *ui.ExistingRecord, ...)) *InteractiveActionsPort_BackupSuggestion_Call

+ func (_c *InteractiveActionsPort_BackupSuggestion_Call) RunAndReturn(...) *InteractiveActionsPort_BackupSuggestion_Call

+ type InteractiveActionsPort_Create_Call struct

+ func (_c *InteractiveActionsPort_Create_Call) Return(_a0 error) *InteractiveActionsPort_Create_Call

+ func (_c *InteractiveActionsPort_Create_Call) Run(run func(createRequest ui.RecordCreation)) *InteractiveActionsPort_Create_Call

+ func (_c *InteractiveActionsPort_Create_Call) RunAndReturn(run func(ui.RecordCreation) error) *InteractiveActionsPort_Create_Call

+ type InteractiveActionsPort_DeleteAlbum_Call struct

+ func (_c *InteractiveActionsPort_DeleteAlbum_Call) Return(_a0 error) *InteractiveActionsPort_DeleteAlbum_Call

+ func (_c *InteractiveActionsPort_DeleteAlbum_Call) Run(run func(folderName string)) *InteractiveActionsPort_DeleteAlbum_Call

+ func (_c *InteractiveActionsPort_DeleteAlbum_Call) RunAndReturn(run func(string) error) *InteractiveActionsPort_DeleteAlbum_Call

+ type InteractiveActionsPort_Expecter struct

+ func (_e *InteractiveActionsPort_Expecter) BackupSuggestion(record interface{}, existing interface{}, listener interface{}) *InteractiveActionsPort_BackupSuggestion_Call

+ func (_e *InteractiveActionsPort_Expecter) Create(createRequest interface{}) *InteractiveActionsPort_Create_Call

+ func (_e *InteractiveActionsPort_Expecter) DeleteAlbum(folderName interface{}) *InteractiveActionsPort_DeleteAlbum_Call

+ func (_e *InteractiveActionsPort_Expecter) RenameAlbum(folderName interface{}, newName interface{}, renameFolder interface{}) *InteractiveActionsPort_RenameAlbum_Call

+ func (_e *InteractiveActionsPort_Expecter) UpdateAlbum(folderName interface{}, start interface{}, end interface{}) *InteractiveActionsPort_UpdateAlbum_Call

+ type InteractiveActionsPort_RenameAlbum_Call struct

+ func (_c *InteractiveActionsPort_RenameAlbum_Call) Return(_a0 error) *InteractiveActionsPort_RenameAlbum_Call

+ func (_c *InteractiveActionsPort_RenameAlbum_Call) Run(run func(folderName string, newName string, renameFolder bool)) *InteractiveActionsPort_RenameAlbum_Call

+ func (_c *InteractiveActionsPort_RenameAlbum_Call) RunAndReturn(run func(string, string, bool) error) *InteractiveActionsPort_RenameAlbum_Call

+ type InteractiveActionsPort_UpdateAlbum_Call struct

+ func (_c *InteractiveActionsPort_UpdateAlbum_Call) Return(_a0 error) *InteractiveActionsPort_UpdateAlbum_Call

+ func (_c *InteractiveActionsPort_UpdateAlbum_Call) Run(run func(folderName string, start time.Time, end time.Time)) *InteractiveActionsPort_UpdateAlbum_Call

+ func (_c *InteractiveActionsPort_UpdateAlbum_Call) RunAndReturn(run func(string, time.Time, time.Time) error) *InteractiveActionsPort_UpdateAlbum_Call

type InteractiveRendererPort

+ func (_m *InteractiveRendererPort) EXPECT() *InteractiveRendererPort_Expecter

+ type InteractiveRendererPort_Expecter struct

+ func (_e *InteractiveRendererPort_Expecter) Height() *InteractiveRendererPort_Height_Call

+ func (_e *InteractiveRendererPort_Expecter) Print(question interface{}) *InteractiveRendererPort_Print_Call

+ func (_e *InteractiveRendererPort_Expecter) ReadAnswer() *InteractiveRendererPort_ReadAnswer_Call

+ func (_e *InteractiveRendererPort_Expecter) Render(state interface{}) *InteractiveRendererPort_Render_Call

+ func (_e *InteractiveRendererPort_Expecter) TakeOverScreen() *InteractiveRendererPort_TakeOverScreen_Call

+ type InteractiveRendererPort_Height_Call struct

+ func (_c *InteractiveRendererPort_Height_Call) Return(_a0 int) *InteractiveRendererPort_Height_Call

+ func (_c *InteractiveRendererPort_Height_Call) Run(run func()) *InteractiveRendererPort_Height_Call

+ func (_c *InteractiveRendererPort_Height_Call) RunAndReturn(run func() int) *InteractiveRendererPort_Height_Call

+ type InteractiveRendererPort_Print_Call struct

+ func (_c *InteractiveRendererPort_Print_Call) Return() *InteractiveRendererPort_Print_Call

+ func (_c *InteractiveRendererPort_Print_Call) Run(run func(question string)) *InteractiveRendererPort_Print_Call

+ func (_c *InteractiveRendererPort_Print_Call) RunAndReturn(run func(string)) *InteractiveRendererPort_Print_Call

+ type InteractiveRendererPort_ReadAnswer_Call struct

+ func (_c *InteractiveRendererPort_ReadAnswer_Call) Return(_a0 string, _a1 error) *InteractiveRendererPort_ReadAnswer_Call

+ func (_c *InteractiveRendererPort_ReadAnswer_Call) Run(run func()) *InteractiveRendererPort_ReadAnswer_Call

+ func (_c *InteractiveRendererPort_ReadAnswer_Call) RunAndReturn(run func() (string, error)) *InteractiveRendererPort_ReadAnswer_Call

+ type InteractiveRendererPort_Render_Call struct

+ func (_c *InteractiveRendererPort_Render_Call) Return(_a0 error) *InteractiveRendererPort_Render_Call

+ func (_c *InteractiveRendererPort_Render_Call) Run(run func(state *ui.InteractiveViewState)) *InteractiveRendererPort_Render_Call

+ func (_c *InteractiveRendererPort_Render_Call) RunAndReturn(run func(*ui.InteractiveViewState) error) *InteractiveRendererPort_Render_Call

+ type InteractiveRendererPort_TakeOverScreen_Call struct

+ func (_c *InteractiveRendererPort_TakeOverScreen_Call) Return() *InteractiveRendererPort_TakeOverScreen_Call

+ func (_c *InteractiveRendererPort_TakeOverScreen_Call) Run(run func()) *InteractiveRendererPort_TakeOverScreen_Call

+ func (_c *InteractiveRendererPort_TakeOverScreen_Call) RunAndReturn(run func()) *InteractiveRendererPort_TakeOverScreen_Call

type Listener

+ func (_m *Listener) EXPECT() *Listener_Expecter

+ type Listener_Execute_Call struct

+ func (_c *Listener_Execute_Call) Return() *Listener_Execute_Call

+ func (_c *Listener_Execute_Call) Run(run func(_a0 config.Config)) *Listener_Execute_Call

+ func (_c *Listener_Execute_Call) RunAndReturn(run func(config.Config)) *Listener_Execute_Call

+ type Listener_Expecter struct

+ func (_e *Listener_Expecter) Execute(_a0 interface{}) *Listener_Execute_Call

type MediaAlbumResolver

+ func (_m *MediaAlbumResolver) EXPECT() *MediaAlbumResolver_Expecter

+ type MediaAlbumResolver_Expecter struct

+ func (_e *MediaAlbumResolver_Expecter) FindAlbumOfMedia(owner interface{}, mediaId interface{}) *MediaAlbumResolver_FindAlbumOfMedia_Call

+ type MediaAlbumResolver_FindAlbumOfMedia_Call struct

+ func (_c *MediaAlbumResolver_FindAlbumOfMedia_Call) Return(_a0 string, _a1 error) *MediaAlbumResolver_FindAlbumOfMedia_Call

+ func (_c *MediaAlbumResolver_FindAlbumOfMedia_Call) Run(run func(owner string, mediaId string)) *MediaAlbumResolver_FindAlbumOfMedia_Call

+ func (_c *MediaAlbumResolver_FindAlbumOfMedia_Call) RunAndReturn(run func(string, string) (string, error)) *MediaAlbumResolver_FindAlbumOfMedia_Call

type MoveMediaPort

+ func (_m *MoveMediaPort) EXPECT() *MoveMediaPort_Expecter

type MoveMediaPortFunc

+ func (_m *MoveMediaPortFunc) EXPECT() *MoveMediaPortFunc_Expecter

+ type MoveMediaPortFunc_Execute_Call struct

+ func (_c *MoveMediaPortFunc_Execute_Call) Return(_a0 error) *MoveMediaPortFunc_Execute_Call

+ func (_c *MoveMediaPortFunc_Execute_Call) Run(...) *MoveMediaPortFunc_Execute_Call

+ func (_c *MoveMediaPortFunc_Execute_Call) RunAndReturn(run func(context.Context, catalog.AlbumId, []catalog.MediaId) error) *MoveMediaPortFunc_Execute_Call

+ type MoveMediaPortFunc_Expecter struct

+ func (_e *MoveMediaPortFunc_Expecter) Execute(ctx interface{}, albumId interface{}, mediaIds interface{}) *MoveMediaPortFunc_Execute_Call

+ type MoveMediaPort_Expecter struct

+ func (_e *MoveMediaPort_Expecter) MoveMedia(ctx interface{}, albumId interface{}, mediaIds interface{}) *MoveMediaPort_MoveMedia_Call

+ type MoveMediaPort_MoveMedia_Call struct

+ func (_c *MoveMediaPort_MoveMedia_Call) Return(_a0 error) *MoveMediaPort_MoveMedia_Call

+ func (_c *MoveMediaPort_MoveMedia_Call) Run(...) *MoveMediaPort_MoveMedia_Call

+ func (_c *MoveMediaPort_MoveMedia_Call) RunAndReturn(run func(context.Context, catalog.AlbumId, []catalog.MediaId) error) *MoveMediaPort_MoveMedia_Call

type Names

+ func (_m *Names) EXPECT() *Names_Expecter

+ type Names_DynamoDBMainTable_Call struct

+ func (_c *Names_DynamoDBMainTable_Call) Return(_a0 string) *Names_DynamoDBMainTable_Call

+ func (_c *Names_DynamoDBMainTable_Call) Run(run func()) *Names_DynamoDBMainTable_Call

+ func (_c *Names_DynamoDBMainTable_Call) RunAndReturn(run func() string) *Names_DynamoDBMainTable_Call

+ type Names_Expecter struct

+ func (_e *Names_Expecter) DynamoDBMainTable() *Names_DynamoDBMainTable_Call

type PostAnalyseFilter

+ func (_m *PostAnalyseFilter) EXPECT() *PostAnalyseFilter_Expecter

+ type PostAnalyseFilter_AcceptAnalysedMedia_Call struct

+ func (_c *PostAnalyseFilter_AcceptAnalysedMedia_Call) Return(_a0 bool) *PostAnalyseFilter_AcceptAnalysedMedia_Call

+ func (_c *PostAnalyseFilter_AcceptAnalysedMedia_Call) Run(run func(media *backup.AnalysedMedia, folderName string)) *PostAnalyseFilter_AcceptAnalysedMedia_Call

+ func (_c *PostAnalyseFilter_AcceptAnalysedMedia_Call) RunAndReturn(run func(*backup.AnalysedMedia, string) bool) *PostAnalyseFilter_AcceptAnalysedMedia_Call

+ type PostAnalyseFilter_Expecter struct

+ func (_e *PostAnalyseFilter_Expecter) AcceptAnalysedMedia(media interface{}, folderName interface{}) *PostAnalyseFilter_AcceptAnalysedMedia_Call

type PrintReadTerminalPort

+ func (_m *PrintReadTerminalPort) EXPECT() *PrintReadTerminalPort_Expecter

+ type PrintReadTerminalPort_Expecter struct

+ func (_e *PrintReadTerminalPort_Expecter) Print(question interface{}) *PrintReadTerminalPort_Print_Call

+ func (_e *PrintReadTerminalPort_Expecter) ReadAnswer() *PrintReadTerminalPort_ReadAnswer_Call

+ type PrintReadTerminalPort_Print_Call struct

+ func (_c *PrintReadTerminalPort_Print_Call) Return() *PrintReadTerminalPort_Print_Call

+ func (_c *PrintReadTerminalPort_Print_Call) Run(run func(question string)) *PrintReadTerminalPort_Print_Call

+ func (_c *PrintReadTerminalPort_Print_Call) RunAndReturn(run func(string)) *PrintReadTerminalPort_Print_Call

+ type PrintReadTerminalPort_ReadAnswer_Call struct

+ func (_c *PrintReadTerminalPort_ReadAnswer_Call) Return(_a0 string, _a1 error) *PrintReadTerminalPort_ReadAnswer_Call

+ func (_c *PrintReadTerminalPort_ReadAnswer_Call) Run(run func()) *PrintReadTerminalPort_ReadAnswer_Call

+ func (_c *PrintReadTerminalPort_ReadAnswer_Call) RunAndReturn(run func() (string, error)) *PrintReadTerminalPort_ReadAnswer_Call

type RefreshTokenRepository

+ func (_m *RefreshTokenRepository) EXPECT() *RefreshTokenRepository_Expecter

+ type RefreshTokenRepository_DeleteRefreshToken_Call struct

+ func (_c *RefreshTokenRepository_DeleteRefreshToken_Call) Return(_a0 error) *RefreshTokenRepository_DeleteRefreshToken_Call

+ func (_c *RefreshTokenRepository_DeleteRefreshToken_Call) Run(run func(token string)) *RefreshTokenRepository_DeleteRefreshToken_Call

+ func (_c *RefreshTokenRepository_DeleteRefreshToken_Call) RunAndReturn(run func(string) error) *RefreshTokenRepository_DeleteRefreshToken_Call

+ type RefreshTokenRepository_Expecter struct

+ func (_e *RefreshTokenRepository_Expecter) DeleteRefreshToken(token interface{}) *RefreshTokenRepository_DeleteRefreshToken_Call

+ func (_e *RefreshTokenRepository_Expecter) FindRefreshToken(token interface{}) *RefreshTokenRepository_FindRefreshToken_Call

+ func (_e *RefreshTokenRepository_Expecter) HouseKeepRefreshToken() *RefreshTokenRepository_HouseKeepRefreshToken_Call

+ func (_e *RefreshTokenRepository_Expecter) StoreRefreshToken(token interface{}, spec interface{}) *RefreshTokenRepository_StoreRefreshToken_Call

+ type RefreshTokenRepository_FindRefreshToken_Call struct

+ func (_c *RefreshTokenRepository_FindRefreshToken_Call) Return(_a0 *aclcore.RefreshTokenSpec, _a1 error) *RefreshTokenRepository_FindRefreshToken_Call

+ func (_c *RefreshTokenRepository_FindRefreshToken_Call) Run(run func(token string)) *RefreshTokenRepository_FindRefreshToken_Call

+ func (_c *RefreshTokenRepository_FindRefreshToken_Call) RunAndReturn(run func(string) (*aclcore.RefreshTokenSpec, error)) *RefreshTokenRepository_FindRefreshToken_Call

+ type RefreshTokenRepository_HouseKeepRefreshToken_Call struct

+ func (_c *RefreshTokenRepository_HouseKeepRefreshToken_Call) Return(_a0 int, _a1 error) *RefreshTokenRepository_HouseKeepRefreshToken_Call

+ func (_c *RefreshTokenRepository_HouseKeepRefreshToken_Call) Run(run func()) *RefreshTokenRepository_HouseKeepRefreshToken_Call

+ func (_c *RefreshTokenRepository_HouseKeepRefreshToken_Call) RunAndReturn(run func() (int, error)) *RefreshTokenRepository_HouseKeepRefreshToken_Call

+ type RefreshTokenRepository_StoreRefreshToken_Call struct

+ func (_c *RefreshTokenRepository_StoreRefreshToken_Call) Return(_a0 error) *RefreshTokenRepository_StoreRefreshToken_Call

+ func (_c *RefreshTokenRepository_StoreRefreshToken_Call) Run(run func(token string, spec aclcore.RefreshTokenSpec)) *RefreshTokenRepository_StoreRefreshToken_Call

+ func (_c *RefreshTokenRepository_StoreRefreshToken_Call) RunAndReturn(run func(string, aclcore.RefreshTokenSpec) error) *RefreshTokenRepository_StoreRefreshToken_Call

type RenameAlbumPort

+ func (_m *RenameAlbumPort) EXPECT() *RenameAlbumPort_Expecter

+ type RenameAlbumPort_Expecter struct

+ func (_e *RenameAlbumPort_Expecter) RenameAlbum(folderName interface{}, newName interface{}, renameFolder interface{}) *RenameAlbumPort_RenameAlbum_Call

+ type RenameAlbumPort_RenameAlbum_Call struct

+ func (_c *RenameAlbumPort_RenameAlbum_Call) Return(_a0 error) *RenameAlbumPort_RenameAlbum_Call

+ func (_c *RenameAlbumPort_RenameAlbum_Call) Run(run func(folderName string, newName string, renameFolder bool)) *RenameAlbumPort_RenameAlbum_Call

+ func (_c *RenameAlbumPort_RenameAlbum_Call) RunAndReturn(run func(string, string, bool) error) *RenameAlbumPort_RenameAlbum_Call

type RepositoryAdapter

+ func (_m *RepositoryAdapter) EXPECT() *RepositoryAdapter_Expecter

+ type RepositoryAdapter_DeleteEmptyAlbum_Call struct

+ func (_c *RepositoryAdapter_DeleteEmptyAlbum_Call) Return(_a0 error) *RepositoryAdapter_DeleteEmptyAlbum_Call

+ func (_c *RepositoryAdapter_DeleteEmptyAlbum_Call) Run(run func(ctx context.Context, id catalog.AlbumId)) *RepositoryAdapter_DeleteEmptyAlbum_Call

+ func (_c *RepositoryAdapter_DeleteEmptyAlbum_Call) RunAndReturn(run func(context.Context, catalog.AlbumId) error) *RepositoryAdapter_DeleteEmptyAlbum_Call

+ type RepositoryAdapter_Expecter struct

+ func (_e *RepositoryAdapter_Expecter) DeleteEmptyAlbum(ctx interface{}, id interface{}) *RepositoryAdapter_DeleteEmptyAlbum_Call

+ func (_e *RepositoryAdapter_Expecter) FindAlbums(ctx interface{}, ids ...interface{}) *RepositoryAdapter_FindAlbums_Call

+ func (_e *RepositoryAdapter_Expecter) FindAlbumsByOwner(ctx interface{}, owner interface{}) *RepositoryAdapter_FindAlbumsByOwner_Call

+ func (_e *RepositoryAdapter_Expecter) FindExistingSignatures(ctx interface{}, owner interface{}, signatures interface{}) *RepositoryAdapter_FindExistingSignatures_Call

+ func (_e *RepositoryAdapter_Expecter) FindMediaCurrentAlbum(ctx interface{}, owner interface{}, mediaId interface{}) *RepositoryAdapter_FindMediaCurrentAlbum_Call

+ func (_e *RepositoryAdapter_Expecter) FindMediaIds(ctx interface{}, request interface{}) *RepositoryAdapter_FindMediaIds_Call

+ func (_e *RepositoryAdapter_Expecter) FindMedias(ctx interface{}, request interface{}) *RepositoryAdapter_FindMedias_Call

+ func (_e *RepositoryAdapter_Expecter) InsertAlbum(ctx interface{}, album interface{}) *RepositoryAdapter_InsertAlbum_Call

+ func (_e *RepositoryAdapter_Expecter) InsertMedias(ctx interface{}, owner interface{}, media interface{}) *RepositoryAdapter_InsertMedias_Call

+ func (_e *RepositoryAdapter_Expecter) TransferMedias(ctx interface{}, owner interface{}, mediaIds interface{}, ...) *RepositoryAdapter_TransferMedias_Call

+ func (_e *RepositoryAdapter_Expecter) TransferMediasFromRecords(ctx interface{}, records interface{}) *RepositoryAdapter_TransferMediasFromRecords_Call

+ func (_e *RepositoryAdapter_Expecter) UpdateAlbum(ctx interface{}, album interface{}) *RepositoryAdapter_UpdateAlbum_Call

+ type RepositoryAdapter_FindAlbumsByOwner_Call struct

+ func (_c *RepositoryAdapter_FindAlbumsByOwner_Call) Return(_a0 []*catalog.Album, _a1 error) *RepositoryAdapter_FindAlbumsByOwner_Call

+ func (_c *RepositoryAdapter_FindAlbumsByOwner_Call) Run(run func(ctx context.Context, owner catalog.Owner)) *RepositoryAdapter_FindAlbumsByOwner_Call

+ func (_c *RepositoryAdapter_FindAlbumsByOwner_Call) RunAndReturn(run func(context.Context, catalog.Owner) ([]*catalog.Album, error)) *RepositoryAdapter_FindAlbumsByOwner_Call

+ type RepositoryAdapter_FindAlbums_Call struct

+ func (_c *RepositoryAdapter_FindAlbums_Call) Return(_a0 []*catalog.Album, _a1 error) *RepositoryAdapter_FindAlbums_Call

+ func (_c *RepositoryAdapter_FindAlbums_Call) Run(run func(ctx context.Context, ids ...catalog.AlbumId)) *RepositoryAdapter_FindAlbums_Call

+ func (_c *RepositoryAdapter_FindAlbums_Call) RunAndReturn(run func(context.Context, ...catalog.AlbumId) ([]*catalog.Album, error)) *RepositoryAdapter_FindAlbums_Call

+ type RepositoryAdapter_FindExistingSignatures_Call struct

+ func (_c *RepositoryAdapter_FindExistingSignatures_Call) Return(_a0 []*catalog.MediaSignature, _a1 error) *RepositoryAdapter_FindExistingSignatures_Call

+ func (_c *RepositoryAdapter_FindExistingSignatures_Call) Run(...) *RepositoryAdapter_FindExistingSignatures_Call

+ func (_c *RepositoryAdapter_FindExistingSignatures_Call) RunAndReturn(...) *RepositoryAdapter_FindExistingSignatures_Call

+ type RepositoryAdapter_FindMediaCurrentAlbum_Call struct

+ func (_c *RepositoryAdapter_FindMediaCurrentAlbum_Call) Return(id *catalog.AlbumId, err error) *RepositoryAdapter_FindMediaCurrentAlbum_Call

+ func (_c *RepositoryAdapter_FindMediaCurrentAlbum_Call) Run(run func(ctx context.Context, owner catalog.Owner, mediaId catalog.MediaId)) *RepositoryAdapter_FindMediaCurrentAlbum_Call

+ func (_c *RepositoryAdapter_FindMediaCurrentAlbum_Call) RunAndReturn(...) *RepositoryAdapter_FindMediaCurrentAlbum_Call

+ type RepositoryAdapter_FindMediaIds_Call struct

+ func (_c *RepositoryAdapter_FindMediaIds_Call) Return(ids []catalog.MediaId, err error) *RepositoryAdapter_FindMediaIds_Call

+ func (_c *RepositoryAdapter_FindMediaIds_Call) Run(run func(ctx context.Context, request *catalog.FindMediaRequest)) *RepositoryAdapter_FindMediaIds_Call

+ func (_c *RepositoryAdapter_FindMediaIds_Call) RunAndReturn(...) *RepositoryAdapter_FindMediaIds_Call

+ type RepositoryAdapter_FindMedias_Call struct

+ func (_c *RepositoryAdapter_FindMedias_Call) Return(medias []*catalog.MediaMeta, err error) *RepositoryAdapter_FindMedias_Call

+ func (_c *RepositoryAdapter_FindMedias_Call) Run(run func(ctx context.Context, request *catalog.FindMediaRequest)) *RepositoryAdapter_FindMedias_Call

+ func (_c *RepositoryAdapter_FindMedias_Call) RunAndReturn(...) *RepositoryAdapter_FindMedias_Call

+ type RepositoryAdapter_InsertAlbum_Call struct

+ func (_c *RepositoryAdapter_InsertAlbum_Call) Return(_a0 error) *RepositoryAdapter_InsertAlbum_Call

+ func (_c *RepositoryAdapter_InsertAlbum_Call) Run(run func(ctx context.Context, album catalog.Album)) *RepositoryAdapter_InsertAlbum_Call

+ func (_c *RepositoryAdapter_InsertAlbum_Call) RunAndReturn(run func(context.Context, catalog.Album) error) *RepositoryAdapter_InsertAlbum_Call

+ type RepositoryAdapter_InsertMedias_Call struct

+ func (_c *RepositoryAdapter_InsertMedias_Call) Return(_a0 error) *RepositoryAdapter_InsertMedias_Call

+ func (_c *RepositoryAdapter_InsertMedias_Call) Run(...) *RepositoryAdapter_InsertMedias_Call

+ func (_c *RepositoryAdapter_InsertMedias_Call) RunAndReturn(run func(context.Context, catalog.Owner, []catalog.CreateMediaRequest) error) *RepositoryAdapter_InsertMedias_Call

+ type RepositoryAdapter_TransferMediasFromRecords_Call struct

+ func (_c *RepositoryAdapter_TransferMediasFromRecords_Call) Return(_a0 catalog.TransferredMedias, _a1 error) *RepositoryAdapter_TransferMediasFromRecords_Call

+ func (_c *RepositoryAdapter_TransferMediasFromRecords_Call) Run(run func(ctx context.Context, records catalog.MediaTransferRecords)) *RepositoryAdapter_TransferMediasFromRecords_Call

+ func (_c *RepositoryAdapter_TransferMediasFromRecords_Call) RunAndReturn(...) *RepositoryAdapter_TransferMediasFromRecords_Call

+ type RepositoryAdapter_TransferMedias_Call struct

+ func (_c *RepositoryAdapter_TransferMedias_Call) Return(_a0 error) *RepositoryAdapter_TransferMedias_Call

+ func (_c *RepositoryAdapter_TransferMedias_Call) Run(...) *RepositoryAdapter_TransferMedias_Call

+ func (_c *RepositoryAdapter_TransferMedias_Call) RunAndReturn(...) *RepositoryAdapter_TransferMedias_Call

+ type RepositoryAdapter_UpdateAlbum_Call struct

+ func (_c *RepositoryAdapter_UpdateAlbum_Call) Return(_a0 error) *RepositoryAdapter_UpdateAlbum_Call

+ func (_c *RepositoryAdapter_UpdateAlbum_Call) Run(run func(ctx context.Context, album catalog.Album)) *RepositoryAdapter_UpdateAlbum_Call

+ func (_c *RepositoryAdapter_UpdateAlbum_Call) RunAndReturn(run func(context.Context, catalog.Album) error) *RepositoryAdapter_UpdateAlbum_Call

type RepositoryContract

+ func (_m *RepositoryContract) EXPECT() *RepositoryContract_Expecter

+ type RepositoryContract_DeleteEmptyAlbum_Call struct

+ func (_c *RepositoryContract_DeleteEmptyAlbum_Call) Return(_a0 error) *RepositoryContract_DeleteEmptyAlbum_Call

+ func (_c *RepositoryContract_DeleteEmptyAlbum_Call) Run(run func(ctx context.Context, id catalog.AlbumId)) *RepositoryContract_DeleteEmptyAlbum_Call

+ func (_c *RepositoryContract_DeleteEmptyAlbum_Call) RunAndReturn(run func(context.Context, catalog.AlbumId) error) *RepositoryContract_DeleteEmptyAlbum_Call

+ type RepositoryContract_Expecter struct

+ func (_e *RepositoryContract_Expecter) DeleteEmptyAlbum(ctx interface{}, id interface{}) *RepositoryContract_DeleteEmptyAlbum_Call

+ func (_e *RepositoryContract_Expecter) FindAlbums(ctx interface{}, ids ...interface{}) *RepositoryContract_FindAlbums_Call

+ func (_e *RepositoryContract_Expecter) FindAlbumsByOwner(ctx interface{}, owner interface{}) *RepositoryContract_FindAlbumsByOwner_Call

+ func (_e *RepositoryContract_Expecter) FindExistingSignatures(ctx interface{}, owner interface{}, signatures interface{}) *RepositoryContract_FindExistingSignatures_Call

+ func (_e *RepositoryContract_Expecter) FindMediaCurrentAlbum(ctx interface{}, owner interface{}, mediaId interface{}) *RepositoryContract_FindMediaCurrentAlbum_Call

+ func (_e *RepositoryContract_Expecter) FindMediaIds(ctx interface{}, request interface{}) *RepositoryContract_FindMediaIds_Call

+ func (_e *RepositoryContract_Expecter) FindMedias(ctx interface{}, request interface{}) *RepositoryContract_FindMedias_Call

+ func (_e *RepositoryContract_Expecter) InsertAlbum(ctx interface{}, album interface{}) *RepositoryContract_InsertAlbum_Call

+ func (_e *RepositoryContract_Expecter) InsertMedias(ctx interface{}, owner interface{}, media interface{}) *RepositoryContract_InsertMedias_Call

+ func (_e *RepositoryContract_Expecter) TransferMedias(ctx interface{}, owner interface{}, mediaIds interface{}, ...) *RepositoryContract_TransferMedias_Call

+ func (_e *RepositoryContract_Expecter) TransferMediasFromRecords(ctx interface{}, records interface{}) *RepositoryContract_TransferMediasFromRecords_Call

+ func (_e *RepositoryContract_Expecter) UpdateAlbum(ctx interface{}, album interface{}) *RepositoryContract_UpdateAlbum_Call

+ type RepositoryContract_FindAlbumsByOwner_Call struct

+ func (_c *RepositoryContract_FindAlbumsByOwner_Call) Return(_a0 []*catalog.Album, _a1 error) *RepositoryContract_FindAlbumsByOwner_Call

+ func (_c *RepositoryContract_FindAlbumsByOwner_Call) Run(run func(ctx context.Context, owner catalog.Owner)) *RepositoryContract_FindAlbumsByOwner_Call

+ func (_c *RepositoryContract_FindAlbumsByOwner_Call) RunAndReturn(run func(context.Context, catalog.Owner) ([]*catalog.Album, error)) *RepositoryContract_FindAlbumsByOwner_Call

+ type RepositoryContract_FindAlbums_Call struct

+ func (_c *RepositoryContract_FindAlbums_Call) Return(_a0 []*catalog.Album, _a1 error) *RepositoryContract_FindAlbums_Call

+ func (_c *RepositoryContract_FindAlbums_Call) Run(run func(ctx context.Context, ids ...catalog.AlbumId)) *RepositoryContract_FindAlbums_Call

+ func (_c *RepositoryContract_FindAlbums_Call) RunAndReturn(run func(context.Context, ...catalog.AlbumId) ([]*catalog.Album, error)) *RepositoryContract_FindAlbums_Call

+ type RepositoryContract_FindExistingSignatures_Call struct

+ func (_c *RepositoryContract_FindExistingSignatures_Call) Return(_a0 []*catalog.MediaSignature, _a1 error) *RepositoryContract_FindExistingSignatures_Call

+ func (_c *RepositoryContract_FindExistingSignatures_Call) Run(...) *RepositoryContract_FindExistingSignatures_Call

+ func (_c *RepositoryContract_FindExistingSignatures_Call) RunAndReturn(...) *RepositoryContract_FindExistingSignatures_Call

+ type RepositoryContract_FindMediaCurrentAlbum_Call struct

+ func (_c *RepositoryContract_FindMediaCurrentAlbum_Call) Return(id *catalog.AlbumId, err error) *RepositoryContract_FindMediaCurrentAlbum_Call

+ func (_c *RepositoryContract_FindMediaCurrentAlbum_Call) Run(run func(ctx context.Context, owner catalog.Owner, mediaId catalog.MediaId)) *RepositoryContract_FindMediaCurrentAlbum_Call

+ func (_c *RepositoryContract_FindMediaCurrentAlbum_Call) RunAndReturn(...) *RepositoryContract_FindMediaCurrentAlbum_Call

+ type RepositoryContract_FindMediaIds_Call struct

+ func (_c *RepositoryContract_FindMediaIds_Call) Return(ids []catalog.MediaId, err error) *RepositoryContract_FindMediaIds_Call

+ func (_c *RepositoryContract_FindMediaIds_Call) Run(run func(ctx context.Context, request *catalog.FindMediaRequest)) *RepositoryContract_FindMediaIds_Call

+ func (_c *RepositoryContract_FindMediaIds_Call) RunAndReturn(...) *RepositoryContract_FindMediaIds_Call

+ type RepositoryContract_FindMedias_Call struct

+ func (_c *RepositoryContract_FindMedias_Call) Return(medias []*catalog.MediaMeta, err error) *RepositoryContract_FindMedias_Call

+ func (_c *RepositoryContract_FindMedias_Call) Run(run func(ctx context.Context, request *catalog.FindMediaRequest)) *RepositoryContract_FindMedias_Call

+ func (_c *RepositoryContract_FindMedias_Call) RunAndReturn(...) *RepositoryContract_FindMedias_Call

+ type RepositoryContract_InsertAlbum_Call struct

+ func (_c *RepositoryContract_InsertAlbum_Call) Return(_a0 error) *RepositoryContract_InsertAlbum_Call

+ func (_c *RepositoryContract_InsertAlbum_Call) Run(run func(ctx context.Context, album catalog.Album)) *RepositoryContract_InsertAlbum_Call

+ func (_c *RepositoryContract_InsertAlbum_Call) RunAndReturn(run func(context.Context, catalog.Album) error) *RepositoryContract_InsertAlbum_Call

+ type RepositoryContract_InsertMedias_Call struct

+ func (_c *RepositoryContract_InsertMedias_Call) Return(_a0 error) *RepositoryContract_InsertMedias_Call

+ func (_c *RepositoryContract_InsertMedias_Call) Run(...) *RepositoryContract_InsertMedias_Call

+ func (_c *RepositoryContract_InsertMedias_Call) RunAndReturn(run func(context.Context, catalog.Owner, []catalog.CreateMediaRequest) error) *RepositoryContract_InsertMedias_Call

+ type RepositoryContract_TransferMediasFromRecords_Call struct

+ func (_c *RepositoryContract_TransferMediasFromRecords_Call) Return(_a0 catalog.TransferredMedias, _a1 error) *RepositoryContract_TransferMediasFromRecords_Call

+ func (_c *RepositoryContract_TransferMediasFromRecords_Call) Run(run func(ctx context.Context, records catalog.MediaTransferRecords)) *RepositoryContract_TransferMediasFromRecords_Call

+ func (_c *RepositoryContract_TransferMediasFromRecords_Call) RunAndReturn(...) *RepositoryContract_TransferMediasFromRecords_Call

+ type RepositoryContract_TransferMedias_Call struct

+ func (_c *RepositoryContract_TransferMedias_Call) Return(_a0 error) *RepositoryContract_TransferMedias_Call

+ func (_c *RepositoryContract_TransferMedias_Call) Run(...) *RepositoryContract_TransferMedias_Call

+ func (_c *RepositoryContract_TransferMedias_Call) RunAndReturn(...) *RepositoryContract_TransferMedias_Call

+ type RepositoryContract_UpdateAlbum_Call struct

+ func (_c *RepositoryContract_UpdateAlbum_Call) Return(_a0 error) *RepositoryContract_UpdateAlbum_Call

+ func (_c *RepositoryContract_UpdateAlbum_Call) Run(run func(ctx context.Context, album catalog.Album)) *RepositoryContract_UpdateAlbum_Call

+ func (_c *RepositoryContract_UpdateAlbum_Call) RunAndReturn(run func(context.Context, catalog.Album) error) *RepositoryContract_UpdateAlbum_Call

type ResizerAdapter

+ func (_m *ResizerAdapter) EXPECT() *ResizerAdapter_Expecter

+ type ResizerAdapter_Expecter struct

+ func (_e *ResizerAdapter_Expecter) ResizeImage(reader interface{}, width interface{}, fast interface{}) *ResizerAdapter_ResizeImage_Call

+ func (_e *ResizerAdapter_Expecter) ResizeImageAtDifferentWidths(reader interface{}, width interface{}) *ResizerAdapter_ResizeImageAtDifferentWidths_Call

+ type ResizerAdapter_ResizeImageAtDifferentWidths_Call struct

+ func (_c *ResizerAdapter_ResizeImageAtDifferentWidths_Call) Return(_a0 map[int][]byte, _a1 string, _a2 error) *ResizerAdapter_ResizeImageAtDifferentWidths_Call

+ func (_c *ResizerAdapter_ResizeImageAtDifferentWidths_Call) Run(run func(reader io.Reader, width []int)) *ResizerAdapter_ResizeImageAtDifferentWidths_Call

+ func (_c *ResizerAdapter_ResizeImageAtDifferentWidths_Call) RunAndReturn(run func(io.Reader, []int) (map[int][]byte, string, error)) *ResizerAdapter_ResizeImageAtDifferentWidths_Call

+ type ResizerAdapter_ResizeImage_Call struct

+ func (_c *ResizerAdapter_ResizeImage_Call) Return(_a0 []byte, _a1 string, _a2 error) *ResizerAdapter_ResizeImage_Call

+ func (_c *ResizerAdapter_ResizeImage_Call) Run(run func(reader io.Reader, width int, fast bool)) *ResizerAdapter_ResizeImage_Call

+ func (_c *ResizerAdapter_ResizeImage_Call) RunAndReturn(run func(io.Reader, int, bool) ([]byte, string, error)) *ResizerAdapter_ResizeImage_Call

type ReverseScopesReader

+ func (_m *ReverseScopesReader) EXPECT() *ReverseScopesReader_Expecter

+ type ReverseScopesReader_Expecter struct

+ func (_e *ReverseScopesReader_Expecter) ListOwnerScopes(owner interface{}, types ...interface{}) *ReverseScopesReader_ListOwnerScopes_Call

+ type ReverseScopesReader_ListOwnerScopes_Call struct

+ func (_c *ReverseScopesReader_ListOwnerScopes_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ReverseScopesReader_ListOwnerScopes_Call

+ func (_c *ReverseScopesReader_ListOwnerScopes_Call) Run(run func(owner string, types ...aclcore.ScopeType)) *ReverseScopesReader_ListOwnerScopes_Call

+ func (_c *ReverseScopesReader_ListOwnerScopes_Call) RunAndReturn(run func(string, ...aclcore.ScopeType) ([]*aclcore.Scope, error)) *ReverseScopesReader_ListOwnerScopes_Call

type RevokeAccessTokenAdapter

+ func (_m *RevokeAccessTokenAdapter) EXPECT() *RevokeAccessTokenAdapter_Expecter

+ type RevokeAccessTokenAdapter_DeleteRefreshToken_Call struct

+ func (_c *RevokeAccessTokenAdapter_DeleteRefreshToken_Call) Return(_a0 error) *RevokeAccessTokenAdapter_DeleteRefreshToken_Call

+ func (_c *RevokeAccessTokenAdapter_DeleteRefreshToken_Call) Run(run func(token string)) *RevokeAccessTokenAdapter_DeleteRefreshToken_Call

+ func (_c *RevokeAccessTokenAdapter_DeleteRefreshToken_Call) RunAndReturn(run func(string) error) *RevokeAccessTokenAdapter_DeleteRefreshToken_Call

+ type RevokeAccessTokenAdapter_Expecter struct

+ func (_e *RevokeAccessTokenAdapter_Expecter) DeleteRefreshToken(token interface{}) *RevokeAccessTokenAdapter_DeleteRefreshToken_Call

type RunnerAnalyser

+ func (_m *RunnerAnalyser) EXPECT() *RunnerAnalyser_Expecter

type RunnerAnalyserFunc

+ func (_m *RunnerAnalyserFunc) EXPECT() *RunnerAnalyserFunc_Expecter

+ type RunnerAnalyserFunc_Execute_Call struct

+ func (_c *RunnerAnalyserFunc_Execute_Call) Return(_a0 *backup.AnalysedMedia, _a1 error) *RunnerAnalyserFunc_Execute_Call

+ func (_c *RunnerAnalyserFunc_Execute_Call) Run(run func(found backup.FoundMedia, progressChannel chan *backup.ProgressEvent)) *RunnerAnalyserFunc_Execute_Call

+ func (_c *RunnerAnalyserFunc_Execute_Call) RunAndReturn(...) *RunnerAnalyserFunc_Execute_Call

+ type RunnerAnalyserFunc_Expecter struct

+ func (_e *RunnerAnalyserFunc_Expecter) Execute(found interface{}, progressChannel interface{}) *RunnerAnalyserFunc_Execute_Call

+ type RunnerAnalyser_Analyse_Call struct

+ func (_c *RunnerAnalyser_Analyse_Call) Return(_a0 *backup.AnalysedMedia, _a1 error) *RunnerAnalyser_Analyse_Call

+ func (_c *RunnerAnalyser_Analyse_Call) Run(run func(found backup.FoundMedia, progressChannel chan *backup.ProgressEvent)) *RunnerAnalyser_Analyse_Call

+ func (_c *RunnerAnalyser_Analyse_Call) RunAndReturn(...) *RunnerAnalyser_Analyse_Call

+ type RunnerAnalyser_Expecter struct

+ func (_e *RunnerAnalyser_Expecter) Analyse(found interface{}, progressChannel interface{}) *RunnerAnalyser_Analyse_Call

type ScanStreamExecutor

+ func (_m *ScanStreamExecutor) EXPECT() *ScanStreamExecutor_Expecter

+ type ScanStreamExecutor_Expecter struct

+ func (_e *ScanStreamExecutor_Expecter) Scan(ctx interface{}, params interface{}, optFns ...interface{}) *ScanStreamExecutor_Scan_Call

+ type ScanStreamExecutor_Scan_Call struct

+ func (_c *ScanStreamExecutor_Scan_Call) Return(_a0 *dynamodb.ScanOutput, _a1 error) *ScanStreamExecutor_Scan_Call

+ func (_c *ScanStreamExecutor_Scan_Call) Run(run func(ctx context.Context, params *dynamodb.ScanInput, ...)) *ScanStreamExecutor_Scan_Call

+ func (_c *ScanStreamExecutor_Scan_Call) RunAndReturn(...) *ScanStreamExecutor_Scan_Call

type ScopeRepository

+ func (_m *ScopeRepository) EXPECT() *ScopeRepository_Expecter

+ type ScopeRepository_Expecter struct

+ func (_e *ScopeRepository_Expecter) FindScopesById(ids ...interface{}) *ScopeRepository_FindScopesById_Call

+ func (_e *ScopeRepository_Expecter) ListOwnerScopes(owner interface{}, types ...interface{}) *ScopeRepository_ListOwnerScopes_Call

+ func (_e *ScopeRepository_Expecter) ListUserScopes(email interface{}, types ...interface{}) *ScopeRepository_ListUserScopes_Call

+ type ScopeRepository_FindScopesById_Call struct

+ func (_c *ScopeRepository_FindScopesById_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopeRepository_FindScopesById_Call

+ func (_c *ScopeRepository_FindScopesById_Call) Run(run func(ids ...aclcore.ScopeId)) *ScopeRepository_FindScopesById_Call

+ func (_c *ScopeRepository_FindScopesById_Call) RunAndReturn(run func(...aclcore.ScopeId) ([]*aclcore.Scope, error)) *ScopeRepository_FindScopesById_Call

+ type ScopeRepository_ListOwnerScopes_Call struct

+ func (_c *ScopeRepository_ListOwnerScopes_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopeRepository_ListOwnerScopes_Call

+ func (_c *ScopeRepository_ListOwnerScopes_Call) Run(run func(owner string, types ...aclcore.ScopeType)) *ScopeRepository_ListOwnerScopes_Call

+ func (_c *ScopeRepository_ListOwnerScopes_Call) RunAndReturn(run func(string, ...aclcore.ScopeType) ([]*aclcore.Scope, error)) *ScopeRepository_ListOwnerScopes_Call

+ type ScopeRepository_ListUserScopes_Call struct

+ func (_c *ScopeRepository_ListUserScopes_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopeRepository_ListUserScopes_Call

+ func (_c *ScopeRepository_ListUserScopes_Call) Run(run func(email string, types ...aclcore.ScopeType)) *ScopeRepository_ListUserScopes_Call

+ func (_c *ScopeRepository_ListUserScopes_Call) RunAndReturn(run func(string, ...aclcore.ScopeType) ([]*aclcore.Scope, error)) *ScopeRepository_ListUserScopes_Call

type ScopeWriter

+ func (_m *ScopeWriter) EXPECT() *ScopeWriter_Expecter

+ type ScopeWriter_DeleteScopes_Call struct

+ func (_c *ScopeWriter_DeleteScopes_Call) Return(_a0 error) *ScopeWriter_DeleteScopes_Call

+ func (_c *ScopeWriter_DeleteScopes_Call) Run(run func(id ...aclcore.ScopeId)) *ScopeWriter_DeleteScopes_Call

+ func (_c *ScopeWriter_DeleteScopes_Call) RunAndReturn(run func(...aclcore.ScopeId) error) *ScopeWriter_DeleteScopes_Call

+ type ScopeWriter_Expecter struct

+ func (_e *ScopeWriter_Expecter) DeleteScopes(id ...interface{}) *ScopeWriter_DeleteScopes_Call

+ func (_e *ScopeWriter_Expecter) SaveIfNewScope(scope interface{}) *ScopeWriter_SaveIfNewScope_Call

+ type ScopeWriter_SaveIfNewScope_Call struct

+ func (_c *ScopeWriter_SaveIfNewScope_Call) Return(_a0 error) *ScopeWriter_SaveIfNewScope_Call

+ func (_c *ScopeWriter_SaveIfNewScope_Call) Run(run func(scope aclcore.Scope)) *ScopeWriter_SaveIfNewScope_Call

+ func (_c *ScopeWriter_SaveIfNewScope_Call) RunAndReturn(run func(aclcore.Scope) error) *ScopeWriter_SaveIfNewScope_Call

type ScopesReader

+ func (_m *ScopesReader) EXPECT() *ScopesReader_Expecter

+ type ScopesReader_Expecter struct

+ func (_e *ScopesReader_Expecter) FindScopesById(ids ...interface{}) *ScopesReader_FindScopesById_Call

+ func (_e *ScopesReader_Expecter) ListUserScopes(email interface{}, types ...interface{}) *ScopesReader_ListUserScopes_Call

+ type ScopesReader_FindScopesById_Call struct

+ func (_c *ScopesReader_FindScopesById_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopesReader_FindScopesById_Call

+ func (_c *ScopesReader_FindScopesById_Call) Run(run func(ids ...aclcore.ScopeId)) *ScopesReader_FindScopesById_Call

+ func (_c *ScopesReader_FindScopesById_Call) RunAndReturn(run func(...aclcore.ScopeId) ([]*aclcore.Scope, error)) *ScopesReader_FindScopesById_Call

+ type ScopesReader_ListUserScopes_Call struct

+ func (_c *ScopesReader_ListUserScopes_Call) Return(_a0 []*aclcore.Scope, _a1 error) *ScopesReader_ListUserScopes_Call

+ func (_c *ScopesReader_ListUserScopes_Call) Run(run func(email string, types ...aclcore.ScopeType)) *ScopesReader_ListUserScopes_Call

+ func (_c *ScopesReader_ListUserScopes_Call) RunAndReturn(run func(string, ...aclcore.ScopeType) ([]*aclcore.Scope, error)) *ScopesReader_ListUserScopes_Call

type SecretAccessKeyDecoder

+ func (_m *SecretAccessKeyDecoder) EXPECT() *SecretAccessKeyDecoder_Expecter

+ type SecretAccessKeyDecoder_Execute_Call struct

+ func (_c *SecretAccessKeyDecoder_Execute_Call) Return(_a0 string, _a1 error) *SecretAccessKeyDecoder_Execute_Call

+ func (_c *SecretAccessKeyDecoder_Execute_Call) Run(run func(encodedValue string)) *SecretAccessKeyDecoder_Execute_Call

+ func (_c *SecretAccessKeyDecoder_Execute_Call) RunAndReturn(run func(string) (string, error)) *SecretAccessKeyDecoder_Execute_Call

+ type SecretAccessKeyDecoder_Expecter struct

+ func (_e *SecretAccessKeyDecoder_Expecter) Execute(encodedValue interface{}) *SecretAccessKeyDecoder_Execute_Call

type ShareAlbumCatalogPort

+ func (_m *ShareAlbumCatalogPort) EXPECT() *ShareAlbumCatalogPort_Expecter

+ type ShareAlbumCatalogPort_Expecter struct

+ func (_e *ShareAlbumCatalogPort_Expecter) FindAlbum(owner interface{}, folderName interface{}) *ShareAlbumCatalogPort_FindAlbum_Call

+ type ShareAlbumCatalogPort_FindAlbum_Call struct

+ func (_c *ShareAlbumCatalogPort_FindAlbum_Call) Return(_a0 *catalog.Album, _a1 error) *ShareAlbumCatalogPort_FindAlbum_Call

+ func (_c *ShareAlbumCatalogPort_FindAlbum_Call) Run(run func(owner string, folderName string)) *ShareAlbumCatalogPort_FindAlbum_Call

+ func (_c *ShareAlbumCatalogPort_FindAlbum_Call) RunAndReturn(run func(string, string) (*catalog.Album, error)) *ShareAlbumCatalogPort_FindAlbum_Call

type SourceVolume

+ func (_m *SourceVolume) EXPECT() *SourceVolume_Expecter

+ type SourceVolume_Expecter struct

+ func (_e *SourceVolume_Expecter) FindMedias() *SourceVolume_FindMedias_Call

+ func (_e *SourceVolume_Expecter) String() *SourceVolume_String_Call

+ type SourceVolume_FindMedias_Call struct

+ func (_c *SourceVolume_FindMedias_Call) Return(_a0 []backup.FoundMedia, _a1 error) *SourceVolume_FindMedias_Call

+ func (_c *SourceVolume_FindMedias_Call) Run(run func()) *SourceVolume_FindMedias_Call

+ func (_c *SourceVolume_FindMedias_Call) RunAndReturn(run func() ([]backup.FoundMedia, error)) *SourceVolume_FindMedias_Call

+ type SourceVolume_String_Call struct

+ func (_c *SourceVolume_String_Call) Return(_a0 string) *SourceVolume_String_Call

+ func (_c *SourceVolume_String_Call) Run(run func()) *SourceVolume_String_Call

+ func (_c *SourceVolume_String_Call) RunAndReturn(run func() string) *SourceVolume_String_Call

type StoreAdapter

+ func (_m *StoreAdapter) EXPECT() *StoreAdapter_Expecter

+ type StoreAdapter_Copy_Call struct

+ func (_c *StoreAdapter_Copy_Call) Return(_a0 string, _a1 error) *StoreAdapter_Copy_Call

+ func (_c *StoreAdapter_Copy_Call) Run(run func(origin string, destination archive.DestructuredKey)) *StoreAdapter_Copy_Call

+ func (_c *StoreAdapter_Copy_Call) RunAndReturn(run func(string, archive.DestructuredKey) (string, error)) *StoreAdapter_Copy_Call

+ type StoreAdapter_Delete_Call struct

+ func (_c *StoreAdapter_Delete_Call) Return(_a0 error) *StoreAdapter_Delete_Call

+ func (_c *StoreAdapter_Delete_Call) Run(run func(locations []string)) *StoreAdapter_Delete_Call

+ func (_c *StoreAdapter_Delete_Call) RunAndReturn(run func([]string) error) *StoreAdapter_Delete_Call

+ type StoreAdapter_Download_Call struct

+ func (_c *StoreAdapter_Download_Call) Return(_a0 io.ReadCloser, _a1 error) *StoreAdapter_Download_Call

+ func (_c *StoreAdapter_Download_Call) Run(run func(key string)) *StoreAdapter_Download_Call

+ func (_c *StoreAdapter_Download_Call) RunAndReturn(run func(string) (io.ReadCloser, error)) *StoreAdapter_Download_Call

+ type StoreAdapter_Expecter struct

+ func (_e *StoreAdapter_Expecter) Copy(origin interface{}, destination interface{}) *StoreAdapter_Copy_Call

+ func (_e *StoreAdapter_Expecter) Delete(locations interface{}) *StoreAdapter_Delete_Call

+ func (_e *StoreAdapter_Expecter) Download(key interface{}) *StoreAdapter_Download_Call

+ func (_e *StoreAdapter_Expecter) SignedURL(key interface{}, duration interface{}) *StoreAdapter_SignedURL_Call

+ func (_e *StoreAdapter_Expecter) Upload(values interface{}, content interface{}) *StoreAdapter_Upload_Call

+ type StoreAdapter_SignedURL_Call struct

+ func (_c *StoreAdapter_SignedURL_Call) Return(_a0 string, _a1 error) *StoreAdapter_SignedURL_Call

+ func (_c *StoreAdapter_SignedURL_Call) Run(run func(key string, duration time.Duration)) *StoreAdapter_SignedURL_Call

+ func (_c *StoreAdapter_SignedURL_Call) RunAndReturn(run func(string, time.Duration) (string, error)) *StoreAdapter_SignedURL_Call

+ type StoreAdapter_Upload_Call struct

+ func (_c *StoreAdapter_Upload_Call) Return(_a0 string, _a1 error) *StoreAdapter_Upload_Call

+ func (_c *StoreAdapter_Upload_Call) Run(run func(values archive.DestructuredKey, content io.Reader)) *StoreAdapter_Upload_Call

+ func (_c *StoreAdapter_Upload_Call) RunAndReturn(run func(archive.DestructuredKey, io.Reader) (string, error)) *StoreAdapter_Upload_Call

type StoreAndCache

+ func (_m *StoreAndCache) EXPECT() *StoreAndCache_Expecter

+ type StoreAndCache_Copy_Call struct

+ func (_c *StoreAndCache_Copy_Call) Return(_a0 string, _a1 error) *StoreAndCache_Copy_Call

+ func (_c *StoreAndCache_Copy_Call) Run(run func(origin string, destination archive.DestructuredKey)) *StoreAndCache_Copy_Call

+ func (_c *StoreAndCache_Copy_Call) RunAndReturn(run func(string, archive.DestructuredKey) (string, error)) *StoreAndCache_Copy_Call

+ type StoreAndCache_Delete_Call struct

+ func (_c *StoreAndCache_Delete_Call) Return(_a0 error) *StoreAndCache_Delete_Call

+ func (_c *StoreAndCache_Delete_Call) Run(run func(locations []string)) *StoreAndCache_Delete_Call

+ func (_c *StoreAndCache_Delete_Call) RunAndReturn(run func([]string) error) *StoreAndCache_Delete_Call

+ type StoreAndCache_Download_Call struct

+ func (_c *StoreAndCache_Download_Call) Return(_a0 io.ReadCloser, _a1 error) *StoreAndCache_Download_Call

+ func (_c *StoreAndCache_Download_Call) Run(run func(key string)) *StoreAndCache_Download_Call

+ func (_c *StoreAndCache_Download_Call) RunAndReturn(run func(string) (io.ReadCloser, error)) *StoreAndCache_Download_Call

+ type StoreAndCache_Expecter struct

+ func (_e *StoreAndCache_Expecter) Copy(origin interface{}, destination interface{}) *StoreAndCache_Copy_Call

+ func (_e *StoreAndCache_Expecter) Delete(locations interface{}) *StoreAndCache_Delete_Call

+ func (_e *StoreAndCache_Expecter) Download(key interface{}) *StoreAndCache_Download_Call

+ func (_e *StoreAndCache_Expecter) Get(key interface{}) *StoreAndCache_Get_Call

+ func (_e *StoreAndCache_Expecter) Put(key interface{}, mediaType interface{}, content interface{}) *StoreAndCache_Put_Call

+ func (_e *StoreAndCache_Expecter) SignedURL(key interface{}, duration interface{}) *StoreAndCache_SignedURL_Call

+ func (_e *StoreAndCache_Expecter) Upload(values interface{}, content interface{}) *StoreAndCache_Upload_Call

+ func (_e *StoreAndCache_Expecter) WalkCacheByPrefix(prefix interface{}, observer interface{}) *StoreAndCache_WalkCacheByPrefix_Call

+ type StoreAndCache_Get_Call struct

+ func (_c *StoreAndCache_Get_Call) Return(_a0 io.ReadCloser, _a1 int, _a2 string, _a3 error) *StoreAndCache_Get_Call

+ func (_c *StoreAndCache_Get_Call) Run(run func(key string)) *StoreAndCache_Get_Call

+ func (_c *StoreAndCache_Get_Call) RunAndReturn(run func(string) (io.ReadCloser, int, string, error)) *StoreAndCache_Get_Call

+ type StoreAndCache_Put_Call struct

+ func (_c *StoreAndCache_Put_Call) Return(_a0 error) *StoreAndCache_Put_Call

+ func (_c *StoreAndCache_Put_Call) Run(run func(key string, mediaType string, content io.Reader)) *StoreAndCache_Put_Call

+ func (_c *StoreAndCache_Put_Call) RunAndReturn(run func(string, string, io.Reader) error) *StoreAndCache_Put_Call

+ type StoreAndCache_SignedURL_Call struct

+ func (_c *StoreAndCache_SignedURL_Call) Return(_a0 string, _a1 error) *StoreAndCache_SignedURL_Call

+ func (_c *StoreAndCache_SignedURL_Call) Run(run func(key string, duration time.Duration)) *StoreAndCache_SignedURL_Call

+ func (_c *StoreAndCache_SignedURL_Call) RunAndReturn(run func(string, time.Duration) (string, error)) *StoreAndCache_SignedURL_Call

+ type StoreAndCache_Upload_Call struct

+ func (_c *StoreAndCache_Upload_Call) Return(_a0 string, _a1 error) *StoreAndCache_Upload_Call

+ func (_c *StoreAndCache_Upload_Call) Run(run func(values archive.DestructuredKey, content io.Reader)) *StoreAndCache_Upload_Call

+ func (_c *StoreAndCache_Upload_Call) RunAndReturn(run func(archive.DestructuredKey, io.Reader) (string, error)) *StoreAndCache_Upload_Call

+ type StoreAndCache_WalkCacheByPrefix_Call struct

+ func (_c *StoreAndCache_WalkCacheByPrefix_Call) Return(_a0 error) *StoreAndCache_WalkCacheByPrefix_Call

+ func (_c *StoreAndCache_WalkCacheByPrefix_Call) Run(run func(prefix string, observer func(string))) *StoreAndCache_WalkCacheByPrefix_Call

+ func (_c *StoreAndCache_WalkCacheByPrefix_Call) RunAndReturn(run func(string, func(string)) error) *StoreAndCache_WalkCacheByPrefix_Call

type Stream

+ func (_m *Stream) EXPECT() *Stream_Expecter

+ type Stream_Count_Call struct

+ func (_c *Stream_Count_Call) Return(_a0 int64) *Stream_Count_Call

+ func (_c *Stream_Count_Call) Run(run func()) *Stream_Count_Call

+ func (_c *Stream_Count_Call) RunAndReturn(run func() int64) *Stream_Count_Call

+ type Stream_Error_Call struct

+ func (_c *Stream_Error_Call) Return(_a0 error) *Stream_Error_Call

+ func (_c *Stream_Error_Call) Run(run func()) *Stream_Error_Call

+ func (_c *Stream_Error_Call) RunAndReturn(run func() error) *Stream_Error_Call

+ type Stream_Expecter struct

+ func (_e *Stream_Expecter) Count() *Stream_Count_Call

+ func (_e *Stream_Expecter) Error() *Stream_Error_Call

+ func (_e *Stream_Expecter) HasNext() *Stream_HasNext_Call

+ func (_e *Stream_Expecter) Next() *Stream_Next_Call

+ type Stream_HasNext_Call struct

+ func (_c *Stream_HasNext_Call) Return(_a0 bool) *Stream_HasNext_Call

+ func (_c *Stream_HasNext_Call) Run(run func()) *Stream_HasNext_Call

+ func (_c *Stream_HasNext_Call) RunAndReturn(run func() bool) *Stream_HasNext_Call

+ type Stream_Next_Call struct

+ func (_c *Stream_Next_Call) Return(_a0 map[string]types.AttributeValue) *Stream_Next_Call

+ func (_c *Stream_Next_Call) Run(run func()) *Stream_Next_Call

+ func (_c *Stream_Next_Call) RunAndReturn(run func() map[string]types.AttributeValue) *Stream_Next_Call

type SuggestionRecordRepositoryPort

+ func (_m *SuggestionRecordRepositoryPort) EXPECT() *SuggestionRecordRepositoryPort_Expecter

+ type SuggestionRecordRepositoryPort_Count_Call struct

+ func (_c *SuggestionRecordRepositoryPort_Count_Call) Return(_a0 int) *SuggestionRecordRepositoryPort_Count_Call

+ func (_c *SuggestionRecordRepositoryPort_Count_Call) Run(run func()) *SuggestionRecordRepositoryPort_Count_Call

+ func (_c *SuggestionRecordRepositoryPort_Count_Call) RunAndReturn(run func() int) *SuggestionRecordRepositoryPort_Count_Call

+ type SuggestionRecordRepositoryPort_Expecter struct

+ func (_e *SuggestionRecordRepositoryPort_Expecter) Count() *SuggestionRecordRepositoryPort_Count_Call

+ func (_e *SuggestionRecordRepositoryPort_Expecter) FindSuggestionRecords() *SuggestionRecordRepositoryPort_FindSuggestionRecords_Call

+ func (_e *SuggestionRecordRepositoryPort_Expecter) Rejects() *SuggestionRecordRepositoryPort_Rejects_Call

+ type SuggestionRecordRepositoryPort_FindSuggestionRecords_Call struct

+ func (_c *SuggestionRecordRepositoryPort_FindSuggestionRecords_Call) Return(_a0 []*ui.SuggestionRecord) *SuggestionRecordRepositoryPort_FindSuggestionRecords_Call

+ func (_c *SuggestionRecordRepositoryPort_FindSuggestionRecords_Call) Run(run func()) *SuggestionRecordRepositoryPort_FindSuggestionRecords_Call

+ func (_c *SuggestionRecordRepositoryPort_FindSuggestionRecords_Call) RunAndReturn(run func() []*ui.SuggestionRecord) *SuggestionRecordRepositoryPort_FindSuggestionRecords_Call

+ type SuggestionRecordRepositoryPort_Rejects_Call struct

+ func (_c *SuggestionRecordRepositoryPort_Rejects_Call) Return(_a0 int) *SuggestionRecordRepositoryPort_Rejects_Call

+ func (_c *SuggestionRecordRepositoryPort_Rejects_Call) Run(run func()) *SuggestionRecordRepositoryPort_Rejects_Call

+ func (_c *SuggestionRecordRepositoryPort_Rejects_Call) RunAndReturn(run func() int) *SuggestionRecordRepositoryPort_Rejects_Call

type TimelineAdapter

+ func (_m *TimelineAdapter) EXPECT() *TimelineAdapter_Expecter

+ type TimelineAdapter_Expecter struct

+ func (_e *TimelineAdapter_Expecter) FindAlbum(dateTime interface{}) *TimelineAdapter_FindAlbum_Call

+ func (_e *TimelineAdapter_Expecter) FindOrCreateAlbum(mediaTime interface{}) *TimelineAdapter_FindOrCreateAlbum_Call

+ type TimelineAdapter_FindAlbum_Call struct

+ func (_c *TimelineAdapter_FindAlbum_Call) Return(folderName string, exists bool, err error) *TimelineAdapter_FindAlbum_Call

+ func (_c *TimelineAdapter_FindAlbum_Call) Run(run func(dateTime time.Time)) *TimelineAdapter_FindAlbum_Call

+ func (_c *TimelineAdapter_FindAlbum_Call) RunAndReturn(run func(time.Time) (string, bool, error)) *TimelineAdapter_FindAlbum_Call

+ type TimelineAdapter_FindOrCreateAlbum_Call struct

+ func (_c *TimelineAdapter_FindOrCreateAlbum_Call) Return(folderName string, created bool, err error) *TimelineAdapter_FindOrCreateAlbum_Call

+ func (_c *TimelineAdapter_FindOrCreateAlbum_Call) Run(run func(mediaTime time.Time)) *TimelineAdapter_FindOrCreateAlbum_Call

+ func (_c *TimelineAdapter_FindOrCreateAlbum_Call) RunAndReturn(run func(time.Time) (string, bool, error)) *TimelineAdapter_FindOrCreateAlbum_Call

type TimelineMutationObserver

+ func (_m *TimelineMutationObserver) EXPECT() *TimelineMutationObserver_Expecter

+ type TimelineMutationObserver_Expecter struct

+ func (_e *TimelineMutationObserver_Expecter) Observe(ctx interface{}, transfers interface{}) *TimelineMutationObserver_Observe_Call

+ type TimelineMutationObserver_Observe_Call struct

+ func (_c *TimelineMutationObserver_Observe_Call) Return(_a0 error) *TimelineMutationObserver_Observe_Call

+ func (_c *TimelineMutationObserver_Observe_Call) Run(run func(ctx context.Context, transfers catalog.TransferredMedias)) *TimelineMutationObserver_Observe_Call

+ func (_c *TimelineMutationObserver_Observe_Call) RunAndReturn(run func(context.Context, catalog.TransferredMedias) error) *TimelineMutationObserver_Observe_Call

type TrackAnalysed

+ func (_m *TrackAnalysed) EXPECT() *TrackAnalysed_Expecter

+ type TrackAnalysed_Expecter struct

+ func (_e *TrackAnalysed_Expecter) OnAnalysed(done interface{}, total interface{}, cached interface{}) *TrackAnalysed_OnAnalysed_Call

+ type TrackAnalysed_OnAnalysed_Call struct

+ func (_c *TrackAnalysed_OnAnalysed_Call) Return() *TrackAnalysed_OnAnalysed_Call

+ func (_c *TrackAnalysed_OnAnalysed_Call) Run(run func(done backup.MediaCounter, total backup.MediaCounter, ...)) *TrackAnalysed_OnAnalysed_Call

+ func (_c *TrackAnalysed_OnAnalysed_Call) RunAndReturn(run func(backup.MediaCounter, backup.MediaCounter, backup.MediaCounter)) *TrackAnalysed_OnAnalysed_Call

type TrackEvents

+ func (_m *TrackEvents) EXPECT() *TrackEvents_Expecter

+ type TrackEvents_Expecter struct

+ func (_e *TrackEvents_Expecter) OnEvent(event interface{}) *TrackEvents_OnEvent_Call

+ type TrackEvents_OnEvent_Call struct

+ func (_c *TrackEvents_OnEvent_Call) Return() *TrackEvents_OnEvent_Call

+ func (_c *TrackEvents_OnEvent_Call) Run(run func(event backup.ProgressEvent)) *TrackEvents_OnEvent_Call

+ func (_c *TrackEvents_OnEvent_Call) RunAndReturn(run func(backup.ProgressEvent)) *TrackEvents_OnEvent_Call

type TrackScanComplete

+ func (_m *TrackScanComplete) EXPECT() *TrackScanComplete_Expecter

+ type TrackScanComplete_Expecter struct

+ func (_e *TrackScanComplete_Expecter) OnScanComplete(total interface{}) *TrackScanComplete_OnScanComplete_Call

+ type TrackScanComplete_OnScanComplete_Call struct

+ func (_c *TrackScanComplete_OnScanComplete_Call) Return() *TrackScanComplete_OnScanComplete_Call

+ func (_c *TrackScanComplete_OnScanComplete_Call) Run(run func(total backup.MediaCounter)) *TrackScanComplete_OnScanComplete_Call

+ func (_c *TrackScanComplete_OnScanComplete_Call) RunAndReturn(run func(backup.MediaCounter)) *TrackScanComplete_OnScanComplete_Call

type TrackUploaded

+ func (_m *TrackUploaded) EXPECT() *TrackUploaded_Expecter

+ type TrackUploaded_Expecter struct

+ func (_e *TrackUploaded_Expecter) OnUploaded(done interface{}, total interface{}) *TrackUploaded_OnUploaded_Call

+ type TrackUploaded_OnUploaded_Call struct

+ func (_c *TrackUploaded_OnUploaded_Call) Return() *TrackUploaded_OnUploaded_Call

+ func (_c *TrackUploaded_OnUploaded_Call) Run(run func(done backup.MediaCounter, total backup.MediaCounter)) *TrackUploaded_OnUploaded_Call

+ func (_c *TrackUploaded_OnUploaded_Call) RunAndReturn(run func(backup.MediaCounter, backup.MediaCounter)) *TrackUploaded_OnUploaded_Call

+ type TransferMediasFunc struct

+ func NewTransferMediasFunc(t interface{ ... }) *TransferMediasFunc

+ func (_m *TransferMediasFunc) EXPECT() *TransferMediasFunc_Expecter

+ func (_m *TransferMediasFunc) Execute(ctx context.Context, records catalog.MediaTransferRecords) (catalog.TransferredMedias, error)

+ type TransferMediasFunc_Execute_Call struct

+ func (_c *TransferMediasFunc_Execute_Call) Return(_a0 catalog.TransferredMedias, _a1 error) *TransferMediasFunc_Execute_Call

+ func (_c *TransferMediasFunc_Execute_Call) Run(run func(ctx context.Context, records catalog.MediaTransferRecords)) *TransferMediasFunc_Execute_Call

+ func (_c *TransferMediasFunc_Execute_Call) RunAndReturn(...) *TransferMediasFunc_Execute_Call

+ type TransferMediasFunc_Expecter struct

+ func (_e *TransferMediasFunc_Expecter) Execute(ctx interface{}, records interface{}) *TransferMediasFunc_Execute_Call

type TransferMediasPort

+ func (_m *TransferMediasPort) EXPECT() *TransferMediasPort_Expecter

+ type TransferMediasPort_Expecter struct

+ func (_e *TransferMediasPort_Expecter) TransferMediasFromRecords(ctx interface{}, records interface{}) *TransferMediasPort_TransferMediasFromRecords_Call

+ type TransferMediasPort_TransferMediasFromRecords_Call struct

+ func (_c *TransferMediasPort_TransferMediasFromRecords_Call) Return(_a0 catalog.TransferredMedias, _a1 error) *TransferMediasPort_TransferMediasFromRecords_Call

+ func (_c *TransferMediasPort_TransferMediasFromRecords_Call) Run(run func(ctx context.Context, records catalog.MediaTransferRecords)) *TransferMediasPort_TransferMediasFromRecords_Call

+ func (_c *TransferMediasPort_TransferMediasFromRecords_Call) RunAndReturn(...) *TransferMediasPort_TransferMediasFromRecords_Call

type UpdateAlbumPort

+ func (_m *UpdateAlbumPort) EXPECT() *UpdateAlbumPort_Expecter

+ type UpdateAlbumPort_Expecter struct

+ func (_e *UpdateAlbumPort_Expecter) UpdateAlbum(folderName interface{}, start interface{}, end interface{}) *UpdateAlbumPort_UpdateAlbum_Call

+ type UpdateAlbumPort_UpdateAlbum_Call struct

+ func (_c *UpdateAlbumPort_UpdateAlbum_Call) Return(_a0 error) *UpdateAlbumPort_UpdateAlbum_Call

+ func (_c *UpdateAlbumPort_UpdateAlbum_Call) Run(run func(folderName string, start time.Time, end time.Time)) *UpdateAlbumPort_UpdateAlbum_Call

+ func (_c *UpdateAlbumPort_UpdateAlbum_Call) RunAndReturn(run func(string, time.Time, time.Time) error) *UpdateAlbumPort_UpdateAlbum_Call

type UserInputPort

+ func (_m *UserInputPort) EXPECT() *UserInputPort_Expecter

+ type UserInputPort_Expecter struct

+ func (_e *UserInputPort_Expecter) StartListening() *UserInputPort_StartListening_Call

+ type UserInputPort_StartListening_Call struct

+ func (_c *UserInputPort_StartListening_Call) Return() *UserInputPort_StartListening_Call

+ func (_c *UserInputPort_StartListening_Call) Run(run func()) *UserInputPort_StartListening_Call

+ func (_c *UserInputPort_StartListening_Call) RunAndReturn(run func()) *UserInputPort_StartListening_Call

v1.5.40

May 6, 2024

v1.5.39

May 6, 2024

Changes in this version

+ type AWSAdapterNames struct

+ func NewAWSAdapterNames(t interface{ ... }) *AWSAdapterNames

+ func (_m *AWSAdapterNames) ArchiveCacheBucketName() string

+ func (_m *AWSAdapterNames) ArchiveJobsSNSARN() string

+ func (_m *AWSAdapterNames) ArchiveJobsSQSURL() string

+ func (_m *AWSAdapterNames) ArchiveMainBucketName() string

+ func (_m *AWSAdapterNames) DynamoDBName() string

v1.5.38

May 6, 2024

v1.5.36

May 5, 2024

v1.5.34

May 4, 2024

v1.5.33

May 3, 2024

Changes in this version

type CArchiveAdapter

+ func (_m *CArchiveAdapter) Observe(ctx context.Context, transfers catalog.TransferredMedias) error

type Config

+ func (_m *Config) GetAWSFactory() *awsfactory.AWSFactory

+ type ConfigFactory struct

+ func NewConfigFactory(t interface{ ... }) *ConfigFactory

+ func (_m *ConfigFactory) NewConfig(ctx context.Context) (aws.Config, error)

+ type ConfigFactoryFunc struct

+ func NewConfigFactoryFunc(t interface{ ... }) *ConfigFactoryFunc

+ func (_m *ConfigFactoryFunc) Execute(ctx context.Context) (aws.Config, error)

+ type FindAlbumsByOwnerPort struct

+ func NewFindAlbumsByOwnerPort(t interface{ ... }) *FindAlbumsByOwnerPort

+ func (_m *FindAlbumsByOwnerPort) FindAlbumsByOwner(ctx context.Context, owner catalog.Owner) ([]*catalog.Album, error)

+ type FindAlbumsByOwnerPortFunc struct

+ func NewFindAlbumsByOwnerPortFunc(t interface{ ... }) *FindAlbumsByOwnerPortFunc

+ func (_m *FindAlbumsByOwnerPortFunc) Execute(ctx context.Context, owner catalog.Owner) ([]*catalog.Album, error)

+ type InsertAlbumPort struct

+ func NewInsertAlbumPort(t interface{ ... }) *InsertAlbumPort

+ func (_m *InsertAlbumPort) InsertAlbum(ctx context.Context, album catalog.Album) error

+ type InsertAlbumPortFunc struct

+ func NewInsertAlbumPortFunc(t interface{ ... }) *InsertAlbumPortFunc

+ func (_m *InsertAlbumPortFunc) Execute(ctx context.Context, album catalog.Album) error

+ type ListMediaIdsPort struct

+ func NewListMediaIdsPort(t interface{ ... }) *ListMediaIdsPort

+ func (_m *ListMediaIdsPort) ListMediaIdsFromSelector(ctx context.Context, selector []catalog.MediaSelector) ([]catalog.MediaId, error)

+ type MoveMediaPort struct

+ func NewMoveMediaPort(t interface{ ... }) *MoveMediaPort

+ func (_m *MoveMediaPort) MoveMedia(ctx context.Context, albumId catalog.AlbumId, mediaIds []catalog.MediaId) error

+ type MoveMediaPortFunc struct

+ func NewMoveMediaPortFunc(t interface{ ... }) *MoveMediaPortFunc

+ func (_m *MoveMediaPortFunc) Execute(ctx context.Context, albumId catalog.AlbumId, mediaIds []catalog.MediaId) error

+ type Names struct

+ func NewNames(t interface{ ... }) *Names

+ func (_m *Names) DynamoDBMainTable() string

type RepositoryAdapter

+ func (_m *RepositoryAdapter) TransferMediasFromRecords(ctx context.Context, records catalog.MediaTransferRecords) (catalog.TransferredMedias, error)

+ type RepositoryContract struct

+ func NewRepositoryContract(t interface{ ... }) *RepositoryContract

+ func (_m *RepositoryContract) DeleteEmptyAlbum(id catalog.AlbumId) error

+ func (_m *RepositoryContract) FindAlbums(ids ...catalog.AlbumId) ([]*catalog.Album, error)

+ func (_m *RepositoryContract) FindAlbumsByOwner(owner catalog.Owner) ([]*catalog.Album, error)

+ func (_m *RepositoryContract) FindExistingSignatures(owner catalog.Owner, signatures []*catalog.MediaSignature) ([]*catalog.MediaSignature, error)

+ func (_m *RepositoryContract) FindMediaCurrentAlbum(owner catalog.Owner, mediaId catalog.MediaId) (*catalog.AlbumId, error)

+ func (_m *RepositoryContract) FindMediaIds(request *catalog.FindMediaRequest) ([]catalog.MediaId, error)

+ func (_m *RepositoryContract) FindMedias(request *catalog.FindMediaRequest) ([]*catalog.MediaMeta, error)

+ func (_m *RepositoryContract) InsertAlbum(album catalog.Album) error

+ func (_m *RepositoryContract) InsertMedias(owner catalog.Owner, media []catalog.CreateMediaRequest) error

+ func (_m *RepositoryContract) TransferMedias(owner catalog.Owner, mediaIds []catalog.MediaId, ...) error

+ func (_m *RepositoryContract) TransferMediasFromRecords(ctx context.Context, records catalog.MediaTransferRecords) (catalog.TransferredMedias, error)

+ func (_m *RepositoryContract) UpdateAlbum(album catalog.Album) error

+ type SecretAccessKeyDecoder struct

+ func NewSecretAccessKeyDecoder(t interface{ ... }) *SecretAccessKeyDecoder

+ func (_m *SecretAccessKeyDecoder) Execute(encodedValue string) (string, error)

+ type TimelineMutationObserver struct

+ func NewTimelineMutationObserver(t interface{ ... }) *TimelineMutationObserver

+ func (_m *TimelineMutationObserver) Observe(ctx context.Context, transfers catalog.TransferredMedias) error

+ type TransferMediasPort struct

+ func NewTransferMediasPort(t interface{ ... }) *TransferMediasPort

+ func (_m *TransferMediasPort) TransferMediasFromRecords(ctx context.Context, records catalog.MediaTransferRecords) (catalog.TransferredMedias, error)

v1.5.31

Apr 28, 2024

v1.5.27

Apr 25, 2024

v1.5.26

Apr 25, 2024

v1.5.23

Apr 24, 2024

v1.5.22

Apr 24, 2024

v1.5.21

Apr 21, 2024

v1.5.20

Apr 21, 2024

Changes in this version

type Config

+ func (_m *Config) GetAWSV2Config() aws.Config

+ type RunnerAnalyser struct

+ func NewRunnerAnalyser(t interface{ ... }) *RunnerAnalyser

+ func (_m *RunnerAnalyser) Analyse(found backup.FoundMedia, progressChannel chan *backup.ProgressEvent) (*backup.AnalysedMedia, error)

v1.5.19

Apr 21, 2024

v1.5.18

Apr 15, 2024

v1.5.17

Apr 15, 2024

v1.5.16

Apr 14, 2024

v1.5.14

Apr 4, 2024

v1.5.12

Apr 3, 2024

v1.5.11

Apr 3, 2024

v1.5.7

Apr 1, 2024

v1.5.3

Mar 18, 2024

v1.5.2

Mar 18, 2024

v1.5.1

Mar 18, 2024

v1.5.0

Mar 17, 2024

Changes in this version

+ type AnalyserDecorator struct

+ func NewAnalyserDecorator(t interface{ ... }) *AnalyserDecorator

+ func (_m *AnalyserDecorator) Decorate(analyseFunc backup.RunnerAnalyserFunc) backup.RunnerAnalyserFunc

type FoundMedia

+ func (_m *FoundMedia) LastModification() time.Time

type GrantRepository

+ func (_m *GrantRepository) ListScopesByOwners(owners []string, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ type IdentityRepository struct

+ func NewIdentityRepository(t interface{ ... }) *IdentityRepository

+ func (_m *IdentityRepository) FindIdentities(emails []string) ([]*aclcore.Identity, error)

+ func (_m *IdentityRepository) FindIdentity(email string) (*aclcore.Identity, error)

+ func (_m *IdentityRepository) StoreIdentity(identity aclcore.Identity) error

+ type RunnerAnalyserFunc struct

+ func NewRunnerAnalyserFunc(t interface{ ... }) *RunnerAnalyserFunc

+ func (_m *RunnerAnalyserFunc) Execute(found backup.FoundMedia, progressChannel chan *backup.ProgressEvent) (*backup.AnalysedMedia, error)

v1.4.1

Sep 24, 2023

v1.4.0

May 9, 2023

Changes in this version

+ type ACLViewCatalogAdapter struct

+ func NewACLViewCatalogAdapter(t mockConstructorTestingTNewACLViewCatalogAdapter) *ACLViewCatalogAdapter

+ func (_m *ACLViewCatalogAdapter) FindAlbums(keys []catalog.AlbumId) ([]*catalog.Album, error)

+ func (_m *ACLViewCatalogAdapter) FindAllAlbums(owner string) ([]*catalog.Album, error)

+ func (_m *ACLViewCatalogAdapter) ListMedias(owner string, folderName string, request catalog.PageRequest) (*catalog.MediaPage, error)

+ type ARepositoryAdapter struct

+ func NewARepositoryAdapter(t mockConstructorTestingTNewARepositoryAdapter) *ARepositoryAdapter

+ func (_m *ARepositoryAdapter) AddLocation(owner string, id string, key string) error

+ func (_m *ARepositoryAdapter) FindById(owner string, id string) (string, error)

+ func (_m *ARepositoryAdapter) FindByIds(owner string, ids []string) (map[string]string, error)

+ func (_m *ARepositoryAdapter) FindIdsFromKeyPrefix(keyPrefix string) (map[string]string, error)

+ func (_m *ARepositoryAdapter) UpdateLocations(owner string, locations map[string]string) error

+ type AsyncJobAdapter struct

+ func NewAsyncJobAdapter(t mockConstructorTestingTNewAsyncJobAdapter) *AsyncJobAdapter

+ func (_m *AsyncJobAdapter) LoadImagesInCache(images ...*archive.ImageToResize) error

+ func (_m *AsyncJobAdapter) WarmUpCacheByFolder(owner string, missedStoreKey string, width int) error

+ type BArchiveAdapter struct

+ func NewBArchiveAdapter(t mockConstructorTestingTNewBArchiveAdapter) *BArchiveAdapter

+ func (_m *BArchiveAdapter) ArchiveMedia(owner string, media *backup.BackingUpMediaRequest) (string, error)

+ type BackupSuggestionPort struct

+ func NewBackupSuggestionPort(t mockConstructorTestingTNewBackupSuggestionPort) *BackupSuggestionPort

+ func (_m *BackupSuggestionPort) BackupSuggestion(record *ui.SuggestionRecord, existing *ui.ExistingRecord, ...) error

+ type CArchiveAdapter struct

+ func NewCArchiveAdapter(t mockConstructorTestingTNewCArchiveAdapter) *CArchiveAdapter

+ func (_m *CArchiveAdapter) MoveMedias(owner string, ids []string, name string) error

+ type CacheAdapter struct

+ func NewCacheAdapter(t mockConstructorTestingTNewCacheAdapter) *CacheAdapter

+ func (_m *CacheAdapter) Get(key string) (io.ReadCloser, int, string, error)

+ func (_m *CacheAdapter) Put(key string, mediaType string, content io.Reader) error

+ func (_m *CacheAdapter) SignedURL(key string, duration time.Duration) (string, error)

+ func (_m *CacheAdapter) WalkCacheByPrefix(prefix string, observer func(string)) error

+ type CatalogAdapter struct

+ func NewCatalogAdapter(t mockConstructorTestingTNewCatalogAdapter) *CatalogAdapter

+ func (_m *CatalogAdapter) AssignIdsToNewMedias(owner string, medias []*backup.AnalysedMedia) (map[*backup.AnalysedMedia]string, error)

+ func (_m *CatalogAdapter) GetAlbumsTimeline(owner string) (backup.TimelineAdapter, error)

+ func (_m *CatalogAdapter) IndexMedias(owner string, requests []*backup.CatalogMediaRequest) error

+ type CatalogRules struct

+ func NewCatalogRules(t mockConstructorTestingTNewCatalogRules) *CatalogRules

+ func (_m *CatalogRules) CanListMediasFromAlbum(owner string, folderName string) error

+ func (_m *CatalogRules) CanManageAlbum(owner string, folderName string) error

+ func (_m *CatalogRules) CanReadMedia(owner string, id string) error

+ func (_m *CatalogRules) Owner() (string, error)

+ func (_m *CatalogRules) SharedByUserGrid(owner string) (map[string]map[string]aclcore.ScopeType, error)

+ func (_m *CatalogRules) SharedWithUserAlbum() ([]catalog.AlbumId, error)

+ type CertificateAuthority struct

+ func NewCertificateAuthority(t mockConstructorTestingTNewCertificateAuthority) *CertificateAuthority

+ func (_m *CertificateAuthority) RequestCertificate(email string, domain string) (*dnsdomain.CompleteCertificate, error)

+ type CertificateManager struct

+ func NewCertificateManager(t mockConstructorTestingTNewCertificateManager) *CertificateManager

+ func (_m *CertificateManager) FindCertificate(domain string) (*dnsdomain.ExistingCertificate, error)

+ func (_m *CertificateManager) InstallCertificate(id string, certificate dnsdomain.CompleteCertificate) error

+ type ClosableFoundMedia struct

+ func NewClosableFoundMedia(t mockConstructorTestingTNewClosableFoundMedia) *ClosableFoundMedia

+ func (_m *ClosableFoundMedia) Close() error

+ type CompletionReport struct

+ func NewCompletionReport(t mockConstructorTestingTNewCompletionReport) *CompletionReport

+ func (_m *CompletionReport) CountPerAlbum() map[string]*backup.TypeCounter

+ func (_m *CompletionReport) NewAlbums() []string

+ func (_m *CompletionReport) Skipped() backup.MediaCounter

+ type Config struct

+ func NewConfig(t mockConstructorTestingTNewConfig) *Config

+ func (_m *Config) Get(key string) interface{}

+ func (_m *Config) GetAWSSession() *session.Session

+ func (_m *Config) GetBool(key string) bool

+ func (_m *Config) GetInt(key string) int

+ func (_m *Config) GetIntOrDefault(key string, defaultValue int) int

+ func (_m *Config) GetString(key string) string

+ func (_m *Config) GetStringOrDefault(key string, defaultValue string) string

+ type CreateAlbumPort struct

+ func NewCreateAlbumPort(t mockConstructorTestingTNewCreateAlbumPort) *CreateAlbumPort

+ func (_m *CreateAlbumPort) Create(createRequest ui.RecordCreation) error

+ type DeleteAlbumPort struct

+ func NewDeleteAlbumPort(t mockConstructorTestingTNewDeleteAlbumPort) *DeleteAlbumPort

+ func (_m *DeleteAlbumPort) DeleteAlbum(folderName string) error

+ type DetailsReaderAdapter struct

+ func NewDetailsReaderAdapter(t mockConstructorTestingTNewDetailsReaderAdapter) *DetailsReaderAdapter

+ func (_m *DetailsReaderAdapter) ReadDetails(reader io.Reader, options backup.DetailsReaderOptions) (*backup.MediaDetails, error)

+ func (_m *DetailsReaderAdapter) Supports(media backup.FoundMedia, mediaType backup.MediaType) bool

+ type DynamoBatchGetItem struct

+ func NewDynamoBatchGetItem(t mockConstructorTestingTNewDynamoBatchGetItem) *DynamoBatchGetItem

+ func (_m *DynamoBatchGetItem) BatchGetItem(_a0 *dynamodb.BatchGetItemInput) (*dynamodb.BatchGetItemOutput, error)

+ type DynamoBatchWriteItem struct

+ func NewDynamoBatchWriteItem(t mockConstructorTestingTNewDynamoBatchWriteItem) *DynamoBatchWriteItem

+ func (_m *DynamoBatchWriteItem) BatchWriteItem(_a0 *dynamodb.BatchWriteItemInput) (*dynamodb.BatchWriteItemOutput, error)

+ type DynamoQuery struct

+ func NewDynamoQuery(t mockConstructorTestingTNewDynamoQuery) *DynamoQuery

+ func (_m *DynamoQuery) Query(d *dynamodb.QueryInput) (*dynamodb.QueryOutput, error)

+ type ExistingRecordRepositoryPort struct

+ func NewExistingRecordRepositoryPort(t mockConstructorTestingTNewExistingRecordRepositoryPort) *ExistingRecordRepositoryPort

+ func (_m *ExistingRecordRepositoryPort) FindExistingRecords() ([]*ui.ExistingRecord, error)

+ type FoundMedia struct

+ func NewFoundMedia(t mockConstructorTestingTNewFoundMedia) *FoundMedia

+ func (_m *FoundMedia) MediaPath() backup.MediaPath

+ func (_m *FoundMedia) ReadMedia() (io.ReadCloser, error)

+ func (_m *FoundMedia) Size() int

+ func (_m *FoundMedia) String() string

+ type GetStreamAdapter struct

+ func NewGetStreamAdapter(t mockConstructorTestingTNewGetStreamAdapter) *GetStreamAdapter

+ func (_m *GetStreamAdapter) BatchGet(_a0 []map[string]*dynamodb.AttributeValue) (*dynamodb.BatchGetItemOutput, error)

+ type GrantRepository struct

+ func NewGrantRepository(t mockConstructorTestingTNewGrantRepository) *GrantRepository

+ func (_m *GrantRepository) DeleteScopes(id ...aclcore.ScopeId) error

+ func (_m *GrantRepository) FindScopesById(ids ...aclcore.ScopeId) ([]*aclcore.Scope, error)

+ func (_m *GrantRepository) ListOwnerScopes(owner string, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ func (_m *GrantRepository) ListUserScopes(email string, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ func (_m *GrantRepository) SaveIfNewScope(scope aclcore.Scope) error

+ type IAccessTokenGenerator struct

+ func NewIAccessTokenGenerator(t mockConstructorTestingTNewIAccessTokenGenerator) *IAccessTokenGenerator

+ func (_m *IAccessTokenGenerator) GenerateAccessToken(email string) (*aclcore.Authentication, error)

+ type IRefreshTokenGenerator struct

+ func NewIRefreshTokenGenerator(t mockConstructorTestingTNewIRefreshTokenGenerator) *IRefreshTokenGenerator

+ func (_m *IRefreshTokenGenerator) GenerateRefreshToken(spec aclcore.RefreshTokenSpec) (string, error)

+ type IdentityDetailsStore struct

+ func NewIdentityDetailsStore(t mockConstructorTestingTNewIdentityDetailsStore) *IdentityDetailsStore

+ func (_m *IdentityDetailsStore) FindIdentity(email string) (*aclcore.Identity, error)

+ func (_m *IdentityDetailsStore) StoreIdentity(identity aclcore.Identity) error

+ type IdentityQueriesIdentityRepository struct

+ func NewIdentityQueriesIdentityRepository(t mockConstructorTestingTNewIdentityQueriesIdentityRepository) *IdentityQueriesIdentityRepository

+ func (_m *IdentityQueriesIdentityRepository) FindIdentities(emails []string) ([]*aclcore.Identity, error)

+ type IdentityQueriesScopeRepository struct

+ func NewIdentityQueriesScopeRepository(t mockConstructorTestingTNewIdentityQueriesScopeRepository) *IdentityQueriesScopeRepository

+ func (_m *IdentityQueriesScopeRepository) ListScopesByOwners(owners []string, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ type InteractiveActionsPort struct

+ func NewInteractiveActionsPort(t mockConstructorTestingTNewInteractiveActionsPort) *InteractiveActionsPort

+ func (_m *InteractiveActionsPort) BackupSuggestion(record *ui.SuggestionRecord, existing *ui.ExistingRecord, ...) error

+ func (_m *InteractiveActionsPort) Create(createRequest ui.RecordCreation) error

+ func (_m *InteractiveActionsPort) DeleteAlbum(folderName string) error

+ func (_m *InteractiveActionsPort) RenameAlbum(folderName string, newName string, renameFolder bool) error

+ func (_m *InteractiveActionsPort) UpdateAlbum(folderName string, start time.Time, end time.Time) error

+ type InteractiveRendererPort struct

+ func NewInteractiveRendererPort(t mockConstructorTestingTNewInteractiveRendererPort) *InteractiveRendererPort

+ func (_m *InteractiveRendererPort) Height() int

+ func (_m *InteractiveRendererPort) Print(question string)

+ func (_m *InteractiveRendererPort) ReadAnswer() (string, error)

+ func (_m *InteractiveRendererPort) Render(state *ui.InteractiveViewState) error

+ func (_m *InteractiveRendererPort) TakeOverScreen()

+ type Listener struct

+ func NewListener(t mockConstructorTestingTNewListener) *Listener

+ func (_m *Listener) Execute(_a0 config.Config)

+ type MediaAlbumResolver struct

+ func NewMediaAlbumResolver(t mockConstructorTestingTNewMediaAlbumResolver) *MediaAlbumResolver

+ func (_m *MediaAlbumResolver) FindAlbumOfMedia(owner string, mediaId string) (string, error)

+ type PostAnalyseFilter struct

+ func NewPostAnalyseFilter(t mockConstructorTestingTNewPostAnalyseFilter) *PostAnalyseFilter

+ func (_m *PostAnalyseFilter) AcceptAnalysedMedia(media *backup.AnalysedMedia, folderName string) bool

+ type PrintReadTerminalPort struct

+ func NewPrintReadTerminalPort(t mockConstructorTestingTNewPrintReadTerminalPort) *PrintReadTerminalPort

+ func (_m *PrintReadTerminalPort) Print(question string)

+ func (_m *PrintReadTerminalPort) ReadAnswer() (string, error)

+ type RefreshTokenRepository struct

+ func NewRefreshTokenRepository(t mockConstructorTestingTNewRefreshTokenRepository) *RefreshTokenRepository

+ func (_m *RefreshTokenRepository) DeleteRefreshToken(token string) error

+ func (_m *RefreshTokenRepository) FindRefreshToken(token string) (*aclcore.RefreshTokenSpec, error)

+ func (_m *RefreshTokenRepository) HouseKeepRefreshToken() (int, error)

+ func (_m *RefreshTokenRepository) StoreRefreshToken(token string, spec aclcore.RefreshTokenSpec) error

+ type RenameAlbumPort struct

+ func NewRenameAlbumPort(t mockConstructorTestingTNewRenameAlbumPort) *RenameAlbumPort

+ func (_m *RenameAlbumPort) RenameAlbum(folderName string, newName string, renameFolder bool) error

+ type RepositoryAdapter struct

+ func NewRepositoryAdapter(t mockConstructorTestingTNewRepositoryAdapter) *RepositoryAdapter

+ func (_m *RepositoryAdapter) DeleteEmptyAlbum(owner string, folderName string) error

+ func (_m *RepositoryAdapter) FindAlbums(ids ...catalog.AlbumId) ([]*catalog.Album, error)

+ func (_m *RepositoryAdapter) FindAlbumsByOwner(owner string) ([]*catalog.Album, error)

+ func (_m *RepositoryAdapter) FindExistingSignatures(owner string, signatures []*catalog.MediaSignature) ([]*catalog.MediaSignature, error)

+ func (_m *RepositoryAdapter) FindMediaCurrentAlbum(owner string, mediaId string) (string, error)

+ func (_m *RepositoryAdapter) FindMediaIds(request *catalog.FindMediaRequest) ([]string, error)

+ func (_m *RepositoryAdapter) FindMedias(request *catalog.FindMediaRequest) ([]*catalog.MediaMeta, error)

+ func (_m *RepositoryAdapter) InsertAlbum(album catalog.Album) error

+ func (_m *RepositoryAdapter) InsertMedias(owner string, media []catalog.CreateMediaRequest) error

+ func (_m *RepositoryAdapter) TransferMedias(owner string, mediaIds []string, newFolderName string) error

+ func (_m *RepositoryAdapter) UpdateAlbum(album catalog.Album) error

+ type ResizerAdapter struct

+ func NewResizerAdapter(t mockConstructorTestingTNewResizerAdapter) *ResizerAdapter

+ func (_m *ResizerAdapter) ResizeImage(reader io.Reader, width int, fast bool) ([]byte, string, error)

+ func (_m *ResizerAdapter) ResizeImageAtDifferentWidths(reader io.Reader, width []int) (map[int][]byte, string, error)

+ type ReverseScopesReader struct

+ func NewReverseScopesReader(t mockConstructorTestingTNewReverseScopesReader) *ReverseScopesReader

+ func (_m *ReverseScopesReader) ListOwnerScopes(owner string, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ type RevokeAccessTokenAdapter struct

+ func NewRevokeAccessTokenAdapter(t mockConstructorTestingTNewRevokeAccessTokenAdapter) *RevokeAccessTokenAdapter

+ func (_m *RevokeAccessTokenAdapter) DeleteRefreshToken(token string) error

+ type ScanStreamExecutor struct

+ func NewScanStreamExecutor(t mockConstructorTestingTNewScanStreamExecutor) *ScanStreamExecutor

+ func (_m *ScanStreamExecutor) Scan(input *dynamodb.ScanInput) (*dynamodb.ScanOutput, error)

+ type ScopeRepository struct

+ func NewScopeRepository(t mockConstructorTestingTNewScopeRepository) *ScopeRepository

+ func (_m *ScopeRepository) FindScopesById(ids ...aclcore.ScopeId) ([]*aclcore.Scope, error)

+ func (_m *ScopeRepository) ListOwnerScopes(owner string, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ func (_m *ScopeRepository) ListUserScopes(email string, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ type ScopeWriter struct

+ func NewScopeWriter(t mockConstructorTestingTNewScopeWriter) *ScopeWriter

+ func (_m *ScopeWriter) DeleteScopes(id ...aclcore.ScopeId) error

+ func (_m *ScopeWriter) SaveIfNewScope(scope aclcore.Scope) error

+ type ScopesReader struct

+ func NewScopesReader(t mockConstructorTestingTNewScopesReader) *ScopesReader

+ func (_m *ScopesReader) FindScopesById(ids ...aclcore.ScopeId) ([]*aclcore.Scope, error)

+ func (_m *ScopesReader) ListUserScopes(email string, types ...aclcore.ScopeType) ([]*aclcore.Scope, error)

+ type ShareAlbumCatalogPort struct

+ func NewShareAlbumCatalogPort(t mockConstructorTestingTNewShareAlbumCatalogPort) *ShareAlbumCatalogPort

+ func (_m *ShareAlbumCatalogPort) FindAlbum(owner string, folderName string) (*catalog.Album, error)

+ type SourceVolume struct

+ func NewSourceVolume(t mockConstructorTestingTNewSourceVolume) *SourceVolume

+ func (_m *SourceVolume) FindMedias() ([]backup.FoundMedia, error)

+ func (_m *SourceVolume) String() string

+ type StoreAdapter struct

+ func NewStoreAdapter(t mockConstructorTestingTNewStoreAdapter) *StoreAdapter

+ func (_m *StoreAdapter) Copy(origin string, destination archive.DestructuredKey) (string, error)

+ func (_m *StoreAdapter) Delete(locations []string) error

+ func (_m *StoreAdapter) Download(key string) (io.ReadCloser, error)

+ func (_m *StoreAdapter) SignedURL(key string, duration time.Duration) (string, error)

+ func (_m *StoreAdapter) Upload(values archive.DestructuredKey, content io.Reader) (string, error)

+ type StoreAndCache struct

+ func NewStoreAndCache(t mockConstructorTestingTNewStoreAndCache) *StoreAndCache

+ func (_m *StoreAndCache) Copy(origin string, destination archive.DestructuredKey) (string, error)

+ func (_m *StoreAndCache) Delete(locations []string) error

+ func (_m *StoreAndCache) Download(key string) (io.ReadCloser, error)

+ func (_m *StoreAndCache) Get(key string) (io.ReadCloser, int, string, error)

+ func (_m *StoreAndCache) Put(key string, mediaType string, content io.Reader) error

+ func (_m *StoreAndCache) SignedURL(key string, duration time.Duration) (string, error)

+ func (_m *StoreAndCache) Upload(values archive.DestructuredKey, content io.Reader) (string, error)

+ func (_m *StoreAndCache) WalkCacheByPrefix(prefix string, observer func(string)) error

+ type Stream struct

+ func NewStream(t mockConstructorTestingTNewStream) *Stream

+ func (_m *Stream) Count() int64

+ func (_m *Stream) Error() error

+ func (_m *Stream) HasNext() bool

+ func (_m *Stream) Next() map[string]*dynamodb.AttributeValue

+ type SuggestionRecordRepositoryPort struct

+ func NewSuggestionRecordRepositoryPort(t mockConstructorTestingTNewSuggestionRecordRepositoryPort) *SuggestionRecordRepositoryPort

+ func (_m *SuggestionRecordRepositoryPort) Count() int

+ func (_m *SuggestionRecordRepositoryPort) FindSuggestionRecords() []*ui.SuggestionRecord

+ func (_m *SuggestionRecordRepositoryPort) Rejects() int

+ type TimelineAdapter struct

+ func NewTimelineAdapter(t mockConstructorTestingTNewTimelineAdapter) *TimelineAdapter

+ func (_m *TimelineAdapter) FindAlbum(dateTime time.Time) (string, bool, error)

+ func (_m *TimelineAdapter) FindOrCreateAlbum(mediaTime time.Time) (string, bool, error)

+ type TrackAnalysed struct

+ func NewTrackAnalysed(t mockConstructorTestingTNewTrackAnalysed) *TrackAnalysed

+ func (_m *TrackAnalysed) OnAnalysed(done backup.MediaCounter, total backup.MediaCounter)

+ type TrackEvents struct

+ func NewTrackEvents(t mockConstructorTestingTNewTrackEvents) *TrackEvents

+ func (_m *TrackEvents) OnEvent(event backup.ProgressEvent)

+ type TrackScanComplete struct

+ func NewTrackScanComplete(t mockConstructorTestingTNewTrackScanComplete) *TrackScanComplete

+ func (_m *TrackScanComplete) OnScanComplete(total backup.MediaCounter)

+ type TrackUploaded struct

+ func NewTrackUploaded(t mockConstructorTestingTNewTrackUploaded) *TrackUploaded

+ func (_m *TrackUploaded) OnUploaded(done backup.MediaCounter, total backup.MediaCounter)

+ type UpdateAlbumPort struct

+ func NewUpdateAlbumPort(t mockConstructorTestingTNewUpdateAlbumPort) *UpdateAlbumPort

+ func (_m *UpdateAlbumPort) UpdateAlbum(folderName string, start time.Time, end time.Time) error

+ type UserInputPort struct

+ func NewUserInputPort(t mockConstructorTestingTNewUserInputPort) *UserInputPort

+ func (_m *UserInputPort) StartListening()

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL