public async Task WithBase64Message_ShouldKeepBase64DecodedPayload()
{
var(realtime, c) = await GetClientAndChannel();
RealtimeChannel channel = (RealtimeChannel)c;
channel.SetChannelState(ChannelState.Attached);
const string testString = "Testing, testing, testing";
var successfulProtocolMessage = new ProtocolMessage(ProtocolMessage.MessageAction.Message)
{
Channel = channel.Name,
Messages = new[] { new Message {
Data = testString.ToBase64(), Encoding = "base64"
}, },
};
realtime.ExecuteCommand(ProcessMessageCommand.Create(successfulProtocolMessage));
await realtime.ProcessCommands();
var previousPayload = channel.MessageDecodingContext.PreviousPayload;
previousPayload.StringData.Should().BeNull();
previousPayload.Encoding.Should().BeEmpty();
previousPayload.ByteData.Should().Equal(testString.GetBytes());
}
public void FailMessageWaitingForAckAndClearOutgoingQueue(RealtimeChannel channel, ErrorInfo error)
{
error = error ?? new ErrorInfo($"Channel cannot publish messages whilst state is {channel.State}", 50000);
AckProcessor.FailChannelMessages(channel.Name, error);
//TODO: Clear messages from the outgoing queue
}
WhenMessageReceived_WithNotMatchingDeltaFromProperty_ShouldStartDecodeRecoveryAndMoveToAttachingWithError()
{
var(realtime, c) = await GetClientAndChannel();
RealtimeChannel channel = (RealtimeChannel)c;
channel.SetChannelState(ChannelState.Attached);
var awaiter = new TaskCompletionAwaiter();
ChannelStateChange stateChange = null;
channel.On(ChannelEvent.Attaching, change =>
{
stateChange = change;
channel.DecodeRecovery.Should().BeTrue();
awaiter.Done();
});
realtime.ExecuteCommand(ProcessMessageCommand.Create(
new ProtocolMessage(ProtocolMessage.MessageAction.Message)
{
Channel = channel.Name,
Messages = new[]
{
new Message {
Extras = CreateExtrasWithDelta(new DeltaExtras("1", string.Empty))
},
},
}));
await awaiter.Task;
stateChange.Current.Should().Be(ChannelState.Attaching);
stateChange.Error.Code.Should().Be(ErrorCodes.VcDiffDecodeError);
}
public async Task WithBinaryMessage_ShouldKeepItPreviousPayloadInBinaryForm()
{
var(realtime, c) = await GetClientAndChannel();
RealtimeChannel channel = (RealtimeChannel)c;
channel.SetChannelState(ChannelState.Attached);
var binaryData = new byte[] { 112, 100, 111 };
var successfulProtocolMessage = new ProtocolMessage(ProtocolMessage.MessageAction.Message)
{
Channel = channel.Name,
Messages = new[] { new Message {
Data = binaryData
}, },
};
realtime.ExecuteCommand(ProcessMessageCommand.Create(successfulProtocolMessage));
await realtime.ProcessCommands();
var previousPayload = channel.MessageDecodingContext.PreviousPayload;
previousPayload.StringData.Should().BeNull();
previousPayload.ByteData.Should().Equal(binaryData);
}
public async Task WithStringMessage_ShouldKeepItWithoutProcessing()
{
var(realtime, c) = await GetClientAndChannel();
RealtimeChannel channel = (RealtimeChannel)c;
channel.SetChannelState(ChannelState.Attached);
var successfulProtocolMessage = new ProtocolMessage(ProtocolMessage.MessageAction.Message)
{
Channel = channel.Name,
Messages = new[] { new Message {
Data = "test", Encoding = "custom"
}, },
};
realtime.ExecuteCommand(ProcessMessageCommand.Create(successfulProtocolMessage));
await realtime.ProcessCommands();
var previousPayload = channel.MessageDecodingContext.PreviousPayload;
previousPayload.Encoding.Should().Be("custom");
previousPayload.StringData.Should().Be("test");
previousPayload.ByteData.Should().BeNull();
}
WhenMultipleMessagesWithAMixOfNormalAndDeltaMessages_ShouldDecodeCorrectly()
{
using var logging = EnableDebugLogging();
var(realtime, c) = await GetClientAndChannel();
RealtimeChannel channel = (RealtimeChannel)c;
channel.SetChannelState(ChannelState.Attached);
List <Message> messages = new List <Message>();
var taskAwaiter = new TaskCompletionAwaiter(15000);
channel.Subscribe(x =>
{
messages.Add(x);
if (messages.Count == 4)
{
taskAwaiter.Done();
}
});
var protocolMessage = new ProtocolMessage(ProtocolMessage.MessageAction.Message)
{
Channel = channel.Name,
Messages = new[]
{
CreateMessage("delta.1", false),
CreateMessage("delta.1.vcdiff", true),
CreateMessage("delta.2.vcdiff", true),
CreateMessage("delta.3.vcdiff", true),
},
};
await realtime.ProcessMessage(protocolMessage);
await realtime.ProcessCommands();
var result = await taskAwaiter;
result.Should().BeTrue("Four messages should have been received.");
messages[0].Data.Should().BeOfType <string>();
IsCorrectFile(((string)messages[0].Data).GetBytes(), "delta.1");
messages[1].Data.Should().BeOfType <byte[]>();
IsCorrectFile((byte[])messages[1].Data, "delta.2");
messages[2].Data.Should().BeOfType <byte[]>();
IsCorrectFile((byte[])messages[2].Data, "delta.3");
messages[3].Data.Should().BeOfType <byte[]>();
IsCorrectFile((byte[])messages[3].Data, "delta.4");
WithChannelInAttachingState_WhenTransportIsDisconnected_ShouldResendAttachMessageOnConnectionResumed2(
Protocol protocol)
{
var testLogger = new TestLogger("RealtimeChannel.SendMessage:Attach");
Logger = testLogger;
var client = await GetRealtimeClient(protocol);
var channel = new RealtimeChannel("RTN19b", "RTN19b", client);
channel.Logger = testLogger;
channel.State = ChannelState.Attaching;
channel.InternalOnInternalStateChanged(this, new ConnectionStateChange(ConnectionState.Connected, ConnectionState.Disconnected));
testLogger.MessageSeen.Should().Be(true);
}
WhenMessageReceivedAndFailsVcdiffDecoding_ShouldSendAttachProtocolMessageWithLastSuccessfulChannelSerial()
{
var(realtime, c) = await GetClientAndChannel();
RealtimeChannel channel = (RealtimeChannel)c;
channel.SetChannelState(ChannelState.Attached);
var successfulProtocolMessage = new ProtocolMessage(ProtocolMessage.MessageAction.Message)
{
Channel = channel.Name,
ChannelSerial = "testSerial",
Messages = new[] { new Message {
Data = "test", Encoding = string.Empty
}, },
};
realtime.ExecuteCommand(ProcessMessageCommand.Create(successfulProtocolMessage));
var awaiter = new TaskCompletionAwaiter();
channel.On(ChannelEvent.Attaching, change => { awaiter.Tick(); });
realtime.ExecuteCommand(ProcessMessageCommand.Create(
new ProtocolMessage(ProtocolMessage.MessageAction.Message)
{
Channel = channel.Name,
Messages = new[]
{
new Message {
Extras = CreateExtrasWithDelta(new DeltaExtras("1", string.Empty))
},
},
}));
await awaiter.Task;
await realtime.ProcessCommands();
var fakeTransport = FakeTransportFactory.LastCreatedTransport;
var lastMessageSend = fakeTransport.LastMessageSend;
lastMessageSend.Should().NotBeNull();
lastMessageSend.Action.Should().Be(ProtocolMessage.MessageAction.Attach);
lastMessageSend.ChannelSerial.Should().Be("testSerial");
}
public async Task WhenMessageReceived_WithDeltaError_ShouldNotPassMessageToChannelSubscriber()
{
var(realtime, c) = await GetClientAndChannel();
RealtimeChannel channel = (RealtimeChannel)c;
channel.SetChannelState(ChannelState.Attached);
List <Message> receivedMessages = new List <Message>();
channel.Subscribe(receivedMessages.Add);
realtime.ExecuteCommand(ProcessMessageCommand.Create(
new ProtocolMessage(ProtocolMessage.MessageAction.Message)
{
Channel = channel.Name,
Messages = new[] { new Message {
Id = "goodMessage", Data = "test"
}, },
}));
realtime.ExecuteCommand(ProcessMessageCommand.Create(
new ProtocolMessage(ProtocolMessage.MessageAction.Message)
{
Channel = channel.Name,
Messages = new[]
{
new Message {
Extras = CreateExtrasWithDelta(new DeltaExtras("1", string.Empty))
},
},
}));
await Task.Delay(2000); // wait for 2 seconds
// We want to ensure just the good message was received
receivedMessages.Should().HaveCount(1);
receivedMessages.Should().Contain(x => x.Id == "goodMessage");
}
