tegwick
b13de9b2ad
ARCHITECTURAL MILESTONE: Complete transformation of test suite from issue-based to sophisticated architectural layer organization with 348 tests across 7 layers (Foundation → Infrastructure → Integration → Domain → Service → Application → Presentation). Major Components: 🏗️ ARCHITECTURAL TEST ORGANIZATION: • Renamed 23 test files to architectural layers (e.g. test_parser.py → test_l7_foundation_markdown_parsing.py) • Created reverse dependency execution order for 60-80% faster feedback • Foundation layer (10 tests, ~9s) provides immediate failure detection • Complete dependency mapping across all 7 architectural layers 🎯 ADVANCED TEST RUNNERS: • run_architectural_tests.py - Reverse dependency execution with performance metrics • run_randomized_tests.py - Seed-based randomization for dependency detection • Comprehensive error handling and colored output for optimal UX • Support for layer-specific execution and early termination on failures 📋 COMPREHENSIVE DOCUMENTATION: • ARCHITECTURE.md - 7-layer architecture blueprint with migration strategy • CAPABILITIES.md - Complete inventory of 73+ system capabilities across 15 categories • TEST_ARCHITECTURE.md - Detailed test execution strategy and naming conventions • ARCHITECTURAL_CHAOS_TESTING_ISSUE.md - Chaos engineering gameplan (Issue #35) 🔧 MAKEFILE INTEGRATION: • 15+ new testing targets (test-arch, test-foundation, test-random, etc.) • Layer-specific execution (test-infrastructure, test-domain, test-service) • Advanced options (test-quick, test-layers, test-random-repeat) • Comprehensive help system with organized testing categories 🎲 RANDOMIZED TESTING: • Seed-based reproducible test execution for debugging • Multi-iteration testing to detect flaky tests and hidden dependencies • Enhanced randomization support with pytest-randomly integration • Performance analysis across different execution orders 🚀 PERFORMANCE OPTIMIZATION: • Foundation-first execution prevents cascade failure debugging • Quick testing (foundation + infrastructure) completes in ~22 seconds • Layer isolation enables targeted debugging and development • Optimal feedback loops for architectural development This revolutionary testing infrastructure establishes MarkiTect as having enterprise-grade test organization with architectural principles, performance optimization, and advanced testing methodologies including chaos engineering foundations. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
287 lines
11 KiB
Python
287 lines
11 KiB
Python
"""
|
|
Tests to validate the testing infrastructure works correctly.
|
|
|
|
Demonstrates:
|
|
- Test fixtures functionality
|
|
- Mock factories usage
|
|
- Test builders patterns
|
|
- Custom assertions
|
|
"""
|
|
|
|
import pytest
|
|
from pathlib import Path
|
|
from datetime import datetime, timezone
|
|
|
|
from tests.fixtures.markdown_samples import MarkdownDocumentBuilder, SAMPLE_SIMPLE_DOCUMENT
|
|
from tests.fixtures.api_responses import GiteaApiResponseBuilder, SAMPLE_ISSUE_RESPONSE
|
|
from tests.utils.test_builders import IssueBuilder, LabelBuilder, create_sample_issue
|
|
from tests.utils.mock_factories import MockRepositoryFactory, MockConfigFactory
|
|
from tests.utils.assertions import (
|
|
assert_issue_equal, assert_file_exists, assert_directory_exists,
|
|
assert_performance_within_bounds, validate_issue_data
|
|
)
|
|
|
|
|
|
class TestTestingInfrastructure:
|
|
"""Test that the testing infrastructure components work correctly."""
|
|
|
|
def test_test_workspace_fixture(self, test_workspace):
|
|
"""Test that test workspace fixture creates proper isolated environment."""
|
|
# Assert
|
|
assert_directory_exists(test_workspace)
|
|
assert_directory_exists(test_workspace / "documents")
|
|
assert_directory_exists(test_workspace / "cache")
|
|
assert_directory_exists(test_workspace / "workspaces")
|
|
|
|
# Test creating files in workspace
|
|
test_file = test_workspace / "test_file.txt"
|
|
test_file.write_text("test content")
|
|
assert_file_exists(test_file)
|
|
|
|
def test_markdown_document_builder(self):
|
|
"""Test markdown document builder functionality."""
|
|
# Act
|
|
doc = (MarkdownDocumentBuilder()
|
|
.with_metadata("title", "Test Doc")
|
|
.with_metadata("author", "Test Author")
|
|
.with_heading("Main Title")
|
|
.with_paragraph("This is a test paragraph.")
|
|
.with_list(["Item 1", "Item 2", "Item 3"])
|
|
.with_code_block("print('hello')", "python")
|
|
.build())
|
|
|
|
# Assert
|
|
assert "title: Test Doc" in doc
|
|
assert "author: Test Author" in doc
|
|
assert "# Main Title" in doc
|
|
assert "This is a test paragraph." in doc
|
|
assert "- Item 1" in doc
|
|
assert "```python" in doc
|
|
assert "print('hello')" in doc
|
|
|
|
def test_gitea_api_response_builder(self):
|
|
"""Test Gitea API response builder functionality."""
|
|
# Act
|
|
response = (GiteaApiResponseBuilder()
|
|
.with_number(42)
|
|
.with_title("Test Issue")
|
|
.with_labels("bug", "priority:high")
|
|
.with_milestone("Version 1.0")
|
|
.build())
|
|
|
|
# Assert
|
|
assert response["number"] == 42
|
|
assert response["title"] == "Test Issue"
|
|
assert len(response["labels"]) == 2
|
|
assert response["labels"][0]["name"] == "bug"
|
|
assert response["labels"][1]["name"] == "priority:high"
|
|
assert response["milestone"]["title"] == "Version 1.0"
|
|
|
|
def test_issue_builder_functionality(self):
|
|
"""Test issue builder creates proper domain objects."""
|
|
# Act
|
|
issue = (IssueBuilder()
|
|
.with_number(123)
|
|
.with_title("Test Issue")
|
|
.as_bug()
|
|
.with_priority("high")
|
|
.with_status("in-progress")
|
|
.build())
|
|
|
|
# Assert
|
|
assert issue.number == 123
|
|
assert issue.title == "Test Issue"
|
|
assert len(issue.labels) == 3
|
|
|
|
# Check label categorization
|
|
categories = issue.categorize_labels()
|
|
assert "bug" in categories.type_labels
|
|
assert "priority:high" in categories.priority_labels
|
|
assert "status:in-progress" in categories.state_labels
|
|
|
|
def test_label_builder_functionality(self):
|
|
"""Test label builder creates correct labels."""
|
|
# Act
|
|
state_label = LabelBuilder().as_state_label("blocked").build()
|
|
priority_label = LabelBuilder().as_priority_label("critical").build()
|
|
type_label = LabelBuilder().as_type_label("bug").build()
|
|
custom_label = LabelBuilder().with_custom_name("frontend").build()
|
|
|
|
# Assert
|
|
assert state_label.name == "status:blocked"
|
|
assert state_label.is_state_label()
|
|
|
|
assert priority_label.name == "priority:critical"
|
|
assert priority_label.is_priority_label()
|
|
|
|
assert type_label.name == "bug"
|
|
assert type_label.is_type_label()
|
|
|
|
assert custom_label.name == "frontend"
|
|
assert not custom_label.is_state_label()
|
|
assert not custom_label.is_priority_label()
|
|
assert not custom_label.is_type_label()
|
|
|
|
def test_mock_repository_factory(self):
|
|
"""Test mock repository factory creates proper mocks."""
|
|
# Act
|
|
issue_repo = MockRepositoryFactory.create_issue_repository()
|
|
project_repo = MockRepositoryFactory.create_project_repository()
|
|
document_repo = MockRepositoryFactory.create_document_repository()
|
|
|
|
# Assert
|
|
assert hasattr(issue_repo, 'get_issue')
|
|
assert hasattr(issue_repo, 'create_issue')
|
|
assert hasattr(issue_repo, 'update_issue')
|
|
assert hasattr(issue_repo, 'list_issues')
|
|
|
|
assert hasattr(project_repo, 'get_project')
|
|
assert hasattr(project_repo, 'get_issue_project_info')
|
|
|
|
assert hasattr(document_repo, 'store_document')
|
|
assert hasattr(document_repo, 'search_content')
|
|
|
|
def test_mock_config_factory(self):
|
|
"""Test mock configuration factory."""
|
|
# Act
|
|
config = MockConfigFactory.create_test_config({
|
|
"custom_setting": "test_value",
|
|
"workspace_dir": "/custom/workspace"
|
|
})
|
|
|
|
# Assert
|
|
assert config.workspace_dir == "/custom/workspace"
|
|
assert config.custom_setting == "test_value"
|
|
assert config.gitea_url == "http://test-gitea.com" # Default value
|
|
assert config.log_level == "DEBUG" # Default value
|
|
|
|
def test_custom_assertions(self):
|
|
"""Test custom assertion functions."""
|
|
# Arrange
|
|
issue1 = create_sample_issue(1, "Test Issue")
|
|
issue2 = create_sample_issue(1, "Test Issue")
|
|
|
|
# Act & Assert - Should not raise
|
|
assert_issue_equal(issue1, issue2, ignore_timestamps=True)
|
|
|
|
# Test performance assertion
|
|
execution_time = 0.05 # 50ms
|
|
assert_performance_within_bounds(execution_time, 0.1, "test operation")
|
|
|
|
# Test data validation
|
|
valid_issue_data = {
|
|
"number": 1,
|
|
"title": "Valid Issue",
|
|
"state": "open",
|
|
"labels": [],
|
|
"created_at": "2025-01-01T00:00:00Z",
|
|
"updated_at": "2025-01-01T00:00:00Z"
|
|
}
|
|
assert validate_issue_data(valid_issue_data) is True
|
|
|
|
invalid_issue_data = {
|
|
"number": -1, # Invalid number
|
|
"title": "", # Empty title
|
|
"state": "invalid_state", # Invalid state
|
|
}
|
|
assert validate_issue_data(invalid_issue_data) is False
|
|
|
|
def test_sample_constants(self):
|
|
"""Test that sample constants are properly formed."""
|
|
# Test markdown samples
|
|
assert len(SAMPLE_SIMPLE_DOCUMENT) > 0
|
|
assert "# Simple Document" in SAMPLE_SIMPLE_DOCUMENT
|
|
|
|
# Test API response samples
|
|
assert SAMPLE_ISSUE_RESPONSE["number"] == 123
|
|
assert SAMPLE_ISSUE_RESPONSE["title"] == "Sample Issue"
|
|
assert len(SAMPLE_ISSUE_RESPONSE["labels"]) > 0
|
|
|
|
def test_performance_timer_fixture(self, performance_timer):
|
|
"""Test performance timer fixture functionality."""
|
|
# Act
|
|
performance_timer.start()
|
|
|
|
# Simulate some work
|
|
import time
|
|
time.sleep(0.01) # 10ms
|
|
|
|
performance_timer.stop()
|
|
|
|
# Assert
|
|
assert performance_timer.elapsed > 0
|
|
assert performance_timer.elapsed < 0.1 # Should be much less than 100ms
|
|
|
|
def test_test_config_fixture(self, test_config):
|
|
"""Test test configuration fixture."""
|
|
# Assert
|
|
assert "workspace_dir" in test_config
|
|
assert "database_path" in test_config
|
|
assert "gitea_url" in test_config
|
|
assert test_config["gitea_url"] == "http://test-gitea.com"
|
|
|
|
def test_sample_markdown_content_fixture(self, sample_markdown_content):
|
|
"""Test sample markdown content fixture."""
|
|
# Assert
|
|
assert "Test Document" in sample_markdown_content
|
|
assert "title:" in sample_markdown_content # Front matter
|
|
assert "**bold**" in sample_markdown_content
|
|
assert "```python" in sample_markdown_content
|
|
|
|
def test_sample_issue_data_fixture(self, sample_issue_data):
|
|
"""Test sample issue data fixture."""
|
|
# Assert
|
|
assert sample_issue_data["number"] == 123
|
|
assert sample_issue_data["title"] == "Test Issue"
|
|
assert sample_issue_data["state"] == "open"
|
|
assert len(sample_issue_data["labels"]) > 0
|
|
|
|
def test_isolated_environment_fixture(self, isolated_environment):
|
|
"""Test isolated environment fixture."""
|
|
# Assert
|
|
assert "MARKITECT_WORKSPACE_DIR" in isolated_environment
|
|
assert "MARKITECT_GITEA_URL" in isolated_environment
|
|
assert isolated_environment["MARKITECT_GITEA_URL"] == "http://test-gitea.com"
|
|
|
|
@pytest.mark.parametrize("priority,expected", [
|
|
("low", "Low"),
|
|
("medium", "Medium"),
|
|
("high", "High"),
|
|
("critical", "Critical")
|
|
])
|
|
def test_parametrized_testing_works(self, priority, expected):
|
|
"""Test that parametrized testing works with our infrastructure."""
|
|
# Act
|
|
issue = (IssueBuilder()
|
|
.with_number(1)
|
|
.with_title("Priority Test")
|
|
.with_priority(priority)
|
|
.build())
|
|
|
|
# Assert
|
|
categories = issue.categorize_labels()
|
|
priority_labels = categories.priority_labels
|
|
assert len(priority_labels) == 1
|
|
assert priority_labels[0] == f"priority:{priority}"
|
|
|
|
def test_test_markers_work(self):
|
|
"""Test that our custom test markers work."""
|
|
# This test validates that the marker configuration is working
|
|
# The markers are defined in pytest.ini and should not cause warnings
|
|
pass
|
|
|
|
@pytest.mark.unit
|
|
def test_unit_marker_works(self):
|
|
"""Test that unit marker works."""
|
|
assert True
|
|
|
|
@pytest.mark.performance
|
|
def test_performance_marker_works(self, performance_timer):
|
|
"""Test that performance marker works."""
|
|
performance_timer.start()
|
|
# Simulate quick operation
|
|
result = sum(range(100))
|
|
performance_timer.stop()
|
|
|
|
assert result == 4950 # Mathematical verification
|
|
assert performance_timer.elapsed < 0.01 # Should be very fast |