Ejemplo n.º 1
0
        public static async Task <MessageResponse> AddMessageAsync(SignalRClient signalRClient, Guid channelId)
        {
            // Create the message called test
            var createMessageRequest = new AddMessageRequest
            {
                ChannelId = channelId,
                Body      = "test",
                Type      = MessageType.Default,
                RequestId = Guid.NewGuid().ToString()
            };

            Console.WriteLine("Creating the message");
            var createdMessage = await signalRClient.AddMessageAsync(createMessageRequest);

            Console.WriteLine("Message was created.");
            Console.WriteLine();

            return(createdMessage);
        }
Ejemplo n.º 2
0
        public async Task Step3_ShouldAddUpdateDeleteMessage()
        {
            // Add message
            // Arrange
            var addMessageRequest = new AddMessageRequest
            {
                ChannelId = _testChannel.Id,
                Body      = "test_body",
                ImageUrl  = string.Empty,
                RequestId = "82EEC70D-D808-492C-98E3-6A5B47276990",
                Type      = MessageType.Default
            };

            // Subscribe event
            MessageResponse addedMessageResponse = null;

            void OnMessageAdded(MessageResponse response)
            {
                addedMessageResponse = response;
            }

            _userSignalRClient.MessageAdded += OnMessageAdded;

            // Act
            var messageResponse = await _adminSignalRClient.AddMessageAsync(addMessageRequest);

            // Unsubscribe events
            _userSignalRClient.MessageAdded -= OnMessageAdded;

            // Assert
            addedMessageResponse.Should().NotBeNull();
            addedMessageResponse.Should().BeEquivalentTo(messageResponse);

            // Update message
            // Arrange
            var updatedMessageRequest = new UpdateMessageRequest
            {
                Body      = $"new_{messageResponse.Body}",
                RequestId = "8992BCD7-630E-4F22-92BF-1A3AA4B7D11E",
                MessageId = messageResponse.Id
            };

            // Subscribe event
            void OnMessageUpdated(MessageResponse response)
            {
                messageResponse = response;
            }

            _userSignalRClient.MessageUpdated += OnMessageUpdated;

            // Act
            await _adminSignalRClient.UpdateMessageAsync(updatedMessageRequest);

            // Unsubscribe events
            _userSignalRClient.MessageUpdated -= OnMessageUpdated;

            // Assert
            messageResponse.Should().NotBeNull();
            messageResponse.Body.Should().BeEquivalentTo(updatedMessageRequest.Body);

            // Delete message
            // Arrange
            var deleteMessageRequest = new DeleteMessageRequest
            {
                RequestId = "47AF87B2-C39F-4814-AD62-3BC078E2A9BA",
                MessageId = messageResponse.Id
            };

            // Subscribe event
            ChannelSummaryResponse channelSummaryResponse = null;
            Guid messageId = new Guid();

            void OnMessageDeleted(Guid id, ChannelSummaryResponse response)
            {
                messageId = id;
                channelSummaryResponse = response;
            }

            _userSignalRClient.MessageDeleted += OnMessageDeleted;

            // Act
            await _adminSignalRClient.DeleteMessageAsync(deleteMessageRequest);

            // Unsubscribe events
            _userSignalRClient.MessageDeleted -= OnMessageDeleted;

            // Assert
            messageId.Should().Be(messageResponse.Id);
            channelSummaryResponse.UnreadMessagesCount.Should().Be(0);
        }
Ejemplo n.º 3
0
        public async Task Step3_AddInviteLeaveMember()
        {
            // Invite member
            // Arrange
            var client = _server.CreateClient();

            client.DefaultRequestHeaders.Add("Authorization", "Bearer " + _adminToken);

            var newMemberSignalRClient = new SignalRClient(_server.BaseAddress.ToString());
            var userToken = await GetJwtTokenAsync("*****@*****.**", "123QWqw!");

            await newMemberSignalRClient.ConnectAsync(userToken, _server.CreateHandler());

            var newUser = await newMemberSignalRClient.AddClientAsync();

            var inviteMultipleMembersRequest = new SignalR.TransportModels.Request.Member.InviteMultipleMembersRequest
            {
                ChannelId         = _testChannel.Id,
                RequestId         = "A372A27B-4860-44AB-9915-27B8CAFB68A3",
                InvitedMembersIds = new List <Guid> {
                    new Guid(newUser.MemberId.ToString())
                }
            };

            // Subscribe event
            MessageResponse userExistsaddedMessageResponse = null;

            void OnMessageAdded(MessageResponse response)
            {
                userExistsaddedMessageResponse = response;
            }

            newMemberSignalRClient.MessageAdded += OnMessageAdded;

            // Act
            async Task <ChannelResponse> GetChannelResponse(HttpClient httpClient)
            {
                var channelResponse = await httpClient.GetAsync(RequestUri);

                var channels = await channelResponse.Content.ReadAsStringAsync();

                var channel = JsonConvert.DeserializeObject <List <ChannelResponse> >(channels).FirstOrDefault();

                return(channel);
            }

            await _adminSignalRClient.InviteMultipleMembersAsync(inviteMultipleMembersRequest);

            var twoMemberChannel = await GetChannelResponse(client);

            var addMessageRequest = new AddMessageRequest
            {
                ChannelId = _testChannel.Id,
                Body      = "test_body",
                ImageUrl  = string.Empty,
                RequestId = "82EEC70D-D808-492C-98E3-6A5B47276990",
                Type      = MessageType.Default
            };

            await _adminSignalRClient.AddMessageAsync(addMessageRequest);

            // Unsubscribe events
            newMemberSignalRClient.MessageAdded -= OnMessageAdded;

            // Assert
            userExistsaddedMessageResponse.Should().NotBeNull();
            userExistsaddedMessageResponse.ChannelId.Should().Be(addMessageRequest.ChannelId);
            userExistsaddedMessageResponse.Body.Should().Be(addMessageRequest.Body);
            twoMemberChannel.Should().NotBeNull();
            twoMemberChannel.MembersCount.Should().Be(2);

            // Leave channel
            // Arrange
            var channelRequest = new ChannelRequest
            {
                ChannelId = _testChannel.Id,
                RequestId = "48033741-F54F-46A4-8AB4-3BFF5EACDBAC"
            };

            // Subscribe event
            MessageResponse userDoesntExistaddedMessageResponse = null;

            void OnMessageSent(MessageResponse response)
            {
                userDoesntExistaddedMessageResponse = response;
            }

            newMemberSignalRClient.MessageAdded += OnMessageSent;

            // Act
            await newMemberSignalRClient.LeaveChannelAsync(channelRequest);

            await _adminSignalRClient.AddMessageAsync(addMessageRequest);

            var oneMemberChannel = await GetChannelResponse(client);

            // Unsubscribe events
            newMemberSignalRClient.MessageAdded -= OnMessageSent;

            // Assert
            userDoesntExistaddedMessageResponse.Should().BeNull();
            oneMemberChannel.Should().NotBeNull();
            oneMemberChannel.MembersCount.Should().Be(1);
        }