archive files for server test runs. add endpoint to retrieve files from server.

Author: mattpolzin

Sources/App/Controllers/APITestController.swift

@@ -9,6 +9,7 @@ import APITesting
 /// Controls basic CRUD operations on `Todo`s.
 final class APITestController {
 
+    static let zipPathPrefix = Environment.archivesPath
     let outputPath: String
     let openAPISource: OpenAPISource
     let database: Database
@@ -55,6 +56,27 @@ final class APITestController {
         }
     }
 
+    func files(_ req: TypedRequest<FilesContext>) throws -> EventLoopFuture<Response> {
+        guard let id = req.parameters.get("id", as: UUID.self) else {
+            return req.response.badRequest
+        }
+
+        let query = APITestDescriptor.query(on: database)
+            .filter(\APITestDescriptor.$id == id)
+
+        return query.first()
+            .unwrap(or: Abort(.notFound))
+            .flatMap { req.fileio.collectFile(at: self.zipPath(for: $0)) }
+            .flatMap { req.response.success.encode($0) }
+            .flatMapError { error in
+                guard let abortError = error as? Abort,
+                    abortError.status == .notFound else {
+                        return req.response.serverError
+                }
+                return req.response.notFound
+        }
+    }
+
     /// Create an `APITestDescriptor` and run a new test suite.
     func create(_ req: TypedRequest<CreateContext>) throws -> EventLoopFuture<Response> {
         let reqUUIDGuess = req
@@ -72,18 +94,30 @@ final class APITestController {
 
         savedDescriptor.whenSuccess { [weak self] in
 
-            guard let source = self?.openAPISource,
-                let database = self?.database,
-                let outPath = self?.outputPath,
-                let eventLoop = self?.testEventLoop() else { return }  // this just happens if the controller has been released from memory
+            // this just happens if the controller has been released from memory
+            // which we consider possible here because this whole process is async
+            // and independent of the API request completion.
+            guard let self = self else { return }
+
+            let source = self.openAPISource
+            let database = self.database
+            let outPath = self.outPath(for: descriptor)
+            let zipPath = self.zipPath(for: descriptor)
+            let eventLoop = self.testEventLoop()
+
+            req.logger.info("Running tests in \(outPath)")
 
             prepOutputFolder(on: eventLoop, at: outPath, logger: logger)
                 .flatMap { descriptor.markBuilding().save(on: database) }
                 .flatMap { openAPIDoc(on: eventLoop, from: source) }
-                .flatMap { openAPIDoc in produceAPITestPackage(on: eventLoop, given: openAPIDoc, to: outPath, logger: logger) }
+                .flatMap { openAPIDoc in produceAPITestPackage(on: eventLoop, given: openAPIDoc, to: outPath, zipToPath: zipPath, logger: logger) }
                 .flatMap { descriptor.markRunning().save(on: database) }
                 .flatMap { runAPITestPackage(on: eventLoop, at: outPath, logger: logger) }
                 .flatMap { descriptor.markPassed().save(on: database) }
+                .always { _ in
+                    try? cleanupOutFolder(outPath, logger: logger)
+                    req.logger.info("Cleaning up tests in \(outPath)")
+                }
                 .whenFailure { error in
                     req.logger.error("Testing Failed",
                                      metadata: ["error": .stringConvertible(String(describing: error))])
@@ -110,6 +144,16 @@ final class APITestController {
         return testEventLoopGroup.next()
     }
 
+    private func zipPath(for test: APITestDescriptor) -> String {
+        return Self.zipPathPrefix
+            + "/\(test.id!.uuidString).zip"
+    }
+
+    private func outPath(for test: APITestDescriptor) -> String {
+        return self.outputPath
+            + "/\(test.id!.uuidString)/"
+    }
+
     // MARK: - Contexts
 
     struct CreateContext: RouteContext {
@@ -214,6 +258,36 @@ final class APITestController {
 
         static let builder = { return Self() }
     }
+
+    struct FilesContext: RouteContext {
+        typealias RequestBodyType = EmptyRequestBody
+
+        let success: ResponseContext<ByteBuffer> =
+            .init { response in
+                response.status = .ok
+                response.headers.contentType = .zip
+        }
+
+        let notFound: CannedResponse<EmptyResponseBody> =
+            .init(response: Response(
+                status: .notFound
+            )
+        )
+
+        let badRequest: CannedResponse<EmptyResponseBody> =
+            .init(response: Response(
+                status: .badRequest
+            )
+        )
+
+        let serverError: CannedResponse<EmptyResponseBody> =
+            .init(response: Response(
+                status: .internalServerError
+            )
+        )
+
+        static let builder = { return Self() }
+    }
 }
 
 extension APITestController {

Sources/App/Environment/APITestEnvironment+database.swift renamed to Sources/App/Environment/APITestEnvironment+server.swift

@@ -1,5 +1,5 @@
 //
-//  APITestEnvironment+database.swift
+//  APITestEnvironment+server.swift
 //  App
 //
 //  Created by Mathew Polzin on 9/28/19.
@@ -26,3 +26,11 @@ public extension Environment {
         case invalidUrl(String)
     }
 }
+
+// MARK: - Archive Vars
+public extension Environment {
+    /// Optional Archives path (folder location in which zip archives will be stored).
+    static var archivesPath: String {
+        return Environment.get("API_TEST_ARCHIVES_PATH") ?? "/app/archives/"
+    }
+}

Sources/App/Vapor Extensions/ByteBuffer+ResponseEncodable.swift

@@ -0,0 +1,15 @@
+//
+//  ByteBuffer+ResponseEncodable.swift
+//  App
+//
+//  Created by Mathew Polzin on 12/4/19.
+//
+
+import Vapor
+
+extension ByteBuffer: ResponseEncodable {
+    public func encodeResponse(for request: Request) -> EventLoopFuture<Response> {
+        let response = Response(status: .ok, body: .init(buffer: self))
+        return request.eventLoop.makeSucceededFuture(response)
+    }
+}

Sources/App/Vapor Extensions/RouteContext.swift

@@ -8,6 +8,13 @@
 import Vapor
 
 public struct EmptyRequestBody: Decodable {}
+public struct EmptyResponseBody: Encodable {}
+
+extension EmptyResponseBody: ResponseEncodable {
+    public func encodeResponse(for request: Request) -> EventLoopFuture<Response> {
+        return "".encodeResponse(for: request)
+    }
+}
 
 public protocol AbstractRouteContext {
     var requestBodyType: Any.Type { get }

Sources/App/routes.swift

@@ -19,6 +19,10 @@ public func routes(_ app: Application) throws {
     app.get("api_test", ":id", use: testController.show)
         .tags("Status")
         .summary("Retrieve a single test result")
+
+    app.get("api_test", ":id", "files", use: testController.files)
+        .tags("Test Files")
+        .summary("Retrieve the test files for the given test.")
 }
 
 extension Route {

Sources/SwiftGen/ApiTestPackageUtil.swift

@@ -10,6 +10,8 @@ import OpenAPIKit
 
 public func prepOutFolder(_ outPath: String, logger: Logger) throws {
     try? FileManager.default.removeItem(atPath: outPath + "/Tests/GeneratedAPITests")
+    try? FileManager.default.removeItem(atPath: outPath + "/api_tests.log")
+    try? FileManager.default.removeItem(atPath: outPath + "/.build")
 
     if !FileManager.default.fileExists(atPath: outPath + "/Tests/GeneratedAPITests/resourceObjects") {
         try FileManager.default.createDirectory(atPath: outPath + "/Tests/GeneratedAPITests/resourceObjects",
@@ -18,6 +20,10 @@ public func prepOutFolder(_ outPath: String, logger: Logger) throws {
     }
 }
 
+public func cleanupOutFolder(_ outPath: String, logger: Logger) throws {
+    try FileManager.default.removeItem(atPath: outPath)
+}
+
 public func runAPITestPackage(at path: String, logger: Logger) throws {
     let (exitCode, stdout) = shell("cd '\(path)' && swift test 2>&1")