Added the "init(uriRoot:)" initializer function for the CheckURIUseCase use case in the library target and also, improved its test cases.

Sources/HummingbirdDocC/Internal/Use Cases/CheckURIUseCase.swift

@@ -15,6 +15,22 @@ import struct HummingbirdCore.URI
 /// A use case that checks whether a given URI against a set of conditions, to determine whether the URI could be used by the middleware or not.
 struct CheckURIUseCase {
     
+    // MARK: Properties
+    
+    /// A root path that prefixes the documentation resource.
+    private let uriRoot: String
+    
+    // MARK: Initializers
+    
+    /// Initializes this use case.
+    ///
+    /// > important: It is assumed that the `uriRoot` parameter is not empty and that it is prefixed by the `/` character.
+    ///
+    /// - Parameter uriRoot: A root path that prefixes the documentation resource.
+    init(uriRoot: String) {
+        self.uriRoot = uriRoot
+    }
+
     // MARK: Functions
     
     /// Checks whether a provided URI against a set of conditions, so it could be used by the middleware.
@@ -23,8 +39,8 @@ struct CheckURIUseCase {
     func callAsFunction(_ uri: URI) -> String? {
         guard
             let uriPath = uri.path.removingPercentEncoding,
-            !uriPath.contains(.Path.previousFolder),
+            uriPath.hasPrefix(uriRoot),
-            uriPath.hasPrefix(.Path.forwardSlash)
+            !uriPath.contains(.Path.previousFolder)
         else {
             return nil
         }

Tests/HummingbirdDocC/Tests/Internal/Use Cases/CheckURIUseCaseTests.swift

@@ -19,75 +19,84 @@ import struct HummingbirdCore.URI
 @Suite("Check URI use case", .tags(.useCase))
 struct CheckURIUseCaseTests {
 
-    // MARK: Properties
-    
-    private let useCase: CheckURIUseCase = .init()
-    
     // MARK: Use case tests
 
-#if swift(>=6.2)
+    #if swift(>=6.2)
-    @Test(arguments: zip(
+        @Test(
-        Input.nonEncodedURIs,
+            arguments: zip(
-        Output.nonEncodedURIs
+                Input.nonEncodedURIs,
-    ))
+                Output.nonEncodedURIs
-    func `check non encoded URIs`(
+            )
-        uri uriPath: String,
+        )
-        expects result: String?
+        func `check non encoded URIs`(
-    ) {
+            uri uriPath: String,
-        assertURI(uriPath, expects: result)
+            expects result: String?
-    }
+        ) {
+            assertURI(uriPath, expects: result)
+        }
 
-    @Test(arguments: zip(
+        @Test(
-        Input.percentEncodedURIs,
+            arguments: zip(
-        Output.percentEncodedURIs
+                Input.percentEncodedURIs,
-    ))
+                Output.percentEncodedURIs
-    func `check percent-encoded URIs`(
+            )
-        uri uriPath: String,
+        )
-        expects result: String?
+        func `check percent-encoded URIs`(
-    ) {
+            uri uriPath: String,
-        assertURI(uriPath, expects: result)
+            expects result: String?
-    }
+        ) {
-#else
+            assertURI(uriPath, expects: result)
-    @Test("check non-encoded URIs", arguments: zip(
+        }
-        Input.nonEncodedURIs,
+    #else
-        Output.nonEncodedURIs
+        @Test(
-    ))
+            "check non-encoded URIs",
-    func check_nonEncodedURIs(
+            arguments: zip(
-        uri uriPath: String,
+                Input.nonEncodedURIs,
-        expects result: String?
+                Output.nonEncodedURIs
-    ) {
+            )
-        assertURI(uriPath, expects: result)
+        )
-    }
+        func check_nonEncodedURIs(
+            uri uriPath: String,
+            expects result: String?
+        ) {
+            assertURI(uriPath, expects: result)
+        }
 
-    @Test("check percent-encoded URIs", arguments: zip(
+        @Test(
-        Input.percentEncodedURIs,
+            "check percent-encoded URIs",
-        Output.percentEncodedURIs
+            arguments: zip(
-    ))
+                Input.percentEncodedURIs,
-    func check_percentEncodedURIs(
+                Output.percentEncodedURIs
-        uri uriPath: String,
+            )
-        expects result: String?
+        )
-    ) {
+        func check_percentEncodedURIs(
-        assertURI(uriPath, expects: result)
+            uri uriPath: String,
-    }
+            expects result: String?
-#endif
+        ) {
+            assertURI(uriPath, expects: result)
+        }
+    #endif
 
 }
 
 // MARK: - Assertions
 
-private extension CheckURIUseCaseTests {
+extension CheckURIUseCaseTests {
 
     // MARK: Functions
 
     /// Asserts a URI path provided by the ``CheckURIPathUseCase`` use case based on a given path and an expected result.
     /// - Parameters:
     ///   - uriPath: A URI path to use with a URI type.
+    ///   - uriRoot: A URI path that prefixes the `DocC` documentation resources.
     ///   - result: An expected result coming out of the use case.
-    func assertURI(
+    fileprivate func assertURI(
         _ uriPath: String,
+        uriRoot: String = .Sample.uriRoot,
         expects result: String?
     ) {
         // GIVEN
+        let useCase = CheckURIUseCase(uriRoot: uriRoot)
         let uri = URI(uriPath)
 
         // WHEN
@@ -101,16 +110,38 @@ private extension CheckURIUseCaseTests {
 
 // MARK: - Constants
 
-private extension Input {
+extension Input {
     /// A list of non-encoded URI samples.
-    static let nonEncodedURIs: [String] = ["/", "/some/known/path", "", "/some/../path", "some/other/path"]
+    fileprivate static let nonEncodedURIs: [String] = [
+        .Sample.uriRoot + .empty,
+        .Sample.uriRoot + .Path.forwardSlash,
+        .Sample.uriRoot + "/some/known/path",
+        .Sample.uriRoot + "/some/../path",
+        "some/other/root/some/known/path",
+    ]
     /// A list of percent-encoded URI samples.
-    static let percentEncodedURIs: [String] = ["%2F", "/some%2Fknown%3Fpath", "%20", "/some/%2E%2E/path", "some%2Fother%3Fpath"]
+    fileprivate static let percentEncodedURIs: [String] = [
+        .Sample.uriRoot + "%2F",
+        .Sample.uriRoot + "/some%2Fknown%3Fpath",
+        .Sample.uriRoot + "/some/%2E%2E/path",
+        "some/other%2Froot/some%2Fknown%3Fpath",
+    ]
 }
 
-private extension Output {
+extension Output {
     /// A list of expected outputs for the non-encoded URI samples.
-    static let nonEncodedURIs: [String?] = ["/", "/some/known/path", "/", nil, nil]
+    fileprivate static let nonEncodedURIs: [String?] = [
+        .Sample.uriRoot,
+        .Sample.uriRoot + .Path.forwardSlash,
+        .Sample.uriRoot + "/some/known/path",
+        nil,
+        nil,
+    ]
     /// A list of expected outputs for the percent-encoded URI samples.
-    static let percentEncodedURIs: [String?] = ["/", "/some/known?path", nil, nil, nil]
+    fileprivate static let percentEncodedURIs: [String?] = [
+        .Sample.uriRoot + .Path.forwardSlash,
+        .Sample.uriRoot + "/some/known?path",
+        nil,
+        nil,
+    ]
 }