Probar código async (XCTest)
Escriba async tests con XCTest: marque las pruebas como async , use await y throws , pruebe fallos y tiempos de espera, y compruebe los resultados de la concurrencia estructurada.
Probar código async (XCTest) es una lección gratuita de Swift Academy en CoddyKit. Esta es la lección 3 de 3. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Swift Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Swift Academy incluye 3 lecciones en total.
Pruebas async: conceptos básicos
XCTest admite pruebas async. Mantenga las pruebas pequeñas y deterministas:
- Declare pruebas
asyncy use await - Use throws y
do/catchpara los errores - Sustituya los sleeps por fakes/stubs pequeños
Caso de éxito async
Marque la prueba como async y llame al SUT con await. Escriba aserciones normales 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)
}
}async throws y aserciones
Use pruebas async throws. Para errores concretos, captúrelos y haga pattern matching para que la intención quede 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
La concurrencia estructurada es fácil de probar: use async let y compruebe el resultado final. Mantenga las demoras muy cortas para evitar pruebas inestables.
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
}
}Pruebas de timeout
Pruebe los timeouts haciendo competir la operación con un sleep corto. Use duraciones muy pequeñas para que las pruebas sean rápidas y estables.
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 (legacy)
Para callbacks antiguos, siga usando expectation/wait. Prefiera las pruebas async para el código nuevo.
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 pruebas async
Comprobación rápida: ¿Cuál es la mejor práctica para probar una función async?
Repaso
Repaso: Use métodos de XCTest async con await, compruebe las rutas de éxito y de error, mantenga las demoras muy cortas y reserve las expectations para callbacks antiguos.
Preguntas frecuentes
¿La lección «Probar código async (XCTest)» es gratis?
Sí — el texto completo de «Probar código async (XCTest)» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Swift Academy, actualiza a CoddyKit PRO. El curso de Swift Academy incluye 3 lecciones en total.
¿Qué aprenderé en «Probar código async (XCTest)»?
Escriba async tests con XCTest: marque las pruebas como async , use await y throws , pruebe fallos y tiempos de espera, y compruebe los resultados de la concurrencia estructurada. Practicas Swift Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Swift Academy?
No se requiere experiencia previa. Swift Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 3.
¿Cuánto tiempo toma la lección «Probar código async (XCTest)»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Swift Academy?
Sí. Cada lección de Swift Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Productor/consumidor, canalizaciones y tiempos de espera
- Conectar callbacks heredados/Combine con async/await
- Probar código async (XCTest)