| public static Publish ( object message ) : void | ||
| message | object | |
| return | void | |
public void CanPublish()
{
var mockRepository = new MockRepository();
var config = mockRepository.DynamicMock<IBrokerConfiguration>();
var connFactory = mockRepository.DynamicMock<IBrokerConnectionFactory>();
var conn = mockRepository.DynamicMock<IBrokerConnection>();
var consumer = mockRepository.DynamicMock<IRegisteredConsumer>();
var message = new TestMessage();
using (mockRepository.Record())
{
SetupResult.For(consumer.MessageType).Return(typeof(TestMessage));
SetupResult.For(connFactory.CreateConnection()).Return(conn);
SetupResult.For(config.Exchange).Return("ex");
SetupResult.For(config.ConnectionFactory).Return(connFactory);
SetupResult.For(config.RegisteredConsumers).Return(new Dictionary<Type, IList<IRegisteredConsumer>> { { typeof(TestMessage), new List<IRegisteredConsumer> { consumer } } }); ;
SetupResult.For(conn.IsOpen).Return(true);
Expect.Call(() => conn.Publish<TestMessage>(null))
.IgnoreArguments()
.WhenCalled(mi =>
{
var envelope = mi.Arguments[0];
Assert.IsAssignableFrom(typeof(IMessageEnvelope<TestMessage>), envelope);
Assert.Same(message, ((IMessageEnvelope<TestMessage>)envelope).Message);
});
}
using (mockRepository.Playback())
{
var bus = new Bus(config);
bus.Publish(message);
}
}
public void EventTest()
{
var bus = new Bus(null, new HandlerRegistry());
int called = 0;
bus.Subscribe<WidgetCreatedEvent>((x) => called++);
bus.Subscribe<WidgetCreatedEvent>((x) => called++);
bus.Publish(new WidgetCreatedEvent());
Assert.AreEqual(2, called);
}
public void When_testing_something()
{
var bus1 = new Bus();
bus1.Subscribe("first", x => _output.WriteLine("Bus1 => ({0}) => {1}", "first", x.Json));
bus1.Subscribe("second", x => _output.WriteLine("Bus1 => ({0}) => {1}", "second", x.Json));
var bus2 = new Bus();
bus2.Subscribe("first", x => _output.WriteLine("Bus2 => ({0}) => {1}", "first", x.Json));
bus2.Subscribe("second", x => _output.WriteLine("Bus2 => ({0}) => {1}", "second", x.Json));
var exchange = new Exchange();
exchange.AddBus(bus1);
exchange.AddBus(bus2);
bus1.Publish("first", new Message { Json = "a message"});
}
public void CreatesNewConnectionIfConnectionClosedWhenPublishing()
{
var mockRepository = new MockRepository();
var config = mockRepository.DynamicMock<IBrokerConfiguration>();
var connFactory = mockRepository.DynamicMock<IBrokerConnectionFactory>();
var conn = mockRepository.DynamicMock<IBrokerConnection>();
var consumer = mockRepository.DynamicMock<IRegisteredConsumer>();
var message = new TestMessage();
using (mockRepository.Record())
{
SetupResult.For(consumer.MessageType).Return(typeof (TestMessage));
SetupResult.For(config.Exchange).Return("ex");
SetupResult.For(config.ConnectionFactory).Return(connFactory);
SetupResult.For(config.RegisteredConsumers).Return(new Dictionary<Type, IList<IRegisteredConsumer>> { { typeof(TestMessage), new List<IRegisteredConsumer> { consumer } } }); ;
SetupResult.For(conn.IsOpen).Return(false);
Expect.Call(connFactory.CreateConnection()).Repeat.Times(4).Return(conn);
}
using (mockRepository.Playback())
{
var bus = new Bus(config);
bus.Publish(message);
bus.Publish(message);
}
}
private void NotifyEndpointIsDown()
{
Bus.Publish(new EndpointIsDown(CorrelationId, ControlUri, DataUri, HeartbeatIntervalInSeconds, LastHeartbeat, Down.Name));
}
public async Task Should_succeed()
{
await Bus.Publish(new PingMessage());
await _handler;
}
public async Task Should_receive_message()
{
await Bus.Publish(new PingMessage());
await _handled;
}
public async Task Should_be_received_properly()
{
await Bus.Publish <PingMessage>(new {});
ConsumeContext <PingMessage> context = await _received;
}
public void Handle(ReplicationMessage.DataChunkBulk message)
{
Interlocked.Decrement(ref FlushMessagesInQueue);
try
{
if (_subscriptionId != message.SubscriptionId)
{
return;
}
if (_activeChunk != null)
{
ReplicationFail(
"Data chunk bulk received, but we have active chunk for receiving raw chunk bulks.",
"Data chunk bulk received, but we have active chunk for receiving raw chunk bulks.");
}
var chunk = Writer.CurrentChunk;
if (chunk.ChunkHeader.ChunkStartNumber != message.ChunkStartNumber || chunk.ChunkHeader.ChunkEndNumber != message.ChunkEndNumber)
{
Log.Error("Received DataChunkBulk for TFChunk {chunkStartNumber}-{chunkEndNumber}, but active chunk is {activeChunkStartNumber}-{activeChunkEndNumber}.",
message.ChunkStartNumber, message.ChunkEndNumber, chunk.ChunkHeader.ChunkStartNumber, chunk.ChunkHeader.ChunkEndNumber);
return;
}
if (_subscriptionPos != message.SubscriptionPosition)
{
Log.Error("Received DataChunkBulk at SubscriptionPosition {subscriptionPosition} (0x{subscriptionPosition:X}) while current SubscriptionPosition is {subscriptionPos} (0x{subscriptionPos:X}).",
message.SubscriptionPosition, message.SubscriptionPosition, _subscriptionPos, _subscriptionPos);
return;
}
_framer.UnFrameData(new ArraySegment <byte>(message.DataBytes));
_subscriptionPos += message.DataBytes.Length;
if (message.CompleteChunk)
{
Log.Trace("Completing data chunk {chunkStartNumber}-{chunkEndNumber}...", message.ChunkStartNumber, message.ChunkEndNumber);
Writer.CompleteChunk();
if (_framer.HasData)
{
ReplicationFail(
"There is some data left in framer when completing chunk.",
"There is some data left in framer when completing chunk.");
}
_subscriptionPos = chunk.ChunkHeader.ChunkEndPosition;
_framer.Reset();
}
}
catch (Exception exc)
{
Log.ErrorException(exc, "Exception in writer.");
throw;
}
finally
{
Flush();
}
if (message.CompleteChunk || _subscriptionPos - _ackedSubscriptionPos >= MasterReplicationService.ReplicaAckWindow)
{
_ackedSubscriptionPos = _subscriptionPos;
Bus.Publish(new ReplicationMessage.AckLogPosition(_subscriptionId, _ackedSubscriptionPos));
}
}
public void Timeout(StartsSaga state)
{
Bus.Publish <MyEvent>();
MarkAsComplete();
}
public void Publish(IEnumerable <IPublishableEvent> eventMessages)
{
Bus.Publish(eventMessages.Select(CreateEventMessage).ToArray());
}
public void Publish(IPublishableEvent eventMessage)
{
Bus.Publish(CreateEventMessage(eventMessage));
}
public void Publish_EmptyEventsParameter_ShouldThrowException()
{
var sut = new Bus(null, new HandlerFactoryTestHelper().GetEventHandlers);
Assert.Throws <ArgumentException>(() => sut.Publish(new List <IEvent>().ToArray()), "The events parameter is null or empty.");
}
public void Handle(TestMessage message)
{
Bus.Publish(ModifyPublish);
}
public void PublishShouldGetProducerFromContainer()
{
// Arrange
var mockConfiguration = new Mock<IConfiguration>();
var mockProducer = new Mock<IProducer>();
var mockContainer = new Mock<IBusContainer>();
var mockProessManagerFinder = new Mock<IProcessManagerFinder>();
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProcessManagerFinder()).Returns(mockProessManagerFinder.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings ());
// Act
var bus = new Bus(mockConfiguration.Object);
bus.Publish(new FakeMessage1(Guid.NewGuid()), null);
// Assert
mockConfiguration.Verify(x => x.GetProducer(), Times.Once());
}
public void publish_without_starting_bus_should_throw_exception()
{
Func <Task> action = () => bus.Publish(new CatEvent());
action.ShouldThrow <InvalidOperationException>().Where(e => e.Message.Contains("start"));
}
public void Consume(IVisitAddedOrChangedMessage message)
{
Console.WriteLine("VisitAddedOrChangedMessage received. VisitId: {0}", message.VisitId);
Bus.Publish(new RepricingRequestMessage(CorrelationId, message.VisitId));
}