public async Task StartConnection_OnReadClose_IfConnectionIsOpen_CloseConnection()
{
// set the underlying connection to not auto close when it retrieves a close message
// from the queue, leaving it up to the apollo client to do the close
var socketClient = new MockClientConnection(autoCloseOnReadCloseMessage: false);
var options = new SubscriptionServerOptions <GraphSchema>();
var provider = new ServiceCollection().BuildServiceProvider();
var apolloClient = new ApolloClientProxy <GraphSchema>(
socketClient,
options,
new ApolloMessageConverterFactory(),
null,
false);
var eventCalled = false;
void ConnectionClosed(object sender, EventArgs e)
{
eventCalled = true;
}
apolloClient.ConnectionClosed += ConnectionClosed;
// execute the connection sequence
socketClient.QueueConnectionCloseMessage();
await apolloClient.StartConnection();
Assert.IsTrue(eventCalled, "Connection Closed Event Handler not called");
}
/// <summary>
/// Asserts that a response message from the server queued and that it is of the supplied type.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="type">The type of message to check for.</param>
/// <param name="dequeue">if true, the message is removed from the queue.</param>
internal static void AssertApolloResponse(
this MockClientConnection connection,
ApolloMessageType type,
bool dequeue = true)
{
AssertApolloResponse(connection, type, null, false, null, false, dequeue);
}
/// <summary>
/// Asserts that the next message on the received queue is a DATA message and that the payload
/// matches the provided json string.
/// </summary>
/// <param name="connection">The connection.</param>
/// <param name="type">The expected type of the message.</param>
/// <param name="id">The expected identifier of the subscription that rendered the data.</param>
/// <param name="expectedPayloadJson">The expected payload of the message, converted to a json string.</param>
/// <param name="dequeue">if set to <c>true</c> if the message should be removed from the queue.</param>
internal static void AssertApolloResponse(
this MockClientConnection connection,
ApolloMessageType type,
string id,
string expectedPayloadJson,
bool dequeue = true)
{
AssertApolloResponse(connection, type, id, true, expectedPayloadJson, true, dequeue);
}
public IMessageEndpointConnection CreateConnection(MessageEndpoint endpoint)
{
var retVal =
new MockClientConnection(endpoint)
{
ErrorLogic = _errorLogic,
};
return(retVal);
}
public void Setup()
{
user = new UserInfo("Nickname", "Phonetic", "Username", 1, 2, true);
manager = new ServerUserManager();
provider = new MockConnectionProvider(GablarskiProtocol.Instance);
provider.Start(MessageTypes.All);
var cs = provider.GetConnections(GablarskiProtocol.Instance);
server = cs.Item2;
client = cs.Item1;
}
private void connectAndJoinRoom()
{
mockClientConnection = new MockClientConnection();
mockClientConnection.SendEventBehaviourHandler = sendEventBehaviourHandler;
mockClientConnection.SendOperationResponseBehaviourHandler = sendOperationResponseBehaviourHandler;
instanceServerApplication.ListenForClientJoinRoomRequest(mockClientConnection);
// Step 1. Fake join room request
Task.Delay(100).ContinueWith(t => {
Core.Logging.Log.Info("---- Mock client " + mockClientConnection.ConnectionId + " sending JoinRoomOpRequest.");
mockClientConnection.OnOperationRequest(
new JoinRoomOpRequest(Mocking.Net.Services.Session.MockSessionService.VALID_SESSION_ID,
"testRoom", "testPassword").ToOperationRequest(), new SendParameters());
});
}
private static void AssertApolloResponse(
this MockClientConnection connection,
ApolloMessageType type,
string id,
bool compareId,
string expectedPayloadJson,
bool compareJson,
bool dequeue = true)
{
if (connection.ResponseMessageCount == 0)
{
Assert.Fail("No messages queued.");
}
var message = dequeue ? connection.DequeueNextReceivedMessage() : connection.PeekNextReceivedMessage();
var str = Encoding.UTF8.GetString(message.Data);
var options = new JsonSerializerOptions();
options.PropertyNameCaseInsensitive = true;
options.AllowTrailingCommas = true;
options.Converters.Add(new ApolloResponseMessageConverter());
var convertedMessage = System.Text.Json.JsonSerializer.Deserialize <ApolloResponseMessage>(str, options);
Assert.IsNotNull(convertedMessage, "Could not deserialized response message");
Assert.AreEqual(type, convertedMessage.Type, $"Expected message type of {type.ToString()} but got {convertedMessage.Type.ToString()}");
if (compareJson)
{
if (expectedPayloadJson == null)
{
Assert.IsNull(convertedMessage.Payload);
}
else
{
CommonAssertions.AreEqualJsonStrings(expectedPayloadJson, convertedMessage.Payload);
}
}
if (compareId)
{
Assert.AreEqual(id, convertedMessage.Id);
}
}
public void Setup()
{
var provider = new MockConnectionProvider(SocialProtocol.Instance);
provider.ConnectionMade += (sender, args) => server = new ConnectionBuffer(args.Connection);
provider.Start(MessageTypes.Reliable);
var c = new MockClientConnection(provider);
client = new ConnectionBuffer(c);
clientContext = new SerializationContext(c, new Dictionary <byte, Protocol> {
{ 2, SocialProtocol.Instance }
});
var context = new TempestClient(c, MessageTypes.Reliable);
context.ConnectAsync(new Target(Target.LoopbackIP, 1)).Wait();
list = new WatchList(context);
}
