Update unit tests to compile with Xcode 15 (#803)

Widcket · web-flow · commit 83feebb8cc17 · 2023-10-25T15:53:15.000+01:00
diff --git a/Auth0Tests/Matchers.swift b/Auth0Tests/Matchers.swift
@@ -120,7 +120,7 @@ func hasBearerToken(_ token: String) -> HTTPStubsTestBlock {
     return hasHeader("Authorization", value: "Bearer \(token)")
 }
 
-func containItem(withName name: String, value: String? = nil) -> Predicate<[URLQueryItem]> {
+func containItem(withName name: String, value: String? = nil) -> Nimble.Predicate<[URLQueryItem]> {
     return Predicate<[URLQueryItem]>.define("contain item with name <\(name)>") { expression, failureMessage -> PredicateResult in
         guard let items = try expression.evaluate() else { return PredicateResult(status: .doesNotMatch, message: failureMessage) }
         let outcome = items.contains { item -> Bool in
@@ -130,7 +130,7 @@ func containItem(withName name: String, value: String? = nil) -> Predicate<[URLQ
     }
 }
 
-func haveAuthenticationError<T>(code: String, description: String) -> Predicate<AuthenticationResult<T>> {
+func haveAuthenticationError<T>(code: String, description: String) -> Nimble.Predicate<AuthenticationResult<T>> {
     return Predicate<AuthenticationResult<T>>.define("be an error response with code <\(code)> and description <\(description)") { expression, failureMessage -> PredicateResult in
         return try beUnsuccessful(expression, failureMessage) { (error: AuthenticationError) -> Bool in
             return code == error.code && description == error.localizedDescription
@@ -139,7 +139,7 @@ func haveAuthenticationError<T>(code: String, description: String) -> Predicate<
 }
 
 #if WEB_AUTH_PLATFORM
-func haveAuthenticationError<T>(code: String, description: String) -> Predicate<WebAuthResult<T>> {
+func haveAuthenticationError<T>(code: String, description: String) -> Nimble.Predicate<WebAuthResult<T>> {
     return Predicate<WebAuthResult<T>>.define("be an error response with code <\(code)> and description <\(description)") { expression, failureMessage -> PredicateResult in
         return try beUnsuccessful(expression, failureMessage) { (error: WebAuthError) -> Bool in
             guard let cause = error.cause as? AuthenticationError else { return false }
@@ -149,7 +149,7 @@ func haveAuthenticationError<T>(code: String, description: String) -> Predicate<
 }
 #endif
 
-func haveManagementError<T>(_ errorString: String, description: String, code: String, statusCode: Int) -> Predicate<ManagementResult<T>> {
+func haveManagementError<T>(_ errorString: String, description: String, code: String, statusCode: Int) -> Nimble.Predicate<ManagementResult<T>> {
     return Predicate<ManagementResult<T>>.define("be an error response with code <\(code)> and description <\(description)") { expression, failureMessage -> PredicateResult in
         return try beUnsuccessful(expression, failureMessage) { (error: ManagementError) -> Bool in
             return errorString == error.info["error"] as? String
@@ -160,7 +160,7 @@ func haveManagementError<T>(_ errorString: String, description: String, code: St
     }
 }
 
-func haveManagementError<T>(description: String, code: String, statusCode: Int = 0, cause: Error? = nil) -> Predicate<ManagementResult<T>> {
+func haveManagementError<T>(description: String, code: String, statusCode: Int = 0, cause: Error? = nil) -> Nimble.Predicate<ManagementResult<T>> {
     return Predicate<ManagementResult<T>>.define("be an error response with code <\(code)> and description <\(description)") { expression, failureMessage -> PredicateResult in
         return try beUnsuccessful(expression, failureMessage) { (error: ManagementError) -> Bool in
             return code == error.code
@@ -171,7 +171,7 @@ func haveManagementError<T>(description: String, code: String, statusCode: Int =
     }
 }
 
-func haveManagementError<T>(description: String, statusCode: Int) -> Predicate<ManagementResult<T>> {
+func haveManagementError<T>(description: String, statusCode: Int) -> Nimble.Predicate<ManagementResult<T>> {
     return Predicate<ManagementResult<T>>.define("be an error result") { expression, failureMessage -> PredicateResult in
         return try beUnsuccessful(expression, failureMessage) { (error: ManagementError) -> Bool in
             return error.localizedDescription == description && error.statusCode == statusCode
@@ -180,7 +180,7 @@ func haveManagementError<T>(description: String, statusCode: Int) -> Predicate<M
 }
 
 #if WEB_AUTH_PLATFORM
-func haveWebAuthError<T>(_ expected: WebAuthError) -> Predicate<WebAuthResult<T>> {
+func haveWebAuthError<T>(_ expected: WebAuthError) -> Nimble.Predicate<WebAuthResult<T>> {
     return Predicate<WebAuthResult<T>>.define("be an error result") { expression, failureMessage -> PredicateResult in
         return try beUnsuccessful(expression, failureMessage) { (error: WebAuthError) -> Bool in
             return error == expected
@@ -190,7 +190,7 @@ func haveWebAuthError<T>(_ expected: WebAuthError) -> Predicate<WebAuthResult<T>
 }
 #endif
 
-func haveCredentialsManagerError<T>(_ expected: CredentialsManagerError) -> Predicate<CredentialsManagerResult<T>> {
+func haveCredentialsManagerError<T>(_ expected: CredentialsManagerError) -> Nimble.Predicate<CredentialsManagerResult<T>> {
     return Predicate<CredentialsManagerResult<T>>.define("be an error result") { expression, failureMessage -> PredicateResult in
         return try beUnsuccessful(expression, failureMessage) { (error: CredentialsManagerError) -> Bool in
             return error == expected
@@ -199,7 +199,7 @@ func haveCredentialsManagerError<T>(_ expected: CredentialsManagerError) -> Pred
     }
 }
 
-func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) -> Predicate<AuthenticationResult<Credentials>> {
+func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) -> Nimble.Predicate<AuthenticationResult<Credentials>> {
     return Predicate<AuthenticationResult<Credentials>>.define("be a successful authentication result") { expression, failureMessage -> PredicateResult in
         return try haveCredentials(accessToken: accessToken,
                                    idToken: idToken,
@@ -210,7 +210,7 @@ func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) ->
 }
 
 #if WEB_AUTH_PLATFORM
-func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) -> Predicate<WebAuthResult<Credentials>> {
+func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) -> Nimble.Predicate<WebAuthResult<Credentials>> {
     return Predicate<WebAuthResult<Credentials>>.define("be a successful authentication result") { expression, failureMessage -> PredicateResult in
         return try haveCredentials(accessToken: accessToken,
                                    idToken: idToken,
@@ -221,7 +221,7 @@ func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) ->
 }
 #endif
 
-func haveCredentials(_ accessToken: String, _ idToken: String? = nil, _ refreshToken: String? = nil) -> Predicate<CredentialsManagerResult<Credentials>> {
+func haveCredentials(_ accessToken: String, _ idToken: String? = nil, _ refreshToken: String? = nil) -> Nimble.Predicate<CredentialsManagerResult<Credentials>> {
     return Predicate<CredentialsManagerResult<Credentials>>.define("be a successful credentials retrieval") { expression, failureMessage -> PredicateResult in
         return try haveCredentials(accessToken: accessToken,
                                    idToken: idToken,
@@ -231,47 +231,47 @@ func haveCredentials(_ accessToken: String, _ idToken: String? = nil, _ refreshT
     }
 }
 
-func haveCredentials() -> Predicate<CredentialsManagerResult<Credentials>> {
+func haveCredentials() -> Nimble.Predicate<CredentialsManagerResult<Credentials>> {
     return Predicate<CredentialsManagerResult<Credentials>>.define("be a successful credentials retrieval") { expression, failureMessage -> PredicateResult in
         return try beSuccessful(expression, failureMessage)
     }
 }
 
-func haveCreatedUser(_ email: String, username: String? = nil) -> Predicate<AuthenticationResult<DatabaseUser>> {
+func haveCreatedUser(_ email: String, username: String? = nil) -> Nimble.Predicate<AuthenticationResult<DatabaseUser>> {
     return Predicate<AuthenticationResult<DatabaseUser>>.define("have created user with email <\(email)>") { expression, failureMessage -> PredicateResult in
         return try beSuccessful(expression, failureMessage) { (created: DatabaseUser) -> Bool in
             return created.email == email && (username == nil || created.username == username)
         }
     }
 }
 
-func beSuccessful<T>() -> Predicate<AuthenticationResult<T>> {
+func beSuccessful<T>() -> Nimble.Predicate<AuthenticationResult<T>> {
     return Predicate<AuthenticationResult<T>>.define("be a successful result") { expression, failureMessage -> PredicateResult in
         return try beSuccessful(expression, failureMessage)
     }
 }
 
-func beSuccessful<T>() -> Predicate<ManagementResult<T>> {
+func beSuccessful<T>() -> Nimble.Predicate<ManagementResult<T>> {
     return Predicate<ManagementResult<T>>.define("be a successful result") { expression, failureMessage -> PredicateResult in
         return try beSuccessful(expression, failureMessage)
     }
 }
 
 #if WEB_AUTH_PLATFORM
-func beSuccessful<T>() -> Predicate<WebAuthResult<T>> {
+func beSuccessful<T>() -> Nimble.Predicate<WebAuthResult<T>> {
     return Predicate<WebAuthResult<T>>.define("be a successful result") { expression, failureMessage -> PredicateResult in
         return try beSuccessful(expression, failureMessage)
     }
 }
 #endif
 
-func beSuccessful<T>() -> Predicate<CredentialsManagerResult<T>> {
+func beSuccessful<T>() -> Nimble.Predicate<CredentialsManagerResult<T>> {
     return Predicate<CredentialsManagerResult<T>>.define("be a successful result") { expression, failureMessage -> PredicateResult in
         return try beSuccessful(expression, failureMessage)
     }
 }
 
-func beUnsuccessful<T>(_ cause: String? = nil) -> Predicate<AuthenticationResult<T>> {
+func beUnsuccessful<T>(_ cause: String? = nil) -> Nimble.Predicate<AuthenticationResult<T>> {
     return Predicate<AuthenticationResult<T>>.define("be a failure result") { expression, failureMessage -> PredicateResult in
         if let cause = cause {
             _ = failureMessage.appended(message: " with cause \(cause)")
@@ -283,7 +283,7 @@ func beUnsuccessful<T>(_ cause: String? = nil) -> Predicate<AuthenticationResult
 }
 
 #if WEB_AUTH_PLATFORM
-func beUnsuccessful<T>(_ cause: String? = nil) -> Predicate<WebAuthResult<T>> {
+func beUnsuccessful<T>(_ cause: String? = nil) -> Nimble.Predicate<WebAuthResult<T>> {
     return Predicate<WebAuthResult<T>>.define("be a failure result") { expression, failureMessage -> PredicateResult in
         if let cause = cause {
             _ = failureMessage.appended(message: " with cause \(cause)")
@@ -295,20 +295,20 @@ func beUnsuccessful<T>(_ cause: String? = nil) -> Predicate<WebAuthResult<T>> {
 }
 #endif
 
-func beUnsuccessful<T>() -> Predicate<CredentialsManagerResult<T>> {
+func beUnsuccessful<T>() -> Nimble.Predicate<CredentialsManagerResult<T>> {
     return Predicate<CredentialsManagerResult<T>>.define("be a failure result") { expression, failureMessage -> PredicateResult in
         _ = failureMessage.appended(message: " from credentials manager")
         return try beUnsuccessful(expression, failureMessage)
     }
 }
 
-func haveProfile(_ sub: String) -> Predicate<AuthenticationResult<UserInfo>> {
+func haveProfile(_ sub: String) -> Nimble.Predicate<AuthenticationResult<UserInfo>> {
     return Predicate<AuthenticationResult<UserInfo>>.define("have userInfo for sub: <\(sub)>") { expression, failureMessage -> PredicateResult in
         return try beSuccessful(expression, failureMessage) { (userInfo: UserInfo) -> Bool in userInfo.sub == sub }
     }
 }
 
-func haveObjectWithAttributes(_ attributes: [String]) -> Predicate<ManagementResult<[String: Any]>> {
+func haveObjectWithAttributes(_ attributes: [String]) -> Nimble.Predicate<ManagementResult<[String: Any]>> {
     return Predicate<ManagementResult<[String: Any]>>.define("have attributes \(attributes)") { expression, failureMessage -> PredicateResult in
         return try beSuccessful(expression, failureMessage) { (value: [String: Any]) -> Bool in
             return Array(value.keys).reduce(true, { (initial, value) -> Bool in
@@ -318,13 +318,13 @@ func haveObjectWithAttributes(_ attributes: [String]) -> Predicate<ManagementRes
     }
 }
 
-func haveJWKS() -> Predicate<AuthenticationResult<JWKS>> {
+func haveJWKS() -> Nimble.Predicate<AuthenticationResult<JWKS>> {
     return Predicate<AuthenticationResult<JWKS>>.define("have a JWKS object with at least one key") { expression, failureMessage -> PredicateResult in
         return try beSuccessful(expression, failureMessage) { (jwks: JWKS) -> Bool in !jwks.keys.isEmpty }
     }
 }
 
-func beURLSafeBase64() -> Predicate<String> {
+func beURLSafeBase64() -> Nimble.Predicate<String> {
     return Predicate<String>.define("be url safe base64") { expression, failureMessage -> PredicateResult in
         var set = CharacterSet()
         set.formUnion(.alphanumerics)
diff --git a/Auth0Tests/RequestSpec.swift b/Auth0Tests/RequestSpec.swift
@@ -94,10 +94,13 @@ class RequestSpec: QuickSpec {
                     expect(body["foo"] as? String) == "bar"
                 }
 
+                // See https://forums.swift.org/t/url-string-behavior-changed-with-xcode-15-0-beta-5/66570/4
+                #if swift(<5.9)
                 it("should not add the parameters as query parameters when the URL is malformed") {
-                    let request = Request(url: URL(string: "//:foo/bar")!, parameters: ["foo": "bar"])
+                    let request = Request(url: URL(string: "//:invalid/url")!, parameters: ["foo": "bar"])
                    expect(request.request.url?.query).to(beNil())
                 }
+                #endif
             }
 
             context("headers") {

Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ func hasBearerToken(_ token: String) -> HTTPStubsTestBlock {`
`120`	`120`	`return hasHeader("Authorization", value: "Bearer \(token)")`
`121`	`121`	`}`
`122`	`122`
`123`		`-func containItem(withName name: String, value: String? = nil) -> Predicate<[URLQueryItem]> {`
	`123`	`+func containItem(withName name: String, value: String? = nil) -> Nimble.Predicate<[URLQueryItem]> {`
`124`	`124`	`return Predicate<[URLQueryItem]>.define("contain item with name <\(name)>") { expression, failureMessage -> PredicateResult in`
`125`	`125`	`guard let items = try expression.evaluate() else { return PredicateResult(status: .doesNotMatch, message: failureMessage) }`
`126`	`126`	`let outcome = items.contains { item -> Bool in`
`@@ -130,7 +130,7 @@ func containItem(withName name: String, value: String? = nil) -> Predicate<[URLQ`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`		`-func haveAuthenticationError<T>(code: String, description: String) -> Predicate<AuthenticationResult<T>> {`
	`133`	`+func haveAuthenticationError<T>(code: String, description: String) -> Nimble.Predicate<AuthenticationResult<T>> {`
`134`	`134`	`return Predicate<AuthenticationResult<T>>.define("be an error response with code <\(code)> and description <\(description)") { expression, failureMessage -> PredicateResult in`
`135`	`135`	`return try beUnsuccessful(expression, failureMessage) { (error: AuthenticationError) -> Bool in`
`136`	`136`	`return code == error.code && description == error.localizedDescription`
`@@ -139,7 +139,7 @@ func haveAuthenticationError<T>(code: String, description: String) -> Predicate<`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`#if WEB_AUTH_PLATFORM`
`142`		`-func haveAuthenticationError<T>(code: String, description: String) -> Predicate<WebAuthResult<T>> {`
	`142`	`+func haveAuthenticationError<T>(code: String, description: String) -> Nimble.Predicate<WebAuthResult<T>> {`
`143`	`143`	`return Predicate<WebAuthResult<T>>.define("be an error response with code <\(code)> and description <\(description)") { expression, failureMessage -> PredicateResult in`
`144`	`144`	`return try beUnsuccessful(expression, failureMessage) { (error: WebAuthError) -> Bool in`
`145`	`145`	`guard let cause = error.cause as? AuthenticationError else { return false }`
`@@ -149,7 +149,7 @@ func haveAuthenticationError<T>(code: String, description: String) -> Predicate<`
`149`	`149`	`}`
`150`	`150`	`#endif`
`151`	`151`
`152`		`-func haveManagementError<T>(_ errorString: String, description: String, code: String, statusCode: Int) -> Predicate<ManagementResult<T>> {`
	`152`	`+func haveManagementError<T>(_ errorString: String, description: String, code: String, statusCode: Int) -> Nimble.Predicate<ManagementResult<T>> {`
`153`	`153`	`return Predicate<ManagementResult<T>>.define("be an error response with code <\(code)> and description <\(description)") { expression, failureMessage -> PredicateResult in`
`154`	`154`	`return try beUnsuccessful(expression, failureMessage) { (error: ManagementError) -> Bool in`
`155`	`155`	`return errorString == error.info["error"] as? String`
`@@ -160,7 +160,7 @@ func haveManagementError<T>(_ errorString: String, description: String, code: St`
`160`	`160`	`}`
`161`	`161`	`}`
`162`	`162`
`163`		`-func haveManagementError<T>(description: String, code: String, statusCode: Int = 0, cause: Error? = nil) -> Predicate<ManagementResult<T>> {`
	`163`	`+func haveManagementError<T>(description: String, code: String, statusCode: Int = 0, cause: Error? = nil) -> Nimble.Predicate<ManagementResult<T>> {`
`164`	`164`	`return Predicate<ManagementResult<T>>.define("be an error response with code <\(code)> and description <\(description)") { expression, failureMessage -> PredicateResult in`
`165`	`165`	`return try beUnsuccessful(expression, failureMessage) { (error: ManagementError) -> Bool in`
`166`	`166`	`return code == error.code`
`@@ -171,7 +171,7 @@ func haveManagementError<T>(description: String, code: String, statusCode: Int =`
`171`	`171`	`}`
`172`	`172`	`}`
`173`	`173`
`174`		`-func haveManagementError<T>(description: String, statusCode: Int) -> Predicate<ManagementResult<T>> {`
	`174`	`+func haveManagementError<T>(description: String, statusCode: Int) -> Nimble.Predicate<ManagementResult<T>> {`
`175`	`175`	`return Predicate<ManagementResult<T>>.define("be an error result") { expression, failureMessage -> PredicateResult in`
`176`	`176`	`return try beUnsuccessful(expression, failureMessage) { (error: ManagementError) -> Bool in`
`177`	`177`	`return error.localizedDescription == description && error.statusCode == statusCode`
`@@ -180,7 +180,7 @@ func haveManagementError<T>(description: String, statusCode: Int) -> Predicate<M`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`#if WEB_AUTH_PLATFORM`
`183`		`-func haveWebAuthError<T>(_ expected: WebAuthError) -> Predicate<WebAuthResult<T>> {`
	`183`	`+func haveWebAuthError<T>(_ expected: WebAuthError) -> Nimble.Predicate<WebAuthResult<T>> {`
`184`	`184`	`return Predicate<WebAuthResult<T>>.define("be an error result") { expression, failureMessage -> PredicateResult in`
`185`	`185`	`return try beUnsuccessful(expression, failureMessage) { (error: WebAuthError) -> Bool in`
`186`	`186`	`return error == expected`
`@@ -190,7 +190,7 @@ func haveWebAuthError<T>(_ expected: WebAuthError) -> Predicate<WebAuthResult<T>`
`190`	`190`	`}`
`191`	`191`	`#endif`
`192`	`192`
`193`		`-func haveCredentialsManagerError<T>(_ expected: CredentialsManagerError) -> Predicate<CredentialsManagerResult<T>> {`
	`193`	`+func haveCredentialsManagerError<T>(_ expected: CredentialsManagerError) -> Nimble.Predicate<CredentialsManagerResult<T>> {`
`194`	`194`	`return Predicate<CredentialsManagerResult<T>>.define("be an error result") { expression, failureMessage -> PredicateResult in`
`195`	`195`	`return try beUnsuccessful(expression, failureMessage) { (error: CredentialsManagerError) -> Bool in`
`196`	`196`	`return error == expected`
`@@ -199,7 +199,7 @@ func haveCredentialsManagerError<T>(_ expected: CredentialsManagerError) -> Pred`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`
`202`		`-func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) -> Predicate<AuthenticationResult<Credentials>> {`
	`202`	`+func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) -> Nimble.Predicate<AuthenticationResult<Credentials>> {`
`203`	`203`	`return Predicate<AuthenticationResult<Credentials>>.define("be a successful authentication result") { expression, failureMessage -> PredicateResult in`
`204`	`204`	`return try haveCredentials(accessToken: accessToken,`
`205`	`205`	`idToken: idToken,`
`@@ -210,7 +210,7 @@ func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) ->`
`210`	`210`	`}`
`211`	`211`
`212`	`212`	`#if WEB_AUTH_PLATFORM`
`213`		`-func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) -> Predicate<WebAuthResult<Credentials>> {`
	`213`	`+func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) -> Nimble.Predicate<WebAuthResult<Credentials>> {`
`214`	`214`	`return Predicate<WebAuthResult<Credentials>>.define("be a successful authentication result") { expression, failureMessage -> PredicateResult in`
`215`	`215`	`return try haveCredentials(accessToken: accessToken,`
`216`	`216`	`idToken: idToken,`
`@@ -221,7 +221,7 @@ func haveCredentials(_ accessToken: String? = nil, _ idToken: String? = nil) ->`
`221`	`221`	`}`
`222`	`222`	`#endif`
`223`	`223`
`224`		`-func haveCredentials(_ accessToken: String, _ idToken: String? = nil, _ refreshToken: String? = nil) -> Predicate<CredentialsManagerResult<Credentials>> {`
	`224`	`+func haveCredentials(_ accessToken: String, _ idToken: String? = nil, _ refreshToken: String? = nil) -> Nimble.Predicate<CredentialsManagerResult<Credentials>> {`
`225`	`225`	`return Predicate<CredentialsManagerResult<Credentials>>.define("be a successful credentials retrieval") { expression, failureMessage -> PredicateResult in`
`226`	`226`	`return try haveCredentials(accessToken: accessToken,`
`227`	`227`	`idToken: idToken,`
`@@ -231,47 +231,47 @@ func haveCredentials(_ accessToken: String, _ idToken: String? = nil, _ refreshT`
`231`	`231`	`}`
`232`	`232`	`}`
`233`	`233`
`234`		`-func haveCredentials() -> Predicate<CredentialsManagerResult<Credentials>> {`
	`234`	`+func haveCredentials() -> Nimble.Predicate<CredentialsManagerResult<Credentials>> {`
`235`	`235`	`return Predicate<CredentialsManagerResult<Credentials>>.define("be a successful credentials retrieval") { expression, failureMessage -> PredicateResult in`
`236`	`236`	`return try beSuccessful(expression, failureMessage)`
`237`	`237`	`}`
`238`	`238`	`}`
`239`	`239`
`240`		`-func haveCreatedUser(_ email: String, username: String? = nil) -> Predicate<AuthenticationResult<DatabaseUser>> {`
	`240`	`+func haveCreatedUser(_ email: String, username: String? = nil) -> Nimble.Predicate<AuthenticationResult<DatabaseUser>> {`
`241`	`241`	`return Predicate<AuthenticationResult<DatabaseUser>>.define("have created user with email <\(email)>") { expression, failureMessage -> PredicateResult in`
`242`	`242`	`return try beSuccessful(expression, failureMessage) { (created: DatabaseUser) -> Bool in`
`243`	`243`	`return created.email == email && (username == nil \|\| created.username == username)`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`	`}`
`247`	`247`
`248`		`-func beSuccessful<T>() -> Predicate<AuthenticationResult<T>> {`
	`248`	`+func beSuccessful<T>() -> Nimble.Predicate<AuthenticationResult<T>> {`
`249`	`249`	`return Predicate<AuthenticationResult<T>>.define("be a successful result") { expression, failureMessage -> PredicateResult in`
`250`	`250`	`return try beSuccessful(expression, failureMessage)`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`
`254`		`-func beSuccessful<T>() -> Predicate<ManagementResult<T>> {`
	`254`	`+func beSuccessful<T>() -> Nimble.Predicate<ManagementResult<T>> {`
`255`	`255`	`return Predicate<ManagementResult<T>>.define("be a successful result") { expression, failureMessage -> PredicateResult in`
`256`	`256`	`return try beSuccessful(expression, failureMessage)`
`257`	`257`	`}`
`258`	`258`	`}`
`259`	`259`
`260`	`260`	`#if WEB_AUTH_PLATFORM`
`261`		`-func beSuccessful<T>() -> Predicate<WebAuthResult<T>> {`
	`261`	`+func beSuccessful<T>() -> Nimble.Predicate<WebAuthResult<T>> {`
`262`	`262`	`return Predicate<WebAuthResult<T>>.define("be a successful result") { expression, failureMessage -> PredicateResult in`
`263`	`263`	`return try beSuccessful(expression, failureMessage)`
`264`	`264`	`}`
`265`	`265`	`}`
`266`	`266`	`#endif`
`267`	`267`
`268`		`-func beSuccessful<T>() -> Predicate<CredentialsManagerResult<T>> {`
	`268`	`+func beSuccessful<T>() -> Nimble.Predicate<CredentialsManagerResult<T>> {`
`269`	`269`	`return Predicate<CredentialsManagerResult<T>>.define("be a successful result") { expression, failureMessage -> PredicateResult in`
`270`	`270`	`return try beSuccessful(expression, failureMessage)`
`271`	`271`	`}`
`272`	`272`	`}`
`273`	`273`
`274`		`-func beUnsuccessful<T>(_ cause: String? = nil) -> Predicate<AuthenticationResult<T>> {`
	`274`	`+func beUnsuccessful<T>(_ cause: String? = nil) -> Nimble.Predicate<AuthenticationResult<T>> {`
`275`	`275`	`return Predicate<AuthenticationResult<T>>.define("be a failure result") { expression, failureMessage -> PredicateResult in`
`276`	`276`	`if let cause = cause {`
`277`	`277`	`_ = failureMessage.appended(message: " with cause \(cause)")`
`@@ -283,7 +283,7 @@ func beUnsuccessful<T>(_ cause: String? = nil) -> Predicate<AuthenticationResult`
`283`	`283`	`}`
`284`	`284`
`285`	`285`	`#if WEB_AUTH_PLATFORM`
`286`		`-func beUnsuccessful<T>(_ cause: String? = nil) -> Predicate<WebAuthResult<T>> {`
	`286`	`+func beUnsuccessful<T>(_ cause: String? = nil) -> Nimble.Predicate<WebAuthResult<T>> {`
`287`	`287`	`return Predicate<WebAuthResult<T>>.define("be a failure result") { expression, failureMessage -> PredicateResult in`
`288`	`288`	`if let cause = cause {`
`289`	`289`	`_ = failureMessage.appended(message: " with cause \(cause)")`
`@@ -295,20 +295,20 @@ func beUnsuccessful<T>(_ cause: String? = nil) -> Predicate<WebAuthResult<T>> {`
`295`	`295`	`}`
`296`	`296`	`#endif`
`297`	`297`
`298`		`-func beUnsuccessful<T>() -> Predicate<CredentialsManagerResult<T>> {`
	`298`	`+func beUnsuccessful<T>() -> Nimble.Predicate<CredentialsManagerResult<T>> {`
`299`	`299`	`return Predicate<CredentialsManagerResult<T>>.define("be a failure result") { expression, failureMessage -> PredicateResult in`
`300`	`300`	`_ = failureMessage.appended(message: " from credentials manager")`
`301`	`301`	`return try beUnsuccessful(expression, failureMessage)`
`302`	`302`	`}`
`303`	`303`	`}`
`304`	`304`
`305`		`-func haveProfile(_ sub: String) -> Predicate<AuthenticationResult<UserInfo>> {`
	`305`	`+func haveProfile(_ sub: String) -> Nimble.Predicate<AuthenticationResult<UserInfo>> {`
`306`	`306`	`return Predicate<AuthenticationResult<UserInfo>>.define("have userInfo for sub: <\(sub)>") { expression, failureMessage -> PredicateResult in`
`307`	`307`	`return try beSuccessful(expression, failureMessage) { (userInfo: UserInfo) -> Bool in userInfo.sub == sub }`
`308`	`308`	`}`
`309`	`309`	`}`
`310`	`310`
`311`		`-func haveObjectWithAttributes(_ attributes: [String]) -> Predicate<ManagementResult<[String: Any]>> {`
	`311`	`+func haveObjectWithAttributes(_ attributes: [String]) -> Nimble.Predicate<ManagementResult<[String: Any]>> {`
`312`	`312`	`return Predicate<ManagementResult<[String: Any]>>.define("have attributes \(attributes)") { expression, failureMessage -> PredicateResult in`
`313`	`313`	`return try beSuccessful(expression, failureMessage) { (value: [String: Any]) -> Bool in`
`314`	`314`	`return Array(value.keys).reduce(true, { (initial, value) -> Bool in`
`@@ -318,13 +318,13 @@ func haveObjectWithAttributes(_ attributes: [String]) -> Predicate<ManagementRes`
`318`	`318`	`}`
`319`	`319`	`}`
`320`	`320`
`321`		`-func haveJWKS() -> Predicate<AuthenticationResult<JWKS>> {`
	`321`	`+func haveJWKS() -> Nimble.Predicate<AuthenticationResult<JWKS>> {`
`322`	`322`	`return Predicate<AuthenticationResult<JWKS>>.define("have a JWKS object with at least one key") { expression, failureMessage -> PredicateResult in`
`323`	`323`	`return try beSuccessful(expression, failureMessage) { (jwks: JWKS) -> Bool in !jwks.keys.isEmpty }`
`324`	`324`	`}`
`325`	`325`	`}`
`326`	`326`
`327`		`-func beURLSafeBase64() -> Predicate<String> {`
	`327`	`+func beURLSafeBase64() -> Nimble.Predicate<String> {`
`328`	`328`	`return Predicate<String>.define("be url safe base64") { expression, failureMessage -> PredicateResult in`
`329`	`329`	`var set = CharacterSet()`
`330`	`330`	`set.formUnion(.alphanumerics)`
Original file line number	Diff line number	Diff line change
`@@ -94,10 +94,13 @@ class RequestSpec: QuickSpec {`
`94`	`94`	`expect(body["foo"] as? String) == "bar"`
`95`	`95`	`}`
`96`	`96`
	`97`	`+ // See https://forums.swift.org/t/url-string-behavior-changed-with-xcode-15-0-beta-5/66570/4`
	`98`	`+ #if swift(<5.9)`
`97`	`99`	`it("should not add the parameters as query parameters when the URL is malformed") {`
`98`		`- let request = Request(url: URL(string: "//:foo/bar")!, parameters: ["foo": "bar"])`
	`100`	`+ let request = Request(url: URL(string: "//:invalid/url")!, parameters: ["foo": "bar"])`
`99`	`101`	`expect(request.request.url?.query).to(beNil())`
`100`	`102`	`}`
	`103`	`+ #endif`
`101`	`104`	`}`
`102`	`105`
`103`	`106`	`context("headers") {`