Merge branch 'trunk' into woomob-73-login-with-captcha

Author: itsmeichigo

Modules/.swiftpm/xcode/xcshareddata/xcschemes/Networking.xcscheme

@@ -33,6 +33,9 @@
             reference = "container:Tests/NetworkingTests/NetworkingTests.xctestplan"
             default = "YES">
          </TestPlanReference>
+         <TestPlanReference
+            reference = "container:Tests/NetworkingTests/RequestAuthenticatorPressureTests.xctestplan">
+         </TestPlanReference>
       </TestPlans>
    </TestAction>
    <LaunchAction

Modules/Sources/NetworkingCore/ApplicationPassword/RequestProcessor.swift

@@ -8,35 +8,29 @@ protocol RequestProcessorDelegate: AnyObject {
 /// Authenticates and retries requests
 ///
 final class RequestProcessor: RequestInterceptor {
-    private var requestsToRetry = [(RetryResult) -> Void]()
-
-    private var isAuthenticating = false
-
-    private var requestAuthenticator: RequestAuthenticator
-
     private let notificationCenter: NotificationCenter
 
-    private var currentSiteID: Int64?
+    private let state: RequestProcessorState
 
     weak var delegate: RequestProcessorDelegate?
 
     init(requestAuthenticator: RequestAuthenticator,
          notificationCenter: NotificationCenter = .default) {
-        self.requestAuthenticator = requestAuthenticator
         self.notificationCenter = notificationCenter
+        self.state = RequestProcessorState(requestAuthenticator: requestAuthenticator)
     }
 
     func updateAuthenticator(_ authenticator: RequestAuthenticator) {
-        requestAuthenticator = authenticator
-        currentSiteID = authenticator.jetpackSiteID
+        state.updateAuthenticator(authenticator)
     }
 }
 
 // MARK: Request Authentication
 //
 extension RequestProcessor: RequestAdapter {
     func adapt(_ urlRequest: URLRequest, for session: Session, completion: @escaping (Result<URLRequest, Error>) -> Void) {
-        let result = Result { try requestAuthenticator.authenticate(urlRequest) }
+        let authenticator = state.authenticator
+        let result = Result { try authenticator.authenticate(urlRequest) }
         completion(result)
     }
 }
@@ -45,18 +39,27 @@ extension RequestProcessor: RequestAdapter {
 //
 extension RequestProcessor: RequestRetrier {
     func retry(_ request: Alamofire.Request, for session: Session, dueTo error: Error, completion: @escaping (RetryResult) -> Void) {
-        guard
-            request.retryCount == 0, // Only retry once
-            let urlRequest = request.request,
-            requestAuthenticator.shouldRetry(urlRequest), // Retry only REST API requests that use application password
-            shouldRetry(error) // Retry only specific errors
-        else {
-            return completion(.doNotRetry)
-        }
-
-        requestsToRetry.append(completion)
-        if !isAuthenticating {
-            isAuthenticating = true
+        guard request.retryCount == 0, // Only retry once
+              let urlRequest = request.request else {
+            completion(.doNotRetry)
+            return
+        }
+
+        guard shouldRetry(error) else {
+            completion(.doNotRetry)
+            return
+        }
+
+        let shouldRetryRequest = state.shouldRetry(urlRequest)
+
+        guard shouldRetryRequest else {
+            completion(.doNotRetry)
+            return
+        }
+
+        let shouldStartAuthentication = state.enqueueRetry(completion)
+
+        if shouldStartAuthentication {
             generateApplicationPassword()
         }
     }
@@ -66,28 +69,30 @@ extension RequestProcessor: RequestRetrier {
 //
 private extension RequestProcessor {
     func generateApplicationPassword() {
-        Task(priority: .medium) { @MainActor in
+        Task(priority: .medium) { @MainActor [weak self] in
+            guard let self else { return }
+            let authenticator = self.state.authenticator
             do {
-                let _ = try await requestAuthenticator.generateApplicationPassword()
-                isAuthenticating = false
+                let _ = try await authenticator.generateApplicationPassword()
+                self.state.setAuthenticating(false)
 
                 // Post a notification for tracking
-                notificationCenter.post(name: .ApplicationPasswordsNewPasswordCreated, object: nil, userInfo: nil)
+                self.notificationCenter.post(name: .ApplicationPasswordsNewPasswordCreated, object: nil, userInfo: nil)
 
-                completeRequests(true)
+                self.completeRequests(true)
             } catch {
 
                 // Post a notification for tracking
-                notificationCenter.post(name: .ApplicationPasswordsGenerationFailed, object: error, userInfo: nil)
+                self.notificationCenter.post(name: .ApplicationPasswordsGenerationFailed, object: error, userInfo: nil)
 
-                let shouldRetry = await checkIfRetryingGenerationIsNeeded(for: error)
+                let shouldRetry = await self.checkIfRetryingGenerationIsNeeded(for: error)
                 if shouldRetry {
-                    generateApplicationPassword()
+                    self.generateApplicationPassword()
                 } else {
-                    isAuthenticating = false
-                    completeRequests(false, error: error)
-                    if let currentSiteID {
-                        notifyFailureIfNeeded(error, for: currentSiteID)
+                    self.state.setAuthenticating(false)
+                    self.completeRequests(false, error: error)
+                    if let siteID = self.state.currentSiteID {
+                        self.notifyFailureIfNeeded(error, for: siteID)
                     }
                 }
             }
@@ -98,14 +103,15 @@ private extension RequestProcessor {
     /// Returns whether retry is needed.
     @MainActor
     func checkIfRetryingGenerationIsNeeded(for error: Error) async -> Bool {
-        guard currentSiteID != nil else {
+        guard state.currentSiteID != nil else {
             return false
         }
         switch error {
         case NetworkError.unacceptableStatusCode(let statusCode, _) where statusCode == 409:
             /// Password with the same name already exists. Request deletion remotely and retry.
             do {
-                try await requestAuthenticator.deleteApplicationPassword()
+                let authenticator = state.authenticator
+                try await authenticator.deleteApplicationPassword()
                 return true
             } catch {
                 return false
@@ -156,10 +162,10 @@ private extension RequestProcessor {
                 .doNotRetry
             }
         }()
-        requestsToRetry.forEach { (completion) in
+        let pendingCompletions = state.drainPendingRetries()
+        pendingCompletions.forEach { completion in
             completion(result)
         }
-        requestsToRetry.removeAll()
     }
 }
 
@@ -182,3 +188,68 @@ public extension NSNotification.Name {
     ///
     static let JetpackSiteEligibleForAppPasswordSupport = NSNotification.Name(rawValue: "JetpackSiteEligibleForAppPasswordSupport")
 }
+
+private extension RequestProcessor {
+    final class RequestProcessorState {
+        private var requestsToRetry: [(RetryResult) -> Void]
+        private var isAuthenticating: Bool
+        private var requestAuthenticator: RequestAuthenticator
+        private var siteID: Int64?
+
+        private let queue = DispatchQueue(
+            label: "com.woocommerce.networking.request-processor.state-queue",
+            qos: .userInitiated
+        )
+
+        init(requestAuthenticator: RequestAuthenticator) {
+            self.requestsToRetry = []
+            self.isAuthenticating = false
+            self.requestAuthenticator = requestAuthenticator
+            self.siteID = requestAuthenticator.jetpackSiteID
+        }
+
+        var authenticator: RequestAuthenticator {
+            queue.sync { requestAuthenticator }
+        }
+
+        var currentSiteID: Int64? {
+            queue.sync { siteID }
+        }
+
+        func shouldRetry(_ request: URLRequest) -> Bool {
+            queue.sync { requestAuthenticator.shouldRetry(request) }
+        }
+
+        func enqueueRetry(_ completion: @escaping (RetryResult) -> Void) -> Bool {
+            queue.sync {
+                requestsToRetry.append(completion)
+                if isAuthenticating {
+                    return false
+                }
+                isAuthenticating = true
+                return true
+            }
+        }
+
+        func setAuthenticating(_ value: Bool) {
+            queue.sync {
+                isAuthenticating = value
+            }
+        }
+
+        func drainPendingRetries() -> [(RetryResult) -> Void] {
+            queue.sync {
+                let completions = requestsToRetry
+                requestsToRetry.removeAll()
+                return completions
+            }
+        }
+
+        func updateAuthenticator(_ authenticator: RequestAuthenticator) {
+            queue.sync {
+                requestAuthenticator = authenticator
+                siteID = authenticator.jetpackSiteID
+            }
+        }
+    }
+}

Modules/Sources/PointOfSale/Controllers/PointOfSaleItemsController.swift

@@ -1,6 +1,7 @@
 import Foundation
 import Observation
 import enum Yosemite.POSItem
+import struct Yosemite.POSSimpleProduct
 import class Yosemite.PointOfSaleItemService
 import protocol Yosemite.PointOfSaleItemServiceProtocol
 import protocol Yosemite.PointOfSaleItemFetchStrategyFactoryProtocol

Modules/Sources/PointOfSale/Presentation/CardReaderConnection/CardReaderConnectionStatusView.swift

@@ -34,6 +34,7 @@ struct CardReaderConnectionStatusView: View {
                     .padding(.horizontal, Constants.horizontalPadding)
                     .frame(maxHeight: .infinity)
                 }
+                .accessibilityIdentifier("pos-reader-connected")
             case .disconnecting:
                 progressIndicatingCardReaderStatus(title: Localization.readerDisconnecting)
             case .cancellingConnection:
@@ -55,6 +56,7 @@ struct CardReaderConnectionStatusView: View {
                     )
                     .padding(Constants.disconnectedBorderInset)
                 }
+                .accessibilityIdentifier("pos-connect-reader-button")
             }
         }
         .font(Constants.font)

Modules/Sources/PointOfSale/Presentation/CardReaderConnection/UI States/Reader Messages/PointOfSaleCardPresentPaymentTapSwipeInsertCardMessageView.swift

@@ -24,6 +24,7 @@ struct PointOfSaleCardPresentPaymentTapSwipeInsertCardMessageView: View {
             }
         }
         .multilineTextAlignment(.center)
+        .accessibilityIdentifier("pos-card-payment-message")
     }
 }
 

Modules/Sources/PointOfSale/Presentation/CardReaderConnection/UI States/Reader Messages/PointOfSalePaymentSuccessView.swift

@@ -31,6 +31,7 @@ struct PointOfSalePaymentSuccessView: View {
                 }
             }
         }
+        .accessibilityIdentifier("pos-payment-success-view")
         .onAppear {
             withAnimation(.spring(response: 0.6, dampingFraction: 0.8)) {
                 isViewLoaded = true

Modules/Sources/PointOfSale/Presentation/CartView.swift

@@ -80,6 +80,7 @@ struct CartView: View {
             })
             .background(backgroundColor.ignoresSafeArea(.all))
             .accessibilityElement(children: .contain)
+            .accessibilityIdentifier("pos-cart-view")
         }
     }
 }
@@ -175,6 +176,7 @@ private extension CartView {
         }
         .buttonStyle(POSFilledButtonStyle(size: .normal))
         .disabled(CartViewHelper().hasUnresolvedItems(cart: posModel.cart))
+        .accessibilityIdentifier("pos-checkout-button")
     }
 
     var backButtonConfiguration: POSPageHeaderBackButtonConfiguration? {

Modules/Sources/PointOfSale/Presentation/Item Selector/ItemList.swift

@@ -156,6 +156,7 @@ struct ItemListRow: View {
             }, label: {
                 SimpleProductCardView(product: product)
             })
+            .accessibilityIdentifier("pos-product-card-\(product.productID)")
         case let .variableParentProduct(parentProduct):
             if #available(iOS 18.0, *) {
                 NavigationLink(value: item) {

Modules/Sources/PointOfSale/Presentation/POSFloatingControlView.swift

@@ -40,6 +40,7 @@ struct POSFloatingControlView: View {
                 }
                 .frame(width: Constants.size)
             }
+            .accessibilityIdentifier("pos-menu-button")
             .background(backgroundColor)
             .cornerRadius(Constants.cornerRadius)
             .disabled(posModel.paymentState.card == .processingPayment)
@@ -78,6 +79,7 @@ private extension POSFloatingControlView {
                 icon: { Image(systemName: "rectangle.portrait.and.arrow.forward") }
             )
         }
+        .accessibilityIdentifier("pos-exit-menu-item")
         Button {
             analytics.track(.pointOfSaleSettingsMenuItemTapped)
             showSettings = true

Modules/Sources/PointOfSale/Presentation/PointOfSaleCollectCashView.swift

@@ -97,6 +97,7 @@ struct PointOfSaleCollectCashView: View {
                             buttonFrame = $0
                         }
                         .buttonStyle(POSFilledButtonStyle(size: .normal, isLoading: isLoading))
+                        .accessibilityIdentifier("pos-mark-payment-complete-button")
                         .frame(maxWidth: .infinity)
                         .dynamicTypeSize(...DynamicTypeSize.accessibility1)
                         .disabled(!isButtonEnabled)