javier
b14a9fa816
This PR contains the work done to improve the documentation efforts in the package, aiming at improving the documentation of the source code as well as the OpenAPI specification document. In addition, a breaking bug has been fixed. Reviewed-on: #16 Co-authored-by: Javier Cicchelli <javier@rock-n-code.com> Co-committed-by: Javier Cicchelli <javier@rock-n-code.com>
465 lines
15 KiB
Swift
465 lines
15 KiB
Swift
// ===----------------------------------------------------------------------===
|
|
//
|
|
// This source file is part of the DiscogsService open source project
|
|
//
|
|
// Copyright (c) 2026 Röck+Cöde VoF. and the DiscogsService project authors
|
|
// Licensed under Apache license v2.0
|
|
//
|
|
// See LICENSE for license information
|
|
// See CONTRIBUTORS for the list of DiscogsService project authors
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
// ===----------------------------------------------------------------------===
|
|
|
|
import struct Foundation.URL
|
|
import struct Foundation.URLComponents
|
|
import struct Foundation.URLQueryItem
|
|
import struct HTTPTypes.HTTPFields
|
|
import struct HTTPTypes.HTTPRequest
|
|
import struct HTTPTypes.HTTPResponse
|
|
|
|
import Testing
|
|
|
|
@testable import DiscogsService
|
|
|
|
@Suite("Auth Middleware", .tags(.middleware))
|
|
struct AuthMiddlewareTests {
|
|
|
|
// MARK: Initializers tests
|
|
|
|
#if swift(>=6.2)
|
|
@Test(arguments: Input.authMethods)
|
|
func `initialize`(
|
|
_ authMethod: AuthMethod
|
|
) async throws {
|
|
try assertInit(
|
|
authMethod: authMethod,
|
|
authTransport: try randomTransport
|
|
)
|
|
}
|
|
|
|
@Test(arguments: zip(
|
|
Input.authMethodsThrows,
|
|
Output.authMethodsThrows
|
|
))
|
|
func `initialize throws`(
|
|
_ authMethod: AuthMethod,
|
|
expects error: InputValidationError?
|
|
) async throws {
|
|
try assertInitThrows(
|
|
authMethod: authMethod,
|
|
authTransport: try randomTransport,
|
|
expects: error
|
|
)
|
|
}
|
|
#else
|
|
@Test("initialize", arguments: Input.authMethods)
|
|
func initialize(
|
|
_ authMethod: AuthMethod
|
|
) throws {
|
|
try assertInit(
|
|
authMethod: authMethod,
|
|
authTransport: try randomTransport
|
|
)
|
|
}
|
|
|
|
@Test("initialize throws", arguments: zip(
|
|
Input.authMethodsThrows,
|
|
Output.authMethodsThrows
|
|
))
|
|
func initializeThrows(
|
|
_ authMethod: AuthMethod,
|
|
expects error: InputValidationError?
|
|
) throws {
|
|
assertInitThrows(
|
|
authMethod: authMethod,
|
|
authTransport: try randomTransport,
|
|
expects: error
|
|
)
|
|
}
|
|
#endif
|
|
|
|
// MARK: Properties tests
|
|
#if swift(>=6.2)
|
|
@Test(arguments: zip(
|
|
Input.authMethods,
|
|
Output.authMethodsShouldAuthenticate
|
|
))
|
|
func `should authenticate`(
|
|
_ authMethod: AuthMethod,
|
|
expects flag: Bool
|
|
) throws {
|
|
try assertShouldAuthenticate(
|
|
authMethod: authMethod,
|
|
authTransport: try randomTransport,
|
|
expects: flag
|
|
)
|
|
}
|
|
#else
|
|
@Test("should authenticate", arguments: zip(
|
|
Input.authMethods,
|
|
Output.authMethodsShouldAuthenticate
|
|
))
|
|
func shouldAuthenticate(
|
|
_ authMethod: AuthMethod,
|
|
expects flag: Bool
|
|
) throws {
|
|
try assertShouldAuthenticate(
|
|
authMethod: authMethod,
|
|
authTransport: try randomTransport,
|
|
expects: flag
|
|
)
|
|
}
|
|
#endif
|
|
|
|
// MARK: Functions tests
|
|
|
|
#if swift(>=6.2)
|
|
@Test(arguments: Input.authMethods)
|
|
func `intercept with authorization on header`(
|
|
_ authMethod: AuthMethod
|
|
) async throws {
|
|
try await assertIntercept(
|
|
authMethod: authMethod,
|
|
authTransport: .onHeader,
|
|
path: "/some/path/to/resource"
|
|
)
|
|
}
|
|
|
|
@Test(arguments: Input.authMethods)
|
|
func `intercept with authorization on query`(
|
|
_ authMethod: AuthMethod
|
|
) async throws {
|
|
try await assertIntercept(
|
|
authMethod: authMethod,
|
|
authTransport: .onQuery,
|
|
path: "/some/path/to/resource"
|
|
)
|
|
}
|
|
|
|
@Test(arguments: Input.authMethods)
|
|
func `intercept with authorization on header when headers populated`(
|
|
_ authMethod: AuthMethod
|
|
) async throws {
|
|
try await assertIntercept(
|
|
authMethod: authMethod,
|
|
authTransport: .onHeader,
|
|
path: "/some/path/to/resource",
|
|
headerFields: [.accept: "*/*"]
|
|
)
|
|
}
|
|
|
|
@Test(arguments: Input.authMethods)
|
|
func `intercept with authorization on query when query is populated`(
|
|
_ authMethod: AuthMethod
|
|
) async throws {
|
|
try await assertIntercept(
|
|
authMethod: authMethod,
|
|
authTransport: .onQuery,
|
|
path: "/some/path/to/resource?key=value"
|
|
)
|
|
}
|
|
#else
|
|
@Test("intercept with authorization on header", arguments: Input.authMethods)
|
|
func intercept_withAuthOnHeader(
|
|
_ authMethod: AuthMethod
|
|
) async throws {
|
|
try await assertIntercept(
|
|
authMethod: authMethod,
|
|
authTransport: .onHeader,
|
|
path: "/some/path/to/resource"
|
|
)
|
|
}
|
|
|
|
@Test("intercept with authorization on query", arguments: Input.authMethods)
|
|
func intercept_withAuthOnQuery(
|
|
_ authMethod: AuthMethod
|
|
) async throws {
|
|
try await assertIntercept(
|
|
authMethod: authMethod,
|
|
authTransport: .onQuery,
|
|
path: "/some/path/to/resource"
|
|
)
|
|
}
|
|
|
|
@Test(
|
|
"intercept with authorization on header when headers are populated",
|
|
arguments: Input.authMethods
|
|
)
|
|
func intercept_withAuthOnHeader_whenHeadersPopulated(
|
|
_ authMethod: AuthMethod
|
|
) async throws {
|
|
try await assertIntercept(
|
|
authMethod: authMethod,
|
|
authTransport: .onHeader,
|
|
path: "/some/path/to/resource",
|
|
headerFields: [.accept: "*/*"]
|
|
)
|
|
}
|
|
|
|
@Test(
|
|
"intercept with authorization on query when query is populated",
|
|
arguments: Input.authMethods
|
|
)
|
|
func intercept_withAuthOnQuery_whenQueryPopulated(
|
|
_ authMethod: AuthMethod
|
|
) async throws {
|
|
try await assertIntercept(
|
|
authMethod: authMethod,
|
|
authTransport: .onQuery,
|
|
path: "/some/path/to/resource?key=value"
|
|
)
|
|
}
|
|
#endif
|
|
|
|
|
|
}
|
|
|
|
// MARK: - Assertions
|
|
|
|
private extension AuthMiddlewareTests {
|
|
|
|
// MARK: Functions
|
|
|
|
/// Asserts the initialization of the middleware, especially the assignment of its properties.
|
|
/// - Parameters:
|
|
/// - authMethod: A representation of an authentication method.
|
|
/// - authTransport: A representation of an authentication transport.
|
|
/// - Throws: an error of type ``InputValidationError`` in case of an unexpected error occurs while running test cases.
|
|
func assertInit(
|
|
authMethod: AuthMethod,
|
|
authTransport: AuthTransport,
|
|
) throws {
|
|
// GIVEN
|
|
// WHEN
|
|
let middleware = try AuthMiddleware(
|
|
method: authMethod,
|
|
transport: authTransport
|
|
)
|
|
|
|
// THEN
|
|
switch (authMethod, authTransport) {
|
|
case let (.consumer(key, secret), .onHeader):
|
|
#expect(middleware.authItems == nil)
|
|
#expect(middleware.authField == .init(
|
|
name: .authorization,
|
|
value: "Discogs \(String.Parameter.key)=\(key), \(String.Parameter.secret)=\(secret)"
|
|
))
|
|
|
|
case let (.consumer(key, secret), .onQuery):
|
|
#expect(middleware.authField == nil)
|
|
#expect(middleware.authItems == [
|
|
.init(name: .Parameter.key, value: key),
|
|
.init(name: .Parameter.secret, value: secret)
|
|
])
|
|
|
|
case let (.user(token), .onHeader):
|
|
#expect(middleware.authItems == nil)
|
|
#expect(middleware.authField == .init(
|
|
name: .authorization,
|
|
value: "Discogs \(String.Parameter.token)=\(token)"
|
|
))
|
|
|
|
case let (.user(token), .onQuery):
|
|
#expect(middleware.authField == nil)
|
|
#expect(middleware.authItems == [
|
|
.init(name: .Parameter.token, value: token)
|
|
])
|
|
|
|
case (.none, _):
|
|
#expect(middleware.authField == nil)
|
|
#expect(middleware.authItems == nil)
|
|
}
|
|
}
|
|
|
|
/// Asserts the error throwing (if justified) during the initialization of a middleware.
|
|
/// - Parameters:
|
|
/// - authMethod: A representation of an authentication method.
|
|
/// - authTransport: A representation of an authentication transport.
|
|
/// - error: An expected error of type ``InputValidationError`` during the initialization of a middleware.
|
|
func assertInitThrows(
|
|
authMethod: AuthMethod,
|
|
authTransport: AuthTransport,
|
|
expects error: InputValidationError?
|
|
) {
|
|
// GIVEN
|
|
// WHEN
|
|
// THEN
|
|
if let error {
|
|
#expect(throws: error) {
|
|
try AuthMiddleware(
|
|
method: authMethod,
|
|
transport: authTransport
|
|
)
|
|
}
|
|
} else {
|
|
#expect(throws: Never.self) {
|
|
try AuthMiddleware(
|
|
method: authMethod,
|
|
transport: authTransport
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Asserts the interception of a request to add its authentication.
|
|
/// - Parameters:
|
|
/// - authMethod: A representation of an authentication method.
|
|
/// - authTransport: A representation of an authentication transport.
|
|
/// - path: A URI path for a request.
|
|
/// - headerFields: A set of header fields for a request.
|
|
/// - Throws:An error in case of an unexpected issue encountered while running a test case.
|
|
func assertIntercept(
|
|
authMethod: AuthMethod,
|
|
authTransport: AuthTransport,
|
|
path: String,
|
|
headerFields: HTTPFields = [:],
|
|
) async throws {
|
|
// GIVEN
|
|
let middleware = try AuthMiddleware(
|
|
method: authMethod,
|
|
transport: authTransport
|
|
)
|
|
let request = HTTPRequest(
|
|
path: path,
|
|
headerFields: headerFields
|
|
)
|
|
|
|
// WHEN
|
|
_ = try await confirmation { confirmation in
|
|
try await middleware.intercept(
|
|
request,
|
|
body: nil,
|
|
baseURL: .Sample.baseURL,
|
|
operationID: .Sample.operationId
|
|
) { request, _, _ in
|
|
// THEN
|
|
switch (authMethod, authTransport) {
|
|
case (.consumer, .onHeader):
|
|
#expect(request.path == path)
|
|
#expect(request.headerFields != headerFields)
|
|
#expect(request.headerFields.contains(where: { $0.name == .authorization }))
|
|
|
|
case (.consumer, .onQuery):
|
|
#expect(request.headerFields == headerFields)
|
|
try assertAuthInPath(request.path, authMethod)
|
|
|
|
case (.user, .onHeader):
|
|
#expect(request.path == path)
|
|
#expect(request.headerFields != headerFields)
|
|
#expect(request.headerFields.contains(where: { $0.name == .authorization }))
|
|
|
|
case (.user, .onQuery):
|
|
#expect(request.headerFields == headerFields)
|
|
try assertAuthInPath(request.path, authMethod)
|
|
|
|
case (.none, _):
|
|
#expect(request.path == path)
|
|
#expect(request.headerFields == headerFields)
|
|
}
|
|
|
|
confirmation()
|
|
|
|
return (.init(status: .ok) , nil)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Asserts the value of `shouldAuthenticate` flag after an initialization of a middleware.
|
|
/// - Parameters:
|
|
/// - authMethod: A representation of an authentication method.
|
|
/// - authTransport: A representation of an authentication transport.
|
|
/// - flag: An expected flag that indicates whether the middleware should authenticate its requests or not.
|
|
/// - Throws: An error of type ``InputValidationError`` in case of an unexpected issue occurs while running test cases.
|
|
func assertShouldAuthenticate(
|
|
authMethod: AuthMethod,
|
|
authTransport: AuthTransport,
|
|
expects flag: Bool
|
|
) throws {
|
|
// GIVEN
|
|
// WHEN
|
|
let middleware = try AuthMiddleware(
|
|
method: authMethod,
|
|
transport: authTransport
|
|
)
|
|
|
|
// THEN
|
|
#expect(middleware.shouldAuthenticate == flag)
|
|
}
|
|
|
|
/// Asserts a request path to contain authentication parameters in its query.
|
|
/// - Parameters:
|
|
/// - path: A request path
|
|
/// - authMethod: A representation of an authentication method.
|
|
/// - Throws:An error in case of an unexpected issue encountered while unwrapping the optionals.
|
|
func assertAuthInPath(
|
|
_ path: String?,
|
|
_ authMethod: AuthMethod
|
|
) throws {
|
|
let pathRequest = try #require(path)
|
|
let urlComponents = try #require(URLComponents(string: pathRequest))
|
|
let queryItems = try #require(urlComponents.queryItems)
|
|
|
|
switch authMethod {
|
|
case .consumer:
|
|
#expect(queryItems.count >= 2)
|
|
#expect(queryItems.contains(where: { $0.name == .Parameter.key }))
|
|
#expect(queryItems.contains(where: { $0.name == .Parameter.secret }))
|
|
case .user:
|
|
#expect(queryItems.count >= 1)
|
|
#expect(queryItems.contains(where: { $0.name == .Parameter.token }))
|
|
case .none: break
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: - Helpers
|
|
|
|
private extension AuthMiddlewareTests {
|
|
|
|
// MARK: Properties
|
|
|
|
/// Provides a random authentication transport representation.
|
|
var randomTransport: AuthTransport {
|
|
get throws {
|
|
try #require(AuthTransport.allCases.randomElement())
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// MARK: - Constants
|
|
|
|
private extension Input {
|
|
/// A list of authentication methods to use in most of the test cases.
|
|
static let authMethods: [AuthMethod] = [
|
|
.consumer(key: "aAbBcCdDeEfFgGhHiIjJ", secret: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP"),
|
|
.user(token: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStT"),
|
|
.none
|
|
]
|
|
/// A list of authentication methods to use in the initialization throw test cases.
|
|
static let authMethodsThrows: [AuthMethod] = authMethods + [
|
|
.consumer(key: .empty, secret: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP"),
|
|
.consumer(key: "aAbBcCdDeEfFgGhHiI", secret: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP"),
|
|
.consumer(key: "aAbBcCdDeEfFgGhHiIjJkK", secret: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP"),
|
|
.consumer(key: "a4bBcCdDe3fFg6hH1Ij7", secret: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP"),
|
|
.consumer(key: "aAbBcCdDeEfFgGhHiIjJ", secret: .empty),
|
|
.consumer(key: "aAbBcCdDeEfFgGhHiIjJ", secret: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoO"),
|
|
.consumer(key: "aAbBcCdDeEfFgGhHiIjJ", secret: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQ"),
|
|
.consumer(key: "aAbBcCdDeEfFgGhHiIjJ", secret: "a4bBcCdDe3fFg6hH1IjJkK1LmMnNo0p9"),
|
|
.user(token: .empty),
|
|
.user(token: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsS"),
|
|
.user(token: "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuU"),
|
|
.user(token: "a4bBcCdDe3fFg6hH1IjJkK1LmMnNo0p9qQrRs5t7"),
|
|
]
|
|
}
|
|
|
|
private extension Output {
|
|
/// A list of expected input validation errors (if thrown) coming from the initialization throw test cases.
|
|
static let authMethodsThrows: [InputValidationError?] = [nil, nil, nil, .inputIsEmpty, .inputNotConsumerKey, .inputNotConsumerKey, .inputNotConsumerKey, .inputIsEmpty, .inputNotConsumerSecret, .inputNotConsumerSecret, .inputNotConsumerSecret, .inputIsEmpty, .inputNotUserToken, .inputNotUserToken, .inputNotUserToken]
|
|
/// A list of expected boolean flags coming from the should authenticate test cases.
|
|
static let authMethodsShouldAuthenticate: [Bool] = [true, true, false]
|
|
}
|