コード例 #1
0
        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.");
        }
コード例 #2
0
        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));
        }
コード例 #3
0
        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]);
        }
コード例 #4
0
        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);
        }