Atlas › Test
Exact test identity: go.temporal.io/server/common/testing/await/TestRequire_DeadlockDetected
go.temporal.io/server/common/testing/awaitTestRequire_DeadlockDetectedTestRequire_DeadlockDetectedExpand a file to inspect source; the > gutter marks covered lines.
const defaultSoftDeadlockTimeout = 30 * time.Second
if s := os.Getenv(softDeadlockTimeoutEnvVar); s != "" {
return d
}
}
return defaultSoftDeadlockTimeout
const defaultHardDeadlockTimeout = 10 * time.Second
if s := os.Getenv(hardDeadlockTimeoutEnvVar); s != "" {
return d
}
}
return defaultHardDeadlockTimeout
// Pass the *await.T to require.*/assert.* — failures cause a retry, not a
// test failure. Use t.Context() inside the callback to honor the timeout.
func Require(ctx context.Context, tb testing.TB, condition func(*T), timeout, pollInterval time.Duration) {
require_ctx.go
tb.Helper()
run(ctx, tb, condition, legacyConfig(timeout, pollInterval, ""), "Require", requireMisuseHint, true)
}
// Requiref is like [Require] but adds a formatted message to the timeout
misuseHint string,
cancellable bool,
tb.Helper()
// Skip if the test already failed — no point polling.
if tb.Failed() {
tb.Logf("%s: skipping (test already failed)", funcName)
return
}
// Guard: context.WithDeadline panics on a nil parent.
tb.Fatalf("%s: nil context", funcName)
return
}
// Cap at the parent context's deadline if it's earlier than our timeout.
if parentDeadline, hasDeadline := parentCtx.Deadline(); hasDeadline && parentDeadline.Before(deadline) {
deadline = parentDeadline
}
// Cap at the test's deadline if it's earlier than our deadline.
// Ideally, the parent context already accounts for the test's deadline - but we are being defensive.
if testDeadline, hasDeadline := d.Deadline(); hasDeadline && testDeadline.Before(deadline) {
deadline = testDeadline
}
awaitCtx, awaitCancel := context.WithDeadline(parentCtx, deadline)
defer awaitCancel()
report := timeoutReport{effectiveTimeout: effectiveTimeout}
for {
// Parent context was canceled while we were sleeping (not our deadline).
if err := awaitCtx.Err(); err != nil && !deadlineReached(deadline) {
report.reportAttemptErrors(tb)
tb.Fatalf("%s: context canceled before condition was satisfied: %v", funcName, err)
}
// Per-attempt context: bounded by the configured attempt timeout and
// further capped by the overall awaitCtx.
attemptCtx, attemptCancel := context.WithTimeout(awaitCtx, cfg.attemptTimeout)
t := &T{tb: tb, ctx: attemptCtx}
// Run attempt.
res := runAttempt(t, condition, attemptCancel, funcName, cancellable)
attemptCancel()
if res.panicVal != nil {
panic(res.panicVal) // propagate to caller
}
if cancellable {
tb.Fatalf("%s: condition still running %v past context cancellation — does it honor t.Context()? (%d attempts)",
require_ctx.go
funcName, hardDeadlockTimeout(), report.attempts)
tb.Fatalf("%s: condition still running %v past deadline (%d attempts)",
funcName, hardDeadlockTimeout(), report.attempts)
funcName string,
cancellable bool,
done := make(chan attemptResult, 1)
go func() {
completed := false
defer func() {
if r := recover(); r != nil {
if _, ok := r.(attemptFailed); ok {
done <- attemptResult{stopped: !completed}
}()
completed = true
}()
softTimer := time.NewTimer(softDeadlockTimeout())
defer softTimer.Stop()
select {
case r := <-done:
return r
// Soft deadlock: log a warning.
t.tb.Logf("%s: soft deadlock — condition still running after %v; waiting %v before declaring hard deadlock",
funcName, softDeadlockTimeout(), hardDeadlockTimeout())
// Cancel so the condition can observe ctx.Done().
cancel()
case <-t.ctx.Done():
// Parent cancelled (await deadline reached or upstream cancel).
// Hard phase: wait for the condition or the hard timer.
defer hardTimer.Stop()
select {
case r := <-done:
return r
return attemptResult{deadlocked: true}
}
}
// DefaultTimeout returns the effective default timeout for test-scoped contexts.
return effectiveTimeout(0)
}
// For returns the test-scoped context for tb. The context is canceled
// return the same context, but an explicit different timeout fails instead of
// being silently ignored.
tb.Helper()
cfg := config{timeout: DefaultTimeout()}
for _, opt := range opts {
opt(&cfg)
}
st.configure(tb, cfg)
return st.context()
}
}
tb.Helper()
testContexts.Lock()
defer testContexts.Unlock()
if st, ok := testContexts.byTest[tb]; ok {
return st
}
// Annotate gRPC requests with the test name for OTEL tracing.
ctx = metadata.AppendToOutgoingContext(ctx, testNameMetadataKey, tb.Name())
st := &contextState{
ctx: ctx,
cancel: cancel,
timeout: timeout,
decorators: make(map[any]struct{}),
}
testContexts.byTest[tb] = st
tb.Cleanup(func() {
err := st.err()
st.cancel()
testContexts.Lock()
delete(testContexts.byTest, tb)
testContexts.Unlock()
if err == context.DeadlineExceeded {
tb.Errorf("test exceeded timeout of %v", st.timeout)
}
})
}
tb.Helper()
s.mu.Lock()
defer s.mu.Unlock()
if cfg.timeoutSet && cfg.timeout != s.timeout {
tb.Fatalf("testcontext: test context already exists with timeout %v; cannot change it to %v", s.timeout, cfg.timeout)
}
}
s.mu.Lock()
defer s.mu.Unlock()
return s.ctx
}
s.mu.Lock()
defer s.mu.Unlock()
return s.ctx.Err()
}
s.mu.Lock()
defer s.mu.Unlock()
s.ctx = nil
}
defer func() {
// Build flag TEMPORAL_DEBUG applies a timeout multiplier to all test timeouts.
timeout *= debug.TimeoutMultiplier
}()
// 1. Custom timeout (via WithTimeout option).
return customTimeout
}
// 2. TEMPORAL_TEST_TIMEOUT environment variable.
if dur, err := time.ParseDuration(envTimeout); err == nil && dur > 0 {
return dur
}
return config{
attemptTimeout: envDuration(attemptTimeoutEnvVar, 10*time.Second) * debug.TimeoutMultiplier,
}
}
cfg := newConfig()
cfg.totalTimeout = timeout
cfg.pollInterval = pollInterval
cfg.timeoutMsg = timeoutMsg
return cfg
}
if s := os.Getenv(name); s != "" {
if d, err := time.ParseDuration(s); err == nil && d > 0 {
return d
}
}
return fallback
}
r.attempts++
}
func (r *timeoutReport) recordErrors(errors []string) {
}
reportAttemptErrors(tb, r.failures)
}
func (r timeoutReport) reportTimeout(tb testing.TB, funcName, timeoutMsg string) {