public void it_should_insert_the_consumption_logs_into_the_store()
{
deleteConsumptionLogTable();
var subject = new TableEventStore(CloudStorageAccount.DevelopmentStorageAccount, "test");
var expectedEvent = new RaisedEvent(
Guid.NewGuid(),
new DummyEvent {Prop = "Property"},
new DateTimeOffset(2013, 01, 17, 12, 06, 39, 967, TimeZoneInfo.Utc.BaseUtcOffset),
"txid");
var expectedConsumptionLog = new ConsumptionLog(
expectedEvent,
expectedEvent.RaisedTimestamp.AddSeconds(1),
new AggregateInfo(typeof (DummyAggregate), 123));
subject.LogConsumption(expectedEvent, expectedConsumptionLog);
var actual = storedConsumptionLogEntity(expectedConsumptionLog);
actual.ShouldNotBeNull();
actual.ConsumedTimestamp.ShouldEqual(expectedConsumptionLog.ConsumedTimestamp);
actual.ConsumptionException.ShouldEqual(expectedConsumptionLog.ConsumptionException);
actual.Event.ShouldEqual(JsonEvent.ConvertToJson(expectedEvent));
actual.EventThumbprint.ShouldEqual(expectedConsumptionLog.EventThumbprint);
}
public async void it_should_insert_the_event_into_the_store()
{
deleteEventStoreTable();
var subject = new TableEventStore(CloudStorageAccount.DevelopmentStorageAccount, "test");
var expected = new RaisedEvent(
Guid.NewGuid(),
new DummyEvent {Prop = "Property"},
new DateTimeOffset(2013, 01, 17, 12, 06, 39, 967, TimeZoneInfo.Utc.BaseUtcOffset),
"txid");
var eventEntity = new EventEntity(expected);
var insert = TableOperation.Insert(eventEntity);
var inserted = Task.Factory.FromAsync<TableOperation, TableResult>(subject.EventStoreTable.BeginExecute,
subject.EventStoreTable.EndExecute, insert, null);
await inserted;
var actual = storedEventEntity(expected);
actual.ShouldNotBeNull();
actual.Event.ShouldEqual(JsonEvent.ConvertToJson(expected));
actual.RaisedTimestamp.ShouldEqual(expected.RaisedTimestamp);
actual.TransactionId.ShouldEqual(expected.TransactionId);
}
public EventEntity(RaisedEvent raisedEvent)
{
PartitionKey = raisedEvent.Thumbprint.ToString();
RowKey = raisedEvent.Event.GetType().FullName;
TransactionId = raisedEvent.TransactionId;
RaisedTimestamp = raisedEvent.RaisedTimestamp;
Event = JsonEvent.ConvertToJson(raisedEvent);
}
public ConsumptionLogEntity(ConsumptionLog consumptionLog, RaisedEvent raisedEvent)
{
PartitionKey = consumptionLog.AffectedAggregate.Type.FullName + "@" + consumptionLog.AffectedAggregate.Key;
RowKey = consumptionLog.ConsumedTimestamp.Ticks.ToString(longPad);
EventThumbprint = raisedEvent.Thumbprint;
ConsumedTimestamp = consumptionLog.ConsumedTimestamp;
ExecutionTime = consumptionLog.ExecutionTime;
ConsumptionException = consumptionLog.ConsumptionException;
Event = JsonEvent.ConvertToJson(raisedEvent);
}
[TestMethod] // Debug this method to be able to see debug output etc.
public async Task WriteData()
{
try
{
await InitApp();
var version = -1;
var dbId = GetRandomString(15);
await _db.CreateDbAsync(dbId); // here we create a random db
var streamKey = $"{dbId}@{0}";
while (true)
{
try
{
var evt = new RaisedEvent(new NoteAdded(0, "someNote")) // create some data, in form of an event
{
SequenceNumber = ++version // protocol way of managing concurrent write to the stream
};
var events = new List <RaisedEvent> {
evt
};
var data = events.Select(e => new EventData(
e.Payload,
Guid.NewGuid(),
Guid.NewGuid(),
e.EventClrType,
e.Id,
e.Name,
e.SequenceNumber,
e.TimeStamp))
.ToList(); // protocol way of how to serialize and package the event data
var batch = new EventBatch(streamKey, Guid.NewGuid(), data); // another protocol way of packaging the data
var res = await _db.StoreBatchAsync(dbId, batch); // store the data to the db
if (res.Error)
{
}
Debug.WriteLine(version); // so we expect to reach ~22-30 entries before sudden crash. Sometimes more, sometimes less.
//await Task.Delay(1000);
}
catch (Exception ex)
{ } // you can put breakpoint here, however, the big problem (and mystery) is that these do not catch anything, program just dies OR a NullReferenceException is reported in logs; "occurred in Unknown Module".
}
}
catch (Exception ex)
{ } // you can put breakpoint here, however, the big problem (and mystery) is that these do not catch anything, program just dies OR a NullReferenceException is reported in logs; "occurred in Unknown Module".
}
static RaisedEvent <T> RaisesInternal <T>(Action <EventHandler <T> > attach, Action <EventHandler <T> > detach, Action testCode)
where T : EventArgs
{
RaisedEvent <T> raisedEvent = null;
EventHandler <T> handler = delegate(object s, T args) { raisedEvent = new RaisedEvent <T>(s, args); };
attach(handler);
testCode();
detach(handler);
return(raisedEvent);
}
static async Task <RaisedEvent <T> > RaisesAsyncInternal <T>(Action <EventHandler <T> > attach, Action <EventHandler <T> > detach, Func <Task> testCode)
where T : EventArgs
{
RaisedEvent <T> raisedEvent = null;
EventHandler <T> handler = delegate(object s, T args) { raisedEvent = new RaisedEvent <T>(s, args); };
attach(handler);
await testCode();
detach(handler);
return(raisedEvent);
}
public virtual void Consume(RaisedEvent raisedEvent)
{
var consumerTasks =
(
from aggregateInfo in applyTo(raisedEvent.Event).ToList()
let consumptionLog = new ConsumptionLog(raisedEvent, DateTimeOffset.UtcNow, aggregateInfo)
select new Task(() => consumeEventOnAggregate(raisedEvent, aggregateInfo, consumptionLog))
).ToList();
//Store the event.
Store.RecordEvent(raisedEvent);
foreach (var task in consumerTasks)
{
task.Start();
}
}
public static RaisedEvent Raises(Action <EventHandler> attach, Action <EventHandler> detach, Action testAction)
{
RaisedEvent raised = null;
attach(OnEventRaised);
testAction();
detach(OnEventRaised);
if (raised is null)
{
throw new RaisesException(typeof(EventArgs));
}
return(raised);
void OnEventRaised(object sender, EventArgs e) => raised = new RaisedEvent(sender, e);
}
public static RaisedEvent <PropertyChangedEventArgs> Raises <T>(
Action <PropertyChangedEventHandler> attach,
Action <PropertyChangedEventHandler> detach,
Action testCode)
where T : PropertyChangedEventArgs
{
RaisedEvent <PropertyChangedEventArgs> raisedEvent = null;
PropertyChangedEventHandler handler = (sender, e)
=> raisedEvent = new RaisedEvent <PropertyChangedEventArgs>(sender, e);
attach(handler);
testCode();
detach(handler);
Assert.IsNotNull(raisedEvent);
return(raisedEvent);
}
private IList <RaisedEvent> RaiseEvents()
{
List <RaisedEvent> raisedEvents = new List <RaisedEvent>();
if (this.Events != null)
{
foreach (string eventName in this.Events)
{
AcmaInternalExitEvent internalEvent = new AcmaInternalExitEvent();
internalEvent.AllowDuplicateIDs = true;
internalEvent.ID = eventName;
RaisedEvent raisedEvent = new RaisedEvent(internalEvent);
raisedEvents.Add(raisedEvent);
}
}
return(raisedEvents);
}
static RaisedEvent <T> RaisesInternal <T>(Action <EventHandler <T> > attach, Action <EventHandler <T> > detach, Action testCode)
#endif
{
GuardArgumentNotNull(nameof(attach), attach);
GuardArgumentNotNull(nameof(detach), detach);
GuardArgumentNotNull(nameof(testCode), testCode);
#if XUNIT_NULLABLE
RaisedEvent <T>?raisedEvent = null;
void handler(object?s, T args) => raisedEvent = new RaisedEvent <T>(s, args);
#else
RaisedEvent <T> raisedEvent = null;
EventHandler <T> handler = (object s, T args) => raisedEvent = new RaisedEvent <T>(s, args);
#endif
attach(handler);
testCode();
detach(handler);
return(raisedEvent);
}
public void EvaluateOnSimpleEvent()
{
Guid newId = Guid.NewGuid();
try
{
MAObjectHologram maObject = ActiveConfig.DB.CreateMAObject(newId, "person");
AcmaEvent maevent = GetAccountNameChangedEvent();
RaisedEvent exitEvent = new RaisedEvent(maevent, maObject);
maObject.IncomingEvents = new List <RaisedEvent>()
{
exitEvent
};
// Positive Tests
EventRule target = new EventRule();
target.EventName = "accountNameChanged";
Assert.IsTrue(target.Evaluate(maObject));
// Negative Tests
maevent = GetSupervisorChangedEvent();
exitEvent = new RaisedEvent(maevent, maObject);
maObject.IncomingEvents = new List <RaisedEvent>()
{
exitEvent
};
target.EventName = "accountNameChanged";
Assert.IsFalse(target.Evaluate(maObject));
target.EventName = "accountNameChanged";
target.EventSource = ActiveConfig.DB.GetAttribute("supervisor");
Assert.IsFalse(target.Evaluate(maObject));
}
finally
{
ActiveConfig.DB.DeleteMAObjectPermanent(newId);
}
}
public void it_will_serialise_raised_events_to_a_brokered_message()
{
var expected = new RaisedEvent(
new DummyEvent {Prop = "value"},
new DateTimeOffset(2013, 01, 14, 21, 46, 22, TimeZoneInfo.Utc.BaseUtcOffset));
var actual = expected.ConvertToMessage();
using (var reader = new StreamReader(actual.GetBody()))
{
var json = reader.ReadToEnd();
var match =
new Regex(
@"\{""Thumbprint"":"".*?"",""Event"":\{""\$type"":""Test[.]Honeycomb[.]Azure[.]DummyEvent,\sTest[.]Honeycomb[.]Azure"",""Prop"":""value""\},""RaisedTimestamp"":""2013-01-14T21:46:22[+]00:00"",""TransactionId"":null\}");
//Console.WriteLine(match);
//Console.WriteLine(json);
match.IsMatch(json).ShouldBeTrue();
}
}
protected void RaiseEvent(Event @event, bool isHistoric = false)
{
// ANTI DATA CORRUPTION MEASURE // For bulk applying and exporting events, since we cannot guarantee they wont contain any objects that are stored to AR state but not deepcloned
var typeName = @event.GetType().AssemblyQualifiedName;
var safeEvent = (Event)@event.AsBytes().Parse(typeName);
// ANTI DATA CORRUPTION MEASURE
Apply(safeEvent);
Version++;
if (!isHistoric)
{
var raised = new RaisedEvent(@event)
{
SequenceNumber = Version
};
_uncommittedEvents.Add(raised);
}
}
static async Task <RaisedEvent <T> > RaisesAsyncInternal <T>(Action <EventHandler <T> > attach, Action <EventHandler <T> > detach, Func <Task> testCode)
#endif
where T : EventArgs
{
GuardArgumentNotNull(nameof(attach), attach);
GuardArgumentNotNull(nameof(detach), detach);
GuardArgumentNotNull(nameof(testCode), testCode);
#if XUNIT_NULLABLE
RaisedEvent <T>?raisedEvent = null;
void handler(object?s, T args) => raisedEvent = new RaisedEvent <T>(s, args);
#else
RaisedEvent <T> raisedEvent = null;
EventHandler <T> handler = (object s, T args) => raisedEvent = new RaisedEvent <T>(s, args);
#endif
attach(handler);
await testCode();
detach(handler);
return(raisedEvent);
}
public void EvaluateOnSourceEvent()
{
Guid supervisorId = Guid.NewGuid();
Guid targetId = Guid.NewGuid();
try
{
MAObjectHologram supervisorObject = ActiveConfig.DB.CreateMAObject(supervisorId, "person");
MAObjectHologram targetObject = ActiveConfig.DB.CreateMAObject(targetId, "person");
AcmaSchemaAttribute supervisorAttribute = ActiveConfig.DB.GetAttribute("supervisor");
targetObject.SetAttributeValue(supervisorAttribute, supervisorObject.ObjectID);
targetObject.CommitCSEntryChange();
AcmaEvent maevent = GetAccountNameChangedEvent();
RaisedEvent exitEvent = new RaisedEvent(maevent, supervisorObject);
targetObject.IncomingEvents = new List <RaisedEvent>()
{
exitEvent
};
// Positive Tests
EventRule target = new EventRule();
target.EventName = "accountNameChanged";
target.EventSource = ActiveConfig.DB.GetAttribute("supervisor");
Assert.IsTrue(target.Evaluate(targetObject));
// Negative Tests
target = new EventRule();
target.EventName = "accountNameChanged";
target.EventSource = ActiveConfig.DB.GetAttribute("directReports");
Assert.IsFalse(target.Evaluate(targetObject));
}
finally
{
ActiveConfig.DB.DeleteMAObjectPermanent(targetId);
ActiveConfig.DB.DeleteMAObjectPermanent(supervisorId);
}
}
public void Emit(RaisedEvent @event)
{
buffer.Enqueue(@event);
nudge.Set();
}
public void LogConsumption(RaisedEvent raisedEvent, ConsumptionLog consumptionLog)
{
var logEntity = new ConsumptionLogEntity(consumptionLog, raisedEvent);
var insert = TableOperation.Insert(logEntity);
logTable.Execute(insert);
}
public void RecordEvent(RaisedEvent raisedEvent)
{
var eventEntity = new EventEntity(raisedEvent);
var insert = TableOperation.Insert(eventEntity);
EventStoreTable.Execute(insert);
}
public static string ConvertToJson(RaisedEvent @event)
{
return JsonConvert.SerializeObject(@event, jsonSerializerSettings);
}
private void consumeEventOnAggregate(RaisedEvent raisedEvent, AggregateInfo aggregateInfo, ConsumptionLog consumptionLog)
{
//If it's not tracked, then select it from the domain.
if (aggregateInfo.Lifestate == AggregateLifestate.Untracked)
selectAggregate(aggregateInfo);
using (var scope = new TransactionScope())
{
try
{
try
{
//If we haven't found it in the domain, then create it, otherwise consume the event.
if (aggregateInfo.Lifestate == AggregateLifestate.Untracked)
AggregateFactory.Create(aggregateInfo, raisedEvent.Event);
else
aggregateInfo.Instance.AsDynamic().Receive(raisedEvent);
}
catch (ApplicationException e)
{
if (e.Source == "ReflectionMagic")
throw new MissingMethodException(
aggregateInfo.Type.FullName,
string.Format(
"{0}({1})",
aggregateInfo.Lifestate == AggregateLifestate.Untracked ? "_ctor" : "Receive",
raisedEvent.GetType()));
throw;
}
}
catch (Exception e)
{
consumptionLog.RecordExceptionForConsumer(e);
}
consumptionLog.RecordConsumptionComplete();
Store.LogConsumption(raisedEvent, consumptionLog);
scope.Complete();
}
}
private EventEntity storedEventEntity(RaisedEvent raisedEvent)
{
var cloudStorageAccount = CloudStorageAccount.DevelopmentStorageAccount;
var cloudTableClient = cloudStorageAccount.CreateCloudTableClient();
var table = cloudTableClient.GetTableReference("testEventStore");
var retrieve = TableOperation.Retrieve<EventEntity>(raisedEvent.Thumbprint.ToString(), raisedEvent.Event.GetType().FullName);
var result = table.Execute(retrieve);
return result.Result as EventEntity;
}