public async Task SubscriptionDeliversFutureCommands(MemstateSettings settings) { const int NumRecords = 5; settings.LoggerFactory.AddProvider(new TestOutputLoggingProvider(_log)); settings.StreamName = _randomStreamName; var provider = settings.CreateStorageProvider(); var records = new List <JournalRecord>(); var subSource = provider.CreateJournalSubscriptionSource(); var sub = subSource.Subscribe(0, records.Add); var writer = provider.CreateJournalWriter(0); for (var i = 0; i < NumRecords; i++) { writer.Send(new AddStringCommand(i.ToString())); } await writer.DisposeAsync().ConfigureAwait(false); await WaitForConditionOrThrow(() => records.Count == 5).ConfigureAwait(false); sub.Dispose(); Assert.Equal(5, records.Count); }
public async Task SubscriptionDeliversPreExistingCommands(MemstateSettings settings) { settings.LoggerFactory.AddProvider(new TestOutputLoggingProvider(_log)); settings.StreamName = _randomStreamName; var provider = settings.CreateStorageProvider(); const int NumRecords = 50; var journalWriter = provider.CreateJournalWriter(0); for (var i = 0; i < NumRecords; i++) { journalWriter.Send(new AddStringCommand(i.ToString())); } await journalWriter.DisposeAsync().ConfigureAwait(false); var records = new List <JournalRecord>(); var subSource = provider.CreateJournalSubscriptionSource(); if (!provider.SupportsCatchupSubscriptions()) { Assert.Throws <NotSupportedException>(() => subSource.Subscribe(0, records.Add)); } else { subSource.Subscribe(0, records.Add); await WaitForConditionOrThrow(() => records.Count == NumRecords).ConfigureAwait(false); Assert.Equal(Enumerable.Range(0, NumRecords), records.Select(r => (int)r.RecordNumber)); } }
public async Task MapsToCommand() { //Arrange var settings = new MemstateSettings(); settings.FileSystem = new InMemoryFileSystem(); var storageProvider = settings.CreateStorageProvider(); var builder = new EngineBuilder(settings, storageProvider); var engine = builder.Build <ITestModel>(new TestModel()); var client = new LocalClient <ITestModel>(engine); var proxy = client.GetDispatchProxy(); //Act proxy.SetCustomer(new Customer()); //release the lock on the journal await engine.DisposeAsync(); var journalEntry = storageProvider.CreateJournalReader().GetRecords().FirstOrDefault(); // If MapTo is correct, a SetCustomerCommand will be written to the journal // if not, then a ProxyCommand will be written Assert.NotNull(journalEntry); Assert.IsInstanceOf <SetCustomerCommand>(journalEntry.Command); }
public ProxyOverloadingTests() { var settings = new MemstateSettings().WithInmemoryStorage(); var storageProvider = settings.CreateStorageProvider(); var engine = new EngineBuilder(settings, storageProvider).Build <ModelWithOverloads>(); var client = new LocalClient <ModelWithOverloads>(engine); _db = client.GetDispatchProxy(); }
public async Task One_journal_entry_per_line_when_using_json_format() { const int NumRecords = 100; const string Stream = "test"; const string FileName = Stream + ".journal"; var settings = new MemstateSettings().WithInmemoryStorage(); settings.Serializers.Register("newtonsoft.json", _ => new JsonSerializerAdapter(settings)); settings.Serializer = "newtonsoft.json"; settings.StreamName = Stream; var provider = settings.CreateStorageProvider(); //Write NumRecords entries var writer = provider.CreateJournalWriter(0); foreach (var i in Enumerable.Range(1, NumRecords)) { writer.Send(new Set <int>("key" + i, i)); } //wait for the writes to complete await writer.DisposeAsync().ConfigureAwait(false); //Read back all the entries, should be NumRecords var reader = provider.CreateJournalReader(); Assert.AreEqual(NumRecords, reader.GetRecords().Count()); await reader.DisposeAsync().ConfigureAwait(false); //Count the actual lines in the file Assert.IsTrue(settings.FileSystem.Exists(FileName)); var streamReader = new StreamReader(settings.FileSystem.OpenRead(FileName)); var lines = 0; while (true) { var line = streamReader.ReadLine(); if (line == null) { break; } Console.WriteLine("> " + line); lines++; } Assert.AreEqual(NumRecords, lines); }
public void MapsToCommand() { var config = new MemstateSettings(); config.StorageProvider = typeof(InMemoryStorageProvider).FullName; var storageProvider = config.CreateStorageProvider(); var builder = new EngineBuilder(config, storageProvider); var engine = builder.Build <ITestModel>(new TestModel()); var client = new LocalClient <ITestModel>(engine); var proxy = client.GetDispatchProxy(); proxy.SetCustomer(new Customer()); var journalEntry = storageProvider.CreateJournalReader().GetRecords().FirstOrDefault(); Assert.NotNull(journalEntry); Assert.IsType(typeof(SetCustomerCommand), journalEntry.Command); }
public void MapsToCommand() { var settings = new MemstateSettings(); settings.FileSystem = new InMemoryFileSystem(); var storageProvider = settings.CreateStorageProvider(); var builder = new EngineBuilder(settings, storageProvider); var engine = builder.Build <ITestModel>(new TestModel()); var client = new LocalClient <ITestModel>(engine); var proxy = client.GetDispatchProxy(); proxy.SetCustomer(new Customer()); var journalEntry = storageProvider.CreateJournalReader().GetRecords().FirstOrDefault(); Assert.NotNull(journalEntry); Assert.IsType <SetCustomerCommand>(journalEntry.Command); }
public async Task CanWriteOne(MemstateSettings settings) { settings.LoggerFactory.AddProvider(new TestOutputLoggingProvider(_log)); settings.StreamName = _randomStreamName; _log.WriteLine(settings.ToString()); var provider = settings.CreateStorageProvider(); provider.Initialize(); var writer = provider.CreateJournalWriter(0); writer.Send(new AddStringCommand("hello")); await writer.DisposeAsync().ConfigureAwait(false); var reader = provider.CreateJournalReader(); var records = reader.GetRecords().ToArray(); await reader.DisposeAsync().ConfigureAwait(false); Assert.Equal(1, records.Length); }
public void SmokeTest() { var config = new MemstateSettings(); config.FileSystem = new InMemoryFileSystem(); var initialModel = new List <string>(); var provider = config.CreateStorageProvider(); var commandStore = provider.CreateJournalWriter(0); var subscriptionSource = provider.CreateJournalSubscriptionSource(); var engine = new Engine <List <string> >(config, initialModel, subscriptionSource, commandStore, 0); var tasks = Enumerable.Range(10, 10000) .Select(n => engine.ExecuteAsync(new AddStringCommand(n.ToString()))) .ToArray(); int expected = 1; foreach (var task in tasks) { Assert.Equal(expected++, task.Result); } }
public async Task WriteAndReadCommands(MemstateSettings settings) { settings.LoggerFactory.AddProvider(new TestOutputLoggingProvider(_log)); settings.StreamName = _randomStreamName; var provider = settings.CreateStorageProvider(); provider.Initialize(); var journalWriter = provider.CreateJournalWriter(0); for (var i = 0; i < 10000; i++) { journalWriter.Send(new AddStringCommand(i.ToString())); } await journalWriter.DisposeAsync().ConfigureAwait(false); var journalReader = provider.CreateJournalReader(); var records = journalReader.GetRecords().ToArray(); await journalReader.DisposeAsync().ConfigureAwait(false); Assert.Equal(10000, records.Length); }