Home IOS Development Working and testing async Vapor instructions

Working and testing async Vapor instructions

0
Working and testing async Vapor instructions

[ad_1]

Find out how to run async instructions in Vapor?

The async / await characteristic is comparatively new in Swift and a few framework authors have not transformed every little thing to reap the benefits of these new key phrases. At present, that is the scenario with the Command API in Vapor 4. You may already outline async instructions, however there is not any solution to register them utilizing the Vapor framework. Luckily, there’s a comparatively easy workaround that you should use if you wish to execute instructions utilizing an asynchronous context. 🔀

First we’ll outline a helper protocol and create an asyncRun perform. We’re going to prolong the unique Command protocol and supply a default implementation for the run methodology.

import Vapor

public protocol AsyncCommand: Command {
    
    func asyncRun(
        utilizing context: CommandContext,
        signature: Signature
    ) async throws
}

public extension AsyncCommand {

    func run(
        utilizing context: CommandContext,
        signature: Signature
    ) throws {
        let promise = context
            .utility
            .eventLoopGroup
            .subsequent()
            .makePromise(of: Void.self)
        
        promise.completeWithTask {
            strive await asyncRun(
                utilizing: context,
                signature: signature
            )
        }
        strive promise.futureResult.wait()
    }
}

This fashion you must have the ability to create a brand new async command and you must implement the asyncRun methodology if you wish to name some asynchronous Swift code.

import Vapor

remaining class MyAsyncCommand: AsyncCommand {
    
    static let title = "async"
    
    let assist = "This command run asynchronously."

    struct Signature: CommandSignature {}

    func asyncRun(
        utilizing context: CommandContext,
        signature: Signature
    ) async throws {
        context.console.information("That is async.")
    }
}

It’s doable to register the command utilizing the configure methodology, you possibly can do this out by operating the swift run Run async snippet if you’re utilizing the usual Vapor template. 💧

import Vapor

public func configure(
    _ app: Software
) throws {

    app.instructions.use(
        MyAsyncCommand(),
        as: MyAsyncCommand.title
    )

    strive routes(app)
}

As you possibly can see it is a fairly neat trick, it is also talked about on GitHub, however hopefully we do not want this workaround for too lengthy and correct async command help will arrive in Vapor 4.x.

Unit testing Vapor instructions

This subject has actually zero documentation, so I assumed it will be good to inform you a bit about tips on how to unit check scripts created through ConsoleKit. To start with we want a TestConsole that we are able to use to gather the output of our instructions. This can be a shameless ripoff from ConsoleKit. 😅

import Vapor

remaining class TestConsole: Console {

    var testInputQueue: [String]
    var testOutputQueue: [String]
    var userInfo: [AnyHashable : Any]

    init() {
        self.testInputQueue = []
        self.testOutputQueue = []
        self.userInfo = [:]
    }

    func enter(isSecure: Bool) -> String {
        testInputQueue.popLast() ?? ""
    }

    func output(_ textual content: ConsoleText, newLine: Bool) {
        let line = textual content.description + (newLine ? "n" : "")
        testOutputQueue.insert(line, at: 0)
    }

    func report(error: String, newLine: Bool) {
        
    }

    func clear(_ sort: ConsoleClear) {
        
    }

    var dimension: (width: Int, top: Int) {
        (0, 0)
    }
}

Now contained in the check suite, you must create a brand new utility occasion utilizing the check setting and configure it for testing functions. Then you must provoke the command that you simply’d like to check and run it utilizing the check console. You simply should create a brand new context and a correct enter with the required arguments and the console.run perform will handle every little thing else.

@testable import App
import XCTVapor

remaining class AppTests: XCTestCase {
    
    func testCommand() throws {
        let app = Software(.testing)
        defer { app.shutdown() }
        strive configure(app)
        
        let command = MyAsyncCommand()
        let arguments = ["async"]
        
        let console = TestConsole()
        let enter = CommandInput(arguments: arguments)
        var context = CommandContext(
            console: console,
            enter: enter
        )
        context.utility = app
        
        strive console.run(command, with: context)

        let output = console
            .testOutputQueue
            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
        
        let expectation = [
            "This is async."
        ]
        XCTAssertEqual(output, expectation)
    }
}

The great factor about this resolution is that the ConsoleKit framework will routinely parse the arguments, choices and the flags. You may present these as standalone array parts utilizing the enter arguments array (e.g. ["arg1", "--option1", "value1", "--flag1"]).

It’s doable to check command teams, you simply have so as to add the particular command title as the primary argument that you simply’d prefer to run from the group and you may merely verify the output by the check console if you’re searching for the precise command outcomes. 💪

[ad_2]

LEAVE A REPLY

Please enter your comment!
Please enter your name here