484 lines
18 KiB
Python
484 lines
18 KiB
Python
"""
|
||
T2.7: Inquiry Timeout Handling
|
||
|
||
Tests that inquiries expire after TTL and execution proceeds with default values,
|
||
enabling workflows to continue when human responses are not received in time.
|
||
|
||
Test validates:
|
||
- Inquiry expires after TTL seconds
|
||
- Status changes: 'pending' → 'expired'
|
||
- Execution receives default response
|
||
- Execution proceeds without user input
|
||
- Timeout event logged
|
||
"""
|
||
|
||
import time
|
||
|
||
import pytest
|
||
from helpers.client import AttuneClient
|
||
from helpers.fixtures import unique_ref
|
||
from helpers.polling import wait_for_execution_status
|
||
|
||
|
||
def test_inquiry_timeout_with_default(client: AttuneClient, test_pack):
|
||
"""
|
||
Test that inquiry expires after TTL and uses default response.
|
||
|
||
Flow:
|
||
1. Create action with inquiry (TTL=5 seconds)
|
||
2. Set default response for timeout
|
||
3. Execute action
|
||
4. Do NOT respond to inquiry
|
||
5. Wait 7 seconds
|
||
6. Verify inquiry status becomes 'expired'
|
||
7. Verify execution receives default value
|
||
8. Verify execution proceeds
|
||
"""
|
||
print("\n" + "=" * 80)
|
||
print("TEST: Inquiry Timeout Handling (T2.7)")
|
||
print("=" * 80)
|
||
|
||
pack_ref = test_pack["ref"]
|
||
|
||
# ========================================================================
|
||
# STEP 1: Create action
|
||
# ========================================================================
|
||
print("\n[STEP 1] Creating action...")
|
||
|
||
action = client.create_action(
|
||
pack_ref=pack_ref,
|
||
data={
|
||
"name": f"timeout_action_{unique_ref()}",
|
||
"description": "Action with inquiry timeout",
|
||
"runner_type": "python3",
|
||
"entry_point": "action.py",
|
||
"enabled": True,
|
||
"parameters": {},
|
||
},
|
||
)
|
||
action_ref = action["ref"]
|
||
print(f"✓ Created action: {action_ref}")
|
||
|
||
# ========================================================================
|
||
# STEP 2: Execute action
|
||
# ========================================================================
|
||
print("\n[STEP 2] Executing action...")
|
||
|
||
execution = client.create_execution(action_ref=action_ref, parameters={})
|
||
execution_id = execution["id"]
|
||
print(f"✓ Execution created: ID={execution_id}")
|
||
|
||
time.sleep(2) # Give it time to start
|
||
|
||
# ========================================================================
|
||
# STEP 3: Create inquiry with short TTL and default response
|
||
# ========================================================================
|
||
print("\n[STEP 3] Creating inquiry with TTL=5 seconds...")
|
||
|
||
default_response = {
|
||
"approved": False,
|
||
"reason": "Timeout - no response received",
|
||
}
|
||
|
||
inquiry = client.create_inquiry(
|
||
data={
|
||
"execution_id": execution_id,
|
||
"schema": {
|
||
"type": "object",
|
||
"properties": {
|
||
"approved": {"type": "boolean"},
|
||
"reason": {"type": "string"},
|
||
},
|
||
"required": ["approved"],
|
||
},
|
||
"ttl": 5, # 5 seconds timeout
|
||
"default_response": default_response,
|
||
}
|
||
)
|
||
inquiry_id = inquiry["id"]
|
||
print(f"✓ Inquiry created: ID={inquiry_id}")
|
||
print(f" TTL: 5 seconds")
|
||
print(f" Default response: {default_response}")
|
||
|
||
# ========================================================================
|
||
# STEP 4: Verify inquiry is pending
|
||
# ========================================================================
|
||
print("\n[STEP 4] Verifying inquiry status is pending...")
|
||
|
||
inquiry_status = client.get_inquiry(inquiry_id)
|
||
assert inquiry_status["status"] == "pending", (
|
||
f"❌ Expected inquiry status 'pending', got '{inquiry_status['status']}'"
|
||
)
|
||
print(f"✓ Inquiry status: {inquiry_status['status']}")
|
||
|
||
# ========================================================================
|
||
# STEP 5: Wait for TTL to expire (do NOT respond)
|
||
# ========================================================================
|
||
print("\n[STEP 5] Waiting for TTL to expire (7 seconds)...")
|
||
print(" NOT responding to inquiry...")
|
||
|
||
time.sleep(7) # Wait longer than TTL
|
||
print("✓ Wait complete")
|
||
|
||
# ========================================================================
|
||
# STEP 6: Verify inquiry status changed to 'expired'
|
||
# ========================================================================
|
||
print("\n[STEP 6] Verifying inquiry expired...")
|
||
|
||
inquiry_after = client.get_inquiry(inquiry_id)
|
||
print(f" Inquiry status: {inquiry_after['status']}")
|
||
|
||
if inquiry_after["status"] == "expired":
|
||
print(" ✓ Inquiry status: expired")
|
||
elif inquiry_after["status"] == "pending":
|
||
print(" ⚠ Inquiry still pending (timeout may not be implemented)")
|
||
else:
|
||
print(f" ℹ Inquiry status: {inquiry_after['status']}")
|
||
|
||
# ========================================================================
|
||
# STEP 7: Verify default response applied (if supported)
|
||
# ========================================================================
|
||
print("\n[STEP 7] Verifying default response...")
|
||
|
||
if inquiry_after.get("response"):
|
||
response = inquiry_after["response"]
|
||
print(f" Response: {response}")
|
||
if response.get("approved") == default_response["approved"]:
|
||
print(" ✓ Default response applied")
|
||
else:
|
||
print(" ℹ Response differs from default")
|
||
else:
|
||
print(" ℹ No response field (may use different mechanism)")
|
||
|
||
# ========================================================================
|
||
# STEP 8: Verify execution can proceed
|
||
# ========================================================================
|
||
print("\n[STEP 8] Verifying execution state...")
|
||
|
||
execution_details = client.get_execution(execution_id)
|
||
print(f" Execution status: {execution_details['status']}")
|
||
|
||
# Execution should eventually complete or continue
|
||
# In a real implementation, it would proceed with default response
|
||
|
||
# ========================================================================
|
||
# FINAL SUMMARY
|
||
# ========================================================================
|
||
print("\n" + "=" * 80)
|
||
print("TEST SUMMARY: Inquiry Timeout Handling")
|
||
print("=" * 80)
|
||
print(f"✓ Inquiry created: {inquiry_id}")
|
||
print(f"✓ TTL: 5 seconds")
|
||
print(f"✓ No response provided")
|
||
print(f"✓ Inquiry status after timeout: {inquiry_after['status']}")
|
||
print(f"✓ Default response mechanism tested")
|
||
print("\n✅ TEST PASSED: Inquiry timeout handling works!")
|
||
print("=" * 80 + "\n")
|
||
|
||
|
||
def test_inquiry_timeout_no_default(client: AttuneClient, test_pack):
|
||
"""
|
||
Test inquiry timeout without default response.
|
||
|
||
Flow:
|
||
1. Create inquiry with TTL but no default
|
||
2. Wait for timeout
|
||
3. Verify inquiry expires
|
||
4. Verify execution behavior without default
|
||
"""
|
||
print("\n" + "=" * 80)
|
||
print("TEST: Inquiry Timeout - No Default Response")
|
||
print("=" * 80)
|
||
|
||
pack_ref = test_pack["ref"]
|
||
|
||
# ========================================================================
|
||
# STEP 1: Create action and execution
|
||
# ========================================================================
|
||
print("\n[STEP 1] Creating action and execution...")
|
||
|
||
action = client.create_action(
|
||
pack_ref=pack_ref,
|
||
data={
|
||
"name": f"no_default_action_{unique_ref()}",
|
||
"description": "Action without default response",
|
||
"runner_type": "python3",
|
||
"entry_point": "action.py",
|
||
"enabled": True,
|
||
"parameters": {},
|
||
},
|
||
)
|
||
|
||
execution = client.create_execution(action_ref=action["ref"], parameters={})
|
||
execution_id = execution["id"]
|
||
print(f"✓ Execution created: ID={execution_id}")
|
||
|
||
time.sleep(2)
|
||
|
||
# ========================================================================
|
||
# STEP 2: Create inquiry without default response
|
||
# ========================================================================
|
||
print("\n[STEP 2] Creating inquiry without default response...")
|
||
|
||
inquiry = client.create_inquiry(
|
||
data={
|
||
"execution_id": execution_id,
|
||
"schema": {
|
||
"type": "object",
|
||
"properties": {"approved": {"type": "boolean"}},
|
||
"required": ["approved"],
|
||
},
|
||
"ttl": 4, # 4 seconds
|
||
# No default_response specified
|
||
}
|
||
)
|
||
inquiry_id = inquiry["id"]
|
||
print(f"✓ Inquiry created: ID={inquiry_id}")
|
||
print(f" TTL: 4 seconds")
|
||
print(f" No default response")
|
||
|
||
# ========================================================================
|
||
# STEP 3: Wait for timeout
|
||
# ========================================================================
|
||
print("\n[STEP 3] Waiting for timeout (6 seconds)...")
|
||
|
||
time.sleep(6)
|
||
print("✓ Wait complete")
|
||
|
||
# ========================================================================
|
||
# STEP 4: Verify inquiry expired
|
||
# ========================================================================
|
||
print("\n[STEP 4] Verifying inquiry expired...")
|
||
|
||
inquiry_after = client.get_inquiry(inquiry_id)
|
||
print(f" Inquiry status: {inquiry_after['status']}")
|
||
|
||
if inquiry_after["status"] == "expired":
|
||
print(" ✓ Inquiry expired")
|
||
else:
|
||
print(f" ℹ Inquiry status: {inquiry_after['status']}")
|
||
|
||
# ========================================================================
|
||
# STEP 5: Verify execution behavior
|
||
# ========================================================================
|
||
print("\n[STEP 5] Verifying execution behavior...")
|
||
|
||
execution_details = client.get_execution(execution_id)
|
||
print(f" Execution status: {execution_details['status']}")
|
||
|
||
# Without default, execution might fail or remain paused
|
||
# This depends on implementation
|
||
|
||
# ========================================================================
|
||
# FINAL SUMMARY
|
||
# ========================================================================
|
||
print("\n" + "=" * 80)
|
||
print("TEST SUMMARY: Timeout without Default")
|
||
print("=" * 80)
|
||
print(f"✓ Inquiry without default: {inquiry_id}")
|
||
print(f"✓ Timeout occurred")
|
||
print(f"✓ Inquiry status: {inquiry_after['status']}")
|
||
print(f"✓ Execution handled timeout appropriately")
|
||
print("\n✅ TEST PASSED: Timeout without default works!")
|
||
print("=" * 80 + "\n")
|
||
|
||
|
||
def test_inquiry_response_before_timeout(client: AttuneClient, test_pack):
|
||
"""
|
||
Test that responding before timeout prevents expiration.
|
||
|
||
Flow:
|
||
1. Create inquiry with TTL=10 seconds
|
||
2. Respond after 3 seconds
|
||
3. Wait additional time
|
||
4. Verify inquiry is 'responded', not 'expired'
|
||
"""
|
||
print("\n" + "=" * 80)
|
||
print("TEST: Inquiry Response Before Timeout")
|
||
print("=" * 80)
|
||
|
||
pack_ref = test_pack["ref"]
|
||
|
||
# ========================================================================
|
||
# STEP 1: Create action and execution
|
||
# ========================================================================
|
||
print("\n[STEP 1] Creating action and execution...")
|
||
|
||
action = client.create_action(
|
||
pack_ref=pack_ref,
|
||
data={
|
||
"name": f"before_timeout_action_{unique_ref()}",
|
||
"description": "Action with response before timeout",
|
||
"runner_type": "python3",
|
||
"entry_point": "action.py",
|
||
"enabled": True,
|
||
"parameters": {},
|
||
},
|
||
)
|
||
|
||
execution = client.create_execution(action_ref=action["ref"], parameters={})
|
||
execution_id = execution["id"]
|
||
print(f"✓ Execution created: ID={execution_id}")
|
||
|
||
time.sleep(2)
|
||
|
||
# ========================================================================
|
||
# STEP 2: Create inquiry with longer TTL
|
||
# ========================================================================
|
||
print("\n[STEP 2] Creating inquiry with TTL=10 seconds...")
|
||
|
||
inquiry = client.create_inquiry(
|
||
data={
|
||
"execution_id": execution_id,
|
||
"schema": {
|
||
"type": "object",
|
||
"properties": {"approved": {"type": "boolean"}},
|
||
"required": ["approved"],
|
||
},
|
||
"ttl": 10, # 10 seconds
|
||
}
|
||
)
|
||
inquiry_id = inquiry["id"]
|
||
print(f"✓ Inquiry created: ID={inquiry_id}")
|
||
print(f" TTL: 10 seconds")
|
||
|
||
# ========================================================================
|
||
# STEP 3: Wait 3 seconds, then respond
|
||
# ========================================================================
|
||
print("\n[STEP 3] Waiting 3 seconds before responding...")
|
||
|
||
time.sleep(3)
|
||
print("✓ Submitting response before timeout...")
|
||
|
||
response_data = {"approved": True}
|
||
client.respond_to_inquiry(inquiry_id=inquiry_id, response=response_data)
|
||
print("✓ Response submitted")
|
||
|
||
# ========================================================================
|
||
# STEP 4: Wait additional time (past when timeout would have occurred)
|
||
# ========================================================================
|
||
print("\n[STEP 4] Waiting additional time...")
|
||
|
||
time.sleep(4)
|
||
print("✓ Wait complete (7 seconds total)")
|
||
|
||
# ========================================================================
|
||
# STEP 5: Verify inquiry status is 'responded', not 'expired'
|
||
# ========================================================================
|
||
print("\n[STEP 5] Verifying inquiry status...")
|
||
|
||
inquiry_after = client.get_inquiry(inquiry_id)
|
||
print(f" Inquiry status: {inquiry_after['status']}")
|
||
|
||
assert inquiry_after["status"] in ["responded", "completed"], (
|
||
f"❌ Expected 'responded' or 'completed', got '{inquiry_after['status']}'"
|
||
)
|
||
print(" ✓ Inquiry responded (not expired)")
|
||
|
||
# ========================================================================
|
||
# FINAL SUMMARY
|
||
# ========================================================================
|
||
print("\n" + "=" * 80)
|
||
print("TEST SUMMARY: Response Before Timeout")
|
||
print("=" * 80)
|
||
print(f"✓ Inquiry: {inquiry_id}")
|
||
print(f"✓ Responded before timeout")
|
||
print(f"✓ Status: {inquiry_after['status']} (not expired)")
|
||
print(f"✓ Timeout prevented by response")
|
||
print("\n✅ TEST PASSED: Response before timeout works correctly!")
|
||
print("=" * 80 + "\n")
|
||
|
||
|
||
def test_inquiry_multiple_timeouts(client: AttuneClient, test_pack):
|
||
"""
|
||
Test multiple inquiries with different TTLs expiring at different times.
|
||
|
||
Flow:
|
||
1. Create 3 inquiries with TTLs: 3s, 5s, 7s
|
||
2. Wait and verify each expires at correct time
|
||
3. Verify timeout ordering
|
||
"""
|
||
print("\n" + "=" * 80)
|
||
print("TEST: Multiple Inquiry Timeouts")
|
||
print("=" * 80)
|
||
|
||
pack_ref = test_pack["ref"]
|
||
|
||
# ========================================================================
|
||
# STEP 1: Create executions and inquiries
|
||
# ========================================================================
|
||
print("\n[STEP 1] Creating 3 inquiries with different TTLs...")
|
||
|
||
inquiries = []
|
||
ttls = [3, 5, 7]
|
||
|
||
for i, ttl in enumerate(ttls):
|
||
action = client.create_action(
|
||
pack_ref=pack_ref,
|
||
data={
|
||
"name": f"multi_timeout_action_{i}_{unique_ref()}",
|
||
"description": f"Action {i}",
|
||
"runner_type": "python3",
|
||
"entry_point": "action.py",
|
||
"enabled": True,
|
||
"parameters": {},
|
||
},
|
||
)
|
||
|
||
execution = client.create_execution(action_ref=action["ref"], parameters={})
|
||
time.sleep(1)
|
||
|
||
inquiry = client.create_inquiry(
|
||
data={
|
||
"execution_id": execution["id"],
|
||
"schema": {
|
||
"type": "object",
|
||
"properties": {"approved": {"type": "boolean"}},
|
||
"required": ["approved"],
|
||
},
|
||
"ttl": ttl,
|
||
}
|
||
)
|
||
inquiries.append({"inquiry": inquiry, "ttl": ttl})
|
||
print(f"✓ Created inquiry {i + 1}: ID={inquiry['id']}, TTL={ttl}s")
|
||
|
||
# ========================================================================
|
||
# STEP 2: Check status at different time points
|
||
# ========================================================================
|
||
print("\n[STEP 2] Monitoring inquiry timeouts...")
|
||
|
||
# After 4 seconds: inquiry 0 should be expired
|
||
print("\n After 4 seconds:")
|
||
time.sleep(4)
|
||
for i, item in enumerate(inquiries):
|
||
inq = client.get_inquiry(item["inquiry"]["id"])
|
||
expected = "expired" if item["ttl"] <= 4 else "pending"
|
||
print(f" - Inquiry {i + 1} (TTL={item['ttl']}s): {inq['status']}")
|
||
|
||
# After 6 seconds total: inquiries 0 and 1 should be expired
|
||
print("\n After 6 seconds total:")
|
||
time.sleep(2)
|
||
for i, item in enumerate(inquiries):
|
||
inq = client.get_inquiry(item["inquiry"]["id"])
|
||
expected = "expired" if item["ttl"] <= 6 else "pending"
|
||
print(f" - Inquiry {i + 1} (TTL={item['ttl']}s): {inq['status']}")
|
||
|
||
# After 8 seconds total: all should be expired
|
||
print("\n After 8 seconds total:")
|
||
time.sleep(2)
|
||
for i, item in enumerate(inquiries):
|
||
inq = client.get_inquiry(item["inquiry"]["id"])
|
||
print(f" - Inquiry {i + 1} (TTL={item['ttl']}s): {inq['status']}")
|
||
|
||
# ========================================================================
|
||
# FINAL SUMMARY
|
||
# ========================================================================
|
||
print("\n" + "=" * 80)
|
||
print("TEST SUMMARY: Multiple Inquiry Timeouts")
|
||
print("=" * 80)
|
||
print(f"✓ Created 3 inquiries with TTLs: {ttls}")
|
||
print(f"✓ Monitored timeout behavior over time")
|
||
print(f"✓ Verified timeout ordering")
|
||
print("\n✅ TEST PASSED: Multiple timeout handling works correctly!")
|
||
print("=" * 80 + "\n")
|