Add tests for server-side validation error extraction

Add comprehensive test coverage for the networking error extraction
logic now in POSOrderService. This logic was previously untested when
it resided in PointOfSaleOrderController.

Test cases cover:
- DotcomError with invalid_variation_id code
- NetworkError with variation_id in data field (detailed error)
- NetworkError without variation_id (generic error)
- AFError wrapping DotcomError (proper unwrapping)
- Unrecognized error codes (pass-through behavior)
- Variation not found in cart (generic fallback)

All tests use properly formatted JSON responses matching real
NetworkError structure with code, message, and optional data fields.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: joshheald

Modules/Sources/PointOfSale/Controllers/PointOfSaleOrderController.swift

@@ -95,16 +95,15 @@ protocol PointOfSaleOrderControllerProtocol {
             return .success(.newOrder)
         } catch {
             self.order = nil
-            trackOrderCreationFailed(error: error, cart: posCart)
-            setOrderStateToError(error, cart: posCart, retryHandler: retryHandler)
+            trackOrderCreationFailed(error: error)
+            setOrderStateToError(error, retryHandler: retryHandler)
             return .failure(SyncOrderStateError.syncFailure)
         }
     }
 
     private func setOrderStateToError(_ error: Error,
-                                      cart: POSCart,
                                       retryHandler: @escaping () async -> Void) {
-        orderState = .error(orderStateError(from: error, cart: cart), {
+        orderState = .error(orderStateError(from: error), {
             Task {
                 await retryHandler()
             }
@@ -189,7 +188,7 @@ private extension PointOfSaleOrderController {
 // MARK: - Error Handling
 
 private extension PointOfSaleOrderController {
-    func orderStateError(from error: Error, cart: POSCart) -> PointOfSaleOrderState.OrderStateError {
+    func orderStateError(from error: Error) -> PointOfSaleOrderState.OrderStateError {
         // Check for missing products error first
         if case .missingProductsInOrder(let missingItems) = error as? POSOrderService.POSOrderServiceError {
             let missingProductInfo = missingItems.map {
@@ -266,7 +265,7 @@ extension PointOfSaleOrderController {
 
 
 private extension PointOfSaleOrderController {
-    func trackOrderCreationFailed(error: Error, cart: POSCart) {
+    func trackOrderCreationFailed(error: Error) {
         var errorType: WooAnalyticsEvent.Orders.OrderCreationErrorType?
 
         if let _ = CouponsError(underlyingError: error) {

Modules/Tests/YosemiteTests/Tools/POS/POSOrderServiceTests.swift

@@ -1,6 +1,10 @@
 import Foundation
 import Testing
 @testable import Yosemite
+import enum Networking.DotcomError
+import enum Networking.NetworkError
+import enum Alamofire.AFError
+import struct Networking.AnyDecodable
 
 struct POSOrderServiceTests {
     let sut: POSOrderService
@@ -341,6 +345,169 @@ struct POSOrderServiceTests {
             return false
         })
     }
+
+    // MARK: - Server-side Validation Error Tests
+
+    @Test func syncOrder_throws_missingProducts_error_for_DotcomError_with_invalid_variation_code() async throws {
+        // Given
+        let cart = POSCart(items: [makePOSCartItem(productID: 100, quantity: 1)])
+        let dotcomError = DotcomError.unknown(code: "order_item_product_invalid_variation_id", message: "Invalid variation")
+        mockOrdersRemote.createPOSOrderResult = .failure(dotcomError)
+
+        // When/Then
+        await #expect(performing: {
+            try await sut.syncOrder(cart: cart, currency: .USD)
+        }, throws: { error in
+            if case .missingProductsInOrder(let missingItems) = error as? POSOrderService.POSOrderServiceError {
+                #expect(missingItems.count == 1)
+                #expect(missingItems.first?.productID == 0) // Generic error
+                #expect(missingItems.first?.variationID == 0)
+                #expect(missingItems.first?.name == "Unknown Product")
+                return true
+            }
+            return false
+        })
+    }
+
+    @Test func syncOrder_throws_missingProducts_error_for_NetworkError_with_invalid_variation_code_and_variation_id() async throws {
+        // Given
+        let cart = POSCart(items: [
+            POSCartItem(
+                item: POSVariation(
+                    id: UUID(),
+                    name: "Large",
+                    formattedPrice: "$20",
+                    price: "20",
+                    productID: 100,
+                    variationID: 500,
+                    parentProductName: "T-Shirt"
+                ),
+                quantity: 1
+            )
+        ])
+
+        let errorJSON = """
+        {
+            "code": "order_item_product_invalid_variation_id",
+            "message": "Invalid variation",
+            "data": {
+                "variation_id": 500
+            }
+        }
+        """
+        let errorData = errorJSON.data(using: .utf8)!
+        let networkError = NetworkError.unacceptableStatusCode(statusCode: 400, response: errorData)
+        mockOrdersRemote.createPOSOrderResult = .failure(networkError)
+
+        // When/Then
+        await #expect(performing: {
+            try await sut.syncOrder(cart: cart, currency: .USD)
+        }, throws: { error in
+            if case .missingProductsInOrder(let missingItems) = error as? POSOrderService.POSOrderServiceError {
+                #expect(missingItems.count == 1)
+                #expect(missingItems.first?.productID == 100)
+                #expect(missingItems.first?.variationID == 500)
+                #expect(missingItems.first?.name == "T-Shirt - Large")
+                return true
+            }
+            return false
+        })
+    }
+
+    @Test func syncOrder_throws_missingProducts_error_for_NetworkError_without_variation_id() async throws {
+        // Given
+        let cart = POSCart(items: [makePOSCartItem(productID: 100, quantity: 1)])
+        let errorJSON = """
+        {
+            "code": "order_item_product_invalid_variation_id",
+            "message": "Invalid variation"
+        }
+        """
+        let errorData = errorJSON.data(using: .utf8)!
+        let networkError = NetworkError.unacceptableStatusCode(statusCode: 400, response: errorData)
+        mockOrdersRemote.createPOSOrderResult = .failure(networkError)
+
+        // When/Then
+        await #expect(performing: {
+            try await sut.syncOrder(cart: cart, currency: .USD)
+        }, throws: { error in
+            if case .missingProductsInOrder(let missingItems) = error as? POSOrderService.POSOrderServiceError {
+                #expect(missingItems.count == 1)
+                #expect(missingItems.first?.productID == 0) // Generic error
+                #expect(missingItems.first?.variationID == 0)
+                return true
+            }
+            return false
+        })
+    }
+
+    @Test func syncOrder_throws_missingProducts_error_for_AFError_wrapping_DotcomError() async throws {
+        // Given
+        let cart = POSCart(items: [makePOSCartItem(productID: 100, quantity: 1)])
+        let dotcomError = DotcomError.unknown(code: "order_item_product_invalid_variation_id", message: "Invalid")
+        let afError = AFError.sessionTaskFailed(error: dotcomError)
+        mockOrdersRemote.createPOSOrderResult = .failure(afError)
+
+        // When/Then
+        await #expect(performing: {
+            try await sut.syncOrder(cart: cart, currency: .USD)
+        }, throws: { error in
+            if case .missingProductsInOrder(let missingItems) = error as? POSOrderService.POSOrderServiceError {
+                #expect(missingItems.count == 1)
+                return true
+            }
+            return false
+        })
+    }
+
+    @Test func syncOrder_throws_original_error_for_unrecognized_DotcomError_code() async throws {
+        // Given
+        let cart = POSCart(items: [makePOSCartItem(productID: 100, quantity: 1)])
+        let dotcomError = DotcomError.unknown(code: "some_other_error_code", message: "Different error")
+        mockOrdersRemote.createPOSOrderResult = .failure(dotcomError)
+
+        // When/Then
+        await #expect(performing: {
+            try await sut.syncOrder(cart: cart, currency: .USD)
+        }, throws: { error in
+            // Should throw the original DotcomError, not missingProductsInOrder
+            if case .unknown = error as? DotcomError {
+                return true
+            }
+            return false
+        })
+    }
+
+    @Test func syncOrder_throws_missingProducts_with_generic_name_when_variation_not_in_cart() async throws {
+        // Given
+        let cart = POSCart(items: [makePOSCartItem(productID: 100, quantity: 1)])
+        let errorJSON = """
+        {
+            "code": "order_item_product_invalid_variation_id",
+            "message": "Invalid variation",
+            "data": {
+                "variation_id": 999
+            }
+        }
+        """
+        let errorData = errorJSON.data(using: .utf8)!
+        let networkError = NetworkError.unacceptableStatusCode(statusCode: 400, response: errorData)
+        mockOrdersRemote.createPOSOrderResult = .failure(networkError)
+
+        // When/Then
+        await #expect(performing: {
+            try await sut.syncOrder(cart: cart, currency: .USD)
+        }, throws: { error in
+            if case .missingProductsInOrder(let missingItems) = error as? POSOrderService.POSOrderServiceError {
+                #expect(missingItems.count == 1)
+                #expect(missingItems.first?.productID == 0)
+                #expect(missingItems.first?.variationID == 999)
+                #expect(missingItems.first?.name == "Unknown Product")
+                return true
+            }
+            return false
+        })
+    }
 }
 
 private func makePOSCartItem(