Added fix for GH issue 950 (#1008)

Author: NandanPrabhu

Auth0/Auth0WebAuth.swift

@@ -355,9 +355,12 @@ extension Auth0WebAuth {
 extension Auth0WebAuth {
 
     func start() async throws -> Credentials {
+        var alreadyResumed = false
         return try await withCheckedThrowingContinuation { continuation in
             Task { @MainActor in
                 self.start { result in
+                    guard !alreadyResumed else { return }
+                    alreadyResumed = true
                     continuation.resume(with: result)
                 }
             }

Auth0Tests/WebAuthSpec.swift

@@ -1,4 +1,5 @@
 import Quick
+import Combine
 import Nimble
 import SafariServices
 
@@ -698,6 +699,187 @@ class WebAuthSpec: QuickSpec {
 
         }
 
+        // MARK: - Combine & Async/Await
+
+        describe("Combine API") {
+            var auth: Auth0WebAuth!
+            var cancellables: Set<AnyCancellable>!
+            
+            beforeEach {
+                let url = URL(string: "https://samples.auth0.com")!
+                auth = Auth0WebAuth(clientId: "client123", url: url, telemetry: Telemetry())
+                QueueBarrier.shared.lower()
+                cancellables = []
+            }
+            
+            afterEach {
+                cancellables.removeAll()
+            }
+            
+            it("start() publishes error on failure") {
+                waitUntil { done in
+                    auth.provider { url, completion in
+                        completion(.failure(WebAuthError(code: .other)))
+                        return SpyUserAgent()
+                    }
+                    
+                    auth.start()
+                        .sink(receiveCompletion: { completion in
+                            if case .failure(let error) = completion {
+                                expect(error.code).to(equal(.other))
+                                done()
+                            }
+                        }, receiveValue: { _ in
+                            fail("Should not emit credentials")
+                        })
+                        .store(in: &cancellables)
+                }
+            }
+            
+            it("clearSession() publishes completion on success") {
+                waitUntil { done in
+                    auth.provider { url, completion in
+                        completion(.success(()))
+                        return SpyUserAgent()
+                    }
+                    
+                    auth.clearSession(federated: false)
+                        .sink(receiveCompletion: { completion in
+                            if case .failure(let error) = completion {
+                                fail("Unexpected error: \(error)")
+                            }
+                        }, receiveValue: {
+                            done()
+                        })
+                        .store(in: &cancellables)
+                }
+            }
+            
+            it("clearSession() publishes error on failure") {
+                waitUntil { done in
+                    auth.provider { url, completion in
+                        completion(.failure(WebAuthError(code: .other)))
+                        return SpyUserAgent()
+                    }
+                    
+                    auth.clearSession(federated: false)
+                        .sink(receiveCompletion: { completion in
+                            if case .failure(let error) = completion {
+                                expect(error.code).to(equal(.other))
+                                done()
+                            }
+                        }, receiveValue: {
+                            fail("Should not succeed")
+                        })
+                        .store(in: &cancellables)
+                }
+            }
+        }
+
+        describe("Async/Await API") {
+            var auth: Auth0WebAuth!
+            
+            beforeEach {
+                let url = URL(string: "https://samples.auth0.com")!
+                QueueBarrier.shared.lower()
+                auth = Auth0WebAuth(clientId: "client123", url: url, telemetry: Telemetry())
+            }
+            it("start() async throws on failure") {
+                auth.provider { url, completion in
+                    completion(.failure(WebAuthError(code: .other)))
+                    return SpyUserAgent()
+                }
+                
+                waitUntil { done in
+                    Task {
+                        do {
+                            _ = try await auth.start()
+                            fail("Should have thrown an error")
+                        } catch let error as WebAuthError {
+                            expect(error.code).to(equal(.other))
+                            done()
+                        } catch {
+                            fail("Unexpected error type")
+                        }
+                    }
+                }
+            }
+            
+            it("ignores double resume but still surfaces first error") {
+                let dummyCredentials = Credentials(
+                    accessToken: "access",
+                    tokenType: "bearer",
+                    idToken: "id",
+                    refreshToken: "refresh",
+                    expiresIn: Date()
+                )
+
+                var callbackRef: (WebAuthResult<Void>) -> Void = { _  in }
+                   auth.provider { url, callback in
+                       callbackRef = callback
+                       callbackRef(.failure(WebAuthError(code: .userCancelled)))
+                       // Second call -> ignored by continuation bridge
+                       callbackRef(.failure(WebAuthError(code: .userCancelled)))
+                       return SpyUserAgent()
+                   }
+
+                   waitUntil(timeout: .seconds(5)) { done in
+                       Task {
+                           // First call -> should throw
+                           
+
+                           do {
+                               _ = try await auth.start()
+                               fail("Expected error")
+                           } catch let error as WebAuthError {
+                               expect(error.code) == .userCancelled
+                               done()
+                           }
+                       }
+                   }
+               }
+            
+            it("clearSession() async completes on success") {
+                auth.provider { url, completion in
+                    completion(.success(()))
+                    return SpyUserAgent()
+                }
+                
+                waitUntil { done in
+                    Task {
+                        do {
+                            try await auth.clearSession(federated: false)
+                            done()
+                        } catch {
+                            fail("Unexpected error: \(error)")
+                        }
+                    }
+                }
+            }
+            
+            it("clearSession() async throws on failure") {
+                auth.provider { url, completion in
+                    completion(.failure(WebAuthError(code: .other)))
+                    return SpyUserAgent()
+                }
+                
+                waitUntil { done in
+                    Task {
+                        do {
+                            try await auth.clearSession(federated: false)
+                            fail("Should have thrown an error")
+                        } catch let error as WebAuthError {
+                            expect(error.code).to(equal(.other))
+                            done()
+                        } catch {
+                            fail("Unexpected error type")
+                        }
+                    }
+                }
+            }
+        }
+
+
         describe("logout") {
 
             var auth: Auth0WebAuth!