Chapter 11 is ready

Author: tib

Chapter 11/myProject/.env.testing

@@ -0,0 +1,4 @@
+DB_URL=postgres://myuser:mypass@localhost:5432/mydb
+APP_URL=http://localhost:8080
+AWS_KEY=<key>
+AWS_SECRET=<secret>

Chapter 11/myProject/Package.resolved

@@ -19,6 +19,8 @@ let package = Package(
         .package(url: "https://github.com/binarybirds/view-kit.git", from: "1.0.0"),
         .package(url: "https://github.com/binarybirds/content-api.git", from: "1.0.0"),
         .package(url: "https://github.com/binarybirds/viper-kit.git", from: "1.0.0"),
+        //...
+        .package(url: "https://github.com/binarybirds/spec.git", from: "1.0.0"),
     ],
     targets: [
         .target(name: "App", dependencies: [
@@ -37,7 +39,7 @@ let package = Package(
         .target(name: "Run", dependencies: ["App"]),
         .testTarget(name: "AppTests", dependencies: [
             .target(name: "App"),
-            .product(name: "XCTVapor", package: "vapor"),
+            .product(name: "Spec", package: "spec"),
         ])
     ]
 )

Chapter 11/myProject/Package.swift

@@ -4,4 +4,24 @@ import ContentApi
 
 struct BlogPostApiController: ApiController {
     typealias Model = BlogPostModel
+    
+    func setValidCategory(req: Request, model: Model, categoryId: String) -> EventLoopFuture<Model> {
+        guard let uuid = UUID(uuidString: categoryId) else {
+            return req.eventLoop.future(error: Abort(.badRequest))
+        }
+        return BlogCategoryModel.find(uuid, on: req.db)
+            .unwrap(or: Abort(.badRequest))
+            .map { category  in
+                model.$category.id = category.id!
+                return model
+            }
+    }
+    
+    func beforeCreate(req: Request, model: Model, content: Model.CreateContent) -> EventLoopFuture<Model> {
+        self.setValidCategory(req: req, model: model, categoryId: content.categoryId)
+    }
+
+    func beforeUpdate(req: Request, model: Model, content: Model.UpdateContent) -> EventLoopFuture<Model> {
+        self.setValidCategory(req: req, model: model, categoryId: content.categoryId)
+    }
 }

Chapter 11/myProject/Sources/App/Modules/Blog/Controllers/BlogPostApiController.swift

@@ -107,6 +107,7 @@ extension BlogPostModel: ApiRepresentable {
         var excerpt: String
         var date: Date
         var content: String
+        var categoryId: String
     }
 
     struct PatchContent: ValidatableContent {

Chapter 11/myProject/Sources/App/Modules/Blog/Models/BlogPostModel.swift

@@ -0,0 +1,59 @@
+@testable import App
+import XCTVapor
+import Fluent
+import FluentSQLiteDriver
+
+extension XCTApplicationTester {
+    @discardableResult public func test<T>(
+        _ method: HTTPMethod,
+        _ path: String,
+        headers: HTTPHeaders = [:],
+        content: T,
+        afterResponse: (XCTHTTPResponse) throws -> () = { _ in }
+    ) throws -> XCTApplicationTester where T: Content {
+        try test(method, path, headers: headers, beforeRequest: { req in
+            try req.content.encode(content)
+        }, afterResponse: afterResponse)
+    }
+}
+
+open class AppTestCase: XCTestCase {
+    
+    func createTestApp() throws -> Application {
+        let app = Application(.testing)
+        try configure(app)
+        app.databases.use(.sqlite(.memory), as: .sqlite)
+        app.databases.default(to: .sqlite)
+        try app.autoMigrate().wait()
+        return app
+    }
+    
+    func getApiToken(_ app: Application) throws -> String {
+        struct UserLoginRequest: Content {
+            let email: String
+            let password: String
+        }
+        struct UserTokenResponse: Content {
+            let id: String
+            let value: String
+        }
+
+        let userBody = UserLoginRequest(email: "[email protected]",
+                                    password: "ChangeMe1")
+        
+        var token: String?
+
+        try app.test(.POST, "/api/user/login", beforeRequest: { req in
+            try req.content.encode(userBody)
+        }, afterResponse: { res in
+            XCTAssertContent(UserTokenResponse.self, res) { content in
+                token = content.value
+            }
+        })
+        guard let t = token else {
+            XCTFail("Login failed")
+            throw Abort(.unauthorized)
+        }
+        return t
+    }
+}

Chapter 11/myProject/Tests/AppTests/AppTestCase.swift

@@ -0,0 +1,47 @@
+@testable import App
+import XCTVapor
+import Fluent
+
+final class BlogCategoryApiTests: AppTestCase {
+    
+    func testGetCategories() throws {
+        let app = try self.createTestApp()
+        let token = try self.getApiToken(app)
+        defer { app.shutdown() }
+
+        let headers = HTTPHeaders([("Authorization", "Bearer \(token)")])
+
+        try app
+            //.testable(method: .inMemory)
+            .testable(method: .running(port: 8081))
+            .test(.GET, "/api/blog/categories", headers: headers) { res in
+                XCTAssertEqual(res.status, .ok)
+                let contentType = try XCTUnwrap(res.headers.contentType)
+                XCTAssertEqual(contentType, .json)
+                XCTAssertContent(Page<BlogCategoryModel.ListItem>.self, res) { content in
+                    XCTAssertEqual(content.metadata.total, 2)
+                }
+            }
+    }
+
+    func testCreateCategory() throws {
+        let app = try self.createTestApp()
+        let token = try self.getApiToken(app)
+        defer { app.shutdown() }
+
+        let headers = HTTPHeaders([("Authorization", "Bearer \(token)")])
+        
+        let newCategory = BlogCategoryModel.CreateContent(title: "Test category")
+
+        try app.test(.POST, "/api/blog/categories",
+                     headers: headers,
+                     content: newCategory) { res in
+                XCTAssertEqual(res.status, .ok)
+                let contentType = try XCTUnwrap(res.headers.contentType)
+                XCTAssertEqual(contentType, .json)
+                XCTAssertContent(BlogCategoryModel.CreateContent.self, res) { content in
+                    XCTAssertEqual(content.title, newCategory.title)
+                }
+            }
+    }
+}

Chapter 11/myProject/Tests/AppTests/AppTests.swift

@@ -0,0 +1,121 @@
+@testable import App
+import Spec
+import Fluent
+
+final class BlogPostApiTests: AppTestCase {
+    //...
+    
+    func testGetPosts() throws {
+        let app = try self.createTestApp()
+        let token = try self.getApiToken(app)
+        defer { app.shutdown() }
+
+        try app
+            .describe("Blog posts should return ok")
+            .get("/api/blog/posts")
+            .bearerToken(token)
+            .expect(.ok)
+            .expect(.json)
+            .expect(Page<BlogPostModel.ListItem>.self) { content in
+                print(content)
+            }
+            .test()
+    }
+    
+    func testCreatePost() throws {
+        let app = try self.createTestApp()
+        let token = try self.getApiToken(app)
+        defer { app.shutdown() }
+
+        let category = try BlogCategoryModel.query(on: app.db).first().wait()
+        guard let c = category else {
+            XCTFail("Missing default category")
+            throw Abort(.notFound)
+        }
+
+        let newPost = BlogPostModel.CreateContent(title: "Dummy post",
+                                                  slug: "dummy-slug",
+                                                  image: "/dummy/image.jpg",
+                                                  excerpt: "Lorem ipsum",
+                                                  date: Date(),
+                                                  content: "Lorem ipsum",
+                                                  categoryId: c.id!.uuidString)
+
+        //...
+        var total = 1
+
+        try app
+            .describe("Get original posts count")
+            .get("/api/blog/posts")
+            .bearerToken(token)
+            .expect(.ok)
+            .expect(.json)
+            .expect(Page<BlogPostModel.ListItem>.self) { content in
+                total += content.metadata.total
+            }
+            .test()
+        
+        try app
+            .describe("Create post should return ok")
+            .post("/api/blog/posts")
+            .body(newPost)
+            .bearerToken(token)
+            .expect(.ok)
+            .expect(.json)
+            .expect(BlogPostModel.GetContent.self) { content in
+                XCTAssertEqual(content.title, newPost.title)
+        }
+        .test()
+        
+        try app
+             .describe("Blog post count should be correct")
+             .get("/api/blog/posts")
+             .bearerToken(token)
+             .expect(.ok)
+             .expect(.json)
+             .expect(Page<BlogPostModel.ListItem>.self) { content in
+                 XCTAssertEqual(content.metadata.total, total)
+             }
+             .test()
+    }
+    
+    func testUpdatePost() throws {
+        let app = try self.createTestApp()
+        let token = try self.getApiToken(app)
+        defer { app.shutdown() }
+
+        let post = try BlogPostModel
+            .query(on: app.db)
+            .with(\.$category)
+            .first()
+            .unwrap(or: Abort(.notFound))
+            .wait()
+
+        let suffix = " updated"
+
+        let newPost = BlogPostModel.UpdateContent(title: post.title + suffix,
+                                                  slug: post.slug + suffix,
+                                                  image: post.image + suffix,
+                                                  excerpt: post.excerpt + suffix,
+                                                  date: post.date,
+                                                  content: post.content + suffix,
+                                                  categoryId: post.category.id!.uuidString)
+        
+        try app
+            .describe("Create post should return ok")
+            .put("/api/blog/posts/\(post.id!.uuidString)")
+            .body(newPost)
+            .bearerToken(token)
+            .expect(.ok)
+            .expect(.json)
+            .expect(BlogPostModel.GetContent.self) { content in
+                XCTAssertEqual(content.id, post.id)
+                XCTAssertEqual(content.title, newPost.title)
+                XCTAssertEqual(content.slug, newPost.slug)
+                XCTAssertEqual(content.image, newPost.image)
+                XCTAssertEqual(content.excerpt, newPost.excerpt)
+                XCTAssertEqual(content.content, newPost.content)
+            }
+            .test()
+    }
+}

Chapter 11/myProject/Tests/AppTests/Blog/BlogCategoryApiTests.swift

@@ -0,0 +1,18 @@
+@testable import App
+import XCTVapor
+
+final class FrontendTests: XCTestCase {
+    
+    func testHomePage() throws {
+        let app = Application(.testing)
+        defer { app.shutdown() }
+        try configure(app)
+
+        try app.testable(method: .inMemory).test(.GET, "") { res in
+            XCTAssertEqual(res.status, .ok)
+            let contentType = try XCTUnwrap(res.headers.contentType)
+            XCTAssertEqual(contentType, .html)
+            XCTAssertTrue(res.body.string.contains("myPage - Home"))
+        }
+    }
+}