mock

package
v0.0.7 Latest Latest
Warning

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

 Go to latest Published: Feb 16, 2025 License: MIT Imports: 5 Imported by: 0

Documentation

Overview

Package mock is a generated GoMock package.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MockCopiable 

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

MockCopiable is a mock of Copiable interface.

func NewMockCopiable 

func NewMockCopiable(ctrl *gomock.Controller) *MockCopiable

NewMockCopiable creates a new mock instance.

func (*MockCopiable) Columns 

func (m *MockCopiable) Columns() []string

Columns mocks base method.

func (*MockCopiable) EXPECT 

func (m *MockCopiable) EXPECT() *MockCopiableMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockCopiable) Flat 

func (m *MockCopiable) Flat() []any

Flat mocks base method.

type MockCopiableColumnsCall 

type MockCopiableColumnsCall struct {
	*gomock.Call
}

MockCopiableColumnsCall wrap *gomock.Call

func (*MockCopiableColumnsCall) Do 

func (c *MockCopiableColumnsCall) Do(f func() []string) *MockCopiableColumnsCall

Do rewrite *gomock.Call.Do

func (*MockCopiableColumnsCall) DoAndReturn 

func (c *MockCopiableColumnsCall) DoAndReturn(f func() []string) *MockCopiableColumnsCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCopiableColumnsCall) Return 

func (c *MockCopiableColumnsCall) Return(arg0 []string) *MockCopiableColumnsCall

Return rewrite *gomock.Call.Return

type MockCopiableFlatCall 

type MockCopiableFlatCall struct {
	*gomock.Call
}

MockCopiableFlatCall wrap *gomock.Call

func (*MockCopiableFlatCall) Do 

func (c *MockCopiableFlatCall) Do(f func() []any) *MockCopiableFlatCall

Do rewrite *gomock.Call.Do

func (*MockCopiableFlatCall) DoAndReturn 

func (c *MockCopiableFlatCall) DoAndReturn(f func() []any) *MockCopiableFlatCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockCopiableFlatCall) Return 

func (c *MockCopiableFlatCall) Return(arg0 []any) *MockCopiableFlatCall

Return rewrite *gomock.Call.Return

type MockCopiableMockRecorder 

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

MockCopiableMockRecorder is the mock recorder for MockCopiable.

func (*MockCopiableMockRecorder) Columns 

func (mr *MockCopiableMockRecorder) Columns() *MockCopiableColumnsCall

Columns indicates an expected call of Columns.

func (*MockCopiableMockRecorder) Flat 

func (mr *MockCopiableMockRecorder) Flat() *MockCopiableFlatCall

Flat indicates an expected call of Flat.

type MockModel 

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

MockModel is a mock of Model interface.

func NewMockModel 

func NewMockModel(ctrl *gomock.Controller) *MockModel

NewMockModel creates a new mock instance.

func (*MockModel) EXPECT 

func (m *MockModel) EXPECT() *MockModelMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockModel) TableName 

func (m *MockModel) TableName() string

TableName mocks base method.

type MockModelMockRecorder 

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

MockModelMockRecorder is the mock recorder for MockModel.

func (*MockModelMockRecorder) TableName 

func (mr *MockModelMockRecorder) TableName() *MockModelTableNameCall

TableName indicates an expected call of TableName.

type MockModelTableNameCall 

type MockModelTableNameCall struct {
	*gomock.Call
}

MockModelTableNameCall wrap *gomock.Call

func (*MockModelTableNameCall) Do 

func (c *MockModelTableNameCall) Do(f func() string) *MockModelTableNameCall

Do rewrite *gomock.Call.Do

func (*MockModelTableNameCall) DoAndReturn 

func (c *MockModelTableNameCall) DoAndReturn(f func() string) *MockModelTableNameCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockModelTableNameCall) Return 

func (c *MockModelTableNameCall) Return(arg0 string) *MockModelTableNameCall

Return rewrite *gomock.Call.Return

type MockTable 

type MockTable[M storage.Model] struct {
	// contains filtered or unexported fields
}

MockTable is a mock of Table interface.

func NewMockTable 

func NewMockTable[M storage.Model](ctrl *gomock.Controller) *MockTable[M]

NewMockTable creates a new mock instance.

func (*MockTable[M]) CursorList 

func (m *MockTable[M]) CursorList(ctx context.Context, id, limit uint64, order storage.SortOrder, cmp storage.Comparator) ([]M, error)

CursorList mocks base method.

func (*MockTable[M]) EXPECT 

func (m *MockTable[M]) EXPECT() *MockTableMockRecorder[M]

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockTable[M]) GetByID 

func (m *MockTable[M]) GetByID(ctx context.Context, id uint64) (M, error)

GetByID mocks base method.

func (*MockTable[M]) IsNoRows 

func (m *MockTable[M]) IsNoRows(err error) bool

IsNoRows mocks base method.

func (*MockTable[M]) LastID 

func (m *MockTable[M]) LastID(ctx context.Context) (uint64, error)

LastID mocks base method.

func (*MockTable[M]) List 

func (m *MockTable[M]) List(ctx context.Context, limit, offset uint64, order storage.SortOrder) ([]M, error)

List mocks base method.

func (*MockTable[M]) Save 

func (m_2 *MockTable[M]) Save(ctx context.Context, m M) error

Save mocks base method.

func (*MockTable[M]) Update 

func (m_2 *MockTable[M]) Update(ctx context.Context, m M) error

Update mocks base method.

type MockTableCursorListCall 

type MockTableCursorListCall[M storage.Model] struct {
	*gomock.Call
}

MockTableCursorListCall wrap *gomock.Call

func (*MockTableCursorListCall[M]) Do 

func (c *MockTableCursorListCall[M]) Do(f func(context.Context, uint64, uint64, storage.SortOrder, storage.Comparator) ([]M, error)) *MockTableCursorListCall[M]

Do rewrite *gomock.Call.Do

func (*MockTableCursorListCall[M]) DoAndReturn 

func (c *MockTableCursorListCall[M]) DoAndReturn(f func(context.Context, uint64, uint64, storage.SortOrder, storage.Comparator) ([]M, error)) *MockTableCursorListCall[M]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTableCursorListCall[M]) Return 

func (c *MockTableCursorListCall[M]) Return(arg0 []M, arg1 error) *MockTableCursorListCall[M]

Return rewrite *gomock.Call.Return

type MockTableGetByIDCall 

type MockTableGetByIDCall[M storage.Model] struct {
	*gomock.Call
}

MockTableGetByIDCall wrap *gomock.Call

func (*MockTableGetByIDCall[M]) Do 

func (c *MockTableGetByIDCall[M]) Do(f func(context.Context, uint64) (M, error)) *MockTableGetByIDCall[M]

Do rewrite *gomock.Call.Do

func (*MockTableGetByIDCall[M]) DoAndReturn 

func (c *MockTableGetByIDCall[M]) DoAndReturn(f func(context.Context, uint64) (M, error)) *MockTableGetByIDCall[M]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTableGetByIDCall[M]) Return 

func (c *MockTableGetByIDCall[M]) Return(arg0 M, arg1 error) *MockTableGetByIDCall[M]

Return rewrite *gomock.Call.Return

type MockTableIsNoRowsCall 

type MockTableIsNoRowsCall[M storage.Model] struct {
	*gomock.Call
}

MockTableIsNoRowsCall wrap *gomock.Call

func (*MockTableIsNoRowsCall[M]) Do 

func (c *MockTableIsNoRowsCall[M]) Do(f func(error) bool) *MockTableIsNoRowsCall[M]

Do rewrite *gomock.Call.Do

func (*MockTableIsNoRowsCall[M]) DoAndReturn 

func (c *MockTableIsNoRowsCall[M]) DoAndReturn(f func(error) bool) *MockTableIsNoRowsCall[M]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTableIsNoRowsCall[M]) Return 

func (c *MockTableIsNoRowsCall[M]) Return(arg0 bool) *MockTableIsNoRowsCall[M]

Return rewrite *gomock.Call.Return

type MockTableLastIDCall 

type MockTableLastIDCall[M storage.Model] struct {
	*gomock.Call
}

MockTableLastIDCall wrap *gomock.Call

func (*MockTableLastIDCall[M]) Do 

func (c *MockTableLastIDCall[M]) Do(f func(context.Context) (uint64, error)) *MockTableLastIDCall[M]

Do rewrite *gomock.Call.Do

func (*MockTableLastIDCall[M]) DoAndReturn 

func (c *MockTableLastIDCall[M]) DoAndReturn(f func(context.Context) (uint64, error)) *MockTableLastIDCall[M]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTableLastIDCall[M]) Return 

func (c *MockTableLastIDCall[M]) Return(arg0 uint64, arg1 error) *MockTableLastIDCall[M]

Return rewrite *gomock.Call.Return

type MockTableListCall 

type MockTableListCall[M storage.Model] struct {
	*gomock.Call
}

MockTableListCall wrap *gomock.Call

func (*MockTableListCall[M]) Do 

func (c *MockTableListCall[M]) Do(f func(context.Context, uint64, uint64, storage.SortOrder) ([]M, error)) *MockTableListCall[M]

Do rewrite *gomock.Call.Do

func (*MockTableListCall[M]) DoAndReturn 

func (c *MockTableListCall[M]) DoAndReturn(f func(context.Context, uint64, uint64, storage.SortOrder) ([]M, error)) *MockTableListCall[M]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTableListCall[M]) Return 

func (c *MockTableListCall[M]) Return(arg0 []M, arg1 error) *MockTableListCall[M]

Return rewrite *gomock.Call.Return

type MockTableMockRecorder 

type MockTableMockRecorder[M storage.Model] struct {
	// contains filtered or unexported fields
}

MockTableMockRecorder is the mock recorder for MockTable.

func (*MockTableMockRecorder[M]) CursorList 

func (mr *MockTableMockRecorder[M]) CursorList(ctx, id, limit, order, cmp any) *MockTableCursorListCall[M]

CursorList indicates an expected call of CursorList.

func (*MockTableMockRecorder[M]) GetByID 

func (mr *MockTableMockRecorder[M]) GetByID(ctx, id any) *MockTableGetByIDCall[M]

GetByID indicates an expected call of GetByID.

func (*MockTableMockRecorder[M]) IsNoRows 

func (mr *MockTableMockRecorder[M]) IsNoRows(err any) *MockTableIsNoRowsCall[M]

IsNoRows indicates an expected call of IsNoRows.

func (*MockTableMockRecorder[M]) LastID 

func (mr *MockTableMockRecorder[M]) LastID(ctx any) *MockTableLastIDCall[M]

LastID indicates an expected call of LastID.

func (*MockTableMockRecorder[M]) List 

func (mr *MockTableMockRecorder[M]) List(ctx, limit, offset, order any) *MockTableListCall[M]

List indicates an expected call of List.

func (*MockTableMockRecorder[M]) Save 

func (mr *MockTableMockRecorder[M]) Save(ctx, m any) *MockTableSaveCall[M]

Save indicates an expected call of Save.

func (*MockTableMockRecorder[M]) Update 

func (mr *MockTableMockRecorder[M]) Update(ctx, m any) *MockTableUpdateCall[M]

Update indicates an expected call of Update.

type MockTableSaveCall 

type MockTableSaveCall[M storage.Model] struct {
	*gomock.Call
}

MockTableSaveCall wrap *gomock.Call

func (*MockTableSaveCall[M]) Do 

func (c *MockTableSaveCall[M]) Do(f func(context.Context, M) error) *MockTableSaveCall[M]

Do rewrite *gomock.Call.Do

func (*MockTableSaveCall[M]) DoAndReturn 

func (c *MockTableSaveCall[M]) DoAndReturn(f func(context.Context, M) error) *MockTableSaveCall[M]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTableSaveCall[M]) Return 

func (c *MockTableSaveCall[M]) Return(arg0 error) *MockTableSaveCall[M]

Return rewrite *gomock.Call.Return

type MockTableUpdateCall 

type MockTableUpdateCall[M storage.Model] struct {
	*gomock.Call
}

MockTableUpdateCall wrap *gomock.Call

func (*MockTableUpdateCall[M]) Do 

func (c *MockTableUpdateCall[M]) Do(f func(context.Context, M) error) *MockTableUpdateCall[M]

Do rewrite *gomock.Call.Do

func (*MockTableUpdateCall[M]) DoAndReturn 

func (c *MockTableUpdateCall[M]) DoAndReturn(f func(context.Context, M) error) *MockTableUpdateCall[M]

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTableUpdateCall[M]) Return 

func (c *MockTableUpdateCall[M]) Return(arg0 error) *MockTableUpdateCall[M]

Return rewrite *gomock.Call.Return

type MockTransactable 

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

MockTransactable is a mock of Transactable interface.

func NewMockTransactable 

func NewMockTransactable(ctrl *gomock.Controller) *MockTransactable

NewMockTransactable creates a new mock instance.

func (*MockTransactable) BeginTransaction 

func (m *MockTransactable) BeginTransaction(ctx context.Context) (storage.Transaction, error)

BeginTransaction mocks base method.

func (*MockTransactable) EXPECT 

func (m *MockTransactable) EXPECT() *MockTransactableMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

type MockTransactableBeginTransactionCall 

type MockTransactableBeginTransactionCall struct {
	*gomock.Call
}

MockTransactableBeginTransactionCall wrap *gomock.Call

func (*MockTransactableBeginTransactionCall) Do 

func (c *MockTransactableBeginTransactionCall) Do(f func(context.Context) (storage.Transaction, error)) *MockTransactableBeginTransactionCall

Do rewrite *gomock.Call.Do

func (*MockTransactableBeginTransactionCall) DoAndReturn 

func (c *MockTransactableBeginTransactionCall) DoAndReturn(f func(context.Context) (storage.Transaction, error)) *MockTransactableBeginTransactionCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactableBeginTransactionCall) Return 

func (c *MockTransactableBeginTransactionCall) Return(arg0 storage.Transaction, arg1 error) *MockTransactableBeginTransactionCall

Return rewrite *gomock.Call.Return

type MockTransactableMockRecorder 

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

MockTransactableMockRecorder is the mock recorder for MockTransactable.

func (*MockTransactableMockRecorder) BeginTransaction 

func (mr *MockTransactableMockRecorder) BeginTransaction(ctx any) *MockTransactableBeginTransactionCall

BeginTransaction indicates an expected call of BeginTransaction.

type MockTransaction 

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

MockTransaction is a mock of Transaction interface.

func NewMockTransaction 

func NewMockTransaction(ctrl *gomock.Controller) *MockTransaction

NewMockTransaction creates a new mock instance.

func (*MockTransaction) Add 

func (m *MockTransaction) Add(ctx context.Context, model any) error

Add mocks base method.

func (*MockTransaction) BulkSave 

func (m *MockTransaction) BulkSave(ctx context.Context, models []any) error

BulkSave mocks base method.

func (*MockTransaction) Close 

func (m *MockTransaction) Close(ctx context.Context) error

Close mocks base method.

func (*MockTransaction) CopyFrom 

func (m *MockTransaction) CopyFrom(ctx context.Context, tableName string, data []storage.Copiable) error

CopyFrom mocks base method.

func (*MockTransaction) EXPECT 

func (m *MockTransaction) EXPECT() *MockTransactionMockRecorder

EXPECT returns an object that allows the caller to indicate expected use.

func (*MockTransaction) Exec 

func (m *MockTransaction) Exec(ctx context.Context, query string, params ...any) (int64, error)

Exec mocks base method.

func (*MockTransaction) Flush 

func (m *MockTransaction) Flush(ctx context.Context) error

Flush mocks base method.

func (*MockTransaction) HandleError 

func (m *MockTransaction) HandleError(ctx context.Context, err error) error

HandleError mocks base method.

func (*MockTransaction) Rollback 

func (m *MockTransaction) Rollback(ctx context.Context) error

Rollback mocks base method.

func (*MockTransaction) Tx 

func (m *MockTransaction) Tx() *bun.Tx

Tx mocks base method.

func (*MockTransaction) Update 

func (m *MockTransaction) Update(ctx context.Context, model any) error

Update mocks base method.

type MockTransactionAddCall 

type MockTransactionAddCall struct {
	*gomock.Call
}

MockTransactionAddCall wrap *gomock.Call

func (*MockTransactionAddCall) Do 

func (c *MockTransactionAddCall) Do(f func(context.Context, any) error) *MockTransactionAddCall

Do rewrite *gomock.Call.Do

func (*MockTransactionAddCall) DoAndReturn 

func (c *MockTransactionAddCall) DoAndReturn(f func(context.Context, any) error) *MockTransactionAddCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactionAddCall) Return 

func (c *MockTransactionAddCall) Return(arg0 error) *MockTransactionAddCall

Return rewrite *gomock.Call.Return

type MockTransactionBulkSaveCall 

type MockTransactionBulkSaveCall struct {
	*gomock.Call
}

MockTransactionBulkSaveCall wrap *gomock.Call

func (*MockTransactionBulkSaveCall) Do 

func (c *MockTransactionBulkSaveCall) Do(f func(context.Context, []any) error) *MockTransactionBulkSaveCall

Do rewrite *gomock.Call.Do

func (*MockTransactionBulkSaveCall) DoAndReturn 

func (c *MockTransactionBulkSaveCall) DoAndReturn(f func(context.Context, []any) error) *MockTransactionBulkSaveCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactionBulkSaveCall) Return 

func (c *MockTransactionBulkSaveCall) Return(arg0 error) *MockTransactionBulkSaveCall

Return rewrite *gomock.Call.Return

type MockTransactionCloseCall 

type MockTransactionCloseCall struct {
	*gomock.Call
}

MockTransactionCloseCall wrap *gomock.Call

func (*MockTransactionCloseCall) Do 

func (c *MockTransactionCloseCall) Do(f func(context.Context) error) *MockTransactionCloseCall

Do rewrite *gomock.Call.Do

func (*MockTransactionCloseCall) DoAndReturn 

func (c *MockTransactionCloseCall) DoAndReturn(f func(context.Context) error) *MockTransactionCloseCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactionCloseCall) Return 

func (c *MockTransactionCloseCall) Return(arg0 error) *MockTransactionCloseCall

Return rewrite *gomock.Call.Return

type MockTransactionCopyFromCall 

type MockTransactionCopyFromCall struct {
	*gomock.Call
}

MockTransactionCopyFromCall wrap *gomock.Call

func (*MockTransactionCopyFromCall) Do 

func (c *MockTransactionCopyFromCall) Do(f func(context.Context, string, []storage.Copiable) error) *MockTransactionCopyFromCall

Do rewrite *gomock.Call.Do

func (*MockTransactionCopyFromCall) DoAndReturn 

func (c *MockTransactionCopyFromCall) DoAndReturn(f func(context.Context, string, []storage.Copiable) error) *MockTransactionCopyFromCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactionCopyFromCall) Return 

func (c *MockTransactionCopyFromCall) Return(arg0 error) *MockTransactionCopyFromCall

Return rewrite *gomock.Call.Return

type MockTransactionExecCall 

type MockTransactionExecCall struct {
	*gomock.Call
}

MockTransactionExecCall wrap *gomock.Call

func (*MockTransactionExecCall) Do 

func (c *MockTransactionExecCall) Do(f func(context.Context, string, ...any) (int64, error)) *MockTransactionExecCall

Do rewrite *gomock.Call.Do

func (*MockTransactionExecCall) DoAndReturn 

func (c *MockTransactionExecCall) DoAndReturn(f func(context.Context, string, ...any) (int64, error)) *MockTransactionExecCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactionExecCall) Return 

func (c *MockTransactionExecCall) Return(arg0 int64, arg1 error) *MockTransactionExecCall

Return rewrite *gomock.Call.Return

type MockTransactionFlushCall 

type MockTransactionFlushCall struct {
	*gomock.Call
}

MockTransactionFlushCall wrap *gomock.Call

func (*MockTransactionFlushCall) Do 

func (c *MockTransactionFlushCall) Do(f func(context.Context) error) *MockTransactionFlushCall

Do rewrite *gomock.Call.Do

func (*MockTransactionFlushCall) DoAndReturn 

func (c *MockTransactionFlushCall) DoAndReturn(f func(context.Context) error) *MockTransactionFlushCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactionFlushCall) Return 

func (c *MockTransactionFlushCall) Return(arg0 error) *MockTransactionFlushCall

Return rewrite *gomock.Call.Return

type MockTransactionHandleErrorCall 

type MockTransactionHandleErrorCall struct {
	*gomock.Call
}

MockTransactionHandleErrorCall wrap *gomock.Call

func (*MockTransactionHandleErrorCall) Do 

func (c *MockTransactionHandleErrorCall) Do(f func(context.Context, error) error) *MockTransactionHandleErrorCall

Do rewrite *gomock.Call.Do

func (*MockTransactionHandleErrorCall) DoAndReturn 

func (c *MockTransactionHandleErrorCall) DoAndReturn(f func(context.Context, error) error) *MockTransactionHandleErrorCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactionHandleErrorCall) Return 

func (c *MockTransactionHandleErrorCall) Return(arg0 error) *MockTransactionHandleErrorCall

Return rewrite *gomock.Call.Return

type MockTransactionMockRecorder 

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

MockTransactionMockRecorder is the mock recorder for MockTransaction.

func (*MockTransactionMockRecorder) Add 

func (mr *MockTransactionMockRecorder) Add(ctx, model any) *MockTransactionAddCall

Add indicates an expected call of Add.

func (*MockTransactionMockRecorder) BulkSave 

func (mr *MockTransactionMockRecorder) BulkSave(ctx, models any) *MockTransactionBulkSaveCall

BulkSave indicates an expected call of BulkSave.

func (*MockTransactionMockRecorder) Close 

func (mr *MockTransactionMockRecorder) Close(ctx any) *MockTransactionCloseCall

Close indicates an expected call of Close.

func (*MockTransactionMockRecorder) CopyFrom 

func (mr *MockTransactionMockRecorder) CopyFrom(ctx, tableName, data any) *MockTransactionCopyFromCall

CopyFrom indicates an expected call of CopyFrom.

func (*MockTransactionMockRecorder) Exec 

func (mr *MockTransactionMockRecorder) Exec(ctx, query any, params ...any) *MockTransactionExecCall

Exec indicates an expected call of Exec.

func (*MockTransactionMockRecorder) Flush 

func (mr *MockTransactionMockRecorder) Flush(ctx any) *MockTransactionFlushCall

Flush indicates an expected call of Flush.

func (*MockTransactionMockRecorder) HandleError 

func (mr *MockTransactionMockRecorder) HandleError(ctx, err any) *MockTransactionHandleErrorCall

HandleError indicates an expected call of HandleError.

func (*MockTransactionMockRecorder) Rollback 

func (mr *MockTransactionMockRecorder) Rollback(ctx any) *MockTransactionRollbackCall

Rollback indicates an expected call of Rollback.

func (*MockTransactionMockRecorder) Tx 

func (mr *MockTransactionMockRecorder) Tx() *MockTransactionTxCall

Tx indicates an expected call of Tx.

func (*MockTransactionMockRecorder) Update 

func (mr *MockTransactionMockRecorder) Update(ctx, model any) *MockTransactionUpdateCall

Update indicates an expected call of Update.

type MockTransactionRollbackCall 

type MockTransactionRollbackCall struct {
	*gomock.Call
}

MockTransactionRollbackCall wrap *gomock.Call

func (*MockTransactionRollbackCall) Do 

func (c *MockTransactionRollbackCall) Do(f func(context.Context) error) *MockTransactionRollbackCall

Do rewrite *gomock.Call.Do

func (*MockTransactionRollbackCall) DoAndReturn 

func (c *MockTransactionRollbackCall) DoAndReturn(f func(context.Context) error) *MockTransactionRollbackCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactionRollbackCall) Return 

func (c *MockTransactionRollbackCall) Return(arg0 error) *MockTransactionRollbackCall

Return rewrite *gomock.Call.Return

type MockTransactionTxCall 

type MockTransactionTxCall struct {
	*gomock.Call
}

MockTransactionTxCall wrap *gomock.Call

func (*MockTransactionTxCall) Do 

func (c *MockTransactionTxCall) Do(f func() *bun.Tx) *MockTransactionTxCall

Do rewrite *gomock.Call.Do

func (*MockTransactionTxCall) DoAndReturn 

func (c *MockTransactionTxCall) DoAndReturn(f func() *bun.Tx) *MockTransactionTxCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactionTxCall) Return 

func (c *MockTransactionTxCall) Return(arg0 *bun.Tx) *MockTransactionTxCall

Return rewrite *gomock.Call.Return

type MockTransactionUpdateCall 

type MockTransactionUpdateCall struct {
	*gomock.Call
}

MockTransactionUpdateCall wrap *gomock.Call

func (*MockTransactionUpdateCall) Do 

func (c *MockTransactionUpdateCall) Do(f func(context.Context, any) error) *MockTransactionUpdateCall

Do rewrite *gomock.Call.Do

func (*MockTransactionUpdateCall) DoAndReturn 

func (c *MockTransactionUpdateCall) DoAndReturn(f func(context.Context, any) error) *MockTransactionUpdateCall

DoAndReturn rewrite *gomock.Call.DoAndReturn

func (*MockTransactionUpdateCall) Return 

func (c *MockTransactionUpdateCall) Return(arg0 error) *MockTransactionUpdateCall

Return rewrite *gomock.Call.Return

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.