Merge pull request #2453 from DataDog/ncreated/chore/merge-app-state-enhancements-to-develop

chore: Consolidate Session Lifecycle Optimizations

Author: ncreated

Datadog/Datadog.xcodeproj/project.pbxproj

@@ -0,0 +1,50 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+import Foundation
+import TestUtilities
+
+/// Defines a chain of `AppRunStep`s representing a test scenario for SDK integration testing.
+/// Allows building scenarios using `given()`, `when()`, and `then()` for fluent test composition.
+internal struct AppRun: Hashable {
+    /// Ordered steps to perform in this run.
+    let steps: [AppRunStep]
+
+    /// Starts a new test scenario with the initial step.
+    /// - Parameter initialStep: The first step to define the starting point of the test.
+    static func given(_ initialStep: AppRunStep) -> Self {
+        return AppRun(steps: [initialStep])
+    }
+
+    /// Adds a step to the scenario in the "when" phase.
+    /// - Parameter step: The next step representing an action or change.
+    func when(_ step: AppRunStep) -> Self {
+        return .init(steps: steps + [step])
+    }
+
+    /// Adds an additional step to the scenario (alias for `when()`).
+    /// - Parameter step: The additional step to append to the sequence.
+    func and(_ step: AppRunStep) -> Self {
+        return when(step)
+    }
+
+    /// Executes the defined scenario and returns the resulting RUM sessions.
+    /// - Returns: An array of RUM session matchers.
+    func then() throws -> [RUMSessionMatcher] {
+        let app = AppRunner()
+        app.setUp()
+        defer { app.tearDown() }
+
+        // Perform all steps:
+        steps.forEach { step in
+            step.perform(app)
+        }
+
+        // Get recorded sessions:
+        let sessions = try app.recordedRUMSessions()
+        return sessions
+    }
+}

Datadog/IntegrationUnitTests/AppRunner/AppRun.swift

@@ -0,0 +1,139 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+import Foundation
+@testable import DatadogCore
+@testable import DatadogRUM
+
+extension AppRunStep {
+    // MARK: - App Lifecycle
+
+    static func appLaunch(type: AppRunner.ProcessLaunchType) -> AppRunStep {
+        return AppRunStep({ app in
+            app.launch(type)
+        })
+    }
+
+    static func advanceTime(by duration: TimeInterval) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: duration)
+        })
+    }
+
+    static func appBecomesActive(after dt: TimeInterval) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.transitionToActive()
+        })
+    }
+
+    static func appEntersBackground(after dt: TimeInterval) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.transitionToBackground()
+        })
+    }
+
+    // MARK: - RUM Use Cases
+
+    static func enableRUM(
+        after dt: TimeInterval,
+        sdkSetup: AppRunner.SDKSetup? = nil,
+        rumSetup: AppRunner.RUMSetup? = nil
+    ) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.initializeSDK(sdkSetup ?? { _ in })
+            app.enableRUM { rumConfig in
+                rumSetup?(&rumConfig)
+                rumConfig.sessionEndedSampleRate = 0 // TODO: RUM-9335 Enable "Session Ended" telemetry after fixing `application.id` value for session stop
+                rumConfig.telemetrySampleRate = 0
+            }
+        })
+    }
+
+    static func stopSession(after dt: TimeInterval) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.rum.stopSession()
+        })
+    }
+
+    static func timeoutSession() -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: RUMSessionScope.Constants.sessionTimeoutDuration)
+        })
+    }
+
+    static func startManualView(after dt: TimeInterval, viewName: String, viewKey: String = "view") -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.rum.startView(key: viewKey, name: viewName)
+        })
+    }
+
+    static func stopManualView(after dt: TimeInterval, viewKey: String = "view") -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.rum.stopView(key: viewKey)
+        })
+    }
+
+    static func startAutomaticView(after dt: TimeInterval, viewController: UIViewController) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.viewDidAppear(vc: viewController)
+        })
+    }
+
+    static func stopAutomaticView(after dt: TimeInterval, viewController: UIViewController) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.viewDidDisappear(vc: viewController)
+        })
+    }
+
+    static func trackTwoActions(after1 dt1: TimeInterval, after2 dt2: TimeInterval) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt1)
+            app.rum.addAction(type: .custom, name: "CustomAction1")
+            app.advanceTime(by: dt2)
+            app.rum.addAction(type: .custom, name: "CustomAction2")
+        })
+    }
+
+    static func trackResource(after dt: TimeInterval, duration: TimeInterval) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.rum.startResource(resourceKey: "resource", url: URL(string: "https://resource.url")!)
+            app.advanceTime(by: duration)
+            app.rum.stopResource(resourceKey: "resource", response: .mockAny())
+        })
+    }
+
+    static func trackTwoLongTasks(after1 dt1: TimeInterval, after2 dt2: TimeInterval, duration1: TimeInterval = 0.1, duration2: TimeInterval = 0.1) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt1)
+            app.rum._internal?.addLongTask(at: app.currentTime, duration: duration1)
+            app.advanceTime(by: dt2)
+            app.rum._internal?.addLongTask(at: app.currentTime, duration: duration2)
+        })
+    }
+
+    static func startResource(after dt: TimeInterval, key: String, url: URL) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.rum.startResource(resourceKey: key, url: url)
+        })
+    }
+
+    static func stopResource(after dt: TimeInterval, key: String) -> AppRunStep {
+        return AppRunStep({ app in
+            app.advanceTime(by: dt)
+            app.rum.stopResource(resourceKey: key, response: .mockAny())
+        })
+    }
+}

Datadog/IntegrationUnitTests/AppRunner/AppRunStep+Fixtures.swift

@@ -0,0 +1,30 @@
+/*
+ * Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
+ * This product includes software developed at Datadog (https://www.datadoghq.com/).
+ * Copyright 2019-Present Datadog, Inc.
+ */
+
+import Foundation
+
+/// Represents a single test action to be performed in an `AppRun`.
+internal struct AppRunStep: Hashable {
+    /// Unique identifier used for distinguishing steps.
+    let uuid = UUID()
+
+    /// The action to perform, provided with an `AppRunner` context.
+    let perform: (AppRunner) -> Void
+
+    /// Creates a new step with the given execution closure.
+    /// - Parameter perform: The closure that defines the step logic using the `AppRunner`.
+    init(_ perform: @escaping (AppRunner) -> Void) {
+        self.perform = perform
+    }
+
+    // MARK: – Equatable
+
+    static func == (lhs: AppRunStep, rhs: AppRunStep) -> Bool { lhs.uuid == rhs.uuid }
+
+    // MARK: – Hashable
+
+    func hash(into hasher: inout Hasher) { hasher.combine(uuid) }
+}