vasceannie/disbord
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
3acb779569e06574ff85f09e00befbb23c6ec2ff
disbord/tests/integration/test_ui_utils_complete_workflows.py
Travis Vasceannie 3acb779569 chore: remove .env.example and add new files for project structure 
- Deleted .env.example file as it is no longer needed.
- Added .gitignore to manage ignored files and directories.
- Introduced CLAUDE.md for AI provider integration documentation.
- Created dev.sh for development setup and scripts.
- Updated Dockerfile and Dockerfile.production for improved build processes.
- Added multiple test files and directories for comprehensive testing.
- Introduced new utility and service files for enhanced functionality.
- Organized codebase with new directories and files for better maintainability.
2025-08-27 23:00:19 -04:00

756 lines
27 KiB
Python
Raw Blame History

"""
Comprehensive integration tests for complete voice interaction workflows.
Tests end-to-end workflows integrating ui/ and utils/ packages for:
- Complete voice interaction workflow (permissions → audio → UI display)
- Quote analysis workflow (audio → processing → AI prompts → UI display)
- User consent workflow (permissions → consent UI → database → metrics)
- Admin operations workflow (permissions → UI components → utils operations)
- Database integration across ui/utils boundaries
- Performance and async coordination between packages
"""
import asyncio
from datetime import datetime, timezone
from unittest.mock import AsyncMock, MagicMock, patch
import discord
import pytest
from tests.fixtures.mock_discord import (MockDiscordGuild, MockDiscordMember,
MockInteraction, MockVoiceChannel)
from ui.components import (ConsentView, EmbedBuilder, QuoteBrowserView,
UIComponentManager)
from utils.audio_processor import AudioProcessor
from utils.metrics import MetricsCollector
from utils.permissions import can_use_voice_commands, has_admin_permissions
from utils.prompts import get_commentary_prompt, get_quote_analysis_prompt
class TestCompleteVoiceInteractionWorkflow:
"""Test complete voice interaction workflow from start to finish."""
@pytest.fixture
async def workflow_setup(self):
"""Setup complete workflow environment."""
# Create guild and users
guild = MockDiscordGuild(guild_id=123456789)
guild.owner_id = 100
# Create voice channel
voice_channel = MockVoiceChannel(channel_id=987654321)
voice_channel.guild = guild
# Create users with different permission levels
admin = MockDiscordMember(user_id=100, username="admin")
admin.guild_permissions.administrator = True
admin.guild_permissions.connect = True
regular_user = MockDiscordMember(user_id=101, username="regular_user")
regular_user.guild_permissions.connect = True
bot_user = MockDiscordMember(user_id=999, username="QuoteBot")
bot_user.guild_permissions.read_messages = True
bot_user.guild_permissions.send_messages = True
bot_user.guild_permissions.embed_links = True
# Setup voice channel permissions
voice_perms = MagicMock()
voice_perms.connect = True
voice_perms.speak = True
voice_perms.use_voice_activation = True
voice_channel.permissions_for.return_value = voice_perms
# Create managers
db_manager = AsyncMock()
consent_manager = AsyncMock()
ai_manager = AsyncMock()
memory_manager = AsyncMock()
quote_analyzer = AsyncMock()
audio_processor = AudioProcessor()
metrics_collector = MetricsCollector(port=8082)
metrics_collector.metrics_enabled = True
# Mock audio processor components
audio_processor.preprocessor.vad_model = MagicMock()
audio_processor.vad_model = audio_processor.preprocessor.vad_model
return {
"guild": guild,
"voice_channel": voice_channel,
"admin": admin,
"regular_user": regular_user,
"bot_user": bot_user,
"db_manager": db_manager,
"consent_manager": consent_manager,
"ai_manager": ai_manager,
"memory_manager": memory_manager,
"quote_analyzer": quote_analyzer,
"audio_processor": audio_processor,
"metrics_collector": metrics_collector,
}
@pytest.mark.asyncio
async def test_complete_voice_to_ui_workflow(self, workflow_setup):
"""Test complete workflow from voice input to UI display."""
setup = workflow_setup
# Step 1: Check permissions for voice interaction
user = setup["regular_user"]
guild = setup["guild"]
voice_channel = setup["voice_channel"]
# Verify user can use voice commands
assert can_use_voice_commands(user, voice_channel)
# Step 2: User joins voice channel and consent is required
consent_manager = setup["consent_manager"]
consent_manager.check_consent.return_value = False # No consent yet
consent_manager.global_opt_outs = set()
consent_manager.grant_consent.return_value = True
# Create consent UI
consent_view = ConsentView(consent_manager, guild.id)
interaction = MockInteraction()
interaction.user = user
interaction.guild = guild
# Step 3: User grants consent
await consent_view.give_consent(interaction, MagicMock())
# Verify consent granted
consent_manager.grant_consent.assert_called_once_with(user.id, guild.id)
assert user.id in consent_view.responses
# Step 4: Audio is recorded and processed
mock_audio_data = b"fake_audio_data" * 1000 # Mock audio bytes
with patch.object(
setup["audio_processor"], "process_audio_clip"
) as mock_process:
mock_process.return_value = mock_audio_data
processed_audio = await setup["audio_processor"].process_audio_clip(
mock_audio_data, source_format="wav"
)
assert processed_audio == mock_audio_data
# Step 5: Voice activity detection
with patch.object(
setup["audio_processor"], "detect_voice_activity"
) as mock_vad:
mock_vad.return_value = [(0.5, 2.3), (3.1, 5.8)] # Voice segments
voice_segments = await setup["audio_processor"].detect_voice_activity(
mock_audio_data
)
assert len(voice_segments) == 2
# Step 6: Quote analysis using AI prompts
quote_text = "This is a hilarious quote that everyone loved"
context = {
"conversation": "Gaming session chat",
"laughter_duration": 2.5,
"laughter_intensity": 0.8,
}
# Generate AI prompt
analysis_prompt = get_quote_analysis_prompt(
quote=quote_text, speaker=user.username, context=context, provider="openai"
)
assert quote_text in analysis_prompt
assert user.username in analysis_prompt
# Mock AI analysis result
analysis_result = {
"funny_score": 8.5,
"dark_score": 1.2,
"silly_score": 7.8,
"suspicious_score": 0.5,
"asinine_score": 2.1,
"overall_score": 7.8,
"reasoning": "High humor score due to timing and wordplay",
"confidence": 0.92,
}
setup["ai_manager"].analyze_quote.return_value = analysis_result
# Step 7: Store quote in database
quote_data = {
"id": 123,
"user_id": user.id,
"guild_id": guild.id,
"quote": quote_text,
"timestamp": datetime.now(timezone.utc),
"username": user.username,
**analysis_result,
}
setup["db_manager"].store_quote.return_value = quote_data
# Step 8: Create UI display with all integrated data
embed = EmbedBuilder.create_quote_embed(quote_data, include_analysis=True)
assert isinstance(embed, discord.Embed)
assert quote_text in embed.description
assert "8.5" in str(embed.to_dict()) # Funny score
# Step 9: Collect metrics throughout the workflow
metrics = setup["metrics_collector"]
with patch.object(metrics, "increment") as mock_metrics:
# Simulate metrics collection at each step
metrics.increment("consent_actions", {"action": "granted"})
metrics.increment("audio_clips_processed", {"status": "success"})
metrics.increment("quotes_detected", {"guild_id": str(guild.id)})
metrics.increment("commands_executed", {"command": "quote_display"})
assert mock_metrics.call_count == 4
@pytest.mark.asyncio
async def test_quote_analysis_pipeline_with_feedback(self, workflow_setup):
"""Test complete quote analysis pipeline with user feedback."""
setup = workflow_setup
# Step 1: Quote is analyzed and displayed
quote_data = {
"id": 456,
"quote": "Why don't scientists trust atoms? Because they make up everything!",
"username": "ComedyKing",
"user_id": setup["regular_user"].id,
"guild_id": setup["guild"].id,
"funny_score": 7.5,
"dark_score": 0.8,
"silly_score": 6.2,
"suspicious_score": 0.3,
"asinine_score": 4.1,
"overall_score": 6.8,
"timestamp": datetime.now(timezone.utc),
}
# Step 2: Create UI with feedback capability
ui_manager = UIComponentManager(
bot=AsyncMock(),
db_manager=setup["db_manager"],
consent_manager=setup["consent_manager"],
memory_manager=setup["memory_manager"],
quote_analyzer=setup["quote_analyzer"],
)
embed, feedback_view = await ui_manager.create_quote_display_with_feedback(
quote_data
)
assert isinstance(embed, discord.Embed)
assert feedback_view is not None
# Step 3: User provides feedback
interaction = MockInteraction()
interaction.user = setup["regular_user"]
await feedback_view.positive_feedback(interaction, MagicMock())
# Step 4: Feedback is stored and metrics collected
setup["db_manager"].execute_query.assert_called() # Feedback stored
# Step 5: Generate commentary based on analysis and feedback
commentary_prompt = get_commentary_prompt(
quote_data=quote_data,
context={
"personality": "Known for dad jokes and puns",
"recent_interactions": "Active in chat today",
"conversation": "Casual conversation",
"user_feedback": "positive",
},
provider="anthropic",
)
assert quote_data["quote"] in commentary_prompt
assert "positive" in commentary_prompt or "dad jokes" in commentary_prompt
@pytest.mark.asyncio
async def test_user_consent_workflow_integration(self, workflow_setup):
"""Test complete user consent workflow across packages."""
setup = workflow_setup
user = setup["regular_user"]
guild = setup["guild"]
# Step 1: Check initial consent status
setup["consent_manager"].check_consent.return_value = False
# Step 2: Create consent interface
ui_manager = UIComponentManager(
bot=AsyncMock(),
db_manager=setup["db_manager"],
consent_manager=setup["consent_manager"],
memory_manager=setup["memory_manager"],
quote_analyzer=setup["quote_analyzer"],
)
embed, view = await ui_manager.create_consent_interface(user.id, guild.id)
assert isinstance(embed, discord.Embed)
assert view is not None
# Step 3: User grants consent through UI
interaction = MockInteraction()
interaction.user = user
interaction.guild = guild
setup["consent_manager"].grant_consent.return_value = True
await view.give_consent(interaction, MagicMock())
# Step 4: Verify database is updated
setup["consent_manager"].grant_consent.assert_called_once_with(
user.id, guild.id
)
# Step 5: Metrics are collected
with patch.object(setup["metrics_collector"], "increment") as mock_metrics:
setup["metrics_collector"].increment(
"consent_actions",
labels={"action": "granted", "guild_id": str(guild.id)},
)
mock_metrics.assert_called()
# Step 6: User can now participate in voice recording
assert can_use_voice_commands(user, setup["voice_channel"])
@pytest.mark.asyncio
async def test_admin_operations_workflow(self, workflow_setup):
"""Test admin operations workflow using permissions and UI."""
setup = workflow_setup
admin = setup["admin"]
guild = setup["guild"]
# Step 1: Verify admin permissions
assert await has_admin_permissions(admin, guild)
# Step 2: Admin accesses quote management
all_quotes = [
{
"id": i,
"quote": f"Quote {i}",
"user_id": 200 + i,
"username": f"User{i}",
"guild_id": guild.id,
"timestamp": datetime.now(timezone.utc),
"funny_score": 5.0 + i,
"dark_score": 2.0,
"silly_score": 4.0 + i,
"suspicious_score": 1.0,
"asinine_score": 3.0,
"overall_score": 5.0 + i,
}
for i in range(10)
]
setup["db_manager"].execute_query.return_value = all_quotes
# Step 3: Create admin quote browser (can see all quotes)
admin_browser = QuoteBrowserView(
db_manager=setup["db_manager"],
user_id=admin.id,
guild_id=guild.id,
quotes=all_quotes,
)
# Step 4: Admin can filter and manage quotes
admin_interaction = MockInteraction()
admin_interaction.user = admin
admin_interaction.guild = guild
select = MagicMock()
select.values = ["all"]
await admin_browser.category_filter(admin_interaction, select)
# Should execute admin-level query
setup["db_manager"].execute_query.assert_called()
# Step 5: Admin operations are logged
with patch.object(setup["metrics_collector"], "increment") as mock_metrics:
setup["metrics_collector"].increment(
"commands_executed",
labels={
"command": "admin_quote_filter",
"status": "success",
"guild_id": str(guild.id),
},
)
mock_metrics.assert_called()
@pytest.mark.asyncio
async def test_database_transaction_workflow(self, workflow_setup):
"""Test database transactions across ui/utils boundaries."""
setup = workflow_setup
db_manager = setup["db_manager"]
# Mock database transaction methods
db_manager.begin_transaction = AsyncMock()
db_manager.commit_transaction = AsyncMock()
db_manager.rollback_transaction = AsyncMock()
# Step 1: Begin transaction for complex operation
await db_manager.begin_transaction()
try:
# Step 2: Store quote data
quote_data = {
"user_id": setup["regular_user"].id,
"guild_id": setup["guild"].id,
"quote": "This is a test quote for transaction",
"funny_score": 7.0,
"overall_score": 6.5,
}
db_manager.store_quote.return_value = {"id": 789, **quote_data}
await db_manager.store_quote(quote_data)
# Step 3: Update user statistics
db_manager.update_user_stats.return_value = True
await db_manager.update_user_stats(
setup["regular_user"].id,
setup["guild"].id,
{"total_quotes": 1, "avg_score": 6.5},
)
# Step 4: Record metrics
db_manager.record_metric.return_value = True
await db_manager.record_metric(
{
"event": "quote_stored",
"user_id": setup["regular_user"].id,
"guild_id": setup["guild"].id,
"timestamp": datetime.now(timezone.utc),
}
)
# Step 5: Commit transaction
await db_manager.commit_transaction()
# Verify all operations were called
db_manager.store_quote.assert_called_once()
db_manager.update_user_stats.assert_called_once()
db_manager.record_metric.assert_called_once()
db_manager.commit_transaction.assert_called_once()
except Exception:
# Step 6: Rollback on error
await db_manager.rollback_transaction()
db_manager.rollback_transaction.assert_called_once()
@pytest.mark.asyncio
async def test_error_handling_across_workflow(self, workflow_setup):
"""Test error handling and recovery across the complete workflow."""
setup = workflow_setup
# Step 1: Simulate audio processing failure
with patch.object(
setup["audio_processor"], "process_audio_clip"
) as mock_process:
mock_process.return_value = None # Processing failed
result = await setup["audio_processor"].process_audio_clip(b"bad_data")
assert result is None
# Step 2: UI should handle processing failure gracefully
embed = EmbedBuilder.error(
"Audio Processing Failed", "Could not process audio clip. Please try again."
)
assert isinstance(embed, discord.Embed)
assert "Failed" in embed.title
# Step 3: Error should be logged in metrics
with patch.object(setup["metrics_collector"], "increment") as mock_metrics:
setup["metrics_collector"].increment(
"errors",
labels={"error_type": "audio_processing", "component": "workflow"},
)
mock_metrics.assert_called()
# Step 4: System should continue working after error
# Test that other operations still work
consent_view = ConsentView(setup["consent_manager"], setup["guild"].id)
assert consent_view is not None
@pytest.mark.asyncio
async def test_performance_coordination_across_packages(self, workflow_setup):
"""Test performance and async coordination between packages."""
# Step 1: Simulate concurrent operations across packages
async def audio_processing_task():
await asyncio.sleep(0.1) # Simulate processing time
return {"status": "audio_completed", "duration": 0.1}
async def database_operation_task():
await asyncio.sleep(0.05) # Faster database operation
return {"status": "db_completed", "duration": 0.05}
async def ui_update_task():
await asyncio.sleep(0.02) # Fast UI update
return {"status": "ui_completed", "duration": 0.02}
async def metrics_collection_task():
await asyncio.sleep(0.01) # Very fast metrics
return {"status": "metrics_completed", "duration": 0.01}
# Step 2: Run tasks concurrently
start_time = asyncio.get_event_loop().time()
tasks = [
audio_processing_task(),
database_operation_task(),
ui_update_task(),
metrics_collection_task(),
]
results = await asyncio.gather(*tasks)
end_time = asyncio.get_event_loop().time()
total_duration = end_time - start_time
# Step 3: Verify concurrent execution
# Total time should be less than sum of individual times
individual_times = sum(result["duration"] for result in results)
assert total_duration < individual_times
# Step 4: Verify all operations completed
assert len(results) == 4
statuses = [result["status"] for result in results]
assert "audio_completed" in statuses
assert "db_completed" in statuses
assert "ui_completed" in statuses
assert "metrics_completed" in statuses
@pytest.mark.asyncio
async def test_resource_cleanup_workflow(self, workflow_setup):
"""Test proper resource cleanup across the workflow."""
setup = workflow_setup
# Step 1: Create resources that need cleanup
resources = {
"temp_files": [],
"db_connections": [],
"audio_buffers": [],
"ui_views": [],
}
try:
# Step 2: Simulate resource allocation
# Mock temporary file creation
temp_file = "/tmp/test_audio.wav"
resources["temp_files"].append(temp_file)
# Mock database connection
db_conn = AsyncMock()
resources["db_connections"].append(db_conn)
# Mock audio buffer
audio_buffer = b"audio_data" * 1000
resources["audio_buffers"].append(audio_buffer)
# Mock UI view
consent_view = ConsentView(setup["consent_manager"], setup["guild"].id)
resources["ui_views"].append(consent_view)
# Step 3: Process with resources
assert len(resources["temp_files"]) == 1
assert len(resources["db_connections"]) == 1
assert len(resources["audio_buffers"]) == 1
assert len(resources["ui_views"]) == 1
finally:
# Step 4: Cleanup resources
for temp_file in resources["temp_files"]:
# Would clean up temp files
pass
for db_conn in resources["db_connections"]:
await db_conn.close()
for buffer in resources["audio_buffers"]:
# Would clear audio buffers
del buffer
for view in resources["ui_views"]:
# Would stop UI views
view.stop()
# Verify cleanup
for db_conn in resources["db_connections"]:
db_conn.close.assert_called_once()
@pytest.mark.asyncio
async def test_scalability_under_load(self, workflow_setup):
"""Test workflow scalability under concurrent load."""
async def simulate_user_interaction(user_id):
"""Simulate a complete user interaction workflow."""
# Create mock user
user = MockDiscordMember(user_id=user_id, username=f"User{user_id}")
user.guild_permissions.connect = True
# Simulate workflow steps
await asyncio.sleep(0.001) # Permission check
await asyncio.sleep(0.002) # Consent check
await asyncio.sleep(0.005) # Audio processing
await asyncio.sleep(0.003) # AI analysis
await asyncio.sleep(0.001) # Database storage
await asyncio.sleep(0.001) # UI update
await asyncio.sleep(0.001) # Metrics collection
return {
"user_id": user_id,
"status": "completed",
"steps": 7,
}
# Step 1: Simulate many concurrent users
concurrent_users = 50
start_time = asyncio.get_event_loop().time()
tasks = [simulate_user_interaction(i) for i in range(concurrent_users)]
results = await asyncio.gather(*tasks)
end_time = asyncio.get_event_loop().time()
total_duration = end_time - start_time
# Step 2: Verify all interactions completed
assert len(results) == concurrent_users
assert all(result["status"] == "completed" for result in results)
# Step 3: Verify reasonable performance
# Should handle 50 users in under 2 seconds
assert (
total_duration < 2.0
), f"Too slow: {total_duration}s for {concurrent_users} users"
# Step 4: Calculate throughput
throughput = concurrent_users / total_duration
assert throughput > 25, f"Low throughput: {throughput} users/second"
class TestWorkflowEdgeCases:
"""Test edge cases and error scenarios in complete workflows."""
@pytest.mark.asyncio
async def test_partial_workflow_failure_recovery(self):
"""Test recovery from partial workflow failures."""
# Step 1: Setup workflow that fails mid-way
consent_manager = AsyncMock()
consent_manager.check_consent.return_value = True
audio_processor = AudioProcessor()
audio_processor.preprocessor.vad_model = MagicMock()
# Step 2: Simulate failure during audio processing
with patch.object(audio_processor, "process_audio_clip") as mock_process:
mock_process.side_effect = Exception("Processing failed")
try:
await audio_processor.process_audio_clip(b"test_data")
pytest.fail("Should have raised exception")
except Exception as e:
assert "Processing failed" in str(e)
# Step 3: Verify system can continue with other operations
# UI should still work
embed = EmbedBuilder.warning(
"Processing Issue",
"Audio processing failed, but you can still use other features.",
)
assert isinstance(embed, discord.Embed)
assert "Processing Issue" in embed.title
@pytest.mark.asyncio
async def test_timeout_handling_in_workflows(self):
"""Test timeout handling across workflow components."""
# Create slow operations
async def slow_audio_processing():
await asyncio.sleep(10) # Very slow
return "result"
async def slow_database_operation():
await asyncio.sleep(5) # Moderately slow
return "db_result"
# Test individual component timeouts
with pytest.raises(asyncio.TimeoutError):
await asyncio.wait_for(slow_audio_processing(), timeout=0.1)
with pytest.raises(asyncio.TimeoutError):
await asyncio.wait_for(slow_database_operation(), timeout=0.1)
# Test that UI remains responsive during timeouts
embed = EmbedBuilder.warning(
"Operation Timeout",
"The operation is taking longer than expected. Please try again.",
)
assert isinstance(embed, discord.Embed)
@pytest.mark.asyncio
async def test_memory_pressure_handling(self):
"""Test workflow behavior under memory pressure."""
# Simulate memory-intensive operations
large_data_chunks = []
try:
# Allocate large amounts of data
for i in range(100):
# Simulate large audio/data processing
chunk = bytearray(1024 * 1024) # 1MB chunks
large_data_chunks.append(chunk)
# Simulate workflow continuing under memory pressure
consent_manager = AsyncMock()
consent_view = ConsentView(consent_manager, 123)
# Should still work even with memory pressure
assert consent_view is not None
finally:
# Cleanup memory
large_data_chunks.clear()
@pytest.mark.asyncio
async def test_network_interruption_handling(self):
"""Test workflow handling of network interruptions."""
# Mock network-dependent operations
db_manager = AsyncMock()
ai_manager = AsyncMock()
# Simulate network failures
db_manager.store_quote.side_effect = Exception("Network timeout")
ai_manager.analyze_quote.side_effect = Exception("API unreachable")
# Workflow should handle network errors gracefully
try:
await db_manager.store_quote({})
pytest.fail("Should have raised network error")
except Exception as e:
assert "Network timeout" in str(e)
try:
await ai_manager.analyze_quote("test")
pytest.fail("Should have raised API error")
except Exception as e:
assert "API unreachable" in str(e)
# UI should show appropriate error messages
embed = EmbedBuilder.error(
"Connection Issue",
"Network connectivity issues detected. Some features may be unavailable.",
)
assert isinstance(embed, discord.Embed)
assert "Connection Issue" in embed.title
Reference in New Issue View Git Blame Copy Permalink