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, @event) =>
async(command) =>
(await store.AppendToStream(
(command as DoSomething).Identifier,
ExpectedVersion.Any,
new NewStreamMessage(Guid.NewGuid(), eventType, eventSerializer.SerializeObject(@event)), CancellationToken.None)
).CurrentPosition;
_handlerResolver = new Mocking <IHandlerResolver, HandlerResolverSetup>();
}
public async Task GivenExistingEventStore_WhenAddingAnEventToTheStore_AllPersistenceIdsProjectionIsUpdated()
{
var streamStore = new InMemoryStreamStore();
var tpyeResovler = new FullyQualifiedTypeNameTypeResolver("EventSourced.Example.Aggregate.Events.{0}, EventSourced.Example");
var eventStore = new SqlStreamStoreEventStore(streamStore, tpyeResovler);
var system = new EventSourcingSystem(eventStore);
await system.EventStore.Persist("test1", new { Data = "Test1" });
await system.EventStore.Persist("test2", new { Data = "Test2" });
var allPersistenceIdsProjection = new AllPersistenceIdsReadModel(system);
Assert.Equal(2, allPersistenceIdsProjection.PersistenceIds.Count);
await system.EventStore.Persist("test3", new { Data = "Test3" });
await Task.Delay(10);
Assert.Equal(3, allPersistenceIdsProjection.PersistenceIds.Count);
}
public async Task CanGetStreamVersion()
{
var streamStore = new InMemoryStreamStore();
var stream1 = new StreamId("test1");
var stream2 = new StreamId("test2");
var message1 = new NewStreamMessage(Guid.NewGuid(), "Test1", @"{ 'Hello': 'World1' }");
await streamStore.AppendToStream(stream1, ExpectedVersion.Any, message1);
message1 = new NewStreamMessage(Guid.NewGuid(), "Test1", @"{ 'Hello': 'World1' }");
await streamStore.AppendToStream(stream1, ExpectedVersion.Any, message1);
var message2 = new NewStreamMessage(Guid.NewGuid(), "Test2", @"{ 'Hello': 'World2' }");
await streamStore.AppendToStream(stream2, ExpectedVersion.Any, message2);
Thread.Sleep(100);
var stream1Metadata = await streamStore.GetStreamMetadata("test1");
var stream2Metadata = await streamStore.GetStreamMetadata("test2");
Assert.Equal(1, stream1Metadata.MetadataStreamVersion);
Assert.Equal(0, stream2Metadata.MetadataStreamVersion);
}
public PublisherTests()
{
// Setup subscriber
_subscriberStreamStore = new InMemoryStreamStore(() => _utcNow);
_subscriberSettings = new WebHookSubscriberSettings(_subscriberStreamStore);
var subscriberWebHostBuilder = new WebHostBuilder()
.UseStartup <WebHookSubscriberStartup>()
.ConfigureServices(services => services.AddSingleton(_subscriberSettings));
var subscriberTestServer = new TestServer(subscriberWebHostBuilder);
_subscriberClient = new HttpClient(subscriberTestServer.CreateHandler())
{
BaseAddress = new Uri("http://subscriber.example.com")
};
// Setup publisher
_publisherStreamStore = new InMemoryStreamStore(() => _utcNow);
var publisherSettings = new WebHookPublisherSettings(_publisherStreamStore)
{
HttpMessageHandler = subscriberTestServer.CreateHandler(),
GetUtcNow = () => _utcNow
};
_publisher = new WebHookPublisher(publisherSettings);
var publisherWebHostBuilder = new WebHostBuilder()
.UseStartup <WebHookPublisherStartup>()
.ConfigureServices(services => services.AddSingleton(publisherSettings));
var publisherTestServer = new TestServer(publisherWebHostBuilder);
_publisherClient = new HttpClient(publisherTestServer.CreateHandler())
{
BaseAddress = new Uri("http://publisher.example.com")
};
_publisherClient.DefaultRequestHeaders.Accept.Add(
MediaTypeWithQualityHeaderValue.Parse("application/json"));
}
public override Task <IStreamStore> GetStreamStore()
{
IStreamStore streamStore = new InMemoryStreamStore(() => GetUtcNow());
return(Task.FromResult(streamStore));
}
public async Task ShowWithStream()
{
//setup a projection schema (one of many ways)
var projector = new AsyncSqlProjector(
Resolve.WhenEqualToHandlerMessageType(new PortfolioProjection()),
new TransactionalSqlCommandExecutor(
new ConnectionStringSettings(
"projac",
@"Data Source=(localdb)\ProjectsV12;Initial Catalog=ProjacUsage;Integrated Security=SSPI;",
"System.Data.SqlClient"),
IsolationLevel.ReadCommitted));
await projector.ProjectAsync(new object[] { new DropSchema(), new CreateSchema() });
//setup a memory eventstore
var store = new InMemoryStreamStore();
//setup a sample stream (using some sample events)
var portfolioId = Guid.NewGuid();
var events = new object[]
{
new PortfolioAdded {
Id = portfolioId, Name = "My Portfolio"
},
new PortfolioRenamed {
Id = portfolioId, Name = "Your Portfolio"
},
new PortfolioRemoved {
Id = portfolioId
}
};
var stream = string.Format("portfolio-{0}", portfolioId.ToString("N"));
await store.AppendToStream(
stream,
ExpectedVersion.Any,
events
.Select(@event => new NewStreamMessage(
Guid.NewGuid(),
@event.GetType().FullName,
JsonConvert.SerializeObject(@event)))
.ToArray());
//project the sample stream (until end of stream)
var result =
await store.ReadStreamForwards(stream, StreamVersion.Start, 1, true);
foreach (var rawMessage in result.Messages)
{
var @event = JsonConvert.DeserializeObject(
await rawMessage.GetJsonData(),
Type.GetType(rawMessage.Type, true));
await projector.ProjectAsync(@event);
}
while (!result.IsEnd)
{
result =
await store.ReadStreamForwards(stream, result.NextStreamVersion, 1, true);
foreach (var rawMessage in result.Messages)
{
var @event = JsonConvert.DeserializeObject(
await rawMessage.GetJsonData(),
Type.GetType(rawMessage.Type, true));
await projector.ProjectAsync(@event);
}
}
}
protected async Task <(IStreamStore, Action)> GetStore(CancellationToken cancellationToken)
{
IStreamStore streamStore = null;
IDisposable disposable = null;
Output.WriteLine(ConsoleColor.Yellow, "Store type:");
await new Menu()
.AddSync("InMem", () => streamStore = new InMemoryStreamStore())
.Add("MS SQL V2 (Docker)",
async _ =>
{
var fixture = new MsSqlStreamStoreDb("dbo");
Console.WriteLine(fixture.ConnectionString);
streamStore = await fixture.GetStreamStore();
disposable = fixture;
})
.Add("MS SQL V3 (Docker)",
async _ =>
{
var fixture = new MsSqlStreamStoreDbV3("dbo");
Console.WriteLine(fixture.ConnectionString);
streamStore = await fixture.GetStreamStore();
disposable = fixture;
})
.AddSync("MS SQL V3 (LocalDB)",
() =>
{
var sqlLocalDb = new SqlLocalDb();
Console.WriteLine(sqlLocalDb.ConnectionString);
streamStore = sqlLocalDb.StreamStore;
disposable = sqlLocalDb;
})
.Add("Postgres (Docker)",
async ct =>
{
var fixture = new PostgresStreamStoreDb("dbo");
Console.WriteLine(fixture.ConnectionString);
streamStore = await fixture.GetPostgresStreamStore(true);
disposable = fixture;
})
.Add("Postgres (Server)",
async ct =>
{
Console.Write("Enter the connection string: ");
var connectionString = Console.ReadLine();
var fixture = new PostgresStreamStoreDb("dbo", connectionString);
Console.WriteLine(fixture.ConnectionString);
streamStore = await fixture.GetPostgresStreamStore(true);
disposable = fixture;
})
/*.Add("MySql (Docker)",
* async ct =>
* {
* var fixture = new MySqlStreamStoreDb();
* Console.WriteLine(fixture.ConnectionString);
* streamStore = await fixture.GetMySqlStreamStore(true);
* disposable = fixture;
* })*/
/*.Add("MySql (Server)",
* async ct =>
* {
* Console.Write("Enter the connection string: ");
* var connectionString = Console.ReadLine();
* var fixture = new MySqlStreamStoreDb(connectionString);
* Console.WriteLine(fixture.ConnectionString);
* streamStore = await fixture.GetMySqlStreamStore(true);
* disposable = fixture;
* })*/
.Display(cancellationToken);
return(
streamStore,
() =>
{
streamStore.Dispose();
disposable?.Dispose();
});
}
public void Test()
{
var streamStore = new InMemoryStreamStore();
}
public InMemoryStreamStoreFixture()
{
Store = new InMemoryStreamStore(() => GetUtcNow());
}
public async Task When_uploading_a_file_that_is_a_zip()
{
var client = new MemoryBlobClient();
var store = new InMemoryStreamStore();
var validator = new ZipArchiveValidator(Encoding.UTF8);
var resolver = Resolve.WhenEqualToMessage(
new RoadNetworkChangesArchiveCommandModule(
client,
store,
new FakeRoadNetworkSnapshotReader(),
validator,
SystemClock.Instance
)
);
var controller = new UploadController(Dispatch.Using(resolver),
client)
{
ControllerContext = new ControllerContext {
HttpContext = new DefaultHttpContext()
}
};
using (var sourceStream = new MemoryStream())
{
using (var archive = new ZipArchive(sourceStream, ZipArchiveMode.Create, true, Encoding.UTF8))
{
var entry = archive.CreateEntry("entry");
using (var entryStream = entry.Open())
{
entryStream.Write(new byte[] { 1, 2, 3, 4 });
entryStream.Flush();
}
}
sourceStream.Position = 0;
var formFile = new FormFile(sourceStream, 0L, sourceStream.Length, "name", "name")
{
Headers = new HeaderDictionary(new Dictionary <string, StringValues>
{
{ "Content-Type", StringValues.Concat(StringValues.Empty, "application/zip") }
})
};
var result = await controller.Post(formFile);
Assert.IsType <OkResult>(result);
var page = await store.ReadAllForwards(Position.Start, 1, true);
var message = Assert.Single(page.Messages);
Assert.Equal(nameof(Messages.RoadNetworkChangesArchiveUploaded), message.Type);
var uploaded =
JsonConvert.DeserializeObject <Messages.RoadNetworkChangesArchiveUploaded>(
await message.GetJsonData());
Assert.True(await client.BlobExistsAsync(new BlobName(uploaded.ArchiveId)));
var blob = await client.GetBlobAsync(new BlobName(uploaded.ArchiveId));
using (var openStream = await blob.OpenAsync())
{
var resultStream = new MemoryStream();
openStream.CopyTo(resultStream);
resultStream.Position = 0;
sourceStream.Position = 0;
Assert.Equal(sourceStream.ToArray(), resultStream.ToArray());
}
}
}
public InMemorySqlStreamStoreProvider()
{
_store = new InMemoryStreamStore();
}
