feat(bindings): add websockets binding (#69)

Author: VisualBean

src/LEGO.AsyncAPI.Readers/AsyncApiBindingDeserializer.cs

@@ -14,6 +14,7 @@ internal static partial class AsyncApiDeserializer
         private static Type operationBindingType = typeof(IOperationBinding);
         private static Type channelBindingType = typeof(IChannelBinding);
         private static Type serverBindingType = typeof(IServerBinding);
+
         private static PatternFieldMap<T> BindingPatternExtensionFields<T>()
     where T : IBinding, new()
         {

src/LEGO.AsyncAPI.Readers/AsyncApiChannelBindingDeserializer.cs

@@ -44,6 +44,8 @@ internal static IChannelBinding LoadChannelBinding(ParseNode node)
                     return LoadBinding("ChannelBinding", property.Value, kafkaChannelBindingFixedFields);
                 case BindingType.Pulsar:
                     return LoadBinding("ChannelBinding", property.Value, pulsarChannelBindingFixedFields);
+                case BindingType.Websockets:
+                    return LoadBinding("ChannelBinding", property.Value, webSocketsChannelBindingFixedFields);
                 default:
                     throw new System.Exception("ChannelBinding not found");
             }

src/LEGO.AsyncAPI.Readers/Bindings/AsyncApiWebSocketsBindingsDeserializer.cs

@@ -0,0 +1,19 @@
+// Copyright (c) The LEGO Group. All rights reserved.
+
+namespace LEGO.AsyncAPI.Readers
+{
+    using LEGO.AsyncAPI.Models.Bindings.Http;
+    using LEGO.AsyncAPI.Readers.ParseNodes;
+    using Models.Bindings.WebSockets;
+
+    internal static partial class AsyncApiDeserializer
+    {
+        private static FixedFieldMap<WebSocketsChannelBinding> webSocketsChannelBindingFixedFields = new()
+        {
+            { "bindingVersion", (a, n) => { a.BindingVersion = n.GetScalarValue(); } },
+            { "method", (a, n) => { a.Method = n.GetScalarValue(); } },
+            { "query", (a, n) => { a.Query = LoadSchema(n); } },
+            { "headers", (a, n) => { a.Headers = LoadSchema(n); } },
+        };
+    }
+}

src/LEGO.AsyncAPI/Models/Bindings/BindingType.cs

@@ -12,6 +12,9 @@ public enum BindingType
         [Display("http")]
         Http,
 
+        [Display("websockets")]
+        Websockets,
+
         [Display("pulsar")]
         Pulsar,
     }

src/LEGO.AsyncAPI/Models/Bindings/WebSockets/WebSocketsChannelBinding.cs

@@ -0,0 +1,71 @@
+// Copyright (c) The LEGO Group. All rights reserved.
+
+namespace LEGO.AsyncAPI.Models.Bindings.WebSockets
+{
+    using System;
+    using System.Collections.Generic;
+    using LEGO.AsyncAPI.Models.Interfaces;
+    using LEGO.AsyncAPI.Writers;
+
+    public class WebSocketsChannelBinding : IChannelBinding
+    {
+        /// <summary>
+        /// The HTTP method t use when establishing the connection. Its value MUST be either 'GET' or 'POST'.
+        /// </summary>
+        public string Method { get; set; }
+
+        /// <summary>
+        /// A Schema object containing the definitions for each query parameter. This schema MUST be of type 'object' and have a 'properties' key.
+        /// </summary>
+        public AsyncApiSchema Query { get; set; }
+
+        /// <summary>
+        /// A Schema object containing the definitions of the HTTP headers to use when establishing the connection. This schma MUST be of type 'object' and have a 'properties' key.
+        /// </summary>
+        public AsyncApiSchema Headers { get; set; }
+
+        public string BindingVersion { get; set; }
+
+        public bool UnresolvedReference { get; set; }
+
+        public AsyncApiReference Reference { get; set; }
+
+        public IDictionary<string, IAsyncApiExtension> Extensions { get; set; } =
+            new Dictionary<string, IAsyncApiExtension>();
+
+        public BindingType Type => BindingType.Websockets;
+
+        public void SerializeV2WithoutReference(IAsyncApiWriter writer)
+        {
+            if (writer is null)
+            {
+                throw new ArgumentNullException(nameof(writer));
+            }
+
+            writer.WriteStartObject();
+
+            writer.WriteOptionalProperty(AsyncApiConstants.Method, this.Method);
+            writer.WriteOptionalObject(AsyncApiConstants.Query, this.Query, (w, h) => h.SerializeV2(w));
+            writer.WriteOptionalObject(AsyncApiConstants.Headers, this.Headers, (w, h) => h.SerializeV2(w));
+            writer.WriteOptionalProperty(AsyncApiConstants.BindingVersion, this.BindingVersion);
+
+            writer.WriteEndObject();
+        }
+
+        public void SerializeV2(IAsyncApiWriter writer)
+        {
+            if (writer is null)
+            {
+                throw new ArgumentNullException(nameof(writer));
+            }
+
+            if (this.Reference != null && writer.GetSettings().ReferenceInline != ReferenceInlineSetting.InlineReferences)
+            {
+                this.Reference.SerializeV2(writer);
+                return;
+            }
+
+            this.SerializeV2WithoutReference(writer);
+        }
+    }
+}

test/LEGO.AsyncAPI.Tests/Models/AsyncApiChannel_Should.cs

@@ -1,14 +1,79 @@
-using LEGO.AsyncAPI.Models;
-using LEGO.AsyncAPI.Models.Bindings.Kafka;
-using LEGO.AsyncAPI.Models.Interfaces;
-using NUnit.Framework;
-
-namespace LEGO.AsyncAPI.Tests.Models
+namespace LEGO.AsyncAPI.Tests.Models
 {
+    using System.Collections.Generic;
+    using LEGO.AsyncAPI.Models;
+    using LEGO.AsyncAPI.Models.Bindings.Kafka;
+    using LEGO.AsyncAPI.Models.Bindings.WebSockets;
+    using LEGO.AsyncAPI.Models.Interfaces;
+    using NUnit.Framework;
+
     internal class AsyncApiChannel_Should
     {
         [Test]
-        public void AsyncApiChannel_WithBindings_Serializes()
+        public void AsyncApiChannel_WithWebSocketsBinding_Serializes()
+        {
+            var expected = @"bindings:
+  websockets:
+    method: POST
+    query:
+      properties:
+        index:
+          description: the index
+    headers:
+      properties:
+        x-correlation-id:
+          description: the correlationid
+    bindingVersion: 0.1.0";
+
+            var channel = new AsyncApiChannel
+            {
+                Bindings = new AsyncApiBindings<IChannelBinding>
+                {
+                    {
+                        new WebSocketsChannelBinding()
+                        {
+                            Method = "POST",
+                            Query = new AsyncApiSchema()
+                            {
+                                Properties = new Dictionary<string, AsyncApiSchema>()
+                                {
+                                    {
+                                        "index", new AsyncApiSchema()
+                                        {
+                                            Description = "the index",
+                                        }
+                                    },
+                                },
+                            },
+                            Headers = new AsyncApiSchema()
+                            {
+                                Properties = new Dictionary<string, AsyncApiSchema>()
+                                {
+                                    {
+                                        "x-correlation-id", new AsyncApiSchema()
+                                        {
+                                            Description = "the correlationid",
+                                        }
+                                    },
+                                },
+                            },
+                            BindingVersion = "0.1.0",
+                        }
+                    },
+                },
+            };
+
+            var actual = channel.SerializeAsYaml();
+
+            actual = actual.MakeLineBreaksEnvironmentNeutral();
+            expected = expected.MakeLineBreaksEnvironmentNeutral();
+
+            // Assert
+            Assert.AreEqual(actual, expected);
+        }
+
+        [Test]
+        public void AsyncApiChannel_WithKafkaBinding_Serializes()
         {
             var expected =
 @"bindings: