initial code

Author: AdamWalkowski

Diff for: .gitignore

@@ -0,0 +1,34 @@
+using Sinch.Encoding;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Header = System.Collections.Generic.KeyValuePair<string, string>;
+
+var message = new SignalMessage
+{
+    Headers = new Dictionary<string, string>(new Header[] {
+        new Header("name-1", "value-1"),
+        new Header("name-2", "value-2"),
+        new Header("name-3", "value-3"),
+    }),
+    Payload = new byte[] { 0b00100011, 0b00011010, 0b00100011 }
+};
+
+Console.WriteLine($"This is object before encoding: ${JsonSerializer.Serialize(message, new JsonSerializerOptions { WriteIndented = true })}\n");
+
+var byteEncoder = new ByteBufferBuilder();
+var encoder = new SignalMessageCodec(byteEncoder);
+
+try
+{
+    var encodedMessage = encoder.Encode(message);
+
+    Console.WriteLine($"This is encoded stream: ${Convert.ToHexString(encodedMessage)}\n");
+
+    var decodedMessage = encoder.Decode(encodedMessage);
+
+    Console.WriteLine($"This is object after decoding: ${JsonSerializer.Serialize(decodedMessage, new JsonSerializerOptions { WriteIndented = true })}\n");
+}
+catch (Exception ex)
+{
+    Console.WriteLine($"Something happened: {ex.Message}");
+}

Diff for: Program.cs

@@ -0,0 +1,58 @@
+# #1 Simple binary encoding for messages
+
+To properly decode message from binary stream some structured informations is needed to avoid traversing through the streams in search for some special bytes dividing blocks of data.
+
+## #1.1 Assumptions about model:
+
+1. A message can contain a binary payload limited to 256 kB.
+2. A message can contain maximal 63 headers as pairs of ASCII-encoded strings.
+3. Each header lenght (name + value) is limited to 2046 bytes.
+
+## #1.2 Assumptions about encoding algorithm:
+
+1. Should not be generic rather optimized to specific structure described in #1.1.
+2. Optimization for transport (data compression) is not a requirement.
+3. Should be simple and easy to maintain and present accepting lower encoding/decoding performance (avoiding unmanaged code).
+
+## #1.3 Therefore simple binary stream structure should contain:
+
+1. Headers count.
+2. For each header offset between name part and value part.
+3. Optional checksum (hash).
+
+# #2 Binary stream encoding
+
+Message model contains a dictionary of headers and raw byte stream of message payload. For effectivness of decoding I decided to place in encoded stream
+metadata information about:
+
+1. payload offest - 4 bytes,
+2. number of headers - 2 bytes,
+3. for each header a 4 byte prefix - first two bytes stores offset of the value part, second 2 bytes stores length of value part.
+
+| payload offset | 4 bytes
+| headers count | 2 bytes
+| value1 offset | 2 bytes
+| value1 length | 2 bytes
+| name1 | 1 kb
+| value1 | 1 kb
+| value2 offset | 2 bytes
+| value2 length | 2 bytes
+| name2 | 1 kb
+| value2 | 1 kb
+| ... | ...
+| payload | 256 kb
+
+Metadata are introduced to make decoding efficient and avoid scanning whole streams for special bytes etc.
+Payload offset on start tells what is the volume of headers part of the encoded stream.
+Value offset simplifies reading name part of heas whereas value length simplifies reading of value part.
+
+# #3 Implementation
+
+To keep codec structure simple and clean I recognized two aspects of the process - encoding sheme layer and binary operations layer (mapping primitives into bytes streams).
+Each aspect is encapsulated in separate module - MessageCodec and ByteBufferBuilder respectively. ByteBufferBuilder module is a ependency of MassageCodec module.
+
+I've started from pure unit tests for an algorithm as specification for my coding algorithm. Also included tests for binary streams builder and
+two integration tests for decoding.
+
+Accoringly to task description I assume that headers and payload are not obligatory for message (...can contain...) and I assume that
+completely empty message (without and headers and no payload) is invalid.

Diff for: README.md

@@ -0,0 +1,60 @@
+namespace Sinch.Encoding.Tests
+{
+    public class ByteBufferBuilderSpecs
+    {
+        private ByteBufferBuilder builder;
+        public ByteBufferBuilderSpecs()
+        {
+            builder = new ByteBufferBuilder();
+        }
+
+        [Fact]
+        public void Should_join_three_buffers_into_one()
+        {
+            // given      
+            byte[] first = System.Text.Encoding.ASCII.GetBytes("heading text");
+            byte[] second = System.Text.Encoding.ASCII.GetBytes("payload content");
+            byte[] third = System.Text.Encoding.ASCII.GetBytes("some other textual content");
+
+            // when
+            byte[] result = builder.JoinBuffers(first, second, third);
+
+            // then
+            Assert.Equal(
+                $"heading textpayload contentsome other textual content",
+                System.Text.Encoding.Default.GetString(result)
+            );
+        }
+
+        [Fact]
+        public void Should_copy_into_stream()
+        {
+            // given
+            var target = new byte[15];
+            var buffers = new List<byte[]>(new[] {
+                System.Text.Encoding.ASCII.GetBytes("Apollo"),
+                System.Text.Encoding.ASCII.GetBytes("Mars"),
+                System.Text.Encoding.ASCII.GetBytes("Venus")
+            }).ToArray();
+
+            // when
+            builder.CopyBuffersIntoTarget(target, null, buffers);
+
+            // then
+            Assert.Equal("ApolloMarsVenus", new String(System.Text.Encoding.ASCII.GetChars(target)));
+        }
+
+        [Fact]
+        public void Should_copy_from_stream()
+        {
+            // given
+            var stream = System.Text.Encoding.ASCII.GetBytes("0123456789");
+
+            // when
+            var result = builder.CopyFromStream(stream, 2, 5);
+
+            // then
+            Assert.Equal("23456", new String(System.Text.Encoding.ASCII.GetChars(result)));
+        }
+    }
+}

Diff for: Sinch.Encoding.Tests/ByteBufferBuilderSpecs.cs

@@ -0,0 +1,68 @@
+using Header = System.Collections.Generic.KeyValuePair<string, string>;
+
+namespace Sinch.Encoding.Tests
+{
+    public class IngerationDecodingSpecs
+    {
+        private Random random;
+        private SignalMessageCodec _encoder;
+        public IngerationDecodingSpecs()
+        {
+            random = new Random(DateTime.Now.Millisecond);
+            var builder = new ByteBufferBuilder();
+            _encoder = new SignalMessageCodec(builder);
+        }
+
+        [Fact]
+        public void Should_decode_simple_message()
+        {
+            // given
+            var message = new SignalMessage
+            {
+                Headers = new Dictionary<string, string>(new Header[]
+                {
+                    new Header("Alpha", "Beta"),
+                    new Header("Kappa", "Omega")
+                }),
+                Payload = System.Text.Encoding.UTF8.GetBytes("Some Text")
+            };
+            var encodedMessage = _encoder.Encode(message);
+
+            // when
+            var decodedMessage = _encoder.Decode(encodedMessage);
+
+            // then
+            Assert.Equal(message.Headers.First().Key, decodedMessage.Headers.First().Key);
+            Assert.Equal(message.Headers.First().Value, decodedMessage.Headers.First().Value);
+            Assert.Equal(message.Headers.Last().Key, decodedMessage.Headers.Last().Key);
+            Assert.Equal(message.Headers.Last().Value, decodedMessage.Headers.Last().Value);
+            Assert.Equal(
+                new String(System.Text.Encoding.UTF8.GetChars(message.Payload)),
+                new String(System.Text.Encoding.UTF8.GetChars(decodedMessage.Payload))
+            );
+        }
+
+        [Fact]
+        public void Should_decode_large_message()
+        {
+            // given
+            var payloadBuffer = new byte[10240];
+            random.NextBytes(payloadBuffer);
+            var headers = Enumerable.Range(0, 48).Select(index => new Header($"Name {index}", $"Value {index}"));
+            var message = new SignalMessage
+            {
+                Headers = new Dictionary<string, string>(headers),
+                Payload = payloadBuffer
+            };
+            var encodedMessage = _encoder.Encode(message);
+
+            // when
+            var decodedMessage = _encoder.Decode(encodedMessage);
+
+            // then
+            Assert.Equal(message.Headers.Count(), decodedMessage.Headers.Count());
+            Assert.NotStrictEqual(message.Headers, decodedMessage.Headers);
+            Assert.Equal(10240, decodedMessage.Payload.Length);
+        }
+    }
+}

Diff for: Sinch.Encoding.Tests/IngerationDecodingSpecs.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Reflection.PortableExecutable;
+using Header = System.Collections.Generic.KeyValuePair<string, string>;
+
+namespace Sinch.Encoding.Tests
+{
+    public class MessageEncodingSpecs
+    {
+        private Random random;
+        private SignalMessageCodec _encoder;
+        public MessageEncodingSpecs()
+        {
+            random = new Random(DateTime.Now.Millisecond);
+            var builder = new ByteBufferBuilder();
+            _encoder = new SignalMessageCodec(builder);
+        }
+
+        [Fact]
+        public void Should_encode_simple_payload_with_headers()
+        {
+            // given
+            var message = new SignalMessage
+            {
+                Headers = new Dictionary<string, string>(new Header[]
+                {
+                    new Header("Alpha", "Beta"),
+                    new Header("Kappa", "Omega")
+                }),
+                Payload = System.Text.Encoding.ASCII.GetBytes("Some Text")
+            };
+
+            // when
+            var encodedMessage = _encoder.Encode(message);
+
+            // then
+            byte[] payloadOffset = new ArraySegment<byte>(encodedMessage, 0, 4).ToArray();
+            int offset = BitConverter.ToInt32(payloadOffset);
+            byte[] headPrefix = new ArraySegment<byte>(encodedMessage, 4, 2).ToArray();
+            short headersCount = BitConverter.ToInt16(headPrefix);
+            int messageLength = encodedMessage.Length - offset;
+            byte[] messageStream = new ArraySegment<byte>(encodedMessage, offset, encodedMessage.Length - offset).ToArray();
+
+            Assert.Equal(42, encodedMessage.Length);
+            Assert.Equal(9, messageLength);
+            Assert.Equal(33, offset);
+            Assert.Equal(2, headersCount);
+            Assert.Equal("Some Text", System.Text.Encoding.Default.GetString(messageStream));
+        }
+
+        [Fact]
+        public void Should_encode_simple_payload_without_headers()
+        {
+            // given
+            var payload = System.Text.Encoding.ASCII.GetBytes("abc");
+            var message = new SignalMessage
+            {
+                Payload = payload
+            };
+
+            // when
+            var encodedMessage = _encoder.Encode(message);
+
+            // then
+            Assert.Equal(sizeof(int) + payload.Length, encodedMessage.Length);
+        }
+
+        [Fact]
+        public void Should_encode_simple_message_without_payload()
+        {
+            // given
+            var message = new SignalMessage
+            {
+                Headers = new Dictionary<string, string>(new Header[]
+                {
+                    new Header("N1", "V1"),
+                    new Header("N2", "V2"),
+                    new Header("N3", "V3")
+                }),
+                Payload = null
+            };
+
+            // when
+            var encodedMessage = _encoder.Encode(message);
+
+            // then
+            int expectedLength = sizeof(int) + sizeof(short) + 3 * (2 * sizeof(short) + 4);
+            Assert.Equal(expectedLength, encodedMessage.Length);
+        }
+
+        [Fact]
+        public void Should_throw_error_when_encoding_empty_message()
+        {
+            // given
+            var emptyMessage = new SignalMessage
+            {
+                Headers = null,
+                Payload = null
+            };
+
+            // when
+            var encodingAction = () => _encoder.Encode(emptyMessage);
+
+            // then
+            Assert.Throws<InvalidDataException>(encodingAction);
+        }
+
+        [Fact]
+        public void Should_throw_error_when_too_long_header_name()
+        {
+            // given
+            var payload = new byte[256];
+            random.NextBytes(payload);
+
+            var veryLongBuffer = new byte[1200];
+            random.NextBytes(veryLongBuffer);
+            var tooLongHeaderName = new String(System.Text.Encoding.ASCII.GetChars(veryLongBuffer));
+
+            var invalidMessage = new SignalMessage
+            {
+                Headers = new Dictionary<string, string>(new Header[]
+                {
+                    new Header(tooLongHeaderName, "value"),
+                    new Header("valid Name", "valid Value")
+                }),
+                Payload = null
+            };
+
+            // when
+            var encodingAction = () => _encoder.Encode(invalidMessage);
+
+            // then
+            Assert.Throws<InvalidDataException>(encodingAction);
+        }
+
+        [Fact]
+        public void Should_throw_error_when_too_many_headers()
+        {
+            // given
+            var tooManyHeaders = Enumerable.Range(0, 100).Select(index => new Header($"Name {index}", $"Value {index}"));
+            var emptyMessage = new SignalMessage
+            {
+                Headers = new Dictionary<string, string>(tooManyHeaders),
+                Payload = null
+            };
+
+            // when
+            var encodingAction = () => _encoder.Encode(emptyMessage);
+
+            // then
+            Assert.Throws<InvalidDataException>(encodingAction);
+        }
+    }
+}