IEventSourcedAggregateRoot.go

// Code generated by mockery v2.30.16. DO NOT EDIT.

package mocks

import (
	domain "github.com/mehdihadeli/go-ecommerce-microservices/internal/pkg/core/domain"
	metadata "github.com/mehdihadeli/go-ecommerce-microservices/internal/pkg/core/metadata"

	mock "github.com/stretchr/testify/mock"

	time "time"

	uuid "github.com/satori/go.uuid"
)

// IEventSourcedAggregateRoot is an autogenerated mock type for the IEventSourcedAggregateRoot type
type IEventSourcedAggregateRoot struct {
	mock.Mock
}

type IEventSourcedAggregateRoot_Expecter struct {
	mock *mock.Mock
}

func (_m *IEventSourcedAggregateRoot) EXPECT() *IEventSourcedAggregateRoot_Expecter {
	return &IEventSourcedAggregateRoot_Expecter{mock: &_m.Mock}
}

// AddDomainEvents provides a mock function with given fields: event
func (_m *IEventSourcedAggregateRoot) AddDomainEvents(event domain.IDomainEvent) error {
	ret := _m.Called(event)

	var r0 error
	if rf, ok := ret.Get(0).(func(domain.IDomainEvent) error); ok {
		r0 = rf(event)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// AddDomainEvents is a helper method to define mock.On call
//   - event domain.IDomainEvent
func (_e *IEventSourcedAggregateRoot_Expecter) AddDomainEvents(event interface{}) *IEventSourcedAggregateRoot_AddDomainEvents_Call {
	return &IEventSourcedAggregateRoot_AddDomainEvents_Call{Call: _e.mock.On("AddDomainEvents", event)}
}

func (_c *IEventSourcedAggregateRoot_AddDomainEvents_Call) Run(run func(event domain.IDomainEvent)) *IEventSourcedAggregateRoot_AddDomainEvents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(domain.IDomainEvent))
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_AddDomainEvents_Call) Return(_a0 error) *IEventSourcedAggregateRoot_AddDomainEvents_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_AddDomainEvents_Call) RunAndReturn(run func(domain.IDomainEvent) error) *IEventSourcedAggregateRoot_AddDomainEvents_Call {
	_c.Call.Return(run)
	return _c
}

// Apply provides a mock function with given fields: event, isNew
func (_m *IEventSourcedAggregateRoot) Apply(event domain.IDomainEvent, isNew bool) error {
	ret := _m.Called(event, isNew)

	var r0 error
	if rf, ok := ret.Get(0).(func(domain.IDomainEvent, bool) error); ok {
		r0 = rf(event, isNew)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Apply is a helper method to define mock.On call
//   - event domain.IDomainEvent
//   - isNew bool
func (_e *IEventSourcedAggregateRoot_Expecter) Apply(event interface{}, isNew interface{}) *IEventSourcedAggregateRoot_Apply_Call {
	return &IEventSourcedAggregateRoot_Apply_Call{Call: _e.mock.On("Apply", event, isNew)}
}

func (_c *IEventSourcedAggregateRoot_Apply_Call) Run(run func(event domain.IDomainEvent, isNew bool)) *IEventSourcedAggregateRoot_Apply_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(domain.IDomainEvent), args[1].(bool))
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_Apply_Call) Return(_a0 error) *IEventSourcedAggregateRoot_Apply_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_Apply_Call) RunAndReturn(run func(domain.IDomainEvent, bool) error) *IEventSourcedAggregateRoot_Apply_Call {
	_c.Call.Return(run)
	return _c
}

// CreatedAt provides a mock function with given fields:
func (_m *IEventSourcedAggregateRoot) CreatedAt() time.Time {
	ret := _m.Called()

	var r0 time.Time
	if rf, ok := ret.Get(0).(func() time.Time); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(time.Time)
	}

	return r0
}

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

// CreatedAt is a helper method to define mock.On call
func (_e *IEventSourcedAggregateRoot_Expecter) CreatedAt() *IEventSourcedAggregateRoot_CreatedAt_Call {
	return &IEventSourcedAggregateRoot_CreatedAt_Call{Call: _e.mock.On("CreatedAt")}
}

func (_c *IEventSourcedAggregateRoot_CreatedAt_Call) Run(run func()) *IEventSourcedAggregateRoot_CreatedAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_CreatedAt_Call) Return(_a0 time.Time) *IEventSourcedAggregateRoot_CreatedAt_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_CreatedAt_Call) RunAndReturn(run func() time.Time) *IEventSourcedAggregateRoot_CreatedAt_Call {
	_c.Call.Return(run)
	return _c
}

// CurrentVersion provides a mock function with given fields:
func (_m *IEventSourcedAggregateRoot) CurrentVersion() int64 {
	ret := _m.Called()

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

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

// CurrentVersion is a helper method to define mock.On call
func (_e *IEventSourcedAggregateRoot_Expecter) CurrentVersion() *IEventSourcedAggregateRoot_CurrentVersion_Call {
	return &IEventSourcedAggregateRoot_CurrentVersion_Call{Call: _e.mock.On("CurrentVersion")}
}

func (_c *IEventSourcedAggregateRoot_CurrentVersion_Call) Run(run func()) *IEventSourcedAggregateRoot_CurrentVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_CurrentVersion_Call) Return(_a0 int64) *IEventSourcedAggregateRoot_CurrentVersion_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_CurrentVersion_Call) RunAndReturn(run func() int64) *IEventSourcedAggregateRoot_CurrentVersion_Call {
	_c.Call.Return(run)
	return _c
}

// HasUncommittedEvents provides a mock function with given fields:
func (_m *IEventSourcedAggregateRoot) HasUncommittedEvents() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// HasUncommittedEvents is a helper method to define mock.On call
func (_e *IEventSourcedAggregateRoot_Expecter) HasUncommittedEvents() *IEventSourcedAggregateRoot_HasUncommittedEvents_Call {
	return &IEventSourcedAggregateRoot_HasUncommittedEvents_Call{Call: _e.mock.On("HasUncommittedEvents")}
}

func (_c *IEventSourcedAggregateRoot_HasUncommittedEvents_Call) Run(run func()) *IEventSourcedAggregateRoot_HasUncommittedEvents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_HasUncommittedEvents_Call) Return(_a0 bool) *IEventSourcedAggregateRoot_HasUncommittedEvents_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_HasUncommittedEvents_Call) RunAndReturn(run func() bool) *IEventSourcedAggregateRoot_HasUncommittedEvents_Call {
	_c.Call.Return(run)
	return _c
}

// Id provides a mock function with given fields:
func (_m *IEventSourcedAggregateRoot) Id() uuid.UUID {
	ret := _m.Called()

	var r0 uuid.UUID
	if rf, ok := ret.Get(0).(func() uuid.UUID); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(uuid.UUID)
		}
	}

	return r0
}

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

// Id is a helper method to define mock.On call
func (_e *IEventSourcedAggregateRoot_Expecter) Id() *IEventSourcedAggregateRoot_Id_Call {
	return &IEventSourcedAggregateRoot_Id_Call{Call: _e.mock.On("Id")}
}

func (_c *IEventSourcedAggregateRoot_Id_Call) Run(run func()) *IEventSourcedAggregateRoot_Id_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_Id_Call) Return(_a0 uuid.UUID) *IEventSourcedAggregateRoot_Id_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_Id_Call) RunAndReturn(run func() uuid.UUID) *IEventSourcedAggregateRoot_Id_Call {
	_c.Call.Return(run)
	return _c
}

// LoadFromHistory provides a mock function with given fields: events, _a1
func (_m *IEventSourcedAggregateRoot) LoadFromHistory(events []domain.IDomainEvent, _a1 metadata.Metadata) error {
	ret := _m.Called(events, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func([]domain.IDomainEvent, metadata.Metadata) error); ok {
		r0 = rf(events, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// LoadFromHistory is a helper method to define mock.On call
//   - events []domain.IDomainEvent
//   - _a1 metadata.Metadata
func (_e *IEventSourcedAggregateRoot_Expecter) LoadFromHistory(events interface{}, _a1 interface{}) *IEventSourcedAggregateRoot_LoadFromHistory_Call {
	return &IEventSourcedAggregateRoot_LoadFromHistory_Call{Call: _e.mock.On("LoadFromHistory", events, _a1)}
}

func (_c *IEventSourcedAggregateRoot_LoadFromHistory_Call) Run(run func(events []domain.IDomainEvent, _a1 metadata.Metadata)) *IEventSourcedAggregateRoot_LoadFromHistory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]domain.IDomainEvent), args[1].(metadata.Metadata))
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_LoadFromHistory_Call) Return(_a0 error) *IEventSourcedAggregateRoot_LoadFromHistory_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_LoadFromHistory_Call) RunAndReturn(run func([]domain.IDomainEvent, metadata.Metadata) error) *IEventSourcedAggregateRoot_LoadFromHistory_Call {
	_c.Call.Return(run)
	return _c
}

// MarkUncommittedEventAsCommitted provides a mock function with given fields:
func (_m *IEventSourcedAggregateRoot) MarkUncommittedEventAsCommitted() {
	_m.Called()
}

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

// MarkUncommittedEventAsCommitted is a helper method to define mock.On call
func (_e *IEventSourcedAggregateRoot_Expecter) MarkUncommittedEventAsCommitted() *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call {
	return &IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call{Call: _e.mock.On("MarkUncommittedEventAsCommitted")}
}

func (_c *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call) Run(run func()) *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call) Return() *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call {
	_c.Call.Return()
	return _c
}

func (_c *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call) RunAndReturn(run func()) *IEventSourcedAggregateRoot_MarkUncommittedEventAsCommitted_Call {
	_c.Call.Return(run)
	return _c
}

// OriginalVersion provides a mock function with given fields:
func (_m *IEventSourcedAggregateRoot) OriginalVersion() int64 {
	ret := _m.Called()

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

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

// OriginalVersion is a helper method to define mock.On call
func (_e *IEventSourcedAggregateRoot_Expecter) OriginalVersion() *IEventSourcedAggregateRoot_OriginalVersion_Call {
	return &IEventSourcedAggregateRoot_OriginalVersion_Call{Call: _e.mock.On("OriginalVersion")}
}

func (_c *IEventSourcedAggregateRoot_OriginalVersion_Call) Run(run func()) *IEventSourcedAggregateRoot_OriginalVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_OriginalVersion_Call) Return(_a0 int64) *IEventSourcedAggregateRoot_OriginalVersion_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_OriginalVersion_Call) RunAndReturn(run func() int64) *IEventSourcedAggregateRoot_OriginalVersion_Call {
	_c.Call.Return(run)
	return _c
}

// SetEntityType provides a mock function with given fields: entityType
func (_m *IEventSourcedAggregateRoot) SetEntityType(entityType string) {
	_m.Called(entityType)
}

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

// SetEntityType is a helper method to define mock.On call
//   - entityType string
func (_e *IEventSourcedAggregateRoot_Expecter) SetEntityType(entityType interface{}) *IEventSourcedAggregateRoot_SetEntityType_Call {
	return &IEventSourcedAggregateRoot_SetEntityType_Call{Call: _e.mock.On("SetEntityType", entityType)}
}

func (_c *IEventSourcedAggregateRoot_SetEntityType_Call) Run(run func(entityType string)) *IEventSourcedAggregateRoot_SetEntityType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_SetEntityType_Call) Return() *IEventSourcedAggregateRoot_SetEntityType_Call {
	_c.Call.Return()
	return _c
}

func (_c *IEventSourcedAggregateRoot_SetEntityType_Call) RunAndReturn(run func(string)) *IEventSourcedAggregateRoot_SetEntityType_Call {
	_c.Call.Return(run)
	return _c
}

// SetId provides a mock function with given fields: id
func (_m *IEventSourcedAggregateRoot) SetId(id uuid.UUID) {
	_m.Called(id)
}

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

// SetId is a helper method to define mock.On call
//   - id uuid.UUID
func (_e *IEventSourcedAggregateRoot_Expecter) SetId(id interface{}) *IEventSourcedAggregateRoot_SetId_Call {
	return &IEventSourcedAggregateRoot_SetId_Call{Call: _e.mock.On("SetId", id)}
}

func (_c *IEventSourcedAggregateRoot_SetId_Call) Run(run func(id uuid.UUID)) *IEventSourcedAggregateRoot_SetId_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(uuid.UUID))
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_SetId_Call) Return() *IEventSourcedAggregateRoot_SetId_Call {
	_c.Call.Return()
	return _c
}

func (_c *IEventSourcedAggregateRoot_SetId_Call) RunAndReturn(run func(uuid.UUID)) *IEventSourcedAggregateRoot_SetId_Call {
	_c.Call.Return(run)
	return _c
}

// SetOriginalVersion provides a mock function with given fields: version
func (_m *IEventSourcedAggregateRoot) SetOriginalVersion(version int64) {
	_m.Called(version)
}

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

// SetOriginalVersion is a helper method to define mock.On call
//   - version int64
func (_e *IEventSourcedAggregateRoot_Expecter) SetOriginalVersion(version interface{}) *IEventSourcedAggregateRoot_SetOriginalVersion_Call {
	return &IEventSourcedAggregateRoot_SetOriginalVersion_Call{Call: _e.mock.On("SetOriginalVersion", version)}
}

func (_c *IEventSourcedAggregateRoot_SetOriginalVersion_Call) Run(run func(version int64)) *IEventSourcedAggregateRoot_SetOriginalVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(int64))
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_SetOriginalVersion_Call) Return() *IEventSourcedAggregateRoot_SetOriginalVersion_Call {
	_c.Call.Return()
	return _c
}

func (_c *IEventSourcedAggregateRoot_SetOriginalVersion_Call) RunAndReturn(run func(int64)) *IEventSourcedAggregateRoot_SetOriginalVersion_Call {
	_c.Call.Return(run)
	return _c
}

// SetUpdatedAt provides a mock function with given fields: updatedAt
func (_m *IEventSourcedAggregateRoot) SetUpdatedAt(updatedAt time.Time) {
	_m.Called(updatedAt)
}

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

// SetUpdatedAt is a helper method to define mock.On call
//   - updatedAt time.Time
func (_e *IEventSourcedAggregateRoot_Expecter) SetUpdatedAt(updatedAt interface{}) *IEventSourcedAggregateRoot_SetUpdatedAt_Call {
	return &IEventSourcedAggregateRoot_SetUpdatedAt_Call{Call: _e.mock.On("SetUpdatedAt", updatedAt)}
}

func (_c *IEventSourcedAggregateRoot_SetUpdatedAt_Call) Run(run func(updatedAt time.Time)) *IEventSourcedAggregateRoot_SetUpdatedAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(time.Time))
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_SetUpdatedAt_Call) Return() *IEventSourcedAggregateRoot_SetUpdatedAt_Call {
	_c.Call.Return()
	return _c
}

func (_c *IEventSourcedAggregateRoot_SetUpdatedAt_Call) RunAndReturn(run func(time.Time)) *IEventSourcedAggregateRoot_SetUpdatedAt_Call {
	_c.Call.Return(run)
	return _c
}

// UncommittedEvents provides a mock function with given fields:
func (_m *IEventSourcedAggregateRoot) UncommittedEvents() []domain.IDomainEvent {
	ret := _m.Called()

	var r0 []domain.IDomainEvent
	if rf, ok := ret.Get(0).(func() []domain.IDomainEvent); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]domain.IDomainEvent)
		}
	}

	return r0
}

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

// UncommittedEvents is a helper method to define mock.On call
func (_e *IEventSourcedAggregateRoot_Expecter) UncommittedEvents() *IEventSourcedAggregateRoot_UncommittedEvents_Call {
	return &IEventSourcedAggregateRoot_UncommittedEvents_Call{Call: _e.mock.On("UncommittedEvents")}
}

func (_c *IEventSourcedAggregateRoot_UncommittedEvents_Call) Run(run func()) *IEventSourcedAggregateRoot_UncommittedEvents_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_UncommittedEvents_Call) Return(_a0 []domain.IDomainEvent) *IEventSourcedAggregateRoot_UncommittedEvents_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_UncommittedEvents_Call) RunAndReturn(run func() []domain.IDomainEvent) *IEventSourcedAggregateRoot_UncommittedEvents_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatedAt provides a mock function with given fields:
func (_m *IEventSourcedAggregateRoot) UpdatedAt() time.Time {
	ret := _m.Called()

	var r0 time.Time
	if rf, ok := ret.Get(0).(func() time.Time); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(time.Time)
	}

	return r0
}

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

// UpdatedAt is a helper method to define mock.On call
func (_e *IEventSourcedAggregateRoot_Expecter) UpdatedAt() *IEventSourcedAggregateRoot_UpdatedAt_Call {
	return &IEventSourcedAggregateRoot_UpdatedAt_Call{Call: _e.mock.On("UpdatedAt")}
}

func (_c *IEventSourcedAggregateRoot_UpdatedAt_Call) Run(run func()) *IEventSourcedAggregateRoot_UpdatedAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_UpdatedAt_Call) Return(_a0 time.Time) *IEventSourcedAggregateRoot_UpdatedAt_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_UpdatedAt_Call) RunAndReturn(run func() time.Time) *IEventSourcedAggregateRoot_UpdatedAt_Call {
	_c.Call.Return(run)
	return _c
}

// fold provides a mock function with given fields: event, _a1
func (_m *IEventSourcedAggregateRoot) fold(event domain.IDomainEvent, _a1 metadata.Metadata) error {
	ret := _m.Called(event, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(domain.IDomainEvent, metadata.Metadata) error); ok {
		r0 = rf(event, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// fold is a helper method to define mock.On call
//   - event domain.IDomainEvent
//   - _a1 metadata.Metadata
func (_e *IEventSourcedAggregateRoot_Expecter) fold(event interface{}, _a1 interface{}) *IEventSourcedAggregateRoot_fold_Call {
	return &IEventSourcedAggregateRoot_fold_Call{Call: _e.mock.On("fold", event, _a1)}
}

func (_c *IEventSourcedAggregateRoot_fold_Call) Run(run func(event domain.IDomainEvent, _a1 metadata.Metadata)) *IEventSourcedAggregateRoot_fold_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(domain.IDomainEvent), args[1].(metadata.Metadata))
	})
	return _c
}

func (_c *IEventSourcedAggregateRoot_fold_Call) Return(_a0 error) *IEventSourcedAggregateRoot_fold_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *IEventSourcedAggregateRoot_fold_Call) RunAndReturn(run func(domain.IDomainEvent, metadata.Metadata) error) *IEventSourcedAggregateRoot_fold_Call {
	_c.Call.Return(run)
	return _c
}

// 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 NewIEventSourcedAggregateRoot(t interface {
	mock.TestingT
	Cleanup(func())
}) *IEventSourcedAggregateRoot {
	mock := &IEventSourcedAggregateRoot{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}