Example #1
0
        public async Task WhenClientSubscribeToTopic_ThenCanRecieveSimpleTypeMessages()
        {
            // Arrange
            string topic   = "anyTopic";
            string content = "Hi, how do you do?";

            bool   messageReceived = false;
            string contentReceived = string.Empty;

            Action <string> handler = (param) => { messageReceived = true; contentReceived = param; };

            IPublishSubscribeHubClient client = new PublishSubscribeHubClient(new Uri("http://test/"), CreateLogger());

            using (var httpClient = _testServer.CreateClient())
            {
                // Act
                await client.ConnectAsync(httpClient);

                await client.SubscribeAsync(topic, handler);

                await client.SendAsync(topic, content);

                // Not good but needed...
                await Task.Delay(50);

                await client.UnSubscribeAsync(topic);

                await client.DisconnectAsync();

                // Assert
                Assert.True(messageReceived);
                Assert.Equal(content, contentReceived);
            }
        }
Example #2
0
        public async Task WhenDisconectAndNeverConnectedBefore_ThenItDoesNotFail()
        {
            // Arrange
            IPublishSubscribeHubClient client = new PublishSubscribeHubClient(new Uri("http://test/"), CreateLogger());

            using (var httpClient = _testServer.CreateClient())
            {
                // Act
                await client.DisconnectAsync();

                // Assert
            }
        }
Example #3
0
        public async Task WhenConnectedTwice_ThenInvalidOperationExceptionIsThrown()
        {
            // Arrange
            IPublishSubscribeHubClient client = new PublishSubscribeHubClient(new Uri("http://test/"), CreateLogger());

            using (var httpClient = _testServer.CreateClient())
            {
                // Act
                await client.ConnectAsync(httpClient);

                // Assert
                await Assert.ThrowsAsync <InvalidOperationException>(async() => await client.ConnectAsync(httpClient));
            }
        }
Example #4
0
        public async Task WhenTwoClientsSubscribeExpectingDifferentTypes_HandlerWithWrongTypeIsNotExecuted()
        {
            // Arrange
            string   topic     = "anyTopic";
            TimeSpan content_1 = new TimeSpan(12345);

            var handler_1_executed = false;
            var handler_2_executed = false;

            Action <TimeSpan> handler_1 = (obj) => { handler_1_executed = true; };
            Action <int>      handler_2 = (obj) => { handler_1_executed = true; };

            IPublishSubscribeHubClient client_1 = new PublishSubscribeHubClient(new Uri("http://test/"), CreateLogger());
            IPublishSubscribeHubClient client_2 = new PublishSubscribeHubClient(new Uri("http://test/"), CreateLogger());

            using (var httpClient_1 = _testServer.CreateClient())
            {
                await client_1.ConnectAsync(httpClient_1);

                await client_1.SubscribeAsync(topic, handler_1);

                using (var httpClient_2 = _testServer.CreateClient())
                {
                    await client_2.ConnectAsync(httpClient_2);

                    await client_2.SubscribeAsync(topic, handler_2);

                    await client_1.SendAsync(topic, content_1);

                    // Not good but needed...
                    await Task.Delay(50);

                    await client_2.UnSubscribeAsync(topic);

                    await client_2.DisconnectAsync();
                }

                await client_1.UnSubscribeAsync(topic);

                await client_1.DisconnectAsync();

                // Assert
                Assert.True(handler_1_executed);
                Assert.False(handler_2_executed);
            }
        }