private void GivenServicesReturnExpectedValues(CreateMessageRequest parsedInput, WebexTeamsMessage apiResponse,
GlobalXMessage parsedApiResponse, Person sender)
{
_messageParser.ParseCreateMessageRequest(_input).Returns(parsedInput);
_apiService.SendMessageAsync(parsedInput).Returns(Task.FromResult(apiResponse));
_messageParser.ParseMessage(apiResponse).Returns(parsedApiResponse);
_apiService.GetPersonAsync(apiResponse.PersonId).Returns(Task.FromResult(sender));
}
internal void TestSendMessage(GlobalXMessage input, CreateMessageRequest parsedInput,
WebexTeamsMessage apiResponse, GlobalXMessage parsedApiResponse, Person sender, GlobalXMessage output)
{
this.Given(x => GivenAGlobalXMessage(input))
.And(x => GivenServicesReturnExpectedValues(parsedInput, apiResponse, parsedApiResponse, sender))
.When(x => WhenSendingAMessage())
.Then(x => ThenItShouldCallApiService())
.And(x => ThenItShouldReturnAMessage(output))
.BDDfy();
}
private async Task <Models.Message> ResendMessageWithRootParentId(Message message)
{
var parentMessage = await _apiService.GetMessageAsync(message.ParentId);
message.ParentId = parentMessage.ParentId;
var request = _messageParser.ParseCreateMessageRequest(message);
var result = await _apiService.SendMessageAsync(request).ConfigureAwait(false);
return(result);
}
internal void TestSendBadParentMessage(GlobalXMessage input, WebexTeamsMessage apiResponse)
{
this.Given(x => GivenAGlobalXMessage(input))
.And(x => GivenApiServiceThrowsInvalidParentExceptionForBadParent())
.And(x => GivenMessageParserReturnsCreateMessageRequest())
.And(x => GivenApiServiceReturnsGoodParent())
.And(x => GivenApiServiceReturnsCorrectResult(apiResponse))
.And(x => GivenServicesReturnSomeValues())
.When(x => WhenSendingAMessage())
.Then(x => ThenThereShouldBeTwoCallsToSendMessage())
.BDDfy();
}
public async Task <Message> SendMessageAsync(Message message)
{
var request = _messageParser.ParseCreateMessageRequest(message);
Models.Message result;
try
{
result = await _apiService.SendMessageAsync(request).ConfigureAwait(false);
}
catch (InvalidParentException)
{
result = await ResendMessageWithRootParentId(message);
}
return(await GetSentMessageWithSender(result));
}
private void ThenItShouldReturnAMessage(GlobalXMessage output)
{
_output.ShouldNotBeNull();
_output.ShouldSatisfyAllConditions(
() => _output.Created.ShouldBe(output.Created),
() => _output.Text.ShouldBe(output.Text),
() => {
if (output.MessageParts != null)
{
_output.MessageParts.ShouldNotBeNull();
_output.MessageParts.Length.ShouldBe(output.MessageParts.Length);
for (int i = 0; i < _output.MessageParts.Length; i++)
{
_output.MessageParts[i].MessageType.ShouldBe(output.MessageParts[i].MessageType);
_output.MessageParts[i].Text.ShouldBe(output.MessageParts[i].Text);
_output.MessageParts[i].UserId.ShouldBe(output.MessageParts[i].UserId);
}
}
else
{
_output.MessageParts.ShouldBeNull();
}
},
() =>
{
if (output.Sender != null)
{
ComparePeople(output.Sender, _output.Sender);
}
else
{
_output.Sender.ShouldBeNull();
}
},
() => _output.RoomId.ShouldBe(output.RoomId),
() => _output.RoomType.ShouldBe(output.RoomType)
);
}
private void GivenAGlobalXMessage(GlobalXMessage input)
{
_input = input;
}
private async void WhenSendingAMessage()
{
_output = await _subject.SendMessageAsync(_input);
}
public CreateMessageRequest ParseCreateMessageRequest(GlobalXMessage message)
{
var request = new CreateMessageRequest
{
ParentId = message.ParentId
};
string roomDecoded;
try
{
var base64String = message.RoomId;
if (base64String.Length % 4 != 0)
{
var amountToPad = 4 - base64String.Length % 4;
base64String = base64String.PadRight(base64String.Length + amountToPad, '=');
}
var roomBytes = Convert.FromBase64String(base64String);
roomDecoded = Encoding.UTF8.GetString(roomBytes);
}
catch (FormatException)
{
throw new ArgumentException($"Invalid room ID {message.RoomId}");
}
if (roomDecoded.StartsWith(RoomIdPrefix))
{
request.RoomId = message.RoomId;
}
else if (roomDecoded.StartsWith(PersonIdPrefix))
{
request.ToPersonId = message.RoomId;
}
else
{
throw new ArgumentException($"Invalid room ID {message.RoomId}");
}
if (!string.IsNullOrWhiteSpace(message.Text) && (message.MessageParts == null || message.MessageParts.Length == 0))
{
request.Markdown = message.Text;
}
else if (message.MessageParts?.Length > 0)
{
var markdownBuilder = new StringBuilder();
foreach (MessagePart messagePart in message.MessageParts)
{
switch (messagePart.MessageType)
{
case MessageType.Text:
markdownBuilder.Append(messagePart.Text);
break;
case MessageType.PersonMention:
markdownBuilder.Append($"<@personId:{messagePart.UserId}|{messagePart.Text}>");
break;
case MessageType.GroupMention:
markdownBuilder.Append($"<@{messagePart.UserId}>");
break;
case MessageType.OrderedList:
markdownBuilder.Append("\n1. ");
markdownBuilder.Append(string.Join("\n1. ", messagePart.ListItems));
markdownBuilder.Append("\n");
break;
case MessageType.UnorderedList:
markdownBuilder.Append("\n- ");
markdownBuilder.Append(string.Join("\n- ", messagePart.ListItems));
markdownBuilder.Append("\n");
break;
default:
throw new ArgumentException($"Invalid message type {messagePart.MessageType}");
}
}
request.Markdown = markdownBuilder.ToString();
}
else
{
throw new ArgumentException("Please provide a message to send");
}
return(request);
}
