mocks

package
v0.0.0-...-dc7611c Latest Latest
Warning

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

 Go to latest Published: Apr 6, 2024 License: MIT Imports: 12 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AggregateStateProjection 

type AggregateStateProjection struct {
	mock.Mock
}

AggregateStateProjection is an autogenerated mock type for the AggregateStateProjection type

func NewAggregateStateProjection 

func NewAggregateStateProjection(t interface {
	mock.TestingT
	Cleanup(func())
}) *AggregateStateProjection

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

func (*AggregateStateProjection) Apply 

func (_m *AggregateStateProjection) Apply(event domain.IDomainEvent, isNew bool) error

Apply provides a mock function with given fields: event, isNew

func (*AggregateStateProjection) EXPECT 

func (_m *AggregateStateProjection) EXPECT() *AggregateStateProjection_Expecter

type AggregateStateProjection_Apply_Call 

type AggregateStateProjection_Apply_Call struct {
	*mock.Call
}

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

func (*AggregateStateProjection_Apply_Call) Return 

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

func (*AggregateStateProjection_Apply_Call) Run 

func (_c *AggregateStateProjection_Apply_Call) Run(run func(event domain.IDomainEvent, isNew bool)) *AggregateStateProjection_Apply_Call

func (*AggregateStateProjection_Apply_Call) RunAndReturn 

func (_c *AggregateStateProjection_Apply_Call) RunAndReturn(run func(domain.IDomainEvent, bool) error) *AggregateStateProjection_Apply_Call

type AggregateStateProjection_Expecter 

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

func (*AggregateStateProjection_Expecter) Apply 

func (_e *AggregateStateProjection_Expecter) Apply(event interface{}, isNew interface{}) *AggregateStateProjection_Apply_Call

Apply is a helper method to define mock.On call

  • event domain.IDomainEvent
  • isNew bool

type AggregateStateProjection_fold_Call 

type AggregateStateProjection_fold_Call struct {
	*mock.Call
}

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

func (*AggregateStateProjection_fold_Call) Return 

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

func (*AggregateStateProjection_fold_Call) Run 

func (_c *AggregateStateProjection_fold_Call) Run(run func(event domain.IDomainEvent, _a1 metadata.Metadata)) *AggregateStateProjection_fold_Call

func (*AggregateStateProjection_fold_Call) RunAndReturn 

func (_c *AggregateStateProjection_fold_Call) RunAndReturn(run func(domain.IDomainEvent, metadata.Metadata) error) *AggregateStateProjection_fold_Call

type AggregateStore 

type AggregateStore[T models.IHaveEventSourcedAggregate] struct {
	mock.Mock
}

AggregateStore is an autogenerated mock type for the AggregateStore type

func NewAggregateStore 

func NewAggregateStore[T models.IHaveEventSourcedAggregate](t interface {
	mock.TestingT
	Cleanup(func())
}) *AggregateStore[T]

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

func (*AggregateStore[T]) EXPECT 

func (_m *AggregateStore[T]) EXPECT() *AggregateStore_Expecter[T]

func (*AggregateStore[T]) Exists 

func (_m *AggregateStore[T]) Exists(ctx context.Context, aggregateId uuid.UUID) (bool, error)

Exists provides a mock function with given fields: ctx, aggregateId

func (*AggregateStore[T]) Load 

func (_m *AggregateStore[T]) Load(ctx context.Context, aggregateId uuid.UUID) (T, error)

Load provides a mock function with given fields: ctx, aggregateId

func (*AggregateStore[T]) LoadWithReadPosition 

func (_m *AggregateStore[T]) LoadWithReadPosition(ctx context.Context, aggregateId uuid.UUID, position readPosition.StreamReadPosition) (T, error)

LoadWithReadPosition provides a mock function with given fields: ctx, aggregateId, position

func (*AggregateStore[T]) Store 

func (_m *AggregateStore[T]) Store(aggregate T, _a1 metadata.Metadata, ctx context.Context) (*appendResult.AppendEventsResult, error)

Store provides a mock function with given fields: aggregate, _a1, ctx

func (*AggregateStore[T]) StoreWithVersion 

func (_m *AggregateStore[T]) StoreWithVersion(aggregate T, _a1 metadata.Metadata, expectedVersion expectedStreamVersion.ExpectedStreamVersion, ctx context.Context) (*appendResult.AppendEventsResult, error)

StoreWithVersion provides a mock function with given fields: aggregate, _a1, expectedVersion, ctx

type AggregateStore_Exists_Call 

type AggregateStore_Exists_Call[T models.IHaveEventSourcedAggregate] struct {
	*mock.Call
}

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

func (*AggregateStore_Exists_Call[T]) Return 

func (_c *AggregateStore_Exists_Call[T]) Return(_a0 bool, _a1 error) *AggregateStore_Exists_Call[T]

func (*AggregateStore_Exists_Call[T]) Run 

func (_c *AggregateStore_Exists_Call[T]) Run(run func(ctx context.Context, aggregateId uuid.UUID)) *AggregateStore_Exists_Call[T]

func (*AggregateStore_Exists_Call[T]) RunAndReturn 

func (_c *AggregateStore_Exists_Call[T]) RunAndReturn(run func(context.Context, uuid.UUID) (bool, error)) *AggregateStore_Exists_Call[T]

type AggregateStore_Expecter 

type AggregateStore_Expecter[T models.IHaveEventSourcedAggregate] struct {
	// contains filtered or unexported fields
}

func (*AggregateStore_Expecter[T]) Exists 

func (_e *AggregateStore_Expecter[T]) Exists(ctx interface{}, aggregateId interface{}) *AggregateStore_Exists_Call[T]

Exists is a helper method to define mock.On call

  • ctx context.Context
  • aggregateId uuid.UUID

func (*AggregateStore_Expecter[T]) Load 

func (_e *AggregateStore_Expecter[T]) Load(ctx interface{}, aggregateId interface{}) *AggregateStore_Load_Call[T]

Load is a helper method to define mock.On call

  • ctx context.Context
  • aggregateId uuid.UUID

func (*AggregateStore_Expecter[T]) LoadWithReadPosition 

func (_e *AggregateStore_Expecter[T]) LoadWithReadPosition(ctx interface{}, aggregateId interface{}, position interface{}) *AggregateStore_LoadWithReadPosition_Call[T]

LoadWithReadPosition is a helper method to define mock.On call

  • ctx context.Context
  • aggregateId uuid.UUID
  • position readPosition.StreamReadPosition

func (*AggregateStore_Expecter[T]) Store 

func (_e *AggregateStore_Expecter[T]) Store(aggregate interface{}, _a1 interface{}, ctx interface{}) *AggregateStore_Store_Call[T]

Store is a helper method to define mock.On call

  • aggregate T
  • _a1 metadata.Metadata
  • ctx context.Context

func (*AggregateStore_Expecter[T]) StoreWithVersion 

func (_e *AggregateStore_Expecter[T]) StoreWithVersion(aggregate interface{}, _a1 interface{}, expectedVersion interface{}, ctx interface{}) *AggregateStore_StoreWithVersion_Call[T]

StoreWithVersion is a helper method to define mock.On call

  • aggregate T
  • _a1 metadata.Metadata
  • expectedVersion expectedStreamVersion.ExpectedStreamVersion
  • ctx context.Context

type AggregateStore_LoadWithReadPosition_Call 

type AggregateStore_LoadWithReadPosition_Call[T models.IHaveEventSourcedAggregate] struct {
	*mock.Call
}

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

func (*AggregateStore_LoadWithReadPosition_Call[T]) Return 

func (_c *AggregateStore_LoadWithReadPosition_Call[T]) Return(_a0 T, _a1 error) *AggregateStore_LoadWithReadPosition_Call[T]

func (*AggregateStore_LoadWithReadPosition_Call[T]) Run 

func (_c *AggregateStore_LoadWithReadPosition_Call[T]) Run(run func(ctx context.Context, aggregateId uuid.UUID, position readPosition.StreamReadPosition)) *AggregateStore_LoadWithReadPosition_Call[T]

func (*AggregateStore_LoadWithReadPosition_Call[T]) RunAndReturn 

func (_c *AggregateStore_LoadWithReadPosition_Call[T]) RunAndReturn(run func(context.Context, uuid.UUID, readPosition.StreamReadPosition) (T, error)) *AggregateStore_LoadWithReadPosition_Call[T]

type AggregateStore_Load_Call 

type AggregateStore_Load_Call[T models.IHaveEventSourcedAggregate] struct {
	*mock.Call
}

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

func (*AggregateStore_Load_Call[T]) Return 

func (_c *AggregateStore_Load_Call[T]) Return(_a0 T, _a1 error) *AggregateStore_Load_Call[T]

func (*AggregateStore_Load_Call[T]) Run 

func (_c *AggregateStore_Load_Call[T]) Run(run func(ctx context.Context, aggregateId uuid.UUID)) *AggregateStore_Load_Call[T]

func (*AggregateStore_Load_Call[T]) RunAndReturn 

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

type AggregateStore_StoreWithVersion_Call 

type AggregateStore_StoreWithVersion_Call[T models.IHaveEventSourcedAggregate] struct {
	*mock.Call
}

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

func (*AggregateStore_StoreWithVersion_Call[T]) Return 

func (_c *AggregateStore_StoreWithVersion_Call[T]) Return(_a0 *appendResult.AppendEventsResult, _a1 error) *AggregateStore_StoreWithVersion_Call[T]

func (*AggregateStore_StoreWithVersion_Call[T]) Run 

func (_c *AggregateStore_StoreWithVersion_Call[T]) Run(run func(aggregate T, _a1 metadata.Metadata, expectedVersion expectedStreamVersion.ExpectedStreamVersion, ctx context.Context)) *AggregateStore_StoreWithVersion_Call[T]

func (*AggregateStore_StoreWithVersion_Call[T]) RunAndReturn 

func (_c *AggregateStore_StoreWithVersion_Call[T]) RunAndReturn(run func(T, metadata.Metadata, expectedStreamVersion.ExpectedStreamVersion, context.Context) (*appendResult.AppendEventsResult, error)) *AggregateStore_StoreWithVersion_Call[T]

type AggregateStore_Store_Call 

type AggregateStore_Store_Call[T models.IHaveEventSourcedAggregate] struct {
	*mock.Call
}

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

func (*AggregateStore_Store_Call[T]) Return 

func (_c *AggregateStore_Store_Call[T]) Return(_a0 *appendResult.AppendEventsResult, _a1 error) *AggregateStore_Store_Call[T]

func (*AggregateStore_Store_Call[T]) Run 

func (_c *AggregateStore_Store_Call[T]) Run(run func(aggregate T, _a1 metadata.Metadata, ctx context.Context)) *AggregateStore_Store_Call[T]

func (*AggregateStore_Store_Call[T]) RunAndReturn 

func (_c *AggregateStore_Store_Call[T]) RunAndReturn(run func(T, metadata.Metadata, context.Context) (*appendResult.AppendEventsResult, error)) *AggregateStore_Store_Call[T]

type Apply 

type Apply struct {
	mock.Mock
}

Apply is an autogenerated mock type for the Apply type

func NewApply 

func NewApply(t interface {
	mock.TestingT
	Cleanup(func())
}) *Apply

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

func (*Apply) Apply 

func (_m *Apply) Apply(event domain.IDomainEvent, isNew bool) error

Apply provides a mock function with given fields: event, isNew

func (*Apply) EXPECT 

func (_m *Apply) EXPECT() *Apply_Expecter

type Apply_Apply_Call 

type Apply_Apply_Call struct {
	*mock.Call
}

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

func (*Apply_Apply_Call) Return 

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

func (*Apply_Apply_Call) Run 

func (_c *Apply_Apply_Call) Run(run func(event domain.IDomainEvent, isNew bool)) *Apply_Apply_Call

func (*Apply_Apply_Call) RunAndReturn 

func (_c *Apply_Apply_Call) RunAndReturn(run func(domain.IDomainEvent, bool) error) *Apply_Apply_Call

type Apply_Expecter 

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

func (*Apply_Expecter) Apply 

func (_e *Apply_Expecter) Apply(event interface{}, isNew interface{}) *Apply_Apply_Call

Apply is a helper method to define mock.On call

  • event domain.IDomainEvent
  • isNew bool

type EventStore 

type EventStore struct {
	mock.Mock
}

EventStore is an autogenerated mock type for the EventStore type

func NewEventStore 

func NewEventStore(t interface {
	mock.TestingT
	Cleanup(func())
}) *EventStore

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

func (*EventStore) AppendEvents 

func (_m *EventStore) AppendEvents(_a0 streamName.StreamName, expectedVersion expectedStreamVersion.ExpectedStreamVersion, events []*models.StreamEvent, ctx context.Context) (*appendResult.AppendEventsResult, error)

AppendEvents provides a mock function with given fields: _a0, expectedVersion, events, ctx

func (*EventStore) AppendNewEvents 

func (_m *EventStore) AppendNewEvents(_a0 streamName.StreamName, events []*models.StreamEvent, ctx context.Context) (*appendResult.AppendEventsResult, error)

AppendNewEvents provides a mock function with given fields: _a0, events, ctx

func (*EventStore) DeleteStream 

func (_m *EventStore) DeleteStream(_a0 streamName.StreamName, expectedVersion expectedStreamVersion.ExpectedStreamVersion, ctx context.Context) error

DeleteStream provides a mock function with given fields: _a0, expectedVersion, ctx

func (*EventStore) EXPECT 

func (_m *EventStore) EXPECT() *EventStore_Expecter

func (*EventStore) ReadEvents 

func (_m *EventStore) ReadEvents(_a0 streamName.StreamName, _a1 readPosition.StreamReadPosition, count uint64, ctx context.Context) ([]*models.StreamEvent, error)

ReadEvents provides a mock function with given fields: _a0, _a1, count, ctx

func (*EventStore) ReadEventsBackwards 

func (_m *EventStore) ReadEventsBackwards(_a0 streamName.StreamName, _a1 readPosition.StreamReadPosition, count uint64, ctx context.Context) ([]*models.StreamEvent, error)

ReadEventsBackwards provides a mock function with given fields: _a0, _a1, count, ctx

func (*EventStore) ReadEventsBackwardsFromEnd 

func (_m *EventStore) ReadEventsBackwardsFromEnd(_a0 streamName.StreamName, count uint64, ctx context.Context) ([]*models.StreamEvent, error)

ReadEventsBackwardsFromEnd provides a mock function with given fields: _a0, count, ctx

func (*EventStore) ReadEventsBackwardsWithMaxCount 

func (_m *EventStore) ReadEventsBackwardsWithMaxCount(stream streamName.StreamName, _a1 readPosition.StreamReadPosition, ctx context.Context) ([]*models.StreamEvent, error)

ReadEventsBackwardsWithMaxCount provides a mock function with given fields: stream, _a1, ctx

func (*EventStore) ReadEventsFromStart 

func (_m *EventStore) ReadEventsFromStart(_a0 streamName.StreamName, count uint64, ctx context.Context) ([]*models.StreamEvent, error)

ReadEventsFromStart provides a mock function with given fields: _a0, count, ctx

func (*EventStore) ReadEventsWithMaxCount 

func (_m *EventStore) ReadEventsWithMaxCount(_a0 streamName.StreamName, _a1 readPosition.StreamReadPosition, ctx context.Context) ([]*models.StreamEvent, error)

ReadEventsWithMaxCount provides a mock function with given fields: _a0, _a1, ctx

func (*EventStore) StreamExists 

func (_m *EventStore) StreamExists(_a0 streamName.StreamName, ctx context.Context) (bool, error)

StreamExists provides a mock function with given fields: _a0, ctx

func (*EventStore) TruncateStream 

func (_m *EventStore) TruncateStream(_a0 streamName.StreamName, _a1 truncatePosition.StreamTruncatePosition, expectedVersion expectedStreamVersion.ExpectedStreamVersion, ctx context.Context) (*appendResult.AppendEventsResult, error)

TruncateStream provides a mock function with given fields: _a0, _a1, expectedVersion, ctx

type EventStore_AppendEvents_Call 

type EventStore_AppendEvents_Call struct {
	*mock.Call
}

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

func (*EventStore_AppendEvents_Call) Return 

func (_c *EventStore_AppendEvents_Call) Return(_a0 *appendResult.AppendEventsResult, _a1 error) *EventStore_AppendEvents_Call

func (*EventStore_AppendEvents_Call) Run 

func (_c *EventStore_AppendEvents_Call) Run(run func(_a0 streamName.StreamName, expectedVersion expectedStreamVersion.ExpectedStreamVersion, events []*models.StreamEvent, ctx context.Context)) *EventStore_AppendEvents_Call

func (*EventStore_AppendEvents_Call) RunAndReturn 

func (_c *EventStore_AppendEvents_Call) RunAndReturn(run func(streamName.StreamName, expectedStreamVersion.ExpectedStreamVersion, []*models.StreamEvent, context.Context) (*appendResult.AppendEventsResult, error)) *EventStore_AppendEvents_Call

type EventStore_AppendNewEvents_Call 

type EventStore_AppendNewEvents_Call struct {
	*mock.Call
}

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

func (*EventStore_AppendNewEvents_Call) Return 

func (_c *EventStore_AppendNewEvents_Call) Return(_a0 *appendResult.AppendEventsResult, _a1 error) *EventStore_AppendNewEvents_Call

func (*EventStore_AppendNewEvents_Call) Run 

func (_c *EventStore_AppendNewEvents_Call) Run(run func(_a0 streamName.StreamName, events []*models.StreamEvent, ctx context.Context)) *EventStore_AppendNewEvents_Call

func (*EventStore_AppendNewEvents_Call) RunAndReturn 

func (_c *EventStore_AppendNewEvents_Call) RunAndReturn(run func(streamName.StreamName, []*models.StreamEvent, context.Context) (*appendResult.AppendEventsResult, error)) *EventStore_AppendNewEvents_Call

type EventStore_DeleteStream_Call 

type EventStore_DeleteStream_Call struct {
	*mock.Call
}

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

func (*EventStore_DeleteStream_Call) Return 

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

func (*EventStore_DeleteStream_Call) Run 

func (_c *EventStore_DeleteStream_Call) Run(run func(_a0 streamName.StreamName, expectedVersion expectedStreamVersion.ExpectedStreamVersion, ctx context.Context)) *EventStore_DeleteStream_Call

func (*EventStore_DeleteStream_Call) RunAndReturn 

func (_c *EventStore_DeleteStream_Call) RunAndReturn(run func(streamName.StreamName, expectedStreamVersion.ExpectedStreamVersion, context.Context) error) *EventStore_DeleteStream_Call

type EventStore_Expecter 

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

func (*EventStore_Expecter) AppendEvents 

func (_e *EventStore_Expecter) AppendEvents(_a0 interface{}, expectedVersion interface{}, events interface{}, ctx interface{}) *EventStore_AppendEvents_Call

AppendEvents is a helper method to define mock.On call

  • _a0 streamName.StreamName
  • expectedVersion expectedStreamVersion.ExpectedStreamVersion
  • events []*models.StreamEvent
  • ctx context.Context

func (*EventStore_Expecter) AppendNewEvents 

func (_e *EventStore_Expecter) AppendNewEvents(_a0 interface{}, events interface{}, ctx interface{}) *EventStore_AppendNewEvents_Call

AppendNewEvents is a helper method to define mock.On call

  • _a0 streamName.StreamName
  • events []*models.StreamEvent
  • ctx context.Context

func (*EventStore_Expecter) DeleteStream 

func (_e *EventStore_Expecter) DeleteStream(_a0 interface{}, expectedVersion interface{}, ctx interface{}) *EventStore_DeleteStream_Call

DeleteStream is a helper method to define mock.On call

  • _a0 streamName.StreamName
  • expectedVersion expectedStreamVersion.ExpectedStreamVersion
  • ctx context.Context

func (*EventStore_Expecter) ReadEvents 

func (_e *EventStore_Expecter) ReadEvents(_a0 interface{}, _a1 interface{}, count interface{}, ctx interface{}) *EventStore_ReadEvents_Call

ReadEvents is a helper method to define mock.On call

  • _a0 streamName.StreamName
  • _a1 readPosition.StreamReadPosition
  • count uint64
  • ctx context.Context

func (*EventStore_Expecter) ReadEventsBackwards 

func (_e *EventStore_Expecter) ReadEventsBackwards(_a0 interface{}, _a1 interface{}, count interface{}, ctx interface{}) *EventStore_ReadEventsBackwards_Call

ReadEventsBackwards is a helper method to define mock.On call

  • _a0 streamName.StreamName
  • _a1 readPosition.StreamReadPosition
  • count uint64
  • ctx context.Context

func (*EventStore_Expecter) ReadEventsBackwardsFromEnd 

func (_e *EventStore_Expecter) ReadEventsBackwardsFromEnd(_a0 interface{}, count interface{}, ctx interface{}) *EventStore_ReadEventsBackwardsFromEnd_Call

ReadEventsBackwardsFromEnd is a helper method to define mock.On call

  • _a0 streamName.StreamName
  • count uint64
  • ctx context.Context

func (*EventStore_Expecter) ReadEventsBackwardsWithMaxCount 

func (_e *EventStore_Expecter) ReadEventsBackwardsWithMaxCount(stream interface{}, _a1 interface{}, ctx interface{}) *EventStore_ReadEventsBackwardsWithMaxCount_Call

ReadEventsBackwardsWithMaxCount is a helper method to define mock.On call

  • stream streamName.StreamName
  • _a1 readPosition.StreamReadPosition
  • ctx context.Context

func (*EventStore_Expecter) ReadEventsFromStart 

func (_e *EventStore_Expecter) ReadEventsFromStart(_a0 interface{}, count interface{}, ctx interface{}) *EventStore_ReadEventsFromStart_Call

ReadEventsFromStart is a helper method to define mock.On call

  • _a0 streamName.StreamName
  • count uint64
  • ctx context.Context

func (*EventStore_Expecter) ReadEventsWithMaxCount 

func (_e *EventStore_Expecter) ReadEventsWithMaxCount(_a0 interface{}, _a1 interface{}, ctx interface{}) *EventStore_ReadEventsWithMaxCount_Call

ReadEventsWithMaxCount is a helper method to define mock.On call

  • _a0 streamName.StreamName
  • _a1 readPosition.StreamReadPosition
  • ctx context.Context

func (*EventStore_Expecter) StreamExists 

func (_e *EventStore_Expecter) StreamExists(_a0 interface{}, ctx interface{}) *EventStore_StreamExists_Call

StreamExists is a helper method to define mock.On call

  • _a0 streamName.StreamName
  • ctx context.Context

func (*EventStore_Expecter) TruncateStream 

func (_e *EventStore_Expecter) TruncateStream(_a0 interface{}, _a1 interface{}, expectedVersion interface{}, ctx interface{}) *EventStore_TruncateStream_Call

TruncateStream is a helper method to define mock.On call

  • _a0 streamName.StreamName
  • _a1 truncatePosition.StreamTruncatePosition
  • expectedVersion expectedStreamVersion.ExpectedStreamVersion
  • ctx context.Context

type EventStore_ReadEventsBackwardsFromEnd_Call 

type EventStore_ReadEventsBackwardsFromEnd_Call struct {
	*mock.Call
}

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

func (*EventStore_ReadEventsBackwardsFromEnd_Call) Return 

func (_c *EventStore_ReadEventsBackwardsFromEnd_Call) Return(_a0 []*models.StreamEvent, _a1 error) *EventStore_ReadEventsBackwardsFromEnd_Call

func (*EventStore_ReadEventsBackwardsFromEnd_Call) Run 

func (_c *EventStore_ReadEventsBackwardsFromEnd_Call) Run(run func(_a0 streamName.StreamName, count uint64, ctx context.Context)) *EventStore_ReadEventsBackwardsFromEnd_Call

func (*EventStore_ReadEventsBackwardsFromEnd_Call) RunAndReturn 

func (_c *EventStore_ReadEventsBackwardsFromEnd_Call) RunAndReturn(run func(streamName.StreamName, uint64, context.Context) ([]*models.StreamEvent, error)) *EventStore_ReadEventsBackwardsFromEnd_Call

type EventStore_ReadEventsBackwardsWithMaxCount_Call 

type EventStore_ReadEventsBackwardsWithMaxCount_Call struct {
	*mock.Call
}

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

func (*EventStore_ReadEventsBackwardsWithMaxCount_Call) Return 

func (_c *EventStore_ReadEventsBackwardsWithMaxCount_Call) Return(_a0 []*models.StreamEvent, _a1 error) *EventStore_ReadEventsBackwardsWithMaxCount_Call

func (*EventStore_ReadEventsBackwardsWithMaxCount_Call) Run 

func (_c *EventStore_ReadEventsBackwardsWithMaxCount_Call) Run(run func(stream streamName.StreamName, _a1 readPosition.StreamReadPosition, ctx context.Context)) *EventStore_ReadEventsBackwardsWithMaxCount_Call

func (*EventStore_ReadEventsBackwardsWithMaxCount_Call) RunAndReturn 

func (_c *EventStore_ReadEventsBackwardsWithMaxCount_Call) RunAndReturn(run func(streamName.StreamName, readPosition.StreamReadPosition, context.Context) ([]*models.StreamEvent, error)) *EventStore_ReadEventsBackwardsWithMaxCount_Call

type EventStore_ReadEventsBackwards_Call 

type EventStore_ReadEventsBackwards_Call struct {
	*mock.Call
}

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

func (*EventStore_ReadEventsBackwards_Call) Return 

func (_c *EventStore_ReadEventsBackwards_Call) Return(_a0 []*models.StreamEvent, _a1 error) *EventStore_ReadEventsBackwards_Call

func (*EventStore_ReadEventsBackwards_Call) Run 

func (_c *EventStore_ReadEventsBackwards_Call) Run(run func(_a0 streamName.StreamName, _a1 readPosition.StreamReadPosition, count uint64, ctx context.Context)) *EventStore_ReadEventsBackwards_Call

func (*EventStore_ReadEventsBackwards_Call) RunAndReturn 

func (_c *EventStore_ReadEventsBackwards_Call) RunAndReturn(run func(streamName.StreamName, readPosition.StreamReadPosition, uint64, context.Context) ([]*models.StreamEvent, error)) *EventStore_ReadEventsBackwards_Call

type EventStore_ReadEventsFromStart_Call 

type EventStore_ReadEventsFromStart_Call struct {
	*mock.Call
}

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

func (*EventStore_ReadEventsFromStart_Call) Return 

func (_c *EventStore_ReadEventsFromStart_Call) Return(_a0 []*models.StreamEvent, _a1 error) *EventStore_ReadEventsFromStart_Call

func (*EventStore_ReadEventsFromStart_Call) Run 

func (_c *EventStore_ReadEventsFromStart_Call) Run(run func(_a0 streamName.StreamName, count uint64, ctx context.Context)) *EventStore_ReadEventsFromStart_Call

func (*EventStore_ReadEventsFromStart_Call) RunAndReturn 

func (_c *EventStore_ReadEventsFromStart_Call) RunAndReturn(run func(streamName.StreamName, uint64, context.Context) ([]*models.StreamEvent, error)) *EventStore_ReadEventsFromStart_Call

type EventStore_ReadEventsWithMaxCount_Call 

type EventStore_ReadEventsWithMaxCount_Call struct {
	*mock.Call
}

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

func (*EventStore_ReadEventsWithMaxCount_Call) Return 

func (_c *EventStore_ReadEventsWithMaxCount_Call) Return(_a0 []*models.StreamEvent, _a1 error) *EventStore_ReadEventsWithMaxCount_Call

func (*EventStore_ReadEventsWithMaxCount_Call) Run 

func (_c *EventStore_ReadEventsWithMaxCount_Call) Run(run func(_a0 streamName.StreamName, _a1 readPosition.StreamReadPosition, ctx context.Context)) *EventStore_ReadEventsWithMaxCount_Call

func (*EventStore_ReadEventsWithMaxCount_Call) RunAndReturn 

func (_c *EventStore_ReadEventsWithMaxCount_Call) RunAndReturn(run func(streamName.StreamName, readPosition.StreamReadPosition, context.Context) ([]*models.StreamEvent, error)) *EventStore_ReadEventsWithMaxCount_Call

type EventStore_ReadEvents_Call 

type EventStore_ReadEvents_Call struct {
	*mock.Call
}

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

func (*EventStore_ReadEvents_Call) Return 

func (_c *EventStore_ReadEvents_Call) Return(_a0 []*models.StreamEvent, _a1 error) *EventStore_ReadEvents_Call

func (*EventStore_ReadEvents_Call) Run 

func (_c *EventStore_ReadEvents_Call) Run(run func(_a0 streamName.StreamName, _a1 readPosition.StreamReadPosition, count uint64, ctx context.Context)) *EventStore_ReadEvents_Call

func (*EventStore_ReadEvents_Call) RunAndReturn 

func (_c *EventStore_ReadEvents_Call) RunAndReturn(run func(streamName.StreamName, readPosition.StreamReadPosition, uint64, context.Context) ([]*models.StreamEvent, error)) *EventStore_ReadEvents_Call

type EventStore_StreamExists_Call 

type EventStore_StreamExists_Call struct {
	*mock.Call
}

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

func (*EventStore_StreamExists_Call) Return 

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

func (*EventStore_StreamExists_Call) Run 

func (_c *EventStore_StreamExists_Call) Run(run func(_a0 streamName.StreamName, ctx context.Context)) *EventStore_StreamExists_Call

func (*EventStore_StreamExists_Call) RunAndReturn 

func (_c *EventStore_StreamExists_Call) RunAndReturn(run func(streamName.StreamName, context.Context) (bool, error)) *EventStore_StreamExists_Call

type EventStore_TruncateStream_Call 

type EventStore_TruncateStream_Call struct {
	*mock.Call
}

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

func (*EventStore_TruncateStream_Call) Return 

func (_c *EventStore_TruncateStream_Call) Return(_a0 *appendResult.AppendEventsResult, _a1 error) *EventStore_TruncateStream_Call

func (*EventStore_TruncateStream_Call) Run 

func (_c *EventStore_TruncateStream_Call) Run(run func(_a0 streamName.StreamName, _a1 truncatePosition.StreamTruncatePosition, expectedVersion expectedStreamVersion.ExpectedStreamVersion, ctx context.Context)) *EventStore_TruncateStream_Call

func (*EventStore_TruncateStream_Call) RunAndReturn 

func (_c *EventStore_TruncateStream_Call) RunAndReturn(run func(streamName.StreamName, truncatePosition.StreamTruncatePosition, expectedStreamVersion.ExpectedStreamVersion, context.Context) (*appendResult.AppendEventsResult, error)) *EventStore_TruncateStream_Call

type IEventSourcedAggregateRoot 

type IEventSourcedAggregateRoot struct {
	mock.Mock
}

IEventSourcedAggregateRoot is an autogenerated mock type for the IEventSourcedAggregateRoot type

func NewIEventSourcedAggregateRoot 

func NewIEventSourcedAggregateRoot(t interface {
	mock.TestingT
	Cleanup(func())
}) *IEventSourcedAggregateRoot

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

func (*IEventSourcedAggregateRoot) AddDomainEvents 

func (_m *IEventSourcedAggregateRoot) AddDomainEvents(event domain.IDomainEvent) error

AddDomainEvents provides a mock function with given fields: event

func (*IEventSourcedAggregateRoot) Apply 

func (_m *IEventSourcedAggregateRoot) Apply(event domain.IDomainEvent, isNew bool) error

Apply provides a mock function with given fields: event, isNew

func (*IEventSourcedAggregateRoot) CreatedAt 

func (_m *IEventSourcedAggregateRoot) CreatedAt() time.Time

CreatedAt provides a mock function with given fields:

func (*IEventSourcedAggregateRoot) CurrentVersion 

func (_m *IEventSourcedAggregateRoot) CurrentVersion() int64

CurrentVersion provides a mock function with given fields:

func (*IEventSourcedAggregateRoot) EXPECT 

func (_m *IEventSourcedAggregateRoot) EXPECT() *IEventSourcedAggregateRoot_Expecter

func (*IEventSourcedAggregateRoot) HasUncommittedEvents 

func (_m *IEventSourcedAggregateRoot) HasUncommittedEvents() bool

HasUncommittedEvents provides a mock function with given fields:

func (*IEventSourcedAggregateRoot) Id 

func (_m *IEventSourcedAggregateRoot) Id() uuid.UUID

Id provides a mock function with given fields:

func (*IEventSourcedAggregateRoot) LoadFromHistory 

func (_m *IEventSourcedAggregateRoot) LoadFromHistory(events []domain.IDomainEvent, _a1 metadata.Metadata) error

LoadFromHistory provides a mock function with given fields: events, _a1

func (*IEventSourcedAggregateRoot) MarkUncommittedEventAsCommitted 

func (_m *IEventSourcedAggregateRoot) MarkUncommittedEventAsCommitted()

MarkUncommittedEventAsCommitted provides a mock function with given fields:

func (*IEventSourcedAggregateRoot) OriginalVersion 

func (_m *IEventSourcedAggregateRoot) OriginalVersion() int64

OriginalVersion provides a mock function with given fields:

func (*IEventSourcedAggregateRoot) SetEntityType 

func (_m *IEventSourcedAggregateRoot) SetEntityType(entityType string)

SetEntityType provides a mock function with given fields: entityType

func (*IEventSourcedAggregateRoot) SetId 

func (_m *IEventSourcedAggregateRoot) SetId(id uuid.UUID)

SetId provides a mock function with given fields: id

func (*IEventSourcedAggregateRoot) SetOriginalVersion 

func (_m *IEventSourcedAggregateRoot) SetOriginalVersion(version int64)

SetOriginalVersion provides a mock function with given fields: version

func (*IEventSourcedAggregateRoot) SetUpdatedAt 

func (_m *IEventSourcedAggregateRoot) SetUpdatedAt(updatedAt time.Time)

SetUpdatedAt provides a mock function with given fields: updatedAt

func (*IEventSourcedAggregateRoot) UncommittedEvents 

func (_m *IEventSourcedAggregateRoot) UncommittedEvents() []domain.IDomainEvent

UncommittedEvents provides a mock function with given fields:

func (*IEventSourcedAggregateRoot) UpdatedAt 

func (_m *IEventSourcedAggregateRoot) UpdatedAt() time.Time

UpdatedAt provides a mock function with given fields:

type IEventSourcedAggregateRoot_AddDomainEvents_Call 

type IEventSourcedAggregateRoot_AddDomainEvents_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_AddDomainEvents_Call) Return 

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

func (*IEventSourcedAggregateRoot_AddDomainEvents_Call) Run 

func (_c *IEventSourcedAggregateRoot_AddDomainEvents_Call) Run(run func(event domain.IDomainEvent)) *IEventSourcedAggregateRoot_AddDomainEvents_Call

func (*IEventSourcedAggregateRoot_AddDomainEvents_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_AddDomainEvents_Call) RunAndReturn(run func(domain.IDomainEvent) error) *IEventSourcedAggregateRoot_AddDomainEvents_Call

type IEventSourcedAggregateRoot_Apply_Call 

type IEventSourcedAggregateRoot_Apply_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_Apply_Call) Return 

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

func (*IEventSourcedAggregateRoot_Apply_Call) Run 

func (_c *IEventSourcedAggregateRoot_Apply_Call) Run(run func(event domain.IDomainEvent, isNew bool)) *IEventSourcedAggregateRoot_Apply_Call

func (*IEventSourcedAggregateRoot_Apply_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_Apply_Call) RunAndReturn(run func(domain.IDomainEvent, bool) error) *IEventSourcedAggregateRoot_Apply_Call

type IEventSourcedAggregateRoot_CreatedAt_Call 

type IEventSourcedAggregateRoot_CreatedAt_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_CreatedAt_Call) Return 

func (_c *IEventSourcedAggregateRoot_CreatedAt_Call) Return(_a0 time.Time) *IEventSourcedAggregateRoot_CreatedAt_Call

func (*IEventSourcedAggregateRoot_CreatedAt_Call) Run 

func (_c *IEventSourcedAggregateRoot_CreatedAt_Call) Run(run func()) *IEventSourcedAggregateRoot_CreatedAt_Call

func (*IEventSourcedAggregateRoot_CreatedAt_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_CreatedAt_Call) RunAndReturn(run func() time.Time) *IEventSourcedAggregateRoot_CreatedAt_Call

type IEventSourcedAggregateRoot_CurrentVersion_Call 

type IEventSourcedAggregateRoot_CurrentVersion_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_CurrentVersion_Call) Return 

func (_c *IEventSourcedAggregateRoot_CurrentVersion_Call) Return(_a0 int64) *IEventSourcedAggregateRoot_CurrentVersion_Call

func (*IEventSourcedAggregateRoot_CurrentVersion_Call) Run 

func (_c *IEventSourcedAggregateRoot_CurrentVersion_Call) Run(run func()) *IEventSourcedAggregateRoot_CurrentVersion_Call

func (*IEventSourcedAggregateRoot_CurrentVersion_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_CurrentVersion_Call) RunAndReturn(run func() int64) *IEventSourcedAggregateRoot_CurrentVersion_Call

type IEventSourcedAggregateRoot_Expecter 

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

func (*IEventSourcedAggregateRoot_Expecter) AddDomainEvents 

func (_e *IEventSourcedAggregateRoot_Expecter) AddDomainEvents(event interface{}) *IEventSourcedAggregateRoot_AddDomainEvents_Call

AddDomainEvents is a helper method to define mock.On call

  • event domain.IDomainEvent

func (*IEventSourcedAggregateRoot_Expecter) Apply 

func (_e *IEventSourcedAggregateRoot_Expecter) Apply(event interface{}, isNew interface{}) *IEventSourcedAggregateRoot_Apply_Call

Apply is a helper method to define mock.On call

  • event domain.IDomainEvent
  • isNew bool

func (*IEventSourcedAggregateRoot_Expecter) CreatedAt 

func (_e *IEventSourcedAggregateRoot_Expecter) CreatedAt() *IEventSourcedAggregateRoot_CreatedAt_Call

CreatedAt is a helper method to define mock.On call

func (*IEventSourcedAggregateRoot_Expecter) CurrentVersion 

func (_e *IEventSourcedAggregateRoot_Expecter) CurrentVersion() *IEventSourcedAggregateRoot_CurrentVersion_Call

CurrentVersion is a helper method to define mock.On call

func (*IEventSourcedAggregateRoot_Expecter) HasUncommittedEvents 

func (_e *IEventSourcedAggregateRoot_Expecter) HasUncommittedEvents() *IEventSourcedAggregateRoot_HasUncommittedEvents_Call

HasUncommittedEvents is a helper method to define mock.On call

func (*IEventSourcedAggregateRoot_Expecter) Id 

func (_e *IEventSourcedAggregateRoot_Expecter) Id() *IEventSourcedAggregateRoot_Id_Call

Id is a helper method to define mock.On call

func (*IEventSourcedAggregateRoot_Expecter) LoadFromHistory 

func (_e *IEventSourcedAggregateRoot_Expecter) LoadFromHistory(events interface{}, _a1 interface{}) *IEventSourcedAggregateRoot_LoadFromHistory_Call

LoadFromHistory is a helper method to define mock.On call

  • events []domain.IDomainEvent
  • _a1 metadata.Metadata

func (*IEventSourcedAggregateRoot_Expecter) MarkUncommittedEventAsCommitted 

func (_e *IEventSourcedAggregateRoot_Expecter) MarkUncommittedEventAsCommitted() *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call

MarkUncommittedEventAsCommitted is a helper method to define mock.On call

func (*IEventSourcedAggregateRoot_Expecter) OriginalVersion 

func (_e *IEventSourcedAggregateRoot_Expecter) OriginalVersion() *IEventSourcedAggregateRoot_OriginalVersion_Call

OriginalVersion is a helper method to define mock.On call

func (*IEventSourcedAggregateRoot_Expecter) SetEntityType 

func (_e *IEventSourcedAggregateRoot_Expecter) SetEntityType(entityType interface{}) *IEventSourcedAggregateRoot_SetEntityType_Call

SetEntityType is a helper method to define mock.On call

  • entityType string

func (*IEventSourcedAggregateRoot_Expecter) SetId 

func (_e *IEventSourcedAggregateRoot_Expecter) SetId(id interface{}) *IEventSourcedAggregateRoot_SetId_Call

SetId is a helper method to define mock.On call

  • id uuid.UUID

func (*IEventSourcedAggregateRoot_Expecter) SetOriginalVersion 

func (_e *IEventSourcedAggregateRoot_Expecter) SetOriginalVersion(version interface{}) *IEventSourcedAggregateRoot_SetOriginalVersion_Call

SetOriginalVersion is a helper method to define mock.On call

  • version int64

func (*IEventSourcedAggregateRoot_Expecter) SetUpdatedAt 

func (_e *IEventSourcedAggregateRoot_Expecter) SetUpdatedAt(updatedAt interface{}) *IEventSourcedAggregateRoot_SetUpdatedAt_Call

SetUpdatedAt is a helper method to define mock.On call

  • updatedAt time.Time

func (*IEventSourcedAggregateRoot_Expecter) UncommittedEvents 

func (_e *IEventSourcedAggregateRoot_Expecter) UncommittedEvents() *IEventSourcedAggregateRoot_UncommittedEvents_Call

UncommittedEvents is a helper method to define mock.On call

func (*IEventSourcedAggregateRoot_Expecter) UpdatedAt 

func (_e *IEventSourcedAggregateRoot_Expecter) UpdatedAt() *IEventSourcedAggregateRoot_UpdatedAt_Call

UpdatedAt is a helper method to define mock.On call

type IEventSourcedAggregateRoot_HasUncommittedEvents_Call 

type IEventSourcedAggregateRoot_HasUncommittedEvents_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_HasUncommittedEvents_Call) Return 

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

func (*IEventSourcedAggregateRoot_HasUncommittedEvents_Call) Run 

func (_c *IEventSourcedAggregateRoot_HasUncommittedEvents_Call) Run(run func()) *IEventSourcedAggregateRoot_HasUncommittedEvents_Call

func (*IEventSourcedAggregateRoot_HasUncommittedEvents_Call) RunAndReturn 

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

type IEventSourcedAggregateRoot_Id_Call 

type IEventSourcedAggregateRoot_Id_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_Id_Call) Return 

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

func (*IEventSourcedAggregateRoot_Id_Call) Run 

func (_c *IEventSourcedAggregateRoot_Id_Call) Run(run func()) *IEventSourcedAggregateRoot_Id_Call

func (*IEventSourcedAggregateRoot_Id_Call) RunAndReturn 

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

type IEventSourcedAggregateRoot_LoadFromHistory_Call 

type IEventSourcedAggregateRoot_LoadFromHistory_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_LoadFromHistory_Call) Return 

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

func (*IEventSourcedAggregateRoot_LoadFromHistory_Call) Run 

func (_c *IEventSourcedAggregateRoot_LoadFromHistory_Call) Run(run func(events []domain.IDomainEvent, _a1 metadata.Metadata)) *IEventSourcedAggregateRoot_LoadFromHistory_Call

func (*IEventSourcedAggregateRoot_LoadFromHistory_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_LoadFromHistory_Call) RunAndReturn(run func([]domain.IDomainEvent, metadata.Metadata) error) *IEventSourcedAggregateRoot_LoadFromHistory_Call

type IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call 

type IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call) Return 

func (_c *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call) Return() *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call

func (*IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call) Run 

func (_c *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call) Run(run func()) *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call

func (*IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call) RunAndReturn(run func()) *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call

type IEventSourcedAggregateRoot_OriginalVersion_Call 

type IEventSourcedAggregateRoot_OriginalVersion_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_OriginalVersion_Call) Return 

func (_c *IEventSourcedAggregateRoot_OriginalVersion_Call) Return(_a0 int64) *IEventSourcedAggregateRoot_OriginalVersion_Call

func (*IEventSourcedAggregateRoot_OriginalVersion_Call) Run 

func (_c *IEventSourcedAggregateRoot_OriginalVersion_Call) Run(run func()) *IEventSourcedAggregateRoot_OriginalVersion_Call

func (*IEventSourcedAggregateRoot_OriginalVersion_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_OriginalVersion_Call) RunAndReturn(run func() int64) *IEventSourcedAggregateRoot_OriginalVersion_Call

type IEventSourcedAggregateRoot_SetEntityType_Call 

type IEventSourcedAggregateRoot_SetEntityType_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_SetEntityType_Call) Return 

func (_c *IEventSourcedAggregateRoot_SetEntityType_Call) Return() *IEventSourcedAggregateRoot_SetEntityType_Call

func (*IEventSourcedAggregateRoot_SetEntityType_Call) Run 

func (_c *IEventSourcedAggregateRoot_SetEntityType_Call) Run(run func(entityType string)) *IEventSourcedAggregateRoot_SetEntityType_Call

func (*IEventSourcedAggregateRoot_SetEntityType_Call) RunAndReturn 

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

type IEventSourcedAggregateRoot_SetId_Call 

type IEventSourcedAggregateRoot_SetId_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_SetId_Call) Return 

func (_c *IEventSourcedAggregateRoot_SetId_Call) Return() *IEventSourcedAggregateRoot_SetId_Call

func (*IEventSourcedAggregateRoot_SetId_Call) Run 

func (_c *IEventSourcedAggregateRoot_SetId_Call) Run(run func(id uuid.UUID)) *IEventSourcedAggregateRoot_SetId_Call

func (*IEventSourcedAggregateRoot_SetId_Call) RunAndReturn 

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

type IEventSourcedAggregateRoot_SetOriginalVersion_Call 

type IEventSourcedAggregateRoot_SetOriginalVersion_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_SetOriginalVersion_Call) Return 

func (_c *IEventSourcedAggregateRoot_SetOriginalVersion_Call) Return() *IEventSourcedAggregateRoot_SetOriginalVersion_Call

func (*IEventSourcedAggregateRoot_SetOriginalVersion_Call) Run 

func (_c *IEventSourcedAggregateRoot_SetOriginalVersion_Call) Run(run func(version int64)) *IEventSourcedAggregateRoot_SetOriginalVersion_Call

func (*IEventSourcedAggregateRoot_SetOriginalVersion_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_SetOriginalVersion_Call) RunAndReturn(run func(int64)) *IEventSourcedAggregateRoot_SetOriginalVersion_Call

type IEventSourcedAggregateRoot_SetUpdatedAt_Call 

type IEventSourcedAggregateRoot_SetUpdatedAt_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_SetUpdatedAt_Call) Return 

func (_c *IEventSourcedAggregateRoot_SetUpdatedAt_Call) Return() *IEventSourcedAggregateRoot_SetUpdatedAt_Call

func (*IEventSourcedAggregateRoot_SetUpdatedAt_Call) Run 

func (_c *IEventSourcedAggregateRoot_SetUpdatedAt_Call) Run(run func(updatedAt time.Time)) *IEventSourcedAggregateRoot_SetUpdatedAt_Call

func (*IEventSourcedAggregateRoot_SetUpdatedAt_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_SetUpdatedAt_Call) RunAndReturn(run func(time.Time)) *IEventSourcedAggregateRoot_SetUpdatedAt_Call

type IEventSourcedAggregateRoot_UncommittedEvents_Call 

type IEventSourcedAggregateRoot_UncommittedEvents_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_UncommittedEvents_Call) Return 

func (_c *IEventSourcedAggregateRoot_UncommittedEvents_Call) Return(_a0 []domain.IDomainEvent) *IEventSourcedAggregateRoot_UncommittedEvents_Call

func (*IEventSourcedAggregateRoot_UncommittedEvents_Call) Run 

func (_c *IEventSourcedAggregateRoot_UncommittedEvents_Call) Run(run func()) *IEventSourcedAggregateRoot_UncommittedEvents_Call

func (*IEventSourcedAggregateRoot_UncommittedEvents_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_UncommittedEvents_Call) RunAndReturn(run func() []domain.IDomainEvent) *IEventSourcedAggregateRoot_UncommittedEvents_Call

type IEventSourcedAggregateRoot_UpdatedAt_Call 

type IEventSourcedAggregateRoot_UpdatedAt_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_UpdatedAt_Call) Return 

func (_c *IEventSourcedAggregateRoot_UpdatedAt_Call) Return(_a0 time.Time) *IEventSourcedAggregateRoot_UpdatedAt_Call

func (*IEventSourcedAggregateRoot_UpdatedAt_Call) Run 

func (_c *IEventSourcedAggregateRoot_UpdatedAt_Call) Run(run func()) *IEventSourcedAggregateRoot_UpdatedAt_Call

func (*IEventSourcedAggregateRoot_UpdatedAt_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_UpdatedAt_Call) RunAndReturn(run func() time.Time) *IEventSourcedAggregateRoot_UpdatedAt_Call

type IEventSourcedAggregateRoot_fold_Call 

type IEventSourcedAggregateRoot_fold_Call struct {
	*mock.Call
}

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

func (*IEventSourcedAggregateRoot_fold_Call) Return 

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

func (*IEventSourcedAggregateRoot_fold_Call) Run 

func (_c *IEventSourcedAggregateRoot_fold_Call) Run(run func(event domain.IDomainEvent, _a1 metadata.Metadata)) *IEventSourcedAggregateRoot_fold_Call

func (*IEventSourcedAggregateRoot_fold_Call) RunAndReturn 

func (_c *IEventSourcedAggregateRoot_fold_Call) RunAndReturn(run func(domain.IDomainEvent, metadata.Metadata) error) *IEventSourcedAggregateRoot_fold_Call

type IHaveEventSourcedAggregate 

type IHaveEventSourcedAggregate struct {
	mock.Mock
}

IHaveEventSourcedAggregate is an autogenerated mock type for the IHaveEventSourcedAggregate type

func NewIHaveEventSourcedAggregate 

func NewIHaveEventSourcedAggregate(t interface {
	mock.TestingT
	Cleanup(func())
}) *IHaveEventSourcedAggregate

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

func (*IHaveEventSourcedAggregate) AddDomainEvents 

func (_m *IHaveEventSourcedAggregate) AddDomainEvents(event domain.IDomainEvent) error

AddDomainEvents provides a mock function with given fields: event

func (*IHaveEventSourcedAggregate) Apply 

func (_m *IHaveEventSourcedAggregate) Apply(event domain.IDomainEvent, isNew bool) error

Apply provides a mock function with given fields: event, isNew

func (*IHaveEventSourcedAggregate) CreatedAt 

func (_m *IHaveEventSourcedAggregate) CreatedAt() time.Time

CreatedAt provides a mock function with given fields:

func (*IHaveEventSourcedAggregate) CurrentVersion 

func (_m *IHaveEventSourcedAggregate) CurrentVersion() int64

CurrentVersion provides a mock function with given fields:

func (*IHaveEventSourcedAggregate) EXPECT 

func (_m *IHaveEventSourcedAggregate) EXPECT() *IHaveEventSourcedAggregate_Expecter

func (*IHaveEventSourcedAggregate) HasUncommittedEvents 

func (_m *IHaveEventSourcedAggregate) HasUncommittedEvents() bool

HasUncommittedEvents provides a mock function with given fields:

func (*IHaveEventSourcedAggregate) Id 

func (_m *IHaveEventSourcedAggregate) Id() uuid.UUID

Id provides a mock function with given fields:

func (*IHaveEventSourcedAggregate) LoadFromHistory 

func (_m *IHaveEventSourcedAggregate) LoadFromHistory(events []domain.IDomainEvent, _a1 metadata.Metadata) error

LoadFromHistory provides a mock function with given fields: events, _a1

func (*IHaveEventSourcedAggregate) MarkUncommittedEventAsCommitted 

func (_m *IHaveEventSourcedAggregate) MarkUncommittedEventAsCommitted()

MarkUncommittedEventAsCommitted provides a mock function with given fields:

func (*IHaveEventSourcedAggregate) NewEmptyAggregate 

func (_m *IHaveEventSourcedAggregate) NewEmptyAggregate()

NewEmptyAggregate provides a mock function with given fields:

func (*IHaveEventSourcedAggregate) OriginalVersion 

func (_m *IHaveEventSourcedAggregate) OriginalVersion() int64

OriginalVersion provides a mock function with given fields:

func (*IHaveEventSourcedAggregate) SetEntityType 

func (_m *IHaveEventSourcedAggregate) SetEntityType(entityType string)

SetEntityType provides a mock function with given fields: entityType

func (*IHaveEventSourcedAggregate) SetId 

func (_m *IHaveEventSourcedAggregate) SetId(id uuid.UUID)

SetId provides a mock function with given fields: id

func (*IHaveEventSourcedAggregate) SetOriginalVersion 

func (_m *IHaveEventSourcedAggregate) SetOriginalVersion(version int64)

SetOriginalVersion provides a mock function with given fields: version

func (*IHaveEventSourcedAggregate) SetUpdatedAt 

func (_m *IHaveEventSourcedAggregate) SetUpdatedAt(updatedAt time.Time)

SetUpdatedAt provides a mock function with given fields: updatedAt

func (*IHaveEventSourcedAggregate) UncommittedEvents 

func (_m *IHaveEventSourcedAggregate) UncommittedEvents() []domain.IDomainEvent

UncommittedEvents provides a mock function with given fields:

func (*IHaveEventSourcedAggregate) UpdatedAt 

func (_m *IHaveEventSourcedAggregate) UpdatedAt() time.Time

UpdatedAt provides a mock function with given fields:

func (*IHaveEventSourcedAggregate) When 

func (_m *IHaveEventSourcedAggregate) When(event domain.IDomainEvent) error

When provides a mock function with given fields: event

type IHaveEventSourcedAggregate_AddDomainEvents_Call 

type IHaveEventSourcedAggregate_AddDomainEvents_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_AddDomainEvents_Call) Return 

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

func (*IHaveEventSourcedAggregate_AddDomainEvents_Call) Run 

func (_c *IHaveEventSourcedAggregate_AddDomainEvents_Call) Run(run func(event domain.IDomainEvent)) *IHaveEventSourcedAggregate_AddDomainEvents_Call

func (*IHaveEventSourcedAggregate_AddDomainEvents_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_AddDomainEvents_Call) RunAndReturn(run func(domain.IDomainEvent) error) *IHaveEventSourcedAggregate_AddDomainEvents_Call

type IHaveEventSourcedAggregate_Apply_Call 

type IHaveEventSourcedAggregate_Apply_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_Apply_Call) Return 

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

func (*IHaveEventSourcedAggregate_Apply_Call) Run 

func (_c *IHaveEventSourcedAggregate_Apply_Call) Run(run func(event domain.IDomainEvent, isNew bool)) *IHaveEventSourcedAggregate_Apply_Call

func (*IHaveEventSourcedAggregate_Apply_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_Apply_Call) RunAndReturn(run func(domain.IDomainEvent, bool) error) *IHaveEventSourcedAggregate_Apply_Call

type IHaveEventSourcedAggregate_CreatedAt_Call 

type IHaveEventSourcedAggregate_CreatedAt_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_CreatedAt_Call) Return 

func (_c *IHaveEventSourcedAggregate_CreatedAt_Call) Return(_a0 time.Time) *IHaveEventSourcedAggregate_CreatedAt_Call

func (*IHaveEventSourcedAggregate_CreatedAt_Call) Run 

func (_c *IHaveEventSourcedAggregate_CreatedAt_Call) Run(run func()) *IHaveEventSourcedAggregate_CreatedAt_Call

func (*IHaveEventSourcedAggregate_CreatedAt_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_CreatedAt_Call) RunAndReturn(run func() time.Time) *IHaveEventSourcedAggregate_CreatedAt_Call

type IHaveEventSourcedAggregate_CurrentVersion_Call 

type IHaveEventSourcedAggregate_CurrentVersion_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_CurrentVersion_Call) Return 

func (_c *IHaveEventSourcedAggregate_CurrentVersion_Call) Return(_a0 int64) *IHaveEventSourcedAggregate_CurrentVersion_Call

func (*IHaveEventSourcedAggregate_CurrentVersion_Call) Run 

func (_c *IHaveEventSourcedAggregate_CurrentVersion_Call) Run(run func()) *IHaveEventSourcedAggregate_CurrentVersion_Call

func (*IHaveEventSourcedAggregate_CurrentVersion_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_CurrentVersion_Call) RunAndReturn(run func() int64) *IHaveEventSourcedAggregate_CurrentVersion_Call

type IHaveEventSourcedAggregate_Expecter 

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

func (*IHaveEventSourcedAggregate_Expecter) AddDomainEvents 

func (_e *IHaveEventSourcedAggregate_Expecter) AddDomainEvents(event interface{}) *IHaveEventSourcedAggregate_AddDomainEvents_Call

AddDomainEvents is a helper method to define mock.On call

  • event domain.IDomainEvent

func (*IHaveEventSourcedAggregate_Expecter) Apply 

func (_e *IHaveEventSourcedAggregate_Expecter) Apply(event interface{}, isNew interface{}) *IHaveEventSourcedAggregate_Apply_Call

Apply is a helper method to define mock.On call

  • event domain.IDomainEvent
  • isNew bool

func (*IHaveEventSourcedAggregate_Expecter) CreatedAt 

func (_e *IHaveEventSourcedAggregate_Expecter) CreatedAt() *IHaveEventSourcedAggregate_CreatedAt_Call

CreatedAt is a helper method to define mock.On call

func (*IHaveEventSourcedAggregate_Expecter) CurrentVersion 

func (_e *IHaveEventSourcedAggregate_Expecter) CurrentVersion() *IHaveEventSourcedAggregate_CurrentVersion_Call

CurrentVersion is a helper method to define mock.On call

func (*IHaveEventSourcedAggregate_Expecter) HasUncommittedEvents 

func (_e *IHaveEventSourcedAggregate_Expecter) HasUncommittedEvents() *IHaveEventSourcedAggregate_HasUncommittedEvents_Call

HasUncommittedEvents is a helper method to define mock.On call

func (*IHaveEventSourcedAggregate_Expecter) Id 

func (_e *IHaveEventSourcedAggregate_Expecter) Id() *IHaveEventSourcedAggregate_Id_Call

Id is a helper method to define mock.On call

func (*IHaveEventSourcedAggregate_Expecter) LoadFromHistory 

func (_e *IHaveEventSourcedAggregate_Expecter) LoadFromHistory(events interface{}, _a1 interface{}) *IHaveEventSourcedAggregate_LoadFromHistory_Call

LoadFromHistory is a helper method to define mock.On call

  • events []domain.IDomainEvent
  • _a1 metadata.Metadata

func (*IHaveEventSourcedAggregate_Expecter) MarkUncommittedEventAsCommitted 

func (_e *IHaveEventSourcedAggregate_Expecter) MarkUncommittedEventAsCommitted() *IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call

MarkUncommittedEventAsCommitted is a helper method to define mock.On call

func (*IHaveEventSourcedAggregate_Expecter) NewEmptyAggregate 

func (_e *IHaveEventSourcedAggregate_Expecter) NewEmptyAggregate() *IHaveEventSourcedAggregate_NewEmptyAggregate_Call

NewEmptyAggregate is a helper method to define mock.On call

func (*IHaveEventSourcedAggregate_Expecter) OriginalVersion 

func (_e *IHaveEventSourcedAggregate_Expecter) OriginalVersion() *IHaveEventSourcedAggregate_OriginalVersion_Call

OriginalVersion is a helper method to define mock.On call

func (*IHaveEventSourcedAggregate_Expecter) SetEntityType 

func (_e *IHaveEventSourcedAggregate_Expecter) SetEntityType(entityType interface{}) *IHaveEventSourcedAggregate_SetEntityType_Call

SetEntityType is a helper method to define mock.On call

  • entityType string

func (*IHaveEventSourcedAggregate_Expecter) SetId 

func (_e *IHaveEventSourcedAggregate_Expecter) SetId(id interface{}) *IHaveEventSourcedAggregate_SetId_Call

SetId is a helper method to define mock.On call

  • id uuid.UUID

func (*IHaveEventSourcedAggregate_Expecter) SetOriginalVersion 

func (_e *IHaveEventSourcedAggregate_Expecter) SetOriginalVersion(version interface{}) *IHaveEventSourcedAggregate_SetOriginalVersion_Call

SetOriginalVersion is a helper method to define mock.On call

  • version int64

func (*IHaveEventSourcedAggregate_Expecter) SetUpdatedAt 

func (_e *IHaveEventSourcedAggregate_Expecter) SetUpdatedAt(updatedAt interface{}) *IHaveEventSourcedAggregate_SetUpdatedAt_Call

SetUpdatedAt is a helper method to define mock.On call

  • updatedAt time.Time

func (*IHaveEventSourcedAggregate_Expecter) UncommittedEvents 

func (_e *IHaveEventSourcedAggregate_Expecter) UncommittedEvents() *IHaveEventSourcedAggregate_UncommittedEvents_Call

UncommittedEvents is a helper method to define mock.On call

func (*IHaveEventSourcedAggregate_Expecter) UpdatedAt 

func (_e *IHaveEventSourcedAggregate_Expecter) UpdatedAt() *IHaveEventSourcedAggregate_UpdatedAt_Call

UpdatedAt is a helper method to define mock.On call

func (*IHaveEventSourcedAggregate_Expecter) When 

func (_e *IHaveEventSourcedAggregate_Expecter) When(event interface{}) *IHaveEventSourcedAggregate_When_Call

When is a helper method to define mock.On call

  • event domain.IDomainEvent

type IHaveEventSourcedAggregate_HasUncommittedEvents_Call 

type IHaveEventSourcedAggregate_HasUncommittedEvents_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_HasUncommittedEvents_Call) Return 

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

func (*IHaveEventSourcedAggregate_HasUncommittedEvents_Call) Run 

func (_c *IHaveEventSourcedAggregate_HasUncommittedEvents_Call) Run(run func()) *IHaveEventSourcedAggregate_HasUncommittedEvents_Call

func (*IHaveEventSourcedAggregate_HasUncommittedEvents_Call) RunAndReturn 

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

type IHaveEventSourcedAggregate_Id_Call 

type IHaveEventSourcedAggregate_Id_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_Id_Call) Return 

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

func (*IHaveEventSourcedAggregate_Id_Call) Run 

func (_c *IHaveEventSourcedAggregate_Id_Call) Run(run func()) *IHaveEventSourcedAggregate_Id_Call

func (*IHaveEventSourcedAggregate_Id_Call) RunAndReturn 

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

type IHaveEventSourcedAggregate_LoadFromHistory_Call 

type IHaveEventSourcedAggregate_LoadFromHistory_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_LoadFromHistory_Call) Return 

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

func (*IHaveEventSourcedAggregate_LoadFromHistory_Call) Run 

func (_c *IHaveEventSourcedAggregate_LoadFromHistory_Call) Run(run func(events []domain.IDomainEvent, _a1 metadata.Metadata)) *IHaveEventSourcedAggregate_LoadFromHistory_Call

func (*IHaveEventSourcedAggregate_LoadFromHistory_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_LoadFromHistory_Call) RunAndReturn(run func([]domain.IDomainEvent, metadata.Metadata) error) *IHaveEventSourcedAggregate_LoadFromHistory_Call

type IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call 

type IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call) Return 

func (_c *IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call) Return() *IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call

func (*IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call) Run 

func (_c *IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call) Run(run func()) *IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call

func (*IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call) RunAndReturn(run func()) *IHaveEventSourcedAggregate_MarkUncommittedEventAsCommitted_Call

type IHaveEventSourcedAggregate_NewEmptyAggregate_Call 

type IHaveEventSourcedAggregate_NewEmptyAggregate_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_NewEmptyAggregate_Call) Return 

func (_c *IHaveEventSourcedAggregate_NewEmptyAggregate_Call) Return() *IHaveEventSourcedAggregate_NewEmptyAggregate_Call

func (*IHaveEventSourcedAggregate_NewEmptyAggregate_Call) Run 

func (_c *IHaveEventSourcedAggregate_NewEmptyAggregate_Call) Run(run func()) *IHaveEventSourcedAggregate_NewEmptyAggregate_Call

func (*IHaveEventSourcedAggregate_NewEmptyAggregate_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_NewEmptyAggregate_Call) RunAndReturn(run func()) *IHaveEventSourcedAggregate_NewEmptyAggregate_Call

type IHaveEventSourcedAggregate_OriginalVersion_Call 

type IHaveEventSourcedAggregate_OriginalVersion_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_OriginalVersion_Call) Return 

func (_c *IHaveEventSourcedAggregate_OriginalVersion_Call) Return(_a0 int64) *IHaveEventSourcedAggregate_OriginalVersion_Call

func (*IHaveEventSourcedAggregate_OriginalVersion_Call) Run 

func (_c *IHaveEventSourcedAggregate_OriginalVersion_Call) Run(run func()) *IHaveEventSourcedAggregate_OriginalVersion_Call

func (*IHaveEventSourcedAggregate_OriginalVersion_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_OriginalVersion_Call) RunAndReturn(run func() int64) *IHaveEventSourcedAggregate_OriginalVersion_Call

type IHaveEventSourcedAggregate_SetEntityType_Call 

type IHaveEventSourcedAggregate_SetEntityType_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_SetEntityType_Call) Return 

func (_c *IHaveEventSourcedAggregate_SetEntityType_Call) Return() *IHaveEventSourcedAggregate_SetEntityType_Call

func (*IHaveEventSourcedAggregate_SetEntityType_Call) Run 

func (_c *IHaveEventSourcedAggregate_SetEntityType_Call) Run(run func(entityType string)) *IHaveEventSourcedAggregate_SetEntityType_Call

func (*IHaveEventSourcedAggregate_SetEntityType_Call) RunAndReturn 

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

type IHaveEventSourcedAggregate_SetId_Call 

type IHaveEventSourcedAggregate_SetId_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_SetId_Call) Return 

func (_c *IHaveEventSourcedAggregate_SetId_Call) Return() *IHaveEventSourcedAggregate_SetId_Call

func (*IHaveEventSourcedAggregate_SetId_Call) Run 

func (_c *IHaveEventSourcedAggregate_SetId_Call) Run(run func(id uuid.UUID)) *IHaveEventSourcedAggregate_SetId_Call

func (*IHaveEventSourcedAggregate_SetId_Call) RunAndReturn 

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

type IHaveEventSourcedAggregate_SetOriginalVersion_Call 

type IHaveEventSourcedAggregate_SetOriginalVersion_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_SetOriginalVersion_Call) Return 

func (_c *IHaveEventSourcedAggregate_SetOriginalVersion_Call) Return() *IHaveEventSourcedAggregate_SetOriginalVersion_Call

func (*IHaveEventSourcedAggregate_SetOriginalVersion_Call) Run 

func (_c *IHaveEventSourcedAggregate_SetOriginalVersion_Call) Run(run func(version int64)) *IHaveEventSourcedAggregate_SetOriginalVersion_Call

func (*IHaveEventSourcedAggregate_SetOriginalVersion_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_SetOriginalVersion_Call) RunAndReturn(run func(int64)) *IHaveEventSourcedAggregate_SetOriginalVersion_Call

type IHaveEventSourcedAggregate_SetUpdatedAt_Call 

type IHaveEventSourcedAggregate_SetUpdatedAt_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_SetUpdatedAt_Call) Return 

func (_c *IHaveEventSourcedAggregate_SetUpdatedAt_Call) Return() *IHaveEventSourcedAggregate_SetUpdatedAt_Call

func (*IHaveEventSourcedAggregate_SetUpdatedAt_Call) Run 

func (_c *IHaveEventSourcedAggregate_SetUpdatedAt_Call) Run(run func(updatedAt time.Time)) *IHaveEventSourcedAggregate_SetUpdatedAt_Call

func (*IHaveEventSourcedAggregate_SetUpdatedAt_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_SetUpdatedAt_Call) RunAndReturn(run func(time.Time)) *IHaveEventSourcedAggregate_SetUpdatedAt_Call

type IHaveEventSourcedAggregate_UncommittedEvents_Call 

type IHaveEventSourcedAggregate_UncommittedEvents_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_UncommittedEvents_Call) Return 

func (_c *IHaveEventSourcedAggregate_UncommittedEvents_Call) Return(_a0 []domain.IDomainEvent) *IHaveEventSourcedAggregate_UncommittedEvents_Call

func (*IHaveEventSourcedAggregate_UncommittedEvents_Call) Run 

func (_c *IHaveEventSourcedAggregate_UncommittedEvents_Call) Run(run func()) *IHaveEventSourcedAggregate_UncommittedEvents_Call

func (*IHaveEventSourcedAggregate_UncommittedEvents_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_UncommittedEvents_Call) RunAndReturn(run func() []domain.IDomainEvent) *IHaveEventSourcedAggregate_UncommittedEvents_Call

type IHaveEventSourcedAggregate_UpdatedAt_Call 

type IHaveEventSourcedAggregate_UpdatedAt_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_UpdatedAt_Call) Return 

func (_c *IHaveEventSourcedAggregate_UpdatedAt_Call) Return(_a0 time.Time) *IHaveEventSourcedAggregate_UpdatedAt_Call

func (*IHaveEventSourcedAggregate_UpdatedAt_Call) Run 

func (_c *IHaveEventSourcedAggregate_UpdatedAt_Call) Run(run func()) *IHaveEventSourcedAggregate_UpdatedAt_Call

func (*IHaveEventSourcedAggregate_UpdatedAt_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_UpdatedAt_Call) RunAndReturn(run func() time.Time) *IHaveEventSourcedAggregate_UpdatedAt_Call

type IHaveEventSourcedAggregate_When_Call 

type IHaveEventSourcedAggregate_When_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_When_Call) Return 

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

func (*IHaveEventSourcedAggregate_When_Call) Run 

func (_c *IHaveEventSourcedAggregate_When_Call) Run(run func(event domain.IDomainEvent)) *IHaveEventSourcedAggregate_When_Call

func (*IHaveEventSourcedAggregate_When_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_When_Call) RunAndReturn(run func(domain.IDomainEvent) error) *IHaveEventSourcedAggregate_When_Call

type IHaveEventSourcedAggregate_fold_Call 

type IHaveEventSourcedAggregate_fold_Call struct {
	*mock.Call
}

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

func (*IHaveEventSourcedAggregate_fold_Call) Return 

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

func (*IHaveEventSourcedAggregate_fold_Call) Run 

func (_c *IHaveEventSourcedAggregate_fold_Call) Run(run func(event domain.IDomainEvent, _a1 metadata.Metadata)) *IHaveEventSourcedAggregate_fold_Call

func (*IHaveEventSourcedAggregate_fold_Call) RunAndReturn 

func (_c *IHaveEventSourcedAggregate_fold_Call) RunAndReturn(run func(domain.IDomainEvent, metadata.Metadata) error) *IHaveEventSourcedAggregate_fold_Call

type IProjection 

type IProjection struct {
	mock.Mock
}

IProjection is an autogenerated mock type for the IProjection type

func NewIProjection 

func NewIProjection(t interface {
	mock.TestingT
	Cleanup(func())
}) *IProjection

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

func (*IProjection) EXPECT 

func (_m *IProjection) EXPECT() *IProjection_Expecter

func (*IProjection) ProcessEvent 

func (_m *IProjection) ProcessEvent(ctx context.Context, streamEvent *models.StreamEvent) error

ProcessEvent provides a mock function with given fields: ctx, streamEvent

type IProjectionPublisher 

type IProjectionPublisher struct {
	mock.Mock
}

IProjectionPublisher is an autogenerated mock type for the IProjectionPublisher type

func NewIProjectionPublisher 

func NewIProjectionPublisher(t interface {
	mock.TestingT
	Cleanup(func())
}) *IProjectionPublisher

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

func (*IProjectionPublisher) EXPECT 

func (_m *IProjectionPublisher) EXPECT() *IProjectionPublisher_Expecter

func (*IProjectionPublisher) Publish 

func (_m *IProjectionPublisher) Publish(ctx context.Context, streamEvent *models.StreamEvent) error

Publish provides a mock function with given fields: ctx, streamEvent

type IProjectionPublisher_Expecter 

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

func (*IProjectionPublisher_Expecter) Publish 

func (_e *IProjectionPublisher_Expecter) Publish(ctx interface{}, streamEvent interface{}) *IProjectionPublisher_Publish_Call

Publish is a helper method to define mock.On call

  • ctx context.Context
  • streamEvent *models.StreamEvent

type IProjectionPublisher_Publish_Call 

type IProjectionPublisher_Publish_Call struct {
	*mock.Call
}

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

func (*IProjectionPublisher_Publish_Call) Return 

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

func (*IProjectionPublisher_Publish_Call) Run 

func (_c *IProjectionPublisher_Publish_Call) Run(run func(ctx context.Context, streamEvent *models.StreamEvent)) *IProjectionPublisher_Publish_Call

func (*IProjectionPublisher_Publish_Call) RunAndReturn 

func (_c *IProjectionPublisher_Publish_Call) RunAndReturn(run func(context.Context, *models.StreamEvent) error) *IProjectionPublisher_Publish_Call

type IProjection_Expecter 

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

func (*IProjection_Expecter) ProcessEvent 

func (_e *IProjection_Expecter) ProcessEvent(ctx interface{}, streamEvent interface{}) *IProjection_ProcessEvent_Call

ProcessEvent is a helper method to define mock.On call

  • ctx context.Context
  • streamEvent *models.StreamEvent

type IProjection_ProcessEvent_Call 

type IProjection_ProcessEvent_Call struct {
	*mock.Call
}

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

func (*IProjection_ProcessEvent_Call) Return 

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

func (*IProjection_ProcessEvent_Call) Run 

func (_c *IProjection_ProcessEvent_Call) Run(run func(ctx context.Context, streamEvent *models.StreamEvent)) *IProjection_ProcessEvent_Call

func (*IProjection_ProcessEvent_Call) RunAndReturn 

func (_c *IProjection_ProcessEvent_Call) RunAndReturn(run func(context.Context, *models.StreamEvent) error) *IProjection_ProcessEvent_Call

type SubscriptionCheckpointRepository 

type SubscriptionCheckpointRepository struct {
	mock.Mock
}

SubscriptionCheckpointRepository is an autogenerated mock type for the SubscriptionCheckpointRepository type

func NewSubscriptionCheckpointRepository 

func NewSubscriptionCheckpointRepository(t interface {
	mock.TestingT
	Cleanup(func())
}) *SubscriptionCheckpointRepository

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

func (*SubscriptionCheckpointRepository) EXPECT 

func (_m *SubscriptionCheckpointRepository) EXPECT() *SubscriptionCheckpointRepository_Expecter

func (*SubscriptionCheckpointRepository) Load 

func (_m *SubscriptionCheckpointRepository) Load(subscriptionId string, ctx context.Context) (uint64, error)

Load provides a mock function with given fields: subscriptionId, ctx

func (*SubscriptionCheckpointRepository) Store 

func (_m *SubscriptionCheckpointRepository) Store(subscriptionId string, position uint64, ctx context.Context) error

Store provides a mock function with given fields: subscriptionId, position, ctx

type SubscriptionCheckpointRepository_Expecter 

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

func (*SubscriptionCheckpointRepository_Expecter) Load 

func (_e *SubscriptionCheckpointRepository_Expecter) Load(subscriptionId interface{}, ctx interface{}) *SubscriptionCheckpointRepository_Load_Call

Load is a helper method to define mock.On call

  • subscriptionId string
  • ctx context.Context

func (*SubscriptionCheckpointRepository_Expecter) Store 

func (_e *SubscriptionCheckpointRepository_Expecter) Store(subscriptionId interface{}, position interface{}, ctx interface{}) *SubscriptionCheckpointRepository_Store_Call

Store is a helper method to define mock.On call

  • subscriptionId string
  • position uint64
  • ctx context.Context

type SubscriptionCheckpointRepository_Load_Call 

type SubscriptionCheckpointRepository_Load_Call struct {
	*mock.Call
}

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

func (*SubscriptionCheckpointRepository_Load_Call) Return 

func (_c *SubscriptionCheckpointRepository_Load_Call) Return(_a0 uint64, _a1 error) *SubscriptionCheckpointRepository_Load_Call

func (*SubscriptionCheckpointRepository_Load_Call) Run 

func (_c *SubscriptionCheckpointRepository_Load_Call) Run(run func(subscriptionId string, ctx context.Context)) *SubscriptionCheckpointRepository_Load_Call

func (*SubscriptionCheckpointRepository_Load_Call) RunAndReturn 

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

type SubscriptionCheckpointRepository_Store_Call 

type SubscriptionCheckpointRepository_Store_Call struct {
	*mock.Call
}

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

func (*SubscriptionCheckpointRepository_Store_Call) Return 

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

func (*SubscriptionCheckpointRepository_Store_Call) Run 

func (_c *SubscriptionCheckpointRepository_Store_Call) Run(run func(subscriptionId string, position uint64, ctx context.Context)) *SubscriptionCheckpointRepository_Store_Call

func (*SubscriptionCheckpointRepository_Store_Call) RunAndReturn 

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

type When 

type When struct {
	mock.Mock
}

When is an autogenerated mock type for the When type

func NewWhen 

func NewWhen(t interface {
	mock.TestingT
	Cleanup(func())
}) *When

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

func (*When) EXPECT 

func (_m *When) EXPECT() *When_Expecter

func (*When) When 

func (_m *When) When(event domain.IDomainEvent) error

When provides a mock function with given fields: event

type WhenFunc 

type WhenFunc struct {
	mock.Mock
}

WhenFunc is an autogenerated mock type for the WhenFunc type

func NewWhenFunc 

func NewWhenFunc(t interface {
	mock.TestingT
	Cleanup(func())
}) *WhenFunc

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

func (*WhenFunc) EXPECT 

func (_m *WhenFunc) EXPECT() *WhenFunc_Expecter

func (*WhenFunc) Execute 

func (_m *WhenFunc) Execute(event domain.IDomainEvent) error

Execute provides a mock function with given fields: event

type WhenFunc_Execute_Call 

type WhenFunc_Execute_Call struct {
	*mock.Call
}

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

func (*WhenFunc_Execute_Call) Return 

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

func (*WhenFunc_Execute_Call) Run 

func (_c *WhenFunc_Execute_Call) Run(run func(event domain.IDomainEvent)) *WhenFunc_Execute_Call

func (*WhenFunc_Execute_Call) RunAndReturn 

func (_c *WhenFunc_Execute_Call) RunAndReturn(run func(domain.IDomainEvent) error) *WhenFunc_Execute_Call

type WhenFunc_Expecter 

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

func (*WhenFunc_Expecter) Execute 

func (_e *WhenFunc_Expecter) Execute(event interface{}) *WhenFunc_Execute_Call

Execute is a helper method to define mock.On call

  • event domain.IDomainEvent

type When_Expecter 

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

func (*When_Expecter) When 

func (_e *When_Expecter) When(event interface{}) *When_When_Call

When is a helper method to define mock.On call

  • event domain.IDomainEvent

type When_When_Call 

type When_When_Call struct {
	*mock.Call
}

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

func (*When_When_Call) Return 

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

func (*When_When_Call) Run 

func (_c *When_When_Call) Run(run func(event domain.IDomainEvent)) *When_When_Call

func (*When_When_Call) RunAndReturn 

func (_c *When_When_Call) RunAndReturn(run func(domain.IDomainEvent) error) *When_When_Call

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.