public async Task WithEncryptionCipherMismatch_ShouldLeaveMessageEncryptedAndLogError(Protocol protocol)
{
var loggerSink = new TestLoggerSink();
ILogger logger = new IO.Ably.DefaultLogger.InternalLogger(LogLevel.Error, loggerSink);
logger.LogLevel.ShouldBeEquivalentTo(LogLevel.Error);
logger.IsDebug.ShouldBeEquivalentTo(false);
var client = await GetRestClient(protocol, options =>
{
options.Logger = logger; // pass the logger into the client
});
var opts = GetOptions(examples);
opts.Logger = logger;
var channel1 = client.Channels.Get("persisted:encryption", opts);
var payload = "test payload";
await channel1.PublishAsync("test", payload);
var channel2 = client.Channels.Get("persisted:encryption", new ChannelOptions(logger, true));
var message = (await channel2.HistoryAsync()).Items.First();
loggerSink.LastLoggedLevel.Should().Be(LogLevel.Error);
message.Encoding.Should().Be("utf-8/cipher+aes-128-cbc");
}
public ClosedStateSpecs(ITestOutputHelper output) : base(output)
{
var sink = new TestLoggerSink();
_logger = new IO.Ably.DefaultLogger.InternalLogger(Defaults.DefaultLogLevel, sink);
_context = new FakeConnectionContext();
_state = new ConnectionClosedState(_context, _logger);
}
public void ACustomLoggerCanBeProvided()
{
var sink = new TestLoggerSink();
Logger.LoggerSink = sink;
Logger.Error("Boo");
sink.LastLevel.Should().Be(LogLevel.Error);
sink.LastMessage.Should().Contain("Boo");
}
public void ACustomLoggerCanBeProvided()
{
var logger = new IO.Ably.DefaultLogger.InternalLogger();
var sink = new TestLoggerSink();
logger.LoggerSink = sink;
logger.Error("Boo");
sink.LastLevel.Should().Be(LogLevel.Error);
sink.LastMessage.Should().Contain("Boo");
}
public async Task WithEncryptionCipherMismatch_ShouldLeaveMessageEncryptedAndLogError(Protocol protocol)
{
var loggerSink = new TestLoggerSink();
using (Logger.SetTempDestination(loggerSink))
{
var client = await GetRestClient(protocol);
var channel1 = client.Channels.Get("persisted:encryption", GetOptions(examples));
var payload = "test payload";
await channel1.PublishAsync("test", payload);
var channel2 = client.Channels.Get("persisted:encryption", new ChannelOptions(true));
var message = (await channel2.HistoryAsync()).Items.First();
loggerSink.LastLoggedLevel.Should().Be(LogLevel.Error);
message.Encoding.Should().Be("utf-8/cipher+aes-128-cbc");
}
}
public async Task WithEncryptionCipherAlgorithmMismatch_ShouldLeaveMessageEncryptedAndLogError(Protocol protocol)
{
var loggerSink = new TestLoggerSink();
var logger = new IO.Ably.DefaultLogger.InternalLogger(Defaults.DefaultLogLevel, loggerSink);
var client = await GetRestClient(protocol);
var channel1 = client.Channels.Get("persisted:encryption", GetOptions(examples));
var payload = "test payload";
await channel1.PublishAsync("test", payload);
var channel2 = client.Channels.Get("persisted:encryption", new ChannelOptions(logger, true, new CipherParams(Crypto.GenerateRandomKey(128, CipherMode.CBC))));
var message = (await channel2.HistoryAsync()).Items.First();
loggerSink.LastLoggedLevel.Should().Be(LogLevel.Error);
loggerSink.LastMessage.Should().Contain("Error decrypting payload");
message.Encoding.Should().Be("utf-8/cipher+aes-128-cbc");
}
public async Task WhenDeltaDecodeFail_ShouldSetStateToAttachingLogTheErrorAndDiscardTheMessage(Protocol protocol)
{
string channelName = "delta-channel".AddRandomSuffix();
var testSink = new TestLoggerSink();
var taskAwaiter = new TaskCompletionAwaiter(5000);
var firstMessageReceived = new TaskCompletionAwaiter();
using (((IInternalLogger)Logger).CreateDisposableLoggingContext(testSink))
{
var realtime = await GetRealtimeClient(protocol);
var channel = realtime.Channels.Get(channelName, new ChannelOptions(channelParams: new ChannelParams {
{ "delta", "vcdiff" }
}));
var received = new List <Message>();
channel.Subscribe(message =>
{
received.Add(message);
if (received.Count == 1)
{
firstMessageReceived.Done();
}
if (received.Count == 2)
{
taskAwaiter.Done();
}
});
await channel.AttachAsync();
// We wait for the first message to be acknowledged. Any consequent messages will be deltas
await channel.PublishAsync("firstMessage", new TestData("bar", 1, "active"));
(await firstMessageReceived).Should().BeTrue("First message should be received before continuing with broken message");
channel.Publish("second", "second message"); // We don't want to wait for the acknowledgement
realtime.ExecuteCommand(ProcessMessageCommand.Create(new ProtocolMessage(ProtocolMessage.MessageAction.Message)
{
Channel = channelName,
Messages = new[]
{
new Message
{
Id = "badMessage", Encoding = "vcdiff", Data = Array.Empty <byte>()
},
},
}));
await channel.WaitForState(ChannelState.Attaching);
await channel.WaitForAttachedState();
var result = await taskAwaiter;
result.Should().BeTrue("TaskAwaiter Done() Should be called.");
received.Should().HaveCount(2);
received[1].Data.Should().Be("second message");
// RTL17 - we make sure the message is not emitted to subscribers
received.Should().NotContain(x => x.Id == "badMessage");
bool hasVcdiffErrorMessage = testSink.Messages.Any(x => x.StartsWith(LogLevel.Error.ToString()) &&
x.Contains(ErrorCodes.VcDiffDecodeError
.ToString()));
hasVcdiffErrorMessage.Should().BeTrue();
}
}
