Files
swift-async-algorithms/Tests/AsyncAlgorithmsTests/TestFlatMapLatest.swift
T
5043186441 feat: Add AsyncSequence.flatMapLatest operator (#382)
* feat: Add initial naive implementation of flatMapLatest

This introduces a simplified version of the flatMapLatest operator for AsyncSequence, along with a basic unit test. Note that this implementation uses unstructured concurrency and may have race conditions regarding task cancellation.

* refactor: Implement robust flatMapLatest with generation tracking

- Replaces naive implementation with a thread-safe approach using ManagedCriticalState.
- Introduces generation tracking to prevent race conditions where cancelled inner sequences could yield stale values.
- Adds test_interleaving_race_condition to verify correctness under concurrent load.
- Ensures Swift 6 Sendable compliance.

* refactor: Implement high-performance State Machine for flatMapLatest

- Replaces AsyncThrowingStream implementation with a custom AsyncSequence, Storage, and StateMachine.
- Implements explicit state management using Lock for thread safety.
- Handles concurrency between outer and inner sequences robustly.
- Ensures correct cancellation propagation and error handling.
- Verified with test_interleaving_race_condition.

* refactor: Split flatMapLatest into separate files

- Moves AsyncFlatMapLatestSequence.swift to Sources/AsyncAlgorithms/FlatMapLatest/
- Extracts FlatMapLatestStateMachine and FlatMapLatestStorage into their own files.
- Aligns project structure with other complex operators like CombineLatest and Debounce.

* test: Add comprehensive tests for flatMapLatest

- Added test_outer_throwing to verify outer sequence error propagation
- Added test_inner_throwing to verify inner sequence error propagation
- Added test_cancellation to verify proper cancellation handling
- Added test_empty_outer to verify empty outer sequence handling
- Added test_empty_inner to verify empty inner sequence handling
- Fixed test_simple_sequence to be more robust against timing issues

* fix: Make test_outer_throwing stable

- Changed from synchronous map with throwIf to AsyncThrowingStream
- Added delay to ensure proper error propagation timing
- Fixes intermittent test failures

* refactor: Clean up verbose comments in FlatMapLatestStateMachine

- Removed LLM-style thinking comments
- Kept only essential, professional explanations
- No functional changes, all tests pass

* docs: Add comprehensive guide for flatMapLatest

- Added FlatMapLatest.md documentation guide
- Authored by Peter Friese
- Includes introduction, code samples, and use cases
- Covers search-as-you-type, location-based data, and dynamic config examples
- Compares with similar operators in ReactiveX and Combine

* docs: Add evolution proposal for flatMapLatest

- Created SAA-00nn proposal for flatMapLatest operator
- Includes motivation, detailed design, and examples
- Covers implementation strategy with state machine
- Compares with ReactiveX switchMap and Combine switchToLatest

* mapError - transforming failures (#366)

* Implement AsyncMapErrorSequence

* Update the proposal, implementation and tests with formatting, additional details and modifications for being able to push it to a review

* Foratting and preambles

* Update Copyright date for error sequence

Co-authored-by: Clive <clive819@users.noreply.github.com>

* Update copyright year for mapError tests

Co-authored-by: Clive <clive819@users.noreply.github.com>

* Update availablity and modify the mapError algorithm to be opaque

* Correct pre 6.0 build avail parameters

* Make the formatting of the algorithm accesor a bit more consistent

* Update the 5.8 package builder to define 1.2

* re-run formatter

---------

Co-authored-by: Clive <clive819@gmail.com>
Co-authored-by: Clive <clive819@users.noreply.github.com>

* Update the flatMapLatest proposal and implementation to a pitchable state

* Fix race condition in flatMapLatest and add regression test

* chore: Remove test_output.log and add it to .gitignore

---------

Co-authored-by: Philippe Hausler <phausler@apple.com>
Co-authored-by: Clive <clive819@gmail.com>
Co-authored-by: Clive <clive819@users.noreply.github.com>
2026-03-04 13:58:48 -08:00

241 lines
7.6 KiB
Swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Async Algorithms open source project
//
// Copyright (c) 2022 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
import XCTest
import AsyncAlgorithms
@available(macOS 15.0, *)
final class TestFlatMapLatest: XCTestCase {
func test_simple_sequence() async throws {
let source = [1, 2, 3].async
let transformed = source.flatMapLatest { intValue in
return [intValue, intValue * 10].async
}
var results: [Int] = []
for try await element in transformed {
results.append(element)
}
// With synchronous emission, we expect only the last inner sequence [3, 30]
// However, depending on timing, we might see more intermediate values
XCTAssertTrue(results.contains(3), "Should contain 3")
XCTAssertTrue(results.contains(30), "Should contain 30")
// We should also verify it ends with the last sequence
XCTAssertEqual(results.suffix(2), [3, 30], "Should end with [3, 30]")
}
func test_interleaving_race_condition() async throws {
// This test simulates a scenario where the inner sequence is slow.
// In a naive implementation (without generation tracking), the inner task for '1'
// might wake up and yield AFTER '2' has already started, causing interleaving.
let source = [1, 2, 3].async
let transformed = source.flatMapLatest { intValue -> AsyncStream<Int> in
AsyncStream { continuation in
Task {
// Yield the value immediately
continuation.yield(intValue)
// Sleep for a bit to allow the outer sequence to move on
try? await Task.sleep(nanoseconds: 10_000_000) // 10ms
// Yield a second value - this should be ignored if a new outer value has arrived
continuation.yield(intValue * 10)
continuation.finish()
}
}
}
// We expect:
// 1 arrives -> starts inner(1) -> yields 1 -> sleeps
// 2 arrives -> cancels inner(1) -> starts inner(2) -> yields 2 -> sleeps
// 3 arrives -> cancels inner(2) -> starts inner(3) -> yields 3 -> sleeps
// inner(3) finishes sleep -> yields 30
//
// Ideally, we should NOT see 10 or 20.
// However, without strict synchronization, we might see them.
// The strict expectation for flatMapLatest is that once a new value arrives,
// the old one produces NO MORE values.
// Note: This test is probabilistic in the naive implementation.
// It might pass or fail depending on scheduling.
// But with a correct implementation, it should ALWAYS pass.
// We'll collect all results to see what happened
var results: [Int] = []
for try await element in transformed {
results.append(element)
}
// In the naive implementation, we might get [1, 2, 3, 10, 20, 30] or similar.
// We want strictly [3, 30] (or [1, 2, 3, 30] depending on how fast the outer sequence is consumed vs produced)
// Actually, if the outer sequence is consumed fast, we might see intermediate "first" values (1, 2).
// But we should NEVER see "second" values (10, 20) from cancelled sequences.
// Let's relax the check to: "Must not contain 10 or 20"
XCTAssertFalse(results.contains(10), "Should not contain 10 (from cancelled sequence 1)")
XCTAssertFalse(results.contains(20), "Should not contain 20 (from cancelled sequence 2)")
XCTAssertTrue(results.contains(30), "Should contain 30 (from final sequence)")
}
func test_outer_throwing() async throws {
let source = AsyncThrowingStream<Int, Error> { continuation in
Task {
for value in [1, 2, 3] {
if value == 2 {
continuation.finish(throwing: FlatMapLatestFailure())
return
}
continuation.yield(value)
try? await Task.sleep(nanoseconds: 5_000_000) // 5ms delay
}
continuation.finish()
}
}
let transformed = source.flatMapLatest { intValue in
return [intValue, intValue * 10].async
}
do {
for try await _ in transformed {}
XCTFail("Should have thrown")
} catch {
XCTAssertEqual(error as? FlatMapLatestFailure, FlatMapLatestFailure())
}
}
func test_inner_throwing() async throws {
let source = AsyncStream<Int> { continuation in
Task {
for value in [1, 2, 3] {
continuation.yield(value)
try? await Task.sleep(nanoseconds: 5_000_000) // 5ms delay between outer values
}
continuation.finish()
}
}
let transformed = source.flatMapLatest { intValue in
return [intValue].async.map { try $0.throwIf(2) }
}
do {
for try await _ in transformed {}
XCTFail("Should have thrown")
} catch {
XCTAssertEqual(error as? FlatMapLatestFailure, FlatMapLatestFailure())
}
}
func test_cancellation() async throws {
let source = [1, 2, 3].async
let transformed = source.flatMapLatest { intValue in
return [intValue].async
}
let task = Task {
for try await _ in transformed {}
}
task.cancel()
do {
try await task.value
} catch is CancellationError {
// Expected
} catch {
XCTFail("Unexpected error: \(error)")
}
}
func test_empty_outer() async throws {
let source = [].async.map { $0 as Int }
let transformed = source.flatMapLatest { intValue in
return [intValue].async
}
var count = 0
for try await _ in transformed {
count += 1
}
XCTAssertEqual(count, 0)
}
func test_empty_inner() async throws {
let source = [1, 2, 3].async
let transformed = source.flatMapLatest { _ in
return [].async.map { $0 as Int }
}
var count = 0
for try await _ in transformed {
count += 1
}
XCTAssertEqual(count, 0)
}
func test_concurrency_crash_repro() async throws {
// This test simulates the exact race condition where an inner stream producer
// mimics the behavior of Firestore/Combine publisher wrappers that might
// yield values or finish asynchronously relative to cancellation.
@Sendable func innerStream(for user: String) -> AsyncThrowingStream<Int, Error> {
return AsyncThrowingStream { continuation in
let task = Task {
for i in 0...100 {
// Artificial delay to allow overlap/interleaving
// This is critical to hit the race condition window
try await Task.sleep(nanoseconds: 1_000_000) // 1ms
continuation.yield(i)
}
continuation.finish()
}
continuation.onTermination = { @Sendable termination in
task.cancel()
}
}
}
let authStream = AsyncStream<String> { continuation in
continuation.yield("A")
Task {
// Yielding again triggers the switch (and cancellation of the previous inner stream)
try? await Task.sleep(nanoseconds: 10_000_000) // 10ms
continuation.yield("B")
try? await Task.sleep(nanoseconds: 10_000_000)
continuation.finish()
}
}
let combined = authStream.flatMapLatest { user in
innerStream(for: user)
}
// Determine success by running without crashing
for try await _ in combined {}
}
}
private struct FlatMapLatestFailure: Error, Equatable {}
extension Int {
fileprivate func throwIf(_ value: Int) throws -> Int {
if self == value {
throw FlatMapLatestFailure()
}
return self
}
}