Event Sourcing Facilitates Mock-free Unit Testing

Introduction

One of the advantages of an event sourcing (or event stream) based system is that you can very easily put together a unit test for your projection logic that uses all the same classes that will be used in the production application without any mocks at all.

So long as your event classes and your projection classes are written with no dependency on where the event stream is stored (or received from), then you can put together actual instances of the event and feed them into the projection as part of your testing.

For example, I have a system where a User can receive an "Applause" event which adds to their Reputation cumulatively. The event to record this occurring might look like:

''' <summary>
''' The user has received praise/applause for something they have done
''' </summary>
''' <remarks>
''' This is a general gamification event to reward users for their actions
''' </remarks>
Public NotInheritable Class ApplaudedEvent
    Inherits EventBase
    Implements IEvent(Of AggregateIdentifiers.UserAggregateIdentity)


    ''' <summary>
    ''' The number of applause points added by this event
    ''' </summary>
    ''' <remarks>
    ''' It may be that the points for different types of event get
    ''' changed over time so we don't refer back to what the
    ''' event was but rather store the points awarded
    ''' </remarks>
    <EventVersion(1)>
    Public Property Points As Integer


    ''' <summary>
    ''' A personal message attached to the applause event
    ''' </summary>
    <EventVersion(1)>
    Public Property Message As String

    ''' <summary>
    ''' Who sent the applause
    ''' </summary>
    <EventVersion(1)>
    Public Property SendBy As String

    Public Overrides Function ToString() As String
        Return "Applause received - " & Points.ToString() _
            & " " & Message & " from " & SendBy
    End Function

End Class

This event (and others) can then be fed into a User Summary projection that gives a view of the user as at a given point in time. This works by just applying the effect of each event in turn to the "current state". It might look something like:

''' <summary>
''' Projection over the User event stream to summarize the state of a user
''' </summary>
Public NotInheritable Class UserSummaryProjection

    Inherits ProjectionBase(Of AggregateIdentifiers.UserAggregateIdentity)

    ReadOnly m_identity As AggregateIdentifiers.UserAggregateIdentity

    ''' <summary>
    ''' The aggregate identifier of the client to which this projection applies
    ''' </summary>
    Public Overrides ReadOnly Property Identity As AggregateIdentifiers.UserAggregateIdentity
        Get
            Return m_identity
        End Get
    End Property

    Public Overrides Sub ConsumeEvent(ByVal sequence As Integer, _
ByVal eventToConsume As IEvent(Of AggregateIdentifiers.UserAggregateIdentity))

        If IsPriorEvent(sequence) Then
            ' This projection ignores out-of-sequence events
            Return
        End If

        If (TypeOf (eventToConsume) Is Events.User.CreatedEvent) Then
            Dim userCreated As Events.User.CreatedEvent = eventToConsume
            m_userIdentifier = userCreated.UserIdentifier
            m_emailAddress = userCreated.EmailAddress
        End If

        If (TypeOf (eventToConsume) Is Events.User.AccountEnabledEvent) Then
            m_enabled = True
        End If

        If (TypeOf (eventToConsume) Is Events.User.AccountDisabledEvent) Then
            m_enabled = False
        End If

        If (TypeOf (eventToConsume) Is Events.User.ApplaudedEvent) Then
            Dim userApplauded As Events.User.ApplaudedEvent = eventToConsume
            m_reputationPoints += userApplauded.Points
        End If

        ' Update the current sequence after the event is consumed
        SetSequence(sequence)
    End Sub

    ''' <summary>
    ''' The public unique identifier of the user (could be a user name or company employee code etc.)
    ''' </summary>
    Private m_userIdentifier As String
    Public ReadOnly Property UserIdentifier As String
        Get
            Return m_userIdentifier
        End Get
    End Property

    ''' <summary>
    ''' The email address of the user
    ''' </summary>
    Private m_emailAddress As String
    Public ReadOnly Property EmailAddress As String
        Get
            Return m_emailAddress
        End Get
    End Property

    ''' <summary>
    ''' Is the user enabled or not
    ''' </summary>
    ''' <remarks>
    ''' This allows users to be removed from the system without any data integrity issues
    ''' </remarks>
    Private m_enabled As Boolean
    Public ReadOnly Property Enabled As Boolean
        Get
            Return m_enabled
        End Get
    End Property

    Private m_reputationPoints As Integer
    Public ReadOnly Property ReputationPoints As Integer
        Get
            Return m_reputationPoints
        End Get
    End Property

    Public Sub New(ByVal aggregateidentity As AggregateIdentifiers.UserAggregateIdentity)
        m_identity = aggregateidentity
    End Sub

End Class

This projection has no run-time dependencies outside of the class itself and the events it handles, and this can be unit tested with no mocking or fakes classes something like:

<TestMethod()>
Public Sub ReputationTestMethod()

    Dim expected As Integer = 3
    Dim actual As Integer = 1


    Dim testObj As New Projections.UserSummaryProjection_
    (New AggregateIdentifiers.UserAggregateIdentity("test"))
    ' Run some applauded events in
    testObj.ConsumeEvent(1, New [Event].Events.User.ApplaudedEvent()
               With {.Points = 1, .Message = "Good job man"})
    testObj.ConsumeEvent(2, New [Event].Events.User.ApplaudedEvent()
               With {.Points = 2, .Message = "Agreed", .SendBy = "Duncan"})
    'Throw in an out of sequence one to test it gets ignored
    testObj.ConsumeEvent(0, New [Event].Events.User.ApplaudedEvent()
               With {.Points = 2, .Message = "This is out of sequence", .SendBy = "Duncan"})

    actual = testObj.ReputationPoints

    Assert.AreEqual(expected, actual)

End Sub

This means that you really can have a great deal of confidence in your code as it has all been unit tested.