feat: reorganize tests by capability with separate test targets

Separate capability-specific tests from core system tests to establish clear
test organization and separation of concerns.

## Test Reorganization:
- **markitect-content tests**: Moved 6 tests to capabilities/markitect-content/tests/
- **markitect-finance tests**: Moved 7 tests to markitect/finance/tests/
- **markitect-query tests**: Moved 1 test to markitect/query_paradigms/tests/
- **markitect-graphql tests**: Moved 2 tests to markitect/graphql/tests/
- **markitect-plugins tests**: Moved 2 tests to markitect/plugins/tests/

## Makefile Updates:
- **make test**: Excludes capability tests, runs only core system tests
- **make test-capabilities**: Runs all capability tests
- **make test-capability-***: Individual capability test targets
- Updated all test targets (test-red, test-green, test-ultra-fast, test-perf)
- Added capability test targets to help documentation

## Benefits:
- Clear separation between core system tests and capability-specific tests
- Faster core test execution (capability tests not run by default)
- Individual capability testing for focused development
- Supports future capability extraction workflow
- Maintains capability test independence

Test verification:
- Core tests: 1291 tests (capability tests excluded)
- Finance capability: 143 tests working independently
- Content capability: 79 tests working independently

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

markitect/query_paradigms/tests/test_query_paradigms.py

@@ -0,0 +1,333 @@
+"""
+Tests for query paradigm system - Issue #62
+"""
+
+import pytest
+import json
+from markitect.query_paradigms.registry import registry
+from markitect.query_paradigms.base import BaseQueryParadigm, QueryResult
+from markitect.query_paradigms.paradigms.sql_paradigm import SQLQueryParadigm
+from markitect.query_paradigms.paradigms.fts_paradigm import FullTextSearchParadigm
+from markitect.query_paradigms.paradigms.qbe_paradigm import QueryByExampleParadigm
+
+
+class TestQueryParadigmRegistry:
+    """Test the query paradigm registry system."""
+
+    def test_registry_has_paradigms(self):
+        """Test that paradigms are automatically registered."""
+        paradigms = registry.list_all()
+        assert len(paradigms) >= 14  # We expect at least 14 paradigms
+
+        # Check that key paradigms are present
+        paradigm_names = [p.name for p in paradigms]
+        assert "SQL" in paradigm_names
+        assert "FTS" in paradigm_names
+        assert "GraphQL" in paradigm_names
+        assert "Natural Language" in paradigm_names
+
+    def test_get_paradigm_by_name(self):
+        """Test retrieving paradigms by name."""
+        sql_paradigm = registry.get("SQL")
+        assert sql_paradigm is not None
+        assert sql_paradigm.name == "SQL"
+        assert sql_paradigm.category == "structural"
+
+        # Test case insensitive lookup
+        fts_paradigm = registry.get("fts")
+        assert fts_paradigm is not None
+        assert fts_paradigm.name == "FTS"
+
+    def test_get_nonexistent_paradigm(self):
+        """Test getting a paradigm that doesn't exist."""
+        result = registry.get("NonExistentParadigm")
+        assert result is None
+
+    def test_list_by_category(self):
+        """Test filtering paradigms by category."""
+        structural = registry.list_by_category("structural")
+        assert len(structural) > 0
+
+        for paradigm in structural:
+            assert paradigm.category == "structural"
+
+        textual = registry.list_by_category("textual")
+        assert len(textual) > 0
+
+        for paradigm in textual:
+            assert paradigm.category == "textual"
+
+    def test_list_by_complexity(self):
+        """Test filtering paradigms by complexity."""
+        beginner = registry.list_by_complexity("beginner")
+        assert len(beginner) > 0
+
+        for paradigm in beginner:
+            assert paradigm.complexity == "beginner"
+
+    def test_search_paradigms(self):
+        """Test searching paradigms by query."""
+        # Search by name
+        sql_results = registry.search_paradigms("SQL")
+        assert len(sql_results) > 0
+        assert any(p.name == "SQL" for p in sql_results)
+
+        # Search by description
+        visual_results = registry.search_paradigms("visual")
+        assert len(visual_results) > 0
+        assert any("visual" in p.description.lower() for p in visual_results)
+
+        # Search for non-existent term
+        empty_results = registry.search_paradigms("xyznonexistent")
+        assert len(empty_results) == 0
+
+    def test_get_categories(self):
+        """Test getting all available categories."""
+        categories = registry.get_categories()
+        assert isinstance(categories, list)
+        assert len(categories) > 0
+        assert "structural" in categories
+        assert "textual" in categories
+        assert "semantic" in categories
+
+    def test_get_complexity_levels(self):
+        """Test getting all complexity levels."""
+        levels = registry.get_complexity_levels()
+        assert isinstance(levels, list)
+        assert len(levels) > 0
+        assert "beginner" in levels
+        assert "intermediate" in levels
+        assert "advanced" in levels
+
+
+class TestSQLParadigm:
+    """Test the SQL query paradigm."""
+
+    def test_paradigm_properties(self):
+        """Test SQL paradigm basic properties."""
+        paradigm = SQLQueryParadigm()
+        assert paradigm.name == "SQL"
+        assert paradigm.category == "structural"
+        assert paradigm.complexity == "intermediate"
+        assert "database" in paradigm.description.lower()
+
+    def test_validate_query(self):
+        """Test SQL query validation."""
+        paradigm = SQLQueryParadigm()
+
+        # Valid queries
+        valid, error = paradigm.validate_query("SELECT * FROM files")
+        assert valid
+        assert error is None
+
+        valid, error = paradigm.validate_query("SELECT name FROM files WHERE author = 'Alice'")
+        assert valid
+
+        # Invalid queries
+        valid, error = paradigm.validate_query("")
+        assert not valid
+        assert error is not None
+
+        valid, error = paradigm.validate_query("   ")
+        assert not valid
+
+    def test_get_examples(self):
+        """Test SQL paradigm examples."""
+        paradigm = SQLQueryParadigm()
+        examples = paradigm.get_examples()
+
+        assert isinstance(examples, list)
+        assert len(examples) > 0
+
+        for example in examples:
+            assert "name" in example
+            assert "description" in example
+            assert "query" in example
+            assert isinstance(example["query"], str)
+
+    def test_get_syntax_help(self):
+        """Test SQL syntax help."""
+        paradigm = SQLQueryParadigm()
+        help_text = paradigm.get_syntax_help()
+
+        assert isinstance(help_text, str)
+        assert len(help_text) > 0
+        assert "SELECT" in help_text
+
+
+class TestFTSParadigm:
+    """Test the Full Text Search paradigm."""
+
+    def test_paradigm_properties(self):
+        """Test FTS paradigm basic properties."""
+        paradigm = FullTextSearchParadigm()
+        assert paradigm.name == "FTS"
+        assert paradigm.category == "textual"
+        assert paradigm.complexity == "beginner"
+        assert "search" in paradigm.description.lower()
+
+    def test_validate_query(self):
+        """Test FTS query validation."""
+        paradigm = FullTextSearchParadigm()
+
+        # Valid queries
+        valid, error = paradigm.validate_query("documentation")
+        assert valid
+        assert error is None
+
+        valid, error = paradigm.validate_query("API AND documentation")
+        assert valid
+
+        valid, error = paradigm.validate_query('"getting started"')
+        assert valid
+
+        # Invalid queries
+        valid, error = paradigm.validate_query("")
+        assert not valid
+        assert error is not None
+
+    def test_get_examples(self):
+        """Test FTS paradigm examples."""
+        paradigm = FullTextSearchParadigm()
+        examples = paradigm.get_examples()
+
+        assert isinstance(examples, list)
+        assert len(examples) > 0
+
+        # Check for expected example types
+        example_names = [ex["name"] for ex in examples]
+        assert "Simple search" in example_names
+        assert "Boolean search" in example_names
+
+
+class TestQueryByExampleParadigm:
+    """Test the Query By Example paradigm (documentation-only)."""
+
+    def test_paradigm_properties(self):
+        """Test QBE paradigm basic properties."""
+        paradigm = QueryByExampleParadigm()
+        assert paradigm.name == "Query By Example"
+        assert paradigm.category == "visual"
+        assert paradigm.complexity == "beginner"
+        assert "template" in paradigm.description.lower()
+
+    def test_validate_query(self):
+        """Test QBE query validation."""
+        paradigm = QueryByExampleParadigm()
+
+        # Valid JSON templates
+        valid, error = paradigm.validate_query('{"author": "Alice"}')
+        assert valid
+        assert error is None
+
+        valid, error = paradigm.validate_query('{"tags": ["tutorial"], "type": "markdown"}')
+        assert valid
+
+        # Invalid queries
+        valid, error = paradigm.validate_query("")
+        assert not valid
+        assert error is not None
+
+        valid, error = paradigm.validate_query("not json")
+        assert not valid
+        assert "JSON" in error
+
+        valid, error = paradigm.validate_query('["not", "an", "object"]')
+        assert not valid
+        assert "object" in error
+
+    def test_execute_returns_not_implemented(self):
+        """Test that QBE execution returns not implemented error."""
+        paradigm = QueryByExampleParadigm()
+        result = paradigm.execute('{"author": "Alice"}')
+
+        assert isinstance(result, QueryResult)
+        assert not result.success
+        assert result.error_message is not None
+        assert "not yet implemented" in result.error_message.lower()
+        assert result.metadata["status"] == "not_implemented"
+
+    def test_get_syntax_help(self):
+        """Test QBE syntax help."""
+        paradigm = QueryByExampleParadigm()
+        help_text = paradigm.get_syntax_help()
+
+        assert isinstance(help_text, str)
+        assert len(help_text) > 0
+        assert "JSON" in help_text
+        assert "template" in help_text.lower()
+
+
+class TestQueryResult:
+    """Test the QueryResult data structure."""
+
+    def test_query_result_creation(self):
+        """Test creating a QueryResult."""
+        result = QueryResult(
+            paradigm="Test",
+            query="test query",
+            execution_time_ms=10.5,
+            result_count=3,
+            results=[{"id": 1}, {"id": 2}, {"id": 3}],
+            metadata={"type": "test"},
+            success=True
+        )
+
+        assert result.paradigm == "Test"
+        assert result.query == "test query"
+        assert result.execution_time_ms == 10.5
+        assert result.result_count == 3
+        assert len(result.results) == 3
+        assert result.metadata["type"] == "test"
+        assert result.success is True
+        assert result.error_message is None
+
+    def test_query_result_with_error(self):
+        """Test creating a QueryResult with error."""
+        result = QueryResult(
+            paradigm="Test",
+            query="bad query",
+            execution_time_ms=1.0,
+            result_count=0,
+            results=[],
+            metadata={},
+            success=False,
+            error_message="Query failed"
+        )
+
+        assert not result.success
+        assert result.error_message == "Query failed"
+        assert result.result_count == 0
+
+
+class TestBaseQueryParadigm:
+    """Test the base query paradigm interface."""
+
+    def test_cannot_instantiate_base_class(self):
+        """Test that BaseQueryParadigm cannot be instantiated directly."""
+        with pytest.raises(TypeError):
+            BaseQueryParadigm()
+
+    def test_paradigm_interface(self):
+        """Test that paradigms implement the required interface."""
+        paradigm = SQLQueryParadigm()
+
+        # Test all required properties
+        assert hasattr(paradigm, 'name')
+        assert hasattr(paradigm, 'description')
+        assert hasattr(paradigm, 'category')
+        assert hasattr(paradigm, 'complexity')
+
+        # Test all required methods
+        assert hasattr(paradigm, 'execute')
+        assert hasattr(paradigm, 'get_examples')
+        assert hasattr(paradigm, 'validate_query')
+        assert hasattr(paradigm, 'get_syntax_help')
+
+        # Test optional methods
+        assert hasattr(paradigm, 'can_translate_from')
+        assert hasattr(paradigm, 'translate_query')
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])