Fixed an issue with the way the regex pattern was generated for the SecureValidationRule type in the library target.

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}$"
 }

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]
 }