public void One_Publisher_One_Subscriber_Batch_Broadcast()
{
using (var publisher = new Publisher())
using (var subscriber = new Subscriber())
{
var endpoint = GetEndpoint();
publisher.Bind(endpoint);
subscriber.Connect(endpoint);
Thread.Sleep(100);
var counterSignal = new CounterSignal(NumberOfMessagesToReceive);
subscriber.MessageReceived += (s, m) => counterSignal.Increment();
var messageSent = new TestMessage();
var batch = new List<TestMessage>();
for (var i = 0; i < NumberOfMessagesToReceive; i++)
batch.Add(messageSent);
var sw = Stopwatch.StartNew();
publisher.Broadcast(batch);
Assert.IsTrue(counterSignal.Wait(TimeOut), "Timeout waiting for message");
sw.Stop();
Assert.Inconclusive("{0} elapsed reading {1} messages ({2:N0} per second)", sw.Elapsed, NumberOfMessagesToReceive, NumberOfMessagesToReceive / sw.Elapsed.TotalSeconds);
}
}
public void SerialiseMessageWithGuid()
{
var message = new TestMessage { Id = Guid.Parse("C50DDB56-B827-46E3-9D7D-ACB701882624") };
var serialisedMessage = this.componentUnderTest.Serialise(message);
Assert.That(serialisedMessage, Is.EqualTo(MessageWithGuid));
}
public void Should_properly_arrive_at_the_destination()
{
var serviceUri = new Uri("net.pipe://localhost/pipe");
string pipeName = "test";
var future = new Future<TestMessage>();
var message = new TestMessage
{
Id = Guid.NewGuid(),
Name = "Alpha",
};
UntypedChannel adapter = new ChannelAdapter();
using (var remote = new WcfChannelHost(new SynchronousFiber(), adapter, serviceUri, pipeName))
{
using (adapter.Connect(x =>
{
x.AddConsumerOf<TestMessage>()
.UsingConsumer(m => future.Complete(m));
}))
{
var client = new WcfChannelProxy(new SynchronousFiber(), serviceUri, pipeName);
client.Send(message);
future.WaitUntilCompleted(2.Seconds()).ShouldBeTrue();
}
}
future.Value.ShouldNotBeNull();
future.Value.ShouldEqual(message);
future.Value.ShouldNotBeTheSameAs(message);
}
public void ShouldForwardPolymorphicMessage()
{
var handler = new TestEventHandler();
var message = new TestMessage();
EventFns.Forward(handler, message);
Assert.IsTrue(handler.IMessageHandled, "Message should have been handled");
}
public void ServiceQueue_1_Writer_1_Reader(ServiceQueueRotationAlgorithm algorithm)
{
using (var serviceQueue = new ServiceQueue(algorithm))
using (var reader = new ServiceQueueReader())
using (var writer = new ServiceQueueWriter())
{
var endpoint = GetEndpoint();
serviceQueue.Bind(endpoint);
var counterSignal = new CounterSignal(NumberOfMessages, 0);
reader.MessageReceived += (s, m) => counterSignal.Increment();
reader.Connect(endpoint);
writer.Connect(endpoint);
var messageSent = new TestMessage();
var sw = Stopwatch.StartNew();
for (var i = 0; i < NumberOfMessages; i++)
{
writer.SendMessage(messageSent);
}
Assert.IsTrue(counterSignal.Wait(TimeOut), "Timeout waiting for message");
sw.Stop();
Assert.Inconclusive("{0} elapsed reading {1} messages ({2:N0} per second)", sw.Elapsed, NumberOfMessages, NumberOfMessages / sw.Elapsed.TotalSeconds);
}
}
public void SetsTheValueOfTheMessageProperty()
{
var message = new TestMessage();
var routeResult = new RouteResult(message, null);
Assert.That(routeResult.Message, Is.SameAs(message));
}
public void Should_be_able_to_serialize_and_deserialize_a_message()
{
var initialMessage = new TestMessage {Text = "Hello!"};
var serializedMessage = serializer.MessageToBytes(initialMessage);
var deserializedMessage = serializer.BytesToMessage<TestMessage>(serializedMessage);
deserializedMessage.Text.ShouldEqual(initialMessage.Text);
}
public void TestBroker()
{
TestMessage message = new TestMessage {Id = Guid.NewGuid(), Text = "Some text"};
MessageBroker broker = new MessageBroker();
broker.Write(message);
TestMessage readMessage = broker.Read<TestMessage>(0);
Assert.IsNotNull(readMessage);
}
public void GetInstance_NullInstanceContext()
{
var data = new ServiceImplementationData();
var container = new ContainerBuilder().Build();
var provider = new AutofacInstanceProvider(container, data);
var message = new TestMessage();
Assert.Throws<ArgumentNullException>(() => provider.GetInstance(null, message));
}
public void send_waiting_message_fires_event_hooks ()
{
var msg = new TestMessage();
((SenderNode)_subject).SendMessage(msg);
_eventHook1.Received().MessageSent(msg);
_eventHook2.Received().MessageSent(msg);
}
public void Definition_should_allow_to_retrieve_proper_correlation_id()
{
var message = new TestMessage { FirstId = Guid.NewGuid(), SecondId = Guid.NewGuid() };
var def1 = MessageDefinition.Create<TestMessage>(m => m.FirstId);
var def2 = MessageDefinition.Create<TestMessage>(m => m.SecondId);
Assert.That(def1.GetCorrelationId(message), Is.EqualTo(message.FirstId), "It should use FirstId");
Assert.That(def2.GetCorrelationId(message), Is.EqualTo(message.SecondId), "It should use SecondId");
}
public void ExpectExceptionForUnreadableData()
{
var message = new TestMessage { content = "This message cannot be resolved!", ID = 0 };
var memoryStream = new MemoryStream(new byte[64]);
var binaryWriter = new BinaryWriter(memoryStream);
binaryWriter.Write(BinaryDataExtensions.ToByteArray(message));
memoryStream.Position = 0;
var binaryReader = new BinaryReader(memoryStream);
Assert.Throws<TypeLoadException>(() => binaryReader.Create());
}
public void Publish_calls_the_method_on_subscriber()
{
var simplePublishWay = new SimpleDispatcher();
var message = new TestMessage();
var handler = new TestHandler();
simplePublishWay.Invoke(message, handler);
Assert.That(handler.TestMessage, Is.SameAs(message));
}
public async Task WaitsForFirstMessage() {
var task = this.EventManager.WaitFor<TestMessage, SecondTestMessage>();
var testMessage = new TestMessage();
this.MessageBus.Send(testMessage);
this.React();
var result = await task;
Assert.AreEqual(result, testMessage);
}
public void SerialiseAndDeserialiseMessage()
{
var componentUnderTest = new JsonMessageSerialiser();
var message = new TestMessage();
var serialisedMessage = componentUnderTest.Serialise(message);
var deserialisedMessage = componentUnderTest.Deserialise(serialisedMessage, typeof(TestMessage));
Assert.That(deserialisedMessage, Is.Not.Null);
}
private static void AssertDispatchesCall(SynchronizationContextDispatcher dispatcher)
{
var handler = new TestHandler();
var message = new TestMessage();
dispatcher.Invoke(message, handler);
handler.Called.WaitOne(1000);
Assert.That(handler.TestMessage, Is.SameAs(message));
}
public void Should_no_throw_if_no_dispatcher_found_and_set_to_ignore()
{
var assignee = new SimpleSubscriber();
var handler = new TestHandler();
var message = new TestMessage();
var publisher = new Publisher(new PublisherSettings{IgnoreNoDispatcher = true},assignee, new[] { new SimpleDispatcher(new Rule(x => false)) });
assignee.Subscribe(handler);
Should.NotThrow(() => publisher.Publish(message));
}
private void When_I_Send_A_Message()
{
try
{
_testMessage = new TestMessage();
_messageBus.Send(_testMessage);
}
catch (NoHandlerException e)
{
_expectedException = e;
}
}
public async Task Reply_ShouldContainMessageInRepliedMessages()
{
var context = new TestableMessageHandlerContext();
var messageInstance = new TestMessage();
var publishOptions = new ReplyOptions();
await context.Reply(messageInstance, publishOptions);
Assert.AreEqual(1, context.RepliedMessages.Length);
Assert.AreSame(messageInstance, context.RepliedMessages[0].Message);
Assert.AreSame(publishOptions, context.RepliedMessages[0].Options);
}
public void Publish_calls_the_method_on_subscriber()
{
var simplePublishWay = new SimpleDispatcher();
var message = new TestMessage();
var handler = new TestHandler();
var tuple = new MessageHandlerTuple(message, handler);
var result = simplePublishWay.TryInvoke(ref tuple);
Assert.That(result, Is.True);
Assert.That(handler.TestMessage, Is.SameAs(message));
}
public void SubscribeAndPublish()
{
var message = new TestMessage (this);
messenger.Subscribe<TestMessage> (m => {
Assert.That (m, Is.EqualTo (message));
Assert.That (m.Sender, Is.EqualTo (this));
});
messenger.Publish (message);
}
public void Should_not_fail_if_onle_one_dispatcher_can_dispath_message()
{
var assignee = new SimpleSubscriber();
var dispatcher = new SimpleDispatcher();
var handler = new TestHandler();
var message = new TestMessage();
var publisher = new Publisher(assignee, new[] { dispatcher, new SimpleDispatcher(new Rule(x => false)) });
assignee.Subscribe(handler);
Should.NotThrow(() => publisher.Publish(message));
}
public void Should_not_throw_if_multiple_dispather_can_dispatch_a_message_and_set_to_ignore()
{
var assignee = new SimpleSubscriber();
var dispatcher = new SimpleDispatcher();
var handler = new TestHandler();
var message = new TestMessage();
var publisher = new Publisher(new PublisherSettings{IgnoreMultipleDispatcher = true}, assignee, new[] { dispatcher, dispatcher });
assignee.Subscribe(handler);
Should.NotThrow(() => publisher.Publish(message));
}
public async Task Send_ShouldContainMessageInSentMessages()
{
var context = new TestableMessageHandlerContext();
var messageInstance = new TestMessage();
var sendOptions = new SendOptions();
await context.Send(messageInstance, sendOptions);
Assert.AreEqual(1, context.SentMessages.Length);
Assert.AreSame(messageInstance, context.SentMessages[0].Message);
Assert.AreSame(sendOptions, context.SentMessages[0].Options);
}
public async Task Verify_consumed_message_contains_property()
{
ITestMessage message = new TestMessage
{
Data = new TestConcreteClass()
};
await InputQueueSendEndpoint.Send(message);
ConsumeContext<ITestMessage> context = await _handled;
Assert.IsInstanceOf<TestConcreteClass>(context.Message.Data);
}
public void Publish_will_send_the_message_to_listner()
{
var assignee = new SimpleSubscriber();
var dispatcher = new SimpleDispatcher();
var handler = new TestHandler();
var message = new TestMessage();
var publisher = new Publisher(assignee, new[] {dispatcher});
assignee.Subscribe(handler);
publisher.Publish(message);
Assert.That(handler.TestMessage, Is.SameAs(message));
}
public static string GetValue(TestMessage msg)
{
switch (msg)
{
case TestMessage.Error:
return "ERROR";
case TestMessage.Warning:
return "WARNING";
case TestMessage.Note:
return "NOTE";
default:
return string.Empty;
}
}
public void Should_decrement_projection()
{
// Arrange
var message = new TestMessage();
var projection = new TestProjection {ProjectionProperty = 5};
var builder = new AddNewProjectionStrategyArguments<TestMessage, TestProjection>();
builder.Decrement(p => p.ProjectionProperty);
// Act
builder.Mappers.Map(message, projection);
// Assert
Assert.AreEqual(4, projection.ProjectionProperty);
}
public void Should_do_lambda_expression()
{
// Arrange
var message = new TestMessage {MessageProperty = 5};
var projection = new TestProjection {ProjectionProperty = 5};
var builder = new AddNewProjectionStrategyArguments<TestMessage, TestProjection>();
builder.Do((e, p) => p.ProjectionProperty = p.ProjectionProperty*e.MessageProperty);
// Act
builder.Mappers.Map(message, projection);
// Assert
Assert.AreEqual(25, projection.ProjectionProperty);
}
private static void AssertDispatchesCall(SynchronizationContextDispatcher dispatcher)
{
var handler = new TestHandler();
var message = new TestMessage();
var tuple = new MessageHandlerTuple(message, handler);
var invoked = dispatcher.TryInvoke(ref tuple);
handler.Called.WaitOne(1000);
Assert.That(invoked, Is.True);
Assert.That(handler.TestMessage, Is.SameAs(message));
}
public void When_Received_Succsessfully_With_Json_Then_True()
{
var services = new ServiceCollection();
services
.AddLogging()
.AddMessaging(
mc => mc
.UseJsonPacker(jss => { })
.UseRabbitMQ(cfb => cfb.Uri = new Uri("###")),
sc => sc.AddSingleton <IMessageHandler <TestMessage>, TestMessageHandler>()
);
var serviceProvider = services.BuildServiceProvider();
var publisher = serviceProvider.GetRequiredService <IMessagePublisher>();
var router = serviceProvider.GetRequiredService <IMessageRouter>();
var testMessage = new TestMessage();
publisher.Publish(testMessage, CancellationToken.None).GetAwaiter().GetResult();
router.Route(CancellationToken.None).GetAwaiter().GetResult();
}
public void Validate_NoError()
{
var message = new TestMessage()
{
HeaderEntity = new TestHeader()
{
SourceEntity = new TestSource()
{
UKPRN = 123456
}
}
};
var fileDataServiceMock = new Mock <IFileDataService>();
fileDataServiceMock.Setup(fds => fds.FileName()).Returns("ILR_123456");
fileDataServiceMock.Setup(fds => fds.FileNameUKPRN()).Returns(123456);
using (var validationErrorHandlerMock = BuildValidationErrorHandlerMockForNoError())
{
NewRule(validationErrorHandler: validationErrorHandlerMock.Object, fileDataService: fileDataServiceMock.Object).Validate(message);
}
}
public void DefaultConstructorTest()
{
var newMessage = new TestMessage();
Assert.AreEqual(0, newMessage.SourceID);
Assert.IsNull(newMessage.ConversationID);
Assert.IsNull(newMessage.MessageID);
var sid = 1;
var cid = "3-1-3";
var mid = "4-2-3";
var m = new TestMessage
{
SourceID = sid,
ConversationID = cid,
MessageID = mid
};
Assert.AreEqual(sid, m.SourceID);
Assert.AreEqual(cid, m.ConversationID);
Assert.AreEqual(mid, m.MessageID);
}
public void UniqueSTDCodesFromMessage_NullValues()
{
var message = new TestMessage()
{
Learners = new List <TestLearner>()
{
new TestLearner()
{
LearningDeliveries = new List <TestLearningDelivery>()
{
new TestLearningDelivery()
{
StdCodeNullable = null
}
}
}
}
};
var result = NewService().UniqueSTDCodesFromMessage(message);
result.Should().BeEmpty();
}
private static void Client_OnMessageReceived(string message)
{
ReceivedMessage receivedMessage = JsonConvert.DeserializeObject <ReceivedMessage>(message);
if (receivedMessage != null && receivedMessage.Messages != null && receivedMessage.Messages.Count > 0)
{
foreach (var msg in receivedMessage.Messages)
{
switch (msg.Method)
{
case "updateMsg":
TestMessage testMessage = JsonConvert.DeserializeObject <TestMessage>(msg.Values[0].ToString());
logger.InfoFormat("Received msg:{0}", testMessage.ToString());
break;
case "testMsg":
string ms = msg.Values[0].ToString();
logger.InfoFormat("Received msg:{0}", ms);
break;
}
}
}
}
public async Task ShouldSend(
[Frozen] Stream stream,
[Frozen] Mock <IProtobufStreamSerializer> protobuf,
[Frozen] Mock <IProtobufFieldNumberCache> cache,
byte[] writtenBytes,
TestMessage message,
ProtobufConnection sut)
{
cache.Setup(x => x.GetFieldNumber(typeof(TestMessage)))
.Returns(5);
Stream writeStream = null !;
protobuf.Setup(x => x.Serialize(It.IsAny <MemoryStream>(), message, 5))
.Callback <Stream, object, int>((stream, message, fieldNumber) =>
{
writeStream = stream;
writeStream.Write(writtenBytes, 0, writtenBytes.Length);
});
await sut.SendAsync(message, Cts.Token);
protobuf.Verify(x => x.Serialize(It.IsAny <MemoryStream>(), message, 5));
// Temporary stream should be disposed.
Assert.Throws <ObjectDisposedException>(
() => writeStream.Read(Array.Empty <byte>(), 0, 0));
// Should write the value to stream.
Assert.NotEmpty(writtenBytes);
var resultBytes = new byte[writtenBytes.Length];
stream.Seek(0, SeekOrigin.Begin);
await stream.ReadAsync(resultBytes.AsMemory(0, writtenBytes.Length));
Assert.Equal(writtenBytes, resultBytes);
}
public async Task WithMessageHandlerWithCustomContext_WithMessageContextFilterWithMessageBodySerializerWithMessageHandlerImplementationFactory_UsesSerializer(bool matches)
{
// Arrange
var services = new MessageHandlerCollection(new ServiceCollection());
var expectedBody = $"test-message-body-{Guid.NewGuid()}";
var expectedMessage = new TestMessage();
var expectedContext = TestMessageContext.Generate();
var serializer = new TestMessageBodySerializer(expectedBody, expectedMessage);
var expectedHandler = new TestMessageHandler();
// Act
services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(
messageContextFilter: context =>
{
Assert.Same(expectedContext, context);
return(matches);
},
messageBodySerializer: serializer,
messageHandlerImplementationFactory: serviceProvider => expectedHandler);
// Assert
IServiceProvider provider = services.Services.BuildServiceProvider();
IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance);
Assert.NotNull(handlers);
MessageHandler handler = Assert.Single(handlers);
Assert.NotNull(handler);
Assert.Same(expectedHandler, handler.GetMessageHandlerInstance());
bool actual = handler.CanProcessMessageBasedOnContext(expectedContext);
Assert.Equal(matches, actual);
MessageResult result = await handler.TryCustomDeserializeMessageAsync(expectedBody);
Assert.NotNull(result);
Assert.Same(expectedMessage, result.DeserializedMessage);
}
public async Task WhenReceiveShouldValidateMaxNumberOfMessages(int maxNumberOfMessages)
{
//Arrange
var amazonSqsMock = new Mock <IAmazonSQS>();
var configurationMock = new Mock <IConfiguration>();
var messageQueueOptions = new MessageQueueOptions();
var msg = new TestMessage()
{
Id = Guid.NewGuid().ToString()
};
amazonSqsMock.Setup(x => x.ReceiveMessageAsync(It.IsAny <ReceiveMessageRequest>(), CancellationToken.None))
.ReturnsAsync(new ReceiveMessageResponse()
{
Messages = new List <Message>()
{
new Message()
{
Body = JsonConvert.SerializeObject(msg),
ReceiptHandle = Guid.NewGuid().ToString()
}
}
})
.Verifiable();
configurationMock.SetupGet(x => x[It.IsAny <string>()]).Returns(string.Empty);
var queue = new MessageQueueSqs(amazonSqsMock.Object, messageQueueOptions, new MessageQueueInfo(messageQueueOptions, configurationMock.Object));
//Act
async Task act() => await queue.Receive <TestMessage>(maxNumberOfMessages)
.GetAsyncEnumerator()
.MoveNextAsync();
//Assert
await Assert.ThrowsAsync <ArgumentException>(act);
}
public void TestIocMessageBus()
{
IKernel kernel = new StandardKernel();
//inital service locator
ServiceLocator.SetLocatorProvider(() => new NinjectServiceLocator(kernel));
//we can also use IoC, instead of "new IoC.MessageBus()"
kernel.Bind <IMessageBus>().To <Messaging.IoC.MessageBus>().InSingletonScope(); //make it singleton
var msg = new TestMessage();
//get instance of bus
IMessageBus bus = kernel.Get <IMessageBus>();
//see what will happen if publish right away
Assert.IsFalse(bus.Publish(msg)); //return false if no handlers
Assert.IsFalse(msg.Handled); //not handled, since no handlers in bus yet
//configure the handlers
kernel.Bind <IHandler <TestMessage> >().To <TertiaryTestMessageHandler>();
kernel.Bind <IHandler <TestMessage> >().To <PrimaryTestMessageHandler>();
kernel.Bind <IHandler <TestMessage> >().To <SecondaryTestMessageHandler>();
Stopwatch sw = Stopwatch.StartNew();
bus.Publish(msg);
sw.Stop();
Console.WriteLine(sw.ElapsedMilliseconds);
Assert.IsTrue(msg.Handled);
//also handled sequentially
Assert.AreEqual(typeof(PrimaryTestMessageHandler).Name, msg.HandledBy[0]);
Assert.AreEqual(typeof(SecondaryTestMessageHandler).Name, msg.HandledBy[1]);
Assert.AreEqual(typeof(TertiaryTestMessageHandler).Name, msg.HandledBy[2]);
}
public void MessageDescriptor_Should_Properly_Pack_A_Message_Proto(int messageType, string data, params string[] arguments)
{
var protobufMessage = new TestMessage {
Data = data
};
var protobufMessageSerialized = protobufMessage.ToByteArray();
var argumentsDescriptors = GetArgumentsDescriptors(arguments);
var totalLength = protobufMessageSerialized.Length + argumentsDescriptors.Sum(argument => argument.Argument.Length + ProtobufHubProtocolConstants.ARGUMENT_HEADER_LENGTH) + 4; //Int => // ProtobufMessageLength
ReadOnlySpan <byte> messagePacked = MessageDescriptor.PackMessage(messageType, protobufMessageSerialized, argumentsDescriptors);
Assert.Equal(messageType, messagePacked[0]);
Assert.Equal(totalLength, BitConverter.ToInt32(messagePacked.Slice(1, 4)));
Assert.Equal(protobufMessageSerialized.Length, BitConverter.ToInt32(messagePacked.Slice(5, 4)));
var protobufObject = new TestMessage();
protobufObject.MergeFrom(messagePacked.Slice(ProtobufHubProtocolConstants.MESSAGE_HEADER_LENGTH, protobufMessageSerialized.Length).ToArray());
Assert.Equal(protobufMessage, protobufObject);
var serializedArguments = messagePacked.Slice(ProtobufHubProtocolConstants.MESSAGE_HEADER_LENGTH + protobufMessageSerialized.Length);
var i = 0;
while (!serializedArguments.IsEmpty)
{
var argumentType = BitConverter.ToInt32(serializedArguments.Slice(0, 4));
var argumentLength = BitConverter.ToInt32(serializedArguments.Slice(4, 4));
var argument = serializedArguments.Slice(ProtobufHubProtocolConstants.ARGUMENT_HEADER_LENGTH, argumentLength).ToArray();
protobufObject.MergeFrom(argument);
Assert.Equal(ARGUMENT_TYPE, argumentType);
Assert.Equal(arguments[i++], protobufObject.Data);
serializedArguments = serializedArguments.Slice(ProtobufHubProtocolConstants.ARGUMENT_HEADER_LENGTH + argumentLength);
}
}
private static async Task RunDataExecutionEngineAsync()
{
await Console.Out.WriteLineAsync("Starting SimpleClient w/ Encryption As An DataExecutionEngine...").ConfigureAwait(false);
var letterTemplate = new Letter("", "TestRabbitServiceQueue", null, new LetterMetadata());
var rabbitService = new RabbitService("Config.json", "passwordforencryption", "saltforencryption");
await rabbitService
.Topologer
.CreateQueueAsync("TestRabbitServiceQueue")
.ConfigureAwait(false);
// Produce Messages
for (ulong i = 0; i < 100; i++)
{
var letter = letterTemplate.Clone();
letter.LetterId = i;
var sentMessage = new TestMessage {
Message = "Sensitive Message"
};
sentMessage.Message += $" {i}";
letter.Body = JsonSerializer.SerializeToUtf8Bytes(sentMessage);
await rabbitService
.Publisher
.QueueLetterAsync(letter);
}
// Start Consumer As An Execution Engine
var consumer = rabbitService.GetConsumer("ConsumerFromConfig");
await consumer
.StartConsumerAsync(false, true)
.ConfigureAwait(false);
_ = Task.Run(() => consumer.DataflowExecutionEngineAsync(ConsumerWorkerAsync, 7));
await Console.In.ReadLineAsync().ConfigureAwait(false);
}
public async Task when_publish_message_to_topic_and_there_is_no_subscribers_then_server_notifies(int count)
{
string topic = Guid.NewGuid().ToString();
IMqttClient publisher = await GetClientAsync();
int topicsNotSubscribedCount = 0;
ManualResetEventSlim topicsNotSubscribedDone = new ManualResetEventSlim();
Server.MessageUndelivered += (sender, e) =>
{
Interlocked.Increment(ref topicsNotSubscribedCount);
if (topicsNotSubscribedCount == count)
{
topicsNotSubscribedDone.Set();
}
};
List <Task> tasks = new List <Task>();
for (int i = 1; i <= count; i++)
{
TestMessage testMessage = GetTestMessage(i);
MqttApplicationMessage message = new MqttApplicationMessage(topic, Serializer.Serialize(testMessage));
tasks.Add(publisher.PublishAsync(message, MqttQualityOfService.AtMostOnce));
}
await Task.WhenAll(tasks);
bool success = topicsNotSubscribedDone.Wait(TimeSpan.FromSeconds(KeepAliveSecs * 2));
topicsNotSubscribedCount.Should().Be(count);
Assert.True(success);
publisher.Dispose();
}
public void Msmq_Send()
{
var msmq = DistributedApplication.ClusterChannel as MsmqChannelProvider;
// init: purge queues
msmq._receiveQueue.Purge();
for (var i = 0; i < msmq._sendQueues.Count; i++)
{
var sendqueue = msmq._sendQueues[i];
sendqueue.Purge();
}
// distribute a single message, and check remote queues if message arrived
var msg = new TestMessage();
msg.Send();
var formatter = new BinaryMessageFormatter();
try
{
for (var i = 0; i < msmq._sendQueues.Count; i++)
{
var sendqueue = msmq._sendQueues[i];
var recvmsg = sendqueue.Receive(TimeSpan.FromSeconds(3));
var recvtestmsg = formatter.Deserialize(recvmsg.Body as Stream) as TestMessage;
Assert.IsTrue(recvtestmsg.Message == msg.Message, "Received message differs from message that was sent."); // check if we received the message that we have sent
}
}
catch (System.Messaging.MessageQueueException mex)
{
if (mex.MessageQueueErrorCode == System.Messaging.MessageQueueErrorCode.IOTimeout)
{
Assert.Fail("Receiving test message from remote queue timed out.");
}
}
}
/// <summary>
/// Runs the test specified by this test descriptor.
/// </summary>
/// <param name="testConfiguration">The test configuration to use for running the test.</param>
public virtual void RunTest(WriterTestConfiguration testConfiguration, BaselineLogger logger)
{
if (this.ShouldSkipForTestConfiguration(testConfiguration))
{
return;
}
// Wrap the memory stream in a non-disposing stream so we can dump the message content
// even in the case of a failure where the message stream normally would get disposed.
logger.LogConfiguration(testConfiguration);
logger.LogModelPresence(this.Model);
this.messageStream = new NonDisposingStream(new MemoryStream());
TestMessage message = this.CreateOutputMessage(this.messageStream, testConfiguration);
IEdmModel model = this.GetMetadataProvider();
WriterTestExpectedResults expectedResult = this.GetExpectedResult(testConfiguration);
ExceptionUtilities.Assert(expectedResult != null, "The expected result could not be determined for the test. Did you specify it?");
Exception exception = TestExceptionUtils.RunCatching(() =>
{
using (ODataMessageWriterTestWrapper messageWriterWrapper = TestWriterUtils.CreateMessageWriter(message, model, testConfiguration, this.settings.Assert))
{
this.WritePayload(messageWriterWrapper, testConfiguration);
expectedResult.VerifyResult(message, this.PayloadKind, testConfiguration, logger);
}
});
try
{
expectedResult.VerifyException(exception);
}
catch (Exception failureException)
{
this.TraceFailureInformation(message, this.messageStream, testConfiguration);
throw failureException;
}
}
/// <summary>
/// Runs the test specified by this test descriptor.
/// </summary>
/// <param name="testConfiguration">The test configuration to use for running the test.</param>
public override void RunTest(WriterTestConfiguration testConfiguration, BaselineLogger logger = null)
{
//TODO: Use Logger to verify result, right now this change is only to unblock writer testcase checkin
if (this.ShouldSkipForTestConfiguration(testConfiguration))
{
return;
}
// Generate a StreamingTestStream with a NonDisposingStream.
this.messageStream = new StreamingTestStream(new NonDisposingStream(new MemoryStream()));
TestMessage message = this.CreateOutputMessage(this.messageStream, testConfiguration);
IEdmModel model = this.GetMetadataProvider();
StreamingWriterTestExpectedResults expectedResult = (StreamingWriterTestExpectedResults)this.GetExpectedResult(testConfiguration);
ExceptionUtilities.Assert(expectedResult != null, "The expected result could not be determined for the test. Did you specify it?");
Exception exception = TestExceptionUtils.RunCatching(() =>
{
using (ODataMessageWriterTestWrapper messageWriterWrapper = TestWriterUtils.CreateMessageWriter(message, model, testConfiguration, this.settings.Assert))
{
this.WritePayload(messageWriterWrapper, testConfiguration);
expectedResult.ObservedElement = this.readObject;
expectedResult.VerifyResult(message, this.PayloadKind, testConfiguration);
}
});
try
{
expectedResult.VerifyException(exception);
}
catch (Exception failureException)
{
this.TraceFailureInformation(message, this.messageStream, testConfiguration);
throw failureException;
}
}
public async Task ExecuteAsync()
{
IMessage message = new TestMessage();
var referenceData = new ReferenceDataRoot();
IExternalDataCache externalDataCache = new ExternalDataCache();
var externalData = "ExtermalData";
var cancellationToken = CancellationToken.None;
var fundingServiceContextMock = new Mock <IFundingServiceContext>();
var jsonSerializationServiceMock = new Mock <IJsonSerializationService>();
var ilrFileProviderServiceMock = new Mock <IFileProviderService <IMessage> >();
var ilrReferenceDataProviderServiceMock = new Mock <IFileProviderService <ReferenceDataRoot> >();
var externalCachePopulationServiceMock = new Mock <IExternalDataCachePopulationService>();
var fundingTaskProviderMock = new Mock <IFundingTaskProvider>();
var loggerMock = new Mock <ILogger>();
ilrFileProviderServiceMock.Setup(sm => sm.ProvideAsync(fundingServiceContextMock.Object, cancellationToken)).Returns(Task.FromResult(message)).Verifiable();
ilrReferenceDataProviderServiceMock.Setup(sm => sm.ProvideAsync(fundingServiceContextMock.Object, cancellationToken)).Returns(Task.FromResult(referenceData)).Verifiable();
externalCachePopulationServiceMock.Setup(sm => sm.PopulateAsync(referenceData, cancellationToken)).Returns(externalDataCache).Verifiable();
jsonSerializationServiceMock.Setup(sm => sm.Serialize(externalDataCache)).Returns(externalData).Verifiable();
fundingTaskProviderMock.Setup(sm => sm.ProvideAsync(fundingServiceContextMock.Object, message, externalData, cancellationToken)).Returns(Task.FromResult(true)).Verifiable();
await NewService(
jsonSerializationServiceMock.Object,
ilrFileProviderServiceMock.Object,
ilrReferenceDataProviderServiceMock.Object,
externalCachePopulationServiceMock.Object,
fundingTaskProviderMock.Object,
loggerMock.Object).ExecuteAsync(fundingServiceContextMock.Object, cancellationToken);
jsonSerializationServiceMock.VerifyAll();
ilrFileProviderServiceMock.VerifyAll();
ilrReferenceDataProviderServiceMock.VerifyAll();
externalCachePopulationServiceMock.VerifyAll();
fundingTaskProviderMock.VerifyAll();
}
public TestMessage BuildMessage(string input)
{
TestMessage message = null;
input = input.Replace("##", Environment.NewLine).Trim();
var direction = input[0];
if (direction == '>') // To bot (request)
{
message = new ToBotMessage()
{
RawTextContent = input.Substring(1).Trim()
};
}
else if (direction == '<') // From bot (response)
{
message = GetMessageFromContent(input.Substring(1).Trim());
}
else
{
message = new UnexpectedTestMessage();
}
return(message);
}
/// <summary>
/// Called to write the payload to the specified <paramref name="messageWriter"/>.
/// </summary>
/// <param name="messageWriter">The <see cref="ODataMessageWriterTestWrapper"/> to use for writing the payload.</param>
/// <param name="testConfiguration">The test configuration to generate the payload for.</param>
protected override void WritePayload(ODataMessageWriterTestWrapper messageWriter, WriterTestConfiguration testConfiguration)
{
Debug.Assert(this.messageStream != null, "Streaming test stream must have been created.");
TestMessage testMessage = this.CreateInputMessageFromStream((TestStream)this.messageStream, testConfiguration, this.PayloadKind, string.Empty, this.UrlResolver);
testMessage.SetContentType(testConfiguration.Format, this.PayloadKind);
Exception exception = TestExceptionUtils.RunCatching(() =>
{
ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings(this.settings.MessageReaderSettings)
{
DisableMessageStreamDisposal = testConfiguration.MessageWriterSettings.DisableMessageStreamDisposal,
EnableAtom = true
};
ReaderTestConfiguration readerConfig = new ReaderTestConfiguration(
testConfiguration.Format,
readerSettings,
testConfiguration.IsRequest,
testConfiguration.Synchronous);
IEdmModel model = this.GetMetadataProvider();
using (ODataMessageReaderTestWrapper messageReaderWrapper = TestReaderUtils.CreateMessageReader(testMessage, model, readerConfig))
{
ODataPayloadElementToObjectModelConverter payloadElementToOMConverter = new ODataPayloadElementToObjectModelConverter(!testConfiguration.IsRequest);
ObjectModelToPayloadElementConverter reverseConverter = new ObjectModelToPayloadElementConverter();
ObjectModelWriteReadStreamer streamer = new ObjectModelWriteReadStreamer();
if (testConfiguration.Format == ODataFormat.Atom)
{
this.PayloadElement.Accept(new AddFeedIDFixup());
}
this.readObject = reverseConverter.Convert(streamer.WriteMessage(messageWriter, messageReaderWrapper, this.PayloadKind, payloadElementToOMConverter.Convert(this.PayloadElement)), !testConfiguration.IsRequest);
}
});
}
//чтение текста из файлов и инциализация
private static void ReadFiles(TcpClient testingTcpClient, TcpClient availableThreadClient, string directoryPath)
{
var filePaths = Directory.GetFiles(directoryPath, "*.txt");
if (filePaths.Length > 127)
{
Console.WriteLine("В выбранной дериктории слишком много файлов, установленно базовое ограниечение в 127");
}
else
{
var testingStream = testingTcpClient.GetStream();
var availableThreadStream = availableThreadClient.GetStream();
var responseStream = new TcpClient("127.0.0.1", 3458).GetStream();
//для проверки доступных потоков создается еще одно подключение
foreach (var filePath in filePaths)
{
var reader = new StreamReader(filePath);
var text = reader.ReadToEnd();
var message = new TestMessage(Path.GetFileName(filePath), text);
SendMessage(availableThreadStream, testingStream, message);
GetResponse(responseStream);
}
}
}
public async Task ValidateErnsAsyncReturnsValidErns()
{
var message = new TestMessage();
var empIds = new List <int> {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 30, 31, 32, 33, 34, 35
};
var loggerMock = new Mock <ILogger>();
var mapperMock = new Mock <IEmpIdMapper>();
mapperMock.Setup(m => m.MapEmpIdsFromMessage(message)).Returns(empIds);
var clientServiceMock = new Mock <IEDRSClientService>();
clientServiceMock
.Setup(m => m.GetInvalidErns(empIds, CancellationToken.None))
.ReturnsAsync(Enumerable.Empty <int>());
var service = NewService(mapperMock.Object, clientServiceMock.Object, loggerMock.Object);
var result = await service.ValidateErnsAsync(message, CancellationToken.None);
result.Should().BeEquivalentTo(empIds);
}
public void ExecuteSubjectTest()
{
var subscriber = new TestSubscriber();
MessageSenderService.ExecuteSubject.Subscribe(subscriber);
var messageSenderService = new MessageSenderService();
var testMessage = new TestMessage
{
Title = "Test Message"
};
messageSenderService.Send <TestMessageSender, TestMessage>(testMessage);
Thread.Sleep(TimeSpan.FromSeconds(1));
Assert.AreEqual(1, TestSubscriber.ActionContexts.Count);
var actionContext = TestSubscriber.ActionContexts[0];
var data = JsonConvert.DeserializeObject <TestMessage>(actionContext.Data);
Assert.AreEqual(testMessage.Title, data.Title);
Assert.AreEqual("Message Sent", actionContext.Action);
Assert.AreEqual(typeof(TestMessageSender), actionContext.MessageSenderType);
Assert.AreEqual(typeof(TestMessage), actionContext.MessageType);
}
public void MustReturnUnknownMessageAsDefault()
{
sut.AuthenticationToken = Guid.Empty;
var token = sut.Connect(Guid.Empty).CommunicationToken.Value;
var message = new TestMessage {
CommunicationToken = token
} as Message;
var response = sut.Send(message);
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
Assert.AreEqual(SimpleResponsePurport.UnknownMessage, (response as SimpleResponse)?.Purport);
message = new SimpleMessage(default(SimpleMessagePurport))
{
CommunicationToken = token
};
response = sut.Send(message);
Assert.IsNotNull(response);
Assert.IsInstanceOfType(response, typeof(SimpleResponse));
Assert.AreEqual(SimpleResponsePurport.UnknownMessage, (response as SimpleResponse)?.Purport);
}
public void BuildValidLearnRefNumbers()
{
var invalidLearnRefNumbers = new List <string>()
{
"a", "b"
};
var message = new TestMessage()
{
Learners = new List <TestLearner>()
{
new TestLearner()
{
LearnRefNumber = "a"
},
new TestLearner()
{
LearnRefNumber = "b"
},
new TestLearner()
{
LearnRefNumber = "c"
},
new TestLearner()
{
LearnRefNumber = "d"
},
new TestLearner()
{
LearnRefNumber = "e"
},
}
};
NewService().BuildValidLearnRefNumbers(message, invalidLearnRefNumbers).Should().BeEquivalentTo("c", "d", "e");
}
public void GivenIHaveRegisteredForAMessageType_WhenIUnregisterForThatMessageType_ThenNoMoreMessagesAreReceived()
{
// Arrange
IMessageBroker messageBroker = new MessageBroker();
bool actionExecuted = false;
Action <TestMessage> testMessageAction = x => actionExecuted = true;
messageBroker.Register(this, testMessageAction);
var testMessage = new TestMessage();
messageBroker.Send(testMessage);
Assert.That(actionExecuted, Is.True);
actionExecuted = false;
// Act
messageBroker.Unregister(this, testMessageAction);
// Assert
messageBroker.Send(testMessage);
Assert.That(actionExecuted, Is.False);
}
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
var testMessage = new TestMessage();
testMessage.Msg = 3.14f;
using (MemoryStream stream = new MemoryStream())
{
// Save the person to a stream
testMessage.WriteTo(stream);
byte[] bytes = stream.ToArray();
for (int i = 0; i < bytes.Length; i++)
{
Console.Write(String.Format("{0:X2}", bytes[i]));
}
Console.WriteLine();
UdpClient udpClient = new UdpClient(4049);
try{
udpClient.Connect("192.168.10.196", 4049);
udpClient.Send(bytes, bytes.Length);
udpClient.Close();
}
catch (Exception e) {
Console.WriteLine(e.ToString());
}
}
}
private void Given()
{
_it = new AwakeReaderService();
_eventRecord = new EventRecord(
100,
new PrepareLogRecord(
1500, Guid.NewGuid(), Guid.NewGuid(), 1500, 0, "Stream", 99, DateTime.UtcNow, PrepareFlags.Data,
"event", new byte[0], null));
_eventCommitted = new StorageMessage.EventCommitted(2000, _eventRecord, isTfEof: true);
_publisher = new InMemoryBus("bus");
_envelope = new PublishEnvelope(_publisher);
_handler = new TestHandler<TestMessage>();
_publisher.Subscribe(_handler);
_reply1 = new TestMessage(1);
_reply2 = new TestMessage(2);
_reply3 = new TestMessage(3);
_reply4 = new TestMessage(4);
_reply5 = new TestMessage(5);
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, Guid.NewGuid(), "Stream", new TFPos(1000, 500), _reply1));
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, Guid.NewGuid(), "Stream", new TFPos(100000, 99500), _reply2));
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, Guid.NewGuid(), "Stream2", new TFPos(1000, 500), _reply3));
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, Guid.NewGuid(), null, new TFPos(1000, 500), _reply4));
_it.Handle(
new AwakeReaderServiceMessage.SubscribeAwake(
_envelope, Guid.NewGuid(), null, new TFPos(100000, 99500), _reply5));
}
public async Task Test_LockError_MessageFlow()
{
await ServiceBusFixture.ServiceBusNamespace.ScorchNamespace();
using (var ts = new CancellationTokenSource())
using (var msn = new Messenger(ServiceBusFixture.ConfigSettings.ServiceBusConnectionString, ServiceBusFixture.ConfigSettings.AzureSubscriptionId))
{
var message = new TestMessage();
await msn.Send(message);
msn.Receive <TestMessage>(
async m =>
{
await msn.Lock(m);
await Task.Delay(TimeSpan.FromSeconds(5), ts.Token);
await msn.Error(m);
ts.Cancel(); // kill switch
});
try
{
await Task.Delay(TimeSpan.FromMinutes(2), ts.Token);
}
catch (TaskCanceledException) { /* soak the kill switch */ }
var receiver = new MessageReceiver(ServiceBusFixture.ConfigSettings.ServiceBusConnectionString, EntityNameHelper.FormatDeadLetterPath(typeof(TestMessage).GetEntityName()), ReceiveMode.ReceiveAndDelete);
var rMessage = (await receiver.ReadBatchAsync <TestMessage>(1)).FirstOrDefault();
rMessage.Should().NotBeNull();
rMessage.Should().BeEquivalentTo(message);
((QueueAdapter <TestMessage>)msn.ServiceBusAdapters[typeof(TestMessage).GetEntityName()]).Messages.Should().BeEmpty();
((QueueAdapter <TestMessage>)msn.ServiceBusAdapters[typeof(TestMessage).GetEntityName()]).LockTimers.Should().BeEmpty();
}
}
public void TestSendMultipleRecipients()
{
ILoggerFactory loggerFactory = new LoggerFactory();
ILogger <MessageService> logger = loggerFactory.CreateLogger <MessageService>();
string testMessageContent = "This is a test";
int numCalls1 = 0;
Action <TestMessage> testAction1 = (testMessage) =>
{
++numCalls1;
if (testMessage.Text != testMessageContent)
{
throw new InvalidOperationException();
}
};
int numCalls2 = 0;
Action <TestMessage> testAction2 = (testMessage) =>
{
++numCalls2;
if (testMessage.Text != testMessageContent)
{
throw new InvalidOperationException();
}
};
var messageService = new MessageService(loggerFactory);
messageService.Register <TestMessage>(testAction1);
messageService.Register <TestMessage>(testAction2);
var message = new TestMessage(testMessageContent);
messageService.Send(message);
Assert.AreEqual(1, numCalls1);
Assert.AreEqual(1, numCalls2);
}
public void UniqueUKPRNsFromMessage_EPAOrgIds()
{
var epaOrgId = "EpaOrg001";
var message = new TestMessage
{
Learners = new List <TestLearner>
{
new TestLearner
{
LearningDeliveries = new List <TestLearningDelivery>
{
new TestLearningDelivery
{
EPAOrgID = epaOrgId
}
}
}
}
};
var epaOrganisationsDataRetrievalServiceMock = new Mock <EPAOrganisationsDataRetrievalService> {
CallBase = true
};
epaOrganisationsDataRetrievalServiceMock.Setup(s => s.UniqueEpaOrgIdsFromMessage(message)).Returns(new List <string> {
epaOrgId
});
var epaOrganisations = epaOrganisationsDataRetrievalServiceMock.Object.UniqueEpaOrgIdsFromMessage(message).ToList();
epaOrganisations.Should().HaveCount(1);
epaOrganisations.Should().BeEquivalentTo(new List <string> {
epaOrgId
});
}
public async Task WithMessageHandlerWithCustomContext_WithMessageBodySerializer_UsesSerializer()
{
// Arrange
var services = new MessageHandlerCollection(new ServiceCollection());
var expectedBody = $"test-message-body-{Guid.NewGuid()}";
var expectedMessage = new TestMessage();
var serializer = new TestMessageBodySerializer(expectedBody, expectedMessage);
// Act
services.WithMessageHandler <TestMessageHandler, TestMessage, TestMessageContext>(messageBodySerializer: serializer);
// Assert
IServiceProvider provider = services.Services.BuildServiceProvider();
IEnumerable <MessageHandler> handlers = MessageHandler.SubtractFrom(provider, NullLogger.Instance);
Assert.NotNull(handlers);
MessageHandler handler = Assert.Single(handlers);
Assert.NotNull(handler);
MessageResult result = await handler.TryCustomDeserializeMessageAsync(expectedBody);
Assert.NotNull(result);
Assert.Same(expectedMessage, result.DeserializedMessage);
}