Merge pull request #1 from dahomey-technologies/AspNetCore

Added Asp.Net core support

Author: Michaël Catanzariti

src/Dahomey.Cbor.AspNetCore.Tests/CborInputFormatterTests.cs

@@ -0,0 +1,92 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.ApiExplorer;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+using Microsoft.AspNetCore.Mvc.ModelBinding.Metadata;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Dahomey.Cbor.AspNetCore.Tests
+{
+    [TestClass]
+    public class CborInputFormatterTests
+    {
+        [TestMethod]
+        public async Task ReadSimpleObject()
+        {
+            const string hexBuffer = "AE67426F6F6C65616EF56553427974650D64427974650C65496E7431360E6655496E7431360F65496E743332106655496E7433321165496E743634126655496E7436341366537472696E6766737472696E676653696E676C65FA41A1AE1466446F75626C65FB40363AE147AE147B684461746554696D6574323031342D30322D32315431393A30303A30305A64456E756D6656616C756531";
+            byte[] buffer = hexBuffer.HexToBytes();
+
+            Mock<HttpRequest> httpRequest = new Mock<HttpRequest>(MockBehavior.Strict);
+            httpRequest.Setup(r => r.ContentType).Returns("application/cbor");
+            httpRequest.Setup(r => r.ContentLength).Returns(buffer.Length);
+            httpRequest.Setup(r => r.Body).Returns(new MemoryStream(buffer));
+
+            Mock<HttpContext> httpContext = new Mock<HttpContext>(MockBehavior.Strict);
+            httpContext.Setup(c => c.Request).Returns(httpRequest.Object);
+
+            Mock<ModelMetadata> modelMetadata = new Mock<ModelMetadata>(
+                MockBehavior.Strict,
+                ModelMetadataIdentity.ForType(typeof(SimpleObject)));
+
+            InputFormatterContext context = new InputFormatterContext(
+                httpContext.Object,
+                nameof(SimpleObject),
+                new ModelStateDictionary(),
+                modelMetadata.Object,
+                (stream, encoding) => new StreamReader(stream, encoding));
+
+            IInputFormatter inputFormatter = new CborInputFormatter(null);
+
+            Assert.IsTrue(inputFormatter.CanRead(context));
+
+            InputFormatterResult result = await inputFormatter.ReadAsync(context);
+
+            Assert.IsFalse(result.HasError);
+            Assert.IsTrue(result.IsModelSet);
+
+            SimpleObject obj = (SimpleObject)result.Model;
+
+            Assert.IsNotNull(obj);
+            Assert.IsTrue(obj.Boolean);
+            Assert.AreEqual(12, obj.Byte);
+            Assert.AreEqual(13, obj.SByte);
+            Assert.AreEqual(14, obj.Int16);
+            Assert.AreEqual(15, obj.UInt16);
+            Assert.AreEqual(16, obj.Int32);
+            Assert.AreEqual(17u, obj.UInt32);
+            Assert.AreEqual(18, obj.Int64);
+            Assert.AreEqual(19ul, obj.UInt64);
+            Assert.AreEqual(20.21f, obj.Single);
+            Assert.AreEqual(22.23, obj.Double);
+            Assert.AreEqual("string", obj.String);
+            Assert.AreEqual(new DateTime(2014, 02, 21, 19, 0, 0, DateTimeKind.Utc), obj.DateTime);
+            Assert.AreEqual(EnumTest.Value1, obj.Enum);
+        }
+
+        [DataTestMethod]
+        [DataRow("application/json", "")]
+        [DataRow("application/cbor", "application/cbor")]
+        public void GetSupportedContentTypes(string actualContentType, string expectedContentType)
+        {
+            IApiRequestFormatMetadataProvider apiRequestFormatMetadataProvider = new CborInputFormatter(null);
+            IReadOnlyList<string> contentTypes
+                = apiRequestFormatMetadataProvider.GetSupportedContentTypes(
+                    actualContentType, typeof(object));
+
+            if (string.IsNullOrEmpty(expectedContentType))
+            {
+                Assert.IsNull(contentTypes);
+            }
+            else
+            {
+                Assert.AreEqual(1, contentTypes.Count);
+                Assert.AreEqual(expectedContentType, contentTypes[0]);
+            }
+        }
+    }
+}

src/Dahomey.Cbor.AspNetCore.Tests/CborOutputFormatterTests.cs

@@ -0,0 +1,72 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using Microsoft.AspNetCore.Mvc.ModelBinding;
+using Microsoft.AspNetCore.Mvc.ModelBinding.Metadata;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Dahomey.Cbor.AspNetCore.Tests
+{
+    [TestClass]
+    public class CborOuputFormatterTests
+    {
+        [TestMethod]
+        public async Task WriteSimpleObject()
+        {
+            SimpleObject obj = new SimpleObject
+            {
+                Boolean = true,
+                Byte = 12,
+                SByte = 13,
+                Int16 = 14,
+                UInt16 = 15,
+                Int32 = 16,
+                UInt32 = 17u,
+                Int64 = 18,
+                UInt64 = 19ul,
+                Single = 20.21f,
+                Double = 22.23,
+                String = "string",
+                DateTime = new DateTime(2014, 02, 21, 19, 0, 0, DateTimeKind.Utc),
+                Enum = EnumTest.Value1
+            };
+
+            const string hexBuffer = "AE67426F6F6C65616EF56553427974650D64427974650C65496E7431360E6655496E7431360F65496E743332106655496E7433321165496E743634126655496E7436341366537472696E6766737472696E676653696E676C65FA41A1AE1466446F75626C65FB40363AE147AE147B684461746554696D6574323031342D30322D32315431393A30303A30305A64456E756D6656616C756531";
+            byte[] buffer = hexBuffer.HexToBytes();
+            MemoryStream body = new MemoryStream(); ;
+
+            Mock<HttpResponse> httpResponse = new Mock<HttpResponse>(MockBehavior.Strict);
+            httpResponse.SetupSet(r => r.ContentType = "application/cbor");
+            httpResponse.Setup(r => r.Body).Returns(body);
+
+            Mock<HttpContext> httpContext = new Mock<HttpContext>(MockBehavior.Strict);
+            httpContext.Setup(c => c.Response).Returns(httpResponse.Object);
+
+            Mock<ModelMetadata> modelMetadata = new Mock<ModelMetadata>(
+                MockBehavior.Strict,
+                ModelMetadataIdentity.ForType(typeof(SimpleObject)));
+
+            OutputFormatterWriteContext context = new OutputFormatterWriteContext(
+                httpContext.Object,
+                (stream, encoding) => new StreamWriter(stream, encoding),
+                typeof(SimpleObject),
+                obj);
+
+            IOutputFormatter outputFormatter = new CborOutputFormatter(
+                new CborOptions
+                {
+                    EnumFormat = ValueFormat.WriteToString
+                });
+
+            Assert.IsTrue(outputFormatter.CanWriteResult(context));
+
+            await outputFormatter.WriteAsync(context);
+
+            string actualHexBuffer = BitConverter.ToString(body.ToArray()).Replace("-", "");
+            Assert.AreEqual(hexBuffer, actualHexBuffer);
+        }
+    }
+}

src/Dahomey.Cbor.AspNetCore.Tests/Dahomey.Cbor.AspNetCore.Tests.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.2</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
+    <PackageReference Include="Moq" Version="4.12.0" />
+    <PackageReference Include="MSTest.TestAdapter" Version="1.3.2" />
+    <PackageReference Include="MSTest.TestFramework" Version="1.3.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Dahomey.Cbor.AspNetCore\Dahomey.Cbor.AspNetCore.csproj" />
+  </ItemGroup>
+
+</Project>

src/Dahomey.Cbor.AspNetCore.Tests/SampleClasses.cs

@@ -0,0 +1,30 @@
+using System;
+
+namespace Dahomey.Cbor.AspNetCore.Tests
+{
+    public enum EnumTest
+    {
+        None = 0,
+        Value1 = 1,
+        Value2 = 2,
+    }
+
+    public class SimpleObject
+    {
+        public bool Boolean { get; set; }
+        public sbyte SByte { get; set; }
+        public byte Byte { get; set; }
+        public ushort Int16 { get; set; }
+        public short UInt16 { get; set; }
+        public int Int32 { get; set; }
+        public uint UInt32 { get; set; }
+        public long Int64 { get; set; }
+        public ulong UInt64 { get; set; }
+        public string String { get; set; }
+        public float Single { get; set; }
+        public double Double { get; set; }
+        public DateTime DateTime { get; set; }
+        public EnumTest Enum { get; set; }
+    }
+
+}

src/Dahomey.Cbor.AspNetCore.Tests/StringExtensions.cs

@@ -0,0 +1,16 @@
+using System.Linq;
+
+namespace System
+{
+    public static class StringExtensions
+    {
+        public static byte[] HexToBytes(this string hexBuffer)
+        {
+            return hexBuffer
+                .Select((c, i) => new { c, i })
+                .GroupBy(a => a.i / 2)
+                .Select(grp => new string(grp.Select(g => g.c).ToArray()))
+                .Select(value => Convert.ToByte(value, 16)).ToArray();
+        }
+    }
+}

src/Dahomey.Cbor.AspNetCore/CborInputFormatter.cs

@@ -0,0 +1,87 @@
+using Dahomey.Cbor.Serialization;
+using Dahomey.Cbor.Serialization.Converters;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using System;
+using System.Buffers;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Dahomey.Cbor.AspNetCore
+{
+    public class CborInputFormatter : InputFormatter
+    {
+        private readonly static Task<InputFormatterResult> failureTask = Task.FromResult(InputFormatterResult.Failure());
+        private readonly static Task<InputFormatterResult> noValueTask = Task.FromResult(InputFormatterResult.NoValue());
+
+        private readonly CborOptions _cborOptions;
+
+        public CborInputFormatter(CborOptions cborOptions)
+        {
+            _cborOptions = cborOptions;
+
+            SupportedMediaTypes.Add("application/cbor");
+        }
+
+        public override Task<InputFormatterResult> ReadRequestBodyAsync(InputFormatterContext context)
+        {
+            try
+            {
+                ValueTask<IMemoryOwner<byte>> task = ReadAsync(context.HttpContext.Request.Body);
+                if (task.IsCompletedSuccessfully)
+                {
+                    using (task.Result)
+                    {
+                        object model = Deserialize(context.ModelType, task.Result.Memory.Span);
+                        return Task.FromResult(InputFormatterResult.Success(model));
+                    }
+                }
+
+                return FinishReadRequestBodyAsync(context.ModelType, task);
+            }
+            catch (Exception ex)
+            {
+                context.ModelState.AddModelError("CBOR", ex.Message);
+                return failureTask;
+            }
+
+            async Task<InputFormatterResult> FinishReadRequestBodyAsync(Type objectType, ValueTask<IMemoryOwner<byte>> task)
+            {
+                await task;
+                using (task.Result)
+                {
+                    object model = Deserialize(objectType, task.Result.Memory.Span);
+                    return InputFormatterResult.Success(model);
+                }
+            }
+        }
+
+        private object Deserialize(Type objectType, ReadOnlySpan<byte> buffer)
+        {
+            CborReader reader = new CborReader(buffer, _cborOptions);
+            ICborConverter cborConverter = CborConverter.Lookup(objectType);
+            return cborConverter.Read(ref reader);
+
+        }
+
+        private async ValueTask<IMemoryOwner<byte>> ReadAsync(Stream stream)
+        {
+            var totalSize = 0;
+            IMemoryOwner<byte> buffer = MemoryPool<byte>.Shared.Rent();
+            int read;
+            while ((read = await stream.ReadAsync(buffer.Memory)) > 0)
+            {
+                if (totalSize + read == buffer.Memory.Length)
+                {
+                    IMemoryOwner<byte> backup = buffer;
+                    buffer = MemoryPool<byte>.Shared.Rent(backup.Memory.Length * 2);
+                    backup.Memory.Span.CopyTo(buffer.Memory.Span);
+                    backup.Dispose();
+                }
+
+                totalSize += read;
+            }
+
+            return buffer;
+        }
+    }
+}

src/Dahomey.Cbor.AspNetCore/CborMvcCoreBuilderExtensions.cs

@@ -0,0 +1,25 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+
+namespace Dahomey.Cbor.AspNetCore
+{
+    public static class CborMvcCoreBuilderExtensions
+    {
+        public static IMvcBuilder AddDahomeyCbor(this IMvcBuilder builder, CborOptions cborOptions = null)
+        {
+            if (builder == null)
+            {
+                throw new ArgumentNullException(nameof(builder));
+            }
+
+            builder.Services.Configure<MvcOptions>(config =>
+            {
+                config.InputFormatters.Add(new CborInputFormatter(cborOptions));
+                config.OutputFormatters.Add(new CborOutputFormatter(cborOptions));
+            });
+
+            return builder;
+        }
+    }
+}

src/Dahomey.Cbor.AspNetCore/CborOutputFormatter.cs

@@ -0,0 +1,32 @@
+using Dahomey.Cbor.Serialization;
+using Dahomey.Cbor.Serialization.Converters;
+using Dahomey.Cbor.Util;
+using Microsoft.AspNetCore.Mvc.Formatters;
+using Microsoft.Net.Http.Headers;
+using System.Threading.Tasks;
+
+namespace Dahomey.Cbor.AspNetCore
+{
+    public class CborOutputFormatter : OutputFormatter
+    {
+        private readonly CborOptions _cborOptions;
+
+        public CborOutputFormatter(CborOptions cborOptions)
+        {
+            _cborOptions = cborOptions;
+
+            SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/cbor"));
+        }
+
+        public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context)
+        {
+            using (ByteBufferWriter bufferWriter = new ByteBufferWriter())
+            {
+                CborWriter writer = new CborWriter(bufferWriter, _cborOptions);
+                ICborConverter cborConverter = CborConverter.Lookup(context.Object.GetType());
+                cborConverter.Write(ref writer, context.Object);
+                return bufferWriter.CopyToAsync(context.HttpContext.Response.Body);
+            }
+        }
+    }
+}