Create POSOrderMapperTests

Author: staskus

Modules/Sources/Yosemite/PointOfSale/OrderList/POSOrderMapper.swift

@@ -26,6 +26,13 @@ struct POSOrderMapper {
             return currencyFormatter.formatAmount(order.discountTotal, with: order.currency, isNegative: true) ?? ""
         }()
 
+        let formattedNetAmount: String? = {
+            guard !order.refunds.isEmpty else {
+                return nil
+            }
+            return order.netAmount(currencyFormatter: currencyFormatter)
+        }()
+
         return POSOrder(
             id: order.orderID,
             number: order.number,
@@ -41,7 +48,7 @@ struct POSOrderMapper {
             formattedTotalTax: currencyFormatter.formatAmount(order.totalTax, with: order.currency) ?? "",
             formattedDiscountTotal: formattedDiscountTotal,
             formattedPaymentTotal: order.paymentTotal(currencyFormatter: currencyFormatter),
-            formattedNetAmount: order.netAmount(currencyFormatter: currencyFormatter)
+            formattedNetAmount: formattedNetAmount
         )
     }
 

Modules/Tests/YosemiteTests/PointOfSale/POSOrderMapperTests.swift

@@ -0,0 +1,211 @@
+import Foundation
+import Testing
+import WooFoundation
+import NetworkingCore
+@testable import Yosemite
+
+struct POSOrderMapperTests {
+    private let currencyFormatter: CurrencyFormatter
+    private let sut: POSOrderMapper
+
+    init() {
+        currencyFormatter = CurrencyFormatter(currencySettings: CurrencySettings())
+        sut = POSOrderMapper(currencyFormatter: currencyFormatter)
+    }
+
+    // MARK: - formattedDiscountTotal Logic Tests
+
+    @Test
+    func formattedDiscountTotal_returns_nil_when_discount_total_is_zero() {
+        // Given
+        let order = makeOrder(discountTotal: "0.00")
+
+        // When
+        let result = sut.map(order: order)
+
+        // Then
+        #expect(result.formattedDiscountTotal == nil)
+    }
+
+    @Test
+    func formattedDiscountTotal_returns_nil_when_discount_total_is_negative() {
+        // Given
+        let order = makeOrder(discountTotal: "-5.00")
+
+        // When
+        let result = sut.map(order: order)
+
+        // Then
+        #expect(result.formattedDiscountTotal == nil)
+    }
+
+    @Test
+    func formattedDiscountTotal_returns_nil_when_discount_total_is_invalid() {
+        // Given
+        let order = makeOrder(discountTotal: "invalid")
+
+        // When
+        let result = sut.map(order: order)
+
+        // Then
+        #expect(result.formattedDiscountTotal == nil)
+    }
+
+    @Test
+    func formattedDiscountTotal_returns_formatted_negative_value_when_discount_total_is_positive() {
+        // Given
+        let order = makeOrder(discountTotal: "15.50", currency: "USD")
+
+        // When
+        let result = sut.map(order: order)
+
+        // Then
+        #expect(result.formattedDiscountTotal == "-$15.50")
+    }
+
+    // MARK: - formattedPaymentTotal Logic Tests
+
+    @Test
+    func formattedPaymentTotal_returns_zero_when_order_is_not_paid() {
+        // Given
+        let order = makeOrder(total: "25.99", datePaid: nil, currency: "USD")
+
+        // When
+        let result = sut.map(order: order)
+
+        // Then
+        #expect(result.formattedPaymentTotal == "$0.00")
+    }
+
+    @Test
+    func formattedPaymentTotal_returns_total_value_when_order_is_paid() {
+        // Given
+        let order = makeOrder(total: "25.99", datePaid: Date(), currency: "USD")
+
+        // When
+        let result = sut.map(order: order)
+
+        // Then
+        #expect(result.formattedPaymentTotal == "$25.99")
+    }
+
+    // MARK: - formattedNetAmount Logic Tests
+
+    @Test
+    func formattedNetAmount_returns_nil_when_no_refunds_exist() {
+        // Given
+        let order = makeOrder(total: "25.99", currency: "USD", refunds: [])
+
+        // When
+        let result = sut.map(order: order)
+
+        // Then
+        #expect(result.formattedNetAmount == nil)
+    }
+
+    @Test
+    func formattedNetAmount_returns_calculated_net_amount_when_refunds_exist() {
+        // Given
+        let refund = makeRefund(refundID: 1, total: "-10.00")
+        let order = makeOrder(total: "25.99", currency: "USD", refunds: [refund])
+
+        // When
+        let result = sut.map(order: order)
+
+        // Then
+        #expect(result.formattedNetAmount == "$15.99")
+    }
+
+    @Test
+    func formattedNetAmount_returns_zero_when_refund_equals_total() {
+        // Given
+        let refund = makeRefund(refundID: 1, total: "-25.99")
+        let order = makeOrder(total: "25.99", currency: "USD", refunds: [refund])
+
+        // When
+        let result = sut.map(order: order)
+
+        // Then
+        #expect(result.formattedNetAmount == "$0.00")
+    }
+
+    @Test
+    func formattedNetAmount_handles_multiple_refunds() {
+        // Given
+        let refund1 = makeRefund(refundID: 1, total: "-10.00")
+        let refund2 = makeRefund(refundID: 2, total: "-5.00")
+        let order = makeOrder(total: "25.99", currency: "USD", refunds: [refund1, refund2])
+
+        // When
+        let result = sut.map(order: order)
+
+        // Then
+        #expect(result.formattedNetAmount == "$10.99")
+    }
+}
+
+// MARK: - Test Helpers
+
+private extension POSOrderMapperTests {
+    func makeOrder(
+        orderID: Int64 = 1,
+        number: String = "1001",
+        dateCreated: Date = Date(),
+        status: OrderStatusEnum = .completed,
+        total: String = "25.99",
+        datePaid: Date? = nil,
+        discountTotal: String = "0.00",
+        totalTax: String = "2.50",
+        currency: String = "USD",
+        refunds: [OrderRefundCondensed] = [],
+        items: [OrderItem] = []
+    ) -> NetworkingCore.Order {
+        return NetworkingCore.Order.fake().copy(
+            orderID: orderID,
+            number: number,
+            status: status,
+            currency: currency,
+            dateCreated: dateCreated,
+            datePaid: datePaid,
+            discountTotal: discountTotal,
+            total: total,
+            totalTax: totalTax,
+            items: items.isEmpty ? [makeOrderItem()] : items,
+            refunds: refunds
+        )
+    }
+
+    func makeOrderItem(
+        itemID: Int64 = 1,
+        name: String = "Test Item",
+        productID: Int64 = 101,
+        variationID: Int64 = 0,
+        quantity: Decimal = 1.0,
+        price: NSDecimalNumber = NSDecimalNumber(string: "10.00"),
+        subtotal: String = "10.00",
+        total: String = "10.00"
+    ) -> NetworkingCore.OrderItem {
+        return NetworkingCore.OrderItem.fake().copy(
+            itemID: itemID,
+            name: name,
+            productID: productID,
+            variationID: variationID,
+            quantity: quantity,
+            price: price,
+            subtotal: subtotal,
+            total: total
+        )
+    }
+
+    func makeRefund(
+        refundID: Int64,
+        total: String,
+        reason: String? = nil
+    ) -> NetworkingCore.OrderRefundCondensed {
+        return NetworkingCore.OrderRefundCondensed(
+            refundID: refundID,
+            reason: reason,
+            total: total
+        )
+    }
+}