Updates tests

Author: NandanPrabhu

Auth0Tests/RequestSpec.swift

@@ -30,6 +30,18 @@ fileprivate extension Request where T == [String: Any], E == AuthenticationError
 
 }
 
+extension Requestable {
+    var storedParameters: [String: Any] {
+        (self as? Request<ResultType, ErrorType>)?.parameters ?? [:]
+    }
+    var storedHeaders: [String: String] {
+        (self as? Request<ResultType, ErrorType>)?.headers ?? [:]
+    }
+    var dpop: DPoP? {
+        (self as? Request<ResultType, ErrorType>)?.dpop
+    }
+}
+
 class RequestSpec: QuickSpec {
     override class func spec() {
 
@@ -52,32 +64,32 @@ class RequestSpec: QuickSpec {
                 }
 
                 it("should create a new request with extra parameters") {
-                    let request = Request().parameters(["foo": "bar"]) as! Request<[String: Any], AuthenticationError>
-                    expect(request.parameters["foo"] as? String) == "bar"
+                    let request = Request().parameters(["foo": "bar"])
+                    expect(request.storedParameters["foo"] as? String) == "bar"
                 }
 
                 it("should merge extra parameters with existing parameters") {
-                    let request = Request(parameters: ["foo": "bar"]).parameters(["baz": "qux"]) as! Request<[String: Any], AuthenticationError>
-                    expect(request.parameters["foo"] as? String) == "bar"
-                    expect(request.parameters["baz"] as? String) == "qux"
+                    let request = Request(parameters: ["foo": "bar"]).parameters(["baz": "qux"])
+                    expect(request.storedParameters["foo"] as? String) == "bar"
+                    expect(request.storedParameters["baz"] as? String) == "qux"
                 }
 
                 it("should overwrite existing parameters with extra parameters") {
-                    let request = Request(parameters: ["foo": "bar"]).parameters(["foo": "baz"]) as! Request<[String: Any], AuthenticationError>
-                    expect(request.parameters["foo"] as? String) == "baz"
+                    let request = Request(parameters: ["foo": "bar"]).parameters(["foo": "baz"])
+                    expect(request.storedParameters["foo"] as? String) == "baz"
                 }
 
                 it("should create a new request and not mutate an existing request") {
                     let request = Request(parameters: ["foo": "bar"])
-                    let updated = request.parameters(["foo": "baz"]) as! Request<[String: Any], AuthenticationError>
-                    expect(updated.parameters["foo"] as? String) == "baz"
+                    let updated = request.parameters(["foo": "baz"])
+                    expect(updated.storedParameters["foo"] as? String) == "baz"
                     expect(request.parameters["foo"] as? String) == "bar"
                 }
 
                 it("should enforce the openid scope when adding extra parameters") {
                     let request = Request(parameters: ["foo": "bar"])
-                    let updated = request.parameters(["scope": "email phone"]) as! Request<[String: Any], AuthenticationError>
-                    expect(updated.parameters["scope"] as? String) == "openid email phone"
+                    let updated = request.parameters(["scope": "email phone"])
+                    expect(updated.storedParameters["scope"] as? String) == "openid email phone"
                 }
 
                 it("should add the parameters as query parameters") {
@@ -113,25 +125,25 @@ class RequestSpec: QuickSpec {
                 }
 
                 it("should create a new request with extra headers") {
-                    let request = Request().headers(["foo": "bar"]) as! Request<[String: Any], AuthenticationError>
-                    expect(request.headers["foo"]) == "bar"
+                    let request = Request().headers(["foo": "bar"])
+                    expect(request.storedHeaders["foo"]) == "bar"
                 }
 
                 it("should merge extra headers with existing headers") {
-                    let request = Request(headers: ["foo": "bar"]).headers(["baz": "qux"]) as! Request<[String: Any], AuthenticationError>
-                    expect(request.headers["foo"]) == "bar"
-                    expect(request.headers["baz"]) == "qux"
+                    let request = Request(headers: ["foo": "bar"]).headers(["baz": "qux"])
+                    expect(request.storedHeaders["foo"]) == "bar"
+                    expect(request.storedHeaders["baz"]) == "qux"
                 }
 
                 it("should overwrite existing headers with extra headers") {
-                    let request = Request(headers: ["foo": "bar"]).headers(["foo": "baz"]) as! Request<[String: Any], AuthenticationError>
-                    expect(request.headers["foo"]) == "baz"
+                    let request = Request(headers: ["foo": "bar"]).headers(["foo": "baz"])
+                    expect(request.storedHeaders["foo"]) == "baz"
                 }
 
                 it("should create a new request and not mutate an existing request") {
                     let request = Request(headers: ["foo": "bar"])
-                    let updated = request.headers(["foo": "baz"]) as! Request<[String: Any], AuthenticationError>
-                    expect(updated.headers["foo"]) == "baz"
+                    let updated = request.headers(["foo": "baz"])
+                    expect(updated.storedHeaders["foo"]) == "baz"
                     expect(request.headers["foo"]) == "bar"
                 }
 
@@ -155,12 +167,12 @@ class RequestSpec: QuickSpec {
                 }
 
                 it("should preserve dpop when adding parameters") {
-                    let request = Request(dpop: DPoP()).parameters(["foo": "bar"]) as! Request<[String: Any], AuthenticationError>
+                    let request = Request(dpop: DPoP()).parameters(["foo": "bar"])
                     expect(request.dpop).toNot(beNil())
                 }
 
                 it("should preserve dpop when adding headers") {
-                    let request = Request(dpop: DPoP()).headers(["foo": "bar"]) as! Request<[String: Any], AuthenticationError>
+                    let request = Request(dpop: DPoP()).headers(["foo": "bar"])
                     expect(request.dpop).toNot(beNil())
                 }
 

V3_MIGRATION_GUIDE.md

@@ -31,6 +31,7 @@ As expected with a major release, Auth0.swift v3 contains breaking changes. Plea
 - [**API Changes**](#api-changes)
   + [WebAuthError cases](#webautherror-cases)
   + [Renamed APIs](#renamed-apis)
+  + [Request to Requestable](#requestable)
 
 ---
 
@@ -369,5 +370,69 @@ let user: UserProfile = ...
 ```
 </details>
 
+## Request to Requestable 
+
+**Change:** API Clients Authentication, MFAClient, MyAccountAuthenticationMethods have been refactored to return Requestable instead of Request 
+
+**Impact:** With returning Requestable protocol instead of Request, developers can now mock Request in the api clients thus mocking Auth0 layer making writing tests supper easy
+
+**Reason:** With existing Request object it was hard to mock Auth0 SDK layer. Only way to mock was using URLProtocol. With Requestable, developers can mock requests and write tests without heavy lifting of mocking url session layer
+
+**example code**
+
+```swift
+public protocol Authentication {  
+    func login(email: String, code: String, audience: String?, scope: String) -> Requestable  
+}  
+  
+class MockRequestable: Requestable {  
+    typealias ResultType = Credentials  
+    typealias ErrorType = AuthenticationError  
+      
+    let mockResult: Result<Credentials, AuthenticationError>  
+      
+    init(mockResult: Result<Credentials, AuthenticationError>) {  
+        self.mockResult = mockResult  
+    }  
+      
+    func start(_ callback: @escaping (Result<Credentials, AuthenticationError>) -> Void) {  
+        callback(mockResult)  
+    }  
+}  
+  
+class MockAuthentication: Authentication {  
+    let mockRequest: MockRequestable  
+      
+    init(mockResult: Result<Credentials, AuthenticationError>) {  
+        self.mockRequest = MockRequestable(mockResult: mockResult)  
+    }  
+      
+    func login(email: String, code: String, audience: String?, scope: String) -> Requestable {  
+        return mockRequest  
+    }  
+}  
+  
+class ClientAppOrSDK {  
+    private let auth: Authentication  
+      
+    func login(email: String, code: String, completion: @escaping (Result<Credentials, Error>) -> Void) {  
+        let requestable = auth.login(email: email, code: code, audience: nil, scope: "openid profile email")  
+        requestable.start { result in  
+            // Handle result  
+        }  
+    }  
+}  
+  
+func testLoginSuccess() {  
+    let mockCredentials = Credentials(accessToken: "token", tokenType: "Bearer", expiresIn: Date(), idToken: "id_token")  
+    let mockAuth = MockAuthentication(mockResult: .success(mockCredentials))  
+    let apporsdk = ClientAppOrSDK(auth: mockAuth)  
+      
+    apporsdk.login(email: "test@example.com", code: "123456") { result in  
+        // Assert success without network calls  
+        XCTAssertEqual(try? result.get().accessToken, "token")  
+    }  
+}
+```
 ---
 [Go up ⤴](#table-of-contents)