IHaveEventSourcedAggregate.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"
)

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

type IHaveEventSourcedAggregate_Expecter struct {
	mock *mock.Mock
}

func (_m *IHaveEventSourcedAggregate) EXPECT() *IHaveEventSourcedAggregate_Expecter {
	return &IHaveEventSourcedAggregate_Expecter{mock: &_m.Mock}
}

// AddDomainEvents provides a mock function with given fields: event
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

// Apply provides a mock function with given fields: event, isNew
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

// CreatedAt provides a mock function with given fields:
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

// CurrentVersion provides a mock function with given fields:
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

// HasUncommittedEvents provides a mock function with given fields:
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

// Id provides a mock function with given fields:
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

// LoadFromHistory provides a mock function with given fields: events, _a1
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// NewEmptyAggregate is a helper method to define mock.On call
func (_e *IHaveEventSourcedAggregate_Expecter) NewEmptyAggregate() *IHaveEventSourcedAggregate_NewEmptyAggregate_Call {
	return &IHaveEventSourcedAggregate_NewEmptyAggregate_Call{Call: _e.mock.On("NewEmptyAggregate")}
}

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

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

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

// OriginalVersion provides a mock function with given fields:
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UncommittedEvents provides a mock function with given fields:
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

// UpdatedAt provides a mock function with given fields:
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

// When provides a mock function with given fields: event
func (_m *IHaveEventSourcedAggregate) When(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
}

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

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

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

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

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

// fold provides a mock function with given fields: event, _a1
func (_m *IHaveEventSourcedAggregate) 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
}

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

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

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

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

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

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

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

	return mock
}