public void DefaultValueIsEmptyString() { var bus = new DurableMessageBus(new RetryPolicy()); Assert.That(bus.MessageVersion, Is.Not.Null); Assert.That(bus.MessageVersion, Is.Empty); }
public async Task SetUp() { await ClearAllDataFiles(); var retryPolicy = new RetryPolicy(1, DateTimeUtility.PositiveOneHourTimeSpan); _bus = new DurableMessageBus(retryPolicy); _commands = new CommandSubscribers(); _events = new EventSubscribers(); _bus.RegisterSubscriptionFor <TestDurableCommand>(_commands.Handle); _bus.RegisterSubscriptionFor <TestDurableEvent>(_events.Handle); }
public async Task SetUp() { await ClearAllDataFiles(); var retryPolicy = new RetryPolicy(); Assume.That(retryPolicy.Retries, Is.EqualTo(0)); _bus = new DurableMessageBus(retryPolicy); _commands = new CommandSubscribers(); _events = new EventSubscribers(); _bus.RegisterSubscriptionFor <TestDurableCommand>(_commands.Handle); _bus.RegisterSubscriptionFor <TestDurableEvent>(_events.Handle); }
public async Task CanRepublishDurableCommandsOnNextStart() { await SendUnacknowledgedCommandAndEventTwiceThenDisposeDurableBus(); //recreate the bus from scratch _bus = new DurableMessageBus(_retryPolicy); //re-register the command subscriber _bus.RegisterSubscriptionFor <TestDurableCommand>(_commands.Handle); //calling start should re-hydrate the list of pending (unacknowledged) commands // and then process them using the re-registered subscriber await _bus.Start(); //we should now have one more payload element received Assert.That(_commands.ProcessedMessagePayload, Is.EqualTo(_tripleValue), "Command not properly re-hydrated."); }
public async Task DurableEventsWithoutMatchingVersionAreDiscardedOnBusStart() { await SendUnacknowledgedCommandAndEventTwiceThenDisposeDurableBus(); //recreate the bus from scratch, set the version to be something *other* than the default empty string _bus = new DurableMessageBus(_retryPolicy) { MessageVersionProvider = () => "not-the-default" }; //re-register the event subscriber _bus.RegisterSubscriptionFor <TestDurableEvent>(_events.Handle); //calling start should re-hydrate the list of pending (unacknowledged) events // and then process them using the re-registered subscriber await _bus.Start(); //because the version of the command doesn't match, we should still only have original two payload elements received Assert.That(_events.ProcessedMessagePayload, Is.EqualTo(_doubleValue), "Event with wrong version not properly ignored."); }
public void VersionIsCachedAfterInitialCalculationAndNotRecalculated() { const string expected = "1"; const string notExpected = "2"; var versionProvider = new VersionProvider { Version = expected }; var bus = new DurableMessageBus(new RetryPolicy()) { MessageVersionProvider = () => versionProvider.Version }; Assume.That(bus.MessageVersion, Is.EqualTo(expected), "MessageVersionProvider delegate not wired up properly."); //this changes the value that would be returned by the delegate, should it improperly be invoked a second time versionProvider.Version = notExpected; //since the delegate should NOT be invoked a second time, we expect the original value to be retained Assert.That(bus.MessageVersion, Is.EqualTo(expected)); }
public async Task MessageIsNotSendToSubscriberOnStart() { const string singleValue = "0"; //we need a retry policy with at least one retry // so that we'd expect the call to Start() to attempt a retry var retryPolicy = new RetryPolicy(1, DateTimeUtility.PositiveOneHourTimeSpan); var bus = new DurableMessageBus(retryPolicy); var commands = new CommandSubscribers(); bus.RegisterSubscriptionFor <TestDurableCommand>(commands.Handle); await bus.SendDurable(new TestDurableCommand(singleValue)); Assume.That(commands.ProcessedMessagePayload, Is.EqualTo(singleValue), "Command Subscriber didn't receive the expected message."); bus.UnRegisterAllSubscriptionsFor <TestDurableCommand>(); await bus.Start(); Assert.That(commands.ProcessedMessagePayload, Is.EqualTo(singleValue), "Bus did not properly ignore queued command."); }
private async Task SendUnacknowledgedCommandAndEventTwiceThenDisposeDurableBus() { _doubleValue = string.Format("{0}{0}", SingleValue); _tripleValue = string.Format("{0}{0}{0}", SingleValue); _retryPolicy = new RetryPolicy(10, DateTimeUtility.PositiveOneHourTimeSpan); _bus = new DurableMessageBus(_retryPolicy); _commands = new DurableCommandSubscribers(); _events = new DurableEventSubscribers(); _bus.RegisterSubscriptionFor <TestDurableCommand>(_commands.Handle); _bus.RegisterSubscriptionFor <TestDurableEvent>(_events.Handle); await _bus.SendDurable(new TestDurableCommand(SingleValue)); await _bus.PublishDurable(new TestDurableEvent(SingleValue)); Assume.That(_commands.ProcessedMessagePayload, Is.EqualTo(SingleValue), "Command Subscriber not registered for command as expected."); Assume.That(_events.ProcessedMessagePayload, Is.EqualTo(SingleValue), "Event Subscriber not registered for event as expected."); await _bus.Start(); Assume.That(_commands.ProcessedMessagePayload, Is.EqualTo(_doubleValue), "Command Subscriber not registered for command as expected."); Assume.That(_events.ProcessedMessagePayload, Is.EqualTo(_doubleValue), "Event Subscriber not registered for event as expected."); await _bus.Stop(); _bus = null; Assume.That(_bus, Is.Null); }
/// <summary> /// Initializes the singleton application object. This is the first line of authored code /// executed, and as such is the logical equivalent of main() or WinMain(). /// </summary> public App() { RunningLog = new ObservableCollection <string>(); TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException; Bus = new DurableMessageBus() { Logger = text => { Debug.WriteLine(text); RunningLog.Add(text); } }; ViewModels = new ViewModelManager(); var registrar = new SubscriberRegistrar(Bus, ViewModels); registrar.RegisterMessageBusSubscribers(); this.InitializeComponent(); this.Suspending += OnSuspending; }
public async Task AcknowledgeLastMessage(DurableMessageBus bus) { await bus.Acknowledge(Messages.Last()); }
public SubscriberRegistrar(DurableMessageBus messageBus, IManageViewModels modelManager) { _messageBus = messageBus; _modelManager = modelManager; }
public IncrementCounterCommandHandler(DurableMessageBus bus) { _bus = bus; }
public CounterIncrementedViewModelEventHandler(DurableMessageBus bus, IManageViewModels modelManager) { _bus = bus; _modelManager = modelManager; }