public void Saving_event_source_while_there_is_a_newer_event_source_should_throw_concurency_exception()
{
var targetStore = new RavenDBEventStore(_documentStore);
var id = Guid.NewGuid();
int sequenceCounter = 0;
var events = new SourcedEvent[]
{
new CustomerCreatedEvent(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow, "Foo",
35),
new CustomerNameChanged(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow,
"Name" + sequenceCounter)
};
var eventSource = MockRepository.GenerateMock <IEventSource>();
eventSource.Stub(e => e.EventSourceId).Return(id).Repeat.Any();
eventSource.Stub(e => e.InitialVersion).Return(0).Repeat.Any();
eventSource.Stub(e => e.Version).Return(events.Length).Repeat.Any();
eventSource.Stub(e => e.GetUncommittedEvents()).Return(events).Repeat.Any();
targetStore.Save(eventSource);
Action act = () => targetStore.Save(eventSource);
act.ShouldThrow <ConcurrencyException>();
}
public void Retrieved_event_should_having_identical_timestamp_as_persisted()
{
var id = Guid.NewGuid();
var utcNow = DateTime.UtcNow.Date.AddHours(9).AddTicks(-1);
var events = new SourcedEvent[]
{
new CustomerCreatedEvent(Guid.NewGuid(), id, 0, utcNow, "Foo", 35)
};
var eventSource = MockRepository.GenerateMock <IEventSource>();
eventSource.Stub(e => e.EventSourceId).Return(id);
eventSource.Stub(e => e.InitialVersion).Return(0);
eventSource.Stub(e => e.Version).Return(events.Length);
eventSource.Stub(e => e.GetUncommittedEvents()).Return(events);
_store.Save(eventSource);
using (var conn = new SQLiteConnection(_connString))
{
conn.Open();
using (var cmd = new SQLiteCommand("SELECT [TimeStamp] FROM [Events]", conn))
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var timestamp = (long)reader["Timestamp"];
timestamp.Should().Be(utcNow.Ticks);
}
}
}
}
public void Rolling_back_transaction_should_remove_inserted_rows()
{
var id = Guid.NewGuid();
var utcNow = DateTime.UtcNow.Date.AddHours(9).AddTicks(-1);
var events = new SourcedEvent[]
{
new CustomerCreatedEvent(Guid.NewGuid(), id, 0, utcNow, "Foo", 35)
};
var eventSource = MockRepository.GenerateMock <IEventSource>();
eventSource.Stub(e => e.EventSourceId).Return(id);
eventSource.Stub(e => e.InitialVersion).Return(0);
eventSource.Stub(e => e.Version).Return(events.Length);
eventSource.Stub(e => e.GetUncommittedEvents()).Return(events);
_store.Save(eventSource);
_transaction.Rollback();
using (var conn = new SQLiteConnection(_connString))
{
conn.Open();
using (var cmd = new SQLiteCommand("SELECT [TimeStamp] FROM [Events]", conn))
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
Assert.Fail("No rows should exist");
}
}
}
}
public void Retrieving_all_events_should_return_the_same_as_added()
{
var targetStore = new RavenDBEventStore(_documentStore);
var id = Guid.NewGuid();
int sequenceCounter = 0;
var events = new SourcedEvent[]
{
new CustomerCreatedEvent(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow, "Foo",
35),
new CustomerNameChanged(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow,
"Name" + sequenceCounter),
new CustomerNameChanged(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow,
"Name" + sequenceCounter),
new CustomerNameChanged(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow,
"Name" + sequenceCounter)
};
var eventSource = MockRepository.GenerateMock <IEventSource>();
eventSource.Stub(e => e.EventSourceId).Return(id);
eventSource.Stub(e => e.InitialVersion).Return(0);
eventSource.Stub(e => e.Version).Return(events.Length);
eventSource.Stub(e => e.GetUncommittedEvents()).Return(events);
targetStore.Save(eventSource);
var result = targetStore.GetAllEvents(id);
result.Count().Should().Be(events.Length);
result.First().EventIdentifier.Should().Be(events.First().EventIdentifier);
Assert.IsTrue(result.SequenceEqual(events));
}
/// <summary>
/// Get some events after specified event.
/// </summary>
/// <param name="eventId">The id of last event not to be included in result set.</param>
/// <param name="maxCount">Maximum numer of returned events</param>
/// <returns>A collection events starting right after <paramref name="eventId"/>.</returns>
public IEnumerable <SourcedEvent> GetEventsAfter(Guid?eventId, int maxCount)
{
var result = new List <SourcedEvent>();
// Create connection and command.
using (var connection = new SqlConnection(_connectionString))
{
var query = eventId.HasValue
? Queries.SelectEventsAfterQuery
: Queries.SelectEventsFromBeginningOfTime;
using (var command = new SqlCommand(string.Format(query, maxCount), connection))
{
if (eventId.HasValue)
{
command.Parameters.AddWithValue("EventId", eventId);
}
connection.Open();
// Execute query and create reader.
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
SourcedEvent evnt = ReadSourcedEvent(reader);
result.Add(evnt);
}
}
}
}
return(result);
}
/// <summary>
/// Get all events provided by an specified event source.
/// </summary>
/// <param name="eventSourceId">The id of the event source that owns the events.</param>
/// <returns>All the events from the event source.</returns>
public IEnumerable <ISourcedEvent> GetAllEventsSinceVersion(Guid id, long version)
{
var result = new List <ISourcedEvent>();
// Create connection and command.
using (var connection = new SqlConnection(_connectionString))
using (var command = new SqlCommand(Queries.SelectAllEventsQuery, connection))
{
// Add EventSourceId parameter and open connection.
command.Parameters.AddWithValue("EventSourceId", id);
command.Parameters.AddWithValue("EventSourceVersion", version);
connection.Open();
// Execute query and create reader.
using (SqlDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
SourcedEvent evnt = ReadSourcedEvent(reader);
result.Add(evnt);
}
}
}
return(result);
}
[SetUp] // TODO: Testdriven.net debug runner doesn't recognize inhiret attributes. Use native for now.
public void Setup()
{
SetupDependencies();
var commandService = BuildCommandService();
PublishedEvents = new SourcedEvent[0];
try
{
var command = WhenExecutingCommand();
using (var context = new EventContext())
{
commandService.Execute(command);
ExecutedCommand = command;
PublishedEvents = context.Events;
}
}
catch (Exception exception)
{
CaughtException = exception;
}
finally
{
Finally();
}
}
public void Saving_event_source_should_succeed()
{
var targetStore = new RavenDBEventStore(_documentStore);
var id = Guid.NewGuid();
int sequenceCounter = 0;
var events = new SourcedEvent[]
{
new CustomerCreatedEvent(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow, "Foo",
35),
new CustomerNameChanged(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow,
"Name" + sequenceCounter),
new CustomerNameChanged(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow,
"Name" + sequenceCounter),
new CustomerNameChanged(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow,
"Name" + sequenceCounter)
};
var eventSource = MockRepository.GenerateMock <IEventSource>();
eventSource.Stub(e => e.EventSourceId).Return(id);
eventSource.Stub(e => e.InitialVersion).Return(0);
eventSource.Stub(e => e.Version).Return(events.Length);
eventSource.Stub(e => e.GetUncommittedEvents()).Return(events);
targetStore.Save(eventSource);
}
public void Initializing_from_history_should_not_throw_an_exception_when_the_history_was_empty()
{
var theAggregate = new MyAggregateRoot();
IEnumerable <SourcedEvent> history = new SourcedEvent[0];
theAggregate.InitializeFromHistory(history);
}
static void Process(SourcedEvent evnt)
{
Thread.Sleep(200);
Interlocked.Increment(ref _processedEvents);
Console.WriteLine("Processing event {0} (id {1})", evnt.EventSequence, evnt.EventIdentifier);
_bus.Publish(evnt);
}
private void ExecuteEvent(SourcedEvent e)
{
var method = this.GetType()
.GetMethods()
.Single(m =>
m.Name == "OnEvent" && m.GetParameters().Length == 1 &&
m.GetParameters().First().ParameterType == e.GetType());
method.Invoke(this, new[] { e });
}
public static SourcedEvent CreateSourcedEvent(this EventMessage @from)
{
var @event = new SourcedEvent
{
Body = @from.Body
};
@from.Headers.ForEach(h => @event.Headers.Add(h.Key, h.Value));
return(@event);
}
public void StoreEvent(SourcedEvent @event, EventStreamId aggregateRootId)
{
var uncommittedEvent = new EventMessage
{
Body = @event.Body
};
@event.Headers.ForEach(h => uncommittedEvent.Headers.Add(h.Key, h.Value));
GetStream(aggregateRootId).Add(uncommittedEvent);
}
private TableEventModel MapToAzureModel(SourcedEvent @event)
{
return(new TableEventModel {
RowKey = @event.EventId.ToString(),
PartitionKey = @event.Metadata.AggregateId.ToString(),
EventTypeHint = modelSerializer.GetTypeHint(@event),
EventDate = @event.Metadata.Date,
EventVersion = (long)@event.Metadata.Version,
CommandId = @event.Metadata.CommandId,
EventJsonData = modelSerializer.Serialize(@event)
});
}
public void RestoreEvent(SourcedEvent e)
{
if (Metadata.Version != 0)
{
if (Metadata.Version != e.Metadata.Version - 1)
{
throw new DungeonEventRestoreException("Version problem.");
}
}
ExecuteEvent(e);
Metadata.Version = e.Metadata.Version;
}
public void Save_SmokeTest()
{
var sequenceCounter = 0;
var id = Guid.NewGuid();
var events = new SourcedEvent[] {
new CustomerCreatedEvent(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow, "Foo", 35),
new CustomerNameChanged(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow, "Name" + sequenceCounter),
new CustomerNameChanged(Guid.NewGuid(), id, sequenceCounter++, DateTime.UtcNow, "Name" + sequenceCounter)
};
var source = MockRepository.GenerateMock <IEventSource>();
source.Stub(e => e.EventSourceId).Return(id);
source.Stub(e => e.InitialVersion).Return(0);
source.Stub(e => e.Version).Return(events.Length);
source.Stub(e => e.GetUncommittedEvents()).Return(events);
_store.Save(source);
}
public void Retrieving_all_events_should_return_the_same_as_added()
{
var targetStore = new MsSqlServerEventStore(connectionString);
var aggregateId = Guid.NewGuid();
var entityId = Guid.NewGuid();
int sequenceCounter = 1;
var events = new SourcedEvent[]
{
new CustomerCreatedEvent(Guid.NewGuid(), aggregateId, sequenceCounter++, DateTime.UtcNow, "Foo",
35),
new CustomerNameChanged(Guid.NewGuid(), aggregateId, sequenceCounter++, DateTime.UtcNow,
"Name" + sequenceCounter),
new CustomerNameChanged(Guid.NewGuid(), aggregateId, sequenceCounter++, DateTime.UtcNow,
"Name" + sequenceCounter),
new CustomerNameChanged(Guid.NewGuid(), aggregateId, sequenceCounter++, DateTime.UtcNow,
"Name" + sequenceCounter),
new AccountNameChangedEvent(Guid.NewGuid(), aggregateId, entityId, sequenceCounter++, DateTime.UtcNow, "New Account Title" + sequenceCounter)
};
var eventSource = MockRepository.GenerateMock <IEventSource>();
eventSource.Stub(e => e.EventSourceId).Return(aggregateId);
eventSource.Stub(e => e.InitialVersion).Return(0);
eventSource.Stub(e => e.Version).Return(events.Length);
eventSource.Stub(e => e.GetUncommittedEvents()).Return(events);
targetStore.Save(eventSource);
var result = targetStore.GetAllEvents(aggregateId);
result.Count().Should().Be(events.Length);
result.First().EventIdentifier.Should().Be(events.First().EventIdentifier);
var foundEntityId = result.ElementAt(4).As <SourcedEntityEvent>().EntityId;
foundEntityId.Should().Be(entityId);
}
public SourcedEventProcessingElement(int sequenceNumber, SourcedEvent @event)
{
SequenceNumber = sequenceNumber;
_event = @event;
}
public SourcedEventProcessingElement(SourcedEvent @event)
{
_event = @event;
}
static void OutputEvent(SourcedEvent e)
{
Trace.TraceInformation(e.Body.ToString());
}
private void CatchAllEventHandler(SourcedEvent e)
{
CatchAllEventHandlerInvokeCount++;
}
public void MyEventHandlerMethod(SourcedEvent e1, SourcedEvent e2)
{
}
public static void MyEventHandlerMethod(SourcedEvent e)
{
}
public void StoreEvent(SourcedEvent @event, string id)
{
}
public static void OnDomainEvent(SourcedEvent e)
{
}
public void StoreEvent(SourcedEvent @event, EventStreamId aggregateRootId)
{
GetStream(aggregateRootId).Add(@event);
}
public void OnDomainEvent(SourcedEvent e1, SourcedEvent e2)
{
}
protected void Apply(SourcedEvent e)
{
ExecuteEvent(e);
notCommitedEvents.Add(e);
}
public void Add(SourcedEvent @event)
{
uncommittedEvents.Add(@event);
}
private void CatchAllHandler(SourcedEvent e)
{
}
