Release v6.0.0

[younata]

Hello friends!

I'm very excited to announce Quick version 6, the async update. Headlining features include async/await support, the ability to rerun an individual test without using fit or xit, the ability to early-exit from a test by throwing a StopTest error, and a new operator, justBeforeEach, which executes the given closure immediately prior to the test's it closure.

As always, I want to give a massive thanks to everyone who has contributed to Quick.

Thanks, have a great day!

[Blackjacx]

Thanks for this massive update. This was long awaited 👍 But now I have 260+ problems 😅 Can you please give me a hint how to deal with them without the need to change too much?

[stherold]

Hmmm it is wiked... I managed to run certain or all closures on the main thread using @mainactor. But then I get the warning Instance method 'toEventually' is unavailable from asynchronous contexts; the sync version of toEventually does not work in async contexts. Use the async version with the same name as a drop-in replacement; this is an error in Swift 6 on the following code:

it("shows empty state") { @MainActor in
    let view = ConnectionDetailsView(date: Date(),
                                     timeZone: TimeZone.current,
                                     delegate: connectionDetailsDelegateMock)
    view.forceLoad()
    expect(view.state).toEventually(equal(.showEmpty))
}

I need to run this on the main thread, this is clear but I also need the toEventually. My questions now:

1. When I specify @MainActor why does the warning still mention async contexts?
2. What is the sync version of toEventually?
3. Will I really have an error in the above constellation?
4. Do I really have to annotate every single describe or it in my test suite with @mainactor?
5. I would like to see some example projects that use Quick in version 6.x and how they do it. Do you know where I can find them?

[younata]

Sorry for the late response:

Your test should look like this:

it("shows empty state") { @MainActor in
    let view = ConnectionDetailsView(date: Date(),
                                     timeZone: TimeZone.current,
                                     delegate: connectionDetailsDelegateMock)
    view.forceLoad()
    await expect(view.state).toEventually(equal(.showEmpty))
}

1. The warning still mentions async contexts because you're using the synchronous overload of toEventually().
2. toEventually() is an overloaded method. There are both synchronous and asynchronous versions of it (that is, the asynchronous version is marked as async and needs to be used with await. The synchronous version is tagged with @available(*, noasync), which provides a warning (error in some future version of Swift - I wish I could force it to error now) and message about what's going on). When you are running the test in an asynchronous context (like all specs in Quick 6, and AsyncSpec subclasses in the upcoming Quick 7), then you must use the asynchronous version of toEventually(). When you are running the test in a synchronous context (i.e. Quick 5, and QuickSpec subclasses in the upcoming Quick 7). This is documented, somewhat, in the Nimble docs, but it could be better documented.
3. The synchronous version of toEventually is known not to work when the test runs on the main actor. The solution is to use the asynchronous version (that is, prepending await to the entire expression).
4. No. In fact, you only need to tag it, beforeEach, justBeforeEach or afterEach blocks with @MainActor when your test would crash if you don't (that is, there are a bunch of UIKit methods that trip the main thread checker if they're called off the main thread, but aren't tagged with @MainActor. It's incredibly frustrating.). You can optionally tag some test closures with @MainActor, which allows you to call methods/closures/types tagged with @MainActor without having to use the await syntax, but it's not necessary.
5. I haven't looked, sorry.

[stherold]

Oh wow thank you for the detailed response!

When you are running the test in an asynchronous context (like all specs in Quick 6, and AsyncSpec subclasses in the upcoming Quick 7), then you must use the asynchronous version of toEventually(). When you are running the test in a synchronous context (i.e. Quick 5, and QuickSpec subclasses in the upcoming Quick 7). This is documented, somewhat, in the Nimble docs, but it could be better documented.

This is actually what I did not find. I understand it like this that we can just keep using QuickSpec (as we do now) in Quick 7 which will save us from annotating our closures with @mainactor and the ones which we like to have async, just use AsyncSpec? Is that correct?

[younata]

@stherold Yes, that is correct. There is a beta out for quick 7 if you wish to pull it in and try.

[Blackjacx]

I tested it already and can confirm it works like a charm 🙏 Can't wait for the release 🥰