From a14d08dea85bd067e0a2a1b39958babce6ca63a1 Mon Sep 17 00:00:00 2001 From: Fadi George Date: Fri, 6 Nov 2026 11:21:43 -0800 Subject: [PATCH] test: [SDK-5663] fix flaky User and Core unit tests - MockOneSignalClient: record a request and choose its response in one locked step, and lock all shared state read from the test thread. - Read OSUserExecutor's request queue through its dispatch queue in tests. - UserJwtLifecycleTests: wait for the 401 to be fully handled before supplying the replacement token. - OSConsistencyManagerTests: drop fixed delays from the multi-key test. - CI: save the xcresult, print failure messages, and upload it on failure. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 16 ++- .../OneSignal.xcodeproj/project.pbxproj | 4 + .../MockOneSignalClient.swift | 128 ++++++++++-------- .../OSConsistencyManagerTests.swift | 92 ++++--------- .../Source/Executors/OSUserExecutor.swift | 3 +- .../CachedUserWithoutAnIdTests.swift | 8 +- .../Executors/ExecutorRetryBackoffTests.swift | 4 +- .../OSUserExecutor+Snapshot.swift | 38 ++++++ .../UserJwtLifecycleTests.swift | 5 +- 9 files changed, 169 insertions(+), 129 deletions(-) create mode 100644 iOS_SDK/OneSignalSDK/OneSignalUserTests/OSUserExecutor+Snapshot.swift diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index deef85e1d0..86125bde24 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -154,7 +154,21 @@ jobs: -"$filetype_parameter" "$file_to_build" \ -destination "platform=$platform,id=$device_id,arch=arm64" \ -maximum-parallel-testing-workers 1 \ - -enableCodeCoverage NO + -enableCodeCoverage NO \ + -resultBundlePath "$RUNNER_TEMP/UnitTests.xcresult" + - name: Print test failures + if: failure() + run: | + xcrun xcresulttool get test-results summary \ + --path "$RUNNER_TEMP/UnitTests.xcresult" --format json \ + | jq -r '.testFailures[]? | "::error title=\(.testName)::\(.failureText)"' + - name: Upload test results + if: failure() + uses: actions/upload-artifact@v7 + with: + name: UnitTests-xcresult + path: ${{ runner.temp }}/UnitTests.xcresult + retention-days: 7 catalyst: name: KMP logger Mac Catalyst integration diff --git a/iOS_SDK/OneSignalSDK/OneSignal.xcodeproj/project.pbxproj b/iOS_SDK/OneSignalSDK/OneSignal.xcodeproj/project.pbxproj index 9fc71c3266..930554a0a0 100644 --- a/iOS_SDK/OneSignalSDK/OneSignal.xcodeproj/project.pbxproj +++ b/iOS_SDK/OneSignalSDK/OneSignal.xcodeproj/project.pbxproj @@ -414,6 +414,7 @@ 91F60F7D1E80E4E400706E60 /* UncaughtExceptionHandler.m in Sources */ = {isa = PBXBuildFile; fileRef = 91F60F7C1E80E4E400706E60 /* UncaughtExceptionHandler.m */; }; 9224347AAE3E092B5743380D /* UserJwtApiTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 80DC5517E6EB5B26CF980CC5 /* UserJwtApiTests.swift */; }; AE95DD5B72F1D102F6D6062A /* XCTestCase+AsyncWork.swift in Sources */ = {isa = PBXBuildFile; fileRef = 54FC986DDF6546AB251EA0A7 /* XCTestCase+AsyncWork.swift */; }; + 5663A0010000000000000001 /* OSUserExecutor+Snapshot.swift in Sources */ = {isa = PBXBuildFile; fileRef = 5663A0010000000000000002 /* OSUserExecutor+Snapshot.swift */; }; 94D9F5AFE86B16453A36C9A2 /* MockUserJwtInvalidatedListener.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1F214EE6C5FE133672D6622F /* MockUserJwtInvalidatedListener.swift */; }; 99B1615D0132AFAA981A9AD3 /* DeltaOwnershipTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 3881024646E7F0DE05158442 /* DeltaOwnershipTests.swift */; }; 9D3300FA23149DAE000F0A83 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 9D3300F923149DAE000F0A83 /* CoreGraphics.framework */; }; @@ -1707,6 +1708,7 @@ 7AFE856E2368DDC50091D6A5 /* OSFocusCallParams.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = OSFocusCallParams.h; sourceTree = ""; }; 80DC5517E6EB5B26CF980CC5 /* UserJwtApiTests.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = UserJwtApiTests.swift; sourceTree = ""; }; 54FC986DDF6546AB251EA0A7 /* XCTestCase+AsyncWork.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = "XCTestCase+AsyncWork.swift"; sourceTree = ""; }; + 5663A0010000000000000002 /* OSUserExecutor+Snapshot.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = "OSUserExecutor+Snapshot.swift"; sourceTree = ""; }; 8596A3E728FB90691E43BCA0 /* OSUrlPath.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = OSUrlPath.swift; sourceTree = ""; }; 89DE5BB0EDD3964C20C5169F /* OSIdentityModelRepoTests.swift */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.swift; path = OSIdentityModelRepoTests.swift; sourceTree = ""; }; 911E2CBA1E398AB3003112A4 /* UnitTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = UnitTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; @@ -2572,6 +2574,7 @@ B5809B47EB4F2478099697CE /* OSUserJwtRepoTests.swift */, 80DC5517E6EB5B26CF980CC5 /* UserJwtApiTests.swift */, 54FC986DDF6546AB251EA0A7 /* XCTestCase+AsyncWork.swift */, + 5663A0010000000000000002 /* OSUserExecutor+Snapshot.swift */, 3881024646E7F0DE05158442 /* DeltaOwnershipTests.swift */, 047D8F5E1095A20C9C54FD33 /* OSRequestAuthTests.swift */, 3016921C1F6B7B7793F67567 /* RequestPathEncodingTests.swift */, @@ -4783,6 +4786,7 @@ 2DB99C76F3532383C3B81D09 /* OSUserJwtRepoTests.swift in Sources */, 9224347AAE3E092B5743380D /* UserJwtApiTests.swift in Sources */, AE95DD5B72F1D102F6D6062A /* XCTestCase+AsyncWork.swift in Sources */, + 5663A0010000000000000001 /* OSUserExecutor+Snapshot.swift in Sources */, 99B1615D0132AFAA981A9AD3 /* DeltaOwnershipTests.swift in Sources */, 1B7E5A0AEB23050C398E6111 /* ExecutorAnonymousPurgeTests.swift in Sources */, D9F1B3E5A7C2495FC1E6B8D3 /* ExecutorRequestAgingTests.swift in Sources */, diff --git a/iOS_SDK/OneSignalSDK/OneSignalCoreMocks/MockOneSignalClient.swift b/iOS_SDK/OneSignalSDK/OneSignalCoreMocks/MockOneSignalClient.swift index 1c865af66e..ac099cb8ec 100644 --- a/iOS_SDK/OneSignalSDK/OneSignalCoreMocks/MockOneSignalClient.swift +++ b/iOS_SDK/OneSignalSDK/OneSignalCoreMocks/MockOneSignalClient.swift @@ -31,14 +31,24 @@ public class MockOneSignalClient: NSObject, IOneSignalClient { public let executionQueue: DispatchQueue = DispatchQueue(label: "com.onesignal.execution", attributes: .concurrent) let lock = NSLock() - var mockResponses: [String: [String: Any]] = [:] - var mockFailureResponses: [String: OneSignalClientError] = [:] - public var lastHTTPRequest: OneSignalRequest? - public var networkRequestCount = 0 - public var executedRequests: [OneSignalRequest] = [] + // Tests read and configure these from the test thread while requests complete on `executionQueue`, + // so every access goes through `lock`. + private var mockResponses: [String: [String: Any]] = [:] + private var mockFailureResponses: [String: OneSignalClientError] = [:] + private var _lastHTTPRequest: OneSignalRequest? + private var _networkRequestCount = 0 + private var _executedRequests: [OneSignalRequest] = [] + private var _startedRequests: [OneSignalRequest] = [] + private var _completedRequests: [OneSignalRequest] = [] + private var _allRequestsHandled = true + + public var lastHTTPRequest: OneSignalRequest? { lock.withLock { _lastHTTPRequest } } + public var networkRequestCount: Int { lock.withLock { _networkRequestCount } } + public var executedRequests: [OneSignalRequest] { lock.withLock { _executedRequests } } /// Requests that have entered `execute` (including those still held / delayed). - public private(set) var startedRequests: [OneSignalRequest] = [] - public private(set) var completedRequests: [OneSignalRequest] = [] + public var startedRequests: [OneSignalRequest] { lock.withLock { _startedRequests } } + public var completedRequests: [OneSignalRequest] { lock.withLock { _completedRequests } } + public var allRequestsHandled: Bool { lock.withLock { _allRequestsHandled } } public var executeInstantaneously = false /// Set to true to make it unnecessary to setup mock responses for every request possible public var fireSuccessForAllRequests = false @@ -51,8 +61,6 @@ public class MockOneSignalClient: NSObject, IOneSignalClient { var shouldUseProvisionalAuthorization = false // new in iOS 12 (aka Direct to History) var remoteParamsOutcomes: [String: Any] = [:] - public var allRequestsHandled = true - /** May add to or change this default remote params response*/ public func getRemoteParamsResponse() -> [String: Any] { return remoteParamsResponse ?? [ @@ -87,14 +95,16 @@ public class MockOneSignalClient: NSObject, IOneSignalClient { } public func reset() { - mockResponses = [:] - lastHTTPRequest = nil - networkRequestCount = 0 - executedRequests.removeAll() - startedRequests.removeAll() - completedRequests.removeAll() - heldExecutions.removeAll() - holdResponses = false + lock.withLock { + mockResponses = [:] + _lastHTTPRequest = nil + _networkRequestCount = 0 + _executedRequests.removeAll() + _startedRequests.removeAll() + _completedRequests.removeAll() + heldExecutions.removeAll() + holdResponses = false + } executeInstantaneously = true remoteParamsResponse = nil shouldUseProvisionalAuthorization = false @@ -106,7 +116,7 @@ public class MockOneSignalClient: NSObject, IOneSignalClient { // Check hold + enqueue under one lock so releaseHeldResponses can't miss a callback mid-hold. let shouldHold = lock.withLock { () -> Bool in - startedRequests.append(request) + _startedRequests.append(request) guard holdResponses else { return false } @@ -154,49 +164,55 @@ public class MockOneSignalClient: NSObject, IOneSignalClient { return stringified } - func finishExecutingRequest(_ request: OneSignalRequest, onSuccess successBlock: OSResultSuccessBlock, onFailure failureBlock: OSClientFailureBlock) { + private enum MockOutcome { + case success([String: Any]?) + case failure(OneSignalClientError) + case unhandled + } - // TODO: This entire method needs to contained within the equivalent of @synchronized ❗️ + func finishExecutingRequest(_ request: OneSignalRequest, onSuccess successBlock: OSResultSuccessBlock, onFailure failureBlock: OSClientFailureBlock) { print("🧪 completing HTTP request: \(request)") - // TODO: Check for existence of app_id in the request and fail if not. - lock.withLock { - executedRequests.append(request) + let stringifiedRequest = stringify(request) + // Recording the request and choosing its response must be one step. Tests wait for a request to + // be executed and then register the response for its retry; if that landed in between, this + // attempt would be answered with the retry's response. + let outcome: MockOutcome = lock.withLock { + _executedRequests.append(request) + _networkRequestCount += 1 + _lastHTTPRequest = request + if let response = mockResponses[stringifiedRequest] { + return .success(response) + } else if let error = mockFailureResponses[stringifiedRequest] { + return .failure(error) + } else if fireSuccessForAllRequests { + _allRequestsHandled = false + return .success([:]) + } else { + _allRequestsHandled = false + return .unhandled + } } - self.didCompleteRequest(request) + print("🧪 didCompleteRequest url: \(String(describing: request.urlRequest().url)) params: \(String(describing: request.parameters))") - let stringifiedRequest = stringify(request) - // Switch between types of requests with mock responses if request.isKind(of: OSRequestGetIosParams.self) { - // send a mock remote params response successBlock(["mockTodo": "responseTodo"]) } - if (mockResponses[stringifiedRequest]) != nil { - successBlock(mockResponses[stringifiedRequest]) - } else if let response = mockFailureResponses[stringifiedRequest] { - failureBlock(response) - } else if fireSuccessForAllRequests { - allRequestsHandled = false - successBlock([:]) - } else { - allRequestsHandled = false + switch outcome { + case .success(let response): + successBlock(response) + case .failure(let error): + failureBlock(error) + case .unhandled: print("🧪 cannot find a mock response for request: \(stringifiedRequest)") } lock.withLock { - completedRequests.append(request) + _completedRequests.append(request) } } - func didCompleteRequest(_ request: OneSignalRequest) { - networkRequestCount += 1 - - print("🧪 didCompleteRequest url(\(networkRequestCount)): \(String(describing: request.urlRequest().url)) params: \(String(describing: request.parameters))") - - lastHTTPRequest = request - } - /** This is not currently hooked up to anything to run */ @objc public func runBackgroundThreads() { // Obj-C implementation: dispatch_sync(executionQueue, ^{}) @@ -206,13 +222,17 @@ public class MockOneSignalClient: NSObject, IOneSignalClient { // A request has one outcome: whichever of these was called for it last. Otherwise a test could not // override a default its setUp registered, nor let a retry succeed after the first attempt failed. public func setMockResponseForRequest(request: String, response: [String: Any]) { - mockResponses[request] = response - mockFailureResponses.removeValue(forKey: request) + lock.withLock { + mockResponses[request] = response + mockFailureResponses.removeValue(forKey: request) + } } public func setMockFailureResponseForRequest(request: String, error: OneSignalClientError) { - mockFailureResponses[request] = error - mockResponses.removeValue(forKey: request) + lock.withLock { + mockFailureResponses[request] = error + mockResponses.removeValue(forKey: request) + } } } @@ -224,7 +244,7 @@ extension MockOneSignalClient { */ @objc public func onlyOneRequest(contains path: String, contains payload: [String: Any]) -> Bool { - let requests = lock.withLock { executedRequests } + let requests = executedRequests var found = false for request in requests { @@ -249,7 +269,7 @@ extension MockOneSignalClient { } public func hasExecutedRequestOfType(_ type: AnyClass, expectedCount: Int? = nil) -> Bool { - let requests = lock.withLock { executedRequests } + let requests = executedRequests let matchingCount = requests.filter { request in request.isKind(of: type) }.count @@ -271,14 +291,14 @@ extension MockOneSignalClient { } public func completedRequestCount(ofType type: AnyClass) -> Int { - let requests = lock.withLock { completedRequests } + let requests = completedRequests return requests.filter { request in request.isKind(of: type) }.count } public func startedRequestCount(ofType type: AnyClass) -> Int { - let requests = lock.withLock { startedRequests } + let requests = startedRequests return requests.filter { request in request.isKind(of: type) }.count @@ -286,6 +306,6 @@ extension MockOneSignalClient { /// Held requests count as in flight. Read under the lock, so safe from the test thread. public var isIdle: Bool { - return lock.withLock { startedRequests.count == completedRequests.count } + return lock.withLock { _startedRequests.count == _completedRequests.count } } } diff --git a/iOS_SDK/OneSignalSDK/OneSignalOSCoreTests/OSConsistencyManagerTests.swift b/iOS_SDK/OneSignalSDK/OneSignalOSCoreTests/OSConsistencyManagerTests.swift index ba23f19c0d..8af3e38368 100644 --- a/iOS_SDK/OneSignalSDK/OneSignalOSCoreTests/OSConsistencyManagerTests.swift +++ b/iOS_SDK/OneSignalSDK/OneSignalOSCoreTests/OSConsistencyManagerTests.swift @@ -138,80 +138,42 @@ class OSConsistencyManagerTests: XCTestCase { } func testMultipleConditionsWithDifferentKeys() { - let expectation1 = self.expectation(description: "UserUpdate condition met") - let expectation2 = self.expectation(description: "SubscriptionUpdate condition met") - - // Given let id = "test_id" let userUpdateKey = OSIamFetchOffsetKey.userUpdate let subscriptionUpdateKey = OSIamFetchOffsetKey.subscriptionUpdate - let userUpdateRywToken = "123" - let userUpdateRywDelay = 1 as NSNumber - let userUpdateRywData = OSReadYourWriteData(rywToken: userUpdateRywToken, rywDelay: userUpdateRywDelay) - let subscriptionUpdateRywToken = "456" - let subscriptionUpdateRywDelay = 1 as NSNumber - let subscriptionUpdateRywData = OSReadYourWriteData(rywToken: subscriptionUpdateRywToken, rywDelay: subscriptionUpdateRywDelay) - - // Create a serial queue to prevent race conditions - let serialQueue = DispatchQueue(label: "com.consistencyManager.test.serialQueue") - - // Register two conditions for different keys - let userUpdateCondition = TestMetCondition(expectedTokens: [id: [NSNumber(value: userUpdateKey.rawValue): userUpdateRywData]]) - let subscriptionCondition = TestMetCondition(expectedTokens: [id: [NSNumber(value: subscriptionUpdateKey.rawValue): subscriptionUpdateRywData]]) - - // Set the userUpdate token first and verify its condition - serialQueue.async { - self.consistencyManager.setRywTokenAndDelay( - id: id, - key: userUpdateKey, - value: userUpdateRywData - ) - - // Introduce a short delay before checking the condition to ensure the token is set - DispatchQueue.global().asyncAfter(deadline: .now() + 0.1) { - let newestUserUpdateToken = self.registerConditionWithTimeout(userUpdateCondition, forId: id) - XCTAssertEqual(newestUserUpdateToken, userUpdateRywData) - expectation1.fulfill() - } - } - - // Set the subscriptionUpdate token separately and verify its condition after a short delay - serialQueue.asyncAfter(deadline: .now() + 1.0) { - self.consistencyManager.setRywTokenAndDelay( - id: id, - key: subscriptionUpdateKey, - value: OSReadYourWriteData(rywToken: subscriptionUpdateRywToken, rywDelay: subscriptionUpdateRywDelay) - ) - - // Introduce a short delay before checking the condition to ensure the token is set - DispatchQueue.global().asyncAfter(deadline: .now() + 0.1) { - let subscriptionRywData = self.registerConditionWithTimeout(subscriptionCondition, forId: id) - XCTAssertEqual(subscriptionRywData?.rywToken, subscriptionUpdateRywToken) - expectation2.fulfill() - } + let userUpdateRywData = OSReadYourWriteData(rywToken: "123", rywDelay: 1 as NSNumber) + let subscriptionUpdateRywData = OSReadYourWriteData(rywToken: "456", rywDelay: 1 as NSNumber) + let userUpdateCondition = TestMetCondition( + expectedTokens: [id: [NSNumber(value: userUpdateKey.rawValue): userUpdateRywData]]) + let subscriptionCondition = TestMetCondition( + expectedTokens: [id: [NSNumber(value: subscriptionUpdateKey.rawValue): subscriptionUpdateRywData]]) + + // Each waiter registers before its token arrives, so the token is what releases it. + let userUpdateReturned = expectation(description: "UserUpdate waiter returned") + var userUpdateResult: OSReadYourWriteData? + DispatchQueue.global().async { + userUpdateResult = self.consistencyManager.getRywTokenFromAwaitableCondition(userUpdateCondition, forId: id) + userUpdateReturned.fulfill() } + OneSignalCoreMocks.waitUntil("UserUpdate waiter registered") { self.consistencyManager.waiterCount == 1 } - // Wait for both expectations to be fulfilled - wait(for: [expectation1, expectation2], timeout: 3.0) - } - - private func registerConditionWithTimeout(_ condition: OSCondition, forId id: String) -> OSReadYourWriteData? { - // This function wraps the registerCondition method with a timeout for testing - let semaphore = DispatchSemaphore(value: 0) - var result: OSReadYourWriteData? - + let subscriptionReturned = expectation(description: "SubscriptionUpdate waiter returned") + var subscriptionResult: OSReadYourWriteData? DispatchQueue.global().async { - result = self.consistencyManager.getRywTokenFromAwaitableCondition(condition, forId: id) - semaphore.signal() // Signal once the condition is met + subscriptionResult = self.consistencyManager.getRywTokenFromAwaitableCondition(subscriptionCondition, forId: id) + subscriptionReturned.fulfill() } + OneSignalCoreMocks.waitUntil("SubscriptionUpdate waiter registered") { self.consistencyManager.waiterCount == 2 } - // Wait for up to 2 seconds to prevent hanging in tests - if semaphore.wait(timeout: .now() + 2.0) == .timedOut { - XCTFail("Condition was not met within the timeout period") - return nil - } + consistencyManager.setRywTokenAndDelay(id: id, key: userUpdateKey, value: userUpdateRywData) + wait(for: [userUpdateReturned], timeout: 5.0) + XCTAssertEqual(userUpdateResult, userUpdateRywData) + // A token for another key must not release the other waiter. + XCTAssertEqual(consistencyManager.waiterCount, 1) - return result + consistencyManager.setRywTokenAndDelay(id: id, key: subscriptionUpdateKey, value: subscriptionUpdateRywData) + wait(for: [subscriptionReturned], timeout: 5.0) + XCTAssertEqual(subscriptionResult?.rywToken, "456") } func testConditionMetImmediatelyAfterTokenAlreadySet() { diff --git a/iOS_SDK/OneSignalSDK/OneSignalUser/Source/Executors/OSUserExecutor.swift b/iOS_SDK/OneSignalSDK/OneSignalUser/Source/Executors/OSUserExecutor.swift index d10d7c53c6..80b500fced 100644 --- a/iOS_SDK/OneSignalSDK/OneSignalUser/Source/Executors/OSUserExecutor.swift +++ b/iOS_SDK/OneSignalSDK/OneSignalUser/Source/Executors/OSUserExecutor.swift @@ -49,7 +49,8 @@ class OSUserExecutor { private let flushDelayMilliseconds = Int(OP_REPO_POST_CREATE_DELAY_SECONDS * 1_000 + 200) // TODO: This could come from a config, plist, method, remote params /// The User executor dispatch queue, serial. This synchronizes access to the request queues. - private let dispatchQueue = DispatchQueue(label: "OneSignal.OSUserExecutor", target: .global()) + /// Non-private so test helpers can read the queues through it. + let dispatchQueue = DispatchQueue(label: "OneSignal.OSUserExecutor", target: .global()) init( newRecordsState: OSNewRecordsState, diff --git a/iOS_SDK/OneSignalSDK/OneSignalUserTests/CachedUserWithoutAnIdTests.swift b/iOS_SDK/OneSignalSDK/OneSignalUserTests/CachedUserWithoutAnIdTests.swift index c64e2aa6a5..ff5f0bac66 100644 --- a/iOS_SDK/OneSignalSDK/OneSignalUserTests/CachedUserWithoutAnIdTests.swift +++ b/iOS_SDK/OneSignalSDK/OneSignalUserTests/CachedUserWithoutAnIdTests.swift @@ -113,7 +113,7 @@ final class CachedUserWithoutAnIdTests: XCTestCase { } // A second one would still be queued here: it goes out only after the post-create delay. OneSignalCoreMocks.waitUntil("A Create User is still queued") { - OneSignalUserManagerImpl.sharedInstance.userExecutor?.userRequestQueue.contains { $0 is OSRequestCreateUser } == false + OneSignalUserManagerImpl.sharedInstance.userExecutor?.snapshotUserRequestQueue().contains { $0 is OSRequestCreateUser } == false } XCTAssertEqual(sentCreateUsers().count, 1) } @@ -147,7 +147,7 @@ final class CachedUserWithoutAnIdTests: XCTestCase { self.client.hasCompletedRequestOfType(OSRequestCreateUser.self) } OneSignalCoreMocks.waitUntil("A Create User is still queued") { - OneSignalUserManagerImpl.sharedInstance.userExecutor?.userRequestQueue.contains { $0 is OSRequestCreateUser } == false + OneSignalUserManagerImpl.sharedInstance.userExecutor?.snapshotUserRequestQueue().contains { $0 is OSRequestCreateUser } == false } XCTAssertEqual(sentCreateUsers().count, 1) } @@ -173,7 +173,7 @@ final class CachedUserWithoutAnIdTests: XCTestCase { self.client.hasCompletedRequestOfType(OSRequestFetchIdentityBySubscription.self) } XCTAssertTrue(sentCreateUsers().isEmpty) - XCTAssertFalse(OneSignalUserManagerImpl.sharedInstance.userExecutor?.userRequestQueue.contains { $0 is OSRequestCreateUser } ?? true) + XCTAssertFalse(OneSignalUserManagerImpl.sharedInstance.userExecutor?.snapshotUserRequestQueue().contains { $0 is OSRequestCreateUser } ?? true) XCTAssertEqual(OneSignalUserManagerImpl.sharedInstance._user?.identityModel.onesignalId, legacyOnesignalId) } @@ -186,6 +186,6 @@ final class CachedUserWithoutAnIdTests: XCTestCase { // Nothing positive to wait for: give the executor's queue a turn, then look. Thread.sleep(forTimeInterval: 0.2) XCTAssertTrue(sentCreateUsers().isEmpty) - XCTAssertEqual(OneSignalUserManagerImpl.sharedInstance.userExecutor?.userRequestQueue.isEmpty, true) + XCTAssertEqual(OneSignalUserManagerImpl.sharedInstance.userExecutor?.snapshotUserRequestQueue().isEmpty, true) } } diff --git a/iOS_SDK/OneSignalSDK/OneSignalUserTests/Executors/ExecutorRetryBackoffTests.swift b/iOS_SDK/OneSignalSDK/OneSignalUserTests/Executors/ExecutorRetryBackoffTests.swift index 9bbb5897eb..fc80d2be17 100644 --- a/iOS_SDK/OneSignalSDK/OneSignalUserTests/Executors/ExecutorRetryBackoffTests.swift +++ b/iOS_SDK/OneSignalSDK/OneSignalUserTests/Executors/ExecutorRetryBackoffTests.swift @@ -191,7 +191,7 @@ final class ExecutorRetryBackoffTests: XCTestCase { uptime += OSRequestRetryBackoff.baseDelaySeconds OneSignalCoreMocks.waitUntil("The Fetch User was not retried until it succeeded") { executor.retryIfDue() - return self.count(OSRequestFetchUser.self) == 2 && executor.userRequestQueue.isEmpty + return self.count(OSRequestFetchUser.self) == 2 && executor.snapshotUserRequestQueue().isEmpty } allowAsyncWorkToRun() } @@ -244,7 +244,7 @@ final class ExecutorRetryBackoffTests: XCTestCase { OneSignalCoreMocks.waitUntil("The current user's Create User was held behind the logged out one") { self.count(OSRequestCreateUser.self) == 2 } - XCTAssertFalse(executor.userRequestQueue.contains { ($0 as? OSRequestCreateUser)?.identityModel === loggedOut }) + XCTAssertFalse(executor.snapshotUserRequestQueue().contains { ($0 as? OSRequestCreateUser)?.identityModel === loggedOut }) XCTAssertFalse(OneSignalUserManagerImpl.sharedInstance.operationRepo.paused) } diff --git a/iOS_SDK/OneSignalSDK/OneSignalUserTests/OSUserExecutor+Snapshot.swift b/iOS_SDK/OneSignalSDK/OneSignalUserTests/OSUserExecutor+Snapshot.swift new file mode 100644 index 0000000000..b5da7ef527 --- /dev/null +++ b/iOS_SDK/OneSignalSDK/OneSignalUserTests/OSUserExecutor+Snapshot.swift @@ -0,0 +1,38 @@ +/* + Modified MIT License + + Copyright 2026 OneSignal + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + 1. The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + 2. All copies of substantial portions of the Software may only be used in connection +with services provided by OneSignal. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. + */ + +@testable import OneSignalUser + +extension OSUserExecutor { + /** + The queue as of right now. Tests poll it while the executor mutates it on its own queue, so + reading `userRequestQueue` directly is a data race. + */ + func snapshotUserRequestQueue() -> [OSUserRequest] { + return dispatchQueue.sync { userRequestQueue } + } +} diff --git a/iOS_SDK/OneSignalSDK/OneSignalUserTests/UserJwtLifecycleTests.swift b/iOS_SDK/OneSignalSDK/OneSignalUserTests/UserJwtLifecycleTests.swift index 01401ee1b6..8c2364a24d 100644 --- a/iOS_SDK/OneSignalSDK/OneSignalUserTests/UserJwtLifecycleTests.swift +++ b/iOS_SDK/OneSignalSDK/OneSignalUserTests/UserJwtLifecycleTests.swift @@ -94,7 +94,7 @@ final class UserJwtLifecycleTests: XCTestCase { } private func queuedUserRequests() -> [OSUserRequest] { - return OneSignalUserManagerImpl.sharedInstance.userExecutor?.userRequestQueue ?? [] + return OneSignalUserManagerImpl.sharedInstance.userExecutor?.snapshotUserRequestQueue() ?? [] } /// The `external_id` of every queued Create User, so a test can tell the anonymous one apart. @@ -329,8 +329,9 @@ final class UserJwtLifecycleTests: XCTestCase { OneSignalUserManagerImpl.sharedInstance.login(externalId: userA_EUID, token: "token-a") OneSignalCoreMocks.waitUntil("The rejected Create User was not parked") { - self.client.hasExecutedRequestOfType(OSRequestCreateUser.self, expectedCount: 1) + self.client.hasCompletedRequestOfType(OSRequestCreateUser.self, expectedCount: 1) && self.queuedCreateUserExternalIds().contains(userA_EUID) + && OneSignalUserManagerImpl.sharedInstance.userJwtRepo.validJwt(externalId: userA_EUID) == nil } XCTAssertTrue(client.hasExecutedRequestOfType(OSRequestCreateUser.self, expectedCount: 1))