Update tests

Package.swift

@@ -18,7 +18,7 @@ let package = Package(
                 "Vapor"
             ]),
         .testTarget(
-            name: "GateKeeperTests",
+            name: "GatekeeperTests",
             dependencies: ["Gatekeeper"]),
     ]
-)
+)

Tests/GatekeeperTests/GatekeeperTests.swift

@@ -1,10 +1,5 @@
 import XCTest
-
-import URI
-import HTTP
 import Vapor
-import Foundation
-
 @testable import Gatekeeper
 
 class GatekeeperTests: XCTestCase {
@@ -15,13 +10,18 @@ class GatekeeperTests: XCTestCase {
         ("testRefreshIntervalValues", testRefreshIntervalValues),
     ]
 
-    func testGateKeeper() {
-        let middleware = Gatekeeper(rate: Rate(10, per: .second))
-        let request = getHTTPSRequest()
-
+    func testGateKeeper() throws {
+
+        let request = try Request.test(
+            gatekeeperConfig: GatekeeperConfig(maxRequests: 10, per: .minute),
+            peerName: "::1"
+        )
+
+        let gateKeeper = try request.make(Gatekeeper.self)
+
         for i in 1...11 {
             do {
-                _ = try middleware.respond(to: request, chainingTo: MockResponder())
+                _ = try gateKeeper.accessEndpoint(on: request).wait()
                 XCTAssertTrue(i <= 10, "ran \(i) times.")
             } catch let error as Abort {
                 switch error.status {
@@ -38,12 +38,18 @@ class GatekeeperTests: XCTestCase {
         }
     }
 
-    func testGateKeeperNoPeer() {
-        let middleware = Gatekeeper(rate: Rate(100, per: .second))
-        let request = getHTTPRequest()
-
+    func testGateKeeperNoPeer() throws {
+
+        let request = try Request.test(
+            gatekeeperConfig: GatekeeperConfig(maxRequests: 10, per: .minute),
+            peerName: nil
+        )
+
+        let gateKeeper = try request.make(Gatekeeper.self)
+
         do {
-            _ = try middleware.respond(to: request, chainingTo: MockResponder())
+            _ = try gateKeeper.accessEndpoint(on: request).wait()
+            XCTAssertTrue(false, "Gatekeeper should throw")
         } catch let error as Abort {
             switch error.status {
                 case .forbidden:
@@ -56,81 +62,51 @@ class GatekeeperTests: XCTestCase {
             XCTFail("Rate limiter failed: \(error)")
         }
     }
-
-    func testGateKeeperCountRefresh() {
-        let middleware = Gatekeeper(rate: Rate(100, per: .second))
-        let request = getHTTPSRequest()
-
+
+    func testGateKeeperCountRefresh() throws {
+
+        let request = try Request.test(
+            gatekeeperConfig: GatekeeperConfig(maxRequests: 100, per: .second),
+            peerName: "192.168.1.2"
+        )
+
+        let gateKeeper = try request.make(Gatekeeper.self)
+
         for _ in 0..<50 {
             do {
-                _ = try middleware.respond(to: request, chainingTo: MockResponder())
+                _ = try gateKeeper.accessEndpoint(on: request).wait()
             } catch {
                 XCTFail("Rate limiter failed: \(error)")
                 break
             }
         }
-
-        var requestsLeft = try! middleware.cache.get("192.168.1.2")?["requestsLeft"]?.int
-        XCTAssertEqual(requestsLeft, 50)
+
+        let cache = try request.make(KeyedCache.self)
+        var entry = try! cache.get("gatekeeper_192.168.1.2", as: Gatekeeper.Entry.self).wait()
+        XCTAssertEqual(entry!.requestsLeft, 50)
 
         Thread.sleep(forTimeInterval: 1)
         do {
-            _ = try middleware.respond(to: request, chainingTo: MockResponder())
+            _ = try gateKeeper.accessEndpoint(on: request).wait()
         } catch {
             XCTFail("Rate limiter failed: \(error)")
         }
-        
-        requestsLeft = try! middleware.cache.get("192.168.1.2")?["requestsLeft"]?.int
-        XCTAssertEqual(requestsLeft, 99, "Requests left should've reset")
+
+        entry = try! cache.get("gatekeeper_192.168.1.2", as: Gatekeeper.Entry.self).wait()
+        XCTAssertEqual(entry!.requestsLeft, 99, "Requests left should've reset")
     }
 
     func testRefreshIntervalValues() {
-        let expected: [(Rate.Interval, Double)] = [
+        let expected: [(GatekeeperConfig.Interval, Double)] = [
             (.second, 1),
             (.minute, 60),
             (.hour, 3_600),
             (.day, 86_400)
         ]
-        
+
         expected.forEach { interval, expected in
-            let rate = Rate(1, per: interval)
+            let rate = GatekeeperConfig(maxRequests: 1, per: interval)
             XCTAssertEqual(rate.refreshInterval, expected)
         }
     }
 }
-
-extension GatekeeperTests {
-    var developmentDrop: Droplet {
-        let config = try! Config()
-        config.environment = .development
-        return try! Droplet(config: config)
-    }
-
-    var productionDrop: Droplet {
-        let config = try! Config()
-        config.environment = .production
-        return try! Droplet(config: config)
-    }
-
-    func getHTTPRequest() -> Request {
-        return Request(method: .get, uri: "http://localhost:8080/")
-    }
-
-    func getHTTPSRequest() -> Request {
-
-        var headers = [HeaderKey: String]()
-        headers["X-Forwarded-For"] = "192.168.1.2"
-
-        return try! Request(
-            method: .get,
-            uri: URI("https://localhost:8080/"),
-            headers: headers
-        )
-    }
-}
-
-struct MockResponder: Responder {
-    func respond(to request: Request) throws -> Response {
-        return "Hello, world".makeResponse()
-    }
-}

Tests/GatekeeperTests/Utilities/Request+test.swift

@@ -0,0 +1,41 @@
+import Gatekeeper
+import HTTP
+import Vapor
+
+extension Request {
+    static func test(
+        gatekeeperConfig: GatekeeperConfig,
+        url: URLRepresentable = "http://localhost:8080/test",
+        peerName: String? = "::1"
+    ) throws -> Request {
+        let config = Config()
+
+        var services = Services()
+        services.register(KeyedCache.self) { container in
+            return MemoryKeyedCache()
+        }
+
+        try services.register(GatekeeperProvider(config: gatekeeperConfig))
+
+        let sharedThreadPool = BlockingIOThreadPool(numberOfThreads: 2)
+        sharedThreadPool.start()
+        services.register(sharedThreadPool)
+
+        let app = try Application(config: config, environment: .testing, services: services)
+        let request = Request(
+            http: HTTPRequest(
+                method: .GET,
+                url: url
+            ),
+            using: app
+        )
+
+        var http = request.http
+        if let peerName = peerName {
+            http.headers.add(name: .init("X-Forwarded-For"), value: peerName)
+        }
+        request.http = http
+
+        return request
+    }
+}

Tests/LinuxMain.swift

@@ -1,7 +1,8 @@
 import XCTest
 
-@testable import GatekeeperTests
+import GatekeeperTests
 
-XCTMain([
-    testCase(GatekeeperTests.allTests),
-])
+var tests = [XCTestCaseEntry]()
+tests += GatekeeperTests.allTests()
+
+XCTMain(tests)