public async Task Should_skip_decompression_if_no_compression_header_is_found()
{
var body = new byte[] { 1, 2, 3 };
var message = new Message(body);
var decompressorExecuted = false;
var receivePlugin = new CompressionPlugin(
new CompressionConfiguration("noop", bytes => bytes, 1,
new Dictionary <string, Func <byte[], byte[]> >
{
{
"compression-x", bytes =>
{
decompressorExecuted = true;
return(bytes);
}
}
}));
var receivedMessage = await receivePlugin.AfterMessageReceive(message);
Assert.Equal(body, receivedMessage.Body);
Assert.False(decompressorExecuted, "Decompressing function should not have executed, but it did.");
}
/// <summary>
/// Register compression plugin with customizations.
/// </summary>
/// <param name="compressionConfiguration">Compression to be used.</param>
/// <param name="client"></param>
public static ServiceBusPlugin RegisterCompressionPlugin(this ClientEntity client, CompressionConfiguration compressionConfiguration)
{
ServiceBusPlugin plugin = new CompressionPlugin(compressionConfiguration);
client.RegisterPlugin(plugin);
return(plugin);
}
public async Task Should_not_compress_empty_body()
{
var message = new Message(new byte[] {});
var plugin = new CompressionPlugin(new GzipCompressionConfiguration());
var result = await plugin.BeforeMessageSend(message);
Assert.Equal(Array.Empty <byte>(), result.Body);
Assert.False(message.UserProperties.ContainsKey(Headers.CompressionMethodName), "Header should not be found for a message with empty body.");
}
public async Task Should_not_compress_null_body()
{
var message = new Message(null);
var plugin = new CompressionPlugin(new GzipCompressionConfiguration());
var result = await plugin.BeforeMessageSend(message);
Assert.Null(result.Body);
Assert.False(message.UserProperties.ContainsKey(Headers.CompressionMethodName), "Header should not be found for a message with null body.");
}
public async Task Should_not_compress_body_smaller_than_configured_size()
{
var bytes = new byte[] { 1, 2, 3 };
var message = new Message(bytes);
var plugin = new CompressionPlugin(new GzipCompressionConfiguration());
var result = await plugin.BeforeMessageSend(message);
Assert.Equal(bytes, result.Body);
Assert.False(message.UserProperties.ContainsKey(Headers.CompressionMethodName), "Header should not be found for a message with empty body.");
}
public async Task Should_throw_for_not_configured_compression_method()
{
var bytes = new byte[] { 1, 2, 3 };
var message = new Message(bytes);
var plugin = new CompressionPlugin(new GzipCompressionConfiguration());
var sentMessage = await plugin.BeforeMessageSend(message);
sentMessage.UserProperties[Headers.CompressionMethodName] = "Unknown";
await Assert.ThrowsAsync <Exception>(() => plugin.AfterMessageReceive(sentMessage));
}
public async Task Should_receive_it()
{
var payload = new string('A', 1500);
var bytes = Encoding.UTF8.GetBytes(payload);
var message = new Message(bytes);
var plugin = new CompressionPlugin(new GzipCompressionConfiguration());
var result = await plugin.BeforeMessageSend(message);
var receivedMessage = await plugin.AfterMessageReceive(result);
Assert.Equal(payload, Encoding.UTF8.GetString(receivedMessage.Body));
Assert.Equal("GZip", message.UserProperties[Headers.CompressionMethodName]);
}
public async Task Should_throw_meaningful_exception_for_erred_compression_func()
{
var configuration = new CompressionConfiguration("test", bytes => throw new Exception("compressor threw"), 1,
new Dictionary <string, Func <byte[], byte[]> > {
{ "test", bytes => null }
});
var plugin = new CompressionPlugin(configuration);
var message = new Message(new byte[] { 1, 2, 3 });
var exception = await Assert.ThrowsAsync <Exception>(() => plugin.BeforeMessageSend(message));
Assert.StartsWith("User provided compression delegate threw an exception.", exception.Message);
}
public async Task Should_be_able_to_decompress_messages_sent_with_different_compression_other_than_default()
{
var deflateCompressionConfiguration = new DeflateCompressionConfiguration();
var gzipCompressionConfiguration = new GzipCompressionConfiguration(1);
gzipCompressionConfiguration.AddDecompressor(deflateCompressionConfiguration.CompressionMethodName, DeflateDecompressor);
var bytes = Enumerable.Range(1, 1024).Select(x => (byte)x).ToArray();
var message = new Message(bytes);
message.UserProperties[Headers.CompressionMethodName] = deflateCompressionConfiguration.CompressionMethodName;
var sendPlugin = new CompressionPlugin(deflateCompressionConfiguration);
var sentMessage = await sendPlugin.BeforeMessageSend(message);
var receivePlugin = new CompressionPlugin(gzipCompressionConfiguration);
var receivedMessage = await receivePlugin.AfterMessageReceive(sentMessage);
Assert.Equal(bytes, receivedMessage.Body);
}
public async Task Should_compress_normal_body()
{
var payload = new string('A', 1500);
var bytes = Encoding.UTF8.GetBytes(payload);
var message = new Message(bytes);
var plugin = new CompressionPlugin(new GzipCompressionConfiguration());
var result = await plugin.BeforeMessageSend(message);
var bodyAsBase64String = Convert.ToBase64String(result.Body);
#if NETFRAMEWORK
Assert.Equal("H4sIAAAAAAAEAHN0HAWjYBSMglEw3AAATW9s69wFAAA=", bodyAsBase64String);
Assert.Equal(32, message.UserProperties[Headers.CompressedBodySize]);
#else
Assert.Equal("H4sIAAAAAAAAC3N0HAWjITAaAqMhMBoCjsMMAABNb2zr3AUAAA==", bodyAsBase64String);
Assert.Equal(37, message.UserProperties[Headers.CompressedBodySize]);
#endif
Assert.Equal("GZip", message.UserProperties[Headers.CompressionMethodName]);
Assert.Equal(payload.Length, message.UserProperties[Headers.OriginalBodySize]);
}