Felipe Cardoso
664415111a
- Added tests for OAuth provider admin and consent endpoints covering edge cases. - Extended agent-related tests to handle incorrect project associations and lifecycle state transitions. - Introduced tests for sprint status transitions and validation checks. - Improved multiline formatting consistency across all test functions.
504 lines
16 KiB
Python
504 lines
16 KiB
Python
# tests/models/syndarix/test_issue.py
|
|
"""
|
|
Unit tests for the Issue model.
|
|
"""
|
|
|
|
import uuid
|
|
from datetime import UTC, datetime, timedelta
|
|
|
|
from app.models.syndarix import (
|
|
AgentInstance,
|
|
AgentType,
|
|
Issue,
|
|
IssuePriority,
|
|
IssueStatus,
|
|
IssueType,
|
|
Project,
|
|
Sprint,
|
|
SprintStatus,
|
|
SyncStatus,
|
|
)
|
|
|
|
|
|
class TestIssueModel:
|
|
"""Tests for Issue model creation and fields."""
|
|
|
|
def test_create_issue_with_required_fields(self, db_session):
|
|
"""Test creating an issue with only required fields."""
|
|
project = Project(
|
|
id=uuid.uuid4(),
|
|
name="Issue Project",
|
|
slug="issue-project",
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="Test Issue",
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = db_session.query(Issue).filter_by(title="Test Issue").first()
|
|
|
|
assert retrieved is not None
|
|
assert retrieved.title == "Test Issue"
|
|
assert retrieved.body == "" # Default empty string
|
|
assert retrieved.status == IssueStatus.OPEN # Default
|
|
assert retrieved.priority == IssuePriority.MEDIUM # Default
|
|
assert retrieved.labels == [] # Default empty list
|
|
assert retrieved.story_points is None
|
|
assert retrieved.assigned_agent_id is None
|
|
assert retrieved.human_assignee is None
|
|
assert retrieved.sprint_id is None
|
|
assert retrieved.sync_status == SyncStatus.SYNCED # Default
|
|
|
|
def test_create_issue_with_all_fields(self, db_session):
|
|
"""Test creating an issue with all optional fields."""
|
|
project = Project(
|
|
id=uuid.uuid4(),
|
|
name="Full Issue Project",
|
|
slug="full-issue-project",
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
issue_id = uuid.uuid4()
|
|
now = datetime.now(UTC)
|
|
|
|
issue = Issue(
|
|
id=issue_id,
|
|
project_id=project.id,
|
|
title="Full Issue",
|
|
body="A complete issue with all fields set",
|
|
type=IssueType.BUG,
|
|
status=IssueStatus.IN_PROGRESS,
|
|
priority=IssuePriority.CRITICAL,
|
|
labels=["bug", "security", "urgent"],
|
|
story_points=8,
|
|
human_assignee="john.doe@example.com",
|
|
external_tracker_type="gitea",
|
|
external_issue_id="gitea-123",
|
|
remote_url="https://gitea.example.com/issues/123",
|
|
external_issue_number=123,
|
|
sync_status=SyncStatus.SYNCED,
|
|
last_synced_at=now,
|
|
external_updated_at=now,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = db_session.query(Issue).filter_by(id=issue_id).first()
|
|
|
|
assert retrieved.title == "Full Issue"
|
|
assert retrieved.body == "A complete issue with all fields set"
|
|
assert retrieved.type == IssueType.BUG
|
|
assert retrieved.status == IssueStatus.IN_PROGRESS
|
|
assert retrieved.priority == IssuePriority.CRITICAL
|
|
assert retrieved.labels == ["bug", "security", "urgent"]
|
|
assert retrieved.story_points == 8
|
|
assert retrieved.human_assignee == "john.doe@example.com"
|
|
assert retrieved.external_tracker_type == "gitea"
|
|
assert retrieved.external_issue_id == "gitea-123"
|
|
assert retrieved.external_issue_number == 123
|
|
assert retrieved.sync_status == SyncStatus.SYNCED
|
|
|
|
def test_issue_timestamps(self, db_session):
|
|
"""Test that timestamps are automatically set."""
|
|
project = Project(
|
|
id=uuid.uuid4(),
|
|
name="Timestamp Issue Project",
|
|
slug="timestamp-issue-project",
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="Timestamp Issue",
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
assert isinstance(issue.created_at, datetime)
|
|
assert isinstance(issue.updated_at, datetime)
|
|
|
|
def test_issue_string_representation(self, db_session):
|
|
"""Test the string representation of an issue."""
|
|
project = Project(
|
|
id=uuid.uuid4(), name="Repr Issue Project", slug="repr-issue-project"
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="This is a very long issue title that should be truncated in repr",
|
|
status=IssueStatus.OPEN,
|
|
priority=IssuePriority.HIGH,
|
|
)
|
|
|
|
repr_str = repr(issue)
|
|
assert "This is a very long issue tit" in repr_str # First 30 chars
|
|
assert "open" in repr_str
|
|
assert "high" in repr_str
|
|
|
|
|
|
class TestIssueStatus:
|
|
"""Tests for Issue status field."""
|
|
|
|
def test_all_issue_statuses(self, db_session):
|
|
"""Test that all issue statuses can be stored."""
|
|
project = Project(
|
|
id=uuid.uuid4(), name="Status Issue Project", slug="status-issue-project"
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
for status in IssueStatus:
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title=f"Issue {status.value}",
|
|
status=status,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = db_session.query(Issue).filter_by(id=issue.id).first()
|
|
assert retrieved.status == status
|
|
|
|
|
|
class TestIssuePriority:
|
|
"""Tests for Issue priority field."""
|
|
|
|
def test_all_issue_priorities(self, db_session):
|
|
"""Test that all issue priorities can be stored."""
|
|
project = Project(
|
|
id=uuid.uuid4(),
|
|
name="Priority Issue Project",
|
|
slug="priority-issue-project",
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
for priority in IssuePriority:
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title=f"Issue {priority.value}",
|
|
priority=priority,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = db_session.query(Issue).filter_by(id=issue.id).first()
|
|
assert retrieved.priority == priority
|
|
|
|
|
|
class TestIssueSyncStatus:
|
|
"""Tests for Issue sync status field."""
|
|
|
|
def test_all_sync_statuses(self, db_session):
|
|
"""Test that all sync statuses can be stored."""
|
|
project = Project(
|
|
id=uuid.uuid4(), name="Sync Issue Project", slug="sync-issue-project"
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
for sync_status in SyncStatus:
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title=f"Issue {sync_status.value}",
|
|
external_tracker_type="gitea",
|
|
external_issue_id=f"ext-{sync_status.value}",
|
|
sync_status=sync_status,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = db_session.query(Issue).filter_by(id=issue.id).first()
|
|
assert retrieved.sync_status == sync_status
|
|
|
|
|
|
class TestIssueLabels:
|
|
"""Tests for Issue labels JSON field."""
|
|
|
|
def test_store_labels(self, db_session):
|
|
"""Test storing labels list."""
|
|
project = Project(
|
|
id=uuid.uuid4(), name="Labels Issue Project", slug="labels-issue-project"
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
labels = ["bug", "security", "high-priority", "needs-review"]
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="Issue with Labels",
|
|
labels=labels,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = db_session.query(Issue).filter_by(title="Issue with Labels").first()
|
|
assert retrieved.labels == labels
|
|
assert "security" in retrieved.labels
|
|
|
|
def test_update_labels(self, db_session):
|
|
"""Test updating labels."""
|
|
project = Project(
|
|
id=uuid.uuid4(), name="Update Labels Project", slug="update-labels-project"
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="Update Labels Issue",
|
|
labels=["initial"],
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
issue.labels = ["updated", "new-label"]
|
|
db_session.commit()
|
|
|
|
retrieved = (
|
|
db_session.query(Issue).filter_by(title="Update Labels Issue").first()
|
|
)
|
|
assert "initial" not in retrieved.labels
|
|
assert "updated" in retrieved.labels
|
|
|
|
|
|
class TestIssueAssignment:
|
|
"""Tests for Issue assignment fields."""
|
|
|
|
def test_assign_to_agent(self, db_session):
|
|
"""Test assigning an issue to an agent."""
|
|
project = Project(
|
|
id=uuid.uuid4(), name="Agent Assign Project", slug="agent-assign-project"
|
|
)
|
|
agent_type = AgentType(
|
|
id=uuid.uuid4(),
|
|
name="Test Agent Type",
|
|
slug="test-agent-type-assign",
|
|
personality_prompt="Test",
|
|
primary_model="claude-opus-4-5-20251101",
|
|
)
|
|
db_session.add(project)
|
|
db_session.add(agent_type)
|
|
db_session.commit()
|
|
|
|
agent_instance = AgentInstance(
|
|
id=uuid.uuid4(),
|
|
agent_type_id=agent_type.id,
|
|
project_id=project.id,
|
|
name="TaskBot",
|
|
)
|
|
db_session.add(agent_instance)
|
|
db_session.commit()
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="Agent Assignment Issue",
|
|
assigned_agent_id=agent_instance.id,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = (
|
|
db_session.query(Issue).filter_by(title="Agent Assignment Issue").first()
|
|
)
|
|
assert retrieved.assigned_agent_id == agent_instance.id
|
|
assert retrieved.human_assignee is None
|
|
|
|
def test_assign_to_human(self, db_session):
|
|
"""Test assigning an issue to a human."""
|
|
project = Project(
|
|
id=uuid.uuid4(), name="Human Assign Project", slug="human-assign-project"
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="Human Assignment Issue",
|
|
human_assignee="developer@example.com",
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = (
|
|
db_session.query(Issue).filter_by(title="Human Assignment Issue").first()
|
|
)
|
|
assert retrieved.human_assignee == "developer@example.com"
|
|
assert retrieved.assigned_agent_id is None
|
|
|
|
|
|
class TestIssueSprintAssociation:
|
|
"""Tests for Issue sprint association."""
|
|
|
|
def test_assign_issue_to_sprint(self, db_session):
|
|
"""Test assigning an issue to a sprint."""
|
|
project = Project(
|
|
id=uuid.uuid4(), name="Sprint Assign Project", slug="sprint-assign-project"
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
from datetime import date
|
|
|
|
sprint = Sprint(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
name="Sprint 1",
|
|
number=1,
|
|
start_date=date.today(),
|
|
end_date=date.today() + timedelta(days=14),
|
|
status=SprintStatus.ACTIVE,
|
|
)
|
|
db_session.add(sprint)
|
|
db_session.commit()
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="Sprint Issue",
|
|
sprint_id=sprint.id,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = db_session.query(Issue).filter_by(title="Sprint Issue").first()
|
|
assert retrieved.sprint_id == sprint.id
|
|
|
|
|
|
class TestIssueExternalTracker:
|
|
"""Tests for Issue external tracker integration."""
|
|
|
|
def test_gitea_integration(self, db_session):
|
|
"""Test Gitea external tracker fields."""
|
|
project = Project(id=uuid.uuid4(), name="Gitea Project", slug="gitea-project")
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
now = datetime.now(UTC)
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="Gitea Synced Issue",
|
|
external_tracker_type="gitea",
|
|
external_issue_id="abc123xyz",
|
|
remote_url="https://gitea.example.com/org/repo/issues/42",
|
|
external_issue_number=42,
|
|
sync_status=SyncStatus.SYNCED,
|
|
last_synced_at=now,
|
|
external_updated_at=now,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = (
|
|
db_session.query(Issue).filter_by(title="Gitea Synced Issue").first()
|
|
)
|
|
assert retrieved.external_tracker_type == "gitea"
|
|
assert retrieved.external_issue_id == "abc123xyz"
|
|
assert retrieved.external_issue_number == 42
|
|
assert "/issues/42" in retrieved.remote_url
|
|
|
|
def test_github_integration(self, db_session):
|
|
"""Test GitHub external tracker fields."""
|
|
project = Project(id=uuid.uuid4(), name="GitHub Project", slug="github-project")
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="GitHub Synced Issue",
|
|
external_tracker_type="github",
|
|
external_issue_id="gh-12345",
|
|
remote_url="https://github.com/org/repo/issues/100",
|
|
external_issue_number=100,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
retrieved = (
|
|
db_session.query(Issue).filter_by(title="GitHub Synced Issue").first()
|
|
)
|
|
assert retrieved.external_tracker_type == "github"
|
|
assert retrieved.external_issue_number == 100
|
|
|
|
|
|
class TestIssueLifecycle:
|
|
"""Tests for Issue lifecycle operations."""
|
|
|
|
def test_close_issue(self, db_session):
|
|
"""Test closing an issue."""
|
|
project = Project(
|
|
id=uuid.uuid4(), name="Close Issue Project", slug="close-issue-project"
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="Issue to Close",
|
|
status=IssueStatus.OPEN,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
# Close the issue
|
|
now = datetime.now(UTC)
|
|
issue.status = IssueStatus.CLOSED
|
|
issue.closed_at = now
|
|
db_session.commit()
|
|
|
|
retrieved = db_session.query(Issue).filter_by(title="Issue to Close").first()
|
|
assert retrieved.status == IssueStatus.CLOSED
|
|
assert retrieved.closed_at is not None
|
|
|
|
def test_reopen_issue(self, db_session):
|
|
"""Test reopening a closed issue."""
|
|
project = Project(
|
|
id=uuid.uuid4(), name="Reopen Issue Project", slug="reopen-issue-project"
|
|
)
|
|
db_session.add(project)
|
|
db_session.commit()
|
|
|
|
now = datetime.now(UTC)
|
|
issue = Issue(
|
|
id=uuid.uuid4(),
|
|
project_id=project.id,
|
|
title="Issue to Reopen",
|
|
status=IssueStatus.CLOSED,
|
|
closed_at=now,
|
|
)
|
|
db_session.add(issue)
|
|
db_session.commit()
|
|
|
|
# Reopen the issue
|
|
issue.status = IssueStatus.OPEN
|
|
issue.closed_at = None
|
|
db_session.commit()
|
|
|
|
retrieved = db_session.query(Issue).filter_by(title="Issue to Reopen").first()
|
|
assert retrieved.status == IssueStatus.OPEN
|
|
assert retrieved.closed_at is None
|