Testando código assíncrono (XCTest)
Escreva testes assíncronos com XCTest: marque os testes como async , use await e throws , teste falhas e timeouts e verifique os resultados da concorrência estruturada.
Testando código assíncrono (XCTest) é uma aula grátis de Swift Academy no CoddyKit. Esta é a aula 3 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Swift Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Swift Academy inclui 3 aulas no total.
Testes assíncronos: conceitos básicos
O XCTest oferece suporte a testes assíncronos. Mantenha os testes pequenos e determinísticos:
- Declare testes
asynce use await - Use throws e
do/catchpara falhas - Substitua esperas por dublês e stubs pequenos
Caso de sucesso assíncrono
Marque o teste como async e chame o SUT com await. Escreva asserções normais, como XCTAssertEqual.
import XCTest
import Foundation
// System Under Test (SUT)
func fetchValue() async -> Int {
try? await Task.sleep(nanoseconds: 50_000_000)
return 42
}
final class AsyncBasicsTests: XCTestCase {
func testFetchValue_returns42() async {
let v = await fetchValue()
XCTAssertEqual(v, 42)
}
}Lançamento de erros assíncrono e asserções
Use testes async throws. Para erros específicos, capture-os e faça a correspondência de padrões para manter a intenção clara.
import XCTest
enum NetError: Error { case offline }
func loadNumber(online: Bool) async throws -> Int {
try await Task.sleep(nanoseconds: 30_000_000)
if !online { throw NetError.offline }
return 7
}
final class AsyncThrowingTests: XCTestCase {
func testLoadNumber_success() async throws {
let n = try await loadNumber(online: true)
XCTAssertEqual(n, 7)
}
func testLoadNumber_offline_throws() async {
do {
_ = try await loadNumber(online: false)
XCTFail("Expected error")
} catch NetError.offline {
// expected
} catch {
XCTFail("Unexpected error: \\(error)")
}
}
}Resultados paralelos
A concorrência estruturada é fácil de testar: use async let e verifique o resultado final. Mantenha os atrasos mínimos para evitar testes instáveis.
import XCTest
func compute(_ x: Int) async -> Int {
try? await Task.sleep(nanoseconds: 10_000_000)
return x * x
}
final class ParallelTests: XCTestCase {
func testParallel_asyncLet_sumsSquares() async {
async let a = compute(2)
async let b = compute(3)
let sum = await (a + b)
XCTAssertEqual(sum, 13) // 4 + 9
}
}Teste de tempo limite
Teste tempos limite disputando a operação com uma espera curta. Use durações muito pequenas para manter os testes rápidos e estáveis.
import XCTest
enum TimeoutError: Error { case timedOut }
func withTimeout<T>(
seconds: Double,
operation: @escaping () async throws -> T
) async throws -> T {
try await withThrowingTaskGroup(of: T.self) { group in
group.addTask { try await operation() }
group.addTask {
try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
throw TimeoutError.timedOut
}
let first = try await group.next()!
group.cancelAll()
return first
}
}
final class TimeoutTests: XCTestCase {
func testTimeout_timesOutFast() async {
do {
_ = try await withTimeout(seconds: 0.01) {
try await Task.sleep(nanoseconds: 50_000_000) // slower than timeout
return "OK"
}
XCTFail("Expected timeout")
} catch TimeoutError.timedOut {
// expected
} catch {
XCTFail("Unexpected error: \\(error)")
}
}
}Expectativas (legado)
Para retornos de chamada antigos, continue usando expectation/wait. Prefira testes assíncronos para códigos novos.
import XCTest
// Legacy API with a completion handler
func legacyFetch(_ completion: @escaping (String) -> Void) {
Task { try? await Task.sleep(nanoseconds: 20_000_000); completion("done") }
}
final class ExpectationTests: XCTestCase {
func testLegacy_withExpectation() {
let exp = expectation(description: "legacy finishes")
legacyFetch { value in
XCTAssertEqual(value, "done")
exp.fulfill()
}
wait(for: [exp], timeout: 1.0)
}
}Estilo moderno de teste assíncrono
Verificação rápida: Qual é a melhor prática para testar uma função assíncrona?
Recapitulação
Recapitulação: Use métodos async do XCTest com await, verifique os caminhos de sucesso e de falha, mantenha os atrasos mínimos e reserve expectativas para retornos de chamada antigos.
Perguntas Frequentes
A aula “Testando código assíncrono (XCTest)” é grátis?
Sim — o texto completo de “Testando código assíncrono (XCTest)” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Swift Academy, atualize para CoddyKit PRO. O curso de Swift Academy inclui 3 aulas no total.
O que vou aprender em “Testando código assíncrono (XCTest)”?
Escreva testes assíncronos com XCTest: marque os testes como async , use await e throws , teste falhas e timeouts e verifique os resultados da concorrência estruturada. Você pratica Swift Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Swift Academy?
Nenhuma experiência prévia é necessária. Swift Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 3.
Quanto tempo leva a aula “Testando código assíncrono (XCTest)”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Swift Academy?
Sim. Cada aula de Swift Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Produtor/consumidor, pipelines e timeouts
- Conectando callbacks legados/Combine a async/await
- Testando código assíncrono (XCTest)