Merge pull request #2131 from woocommerce/issue/1409-currency-formatter-tests-currency-settings

Fix test cases in `CurrencyFormatterTests` from locale, singleton usage, and negative value with RTL

Author: jaclync

WooCommerce/Classes/Tools/Currency/CurrencyFormatter.swift

@@ -14,12 +14,13 @@ public class CurrencyFormatter {
     /// Returns a decimal value from a given string.
     /// - Parameters:
     ///   - stringValue: the string received from the API
+    ///   - locale: the locale that the currency string is based on.
     ///
-    func convertToDecimal(from stringValue: String) -> NSDecimalNumber? {
+    func convertToDecimal(from stringValue: String, locale: Locale = .current) -> NSDecimalNumber? {
 
         // NSDecimalNumber use by default the local decimal separator to evaluate a decimal amount.
         // We substitute the current decimal separator with the locale decimal separator.
-        let localeDecimalSeparator = Locale.current.decimalSeparator ?? currencySettings.decimalSeparator
+        let localeDecimalSeparator = locale.decimalSeparator ?? currencySettings.decimalSeparator
         var newStringValue = stringValue.replacingOccurrences(of: ",", with: localeDecimalSeparator)
         newStringValue = newStringValue.replacingOccurrences(of: ".", with: localeDecimalSeparator)
 
@@ -28,7 +29,7 @@ public class CurrencyFormatter {
         let unit = currencySettings.symbol(from: currencyCode)
         newStringValue = newStringValue.replacingOccurrences(of: unit, with: "")
 
-        let decimalValue = NSDecimalNumber(string: newStringValue, locale: Locale.current)
+        let decimalValue = NSDecimalNumber(string: newStringValue, locale: locale)
 
         guard decimalValue != NSDecimalNumber.notANumber else {
             DDLogError("Error: string input is not a number: \(stringValue)")
@@ -72,21 +73,22 @@ public class CurrencyFormatter {
 
     /// Returns a string that displays the amount using all of the specified currency settings
     /// - Parameters:
-    ///     - amount: a formatted string, preferably converted using `localize(_:in:with:including:)`.
+    ///     - stringValue: a formatted string, preferably converted using `localize(_:in:with:including:)`.
     ///     - position: the currency position enum, either right, left, right_space, or left_space.
     ///     - symbol: the currency symbol as a string, to be used with the amount.
+    ///     - isNegative: whether the value is negative or not.
+    ///     - locale: the locale that is used to format the currency amount string.
     ///
-    func formatCurrency(using stringValue: String, at position: CurrencySettings.CurrencyPosition, with symbol: String, isNegative: Bool) -> String {
+    func formatCurrency(using amount: String,
+                        at position: CurrencySettings.CurrencyPosition,
+                        with symbol: String,
+                        isNegative: Bool,
+                        locale: Locale = .current) -> String {
         let space = "\u{00a0}" // unicode equivalent of  
         let negative = isNegative ? "-" : ""
 
         // We're relying on the phone's Locale to assist with language direction
-        let current = Locale.current as NSLocale
-        let languageCode = current.object(forKey: NSLocale.Key.languageCode) as? String
-
-        // Remove all occurences of the minus sign from the string amount.
-        // We want to position the minus sign manually.
-        let amount = stringValue.replacingOccurrences(of: "-", with: "")
+        let languageCode = locale.languageCode
 
         // Detect the language direction
         var languageDirection: Locale.LanguageDirection = .unknown
@@ -126,23 +128,25 @@ public class CurrencyFormatter {
     /// - Parameters:
     ///     - amount: a raw string representation of the amount, from the API, with no formatting applied. e.g. "19.87"
     ///     - currency: a 3-letter country code for currencies that are supported in the API. e.g. "USD"
+    ///     - locale: the locale that is used to format the currency amount string.
     ///
-    func formatAmount(_ stringAmount: String, with currency: String = CurrencySettings.shared.currencyCode.rawValue) -> String? {
-        guard let decimalAmount = convertToDecimal(from: stringAmount) else {
+    func formatAmount(_ amount: String, with currency: String? = nil, locale: Locale = .current) -> String? {
+        guard let decimalAmount = convertToDecimal(from: amount, locale: locale) else {
             return nil
         }
 
-        return formatAmount(decimalAmount, with: currency)
+        return formatAmount(decimalAmount, with: currency ?? currencySettings.currencyCode.rawValue, locale: locale)
     }
 
 
     /// Formats the provided `amount` param into a human readable value and applies the currency option
     /// settings for the given currency.
     ///
     /// - Parameters:
-    ///   - amount: a raw string representation of the amount, from the API, with no formatting applied. e.g. "19.87"
+    ///   - stringAmount: a raw string representation of the amount, from the API, with no formatting applied. e.g. "19.87"
     ///   - currency: a 3-letter country code for currencies that are supported in the API. e.g. "USD"
     ///   - roundSmallNumbers: if `true`, small numbers are rounded, if `false`, no rounding occurs (defaults to true)
+    ///   - locale: the locale that is used to format the currency amount string.
     /// - Returns: a formatted amount string
     ///
     /// For our purposes here, a "small number" is anything in-between -1000 and 1000 (exclusive).
@@ -167,17 +171,21 @@ public class CurrencyFormatter {
     ///  - 5800199.56 becomes "$5.8m"
     ///
     func formatHumanReadableAmount(_ stringAmount: String,
-                                   with currency: String = CurrencySettings.shared.currencyCode.rawValue,
-                                   roundSmallNumbers: Bool = true) -> String? {
-        guard let amount = convertToDecimal(from: stringAmount) else {
+                                   with currency: String? = nil,
+                                   roundSmallNumbers: Bool = true,
+                                   locale: Locale = .current) -> String? {
+        guard let amount = convertToDecimal(from: stringAmount, locale: locale) else {
+            assertionFailure("Cannot convert the amount \"\(stringAmount)\" to decimal value with locale \(locale.identifier)")
             return nil
         }
 
-        let humanReadableAmount = amount.humanReadableString(roundSmallNumbers: roundSmallNumbers)
+        let currency = currency ?? currencySettings.currencyCode.rawValue
+
+        let humanReadableAmount = amount.abs().humanReadableString(roundSmallNumbers: roundSmallNumbers)
         if humanReadableAmount == amount.stringValue, roundSmallNumbers == false {
             // The human readable version of amount is the same as the converted param value which means this is a "small"
             // number — format it normally *without* rounding.
-            return formatAmount(amount, with: currency)
+            return formatAmount(amount, with: currency, locale: locale)
         }
 
         // If we are here, the human readable version of the amount param is a "large" number *OR* a small number but rounding has been requested,
@@ -190,15 +198,18 @@ public class CurrencyFormatter {
         return formatCurrency(using: humanReadableAmount,
                               at: position,
                               with: symbol,
-                              isNegative: isNegative)
+                              isNegative: isNegative,
+                              locale: locale)
     }
 
     /// Applies currency option settings to the amount for the given currency.
     /// - Parameters:
     ///     - amount: a NSDecimalNumber representation of the amount, from the API, with no formatting applied. e.g. "19.87"
     ///     - currency: a 3-letter country code for currencies that are supported in the API. e.g. "USD"
+    ///     - locale: the locale that is used to format the currency amount string.
     ///
-    func formatAmount(_ decimalAmount: NSDecimalNumber, with currency: String = CurrencySettings.shared.currencyCode.rawValue) -> String? {
+    func formatAmount(_ amount: NSDecimalNumber, with currency: String? = nil, locale: Locale = .current) -> String? {
+        let currency = currency ?? currencySettings.currencyCode.rawValue
         // Get the currency code
         let code = CurrencySettings.CurrencyCode(rawValue: currency) ?? currencySettings.currencyCode
         // Grab the read-only currency options. These are set by the user in Site > Settings.
@@ -210,7 +221,7 @@ public class CurrencyFormatter {
 
         // Put all the pieces of user preferences on currency formatting together
         // and spit out a string that has the formatted amount.
-        let localized = localize(decimalAmount,
+        let localized = localize(amount,
                                  with: separator,
                                  in: numberOfDecimals,
                                  including: thousandSeparator)
@@ -224,7 +235,8 @@ public class CurrencyFormatter {
         let formattedAmount = formatCurrency(using: localizedAmount,
                                              at: position,
                                              with: symbol,
-                                             isNegative: decimalAmount.isNegative())
+                                             isNegative: amount.isNegative(),
+                                             locale: locale)
 
         return formattedAmount
     }