fix: keep unregistered bindings as errors

A binding without a registered parser is dropped from the model and is
lost when the document is written back, so reading it stays an error
with its original message. Adds tests covering a registered and an
unregistered binding read together and re-serialized.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: bielu

src/ByteBard.AsyncAPI.Readers/BindingDeserializer.cs

@@ -40,8 +40,9 @@ internal static AsyncApiBindings<TBinding> LoadBindings<TBinding>(
 
                 if (!parsers.TryGetValue(property.Name, out var parser))
                 {
-                    context.Diagnostic.Warnings.Add(
-                        new AsyncApiError(context.GetLocation(), $"{bindingType} '{property.Name}' was ignored because no binding parser is registered for it."));
+                    // Reported as an error because the binding is dropped from the model and cannot be written back.
+                    context.Diagnostic.Errors.Add(
+                        new AsyncApiError(context.GetLocation(), $"{bindingType} {property.Name} is not found"));
                     continue;
                 }
 

test/ByteBard.AsyncAPI.Tests/Bindings/BindingsDiagnostics_Should.cs

@@ -55,30 +55,58 @@ public void MessageBindings_WithExtension_ReadsExtensionWithoutDiagnostics(Async
 
         [TestCase(AsyncApiVersion.AsyncApi2_0)]
         [TestCase(AsyncApiVersion.AsyncApi3_0)]
-        public void ServerBindings_WithUnregisteredBinding_AddsWarning(AsyncApiVersion version)
+        public void ServerBindings_WithUnregisteredBinding_AddsError(AsyncApiVersion version)
         {
-            AssertUnregisteredBindingWarns<IServerBinding>(version, "ServerBinding");
+            AssertUnregisteredBindingErrors<IServerBinding>(version, "ServerBinding");
         }
 
         [TestCase(AsyncApiVersion.AsyncApi2_0)]
         [TestCase(AsyncApiVersion.AsyncApi3_0)]
-        public void ChannelBindings_WithUnregisteredBinding_AddsWarning(AsyncApiVersion version)
+        public void ChannelBindings_WithUnregisteredBinding_AddsError(AsyncApiVersion version)
         {
-            AssertUnregisteredBindingWarns<IChannelBinding>(version, "ChannelBinding");
+            AssertUnregisteredBindingErrors<IChannelBinding>(version, "ChannelBinding");
         }
 
         [TestCase(AsyncApiVersion.AsyncApi2_0)]
         [TestCase(AsyncApiVersion.AsyncApi3_0)]
-        public void OperationBindings_WithUnregisteredBinding_AddsWarning(AsyncApiVersion version)
+        public void OperationBindings_WithUnregisteredBinding_AddsError(AsyncApiVersion version)
         {
-            AssertUnregisteredBindingWarns<IOperationBinding>(version, "OperationBinding");
+            AssertUnregisteredBindingErrors<IOperationBinding>(version, "OperationBinding");
         }
 
         [TestCase(AsyncApiVersion.AsyncApi2_0)]
         [TestCase(AsyncApiVersion.AsyncApi3_0)]
-        public void MessageBindings_WithUnregisteredBinding_AddsWarning(AsyncApiVersion version)
+        public void MessageBindings_WithUnregisteredBinding_AddsError(AsyncApiVersion version)
         {
-            AssertUnregisteredBindingWarns<IMessageBinding>(version, "MessageBinding");
+            AssertUnregisteredBindingErrors<IMessageBinding>(version, "MessageBinding");
+        }
+
+        [TestCase(AsyncApiVersion.AsyncApi2_0)]
+        [TestCase(AsyncApiVersion.AsyncApi3_0)]
+        public void ServerBindings_WithRegisteredAndUnregisteredBinding_ReserializesOnlyRegisteredBinding(AsyncApiVersion version)
+        {
+            AssertUnregisteredBindingIsNotReserialized<IServerBinding>(version);
+        }
+
+        [TestCase(AsyncApiVersion.AsyncApi2_0)]
+        [TestCase(AsyncApiVersion.AsyncApi3_0)]
+        public void ChannelBindings_WithRegisteredAndUnregisteredBinding_ReserializesOnlyRegisteredBinding(AsyncApiVersion version)
+        {
+            AssertUnregisteredBindingIsNotReserialized<IChannelBinding>(version);
+        }
+
+        [TestCase(AsyncApiVersion.AsyncApi2_0)]
+        [TestCase(AsyncApiVersion.AsyncApi3_0)]
+        public void OperationBindings_WithRegisteredAndUnregisteredBinding_ReserializesOnlyRegisteredBinding(AsyncApiVersion version)
+        {
+            AssertUnregisteredBindingIsNotReserialized<IOperationBinding>(version);
+        }
+
+        [TestCase(AsyncApiVersion.AsyncApi2_0)]
+        [TestCase(AsyncApiVersion.AsyncApi3_0)]
+        public void MessageBindings_WithRegisteredAndUnregisteredBinding_ReserializesOnlyRegisteredBinding(AsyncApiVersion version)
+        {
+            AssertUnregisteredBindingIsNotReserialized<IMessageBinding>(version);
         }
 
         private static AsyncApiBindings<TBinding> Read<TBinding>(string input, AsyncApiVersion version, out AsyncApiDiagnostic diagnostic)
@@ -102,17 +130,33 @@ private static void AssertExtensionIsRead<TBinding>(AsyncApiVersion version)
             bindings.Extensions.Keys.Should().BeEquivalentTo("x-myextension");
         }
 
-        private static void AssertUnregisteredBindingWarns<TBinding>(AsyncApiVersion version, string bindingType)
+        private static void AssertUnregisteredBindingErrors<TBinding>(AsyncApiVersion version, string bindingType)
             where TBinding : IBinding
         {
             // Act
             var bindings = Read<TBinding>(BindingsWithUnknownBinding, version, out var diagnostic);
 
             // Assert
-            diagnostic.Errors.Should().BeEmpty();
-            diagnostic.Warnings.Select(w => w.Message).Should().BeEquivalentTo(
-                $"{bindingType} 'unknown' was ignored because no binding parser is registered for it.");
+            diagnostic.Errors.Select(e => e.Message).Should().BeEquivalentTo($"{bindingType} unknown is not found");
+            diagnostic.Warnings.Should().BeEmpty();
             bindings.Keys.Should().BeEquivalentTo("kafka");
         }
+
+        private static void AssertUnregisteredBindingIsNotReserialized<TBinding>(AsyncApiVersion version)
+            where TBinding : IBinding
+        {
+            // Arrange
+            var bindings = Read<TBinding>(BindingsWithUnknownBinding, version, out var diagnostic);
+
+            // Act
+            var reserialized = bindings.SerializeAsYaml(version);
+
+            // Assert
+            // The model has no way to hold a binding without a parser, so it is lost on write.
+            // That is why reading it must stay an error.
+            diagnostic.Errors.Should().ContainSingle();
+            reserialized.Should().Contain("kafka");
+            reserialized.Should().NotContain("unknown");
+        }
     }
 }