Python SDK for AI agent monitoring, LLM cost tracking, benchmarking, and more. Integrates with most LLMs and agent frameworks including CrewAI, Agno, OpenAI Agents SDK, Langchain, Autogen, AG2, and CamelAI
Python agentagentopsagents-sdkaianthropicautogencost-estimationcrewaievalsevaluation-metricsgroqlangchainllmmistralollamaopenaiopenai-agents
"""Unit tests for the queue module."""
import json
import pytest
from unittest.mock import Mock, patch
from datetime import datetime, UTC
from jockey.worker.queue import (
queue_task,
claim_next_task,
get_task_data,
get_queue_length,
get_queued_tasks,
_get_task_key,
_get_queue_key,
_get_event_key,
TASKS_HASH_NAME,
REDIS_KEY_PREFIX,
)
from jockey.config import DeploymentConfig, TaskType
class TestQueueOperations:
"""Test the core queue operations."""
@pytest.fixture
def mock_redis(self):
"""Mock Redis client for testing."""
with patch('jockey.worker.queue._get_redis_client') as mock_get_client:
mock_client = Mock()
mock_get_client.return_value = mock_client
yield mock_client
@pytest.fixture
def sample_config(self):
"""Sample deployment configuration for testing."""
return DeploymentConfig(
project_id="test-project-id",
namespace="test-namespace",
ports=[8080, 9090],
replicas=2,
)
def test_queue_task_creates_job_data_and_queues_id(self, mock_redis, sample_config):
"""Test that queue_task creates job data and adds job ID to queue."""
# Setup
mock_redis.hset.return_value = True
mock_redis.rpush.return_value = 1
# Execute
job_id = queue_task(TaskType.SERVE, sample_config, "project-456")
# Verify job ID format (full UUID)
assert len(job_id) == 36 # Full UUID string
assert job_id.count('-') == 4 # UUID format
# Verify job data was stored in composite hash
assert mock_redis.hset.call_count == 1
hash_call = mock_redis.hset.call_args
hash_name = hash_call[0][0]
composite_key = hash_call[0][1]
job_data_json = hash_call[0][2]
assert hash_name == TASKS_HASH_NAME
assert composite_key == f"test-namespace:project-456:{job_id}"
# Parse and verify job data
job_data = json.loads(job_data_json)
assert job_data["job_id"] == job_id
assert job_data["project_id"] == "project-456"
assert job_data["namespace"] == "test-namespace"
assert "queued_at" in job_data
assert "config" in job_data
# Verify config was serialized
config_data = job_data["config"]
assert config_data["project_id"] == "test-project-id"
assert config_data["namespace"] == "test-namespace"
assert config_data["ports"] == [8080, 9090]
assert config_data["replicas"] == 2
# Verify job ID was added to queue
assert mock_redis.rpush.call_count == 1
queue_call = mock_redis.rpush.call_args
assert queue_call[0][0] == _get_queue_key()
assert queue_call[0][1] == job_id
def test_claim_next_task_returns_job_data(self, mock_redis, sample_config):
"""Test that claim_next_task returns job data for next job."""
# Setup
test_job_id = "abcd1234"
mock_job_data = {
"job_id": test_job_id,
"project_id": "project-456",
"namespace": "test-namespace",
"queued_at": datetime.now(UTC).isoformat(),
"config": sample_config.serialize(),
}
mock_redis.lpop.return_value = test_job_id
# Mock hscan to return the job data - hscan returns (cursor, fields_dict)
mock_redis.hscan.return_value = (0, {f"test-namespace:project-456:{test_job_id}": json.dumps(mock_job_data)})
# Execute
job_data = claim_next_task()
# Verify
assert job_data is not None
assert job_data["job_id"] == test_job_id
# deployment_id field has been removed, only project_id remains
assert job_data["project_id"] == "project-456"
assert job_data["namespace"] == "test-namespace"
# Verify Redis calls
mock_redis.lpop.assert_called_once_with(_get_queue_key())
mock_redis.hscan.assert_called_once_with(TASKS_HASH_NAME, 0, match=f"*:*:{test_job_id}")
def test_claim_next_task_returns_none_when_queue_empty(self, mock_redis):
"""Test that claim_next_task returns None when queue is empty."""
# Setup
mock_redis.lpop.return_value = None
# Execute
job_data = claim_next_task()
# Verify
assert job_data is None
mock_redis.lpop.assert_called_once_with(_get_queue_key())
mock_redis.hget.assert_not_called()
def test_claim_next_task_logs_error_when_job_data_missing(self, mock_redis):
"""Test that claim_next_task logs error when job data is missing."""
# Setup
test_job_id = "abcd1234"
mock_redis.lpop.return_value = test_job_id
# Mock hscan to return no job data - hscan returns (cursor, fields_dict)
mock_redis.hscan.return_value = (0, {})
# Execute
with patch('jockey.worker.queue.logger') as mock_logger:
job_data = claim_next_task()
# Verify
assert job_data is None
mock_logger.error.assert_called_once_with(
f"Task {test_job_id} was in queue but task data not found in hash"
)
def test_get_task_data_returns_job_data(self, mock_redis, sample_config):
"""Test that get_task_data returns job data for a given job ID."""
# Setup
test_job_id = "abcd1234"
mock_job_data = {
"job_id": test_job_id,
"project_id": "project-456",
"namespace": "test-namespace",
"queued_at": datetime.now(UTC).isoformat(),
"config": sample_config.serialize(),
}
# Mock hscan to return the job data - hscan returns (cursor, fields_dict)
mock_redis.hscan.return_value = (0, {f"test-namespace:project-456:{test_job_id}": json.dumps(mock_job_data)})
# Execute
job_data = get_task_data(test_job_id)
# Verify
assert job_data is not None
assert job_data["job_id"] == test_job_id
assert job_data["namespace"] == "test-namespace"
mock_redis.hscan.assert_called_once_with(TASKS_HASH_NAME, 0, match=f"*:*:{test_job_id}")
def test_get_task_data_returns_none_when_not_found(self, mock_redis):
"""Test that get_task_data returns None when job data not found."""
# Setup
test_job_id = "abcd1234"
# Mock hscan to return no job data - hscan returns (cursor, fields_dict)
mock_redis.hscan.return_value = (0, {})
# Execute
job_data = get_task_data(test_job_id)
# Verify
assert job_data is None
mock_redis.hscan.assert_called_once_with(TASKS_HASH_NAME, 0, match=f"*:*:{test_job_id}")
def test_get_queue_length_returns_queue_length(self, mock_redis):
"""Test that get_queue_length returns the number of jobs in queue."""
# Setup
mock_redis.llen.return_value = 5
# Execute
length = get_queue_length()
# Verify
assert length == 5
mock_redis.llen.assert_called_once_with(_get_queue_key())
def test_get_queued_tasks_returns_job_ids(self, mock_redis):
"""Test that get_queued_tasks returns list of job IDs."""
# Setup
mock_job_ids = ["abcd1234", "efgh5678", "ijkl9012"]
mock_redis.lrange.return_value = mock_job_ids
# Execute
job_ids = get_queued_tasks()
# Verify
assert job_ids == mock_job_ids
mock_redis.lrange.assert_called_once_with(_get_queue_key(), 0, -1)
def test_get_job_key_generates_correct_key(self):
"""Test that _get_job_key generates correct Redis key."""
namespace = "test-namespace"
project_id = "project-456"
job_id = "abcd1234"
key = _get_task_key(namespace, project_id, job_id)
assert key == f"{namespace}:{project_id}:{job_id}"
def test_job_data_includes_namespace(self, mock_redis, sample_config):
"""Test that job data includes namespace from config."""
# Setup
mock_redis.hset.return_value = True
mock_redis.rpush.return_value = 1
# Execute
job_id = queue_task(TaskType.SERVE, sample_config, "project-456")
# Verify namespace is included
hash_call = mock_redis.hset.call_args
job_data_json = hash_call[0][2]
job_data = json.loads(job_data_json)
assert job_data["namespace"] == "test-namespace"
def test_job_data_type_annotation(self, mock_redis, sample_config):
"""Test that job data structure matches JobData TypedDict."""
# Setup
mock_redis.hset.return_value = True
mock_redis.rpush.return_value = 1
# Execute
job_id = queue_task(TaskType.SERVE, sample_config, "project-456")
# Get the job data that was stored
hash_call = mock_redis.hset.call_args
job_data_json = hash_call[0][2]
job_data = json.loads(job_data_json)
# Verify all required JobData fields are present
required_fields = ["job_id", "project_id", "namespace", "config", "queued_at"]
for field in required_fields:
assert field in job_data, f"Missing required field: {field}"
# Verify types (as much as we can from JSON)
assert isinstance(job_data["job_id"], str)
assert isinstance(job_data["project_id"], str)
assert isinstance(job_data["namespace"], str)
assert isinstance(job_data["config"], dict)
assert isinstance(job_data["queued_at"], str)