[Woo POS] Modularization: refactor WaitingTimeTracker to remove Analytics dependency and move it to WooFoundation

Modules/Sources/WooFoundation/Utilities/WaitingTimeTracker.swift

@@ -0,0 +1,86 @@
+import Foundation
+
+/// Tracks the waiting time for a given scenario, allowing to evaluate as analytics
+/// how much time in seconds it took between the init and `end` function call
+///
+public class WaitingTimeTracker {
+    private let trackScenario: WooAnalyticsEvent.WaitingTime.Scenario
+    private let currentTimestampSeconds: () -> TimeInterval
+    private let waitingStartedTimestamp: TimeInterval
+
+    public enum TrackingUnit {
+        case seconds
+        case milliseconds
+    }
+
+    public init(trackScenario: WooAnalyticsEvent.WaitingTime.Scenario,
+                currentTimestampSeconds: @escaping () -> TimeInterval = { Date().timeIntervalSince1970 }
+    ) {
+        self.trackScenario = trackScenario
+        self.currentTimestampSeconds = currentTimestampSeconds
+        waitingStartedTimestamp = currentTimestampSeconds()
+    }
+
+    /// Default `end()` method to preserve interface compatibility. By default, tracks in `.seconds`
+    /// - Returns: The analytics event to be tracked.
+    ///
+    public func end() -> WooAnalyticsEvent {
+        end(using: .seconds)
+    }
+
+    /// End the waiting time by evaluating the elapsed time from the init,
+    /// and returning an analytics event for tracking.
+    ///
+    /// - Parameter trackingUnit: Defines whether the elapsed time should be tracked in `.seconds` or `.milliseconds` (default is `.seconds`).
+    /// - Returns: The analytics event to be tracked.
+    ///
+    public func end(using trackingUnit: TrackingUnit = .seconds) -> WooAnalyticsEvent {
+        let elapsedTime = calculateElapsedTime(in: trackingUnit)
+        return .WaitingTime.waitingFinished(scenario: trackScenario, elapsedTime: elapsedTime)
+    }
+
+    /// Calculates elapsed time in the specified tracking unit.
+    ///
+    private func calculateElapsedTime(in trackingUnit: TrackingUnit) -> TimeInterval {
+        let elapsedTime = currentTimestampSeconds() - waitingStartedTimestamp
+        return trackingUnit == .milliseconds ? elapsedTime * 1000 : elapsedTime
+    }
+}
+
+// MARK: - Waiting Time measurement
+//
+public extension WooAnalyticsEvent {
+    enum WaitingTime {
+        /// Possible Waiting time scenarios
+        public enum Scenario {
+            case orderDetails
+            case dashboardTopPerformers
+            case dashboardMainStats
+            case analyticsHub
+            case appStartup
+            case pointOfSaleLoaded
+        }
+
+        private enum Keys {
+            static let waitingTime = "waiting_time"
+            static let millisecondsTimeElapsedInSplashScreen = "milliseconds_time_elapsed_in_splash_screen"
+        }
+
+        static func waitingFinished(scenario: Scenario, elapsedTime: TimeInterval) -> WooAnalyticsEvent {
+            switch scenario {
+            case .orderDetails:
+                return WooAnalyticsEvent(statName: .orderDetailWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
+            case .dashboardTopPerformers:
+                return WooAnalyticsEvent(statName: .dashboardTopPerformersWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
+            case .dashboardMainStats:
+                return WooAnalyticsEvent(statName: .dashboardMainStatsWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
+            case .analyticsHub:
+                return WooAnalyticsEvent(statName: .analyticsHubWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
+            case .appStartup:
+                return WooAnalyticsEvent(statName: .applicationOpenedWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
+            case .pointOfSaleLoaded:
+                return WooAnalyticsEvent(statName: .pointOfSaleLoaded, properties: [Keys.millisecondsTimeElapsedInSplashScreen: elapsedTime])
+            }
+        }
+    }
+}

Modules/Tests/WooFoundationTests/Utilities/WaitingTimeTrackerTests.swift

@@ -0,0 +1,113 @@
+import XCTest
+@testable import WooFoundation
+
+/// WaitingTimeTracker Unit Tests
+///
+final class WaitingTimeTrackerTests: XCTestCase {
+    func testTimeElapsedEvaluationIsCorrect() {
+        var currentTimeCallCounter = 0.0
+
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .orderDetails) {
+            currentTimeCallCounter += 1
+            return currentTimeCallCounter * 10
+        }
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.properties["waiting_time"] as? TimeInterval, 10.0)
+    }
+
+    func testOrderDetailsTrackScenarioTriggersExpectedAnalyticsStat() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .orderDetails, currentTimestampSeconds: { 0 })
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.orderDetailWaitingTimeLoaded.rawValue)
+    }
+
+    func testTopPerformersTrackScenarioTriggersExpectedAnalyticsStat() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .dashboardTopPerformers,
+                                                currentTimestampSeconds: { 0 }
+        )
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.dashboardTopPerformersWaitingTimeLoaded.rawValue)
+    }
+
+    func testMainStatsTrackScenarioTriggersExpectedAnalyticsStat() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .dashboardMainStats,
+                                                currentTimestampSeconds: { 0 }
+        )
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.dashboardMainStatsWaitingTimeLoaded.rawValue)
+    }
+
+    func test_analytics_hub_track_scenario_triggers_expected_analytics_stat() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .analyticsHub,
+                                                currentTimestampSeconds: { 0 }
+        )
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.analyticsHubWaitingTimeLoaded.rawValue)
+    }
+
+    func test_appStartup_track_scenario_triggers_expected_analytics_stat() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .appStartup,
+                                                currentTimestampSeconds: { 0 }
+        )
+
+        // When
+        let event = waitingTracker.end()
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.applicationOpenedWaitingTimeLoaded.rawValue)
+    }
+
+    func test_timeElapsed_evaluation_in_milliseconds_is_correct() {
+        // Given
+        var currentTimeCallCounter = 0.0
+        let expectedReceivedWaitingTime = 10_000.0 // 10s * 1000 ms
+        let waitingTracker = WaitingTimeTracker(trackScenario: .orderDetails) {
+            currentTimeCallCounter += 1
+            return currentTimeCallCounter * 10
+        }
+
+        // When
+        let event = waitingTracker.end(using: .milliseconds)
+
+        // Then
+        XCTAssertEqual(event.properties["waiting_time"] as? TimeInterval, expectedReceivedWaitingTime)
+    }
+
+    func test_track_scenario_triggers_expected_analytics_stat_in_milliseconds() {
+        // Given
+        let waitingTracker = WaitingTimeTracker(trackScenario: .pointOfSaleLoaded,
+                                                currentTimestampSeconds: { 0 })
+
+        // When
+        let event = waitingTracker.end(using: .milliseconds)
+
+        // Then
+        XCTAssertEqual(event.statName.rawValue, WooAnalyticsStat.pointOfSaleLoaded.rawValue)
+    }
+}

WooCommerce/Classes/Analytics/AppStartupWaitingTimeTracker.swift

@@ -1,11 +1,12 @@
 import Foundation
 import Yosemite
+import class WooFoundation.WaitingTimeTracker
 import protocol WooFoundation.Analytics
 
 /// Tracks the waiting time for app startup, allowing to evaluate as analytics
 /// how much time in seconds it took between the init and the final `end(action:)` function call.
 ///
-final class AppStartupWaitingTimeTracker: WaitingTimeTracker {
+final class AppStartupWaitingTimeTracker {
 
     /// All actions tracked in the app startup waiting time.
     ///
@@ -19,10 +20,13 @@ final class AppStartupWaitingTimeTracker: WaitingTimeTracker {
     /// Represents all of the app startup actions waiting to be completed.
     ///
     private(set) var startupActionsPending = StartupAction.allCases
+    private let analyticsService: Analytics
+    private let waitingTimeTracker: WaitingTimeTracker
 
     init(analyticsService: Analytics = ServiceLocator.analytics,
          currentTimestampSeconds: @escaping () -> TimeInterval = { Date().timeIntervalSince1970 }) {
-        super.init(trackScenario: .appStartup, analyticsService: analyticsService, currentTimestampSeconds: currentTimestampSeconds)
+        self.analyticsService = analyticsService
+        self.waitingTimeTracker = WaitingTimeTracker(trackScenario: .appStartup, currentTimestampSeconds: currentTimestampSeconds)
     }
 
     /// Ends the waiting time for the provided startup action.
@@ -39,7 +43,7 @@ final class AppStartupWaitingTimeTracker: WaitingTimeTracker {
 
         // If all actions completed without any errors, send the analytics event.
         if startupActionsPending.isEmpty {
-            super.end()
+            analyticsService.track(event: waitingTimeTracker.end())
         }
     }
 
@@ -48,7 +52,7 @@ final class AppStartupWaitingTimeTracker: WaitingTimeTracker {
     /// This can be used to stop tracking in scenarios that would skew the waiting time analysis.
     /// For example, when the app is backgrounded or a startup action has an API error or network connection error.
     ///
-    override func end() {
+    func endWithoutTracking() {
         startupActionsPending.removeAll()
     }
 }

WooCommerce/Classes/Analytics/WooAnalyticsEvent+WooApp.swift

@@ -2565,45 +2565,6 @@ extension WooAnalyticsEvent {
     }
 }
 
-
-// MARK: - Waiting Time measurement
-//
-extension WooAnalyticsEvent {
-    enum WaitingTime {
-        /// Possible Waiting time scenarios
-        enum Scenario {
-            case orderDetails
-            case dashboardTopPerformers
-            case dashboardMainStats
-            case analyticsHub
-            case appStartup
-            case pointOfSaleLoaded
-        }
-
-        private enum Keys {
-            static let waitingTime = "waiting_time"
-            static let millisecondsTimeElapsedInSplashScreen = "milliseconds_time_elapsed_in_splash_screen"
-        }
-
-        static func waitingFinished(scenario: Scenario, elapsedTime: TimeInterval) -> WooAnalyticsEvent {
-            switch scenario {
-            case .orderDetails:
-                return WooAnalyticsEvent(statName: .orderDetailWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
-            case .dashboardTopPerformers:
-                return WooAnalyticsEvent(statName: .dashboardTopPerformersWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
-            case .dashboardMainStats:
-                return WooAnalyticsEvent(statName: .dashboardMainStatsWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
-            case .analyticsHub:
-                return WooAnalyticsEvent(statName: .analyticsHubWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
-            case .appStartup:
-                return WooAnalyticsEvent(statName: .applicationOpenedWaitingTimeLoaded, properties: [Keys.waitingTime: elapsedTime])
-            case .pointOfSaleLoaded:
-                return WooAnalyticsEvent(statName: .pointOfSaleLoaded, properties: [Keys.millisecondsTimeElapsedInSplashScreen: elapsedTime])
-            }
-        }
-    }
-}
-
 // MARK: - Site picker
 //
 extension WooAnalyticsEvent {

WooCommerce/Classes/AppDelegate.swift

@@ -436,7 +436,7 @@ private extension AppDelegate {
     /// Cancel the app startup waiting time tracker
     ///
     func cancelStartupWaitingTimeTracker() {
-        ServiceLocator.startupWaitingTimeTracker.end()
+        ServiceLocator.startupWaitingTimeTracker.endWithoutTracking()
     }
 
     func handleLaunchArguments() {

WooCommerce/Classes/POS/Presentation/PointOfSaleDashboardView.swift

@@ -4,6 +4,7 @@ import WooFoundation
 struct PointOfSaleDashboardView: View {
     @Environment(PointOfSaleAggregateModel.self) private var posModel
     @Environment(\.horizontalSizeClass) private var horizontalSizeClass
+    @Environment(\.posAnalytics) private var analytics
     @Environment(\.posExternalViews) private var externalViews
 
     @State private var showExitPOSModal: Bool = false
@@ -230,7 +231,8 @@ private extension PointOfSaleDashboardView {
 
     func trackElapsedTimeForInitialLoadingState() {
         if let waitingTimeTracker {
-            waitingTimeTracker.end(using: .milliseconds)
+            let event = waitingTimeTracker.end(using: .milliseconds)
+            analytics.track(event: event)
             self.waitingTimeTracker = nil
         }
     }

WooCommerce/Classes/ViewRelated/Dashboard/Analytics Hub/AnalyticsHubViewModel.swift

@@ -2,6 +2,7 @@ import Foundation
 import Yosemite
 import Combine
 import class UIKit.UIColor
+import class WooFoundation.WaitingTimeTracker
 import protocol Storage.StorageManagerType
 import protocol WooFoundation.Analytics
 
@@ -278,9 +279,9 @@ final class AnalyticsHubViewModel: ObservableObject {
     func updateData(for cards: [AnalyticsCard.CardType]? = nil) async {
         let cardsNeedingData = cards ?? enabledCards
         do {
-            let tracker = WaitingTimeTracker(trackScenario: .analyticsHub, analyticsService: analytics)
+            let tracker = WaitingTimeTracker(trackScenario: .analyticsHub)
             try await retrieveData(for: cardsNeedingData)
-            tracker.end()
+            analytics.track(event: tracker.end())
         } catch is AnalyticsHubTimeRangeSelection.TimeRangeGeneratorError {
             dismissNotice = Notice(title: Localization.timeRangeGeneratorError, feedbackType: .error)
             ServiceLocator.analytics.track(event: .AnalyticsHub.dateRangeSelectionFailed(for: timeRangeSelectionType))