agila_open_tool/tools/v/vlib/x/async/group_test.v

import context
import time
import x.async as xasync

fn test_with_cancel_sets_error_and_closes_done() {
	mut ctx, cancel := xasync.with_cancel()
	cancel()
	done := ctx.done()
	select {
		_ := <-done {
			assert ctx.err().msg() == 'context canceled'
		}
		1 * time.second {
			assert false, 'cancel did not close the context done channel'
		}
	}
}

fn test_group_success() {
	parent := context.background()
	mut group := xasync.new_group(parent)
	done := chan int{cap: 2}
	group.go(fn [done] (mut ctx context.Context) ! {
		_ = ctx
		done <- 1
	})!
	group.go(fn [done] (mut ctx context.Context) ! {
		_ = ctx
		done <- 2
	})!
	group.wait()!
	assert (<-done) + (<-done) == 3
}

fn test_group_error_returns_first_error() {
	parent := context.background()
	mut group := xasync.new_group(parent)
	group.go(fn (mut ctx context.Context) ! {
		_ = ctx
		return error('group failed')
	})!
	group.wait() or {
		assert err.msg() == 'group failed'
		return
	}
	assert false
}

fn test_group_default_does_not_collect_errors() {
	mut group := xasync.new_group(context.background())
	group.go(fn (mut ctx context.Context) ! {
		_ = ctx
		return error('group failed')
	})!
	group.wait() or {
		assert err.msg() == 'group failed'
		assert group.errors().len == 0
		return
	}
	assert false
}

fn test_group_rejects_invalid_error_collection_config() {
	xasync.new_group_with_config(context.background(), collect_errors: true, max_errors: 0) or {
		assert err.msg() == 'async: group max_errors must be positive'
		return
	}
	assert false
}

fn test_group_wait_without_tasks() {
	parent := context.background()
	mut group := xasync.new_group(parent)
	group.wait()!
}

fn test_group_refuses_go_after_wait() {
	parent := context.background()
	mut group := xasync.new_group(parent)
	group.wait()!
	group.go(fn (mut ctx context.Context) ! {
		_ = ctx
	}) or {
		assert err.msg() == 'async: group does not accept new tasks after wait starts'
		return
	}
	assert false
}

fn test_group_refuses_second_wait() {
	parent := context.background()
	mut group := xasync.new_group(parent)
	group.wait()!
	group.wait() or {
		assert err.msg() == 'async: group wait was already called'
		return
	}
	assert false
}

fn test_group_refuses_nil_job() {
	parent := context.background()
	mut group := xasync.new_group(parent)
	nil_job := unsafe { xasync.JobFn(nil) }
	group.go(nil_job) or {
		assert err.msg() == 'async: job function is nil'
		return
	}
	assert false
}

fn test_group_cancels_siblings_cooperatively() {
	parent := context.background()
	mut group := xasync.new_group(parent)
	cancelled := chan bool{cap: 1}
	group.go(fn (mut ctx context.Context) ! {
		_ = ctx
		return error('stop siblings')
	})!
	group.go(fn [cancelled] (mut ctx context.Context) ! {
		done := ctx.done()
		select {
			_ := <-done {
				cancelled <- true
			}
			1 * time.second {
				cancelled <- false
			}
		}
	})!
	group.wait() or { assert err.msg() == 'stop siblings' }
	assert <-cancelled
}

fn test_group_first_error_remains_stable_with_concurrent_secondary_errors() {
	parent := context.background()
	mut group := xasync.new_group(parent)
	secondary_ready := chan bool{cap: 8}
	for _ in 0 .. 8 {
		group.go(fn [secondary_ready] (mut ctx context.Context) ! {
			secondary_ready <- true
			done := ctx.done()
			select {
				_ := <-done {
					return error('secondary error after cancellation')
				}
				1 * time.second {
					return error('secondary error timeout')
				}
			}
		})!
	}
	for _ in 0 .. 8 {
		assert <-secondary_ready
	}
	group.go(fn (mut ctx context.Context) ! {
		_ = ctx
		return error('primary error')
	})!
	group.wait() or {
		assert err.msg() == 'primary error'
		return
	}
	assert false
}

fn test_group_collects_errors_without_changing_wait_error() {
	mut group := xasync.new_group_with_config(context.background(),
		collect_errors: true
		max_errors:     4
	)!
	secondary_ready := chan bool{cap: 3}
	for i in 0 .. 3 {
		group.go(fn [secondary_ready, i] (mut ctx context.Context) ! {
			secondary_ready <- true
			done := ctx.done()
			select {
				_ := <-done {
					return error('secondary collected error ${i}')
				}
				1 * time.second {
					return error('secondary timeout ${i}')
				}
			}
		})!
	}
	for _ in 0 .. 3 {
		assert <-secondary_ready
	}
	group.go(fn (mut ctx context.Context) ! {
		_ = ctx
		return error('primary collected error')
	})!
	group.wait() or {
		assert err.msg() == 'primary collected error'
		errs := group.errors()
		assert errs.len == 4
		assert error_messages_contain(errs, 'primary collected error')
		return
	}
	assert false
}

fn test_group_error_collection_is_bounded_and_includes_first_error() {
	mut group := xasync.new_group_with_config(context.background(),
		collect_errors: true
		max_errors:     2
	)!
	secondary_ready := chan bool{cap: 4}
	for i in 0 .. 4 {
		group.go(fn [secondary_ready, i] (mut ctx context.Context) ! {
			secondary_ready <- true
			done := ctx.done()
			select {
				_ := <-done {
					return error('bounded secondary error ${i}')
				}
				1 * time.second {
					return error('bounded secondary timeout ${i}')
				}
			}
		})!
	}
	for _ in 0 .. 4 {
		assert <-secondary_ready
	}
	group.go(fn (mut ctx context.Context) ! {
		_ = ctx
		return error('bounded primary error')
	})!
	group.wait() or {
		assert err.msg() == 'bounded primary error'
		errs := group.errors()
		assert errs.len == 2
		assert error_messages_contain(errs, 'bounded primary error')
		return
	}
	assert false
}

fn test_group_errors_returns_snapshot_copy() {
	mut group := xasync.new_group_with_config(context.background(),
		collect_errors: true
		max_errors:     1
	)!
	group.go(fn (mut ctx context.Context) ! {
		_ = ctx
		return error('snapshot source error')
	})!
	group.wait() or {
		assert err.msg() == 'snapshot source error'
		mut snapshot := group.errors()
		assert snapshot.len == 1
		snapshot[0] = error('mutated snapshot error')
		second_snapshot := group.errors()
		assert second_snapshot.len == 1
		assert second_snapshot[0].msg() == 'snapshot source error'
		return
	}
	assert false
}

fn test_group_many_short_jobs_return_first_error() {
	jobs := 64
	mut group := xasync.new_group(context.background())
	done := chan int{cap: jobs}
	for i in 0 .. jobs {
		group.go(fn [done, i] (mut ctx context.Context) ! {
			_ = ctx
			done <- i
		})!
	}
	group.go(fn (mut ctx context.Context) ! {
		_ = ctx
		return error('group stress failure')
	})!
	group.wait() or {
		assert err.msg() == 'group stress failure'
		mut seen := []bool{len: jobs}
		for _ in 0 .. jobs {
			select {
				i := <-done {
					assert i >= 0
					assert i < jobs
					assert !seen[i]
					seen[i] = true
				}
				1 * time.second {
					assert false, 'group short job did not finish'
				}
			}
		}
		for was_seen in seen {
			assert was_seen
		}
		return
	}
	assert false
}

fn test_group_parent_cancellation_is_observed_by_cooperative_job() {
	parent_ctx, cancel := xasync.with_cancel()
	mut group := xasync.new_group(parent_ctx)
	observed := chan string{cap: 1}
	group.go(fn [observed] (mut ctx context.Context) ! {
		done := ctx.done()
		select {
			_ := <-done {
				err := ctx.err()
				observed <- err.msg()
				return err
			}
			1 * time.second {
				observed <- 'not canceled'
				return error('parent cancellation was not observed')
			}
		}
	})!
	cancel()
	group.wait() or { assert err.msg() == 'context canceled' }
	select {
		msg := <-observed {
			assert msg == 'context canceled'
		}
		2 * time.second {
			assert false, 'cooperative group job did not observe parent cancellation'
		}
	}
}

fn error_messages_contain(errs []IError, msg string) bool {
	for err in errs {
		if err.msg() == msg {
			return true
		}
	}
	return false
}