示例#1
0
        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);
        }
示例#3
0
        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));
        }
示例#6
0
        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);
                }
            }
        }
示例#7
0
        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();
            });
        }
示例#8
0
 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();
 }