Exemple #1
0
        public async void CanConnectTwoSubscriptionsSimultaneously()
        {
            var port            = NetworkHelpers.GetFreeTcpPortNumber();
            var callbackTester  = new CallbackMonitor <Exception>();
            var callbackTester2 = new CallbackMonitor <Exception>();

            var callbackMonitor = ChatClient.ConfigureMonitorForOnWebsocketConnected();
            await ChatClient.InitializeWebsocketConnection();

            callbackMonitor.Should().HaveBeenInvokedWithPayload();

            Debug.WriteLine("creating subscription stream");
            var observable1 = ChatClient.CreateSubscriptionStream <MessageAddedSubscriptionResult>(_subscriptionRequest, callbackTester.Invoke);
            var observable2 = ChatClient.CreateSubscriptionStream <UserJoinedSubscriptionResult>(_subscriptionRequest2, callbackTester2.Invoke);

            Debug.WriteLine("subscribing...");
            var blocker = new ManualResetEventSlim(false);
            FluentTestObserver <GraphQLResponse <MessageAddedSubscriptionResult> > messagesMonitor = null;
            FluentTestObserver <GraphQLResponse <UserJoinedSubscriptionResult> >   joinedMonitor   = null;

            var tasks = new List <Task>
            {
                Task.Run(() =>
                {
                    blocker.Wait();
                    messagesMonitor = observable1.Observe();
                }),
                Task.Run(() =>
                {
                    blocker.Wait();
                    joinedMonitor = observable2.Observe();
                })
            };

            blocker.Set();
            await Task.WhenAll(tasks);

            await messagesMonitor.Should().PushAsync(1);

            messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(InitialMessage.Content);

            const string message1 = "Hello World";
            var          response = await ChatClient.AddMessageAsync(message1);

            response.Data.AddMessage.Content.Should().Be(message1);
            await messagesMonitor.Should().PushAsync(2);

            messagesMonitor.RecordedMessages.Last().Data.MessageAdded.Content.Should().Be(message1);

            joinedMonitor.Should().NotPush();
            messagesMonitor.Clear();
            joinedMonitor.Clear();

            var joinResponse = await ChatClient.JoinDeveloperUser();

            joinResponse.Data.Join.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");

            var payload = await joinedMonitor.Should().PushAsync().GetLastMessageAsync();

            using (new AssertionScope())
            {
                payload.Data.UserJoined.Id.Should().Be("1", "because that's the id we sent with our mutation request");
                payload.Data.UserJoined.DisplayName.Should().Be("developer", "because that's the display name of user \"1\"");
            }

            messagesMonitor.Should().NotPush();
            messagesMonitor.Clear();
            joinedMonitor.Clear();

            Debug.WriteLine("disposing subscription...");
            joinedMonitor.Dispose();

            const string message3 = "lorem ipsum dolor si amet";

            response = await ChatClient.AddMessageAsync(message3);

            response.Data.AddMessage.Content.Should().Be(message3);
            var msg = await messagesMonitor.Should().PushAsync().GetLastMessageAsync();

            msg.Data.MessageAdded.Content.Should().Be(message3);

            // disposing the client should complete the subscription
            ChatClient.Dispose();
            await messagesMonitor.Should().CompleteAsync();
        }