public PaginatedResult <T> ParsePaginatedResponse <T>(AblyRequest request, AblyResponse response, Func <PaginatedRequestParams, Task <PaginatedResult <T> > > executeDataQueryRequest) where T : class
{
LogResponse(response);
var result = Paginated(request, response, executeDataQueryRequest);
if (typeof(T) == typeof(Message))
{
var typedResult = result as PaginatedResult <Message>;
typedResult.Items.AddRange(ParseMessagesResponse(response, request.ChannelOptions));
}
if (typeof(T) == typeof(Stats))
{
var typedResult = result as PaginatedResult <Stats>;
typedResult?.Items.AddRange(ParseStatsResponse(response));
}
if (typeof(T) == typeof(PresenceMessage))
{
var typedResult = result as PaginatedResult <PresenceMessage>;
typedResult.Items.AddRange(ParsePresenceMessages(response, request.ChannelOptions));
}
return(result);
}
public T ParseResponse <T>(AblyRequest request, AblyResponse response) where T : class
{
LogResponse(response);
if (typeof(T) == typeof(PaginatedResource <Message>))
{
var result = PaginatedResource.InitialisePartialResult <Message>(response.Headers, GetLimit(request));
result.AddRange(ParseMessagesResponse(response, request.ChannelOptions));
return(result as T);
}
if (typeof(T) == typeof(PaginatedResource <Stats>))
{
var result = PaginatedResource.InitialisePartialResult <Stats>(response.Headers, GetLimit(request));
result.AddRange(ParseStatsResponse(response));
return(result as T);
}
if (typeof(T) == typeof(PaginatedResource <PresenceMessage>))
{
var result = PaginatedResource.InitialisePartialResult <PresenceMessage>(response.Headers, GetLimit(request));
result.AddRange(ParsePresenceMessages(response));
return(result as T);
}
var responseText = response.TextResponse;
if (_protocol == Protocol.MsgPack)
{
//A bit of a hack. Message pack serialiser does not like capability objects
responseText = MsgPackHelper.DeSerialise(response.Body, typeof(MessagePackObject)).ToString();
}
return((T)JsonConvert.DeserializeObject(responseText, typeof(T)));
}
public void History_ForAnEncryptedChannel_DecryptsMessagesBeforeReturningThem()
{
//Arrange
var rest = GetRestClient();
var message = new Message()
{
Name = "test", Data = "Test"
};
var defaultParams = Crypto.GetDefaultParams();
rest.ExecuteHttpRequest = request =>
{
var response = new AblyResponse()
{
Headers = DataRequestQueryTests.GetSampleHistoryRequestHeaders(),
TextResponse = string.Format("[{0}]", JsonConvert.SerializeObject(message))
};
return(response);
};
var channel = rest.Channels.Get("test", new ChannelOptions(defaultParams));
//Act
var result = channel.History();
//Assert
Assert.NotEmpty(result);
var firstMessage = result.First();
Assert.Equal(message.Data, firstMessage.Data);
}
public async Task History_ForAnEncryptedChannel_DecryptsMessagesBeforeReturningThem()
{
//Arrange
var rest = GetRestClient();
var message = new Message()
{
Name = "test", Data = "Test"
};
var defaultParams = Crypto.GetDefaultParams();
rest.ExecuteHttpRequest = request =>
{
var response = new AblyResponse()
{
Headers = DataRequestQueryTests.GetSampleHistoryRequestHeaders(),
TextResponse = $"[{JsonHelper.Serialize(message)}]"
};
return(response.ToTask());
};
var channel = rest.Channels.Get("test", new ChannelOptions(defaultParams));
//Act
var result = await channel.HistoryAsync();
//Assert
Assert.NotEmpty(result.Items);
var firstMessage = result.Items.First();
Assert.Equal(message.Data, firstMessage.Data);
}
public T ParseMessagesResponse <T>(AblyResponse response) where T : class
{
if (response.Type == ResponseType.Json)
{
return(JsonConvert.DeserializeObject <T>(response.TextResponse));
}
return(default(T));
}
private IEnumerable <Stats> ParseStatsResponse(AblyResponse response)
{
var body = response.TextResponse;
if (_protocol == Protocol.MsgPack)
{
body = ((MessagePackObject)MsgPackHelper.DeSerialise(response.Body, typeof(MessagePackObject))).ToString();
}
return(JsonConvert.DeserializeObject <List <Stats> >(body));
}
private IEnumerable <Stats> ParseStatsResponse(AblyResponse response)
{
var body = response.TextResponse;
if (_protocol == Protocol.MsgPack)
{
return((List <Stats>)MsgPackHelper.Deserialise(response.Body, typeof(List <Stats>)));
}
return(JsonHelper.Deserialize <List <Stats> >(body));
}
public void Ctor_WithEncoding_SetsEncodingCorrectly(string encoding, string expected)
{
// Arrange
// Act
var response = new AblyResponse(encoding, string.Empty, Array.Empty <byte>());
// Assert
expected.Should().Be(response.Encoding);
}
public void Ctor_WithContentType_SetsTypeCorrectly(string type, object responseType)
{
// Arrange
// Act
var response = new AblyResponse(string.Empty, type, Array.Empty <byte>());
// Assert
((ResponseType)responseType).Should().Be(response.Type);
}
public void Ctor_WithEncoding_SetsEncodingCorrectly(string encoding, string expected)
{
//Arrange
//Act
var response = new AblyResponse(encoding, "", new byte[0]);
//Assert
Assert.Equal(expected, response.Encoding);
}
public void Ctor_WhenTypeIsJson_SetsTextResponse()
{
//Arrange
var text = "Test";
//Act
var response = new AblyResponse("", "application/json", text.GetBytes());
//Assert
Assert.Equal(text, response.TextResponse);
}
public void Ctor_WithContentType_SetsTypeCorrectly(string type, object responseType)
{
//Arrange
//Act
var response = new AblyResponse("", type, new byte[0]);
//Assert
Assert.Equal((ResponseType)responseType, response.Type);
}
public void Ctor_WhenTypeIsJson_SetsTextResponse()
{
// Arrange
const string text = "Test";
// Act
var response = new AblyResponse(string.Empty, "application/json", text.GetBytes());
// Assert
text.Should().Be(response.TextResponse);
}
private static IEnumerable <T> ParseOther <T>(AblyResponse response)
{
var body = response.TextResponse;
#if MSGPACK
if (_protocol == Protocol.MsgPack)
{
return((List <Stats>)MsgPackHelper.Deserialise(response.Body, typeof(List <Stats>)));
}
#endif
return(JsonHelper.Deserialize <List <T> >(body) ?? new List <T>());
}
public T ParseResponse <T>(AblyRequest request, AblyResponse response) where T : class
{
LogResponse(response);
var responseText = response.TextResponse;
if (_protocol == Protocol.MsgPack)
{
return((T)MsgPackHelper.Deserialise(response.Body, typeof(T)));
}
return(JsonHelper.Deserialize <T>(responseText));
}
public IEnumerable <PresenceMessage> ParsePresenceMessages(AblyResponse response, ChannelOptions options)
{
if (response.Type == ResponseType.Json)
{
var messages = JsonHelper.Deserialize <List <PresenceMessage> >(response.TextResponse);
ProcessMessages(messages, options);
return(messages);
}
var payloads = MsgPackHelper.Deserialise(response.Body, typeof(List <PresenceMessage>)) as List <PresenceMessage>;
ProcessMessages(payloads, options);
return(payloads);
}
public void Parse_WithJsonResponseWhereJsonIsWrong_ReturnsUnknown500Error()
{
// Arrange
var response = new AblyResponse {
TextResponse = string.Empty, Type = ResponseType.Json, StatusCode = (HttpStatusCode)500
};
// Act
var errorInfo = ErrorInfo.Parse(response);
// Assert
errorInfo.Message.Should().Be("Unknown error");
errorInfo.Code.Should().Be(ErrorCodes.InternalError);
errorInfo.StatusCode.Should().Be(response.StatusCode);
}
public IEnumerable <PresenceMessage> ParsePresenceMessages(AblyResponse response, ChannelOptions options)
{
if (response.Type == ResponseType.Json)
{
var messages = JsonHelper.Deserialize <List <PresenceMessage> >(response.TextResponse);
ProcessMessages(messages, options);
return(messages);
}
#if MSGPACK
var payloads = MsgPackHelper.Deserialise(response.Body, typeof(List <PresenceMessage>)) as List <PresenceMessage>;
ProcessMessages(payloads, options);
return(payloads);
#else
throw new AblyException($"Response of type '{response.Type}' is invalid because MsgPack support was not enabled for this build.");
#endif
}
public void Parse_WithJsonResponseWhereJsonIsWrong_ReturnsUnknown500Error()
{
//Arrange
var response = new AblyResponse()
{
TextResponse = "", Type = ResponseType.Json, StatusCode = (HttpStatusCode)500
};
//Act
var errorInfo = ErrorInfo.Parse(response);
//Assert
Assert.Equal("Unknown error", errorInfo.Reason);
Assert.Equal(500, errorInfo.Code);
Assert.Equal(response.StatusCode, errorInfo.StatusCode);
}
public void Parse_WithValidJsonResponse_RetrievesCodeAndReasonFromJson()
{
//Arrange
var reason = "test";
var code = 40400;
var response = new AblyResponse()
{
TextResponse = string.Format("{{ \"error\": {{ \"code\":{0}, \"message\":\"{1}\" }} }}", code, reason), Type = ResponseType.Json, StatusCode = (HttpStatusCode)500
};
//Act
var errorInfo = ErrorInfo.Parse(response);
//Assert
Assert.Equal(reason, errorInfo.Reason);
Assert.Equal(code, errorInfo.Code);
}
private void LogResponse(AblyResponse response)
{
Logger.Info("Protocol:" + _protocol);
try
{
var responseBody = response.TextResponse;
if (_protocol == Protocol.MsgPack && response.Body != null)
{
responseBody = MsgPackHelper.DeSerialise(response.Body, typeof(MessagePackObject)).ToString();
}
Logger.Debug("Response: " + responseBody);
}
catch (Exception ex)
{
Logger.Error("Error while logging response body.", ex);
}
}
public void Parse_WithValidJsonResponse_RetrievesCodeAndReasonFromJson()
{
// Arrange
const string reason = "test";
var response = new AblyResponse
{
TextResponse = $"{{ \"error\": {{ \"code\":{ErrorCodes.NotFound}, \"message\":\"{reason}\" }} }}",
Type = ResponseType.Json,
StatusCode = (HttpStatusCode)500
};
// Act
var errorInfo = ErrorInfo.Parse(response);
// Assert
errorInfo.Message.Should().Be(reason);
errorInfo.Code.Should().Be(ErrorCodes.NotFound);
}
public IEnumerable <PresenceMessage> ParsePresenceMessages(AblyResponse response)
{
if (response.Type == ResponseType.Json)
{
var messages = JsonConvert.DeserializeObject <List <PresenceMessage> >(response.TextResponse);
ProcessMessages(messages, new ChannelOptions());
return(messages);
}
var payloads = MsgPackHelper.DeSerialise(response.Body, typeof(List <PresenceMessage>)) as List <PresenceMessage>;
foreach (var payload in payloads.Where(x => x.Data != null))
{
//Unwrap the data objects because message pack leaves them as a MessagePackObject
payload.Data = ((MessagePackObject)payload.Data).ToObject();
}
ProcessMessages(payloads, new ChannelOptions());
return(payloads);
}
public async Task ShouldReturnCorrectFirstAndNextLinks()
{
//Arrange
var rest = GetRestClient(request =>
{
var response = new AblyResponse()
{
Headers = DataRequestQueryTests.GetSampleStatsRequestHeaders(),
TextResponse = "[{}]"
};
return(response.ToTask());
});
//Act
var result = await rest.StatsAsync();
//Assert
NotNull(result.NextDataQuery);
NotNull(result.FirstDataQuery);
}
public void Stats_ReturnsCorrectFirstAndNextLinks()
{
//Arrange
var rest = GetRestClient();
rest.ExecuteHttpRequest = request =>
{
var response = new AblyResponse()
{
Headers = DataRequestQueryTests.GetSampleStatsRequestHeaders(),
TextResponse = "[{}]"
};
return(response);
};
//Act
var result = rest.Stats();
//Assert
Assert.NotNull(result.NextQuery);
Assert.NotNull(result.FirstQuery);
}
private void LogResponse(AblyResponse response)
{
if (Logger.IsDebug)
{
Logger.Debug("Protocol:" + _protocol);
try
{
var responseBody = response.TextResponse;
#if MSGPACK
if (_protocol == Protocol.MsgPack && response.Body != null)
{
responseBody = MsgPackHelper.DeserialiseMsgPackObject(response.Body).ToString();
}
#endif
Logger.Debug("Response: " + responseBody);
}
catch (Exception ex)
{
Logger.Error("Error while logging response body.", ex);
}
}
}
public PaginatedResult <T> ParsePaginatedResponse <T>(AblyRequest request, AblyResponse response, Func <PaginatedRequestParams, Task <PaginatedResult <T> > > executeDataQueryRequest) where T : class
{
LogResponse(response);
var result = Paginated(request, response, executeDataQueryRequest);
if (typeof(T) == typeof(Message))
{
var typedResult = result as PaginatedResult <Message>;
var context = request.ChannelOptions.ToDecodingContext();
typedResult?.Items.AddRange(ParseMessagesResponse(response, context));
}
else if (typeof(T) == typeof(PresenceMessage))
{
var typedResult = result as PaginatedResult <PresenceMessage>;
var context = request.ChannelOptions.ToDecodingContext();
typedResult?.Items.AddRange(ParsePresenceMessages(response, context));
}
else
{
result?.Items.AddRange(ParseOther <T>(response));
}
return(result);
}
public void History_WithPartialResult_ReturnsCorrectFirstCurrentAndNextLinks()
{
//Arrange
var rest = GetRestClient();
rest.ExecuteHttpRequest = request =>
{
var response = new AblyResponse()
{
Headers = DataRequestQueryTests.GetSampleHistoryRequestHeaders(),
TextResponse = "[]"
};
return(response);
};
var channel = rest.Channels.Get("test");
//Act
var result = channel.History();
//Assert
Assert.NotNull(result.NextQuery);
Assert.NotNull(result.CurrentQuery);
Assert.NotNull(result.FirstQuery);
}
public HttpPaginatedResponse ParseHttpPaginatedResponse(AblyRequest request, AblyResponse response, PaginatedRequestParams requestParams, Func <PaginatedRequestParams, Task <HttpPaginatedResponse> > executeDataQueryRequest)
{
LogResponse(response);
return(new HttpPaginatedResponse(response, GetLimit(request), requestParams, executeDataQueryRequest));
}
/// <summary>Parse paginated response using specified parser function.</summary>
/// <typeparam name="T">Item type</typeparam>
/// <param name="request"></param>
/// <param name="response"></param>
/// <param name="funcParse">Function to parse HTTP response into a sequence of items.</param>
/// <returns></returns>
internal static PaginatedResult <T> Paginated <T>(AblyRequest request, AblyResponse response, Func <PaginatedRequestParams, Task <PaginatedResult <T> > > executeDataQueryRequest) where T : class
{
PaginatedResult <T> res = new PaginatedResult <T>(response, GetLimit(request), executeDataQueryRequest);
return(res);
}
