public void TestListenerAndSenderRemovesCommandQueues()
{
var timeout = TimeSpan.FromSeconds(1);
using (var sender = new TestSender(timeout))
{
sender.PublishCommand(6);
using (var service = new BlockingReceiver <int>())
using (var listener = sender.Listener())
{
service.SubscribeToCommand(listener);
Assert.Equal(6, service.Next());
}
sender.PublishCommand(3);
Thread.Sleep(timeout);
using (var service = new BlockingReceiver <int>())
using (var listener = sender.Listener())
{
service.SubscribeToCommand(listener);
Assert.Throws <TimeoutException>(() => service.Next(TimeSpan.FromSeconds(1)));
}
}
}
// Use this for initialization
void Start()
{
power.image.color = Color.red;
sender = gameObject.AddComponent <TestSender>();
lampIsOn = true;
//satSlider.onValueChanged.AddListener(ListenerMethod);
}
public void ChannelBaseUsesPrivateQueuesPerNamespace()
{
using (var sender1 = new TestSender())
using (var sender2 = new TestSender())
{
sender1.PublishCommand(3);
sender2.PublishCommand(4);
using (var listener = sender1.Listener())
using (var service = new BlockingReceiver <int>())
{
service.SubscribeToCommand(listener);
Assert.Equal(3, service.Next());
Assert.Throws <TimeoutException>(() => service.Next(TimeSpan.FromSeconds(1)));
}
using (var listener = sender2.Listener())
using (var service = new BlockingReceiver <int>())
{
service.SubscribeToCommand(listener);
Assert.Equal(4, service.Next());
Assert.Throws <TimeoutException>(() => service.Next(TimeSpan.FromSeconds(1)));
}
}
}
public async Task InvokeAsync_WhenSenderTypeIsNull_ShouldPublishToGlobalSubscriptionsImmediately()
{
var testSender = new TestSender();
var testEventArgs = new TestEventArgs();
var pipelineContext = CreatePipelineContext(testEventArgs
);
PipelineContext nextModuleContext = null;
Task InvokeNextModule(PipelineContext context)
{
nextModuleContext = context;
return(Task.CompletedTask);
}
_publishingServiceMock
.Setup(x => x.PublishEventToGlobalSubscriptionsAsync(pipelineContext.PipelineEvent))
.Returns(Task.CompletedTask)
.Verifiable();
await _globalPublishPipelineModule.InvokeAsync(_globalPublishPipelineModuleConfig, pipelineContext, InvokeNextModule);
Assert.That(nextModuleContext, Is.Not.Null);
Assert.That(nextModuleContext, Is.EqualTo(pipelineContext));
}
public async Task InvokeAsync_WhenSenderTypeIsNotNull_ShouldSendEvent()
{
var testSender = new TestSender();
var testEventArgs = new TestEventArgs();
_globalPublishPipelineModuleConfig.SenderType = _eventSender1Mock.Object.GetType();
var pipelineContext = CreatePipelineContext(testEventArgs
);
PipelineContext nextModuleContext = null;
Task InvokeNextModule(PipelineContext context)
{
nextModuleContext = context;
return(Task.CompletedTask);
}
_eventSender1Mock
.Setup(x => x.SendAsync(pipelineContext.PipelineEvent))
.Returns(Task.CompletedTask)
.Verifiable();
await _globalPublishPipelineModule.InvokeAsync(_globalPublishPipelineModuleConfig, pipelineContext, InvokeNextModule);
Assert.That(nextModuleContext, Is.Not.Null);
Assert.That(nextModuleContext, Is.EqualTo(pipelineContext));
}
// Use this for initialization
void Start()
{
yourGradientMaterial.SetColor("_Color", Color.red);
yourGradientMaterial.SetColor("_Color2", Color.white);
sender = gameObject.AddComponent <TestSender>();
//satSlider.onValueChanged.AddListener(ListenerMethod);
}
public void DisposeTest()
{
Func <TestSenderOptions, ISender> createSender = options =>
{
return(new TestSender("MyTestSender", options.TestSetting1, options.TestSetting2));
};
var initialOptions = new TestSenderOptions
{
TestSetting1 = "InitialTestSetting1",
TestSetting2 = "InitialTestSetting2"
};
var mockOptionsMonitor = new Mock <IOptionsMonitor <TestSenderOptions> >(MockBehavior.Strict);
var mockChangeListener = new Mock <IDisposable>();
mockOptionsMonitor.Setup(m => m.Get("MyReloadingSender")).Returns(initialOptions);
mockOptionsMonitor.Setup(m => m.OnChange(It.IsAny <Action <TestSenderOptions, string> >()))
.Returns(mockChangeListener.Object);
Action <TestSenderOptions> configureOptions = options => { };
ISender sender = ReloadingSender.New("MyReloadingSender",
createSender, mockOptionsMonitor.Object, configureOptions);
TestSender testSender = ((dynamic)sender).Sender;
testSender.Disposed.Should().BeFalse();
mockChangeListener.Verify(m => m.Dispose(), Times.Never());
sender.Dispose();
testSender.Disposed.Should().BeTrue();
mockChangeListener.Verify(m => m.Dispose());
}
public void FrontEndServiceShouldRespondToPersonCreatedEvents()
{
// Arrange
using (var context = new FrontEndContext(
new DbContextOptionsBuilder <FrontEndContext>().UseSqlite(@"Filename=.\test.db").Options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
var builder = new ContainerBuilder();
builder
.RegisterType <FrontEndService>()
.As <IReceive <PersonCreated> >();
builder
.RegisterInstance <IFrontEndContext>(context).ExternallyOwned();
using (var waiter = new BlockingReceiver <PersonCreated>())
using (var container = builder.Build())
using (var sender = new TestSender())
using (var listener = sender.Listener())
{
listener.SubscribeEvents <PersonCreated>(container);
waiter.SubscribeToEvents(listener);
// Act
sender.PublishEvent(new PersonCreated {
});
waiter.Next();
}
// Assert
Assert.True(context.People.Any());
}
}
public void ReceiverWithExceptionLeavesCommandInQueueToBeRedelivered()
{
using (var sender = new TestSender())
{
sender.PublishCommand(3);
using (var wait = new ManualResetEvent(false))
{
var service = Substitute.For <IReceive <int> >();
service.When(_ => _.Execute(Arg.Any <int>())).Do(_ =>
{
wait.Set();
throw new NotImplementedException();
});
var builder = new ContainerBuilder();
builder.RegisterInstance(service);
using (var container = builder.Build())
using (var listener = sender.Listener())
{
listener.SubscribeCommands <int>(container);
Assert.True(wait.WaitOne(TimeSpan.FromSeconds(5)));
service.Received(1).Execute(3);
}
}
using (var service = new BlockingReceiver <int>())
using (var listener = sender.Listener())
{
service.SubscribeToCommand(listener);
Assert.Equal(3, service.Next());
}
}
}
public void OnOptionsChangedTest1()
{
Func <TestSenderOptions, ISender> createSender = options =>
{
return(new TestSender("MyTestSender", options.TestSetting1, options.TestSetting2));
};
var initialOptions = new TestSenderOptions
{
TestSetting1 = "InitialTestSetting1",
TestSetting2 = "InitialTestSetting2"
};
var mockOptionsMonitor = new Mock <IOptionsMonitor <TestSenderOptions> >(MockBehavior.Strict);
var mockChangeListener = new Mock <IDisposable>(MockBehavior.Strict);
Action <TestSenderOptions, string> onChangeCallback = null;
mockOptionsMonitor.Setup(m => m.Get("MyReloadingSender")).Returns(initialOptions);
mockOptionsMonitor.Setup(m => m.OnChange(It.IsAny <Action <TestSenderOptions, string> >()))
.Callback <Action <TestSenderOptions, string> >(onChange => onChangeCallback = onChange)
.Returns(mockChangeListener.Object);
Action <TestSenderOptions> configureOptions = options =>
{
options.TestSetting2 = "ConfiguredTestSetting2";
};
ISender sender = ReloadingSender.New("MyReloadingSender",
createSender, mockOptionsMonitor.Object, configureOptions);
dynamic s = sender;
onChangeCallback.Should().NotBeNull();
TestSender initialTestSender = s.Sender;
var newOptions = new TestSenderOptions
{
TestSetting1 = "NewTestSetting1",
// Note that we won't see this value below, since our
// 'configureOptions' action above overrides this value.
TestSetting2 = "NewTestSetting2"
};
// Simulate the change to our sender:
onChangeCallback(newOptions, "MyReloadingSender");
TestSender newTestSender = s.Sender;
newTestSender.Should().NotBeSameAs(initialTestSender);
newTestSender.Name.Should().Be("MyTestSender");
newTestSender.TestSetting1.Should().Be("NewTestSetting1");
newTestSender.TestSetting2.Should().Be("ConfiguredTestSetting2");
initialTestSender.Disposed.Should().BeTrue();
}
public void TestReceiveMessageFromSingleSender( )
{
var sender = new TestSender( );
using (var receiver = new TestReceiver( )) {
receiver.SubscribeToMessagesFrom(sender);
sender.SendMessage(MessageLevel.INFO, "This is a test.");
Assert.That(receiver.MessageReceived, Is.True);
}
}
public void SenderRaisesEvent()
{
using (var sender = new TestSender())
{
var message = string.Empty;
sender.Send += (o, e) => message = e.Message;
sender.PublishEvent("hallo");
Assert.Equal("\"hallo\"", message);
}
}
public void TestMailSenderDoesntThrowException()
{
IEmailSender sender = new TestSender();
sender.Subject = "Test123";
sender.ToEmail = "*****@*****.**";
sender.Body = "Message to send.";
Action action = () => sender.Send();
action.Should().NotThrow();
}
internal InboxSmokeTestsHelper(TestSender testSender)
{
_testSender = testSender;
var broker = new Broker(testSender.Id);
var serviceProvider = LoggingUtility.CreateServiceProviderAndSetUpLogging();
_client = new DigipostClient(
new ClientConfig(broker, testSender.Environment),
testSender.Certificate,
serviceProvider.GetService <ILoggerFactory>()
);
}
public ClientSmokeTestHelper(TestSender testSender, bool withoutDataTypesProject = false)
{
var broker = new Broker(testSender.Id);
_testSender = testSender;
var serviceProvider = LoggingUtility.CreateServiceProviderAndSetUpLogging();
_digipostClient = new DigipostClient(new ClientConfig(broker, testSender.Environment)
{
TimeoutMilliseconds = 900000000, LogRequestAndResponse = true, SkipMetaDataValidation = withoutDataTypesProject
}, testSender.Certificate, serviceProvider.GetService <ILoggerFactory>());
}
public void TestReceiveMessageFromMultipleSenders( )
{
var aSender = new TestSender( );
var anotherSender = new TestSender( );
using (var receiver = new TestReceiver( )) {
receiver.SubscribeToMessagesFrom(aSender);
receiver.SubscribeToMessagesFrom(anotherSender);
aSender.SendMessage(MessageLevel.INFO, "Message sent from a sender.");
anotherSender.SendMessage(MessageLevel.INFO, "Message sent from another sender.");
Assert.That(receiver.MessageReceived, Is.True);
}
}
public void ConstructorTest()
{
Func <TestSenderOptions, ISender> expectedCreateSender = options =>
{
return(new TestSender("MyTestSender", options.TestSetting1, options.TestSetting2));
};
var testOptions = new TestSenderOptions
{
TestSetting1 = "MyTestSetting1",
TestSetting2 = "MyTestSetting2"
};
var mockOptionsMonitor = new Mock <IOptionsMonitor <TestSenderOptions> >(MockBehavior.Strict);
var mockChangeListener = new Mock <IDisposable>(MockBehavior.Strict);
mockOptionsMonitor.Setup(m => m.Get("MyReloadingSender")).Returns(testOptions);
mockOptionsMonitor.Setup(m => m.OnChange(It.IsAny <Action <TestSenderOptions, string> >()))
.Returns(mockChangeListener.Object);
Action <TestSenderOptions> expectedConfigureOptions = options => { };
ISender sender = ReloadingSender.New("MyReloadingSender",
expectedCreateSender, mockOptionsMonitor.Object, expectedConfigureOptions);
sender.Name.Should().Be("MyReloadingSender");
sender.GetType().Should().Be(ReloadingSender);
dynamic s = sender;
Func <TestSenderOptions, ISender> createSender = s.CreateSender;
createSender.Should().BeSameAs(expectedCreateSender);
Action <TestSenderOptions> configureOptions = s.ConfigureOptions;
configureOptions.Should().BeSameAs(expectedConfigureOptions);
TestSender testSender = s.Sender;
testSender.Name.Should().Be("MyTestSender");
testSender.TestSetting1.Should().Be("MyTestSetting1");
testSender.TestSetting2.Should().Be("MyTestSetting2");
IDisposable changeListener = s.ChangeListener;
changeListener.Should().BeSameAs(mockChangeListener.Object);
}
public void OnOptionsChangedTest2()
{
Func <TestSenderOptions, ISender> createSender = options =>
{
return(new TestSender("MyTestSender", options.TestSetting1, options.TestSetting2));
};
var initialOptions = new TestSenderOptions
{
TestSetting1 = "InitialTestSetting1",
TestSetting2 = "InitialTestSetting2"
};
var mockOptionsMonitor = new Mock <IOptionsMonitor <TestSenderOptions> >(MockBehavior.Strict);
var mockChangeListener = new Mock <IDisposable>(MockBehavior.Strict);
Action <TestSenderOptions, string> onChangeCallback = null;
mockOptionsMonitor.Setup(m => m.Get("MyReloadingSender")).Returns(initialOptions);
mockOptionsMonitor.Setup(m => m.OnChange(It.IsAny <Action <TestSenderOptions, string> >()))
.Callback <Action <TestSenderOptions, string> >(onChange => onChangeCallback = onChange)
.Returns(mockChangeListener.Object);
Action <TestSenderOptions> configureOptions = options => { };
ISender sender = ReloadingSender.New("MyReloadingSender",
createSender, mockOptionsMonitor.Object, configureOptions);
dynamic r = sender;
onChangeCallback.Should().NotBeNull();
TestSender initialTestSender = r.Sender;
var newOptions = new TestSenderOptions
{
TestSetting1 = "NewTestSetting1",
TestSetting2 = "NewTestSetting2"
};
// Simulate a change to some other sender:
onChangeCallback(newOptions, "SomeOtherSender");
TestSender newTestSender = r.Sender;
newTestSender.Should().BeSameAs(initialTestSender);
initialTestSender.Disposed.Should().BeFalse();
}
public void CommandsAreDeliveredAlsoWhenPublishedBeforeListenerSubscribed()
{
using (var sender = new TestSender())
{
sender.PublishCommand(3);
using (var service = new BlockingReceiver <int>())
using (var listener = sender.Listener())
{
service.SubscribeToCommand(listener);
var result = service.Next();
Assert.Equal(3, result);
}
}
}
public void TestMessageRelaying( )
{
var sender = new TestSender( );
using (var relay = new TestRelay( )) {
using (var receiver = new TestReceiver( )) {
relay.SubscribeToMessagesFrom(sender);
receiver.SubscribeToMessagesFrom(relay);
sender.SendMessage(MessageLevel.INFO, "Message sent from a sender.");
relay.SendMessage(MessageLevel.INFO, "Message sent from a relay.");
Assert.That(relay.MessageReceived, Is.True);
Assert.That(receiver.MessageReceived, Is.True);
}
}
}
public void InvokeAsync_WhenSenderIsNotFound_ShouldThrow()
{
var testSender = new TestSender();
var testEventArgs = new TestEventArgs();
_globalPublishPipelineModuleConfig.SenderType = typeof(object);
var pipelineContext = CreatePipelineContext(testEventArgs
);
Task InvokeNextModule(PipelineContext context) => Task.CompletedTask;
Assert.That(async() =>
{
await _globalPublishPipelineModule.InvokeAsync(_globalPublishPipelineModuleConfig, pipelineContext, InvokeNextModule);
}, Throws.TypeOf <EventSenderNotFoundException>());
}
public async Task When_SendMessageAsync_SendAsync_Succeeds_MessagesSent_Is_Incremented()
{
const string deviceId = "device1";
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>())
.Build();
var stats = new RunnerStats();
var config = RunnerConfiguration.Load(configuration, NullLogger.Instance);
var sender = new TestSender(false, false, deviceId, config);
await sender.SendMessageAsync(stats, CancellationToken.None);
Assert.Equal(1, stats.MessagesSent);
Assert.Equal(0, stats.TotalSendTelemetryErrors);
Assert.Single(sender.TestMessages);
}
public async Task When_SendingMessage_With_Different_Payload_Per_Device_Should_Work()
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("./test_files/test3-config-multiple-devices.json")
.Build();
var stats = new RunnerStats();
var config = RunnerConfiguration.Load(configuration, NullLogger.Instance);
var senderDevice1 = new TestSender(false, false, "device0001", config);
var senderDevice2 = new TestSender(false, false, "device0002", config);
var senderDevice3 = new TestSender(false, false, "device0003", config);
const int messageCount = 3;
for (int i = 0; i < messageCount; i++)
{
await Task.WhenAll(
senderDevice1.SendMessageAsync(stats, default),
senderDevice2.SendMessageAsync(stats, default),
senderDevice3.SendMessageAsync(stats, default));
}
foreach (var expectedMessageForDevice1 in new[]
{
"{\"value\":\"1\"}",
"{\"value\":\"true\"}",
"{\"value\":\"2\"}",
})
{
Assert.Equal(1, senderDevice1.TestMessages.Count(x => expectedMessageForDevice1 == Encoding.UTF8.GetString(x.MessageBytes)));
}
foreach (var expectedMessageForDevice3 in new[]
{
"{\"a\":\"b\",\"value\":\"1\"}",
"{\"a\":\"b\",\"value\":\"true\"}",
"{\"a\":\"b\",\"value\":\"2\"}",
})
{
Assert.Equal(1, senderDevice3.TestMessages.Count(x => expectedMessageForDevice3 == Encoding.UTF8.GetString(x.MessageBytes)));
}
const string expectedMessageForDevice2 = "{\"value\":\"myfixvalue\"}";
Assert.Equal(messageCount, senderDevice2.TestMessages.Count(x => Encoding.UTF8.GetString(x.MessageBytes) == expectedMessageForDevice2));
}
public void ShouldReplaceCorrelationIdOnRequestWithoutLabel()
{
var storageMock = new Mock <IIncomingMessageHeaderStorage>();
var incomingHeaders = new Dictionary <string, object>
{
[Headers.OriginalMessageId] = "OriginalMessageId",
[Headers.CorrelationId] = "CorrelationId"
};
storageMock.Setup(s => s.Load())
.Returns(
incomingHeaders);
var senderConfigMock = new Mock <ISenderConfiguration>();
senderConfigMock.Setup(s => s.Options)
.Returns(
new SenderOptions
{
IncomingMessageHeaderStorage = new Maybe <IIncomingMessageHeaderStorage>(storageMock.Object)
});
senderConfigMock.Setup(s => s.Label)
.Returns(MessageLabel.Any);
IMessage sentMessage = null;
var sut = new TestSender(
me =>
{
sentMessage = me.Out;
me.In = new Message(MessageLabel.Any, new object());
TaskCompletionSource <MessageExchange> tcs = new TaskCompletionSource <MessageExchange>();
tcs.SetResult(me);
return(tcs.Task);
},
new Mock <IEndpoint>().Object,
senderConfigMock.Object,
Enumerable.Empty <IMessageExchangeFilter>());
var r = sut.Request <object>(new { }, new RequestOptions()).Result;
Assert.IsNotNull(sentMessage);
Assert.AreEqual(incomingHeaders[Headers.OriginalMessageId], sentMessage.Headers[Headers.OriginalMessageId]);
Assert.AreNotEqual(incomingHeaders[Headers.CorrelationId], sentMessage.Headers[Headers.CorrelationId]);
}
public void TestSenderProvidesSpecificListener()
{
using (var sender1 = new TestSender())
using (var sender2 = new TestSender())
using (var listener1 = sender1.Listener())
using (var listener2 = sender2.Listener())
using (var service1 = new BlockingReceiver <int>())
using (var service2 = new BlockingReceiver <int>())
{
service1.SubscribeToEvents(listener1);
service2.SubscribeToEvents(listener2);
sender1.PublishEvent(3);
sender2.PublishEvent(4);
Assert.Equal(3, service1.Next());
Assert.Equal(4, service2.Next());
}
}
public void ReceivedCommandIsNotDeliveredTwice()
{
using (var sender = new TestSender())
{
sender.PublishCommand(3);
using (var service = new BlockingReceiver <int>())
using (var listener = sender.Listener())
{
service.SubscribeToCommand(listener);
Assert.Equal(3, service.Next());
}
using (var service = new BlockingReceiver <int>())
using (var listener = sender.Listener())
{
service.SubscribeToCommand(listener);
Assert.Throws <TimeoutException>(() => service.Next(TimeSpan.FromSeconds(1)));
}
}
}
public async Task When_SendMessageAsync_SendAsync_Throws_NonTransientExcption_SendTelemetryErrors_Is_Incremented()
{
const string deviceId = "device1";
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>())
.Build();
var stats = new RunnerStats();
var config = RunnerConfiguration.Load(configuration, NullLogger.Instance);
var sender = new TestSender(false, true, deviceId, config);
var stopwatch = Stopwatch.StartNew();
await sender.SendMessageAsync(stats, CancellationToken.None);
stopwatch.Stop();
Assert.InRange(stopwatch.ElapsedMilliseconds, sender.TransientErrorWaitTime, (sender.MaxNumberOfSendAttempts + 1) * sender.TransientErrorWaitTime);
Assert.Equal(0, stats.MessagesSent);
Assert.InRange(stats.TotalSendTelemetryErrors, 1, int.MaxValue);
Assert.Empty(sender.TestMessages);
}
public void PublishedMessageShouldBeDeliveredToSubscribedReceiversFromBothListeners()
{
// Arrange
using (var sender = new TestSender())
using (var listener1 = sender.Listener())
using (var listener2 = sender.Listener())
using (var service1 = new BlockingReceiver <Person>())
using (var service2 = new BlockingReceiver <Person>())
{
service1.SubscribeToEvents(listener1);
service2.SubscribeToEvents(listener2);
// Act
sender.PublishEvent(new Person {
FirstName = "first"
});
// Assert
service1.Next();
service2.Next();
}
}
public async Task When_SendMessageAsync_With_Header_Property_Is_Added()
{
const string deviceId = "device1";
const string propertyKey = "myPropertyKey";
const string propertyValue = "My Propert Value";
var rawTemplate = $"{{ \"{propertyKey}\": \"{propertyValue}\" }}";
var configuration = new ConfigurationBuilder()
.AddInMemoryCollection(new Dictionary <string, string>()
{
{ "Header", rawTemplate }
})
.Build();
var stats = new RunnerStats();
var config = RunnerConfiguration.Load(configuration, NullLogger.Instance);
var sender = new TestSender(false, false, deviceId, config);
await sender.SendMessageAsync(stats, CancellationToken.None);
Assert.Equal(propertyValue, sender.TestMessages.Single().Properties[propertyKey]);
Assert.Equal(1, stats.MessagesSent);
Assert.Equal(0, stats.TotalSendTelemetryErrors);
Assert.Single(sender.TestMessages);
}
// Use this for initialization
void Start()
{
sender = gameObject.AddComponent <TestSender>();
}
