mock_event_test.go

// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq

package cqrs_test

import (
	"github.com/google/uuid"
	"sync"
	"github.com/theskyinflames/cqrs-eda/pkg/events"
)

// Ensure, that EventMock does implement events.Event.
// If this is not the case, regenerate this file with moq.
var _ events.Event = &EventMock{}

// EventMock is a mock implementation of events.Event.
//
//	func TestSomethingThatUsesEvent(t *testing.T) {
//
//		// make and configure a mocked events.Event
//		mockedEvent := &EventMock{
//			AggregateIDFunc: func() uuid.UUID {
//				panic("mock out the AggregateID method")
//			},
//			NameFunc: func() string {
//				panic("mock out the Name method")
//			},
//		}
//
//		// use mockedEvent in code that requires events.Event
//		// and then make assertions.
//
//	}
type EventMock struct {
	// AggregateIDFunc mocks the AggregateID method.
	AggregateIDFunc func() uuid.UUID

	// NameFunc mocks the Name method.
	NameFunc func() string

	// calls tracks calls to the methods.
	calls struct {
		// AggregateID holds details about calls to the AggregateID method.
		AggregateID []struct {
		}
		// Name holds details about calls to the Name method.
		Name []struct {
		}
	}
	lockAggregateID sync.RWMutex
	lockName        sync.RWMutex
}

// AggregateID calls AggregateIDFunc.
func (mock *EventMock) AggregateID() uuid.UUID {
	callInfo := struct {
	}{}
	mock.lockAggregateID.Lock()
	mock.calls.AggregateID = append(mock.calls.AggregateID, callInfo)
	mock.lockAggregateID.Unlock()
	if mock.AggregateIDFunc == nil {
		var (
			uUIDOut uuid.UUID
		)
		return uUIDOut
	}
	return mock.AggregateIDFunc()
}

// AggregateIDCalls gets all the calls that were made to AggregateID.
// Check the length with:
//
//	len(mockedEvent.AggregateIDCalls())
func (mock *EventMock) AggregateIDCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockAggregateID.RLock()
	calls = mock.calls.AggregateID
	mock.lockAggregateID.RUnlock()
	return calls
}

// Name calls NameFunc.
func (mock *EventMock) Name() string {
	callInfo := struct {
	}{}
	mock.lockName.Lock()
	mock.calls.Name = append(mock.calls.Name, callInfo)
	mock.lockName.Unlock()
	if mock.NameFunc == nil {
		var (
			sOut string
		)
		return sOut
	}
	return mock.NameFunc()
}

// NameCalls gets all the calls that were made to Name.
// Check the length with:
//
//	len(mockedEvent.NameCalls())
func (mock *EventMock) NameCalls() []struct {
} {
	var calls []struct {
	}
	mock.lockName.RLock()
	calls = mock.calls.Name
	mock.lockName.RUnlock()
	return calls
}