Início / coding / Perguntas / 79197294
Accepted
lazarevzubov
Asked: 2024-11-17 21:30:10 +0800 CST

Como testar o Combine Publishers no Swift Testing?

  • 772

Considere este teste de unidade baseado no XCTest:

func testImageRetrieved() {
  let expectation = XCTestExpectation()
  let cancellable = viewModel.$image.dropFirst().sink { _ in
    // Do nothing on completion.
  } receiveValue: {
    XCTAssertNotNil($0)
    expectation.fulfill()
  }
  wait(for: [expectation], timeout: 1.0)

  cancellable.cancel()
}

De acordo com o Migrating a test from XCTest da Apple , isso deve ser diretamente traduzível neste método baseado em testes Swift:

@Test
func imageRetrieved() async {
  var cancellable: AnyCancellable?
  await confirmation { imageRetrieved in
    cancellable = viewModel.$image.dropFirst().sink { _ in
      // Do nothing on completion.
    } receiveValue: {
      #expect($0 != nil)
      imageRetrieved()
    }
  }
  cancellable?.cancel()
}

O último teste, no entanto, falha com o erro dizendo: "A confirmação foi confirmada 0 vezes, mas esperava-se que fosse confirmada 1 vez". Parece que a confirmação não "espera" até que o publicador emita um valor.

Qual é a maneira correta de testar editores do Combine no Swift Testing?

swift

2 respostas

  1. Best Answer

    Parece que a confirmação não "espera" até que o publicador emita um valor.

    Correto. A documentação diz,

    Quando o fechamento retorna, a biblioteca de testes verifica se as pré-condições da confirmação foram atendidas e registra um problema caso contrário.

    O closure neste caso retorna quase imediatamente, já que tudo o que ele faz é atribuir a uma variável. O teste não verá nenhum valor que seja publicado de forma assíncrona.

    Compare isso com o exemplo no guia de migração.

    struct FoodTruckTests {
  @Test func truckEvents() async {
    await confirmation("…") { soldFood in
      FoodTruck.shared.eventHandler = { event in
        if case .soldFood = event {
          soldFood()
        }
      }
      await Customer().buy(.soup)
    }
    ...
  }
  ...
}

    No final do fechamento, await Customer().buy(.soup)é chamado, e é isso que presumivelmente irá disparar FoodTruck.shared.eventHandler.

    Para publicadores, você pode facilmente obter its valuescomo um AsyncSequence, o que é muito mais fácil de consumir. Por exemplo, para verificar se o publicador publica pelo menos um elemento, e se o primeiro elemento não é nil. você pode fazer:

    @Test func someTest() async throws {
    var iterator = publisher.values.makeAsyncIterator()
    let first = await iterator.next()
    #expect(first != nil)
}

// example publisher:
var publisher: some Publisher<Int?, Never> {
    Just<Int?>(1).delay(for: 1, scheduler: DispatchQueue.main)
}

    Considere também adicionar um timeoutantes .values.

    Alternativamente, você pode esperar manualmente apenas chamando Task.sleep. Os testes a seguir publisherpublicam exatamente um elemento, que não é nulo, em um período de 2 segundos.

    @Test func someTest() async throws {
    var cancellable: Set<AnyCancellable> = []
    try await confirmation { confirmation in
        publisher.sink { value in
            #expect(first != nil)
            confirmation()
        }.store(in: &cancellable)
        try await Task.sleep(for: .seconds(2))
    }
}

    Claro, isso faz com que o teste seja executado por pelo menos 2 segundos, o que pode ser indesejável às vezes.

    • 2

  2. Você está correto, que “ confirmationnão ‘espera’ até que o publicador emita um valor”. Como diz o documento :

    As confirmações funcionam de forma semelhante à API de expectativas de XCTest, no entanto, elas não bloqueiam ou suspendem o chamador enquanto aguardam que uma condição seja atendida. Em vez disso, espera-se que o requisito seja confirmado (o equivalente a atender uma expectativa) antes de confirmation()retornar, e registra um problema de outra forma.

    Se você observar os confirmationexemplos nesse documento, todos eles fazem awaitalguma asyncchamada antes de retornar.

    Mas você pode usar valuespara renderizar seu Publishercomo um AsyncSequence, o que você pode simplesmente awaitem um asyncteste. Então, em vez de sink, apenas pegue o primeiro valor desta sequência assíncrona:

    @Test
func publisherValue() async {
    let publisher = …
    let value = await publisher.values.first()
    #expect(value != nil)
}

    Então, no seu caso, você deve ser capaz de fazer:

    @Test
func imageRetrieved() async {
    let value = await viewModel.$image.values.first()
    #expect(value != nil)
}

    Com esta extensão para simplificar a chamada para first(where:):

    extension AsyncSequence {
    func first() async rethrows -> Element? {
        try await first(where: { _ in true})
    }
}
    • 2

relate perguntas