feat: check the response properties are valid

Author: tidusjar

src/Wiremock.OpenAPIValidator.Tests/Queries/PropertyRequiredQueryHandlerTests.cs

@@ -0,0 +1,155 @@
+using Microsoft.OpenApi.Models;
+using Wiremock.OpenAPIValidator.Models;
+using Wiremock.OpenAPIValidator.Queries;
+
+namespace Wiremock.OpenAPIValidator.Tests.Queries;
+
+public class PropertyRequiredQueryHandlerTests
+{
+
+    private PropertyRequiredQueryHandler _handler;
+
+    [SetUp]
+    public void Setup()
+    {
+        _handler = new PropertyRequiredQueryHandler();
+    }
+
+    [Test]
+    public async Task Handle_ValidMatchingRequiredProperties()
+    {
+        var wiremockProps = new WiremockResponseProperties();
+        wiremockProps.Properties.Add("Prop1", typeof(string));
+
+        OpenApiResponses apiResponse = RequiredOpenApiSchema();
+
+        var response = await _handler.Handle(new PropertyRequiredQuery
+        {
+            Responses = apiResponse,
+            MockProperties = wiremockProps,
+            Name = "UnitTest"
+        }, CancellationToken.None);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(response.Count, Is.EqualTo(1));
+            Assert.That(response[0].Type, Is.EqualTo(ValidatorType.ResponsePropertyRequired));
+            Assert.That(response[0].Name, Is.EqualTo("UnitTest - prop1"));
+            Assert.That(response[0].ValidationResult, Is.EqualTo(ValidationResult.Passed));
+            Assert.That(response[0].Description, Is.Null.Or.Empty);
+        });
+    }
+
+    [Test]
+    public async Task Handle_MissingRequiredProperties()
+    {
+        var wiremockProps = new WiremockResponseProperties();
+        wiremockProps.Properties.Add("Prop2", typeof(string));
+
+        OpenApiResponses apiResponse = RequiredOpenApiSchema();
+
+        var response = await _handler.Handle(new PropertyRequiredQuery
+        {
+            Responses = apiResponse,
+            MockProperties = wiremockProps,
+            Name = "UnitTest"
+        }, CancellationToken.None);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(response.Count, Is.EqualTo(1));
+            Assert.That(response[0].Type, Is.EqualTo(ValidatorType.ResponsePropertyRequired));
+            Assert.That(response[0].Name, Is.EqualTo("UnitTest - prop1"));
+            Assert.That(response[0].ValidationResult, Is.EqualTo(ValidationResult.Failed));
+            Assert.That(response[0].Description, Is.Not.Null.And.Contains("prop1"));
+        });
+    }
+
+    [Test]
+    public async Task Handle_MissingOptionalProperties()
+    {
+        var wiremockProps = new WiremockResponseProperties();
+        wiremockProps.Properties.Add("Prop2", typeof(string));
+
+        OpenApiResponses apiResponse = RequiredOpenApiSchema();
+        apiResponse["200"].Content["application/json"].Schema.Required = new HashSet<string>();
+
+        var response = await _handler.Handle(new PropertyRequiredQuery
+        {
+            Responses = apiResponse,
+            MockProperties = wiremockProps,
+            Name = "UnitTest"
+        }, CancellationToken.None);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(response.Count, Is.EqualTo(1));
+            Assert.That(response[0].Type, Is.EqualTo(ValidatorType.ResponsePropertyRequired));
+            Assert.That(response[0].Name, Is.EqualTo("UnitTest - prop1"));
+            Assert.That(response[0].ValidationResult, Is.EqualTo(ValidationResult.Warning));
+            Assert.That(response[0].Description, Is.Not.Null.And.Contains("prop1"));
+        });
+    }
+
+
+    [Test]
+    public async Task Handle_MultipleMissingOptionalAndRequiredProperties()
+    {
+        var wiremockProps = new WiremockResponseProperties();
+        wiremockProps.Properties.Add("Prop1", typeof(string));
+        wiremockProps.Properties.Add("Prop4", typeof(string));
+
+        OpenApiResponses apiResponse = RequiredOpenApiSchema();
+        apiResponse["200"].Content["application/json"].Schema.Required.Add("Prop2");
+        apiResponse["200"].Content["application/json"].Schema.Properties.Add("Prop2", new OpenApiSchema());
+        apiResponse["200"].Content["application/json"].Schema.Properties.Add("Prop3", new OpenApiSchema());
+
+        var response = await _handler.Handle(new PropertyRequiredQuery
+        {
+            Responses = apiResponse,
+            MockProperties = wiremockProps,
+            Name = "UnitTest"
+        }, CancellationToken.None);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(response.Count, Is.EqualTo(3));
+            Assert.That(response[0].Type, Is.EqualTo(ValidatorType.ResponsePropertyRequired));
+            Assert.That(response[0].Name, Is.EqualTo("UnitTest - prop1"));
+            Assert.That(response[0].ValidationResult, Is.EqualTo(ValidationResult.Passed));
+            Assert.That(response[0].Description, Is.Null.Or.Empty);
+            Assert.That(response[1].Type, Is.EqualTo(ValidatorType.ResponsePropertyRequired));
+            Assert.That(response[1].Name, Is.EqualTo("UnitTest - Prop2"));
+            Assert.That(response[1].ValidationResult, Is.EqualTo(ValidationResult.Failed));
+            Assert.That(response[1].Description, Is.Not.Null.And.Contains("Prop2"));
+            Assert.That(response[2].Type, Is.EqualTo(ValidatorType.ResponsePropertyRequired));
+            Assert.That(response[2].Name, Is.EqualTo("UnitTest - Prop3"));
+            Assert.That(response[2].ValidationResult, Is.EqualTo(ValidationResult.Warning));
+            Assert.That(response[2].Description, Is.Not.Null.And.Contains("Prop3"));
+        });
+    }
+
+    private static OpenApiResponses RequiredOpenApiSchema()
+    {
+        return new OpenApiResponses
+        {
+            {"200", new OpenApiResponse
+            {
+                Content = new Dictionary<string, OpenApiMediaType>
+                {
+                    { "application/json", new OpenApiMediaType
+                    {
+                        Schema = new OpenApiSchema
+                        {
+                            Required = new HashSet<string> { "prop1" },
+                            Properties = new Dictionary<string, OpenApiSchema>
+                            {
+                                {"prop1", new OpenApiSchema() }
+                            }
+                        }
+                    } }
+                }
+            } }
+        };
+    }
+}

src/Wiremock.OpenAPIValidator.Tests/ValidationServiceTests.cs

@@ -9,6 +9,7 @@
 using System.Text.Json;
 using System.Threading.Tasks;
 using Wiremock.OpenAPIValidator.Commands;
+using Wiremock.OpenAPIValidator.Models;
 using Wiremock.OpenAPIValidator.Queries;
 
 namespace Wiremock.OpenAPIValidator.Tests
@@ -49,6 +50,10 @@ public async Task SuccessfulValidation()
                     {
                         UrlPattern = "abc",
                         QueryParameters = doc.RootElement
+                    },
+                    Response = new WiremockResponse
+                    {
+                        FileName = "Test"
                     }
                 });
 
@@ -61,7 +66,15 @@ public async Task SuccessfulValidation()
                     } } }
                 }));
 
+            _mocker.Setup<IMediator, Task<WiremockResponseProperties>>(x => x.Send(It.IsAny<WiremockResponseReaderCommand>(), It.IsAny<CancellationToken>()))
+               .ReturnsAsync(new WiremockResponseProperties());
+
+            _mocker.Setup<IMediator, Task<List<ValidatorNode>>>(x => x.Send(It.IsAny<PropertyRequiredQuery>(), It.IsAny<CancellationToken>()))
+               .ReturnsAsync(new List<ValidatorNode>());
+
             var result = await _service.ValidateAsync("test1", "test2");
+
+            Assert.That(result, Is.Not.Null);
         }
     }
 }

src/Wiremock.OpenAPIValidator/Queries/PropertyRequiredQueryHandler.cs

@@ -1,6 +1,5 @@
 using MediatR;
 using Microsoft.OpenApi.Models;
-using System.Text.Json;
 using Wiremock.OpenAPIValidator.Models;
 
 namespace Wiremock.OpenAPIValidator.Queries;
@@ -46,14 +45,15 @@ public Task<List<ValidatorNode>> Handle(PropertyRequiredQuery request, Cancellat
                     ValidationResult = ValidationResult.Warning
                 });
             }
-
-            response.Add(new ValidatorNode
+            else
             {
-                Name = GetName(request.Name, property.Key),
-                Type = ValidatorType.ResponsePropertyRequired,
-                ValidationResult = ValidationResult.Passed
-            });
-
+                response.Add(new ValidatorNode
+                {
+                    Name = GetName(request.Name, property.Key),
+                    Type = ValidatorType.ResponsePropertyRequired,
+                    ValidationResult = ValidationResult.Passed
+                });
+            }
         }
         return Task.FromResult(response);
     }