Wait

Overview

The Wait action pauses workflow execution for a specified duration. It allows you to introduce deliberate delays between workflow steps to ensure proper timing, system processing, and synchronization.

⏳ Purpose

Use Wait to pause execution and allow time for:

• Backend processing to complete

• Email delivery

• Database synchronization

• UI animations or transitions

• User think-time simulation

---

When to Use Wait

✅ Good Use Cases

Scenario	Reason
API Processing	Wait for server to process data before verification
Email Testing	Wait for email delivery before checking inbox
Database Sync	Allow time for database replication/sync
UI Animations	Let animations complete before interaction
Scheduled Jobs	Wait for background jobs to execute
Cache Invalidation	Allow cache to clear before next operation

❌ Anti-Patterns (Don't Do)

• ❌ Use as error handling (use Retry instead)

• ❌ Excessive waits (slows down test suite)

• ❌ Arbitrary waits without reason

• ❌ Fixed waits for variable operations (use polling instead)

---

Configuration

Basic Setup

1. Open your workflow

2. Click "Add Action" → Select "Wait"

3. Configure duration:

   • Value: Enter number

   • Unit: Seconds, Minutes, or Hours

4. Add optional description (recommended)

5. Connect to workflow - Place between relevant steps

6. Save

Configuration Options

Wait Action Configuration
├── Duration Value: 1-3600 (numeric)
├── Duration Unit: Seconds / Minutes / Hours
├── Description: Optional context (e.g., "Allow DB sync")
├── Conditional: Wait based on condition (optional)
└── Max Wait: Maximum duration before timeout

Example Configurations

Short Wait (Seconds)

Duration: 5 seconds
Use: Quick UI animation delays

Medium Wait (Seconds to Minutes)

Duration: 30 seconds
Use: API processing, email delivery

Longer Wait (Minutes)

Duration: 2 minutes
Use: Scheduled job execution, batch processing

---

Practical Examples

Example 1: Email Verification Workflow

Workflow: Verify New User Email

Step 1: API - Create User Account
   └─ Output: user_id, email

Step 2: API - Send Welcome Email
   └─ Triggers email to be sent

[WAIT: 10 seconds]
   └─ Allow email service to deliver

Step 3: Web - Check Email Inbox
   └─ Verify welcome email received
   └─ Verify email contains user_id from Step 1

Example 2: Order Processing with Database Sync

Workflow: Create and Verify Order

Step 1: Web - Place Order
   └─ Output: order_id, total_amount

Step 2: API - Verify Order Created
   └─ Check order exists in database

[WAIT: 3 seconds]
   └─ Allow database replication

Step 3: API - Verify Order Details
   └─ Confirm correct amount and status

Example 3: Background Job Completion

Workflow: Generate and Download Report

Step 1: Web - Trigger Report Generation
   └─ Click "Generate Report" button

[WAIT: 60 seconds]
   └─ Allow background job to complete

Step 2: Web - Download Generated Report
   └─ Report should now be available

Example 4: Cascading Operations

Workflow: Complete User Registration

Step 1: API - Create User
[WAIT: 2 seconds] → Step 2: API - Create Profile
[WAIT: 2 seconds] → Step 3: API - Send Confirmation Email
[WAIT: 5 seconds] → Step 4: API - Verify All Complete

---

Best Practices

✅ Do

• Document the reason - Add description explaining why wait is needed

• Use minimum necessary time - Don't add extra buffer unnecessarily

• Test to determine duration - Run test multiple times to find right wait time

• Consider retry logic - Combine with Retry for more resilience

• Monitor impact - Track if wait significantly affects test speed

• Use polling when possible - Some systems support polling instead of fixed waits

❌ Don't

• Use arbitrary long waits - 5 minutes wait for no reason

• Cascade many waits - Multiple waits significantly slow tests

• Skip documentation - Always explain why wait is needed

• Forget about failure scenarios - What if operation takes longer?

• Ignore test duration impact - Sum all waits to understand total time

• Wait without verification - Always verify something happened after wait

---

Timing Strategies

Strategy 1: Minimum Viable Wait

Find the absolute minimum time needed:

Test 1: Wait 2 seconds - Test fails (too fast)
Test 2: Wait 3 seconds - Test fails (too fast)
Test 3: Wait 5 seconds - Test passes
Test 4: Wait 5 seconds - Test passes

Result: Use 5 second wait (minimum reliable duration)

Strategy 2: Buffer Strategy

Add buffer to minimum time for reliability:

Minimum identified: 5 seconds
Add 30% buffer: 5 + 1.5 = 6.5 seconds (round to 7 seconds)
Final wait: 7 seconds

Strategy 3: Conditional Wait

Wait based on previous operation:

IF operation_slow THEN
    Wait 10 seconds
ELSE
    Wait 3 seconds
END

---

Combining Wait with Other Actions

Wait + Retry

Reliable pattern for operations with variable timing:

[Operation that may be slow]
    ↓
[Wait: Initial delay]
    ↓
[Retry: If still not ready]
    ↓
[Verification]

Wait for Polling

Monitor status with waits:

[Start long operation]
    ↓
[Wait: 5 seconds]
    ↓
[Check status]
    ↓
IF not_complete THEN
    [Wait another 5 seconds]
    [Check again]
ELSE
    [Proceed]

---

Performance Impact

Wait Duration Analysis

Wait times impact total execution:

Workflow with no waits: 5 minutes
Workflow with one 10-second wait: 5m 10s (+3%)
Workflow with three 30-second waits: 5m 90s (+30%)
Workflow with five 60-second waits: 5m 300s (+100%)

Rule of thumb: Every 60 seconds of wait = 1% of test time added

Optimization Tips

• ✅ Use minimum necessary duration

• ✅ Optimize independent operations to reduce wait impact

• ✅ Review and reduce waits regularly

• ✅ Monitor performance trends

• ✅ Consider async operations for long-running tasks

---

Troubleshooting

Issue: Wait seems too short, test fails intermittently

Solution:

1. Add 30% buffer to current wait time

2. Run test multiple times to confirm

3. Check if system is under load (affects timing)

4. Consider using monitoring instead of fixed wait

Issue: Wait seems too long, slowing tests

Solution:

1. Gradually reduce wait time (test each step)

2. Look for operation completion indicators

3. Switch to polling if available

4. Run during different times to see if timing varies

Issue: Wait duration varies based on load

Solution:

1. Use longer wait time to account for peak load

2. Combine with Retry action for flexibility

3. Consider time-of-day scheduling

4. Monitor and adjust based on metrics

Issue: Test still fails after wait

Symptoms:

• Operation timeout after wait

• Expected data not available

Causes:

• System under heavy load

• Operation taking longer than expected

• Wait placement is incorrect

Solutions:

1. Increase wait duration

2. Add Retry logic with exponential backoff

3. Add intermediate verification step

4. Check system health/performance

---

Advanced Configuration

Conditional Wait

Wait Action
├── Base Duration: 5 seconds
├── Condition: IF previous_step_slow
├── Extended Duration: 10 seconds
└── Description: "Adaptive wait based on system state"

Wait with Maximum

Wait Action
├── Target Duration: Until system_ready
├── Maximum Wait: 60 seconds
├── Check Interval: 2 seconds
└── Description: "Poll every 2 seconds, max 60 seconds"

---

Real-World Scenarios

E-Commerce Checkout

Workflow: Complete Purchase

[Web: Add Item to Cart]
[WAIT: 2 seconds]
[Web: Proceed to Checkout]
[WAIT: 2 seconds]
[Web: Enter Payment Info]
[WAIT: 1 second]
[Web: Submit Order]
[WAIT: 3 seconds] ← For payment processing
[API: Verify Order Created]
[WAIT: 5 seconds] ← For email dispatch
[Email: Verify Order Confirmation]

API Testing with Database

Workflow: Create Resource and Verify

[API: POST /users (create user)]
[WAIT: 2 seconds] ← DB replication
[API: GET /users/{id} (verify)]
[WAIT: 1 second] ← Cache consistency
[API: GET /users/search (find by email)]
[Assertions: All calls successful]

---

Related Topics

• Retry Action - Combine with retry for resilience

• Error Handling - Alternative strategies

• Action Types Overview - All available actions

• Execution Flow - How execution works

• Workflow Patterns - Common patterns

---

Summary

• Wait pauses workflow for specified duration

• Use for synchronization between dependent operations

• Document why each wait is necessary

• Optimize duration for reliability and speed

• Combine with Retry for variable-timing operations

• Monitor impact on total test execution time

---

Next: Learn about Retry Action for handling failures automatically.