public void ShouldCloseSessionWhenDisposed()
{
_publisher.PublishAsync(new TestMessage());
_testScheduler.AdvanceBy(1);
_publisher.Dispose();
A.CallTo(() => _session.Close()).MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => _producer.Close()).MustHaveHappened(Repeated.Exactly.Once);
}
public void Dispose()
{
if (!_keepPublisherOpen)
{
_parentPublisher.Dispose();
}
}
/// <summary> Stops the message consumers and closes the connection. </summary>
private void Shutdown()
{
connection.Stop();
publisher.Dispose();
channel.Dispose();
connection.Dispose();
}
public override async Task StopAsync(CancellationToken cancellationToken)
{
_poller.Stop();
_poller.Dispose();
_publisher.Dispose();
_resetEvent.Set();
await base.StopAsync(cancellationToken);
}
public void ShouldThrowExceptionIfPublishAttemptedAfterDisposed()
{
_publisher = new MessagePublisher <IMessage>(_lazyConnection, _destination, _serializer, _propertyProvider, _testScheduler);
Assert.ThrowsAsync <InvalidOperationException>(async() =>
{
await _publisher.PublishAsync(new TestMessage());
_publisher.Dispose();
await _publisher.PublishAsync(new TestMessage());
});
}
public async Task ShouldCloseSessionWhenDisposed()
{
_publisher = new MessagePublisher <IMessage>(_lazyConnection, _destination, _serializer, _propertyProvider, _testScheduler);
await _publisher.PublishAsync(new TestMessage());
_publisher.Dispose();
A.CallTo(() => _session.Close()).MustHaveHappened(1, Times.Exactly);
A.CallTo(() => _producer.Close()).MustHaveHappened(1, Times.Exactly);
}
public void Dispose()
{
lock (_bufferLock)
if (!_isDisposed)
{
_isDisposed = true;
_forwardPublisher.Dispose();
_timer.Dispose();
_timer = null;
}
}
public void ShouldDisposeSourcesAndPublishers()
{
IMessageSource <IRequest> requestSource = A.Fake <IMessageSource <IRequest> >();
IMessageSource <ICommand> commandSource = A.Fake <IMessageSource <ICommand> >();
IMessagePublisher <IEvent> eventPublisher = A.Fake <IMessagePublisher <IEvent> >();
IMessagePublisher <IResponse> responsePublisher = A.Fake <IMessagePublisher <IResponse> >();
IServiceEndpoint endpoint = new ServiceEndpoint(requestSource, commandSource, eventPublisher, responsePublisher, typeof(ITestServiceMessage1));
endpoint.Dispose();
A.CallTo(() => requestSource.Dispose()).MustHaveHappened(1, Times.Exactly);
A.CallTo(() => commandSource.Dispose()).MustHaveHappened(1, Times.Exactly);
A.CallTo(() => eventPublisher.Dispose()).MustHaveHappened(1, Times.Exactly);
A.CallTo(() => responsePublisher.Dispose()).MustHaveHappened(1, Times.Exactly);
}
public override void Dispose()
{
_cts.Cancel();
if (_publisher != null)
{
_publisher.Dispose();
}
if (_receiver != null)
{
_receiver.Dispose();
}
base.Dispose();
}
public void ShouldUnsubcribeOnDispose()
{
IMessagePublisher <TestMessage> publisher = A.Fake <IMessagePublisher <TestMessage> >();
IMessageSource <TestMessage> source = A.Fake <IMessageSource <TestMessage> >();
IMessageBridge bridge = new MessageBridge <TestMessage, TestMessage>(publisher, A.Fake <IMessageConverter <TestMessage, TestMessage> >(), source);
IDisposable subscription = A.Fake <IDisposable>();
A.CallTo(() => source.Messages.Subscribe(A <IObserver <TestMessage> > .Ignored)).Returns(subscription);
bridge.Start();
bridge.Dispose();
A.CallTo(() => subscription.Dispose()).MustHaveHappenedOnceExactly();
A.CallTo(() => publisher.Dispose()).MustHaveHappenedOnceExactly();
}
public void Dispose()
{
Log("disposing");
_cts.Cancel();
if (Publisher != null)
{
Publisher.Dispose();
}
if (Receiver != null)
{
Receiver.Dispose();
}
}
public async Task ShouldDiscardMessagesThatAreStillQueuedOnSchedulerAfterDispose()
{
_publisher = new MessagePublisher <IMessage>(_lazyConnection, _destination, _serializer, _propertyProvider, _testScheduler);
var message1 = new TestMessage();
var message2 = new TestMessage();
await _publisher.PublishAsync(message1);
A.CallTo(() => _producer.Send(_message, MsgDeliveryMode.NonPersistent, MsgPriority.Normal, TimeSpan.Zero)).MustHaveHappened(1, Times.Exactly);
await _publisher.PublishAsync(message2);
_publisher.Dispose();
A.CallTo(() => _producer.Send(_message, MsgDeliveryMode.NonPersistent, MsgPriority.Normal, TimeSpan.Zero)).MustHaveHappened(2, Times.Exactly);
}
protected override void Disposing()
{
_messagePublisher.Dispose();
}
public void Dispose()
{
messagePublisher.Dispose();
}
public void Dispose()
{
Stop();
_publisher.Dispose();
}
public void Dispose()
{
messageProcessor.Dispose();
}
public void Dispose()
{
_messagePublisher.Dispose();
_messageSubscriber.Dispose();
}
public void Dispose()
{
_messagePublisher?.Dispose();
}
