Replaced usage of TimeInterval with Duration

Author: dimitribouniol

Sources/WebAuthn/Ceremonies/Authentication/PublicKeyCredentialRequestOptions.swift

@@ -30,7 +30,7 @@ public struct PublicKeyCredentialRequestOptions: Encodable {
     ///
     /// - Note: When encoded, this value is represented in milleseconds as a ``UInt32``.
     /// See https://www.w3.org/TR/webauthn-2/#dictionary-assertion-options
-    public let timeout: TimeInterval?
+    public let timeout: Duration?
 
     /// The Relying Party ID.
     public let rpId: String?
@@ -47,8 +47,7 @@ public struct PublicKeyCredentialRequestOptions: Encodable {
         var container = encoder.container(keyedBy: CodingKeys.self)
 
         try container.encode(challenge.base64URLEncodedString(), forKey: .challenge)
-        let timeoutInMilliseconds = timeout.map { UInt32($0 * 1000) }
-        try container.encodeIfPresent(timeoutInMilliseconds, forKey: .timeout)
+        try container.encodeIfPresent(timeout?.milliseconds, forKey: .timeout)
         try container.encodeIfPresent(rpId, forKey: .rpId)
         try container.encodeIfPresent(allowCredentials, forKey: .allowCredentials)
         try container.encodeIfPresent(userVerification, forKey: .userVerification)

Sources/WebAuthn/Ceremonies/Registration/PublicKeyCredentialCreationOptions.swift

@@ -42,7 +42,7 @@ public struct PublicKeyCredentialCreationOptions: Encodable {
     /// hint, and may be overridden by the client.
     ///
     /// - Note: When encoded, this value is represented in milleseconds as a ``UInt32``.
-    public let timeout: TimeInterval?
+    public let timeout: Duration?
 
     /// Sets the Relying Party's preference for attestation conveyance. At the time of writing only `none` is
     /// supported.
@@ -55,8 +55,7 @@ public struct PublicKeyCredentialCreationOptions: Encodable {
         try container.encode(user, forKey: .user)
         try container.encode(relyingParty, forKey: .relyingParty)
         try container.encode(publicKeyCredentialParameters, forKey: .publicKeyCredentialParameters)
-        let timeoutInMilliseconds = timeout.map { UInt32($0 * 1000) }
-        try container.encodeIfPresent(timeoutInMilliseconds, forKey: .timeout)
+        try container.encodeIfPresent(timeout?.milliseconds, forKey: .timeout)
         try container.encode(attestation, forKey: .attestation)
     }
 

Sources/WebAuthn/Helpers/Duration+Milliseconds.swift

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the WebAuthn Swift open source project
+//
+// Copyright (c) 2022 the WebAuthn Swift project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of WebAuthn Swift project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+extension Duration {
+    /// The value of a positive duration in milliseconds, suitable to be encoded in WebAuthn types.
+    var milliseconds: Int64 {
+        let (seconds, attoseconds) = self.components
+        return Int64(seconds * 1000) + Int64(attoseconds/1_000_000_000_000_000)
+    }
+}

Sources/WebAuthn/WebAuthnManager.swift

@@ -55,7 +55,7 @@ public struct WebAuthnManager {
     /// - Returns: Registration options ready for the browser.
     public func beginRegistration(
         user: PublicKeyCredentialUserEntity,
-        timeout: TimeInterval? = 3600,
+        timeout: Duration? = .seconds(3600),
         attestation: AttestationConveyancePreference = .none,
         publicKeyCredentialParameters: [PublicKeyCredentialParameters] = .supported
     ) -> PublicKeyCredentialCreationOptions {
@@ -134,7 +134,7 @@ public struct WebAuthnManager {
     ///     "user verified" flag.
     /// - Returns: Authentication options ready for the browser.
     public func beginAuthentication(
-        timeout: TimeInterval? = 60,
+        timeout: Duration? = .seconds(60),
         allowCredentials: [PublicKeyCredentialDescriptor]? = nil,
         userVerification: UserVerificationRequirement = .preferred
     ) throws -> PublicKeyCredentialRequestOptions {

Tests/WebAuthnTests/DurationTests.swift

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the WebAuthn Swift open source project
+//
+// Copyright (c) 2022 the WebAuthn Swift project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of WebAuthn Swift project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import XCTest
+@testable import WebAuthn
+
+final class DurationTests: XCTestCase {
+    func testMilliseconds() throws {
+        XCTAssertEqual(Duration.milliseconds(1234).milliseconds, 1234)
+        XCTAssertEqual(Duration.milliseconds(-1234).milliseconds, -1234)
+        XCTAssertEqual(Duration.microseconds(12345).milliseconds, 12)
+        XCTAssertEqual(Duration.microseconds(-12345).milliseconds, -12)
+    }
+}

Tests/WebAuthnTests/WebAuthnManagerAuthenticationTests.swift

@@ -37,13 +37,13 @@ final class WebAuthnManagerAuthenticationTests: XCTestCase {
     func testBeginAuthentication() async throws {
         let allowCredentials: [PublicKeyCredentialDescriptor] = [.init(type: "public-key", id: [1, 0, 2, 30])]
         let options = try webAuthnManager.beginAuthentication(
-            timeout: 1234,
+            timeout: .seconds(1234),
             allowCredentials: allowCredentials,
             userVerification: .preferred
         )
 
         XCTAssertEqual(options.challenge, challenge)
-        XCTAssertEqual(options.timeout, 1234)
+        XCTAssertEqual(options.timeout, .seconds(1234))
         XCTAssertEqual(options.rpId, relyingPartyID)
         XCTAssertEqual(options.allowCredentials, allowCredentials)
         XCTAssertEqual(options.userVerification, .preferred)

Tests/WebAuthnTests/WebAuthnManagerIntegrationTests.swift

@@ -31,7 +31,7 @@ final class WebAuthnManagerIntegrationTests: XCTestCase {
 
         // Step 1.: Begin Registration
         let mockUser = PublicKeyCredentialUserEntity.mock
-        let timeout: TimeInterval = 1234
+        let timeout: Duration = .seconds(1234)
         let attestationPreference = AttestationConveyancePreference.none
         let publicKeyCredentialParameters: [PublicKeyCredentialParameters] = .supported
 
@@ -93,7 +93,7 @@ final class WebAuthnManagerIntegrationTests: XCTestCase {
         XCTAssertEqual(credential.publicKey, mockCredentialPublicKey)
 
         // Step 3.: Begin Authentication
-        let authenticationTimeout: TimeInterval = 4567
+        let authenticationTimeout: Duration = .seconds(4567)
         let userVerification: UserVerificationRequirement = .preferred
         let rememberedCredentials = [PublicKeyCredentialDescriptor(
             type: "public-key",