public async Task PutAsJsonAsync_ShouldSendAsyncPutRequestMessage()
{
// Arrange
const string requestUri = "http://some/url";
var putRequest = new HttpRequestMessage(HttpMethod.Put, requestUri);
var sut = Substitute.ForPartsOf <HttpClientWrapper>(_client);
var responseMessage = new HttpResponseMessage();
var data = new SessionUpdate(SessionStatus.Error, "something bad happened!");
sut.WhenForAnyArgs(x => x.CreateRequestMessage(HttpMethod.Put, requestUri)).DoNotCallBase();
sut.CreateRequestMessage(Arg.Is(HttpMethod.Put), Arg.Is(requestUri)).Returns(putRequest);
var formatter = new JsonMediaTypeFormatter();
sut.GetFormatters().Returns(new MediaTypeFormatter[] { formatter });
_client.SendAsync(putRequest, CancellationToken.None).Returns(Task.FromResult(responseMessage));
// Act
var result = await sut.PutAsJsonAsync(requestUri, data);
// Assert
result.Should().BeSameAs(responseMessage);
var content = putRequest.Content.Should().BeOfType <ObjectContent <SessionUpdate> >().Subject;
content.Value.Should().BeSameAs(data);
content.Formatter.Should().BeSameAs(formatter);
}
protected virtual void OnSessionUpdate(Vector3 handPoint)
{
notifyListeners("Session_Update", handPoint);
if (null != SessionUpdate)
{
SessionUpdate.Invoke(this, new SessionUpdateEventArgs(handPoint));
}
}
/// <summary>
/// Creates an envelope item from a session update.
/// </summary>
public static EnvelopeItem FromSession(SessionUpdate sessionUpdate)
{
var header = new Dictionary <string, object?>(1, StringComparer.Ordinal)
{
[TypeKey] = TypeValueSession
};
return(new EnvelopeItem(header, new JsonSerializable(sessionUpdate)));
}
/// <summary>
/// Creates an envelope that contains a session update.
/// </summary>
public static Envelope FromSession(SessionUpdate sessionUpdate)
{
var header = CreateHeader();
var items = new[]
{
EnvelopeItem.FromSession(sessionUpdate)
};
return(new Envelope(header, items));
}
public void Serialization_Session_Success()
{
// Arrange
var session = new Session(
SentryId.Parse("75302ac48a024bde9a3b3734a82e36c8"),
"bar",
DateTimeOffset.Parse("2020-01-01T00:00:00+00:00", CultureInfo.InvariantCulture),
"release123",
"env123",
"192.168.0.1",
"Google Chrome"
);
session.ReportError();
session.ReportError();
session.ReportError();
var sessionUpdate = new SessionUpdate(
session,
true,
DateTimeOffset.Parse("2020-01-02T00:00:00+00:00", CultureInfo.InvariantCulture),
5,
SessionEndStatus.Crashed
);
// Act
var json = sessionUpdate.ToJsonString();
// Assert
json.Should().Be(
"{" +
"\"sid\":\"75302ac48a024bde9a3b3734a82e36c8\"," +
"\"did\":\"bar\"," +
"\"init\":true," +
"\"started\":\"2020-01-01T00:00:00+00:00\"," +
"\"timestamp\":\"2020-01-02T00:00:00+00:00\"," +
"\"seq\":5," +
"\"duration\":86400," +
"\"errors\":3," +
"\"status\":\"crashed\"," +
"\"attrs\":{" +
"\"release\":\"release123\"," +
"\"environment\":\"env123\"," +
"\"ip_address\":\"192.168.0.1\"," +
"\"user_agent\":\"Google Chrome\"" +
"}" +
"}"
);
}
public async Task ConnectToSession (string sessionId) {
UserModel user = await userManager.GetUserAsync( Context.GetHttpContext().User );
await Groups.AddToGroupAsync( Context.ConnectionId, sessionId );
IEnumerable<string> membersAfter = hubGroupService.AddToSession( sessionId, user.UserId );
Task<Session> sessionTask = sessionService.Get( sessionId );
Task<Game> gameTask = gameService.Get( sessionId );
Task<Board> boardTask = boardService.Get( sessionId );
SessionUpdate sessionUpdate = new SessionUpdate {
SessionId = sessionId,
Session = await sessionTask,
Game = await gameTask,
Board = await boardTask
};
await Clients.Caller.SendAsync(
"HandleSessionUpdate",
sessionUpdate
);
await Clients.Group( sessionId ).SendAsync( "UpdateConnectedPlayers", sessionId, membersAfter.ToArray() );
}
private static async Task <ISerializable> DeserializePayloadAsync(
Stream stream,
IReadOnlyDictionary <string, object?> header,
CancellationToken cancellationToken = default)
{
var payloadLength = header.GetValueOrDefault(LengthKey) switch
{
null => (long?)null,
var value => Convert.ToInt64(value)
};
var payloadType = header.GetValueOrDefault(TypeKey) as string;
// Event
if (string.Equals(payloadType, TypeValueEvent, StringComparison.OrdinalIgnoreCase))
{
var bufferLength = (int)(payloadLength ?? stream.Length);
var buffer = await stream.ReadByteChunkAsync(bufferLength, cancellationToken).ConfigureAwait(false);
var json = Json.Parse(buffer);
return(new JsonSerializable(SentryEvent.FromJson(json)));
}
// User report
if (string.Equals(payloadType, TypeValueUserReport, StringComparison.OrdinalIgnoreCase))
{
var bufferLength = (int)(payloadLength ?? stream.Length);
var buffer = await stream.ReadByteChunkAsync(bufferLength, cancellationToken).ConfigureAwait(false);
var json = Json.Parse(buffer);
return(new JsonSerializable(UserFeedback.FromJson(json)));
}
// Transaction
if (string.Equals(payloadType, TypeValueTransaction, StringComparison.OrdinalIgnoreCase))
{
var bufferLength = (int)(payloadLength ?? stream.Length);
var buffer = await stream.ReadByteChunkAsync(bufferLength, cancellationToken).ConfigureAwait(false);
var json = Json.Parse(buffer);
return(new JsonSerializable(Transaction.FromJson(json)));
}
// Session
if (string.Equals(payloadType, TypeValueSession, StringComparison.OrdinalIgnoreCase))
{
var bufferLength = (int)(payloadLength ?? stream.Length);
var buffer = await stream.ReadByteChunkAsync(bufferLength, cancellationToken).ConfigureAwait(false);
var json = Json.Parse(buffer);
return(new JsonSerializable(SessionUpdate.FromJson(json)));
}
// Arbitrary payload
var payloadStream = new PartialStream(stream, stream.Position, payloadLength);
if (payloadLength is not null)
{
stream.Seek(payloadLength.Value, SeekOrigin.Current);
}
else
{
stream.Seek(0, SeekOrigin.End);
}
return(new StreamSerializable(payloadStream));
}
public void CaptureSession(SessionUpdate sessionUpdate)
{
}
