public void DeserializesClassWithIListArray()
{
var serializer = new EventSerializer();
bool hasMetadata;
var obj = new ObjectWithIList2 {
Items = new ObjectDbTest.Person[] { new ObjectDbTest.Person {
Name = "A", Age = 1
} }
};
var meta = serializer.Serialize(out hasMetadata, obj).ToAsyncSafe();
Assert.Equal(99, meta.Length);
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
serializer = new EventSerializer();
serializer.ProcessMetadataLog(meta);
var data2 = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer();
object obj2;
Assert.False(deserializer.Deserialize(out obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
Assert.Equal(obj, obj2);
deserializer = new EventDeserializer();
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
Assert.Equal(obj, obj2);
}
public void Create(EventDeserializer eventDsl, out Event @event)
{
@event = new Event()
{
Title = eventDsl.Title,
Description = eventDsl.Description,
SubscribeNumber = eventDsl.SubscribeNumber,
ValidationRequired = eventDsl.ValidationRequired,
RestrictedEvent = eventDsl.RestrictedEvent,
Status = eventDsl.Status,
JuryPoint = eventDsl.JuryPoint,
Location = eventDsl.Location,
StartAt = eventDsl.StartAt,
CloseAt = eventDsl.CloseAt,
OpenAt = eventDsl.OpenAt,
EndAt = eventDsl.EndAt,
Images = eventDsl.Images,
Prices = eventDsl.Prices
};
if (@event.ValidationRequired)
{
@event.ValidatedNumber = 0;
}
Context.Event.Add(@event);
if (@event.RestrictedEvent)
{
AddAndRemoveEventRoles(eventDsl.RestrictedRolesList, @event);
}
}
public void SetUp()
{
_model = new Model();
var eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
var eventSerializer = new EventSerializer(SimpleJson.SerializeObject);
var eventMapping = new EventMapping(new Dictionary <string, Type>
{
{ typeof(SnapshotStub).AssemblyQualifiedName, typeof(SnapshotStub) },
{ typeof(EventStub).AssemblyQualifiedName, typeof(EventStub) },
});
var snapshotContainer = new SnapshotContainer
{
Info =
{
Position = 4,
Type = typeof(SnapshotStub).AssemblyQualifiedName
},
Data = eventSerializer.SerializeObject(new SnapshotStub(1))
};
_sut = new RepositoryScenarioBuilder(eventMapping, eventDeserializer)
.ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(0))
.ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(1))
.ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(2))
.ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(3))
.ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(4))
.ScheduleAppendToStream($"{_model.KnownIdentifier}-snapshots", snapshotContainer)
.ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(5))
.ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(6))
.BuildForRepository <AggregateRootEntitySnapshotableStub>();
}
public void CanMigrateListInDict()
{
var obj = PassThroughEventStorage(new EventDictListRoot
{
Items = new Dictionary <ulong, IList <Item> > {
{ 1, new List <Item> {
new Item {
Field = "A"
}
} }
}
}, new FullNameTypeMapper());
var serializer = new EventSerializer();
bool hasMetadata;
var meta = serializer.Serialize(out hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer();
object obj2;
Assert.False(deserializer.Deserialize(out obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
}
public void CanMigrateListWithNewFields()
{
var parentMapper = new FullNameTypeMapper();
var mapper = new EventStoreTest.OverloadableTypeMapper(typeof(Item2), parentMapper.ToName(typeof(Item)),
new EventStoreTest.OverloadableTypeMapper(typeof(EventRoot2), parentMapper.ToName(typeof(EventRoot)),
parentMapper
));
var obj = PassThroughEventStorage(new EventRoot
{
Items = new List <Item> {
new Item {
Field = "A"
}
}
}, mapper);
var serializer = new EventSerializer(mapper);
bool hasMetadata;
var meta = serializer.Serialize(out hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer(mapper);
object obj2;
Assert.False(deserializer.Deserialize(out obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
}
public void DeserializesClassWithIList()
{
var serializer = new EventSerializer();
bool hasMetadata;
var obj = new ObjectWithIList {
Items = new List <int> {
1
}
};
var meta = serializer.Serialize(out hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer();
object obj2;
Assert.False(deserializer.Deserialize(out obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
Assert.Equal(obj, obj2);
deserializer = new EventDeserializer();
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
Assert.Equal(obj, obj2);
}
public void CreateDependencies()
{
var store = new InMemoryStreamStore();
var eventMapping = new EventMapping(new Dictionary <string, Type>
{
{ "SomethingHappened", typeof(SomethingHappened) },
{ "SomethingElseHappened", typeof(SomethingElseHappened) },
});
var eventSerializer = new EventSerializer(JsonConvert.SerializeObject);
var eventDeserializer = new EventDeserializer(JsonConvert.DeserializeObject);
_factRepository = new StreamStoreFactRepository(store, eventMapping, eventSerializer, eventDeserializer);
_handlerFactory = (eventType, @events) =>
async(command) =>
{
long position = 0;
foreach (var @event in events)
{
position = (await store.AppendToStream(
(command as DoSomething).Identifier,
ExpectedVersion.Any,
new NewStreamMessage(Guid.NewGuid(), eventType,
eventSerializer.SerializeObject(@event)),
CancellationToken.None)
).CurrentPosition;
}
return(position);
};
_handlerResolver = new Mocking <IHandlerResolver, HandlerResolverSetup>();
//_handlerResolver.When().ResolvesHandler(_handlerFactory);
}
public void ChangeDetected(List <OutboxItem> items)
{
foreach (var item in items)
{
var type = _typeResolver.GetType(item.EventType);
if (type == null)
{
_logger.LogError($"Type of '{item.EventType}' not found in event types");
continue;
}
var eventToPublish = EventDeserializer.Deserialize(type, item.EventBody);
if (_filter.ShouldPublish(eventToPublish))
{
eventToPublish = TransformEvent(eventToPublish, item);
_eventBus.Publish(eventToPublish);
_logger.LogInformation($"Event '{item.EventType}-{item.EventId}' Published on bus.");
}
else
{
_logger.LogInformation($"Publishing Event '{item.EventType}-{item.EventId}' Skipped because of filter");
}
}
}
public void SetUp()
{
_store = new InMemoryStreamStore(() => DateTime.UtcNow);
_unitOfWork = new ConcurrentUnitOfWork();
_factory = AggregateRootEntityStub.Factory;
_eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
_eventMapping = new EventMapping(new Dictionary <string, Type>());
}
public void SetUp()
{
var eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
var eventMapping = new EventMapping(new Dictionary <string, Type>());
_model = new Model();
_sut = new RepositoryScenarioBuilder(eventMapping, eventDeserializer).BuildForRepository();
}
public RepositoryScenarioBuilder(EventMapping eventMapping, EventDeserializer eventDeserializer)
{
_eventStore = new InMemoryStreamStore(() => DateTime.UtcNow);
_unitOfWork = new ConcurrentUnitOfWork();
_eventStoreSchedule = new List <Action <IStreamStore> >();
_unitOfWorkSchedule = new List <Action <ConcurrentUnitOfWork> >();
_eventMapping = eventMapping;
_eventDeserializer = eventDeserializer;
}
public Repository(
Func <TAggregateRoot> factory,
ConcurrentUnitOfWork unitOfWork,
IStreamStore eventStore,
EventMapping eventMapping,
EventDeserializer eventDeserializer)
: base(factory, unitOfWork, eventStore, eventMapping, eventDeserializer)
{
}
public void SetUp()
{
var eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
var eventMapping = new EventMapping(new Dictionary <string, Type>());
_model = new Model();
_root = AggregateRootEntityStub.Factory();
_sut = new RepositoryScenarioBuilder(eventMapping, eventDeserializer).
ScheduleAttachToUnitOfWork(new Aggregate(_model.KnownIdentifier, 0, _root)).
BuildForRepository();
}
public void SetUp()
{
var eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
var eventMapping = new EventMapping(new Dictionary <string, Type>());
_model = new Model();
_sut = new RepositoryScenarioBuilder(eventMapping, eventDeserializer).
ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(1)).
ScheduleDeleteStream(_model.KnownIdentifier).
BuildForRepository();
}
public StreamStoreFactRepository(
IStreamStore streamStore,
EventMapping eventMapping,
EventSerializer eventSerializer,
EventDeserializer eventDeserializer)
{
_streamStore = streamStore ?? throw new ArgumentNullException(nameof(streamStore));
_eventMapping = eventMapping ?? throw new ArgumentNullException(nameof(eventMapping));
_eventSerializer = eventSerializer ?? throw new ArgumentNullException(nameof(eventSerializer));
_eventDeserializer = eventDeserializer ?? throw new ArgumentNullException(nameof(eventDeserializer));
}
/// <summary>
/// Creates a new <see cref="BinlogReader"/>.
/// </summary>
/// <param name="eventDeserializer">EventDeserializer implementation for a specific provider</param>
/// <param name="stream">Stream representing a binlog file</param>
public BinlogReader(EventDeserializer eventDeserializer, Stream stream)
{
byte[] header = new byte[EventConstants.FirstEventPosition];
stream.Read(header, 0, EventConstants.FirstEventPosition);
if (!header.SequenceEqual(MagicNumber))
{
throw new InvalidOperationException("Invalid binary log file header");
}
_eventDeserializer = eventDeserializer;
_pipeReader = PipeReader.Create(stream);
}
/// <summary>
/// Creates a new <see cref="BinlogReader"/>.
/// </summary>
/// <param name="eventDeserializer">EventDeserializer implementation for a specific provider</param>
/// <param name="stream">Stream representing a binlog file</param>
/// <param name="cancellationToken">Cancellation token</param>
public BinlogReader(EventDeserializer eventDeserializer, Stream stream, CancellationToken cancellationToken = default)
{
byte[] header = new byte[EventConstants.FirstEventPosition];
stream.Read(header, 0, EventConstants.FirstEventPosition);
if (!header.SequenceEqual(MagicNumber))
{
throw new InvalidOperationException("Invalid binary log file header");
}
_eventDeserializer = eventDeserializer;
_pipeReader = PipeReader.Create(stream);
_ = Task.Run(async() => await ReceivePacketsAsync(_pipeReader, cancellationToken));
}
public void SetUp()
{
_model = new Model();
var eventDeserializer = new EventDeserializer(SimpleJson.DeserializeObject);
var eventMapping = new EventMapping(new Dictionary <string, Type>
{
{ typeof(EventStub).AssemblyQualifiedName, typeof(EventStub) },
});
_sut = new RepositoryScenarioBuilder(eventMapping, eventDeserializer).
ScheduleAppendToStream(_model.KnownIdentifier, new EventStub(1)).
BuildForRepository();
}
internal static async Task Start(bool mariadb)
{
using (Stream stream = File.OpenRead("binlog.000003"))
{
EventDeserializer deserializer = mariadb
? new MariaDbEventDeserializer()
: new MySqlEventDeserializer();
var reader = new BinlogReader(deserializer, stream);
await foreach (var binlogEvent in reader.ReadEvents())
{
await PrintEventAsync(binlogEvent);
}
}
}
public void DeserializeSimpleClass()
{
var serializer = new EventSerializer();
bool hasMetadata;
var obj = new User { Name = "Boris", Age = 40 };
var meta = serializer.Serialize(out hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer();
object obj2;
Assert.False(deserializer.Deserialize(out obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
Assert.Equal(obj, obj2);
}
public void DeserializesClassWithEnum()
{
var serializer = new EventSerializer();
var obj = new ObjectWithEnum {
State = StateEnum.Alive
};
var meta = serializer.Serialize(out _, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out _, obj);
var deserializer = new EventDeserializer();
Assert.False(deserializer.Deserialize(out var obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
Assert.Equal(obj, obj2);
}
public void SimpleNestedObjects()
{
var serializer = new EventSerializer();
var obj = new EventWithUser
{
User = new User()
};
var meta = serializer.Serialize(out var hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer();
Assert.False(deserializer.Deserialize(out var obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
}
public void SerializingSkipsNotStoredProperties()
{
var serializer = new EventSerializer();
var obj = new DtoWithNotStored {
Name = "Boris", Skip = 1
};
var meta = serializer.Serialize(out var hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer();
Assert.False(deserializer.Deserialize(out var obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
Assert.Equal(0, ((DtoWithNotStored)obj2).Skip);
}
public void SerializingBoxedDoubleDoesNotCrash()
{
var serializer = new EventSerializer();
var obj = new DtoWithObject {
Something = 1.2
};
var meta = serializer.Serialize(out var hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer();
Assert.False(deserializer.Deserialize(out var obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
Assert.Equal(1.2, ((DtoWithObject)obj2).Something);
}
public PublicServiceControllerTests()
{
var dbContextOptions = CreateDbContext();
_existingPublicServiceId = "DVR000000001";
var publicServiceListItem = new PublicServiceListItem
{
PublicServiceId = _existingPublicServiceId,
Name = "Dienstverlening"
};
_backofficeContext = new BackofficeContext(dbContextOptions);
_backofficeContext.PublicServiceList.Add(publicServiceListItem);
_backofficeContext.SaveChanges();
_eventMapping = new EventMapping(EventMapping.DiscoverEventNamesInAssembly(typeof(DomainAssemblyMarker).Assembly));
_eventDeserializer = new EventDeserializer(JsonConvert.DeserializeObject);
}
public void DeserializesAsObjectClassWithList()
{
var serializer = new EventSerializer();
var obj = new ObjectWithList {
Items = new List <int> {
1
}
};
var meta = serializer.Serialize(out var hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer(new TypeSerializersTest.ToDynamicMapper());
Assert.False(deserializer.Deserialize(out dynamic obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
Assert.Equal(1, obj2.Items[0]);
}
public void SkipsIIndirect()
{
var serializer = new EventSerializer();
var obj = new EventWithIIndirect
{
Name = "A",
Ind1 = new DBIndirect <User>(),
Ind2 = new List <IIndirect <User> >()
};
var meta = serializer.Serialize(out var hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer();
Assert.False(deserializer.Deserialize(out var obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
}
public void DeserializesAsObjectClassWithDictionaryOfSimpleTypes()
{
var serializer = new EventSerializer();
var obj = new ObjectWithDictionaryOfSimpleType {
Items = new Dictionary <int, string>()
{
{ 1, "Ahoj" }
}
};
var meta = serializer.Serialize(out var hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer(new TypeSerializersTest.ToDynamicMapper());
Assert.False(deserializer.Deserialize(out dynamic obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
Assert.Equal("Ahoj", obj2.Items[1].ToString());
}
public static IServiceCollection AddEasyEventSourcing <TAggregateRoot>(this IServiceCollection services,
EventStoreOptions options = null) where TAggregateRoot : IAggregate
{
services = services ?? throw new ArgumentNullException(nameof(services));
options = options ?? EventStoreOptions.Create();
var connection = EventStoreConnectionFactory.Create(options.ConnectionString);
var eventDeserializer = new EventDeserializer(typeof(TAggregateRoot).GetTypeInfo().Assembly);
var projections = new EventStoreProjectionsClient(options);
services.AddSingleton(connection);
services.AddSingleton(eventDeserializer);
services.AddSingleton <IEventStoreProjections>(projections);
services.AddSingleton <IEventStoreBus>(new EventStoreSubscription(connection, options, eventDeserializer, projections));
services.AddTransient <IRepository, EventStoreRepository>();
services.AddTransient <IEventStore, EventStoreRepository>();
return(services);
}
public void SupportPureArray()
{
var serializer = new EventSerializer();
var obj = new PureArray {
A = new[] { "A", "B" }, B = new[] { 42, 7 }
};
var meta = serializer.Serialize(out var hasMetadata, obj).ToAsyncSafe();
serializer.ProcessMetadataLog(meta);
var data = serializer.Serialize(out hasMetadata, obj);
var deserializer = new EventDeserializer();
Assert.False(deserializer.Deserialize(out var obj2, data));
deserializer.ProcessMetadataLog(meta);
Assert.True(deserializer.Deserialize(out obj2, data));
var ev = obj2 as PureArray;
Assert.Equal(ev.A, new[] { "A", "B" });
Assert.Equal(ev.B, new[] { 42, 7 });
}
