Improve validation and test coverage for orders API

Updated `EmptyStringToNullIntConverter` to throw specific
`JsonException` messages for invalid input, ensuring clearer
error handling. Enhanced `Program.cs` to return custom
422 responses for JSON binding and semantic validation
errors, replacing `ValidationProblemDetails`.

Expanded `ApiE2eTest` with new test cases for edge cases
and invalid input scenarios, including empty, non-integer,
and whitespace values for `quantity` and `country`. Added
parameterized tests and improved assertions for existing
tests to validate all fields and error messages.

Author: valentinajemuovic

monolith/Core/Converters/EmptyStringToNullIntConverter.cs

@@ -23,8 +23,8 @@ public class EmptyStringToNullIntConverter : JsonConverter<int?>
                 return result;
             }
 
-            // Invalid format - return null to trigger validation
-            return null;
+            // Invalid format - throw exception with specific message
+            throw new JsonException("Quantity must be an integer");
         }
 
         if (reader.TokenType == JsonTokenType.Number)
@@ -37,7 +37,7 @@ public class EmptyStringToNullIntConverter : JsonConverter<int?>
             return null;
         }
 
-        throw new JsonException($"Unable to convert to int?");
+        throw new JsonException("Quantity must be an integer");
     }
 
     public override void Write(Utf8JsonWriter writer, int? value, JsonSerializerOptions options)

monolith/Program.cs

@@ -17,27 +17,39 @@
     {
         options.InvalidModelStateResponseFactory = context =>
         {
-            // Check if this is a JSON binding error by examining ModelState keys
-            // JSON binding errors have keys that start with "$" (e.g., "$.quantity")
-            var hasJsonBindingError = context.ModelState.Keys.Any(key => key.StartsWith("$"));
-            
-            if (hasJsonBindingError)
+            // Check for JSON binding errors (e.g., from JsonConverter throwing JsonException)
+            var jsonBindingErrors = context.ModelState
+                .Where(kvp => kvp.Key.StartsWith("$"))
+                .SelectMany(kvp => kvp.Value?.Errors ?? new Microsoft.AspNetCore.Mvc.ModelBinding.ModelErrorCollection())
+                .ToList();
+
+            if (jsonBindingErrors.Any())
             {
-                // Return 400 for JSON binding errors (type conversion failures)
-                var problemDetails = new Microsoft.AspNetCore.Mvc.ValidationProblemDetails(context.ModelState)
-                {
-                    Status = 400
-                };
-                return new Microsoft.AspNetCore.Mvc.BadRequestObjectResult(problemDetails);
+                // Extract the error message from the first JSON binding error
+                var firstError = jsonBindingErrors.First();
+                var errorMessage = firstError.Exception?.Message ?? firstError.ErrorMessage;
+                
+                // Return 422 with the custom error message
+                context.HttpContext.Response.StatusCode = 422;
+                context.HttpContext.Response.ContentType = "application/json";
+                var response = new { message = errorMessage };
+                return new Microsoft.AspNetCore.Mvc.JsonResult(response);
             }
             else
             {
                 // Return 422 for semantic validation errors (Required, Range, etc.)
-                var problemDetails = new Microsoft.AspNetCore.Mvc.ValidationProblemDetails(context.ModelState)
-                {
-                    Status = 422
-                };
-                return new Microsoft.AspNetCore.Mvc.UnprocessableEntityObjectResult(problemDetails);
+                var errors = context.ModelState
+                    .Where(x => x.Value?.Errors.Count > 0)
+                    .SelectMany(x => x.Value!.Errors)
+                    .Select(x => x.ErrorMessage)
+                    .ToList();
+
+                var errorMessage = string.Join("; ", errors);
+                
+                context.HttpContext.Response.StatusCode = 422;
+                context.HttpContext.Response.ContentType = "application/json";
+                var response = new { message = errorMessage };
+                return new Microsoft.AspNetCore.Mvc.JsonResult(response);
             }
         };
     });

system-test/E2eTests/ApiE2eTest.cs

@@ -46,11 +46,11 @@ public async Task PlaceOrder_WithValidRequest_ShouldReturnCreated()
     [Fact]
     public async Task GetOrder_WithExistingOrder_ShouldReturnOrder()
     {
-        // Arrange
+        // Arrange - Set up product in ERP first
         var baseSku = "AUTO-GO-200";
-        var unitPrice = 125.50m;
-        var quantity = 2;
-        var country = "US";
+        var unitPrice = 299.50m;
+        var quantity = 3;
+        var country = "DE";
 
         var sku = await _erpApiClient.Products().CreateProductAsync(baseSku, unitPrice);
 
@@ -59,14 +59,21 @@ public async Task GetOrder_WithExistingOrder_ShouldReturnOrder()
         // Act
         var httpResponse = await _shopApiClient.Orders().ViewOrderAsync(orderNumber);
 
-        // Assert
+        // Assert - Assert all fields from GetOrderResponse
         var order = await _shopApiClient.Orders().AssertOrderViewedSuccessfullyAsync(httpResponse);
+        Assert.NotNull(order.OrderNumber);
         Assert.Equal(orderNumber, order.OrderNumber);
         Assert.Equal(sku, order.Sku);
         Assert.Equal(quantity, order.Quantity);
         Assert.Equal(country, order.Country);
+        
+        // Assert with concrete values based on known input
         Assert.Equal(unitPrice, order.UnitPrice);
-        Assert.Equal(251.00m, order.OriginalPrice);
+        
+        var expectedOriginalPrice = 898.50m;
+        Assert.Equal(expectedOriginalPrice, order.OriginalPrice);
+        
+        Assert.NotNull(order.Status);
         Assert.Equal(OrderStatus.PLACED, order.Status);
     }
 
@@ -157,6 +164,23 @@ public async Task PlaceOrder_WithInvalidRequest_ShouldReturnBadRequest(
         Assert.Contains(expectedError, errorMessage);
     }
 
+    [Fact]
+    public async Task PlaceOrder_WithNonExistentSku_ShouldReturnUnprocessableEntity()
+    {
+        // Arrange
+        var sku = "NON-EXISTENT-SKU-12345";
+        var quantity = "5";
+        var country = "US";
+
+        // Act
+        var httpResponse = await _shopApiClient.Orders().PlaceOrderAsync(sku, quantity, country);
+
+        // Assert
+        _shopApiClient.Orders().AssertOrderPlacementFailed(httpResponse);
+        var errorMessage = await _shopApiClient.Orders().GetErrorMessageAsync(httpResponse);
+        Assert.Contains("Product does not exist for SKU", errorMessage);
+    }
+
     [Theory]
     [MemberData(nameof(GetInvalidQuantityTestData))]
     public async Task PlaceOrder_WithInvalidQuantityType_ShouldReturnBadRequest(
@@ -180,6 +204,86 @@ public static IEnumerable<object[]> GetInvalidQuantityTestData()
         yield return new object[] { null!, "Quantity must not be empty" };
     }
 
+    [Theory]
+    [MemberData(nameof(GetEmptyQuantityTestData))]
+    public async Task PlaceOrder_WithEmptyQuantity_ShouldReturnBadRequest(
+        string? quantityValue, string expectedError)
+    {
+        // Arrange - Set up product in ERP first
+        var baseSku = "AUTO-EQ-500";
+        var unitPrice = 150.00m;
+
+        var sku = await _erpApiClient.Products().CreateProductAsync(baseSku, unitPrice);
+
+        // Act
+        var httpResponse = await _shopApiClient.Orders().PlaceOrderAsync(sku, quantityValue ?? "", "US");
+
+        // Assert
+        _shopApiClient.Orders().AssertOrderPlacementFailed(httpResponse);
+        var errorMessage = await _shopApiClient.Orders().GetErrorMessageAsync(httpResponse);
+        Assert.Contains(expectedError, errorMessage);
+    }
+
+    public static IEnumerable<object[]> GetEmptyQuantityTestData()
+    {
+        yield return new object?[] { null, "Quantity must not be empty" };
+        yield return new object[] { "", "Quantity must not be empty" };
+        yield return new object[] { "   ", "Quantity must not be empty" };
+    }
+
+    [Theory]
+    [MemberData(nameof(GetNonIntegerQuantityTestData))]
+    public async Task PlaceOrder_WithNonIntegerQuantity_ShouldReturnBadRequest(
+        string quantityValue, string expectedError)
+    {
+        // Arrange - Set up product in ERP first
+        var baseSku = "AUTO-NIQ-600";
+        var unitPrice = 175.00m;
+
+        var sku = await _erpApiClient.Products().CreateProductAsync(baseSku, unitPrice);
+
+        // Act
+        var httpResponse = await _shopApiClient.Orders().PlaceOrderAsync(sku, quantityValue, "US");
+
+        // Assert
+        _shopApiClient.Orders().AssertOrderPlacementFailed(httpResponse);
+        var errorMessage = await _shopApiClient.Orders().GetErrorMessageAsync(httpResponse);
+        Assert.Contains(expectedError, errorMessage);
+    }
+
+    public static IEnumerable<object[]> GetNonIntegerQuantityTestData()
+    {
+        yield return new object[] { "3.5", "Quantity must be an integer" };
+        yield return new object[] { "lala", "Quantity must be an integer" };
+    }
+
+    [Theory]
+    [MemberData(nameof(GetEmptyCountryTestData))]
+    public async Task PlaceOrder_WithEmptyCountry_ShouldReturnBadRequest(
+        string? countryValue, string expectedError)
+    {
+        // Arrange - Set up product in ERP first and get unique SKU
+        var baseSku = "AUTO-EC-700";
+        var unitPrice = 225.00m;
+
+        var sku = await _erpApiClient.Products().CreateProductAsync(baseSku, unitPrice);
+
+        // Act
+        var httpResponse = await _shopApiClient.Orders().PlaceOrderAsync(sku, "5", countryValue ?? "");
+
+        // Assert
+        _shopApiClient.Orders().AssertOrderPlacementFailed(httpResponse);
+        var errorMessage = await _shopApiClient.Orders().GetErrorMessageAsync(httpResponse);
+        Assert.Contains(expectedError, errorMessage);
+    }
+
+    public static IEnumerable<object[]> GetEmptyCountryTestData()
+    {
+        yield return new object?[] { null, "Country must not be empty" };
+        yield return new object[] { "", "Country must not be empty" };
+        yield return new object[] { "   ", "Country must not be empty" };
+    }
+
     [Fact]
     public async Task PlaceOrder_WithMissingFields_ShouldReturnBadRequest()
     {