SDK-300 Add OnSuccess/OnFailure handlers to logoutUser (#1069)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: sumeruchat

swift-sdk/Internal/InternalIterableAPI.swift

@@ -250,6 +250,36 @@ final class InternalIterableAPI: NSObject, PushTrackerProtocol, AuthProvider {
     func logoutUser() {
         logoutPreviousUser()
     }
+
+    func logoutUser(withOnSuccess onSuccess: OnSuccessHandler?,
+                    onFailure: OnFailureHandler?) {
+        ITBInfo()
+
+        guard isSDKInitialized() else {
+            onFailure?("Iterable SDK is not initialized", nil)
+            return
+        }
+
+        if config.autoPushRegistration {
+            disableDeviceForCurrentUser(withOnSuccess: onSuccess, onFailure: onFailure)
+        }
+
+        _email = nil
+        _userId = nil
+
+        storeIdentifierData()
+
+        authManager.logoutUser()
+
+        _ = inAppManager.reset()
+        _ = embeddedManager.reset()
+
+        try? requestHandler.handleLogout()
+
+        if !config.autoPushRegistration {
+            onSuccess?(nil)
+        }
+    }
 
     func attemptAndProcessMerge(merge: Bool, replay: Bool, destinationUser: String?, isEmail: Bool, failureHandler: OnFailureHandler? = nil) {
         unknownUserMerge.tryMergeUser(destinationUser: destinationUser, isEmail: isEmail, merge: merge) { mergeResult, error in
@@ -845,25 +875,12 @@ final class InternalIterableAPI: NSObject, PushTrackerProtocol, AuthProvider {
     }
 
     private func logoutPreviousUser() {
-        ITBInfo()
-        
-        guard isSDKInitialized() else { return }
-        
-        if config.autoPushRegistration {
-            disableDeviceForCurrentUser()
-        }
-        
-        _email = nil
-        _userId = nil
-        
-        storeIdentifierData()
-        
-        authManager.logoutUser()
-                
-        _ = inAppManager.reset()
-        _ = embeddedManager.reset()
-        
-        try? requestHandler.handleLogout()
+        // Delegates to logoutUser(withOnSuccess:onFailure:) so the logout cleanup
+        // sequence has a single source of truth. The user-switch paths (setEmail/
+        // setUserId) pass no handlers: a nil onFailure keeps the not-initialized
+        // guard a silent no-op, and a nil onSuccess makes the auto-push-off
+        // completion a no-op, matching this method's previous behavior.
+        logoutUser(withOnSuccess: nil, onFailure: nil)
     }
 
     private func storeIdentifierData() {

swift-sdk/SDK/IterableAPI.swift

@@ -212,7 +212,47 @@ import UIKit
     ///           If `autoPushRegistration` is `true` (which is the default value), this will also
     ///           disable the current push token.
     public static func logoutUser() {
-        implementation?.logoutUser()
+        logoutUser(withOnSuccess: nil, onFailure: nil)
+    }
+
+    /// Logs out the current user from the SDK instance, with completion handlers.
+    ///
+    /// Logout itself is a **local-only** operation: it clears the stored user
+    /// identity, resets the in-app and embedded managers, and clears auth state.
+    /// Once the SDK is initialized this local cleanup always runs (and
+    /// effectively always succeeds).
+    ///
+    /// The handlers are an **observability** signal for the one network
+    /// side-effect logout can trigger — the `disableDevice` call made when
+    /// `autoPushRegistration` is enabled:
+    /// - When `autoPushRegistration` is `true`, the handlers reflect the result
+    ///   of that `disableDevice` request: `onSuccess` when it succeeds,
+    ///   `onFailure` when it fails or cannot be sent (e.g. no push token is
+    ///   registered, reported as `"no token present"`). An `onFailure` here does
+    ///   **not** mean the local logout failed — the local logout still completed.
+    /// - When `autoPushRegistration` is `false`, no network call is made and
+    ///   `onSuccess(nil)` is invoked once the local logout sequence completes.
+    /// - If the SDK is not initialized, `onFailure("Iterable SDK is not
+    ///   initialized", nil)` is invoked and no logout is performed.
+    ///
+    /// - Note: Handlers are delivered in-process and are not persisted. If the
+    ///   triggered `disableDevice` request is retried offline, the handler is
+    ///   resolved if/when the retry completes within the same app session — it is
+    ///   not preserved across app termination. Handlers are also not guaranteed
+    ///   to be invoked on the main thread.
+    ///
+    /// - Parameters:
+    ///    - onSuccess: `OnSuccessHandler` to invoke on success (see above)
+    ///    - onFailure: `OnFailureHandler` to invoke on failure (see above)
+    ///
+    /// - SeeAlso: OnSuccessHandler, OnFailureHandler
+    public static func logoutUser(withOnSuccess onSuccess: OnSuccessHandler?, onFailure: OnFailureHandler?) {
+        guard let implementation else {
+            onFailure?("Iterable SDK is not initialized", nil)
+            return
+        }
+
+        implementation.logoutUser(withOnSuccess: onSuccess, onFailure: onFailure)
     }
 
     /// The instance that manages getting and showing in-app messages
@@ -314,7 +354,10 @@ import UIKit
     ///
     /// - SeeAlso: OnSuccessHandler, OnFailureHandler
     public static func disableDeviceForCurrentUser(withOnSuccess onSuccess: OnSuccessHandler?, onFailure: OnFailureHandler?) {
-        guard let implementation, implementation.isSDKInitialized() else { return }
+        guard let implementation, implementation.isSDKInitialized() else {
+            onFailure?("Iterable SDK is not initialized", nil)
+            return
+        }
 
         implementation.disableDeviceForCurrentUser(withOnSuccess: onSuccess, onFailure: onFailure)
     }
@@ -327,7 +370,10 @@ import UIKit
     ///
     /// - SeeAlso: OnSuccessHandler, OnFailureHandler
     public static func disableDeviceForAllUsers(withOnSuccess onSuccess: OnSuccessHandler?, onFailure: OnFailureHandler?) {
-        guard let implementation, implementation.isSDKInitialized() else { return }
+        guard let implementation, implementation.isSDKInitialized() else {
+            onFailure?("Iterable SDK is not initialized", nil)
+            return
+        }
 
         implementation.disableDeviceForAllUsers(withOnSuccess: onSuccess, onFailure: onFailure)
     }

tests/unit-tests/AuthTests.swift

@@ -1251,7 +1251,230 @@ class AuthTests: XCTestCase {
         _ = authDelegate
     }
 
+    func testLogoutUserWithHandlersAutoPushOnDisableDeviceSucceeds() {
+        let logoutSucceeded = expectation(description: "logout success handler called")
+        let token = "zeeToken".data(using: .utf8)!
+        let networkSession = MockNetworkSession(statusCode: 200)
+        let context = createLogoutTestContext(autoPushRegistration: true, networkSession: networkSession)
+
+        context.api.email = AuthTests.email
+        context.api.register(token: token)
+
+        context.api.logoutUser(withOnSuccess: { _ in
+            logoutSucceeded.fulfill()
+        }, onFailure: { reason, _ in
+            XCTFail("logout should not fail: \(reason ?? "nil")")
+        })
+
+        wait(for: [logoutSucceeded], timeout: testExpectationTimeout)
+
+        assertLogoutCleanupCompleted(context)
+
+        guard let request = networkSession.getRequest(withEndPoint: Const.Path.disableDevice),
+              let body = TestUtils.getRequestBody(request: request) else {
+            XCTFail("Expected disableDevice request")
+            return
+        }
+
+        TestUtils.validateElementPresent(withName: JsonKey.token, andValue: token.hexString(), inDictionary: body)
+        TestUtils.validateElementPresent(withName: JsonKey.email, andValue: AuthTests.email, inDictionary: body)
+    }
+
+    func testLogoutUserWithHandlersAutoPushOnDisableDeviceFails() {
+        let logoutFailed = expectation(description: "logout failure handler called")
+        let expectedReason = "disable failed"
+        let token = "zeeToken".data(using: .utf8)!
+        let networkSession = MockNetworkSession(statusCode: 400,
+                                                json: ["msg": expectedReason])
+        let context = createLogoutTestContext(autoPushRegistration: true, networkSession: networkSession)
+
+        context.api.email = AuthTests.email
+        context.api.register(token: token)
+
+        context.api.logoutUser(withOnSuccess: { _ in
+            XCTFail("logout should not succeed")
+        }, onFailure: { reason, data in
+            XCTAssertEqual(reason, expectedReason)
+            XCTAssertNotNil(data)
+            logoutFailed.fulfill()
+        })
+
+        wait(for: [logoutFailed], timeout: testExpectationTimeout)
+
+        assertLogoutCleanupCompleted(context)
+
+        guard let request = networkSession.getRequest(withEndPoint: Const.Path.disableDevice),
+              let body = TestUtils.getRequestBody(request: request) else {
+            XCTFail("Expected disableDevice request")
+            return
+        }
+
+        TestUtils.validateElementPresent(withName: JsonKey.token, andValue: token.hexString(), inDictionary: body)
+        TestUtils.validateElementPresent(withName: JsonKey.email, andValue: AuthTests.email, inDictionary: body)
+    }
+
+    func testLogoutUserWithHandlersAutoPushOffSucceedsSynchronouslyWithoutNetwork() {
+        let logoutSucceeded = expectation(description: "logout success handler called")
+        let networkSession = MockNetworkSession(statusCode: 200)
+        let context = createLogoutTestContext(autoPushRegistration: false, networkSession: networkSession)
+
+        context.api.email = AuthTests.email
+
+        var logoutReturned = false
+        context.api.logoutUser(withOnSuccess: { data in
+            XCTAssertNil(data)
+            XCTAssertFalse(logoutReturned)
+            logoutSucceeded.fulfill()
+        }, onFailure: { reason, _ in
+            XCTFail("logout should not fail: \(reason ?? "nil")")
+        })
+        logoutReturned = true
+
+        wait(for: [logoutSucceeded], timeout: testExpectationTimeout)
+
+        assertLogoutCleanupCompleted(context)
+        XCTAssertTrue(networkSession.requests.isEmpty)
+    }
+
+    func testLogoutUserWithHandlersAutoPushOnNoTokenFailsButStillClearsLocalState() {
+        let logoutFailed = expectation(description: "logout failure handler called")
+        let networkSession = MockNetworkSession(statusCode: 200)
+        let context = createLogoutTestContext(autoPushRegistration: true, networkSession: networkSession)
+
+        context.api.email = AuthTests.email
+        // Intentionally do NOT register a token: there is no push token to disable.
+
+        context.api.logoutUser(withOnSuccess: { _ in
+            XCTFail("logout should not report success when there is no token to disable")
+        }, onFailure: { reason, data in
+            XCTAssertEqual(reason, "no token present")
+            XCTAssertNil(data)
+            logoutFailed.fulfill()
+        })
+
+        wait(for: [logoutFailed], timeout: testExpectationTimeout)
+
+        // Logout is local-only and must still complete even though the triggered
+        // disableDevice could not run (no token) and onFailure was reported.
+        assertLogoutCleanupCompleted(context)
+        XCTAssertNil(networkSession.getRequest(withEndPoint: Const.Path.disableDevice),
+                     "no disableDevice request should be sent when there is no token")
+    }
+
+    func testLogoutUserWithHandlersNotInitializedFails() {
+        let logoutFailed = expectation(description: "logout failure handler called")
+        let networkSession = MockNetworkSession(statusCode: 200)
+        let context = createLogoutTestContext(autoPushRegistration: true, networkSession: networkSession)
+
+        context.api.logoutUser(withOnSuccess: { _ in
+            XCTFail("logout should not succeed")
+        }, onFailure: { reason, data in
+            XCTAssertEqual(reason, "Iterable SDK is not initialized")
+            XCTAssertNil(data)
+            logoutFailed.fulfill()
+        })
+
+        wait(for: [logoutFailed], timeout: testExpectationTimeout)
+
+        XCTAssertTrue(networkSession.requests.isEmpty)
+        XCTAssertEqual(context.inAppManager.resetCallCount, 0)
+        XCTAssertEqual(context.embeddedManager.resetCallCount, 0)
+    }
+
+    func testDisableDeviceWithHandlersNotInitializedFails() {
+        let previousImplementation = IterableAPI.implementation
+        defer { IterableAPI.implementation = previousImplementation }
+        IterableAPI.implementation = nil
+        let currentUserFailed = expectation(description: "current user disable failure handler called")
+        let allUsersFailed = expectation(description: "all users disable failure handler called")
+
+        IterableAPI.disableDeviceForCurrentUser(withOnSuccess: { _ in
+            XCTFail("disable current user should not succeed")
+        }, onFailure: { reason, data in
+            XCTAssertEqual(reason, "Iterable SDK is not initialized")
+            XCTAssertNil(data)
+            currentUserFailed.fulfill()
+        })
+
+        IterableAPI.disableDeviceForAllUsers(withOnSuccess: { _ in
+            XCTFail("disable all users should not succeed")
+        }, onFailure: { reason, data in
+            XCTAssertEqual(reason, "Iterable SDK is not initialized")
+            XCTAssertNil(data)
+            allUsersFailed.fulfill()
+        })
+
+        wait(for: [currentUserFailed, allUsersFailed], timeout: testExpectationTimeout)
+    }
+
+    func testLogoutUserParameterlessOverloadStillLogsOut() {
+        let networkSession = MockNetworkSession(statusCode: 200)
+        let context = createLogoutTestContext(autoPushRegistration: false, networkSession: networkSession)
+
+        context.api.email = AuthTests.email
+
+        context.api.logoutUser()
+
+        assertLogoutCleanupCompleted(context)
+        XCTAssertTrue(networkSession.requests.isEmpty)
+    }
+
     // MARK: - Private
+
+    private final class LogoutTrackingInAppManager: EmptyInAppManager {
+        private(set) var resetCallCount = 0
+
+        override func reset() -> Pending<Bool, Error> {
+            resetCallCount += 1
+            return Fulfill<Bool, Error>(value: true)
+        }
+    }
+
+    private final class LogoutTrackingEmbeddedManager: EmptyEmbeddedManager {
+        private(set) var resetCallCount = 0
+
+        override func reset() {
+            resetCallCount += 1
+        }
+    }
+
+    private typealias LogoutTestContext = (api: InternalIterableAPI,
+                                           localStorage: MockLocalStorage,
+                                           inAppManager: LogoutTrackingInAppManager,
+                                           embeddedManager: LogoutTrackingEmbeddedManager)
+
+    private func createLogoutTestContext(autoPushRegistration: Bool,
+                                         networkSession: MockNetworkSession) -> LogoutTestContext {
+        let config = IterableConfig()
+        config.autoPushRegistration = autoPushRegistration
+        config.pushIntegrationName = "my-push-integration"
+
+        let localStorage = MockLocalStorage()
+        let api = InternalIterableAPI.initializeForTesting(config: config,
+                                                           networkSession: networkSession,
+                                                           notificationStateProvider: MockNotificationStateProvider(enabled: true),
+                                                           localStorage: localStorage)
+        let inAppManager = LogoutTrackingInAppManager()
+        let embeddedManager = LogoutTrackingEmbeddedManager()
+        api.inAppManager = inAppManager
+        api.embeddedManager = embeddedManager
+
+        return (api: api,
+                localStorage: localStorage,
+                inAppManager: inAppManager,
+                embeddedManager: embeddedManager)
+    }
+
+    private func assertLogoutCleanupCompleted(_ context: LogoutTestContext,
+                                              file: StaticString = #file,
+                                              line: UInt = #line) {
+        XCTAssertNil(context.api.email, file: file, line: line)
+        XCTAssertNil(context.api.userId, file: file, line: line)
+        XCTAssertNil(context.localStorage.email, file: file, line: line)
+        XCTAssertNil(context.localStorage.userId, file: file, line: line)
+        XCTAssertEqual(context.inAppManager.resetCallCount, 1, file: file, line: line)
+        XCTAssertEqual(context.embeddedManager.resetCallCount, 1, file: file, line: line)
+    }
 
     class DefaultAuthDelegate: IterableAuthDelegate {
         var authTokenGenerator: (() -> String?)