Kevinzhow | 周楷雯修改

import Fluent 




struct AddUserIDToPost: AsyncMigration { 

    func prepare(on database: Database) async throws { 

        try await database.schema(Post.schema)  

            .field("user_id", .uuid, .references(User.schema, "id")) 

            .update()

    }



    func revert(on database: Database) async throws { 

       try await database.schema(Post.schema)

          .deleteField("user_id")

          .update()

    }


}

app.migrations.add([CreatePost(), CreateUser(), AddUserIDToPost()])

final class Post: Model, Content {

    static let schema = "posts"



    @ID(key: .id)

    var id: UUID?



    @OptionalParent(key: "user_id")

    var user: User?



    @Field(key: "content")

    var content: String

    

    @Timestamp(key: "created_at", on: .create)

    var createdAt: Date?



    init() { }



    init(id: UUID? = nil, content: String) {

        self.id = id

        self.content = content

    }


}

import Vapor


import Fluent




final class User: Model, Content {

    static let schema = "users"

    

    @ID(key: .id)

    var id: UUID?

    

    @Field(key: "username")

    var username: String

    

    @Field(key: "password_hash")

    var passwordHash: String



    @Children(for: \.$user)

    var posts: [Post]

    

    @Timestamp(key: "created_at", on: .create)

    var createdAt: Date?

    

    init() {}

    

    init(id: UUID? = nil, username: String, passwordHash: String) {

        self.id = id

        self.username = username

        self.passwordHash = passwordHash

    }


}

let user = User(username: "hellouser", passwordHash: try await app.password.async.hash("123456"))


try await user.save(on: app.db)


let post = Post(content: "Hello, World!")


post.$user.id = try user.requiredID()

let user = User(username: "hellouser", passwordHash: try await app.password.async.hash("123456"))


try await user.save(on: app.db)


let post = Post(content: "Hello, World!")


user.$posts.create(post, on: app.db)

extension User: ModelAuthenticatable {

    static let usernameKey = \User.$username

    static let passwordHashKey = \User.$passwordHash



    func verify(password: String) throws -> Bool {

        try Bcrypt.verify(password, created: self.passwordHash)

    }


}

func boot(routes: RoutesBuilder) throws {

    routes.group("posts") { posts in

        posts.get(use: index)

        posts.grouped(User.authenticator()).post(use: create)

    }


}

func create(req: Request) async throws -> Post {

    let user = try req.auth.require(User.self)



    let postData = try req.content.decode(Post.CreateDTO.self)

        

    let post = Post(content: postData.content)



    post.$user.id = try user.requireID()

    

    try await post.create(on: req.db)

    

    return post


}

@testable import App


import XCTVapor




final class PostTests: XCTestCase {

    var app: Application!



    override func setUp() async throws {

        app = Application(.testing)

        try configure(app)



        try await app.autoRevert()

        try await app.autoMigrate()

    }



    

    override func tearDown() async throws {

        app.shutdown()

    }

    



    func testCreatePost() async throws {

        let user = User(username: "hellouser", passwordHash: try await app.password.async.hash("123456"))

        try await user.save(on: app.db)

        let postDTO = Post.CreateDTO(content: "Post created from test")



        try app.test(.POST, "posts", beforeRequest: { req in

            try req.content.encode(postDTO)

            req.headers.basicAuthorization = BasicAuthorization(username: user.username, password: "123456")

        }, afterResponse: { res in

            XCTAssertEqual(res.status, .ok)

            

            let post = try res.content.decode(Post.self)

            

            XCTAssertEqual(postDTO.content, post.content)

            XCTAssertEqual(try user.requireID(), post.$user.id)

        })

    }


}

import Vapor


import Fluent




final class User: Model, Content {

    static let schema = "users"

    

    @ID(key: .id)

    var id: UUID?

    

    @Field(key: "username")

    var username: String

    

    @Field(key: "password_hash")

    var passwordHash: String

    

    @Timestamp(key: "created_at", on: .create)

    var createdAt: Date?

    

    init() {}

    

    init(id: UUID? = nil, username: String, passwordHash: String) {

        self.id = id

        self.username = username

        self.passwordHash = passwordHash

    }


}




extension User {

    struct CreateDTO: Content {

        let username: String

        let password: String

    }


}

import Fluent 




struct CreateUser: AsyncMigration { 

    func prepare(on database: Database) async throws { 

        try await database.schema(User.schema)  

            .id()  

            .field("username", .string, .required)

            .field("password_hash", .string, .required)

            .field("created_at", .datetime)

            .create()

    }



    func revert(on database: Database) async throws { 

        try await database.schema(User.schema).delete() 

    }


}

app.passwords.use(.bcrypt) // Bcrypt 是一种密码加密算法，可以确保多次加密后的密码都是不同的，但是可以通过原始密码验证


app.migrations.add([CreatePost(), CreateUser()])

import Fluent


import Vapor




struct UserController: RouteCollection {

    func boot(routes: RoutesBuilder) throws {

        routes.group("users") { posts in

            posts.get(use: index)

            posts.post(use: create)

        }

    }



    func create(req: Request) async throws -> User {

        let postData = try req.content.decode(User.CreateDTO.self)

            

        let user = User(username: postData.username, passwordHash: try await req.password.async.hash(postData.password))

        

        try await user.create(on: req.db)

        

        return user

    }



    func index(req: Request) async throws -> [User] {

        let users = try await User.query(on: req.db).all()

        

        return users

    }


}

try app.register(collection: UserController())

@testable import App


import XCTVapor




final class UserTests: XCTestCase {

    var app: Application!



    override func setUp() async throws {

        app = Application(.testing)

        try configure(app)



        try await app.autoRevert()

        try await app.autoMigrate()

    }



    

    override func tearDown() async throws {

        app.shutdown()

    }

    

    func testCreateUser() async throws {

        let userData = User.CreateDTO(username: "happyuser", password: "123456")

        try app.test(.POST, "users", beforeRequest: { req in

            try req.content.encode(userData)

        }, afterResponse: { res in

            XCTAssertEqual(res.status, .ok)

            

            let user = try res.content.decode(User.self)

            

            XCTAssertEqual(user.username, userData.username)

            XCTAssertTrue(try app.password.verify("123456", created: user.passwordHash))

        })

    }

    

    func testGetUsers() async throws {

        let user = User(username: "hellouser", passwordHash: try await app.password.async.hash("123456"))

        try await user.save(on: app.db)

        try app.test(.GET, "users", afterResponse: { res in

            XCTAssertEqual(res.status, .ok)

            

            let users = try res.content.decode([User].self)

            

            XCTAssertEqual(users.count, 1)

            XCTAssertEqual(users[0].username, user.username)

        })

    }


}

import Fluent


import Vapor




struct PostController: RouteCollection {

    func boot(routes: RoutesBuilder) throws {

        routes.group("posts") { posts in

            posts.get(use: index)

            posts.post(use: create)

        }

    }



    func create(req: Request) async throws -> Post {

        let postData = try req.content.decode(Post.CreateDTO.self)

            

        let post = Post(content: postData.content)

        

        try await post.create(on: req.db)

        

        return post

    }



    func index(req: Request) async throws -> [Post] {

        let posts = try await Post.query(on: req.db).all()

        

        return posts

    }


}

import Fluent


import FluentPostgresDriver


import Vapor




public func configure(_ app: Application) throws {

    app.databases.use(.postgres(configuration: SQLPostgresConfiguration(

        hostname: Environment.get("DATABASE_HOST") ?? "localhost",

        port: Environment.get("DATABASE_PORT").flatMap(Int.init(_:)) ?? SQLPostgresConfiguration.ianaPortNumber,

        username: Environment.get("DATABASE_USERNAME") ?? "vapor_username",

        password: Environment.get("DATABASE_PASSWORD") ?? "vapor_password",

        database: Environment.get("DATABASE_NAME") ?? "vapor_database",

        tls: .prefer(try .init(configuration: .clientDefault)))

    ), as: .psql)



    app.migrations.add([CreatePost()])



    try app.register(collection: PostController())


}