From c2ab60a5aa0cc06413adcbcaa781cef7a3b164ef Mon Sep 17 00:00:00 2001 From: Javier Cicchelli Date: Sun, 12 Oct 2025 19:15:26 +0200 Subject: [PATCH] Fixed an issue with the way the regex pattern was generated for the SecureValidationRule type in the library target. --- .../SecureValidationRule.swift | 4 +- .../Use Cases/ValidateInputUesCaseTests.swift | 156 ++++++++++++++++-- 2 files changed, 146 insertions(+), 14 deletions(-) diff --git a/Sources/DiscogsService/Internal/Validation Rules/SecureValidationRule.swift b/Sources/DiscogsService/Internal/Validation Rules/SecureValidationRule.swift index e19873465..354b759a3 100644 --- a/Sources/DiscogsService/Internal/Validation Rules/SecureValidationRule.swift +++ b/Sources/DiscogsService/Internal/Validation Rules/SecureValidationRule.swift @@ -81,7 +81,7 @@ private extension SecureValidationRule { /// - Parameter input: An input to validate. /// - Returns: A flag that indicates whether a given input is valid or not. func isValid(_ input: String) -> Bool { - let regexPattern: String = .init(format: .Pattern.securityInput, inputType.rawValue) + let regexPattern = String(format: .Pattern.securityInput, inputType.rawValue) do { if #available(macOS 13.0, iOS 16.0, tvOS 16.0, watchOS 6.0, *) { @@ -131,5 +131,5 @@ private extension SecureValidationRule { private extension String.Pattern { /// A regular expression pattern to match the security inputs against. - static let securityInput = "^([a-z]|[A-Z]){%@}$" + static let securityInput = "^([a-z]|[A-Z]){%d}$" } diff --git a/Tests/DiscogsService/Cases/Internal/Use Cases/ValidateInputUesCaseTests.swift b/Tests/DiscogsService/Cases/Internal/Use Cases/ValidateInputUesCaseTests.swift index 631fd12ff..65689b18c 100644 --- a/Tests/DiscogsService/Cases/Internal/Use Cases/ValidateInputUesCaseTests.swift +++ b/Tests/DiscogsService/Cases/Internal/Use Cases/ValidateInputUesCaseTests.swift @@ -23,26 +23,140 @@ struct ValidateInputUseCaseTests { #if swift(>=6.2) @Test(arguments: zip( - Input.inputsToValidate, - Output.inputsToValidate - )) func `validate`( + Input.inputsNotEmpty, + Output.inputsNotEmpty + )) func `validates not empty`( + input: String, + expects error: InputValidationError? + ) async throws { + try assertValidate( + rule: .notEmpty, + input: input, + expects: error + ) + } + + @Test(arguments: zip( + Input.inputsNotNil, + Output.inputsNotNil + )) func `validate not nil`( input: String?, expects error: InputValidationError? ) async throws { try assertValidate( + rule: .notNil, + input: input, + expects: error + ) + } + + @Test(arguments: zip( + Input.inputsSecureConsumerKey, + Output.inputsSecureConsumerKey + )) func `validate secure (consumer key)`( + input: String?, + expects error: InputValidationError? + ) async throws { + try assertValidate( + rule: .secure(.consumerKey), + input: input, + expects: error + ) + } + + @Test(arguments: zip( + Input.inputsSecureConsumerSecret, + Output.inputsSecureConsumerSecret + )) func `validate secure (consumer secret)`( + input: String?, + expects error: InputValidationError? + ) async throws { + try assertValidate( + rule: .secure(.consumerSecret), + input: input, + expects: error + ) + } + + @Test(arguments: zip( + Input.inputsSecureUserToken, + Output.inputsSecureUserToken + )) func `validate secure (user token)`( + input: String?, + expects error: InputValidationError? + ) async throws { + try assertValidate( + rule: .secure(.userToken), input: input, expects: error ) } #else - @Test("validate", arguments: zip( - Input.inputsToValidate, - Output.inputsToValidate - )) func validate( + @Test("validate not empty", arguments: zip( + Input.inputsNotEmpty, + Output.inputsNotEmpty + )) func validateNotEmpty( + input: String, + expects error: InputValidationError? + ) async throws { + try assertValidate( + rule: .notEmpty, + input: input, + expects: error + ) + } + + @Test("validate not nil", arguments: zip( + Input.inputsNotNil, + Output.inputsNotNil + )) func validateNotNil( input: String?, expects error: InputValidationError? ) async throws { try assertValidate( + rule: .notNil, + input: input, + expects: error + ) + } + + @Test("validate secure (consumer key)", arguments: zip( + Input.inputsSecureConsumerKey, + Output.inputsSecureConsumerKey + )) func validateSecureConsumerKey( + input: String?, + expects error: InputValidationError? + ) async throws { + try assertValidate( + rule: .secure(.consumerKey), + input: input, + expects: error + ) + } + + @Test("validate secure (consumer secret)", arguments: zip( + Input.inputsSecureConsumerSecret, + Output.inputsSecureConsumerSecret + )) func validateSecureConsumerSecret( + input: String?, + expects error: InputValidationError? + ) async throws { + try assertValidate( + rule: .secure(.consumerSecret), + input: input, + expects: error + ) + } + + @Test("validate secure (user token)", arguments: zip( + Input.inputsSecureUserToken, + Output.inputsSecureUserToken + )) func validateSecureUserToken( + input: String?, + expects error: InputValidationError? + ) async throws { + try assertValidate( + rule: .secure(.userToken), input: input, expects: error ) @@ -59,15 +173,17 @@ private extension ValidateInputUseCaseTests { /// Asserts an input validation of a ``ValidateInputUseCase`` use case. /// - Parameters: + /// - rule: A validation rule to test. /// - input: An input to validate, if any. /// - error: An expected error, if any. /// - Throws: An error of type ``InputValidationError`` in case of an unexpected test case scenario. func assertValidate( + rule: InputValidationRule, input: String?, expects error: InputValidationError? ) throws { // GIVEN - let validate = ValidateInputUseCase(rules: .notNil, .notEmpty) + let validate = ValidateInputUseCase(rules: rule) // WHEN // THEN @@ -87,11 +203,27 @@ private extension ValidateInputUseCaseTests { // MARK: - Constants private extension Input { - /// A list of inputs to validate against a set of validation rules. - static let inputsToValidate: [String?] = [nil, .empty, "SomeInput"] + /// A list of inputs to validate against the not empty validation rule. + static let inputsNotEmpty: [String] = ["Something", .empty] + /// A list of inputs to validate against the not nil validation rule. + static let inputsNotNil: [String?] = [.empty, nil] + /// A list of inputs to validate against the secure (consumer key) validation rule. + static let inputsSecureConsumerKey: [String] = ["aAbBcCdDeEfFgGhHiIjJ", "aAbBcCdDeEfFgGhH", "aAbBcCdDeEfFgGhHiIjJkK", "a4bBcCdDe3fFg6hH1Ij7"] + /// A list of inputs to validate against the secure (consumer secret) validation rule. + static let inputsSecureConsumerSecret: [String] = ["aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpP", "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoO", "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQ", "a4bBcCdDe3fFg6hH1IjJkK1LmMnNo0p9"] + /// A list of inputs to validate against the secure (user token) validation rule. + static let inputsSecureUserToken: [String] = ["aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStT", "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsS", "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuU", "a4bBcCdDe3fFg6hH1IjJkK1LmMnNo0p9qQrRs5t7"] } private extension Output { - /// A list of expected input validation errors to be thrown (if necessary). - static let inputsToValidate: [InputValidationError?] = [.inputIsNil, .inputIsEmpty, nil] + /// A list of expected input validation errors to be thrown after validating inputs against the not empty validation rule. + static let inputsNotEmpty: [InputValidationError?] = [nil, .inputIsEmpty] + /// A list of expected input validation errors to be thrown after validating inputs against the not nil validation rule. + static let inputsNotNil: [InputValidationError?] = [nil, .inputIsNil] + /// A list of expected input validation errors to be thrown after validating inputs against the secure (consumer key) validation rule. + static let inputsSecureConsumerKey: [InputValidationError?] = [nil, .inputNotConsumerKey, .inputNotConsumerKey, .inputNotConsumerKey] + /// A list of expected input validation errors to be thrown after validating inputs against the secure (consumer secret) validation rule. + static let inputsSecureConsumerSecret: [InputValidationError?] = [nil, .inputNotConsumerSecret, .inputNotConsumerSecret, .inputNotConsumerSecret] + /// A list of expected input validation errors to be thrown after validating inputs against the secure (user token) validation rule. + static let inputsSecureUserToken: [InputValidationError?] = [nil, .inputNotUserToken, .inputNotUserToken, .inputNotUserToken] }