jleechanorg-pr-automation 0.1.1__py3-none-any.whl → 0.2.45__py3-none-any.whl

jleechanorg_pr_automation/tests/test_workflow_specific_limits.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""
+Test-Driven Development for Workflow-Specific Safety Limits
+
+RED Phase: Tests should FAIL initially (implementation broken)
+GREEN Phase: Fix implementation to make tests pass
+
+Tests workflow-specific comment counting and safety limits:
+- pr_automation workflow
+- fix_comment workflow
+- codex_update workflow
+- fixpr workflow
+"""
+
+import unittest
+from unittest.mock import Mock, patch
+
+from jleechanorg_pr_automation.jleechanorg_pr_monitor import JleechanorgPRMonitor
+
+
+class TestWorkflowSpecificLimits(unittest.TestCase):
+    """Test workflow-specific comment counting and safety limits"""
+
+    def setUp(self):
+        """Set up test environment"""
+        with patch('jleechanorg_pr_automation.jleechanorg_pr_monitor.AutomationSafetyManager'):
+            # Initialize with explicit test username to avoid environment dependency
+            self.monitor = JleechanorgPRMonitor(automation_username="test-automation-user")
+            # Mock safety manager with workflow-specific limits
+            self.monitor.safety_manager.pr_automation_limit = 10
+            self.monitor.safety_manager.fix_comment_limit = 5
+            self.monitor.safety_manager.codex_update_limit = 10
+            self.monitor.safety_manager.fixpr_limit = 10
+
+    def test_count_pr_automation_comments(self):
+        """Test counting PR automation comments (codex marker, not fix-comment)"""
+        comments = [
+            {"body": "<!-- codex-automation-commit:abc123 -->"},
+            {"body": "<!-- codex-automation-commit:def456 -->"},
+            {"body": "<!-- fix-comment-automation-commit:xyz789 -->"},  # Should NOT count
+            {"body": "Regular comment"},
+        ]
+        count = self.monitor._count_workflow_comments(comments, "pr_automation")
+        self.assertEqual(count, 2, "Should count only codex-automation-commit comments without fix-comment marker")
+
+    def test_count_fix_comment_comments(self):
+        """Test counting fix-comment workflow comments"""
+        comments = [
+            {"body": "<!-- fix-comment-automation-commit:abc123 -->", "author": {"login": "test-automation-user"}},
+            {"body": "<!-- fix-comment-automation-commit:def456 -->", "author": {"login": "test-automation-user"}},
+            {"body": "<!-- codex-automation-commit:xyz789 -->", "author": {"login": "test-automation-user"}},  # Should NOT count
+            {"body": "Regular comment", "author": {"login": "test-automation-user"}},
+        ]
+        count = self.monitor._count_workflow_comments(comments, "fix_comment")
+        self.assertEqual(count, 2, "Should count only fix-comment-automation-commit comments")
+
+    def test_count_fix_comment_run_comments(self):
+        """Test counting fix-comment queued run markers"""
+        comments = [
+            {"body": "<!-- fix-comment-run-automation-commit:gemini:abc123 -->", "author": {"login": "test-automation-user"}},
+            {"body": "<!-- fix-comment-run-automation-commit:codex:def456 -->", "author": {"login": "test-automation-user"}},
+            {"body": "<!-- codex-automation-commit:xyz789 -->", "author": {"login": "test-automation-user"}},  # Should NOT count
+            {"body": "Regular comment", "author": {"login": "test-automation-user"}},
+        ]
+        count = self.monitor._count_workflow_comments(comments, "fix_comment")
+        self.assertEqual(count, 2, "Should count fix-comment-run-automation-commit comments for fix_comment workflow")
+
+    def test_count_codex_update_comments(self):
+        """Test counting codex-update workflow comments (should always be 0)"""
+        comments = [
+            {"body": "<!-- codex-automation-commit:abc123 -->"},
+            {"body": "<!-- fix-comment-automation-commit:def456 -->"},
+        ]
+        count = self.monitor._count_workflow_comments(comments, "codex_update")
+        self.assertEqual(count, 0, "Codex update workflow doesn't post PR comments, should always return 0")
+
+    def test_count_fixpr_comments(self):
+        """Test counting fixpr workflow comments"""
+        comments = [
+            {"body": "<!-- fixpr-run-automation-commit:gemini:abc123 -->", "author": {"login": "test-automation-user"}},
+            {"body": "<!-- fixpr-run-automation-commit:codex:def456 -->", "author": {"login": "test-automation-user"}},
+            {"body": "<!-- codex-automation-commit:xyz789 -->", "author": {"login": "test-automation-user"}},  # Should NOT count
+            {"body": "<!-- fix-comment-automation-commit:ghi012 -->", "author": {"login": "test-automation-user"}},  # Should NOT count
+            {"body": "Regular comment", "author": {"login": "test-automation-user"}},
+        ]
+        count = self.monitor._count_workflow_comments(comments, "fixpr")
+        self.assertEqual(count, 2, "Should count only fixpr-run-automation-commit comments for fixpr workflow")
+
+    def test_workflow_specific_limit_pr_automation(self):
+        """Test that PR automation workflow uses its own limit"""
+        comments = [
+            {"body": f"<!-- codex-automation-commit:abc{i} -->"} for i in range(10)
+        ]
+        count = self.monitor._count_workflow_comments(comments, "pr_automation")
+        # Should be at limit (10), not blocked yet
+        self.assertEqual(count, 10)
+        # 11th comment should exceed limit
+        comments.append({"body": "<!-- codex-automation-commit:abc11 -->"})
+        count = self.monitor._count_workflow_comments(comments, "pr_automation")
+        self.assertEqual(count, 11)
+        self.assertGreater(count, self.monitor.safety_manager.pr_automation_limit)
+
+    def test_workflow_specific_limit_fix_comment(self):
+        """Test that fix-comment workflow uses its own limit (5)"""
+        comments = [
+            {"body": f"<!-- fix-comment-automation-commit:abc{i} -->", "author": {"login": "test-automation-user"}} for i in range(5)
+        ]
+        count = self.monitor._count_workflow_comments(comments, "fix_comment")
+        # Should be at limit (5)
+        self.assertEqual(count, 5)
+        # 6th comment should exceed limit
+        comments.append({"body": "<!-- fix-comment-automation-commit:abc6 -->", "author": {"login": "test-automation-user"}})
+        count = self.monitor._count_workflow_comments(comments, "fix_comment")
+        self.assertEqual(count, 6)
+        self.assertGreater(count, self.monitor.safety_manager.fix_comment_limit)
+
+    def test_workflow_specific_limit_independence(self):
+        """Test that different workflows have independent limits"""
+        # PR automation has 10 comments (at limit)
+        pr_automation_comments = [
+            {"body": f"<!-- codex-automation-commit:pr{i} -->", "author": {"login": "test-automation-user"}} for i in range(10)
+        ]
+        # Fix-comment has 2 comments (under limit)
+        fix_comment_comments = [
+            {"body": f"<!-- fix-comment-automation-commit:fix{i} -->", "author": {"login": "test-automation-user"}} for i in range(2)
+        ]
+
+        pr_count = self.monitor._count_workflow_comments(pr_automation_comments, "pr_automation")
+        fix_count = self.monitor._count_workflow_comments(fix_comment_comments, "fix_comment")
+
+        self.assertEqual(pr_count, 10)
+        self.assertEqual(fix_count, 2)
+        # Fix-comment should still be allowed even though PR automation is at limit
+        self.assertLess(fix_count, self.monitor.safety_manager.fix_comment_limit)
+        self.assertEqual(pr_count, self.monitor.safety_manager.pr_automation_limit)
+
+    def test_mixed_comments_pr_automation(self):
+        """Test PR automation counting with mixed comment types"""
+        comments = [
+            {"body": "<!-- codex-automation-commit:abc123 -->"},  # Count
+            {"body": "<!-- codex-automation-commit:def456 -->"},  # Count
+            {"body": "<!-- fix-comment-automation-commit:xyz789 -->"},  # Don't count
+            {"body": "<!-- codex-automation-commit:ghi012 -->"},  # Count
+            {"body": "Regular comment"},  # Don't count
+        ]
+        count = self.monitor._count_workflow_comments(comments, "pr_automation")
+        self.assertEqual(count, 3, "Should count only codex comments without fix-comment marker")
+
+    def test_mixed_comments_fix_comment(self):
+        """Test fix-comment counting with mixed comment types"""
+        comments = [
+            {"body": "<!-- fix-comment-automation-commit:abc123 -->", "author": {"login": "test-automation-user"}},  # Count
+            {"body": "<!-- codex-automation-commit:def456 -->", "author": {"login": "test-automation-user"}},  # Don't count
+            {"body": "<!-- fix-comment-automation-commit:xyz789 -->", "author": {"login": "test-automation-user"}},  # Count
+            {"body": "Regular comment", "author": {"login": "test-automation-user"}},  # Don't count
+        ]
+        count = self.monitor._count_workflow_comments(comments, "fix_comment")
+        self.assertEqual(count, 2, "Should count only fix-comment-automation-commit comments")
+
+    def test_empty_comments_list(self):
+        """Test counting with empty comments list"""
+        comments = []
+        for workflow_type in ["pr_automation", "fix_comment", "codex_update", "fixpr"]:
+            count = self.monitor._count_workflow_comments(comments, workflow_type)
+            self.assertEqual(count, 0, f"Empty list should return 0 for {workflow_type}")
+
+    def test_unknown_workflow_type(self):
+        """Test that unknown workflow type falls back to counting all automation comments"""
+        comments = [
+            {"body": "<!-- codex-automation-commit:abc123 -->"},
+            {"body": "<!-- fix-comment-automation-commit:def456 -->"},
+        ]
+        count = self.monitor._count_workflow_comments(comments, "unknown_workflow")
+        # Should count all automation comments as fallback
+        self.assertEqual(count, 2)
+
+    def test_count_fix_comment_ignores_impostors(self):
+        """Test that fix-comment counts ignore comments from other users"""
+        comments = [
+            # Valid marker but wrong author
+            {"body": "<!-- fix-comment-automation-commit:abc123 -->", "author": {"login": "impostor"}},
+            # Valid marker and correct author
+            {"body": "<!-- fix-comment-automation-commit:def456 -->", "author": {"login": "test-automation-user"}},
+        ]
+        count = self.monitor._count_workflow_comments(comments, "fix_comment")
+        self.assertEqual(count, 1, "Should ignore comments from impostor users")
+
+    def test_count_fixpr_ignores_impostors(self):
+        """Test that fixpr counts ignore comments from other users"""
+        comments = [
+            # Valid marker but wrong author
+            {"body": "<!-- fixpr-run-automation-commit:gemini:abc123 -->", "author": {"login": "impostor"}},
+            # Valid marker and correct author
+            {"body": "<!-- fixpr-run-automation-commit:codex:def456 -->", "author": {"login": "test-automation-user"}},
+        ]
+        count = self.monitor._count_workflow_comments(comments, "fixpr")
+        self.assertEqual(count, 1, "Should ignore comments from impostor users")
+
+
+
+if __name__ == "__main__":
+    unittest.main()

jleechanorg_pr_automation/tests/test_workspace_dispatch_missing_dir.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Test for workspace dispatch when workspace directory doesn't exist.
+
+This tests the critical bug where automation fails when:
+1. PR is processed initially (workspace created)
+2. Workspace is cleaned up
+3. PR gets new commits
+4. Automation tries to re-process but fails because workspace is missing
+
+Expected behavior: Create workspace if missing, don't fail
+"""
+
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+# Import from local source, not installed package
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+from jleechanorg_pr_automation.orchestrated_pr_runner import prepare_workspace_dir
+
+
+class TestWorkspaceDispatchMissingDirectory(unittest.TestCase):
+    """Test that workspace dispatch handles missing directories gracefully."""
+
+    def setUp(self):
+        """Set up test workspace directory."""
+        self.test_root = Path(tempfile.mkdtemp(prefix="test_workspace_dispatch_"))
+
+    def tearDown(self):
+        """Clean up test workspace directory."""
+        if self.test_root.exists():
+            shutil.rmtree(self.test_root)
+
+    def test_prepare_workspace_ignores_rmtree_filenotfound_race(self):
+        """
+        Test that prepare_workspace_dir ignores FileNotFoundError from rmtree.
+
+        This can happen if the workspace exists during the initial existence check but
+        is removed concurrently (external cleanup, reboot/tmpfs cleanup, etc.) before
+        shutil.rmtree() runs.
+        """
+        repo = "worldarchitect.ai"
+        workspace_name = "pr-2915-fix-social-hp-god-tier-enforcement"
+
+        # Workspace exists, but removal races with external cleanup.
+        workspace_path = self.test_root / repo / workspace_name
+        workspace_path.mkdir(parents=True, exist_ok=True)
+
+        with patch("jleechanorg_pr_automation.orchestrated_pr_runner.WORKSPACE_ROOT_BASE", self.test_root):
+            with patch(
+                "jleechanorg_pr_automation.orchestrated_pr_runner.shutil.rmtree",
+                side_effect=FileNotFoundError("[Errno 2] No such file or directory"),
+            ) as mock_rmtree:
+                result = prepare_workspace_dir(repo, workspace_name)
+
+        self.assertEqual(result, self.test_root / repo / workspace_name)
+        self.assertTrue(result.parent.exists(), f"Parent directory {result.parent} should exist after prepare_workspace_dir")
+        self.assertEqual(mock_rmtree.call_count, 1, "Expected a single rmtree attempt")
+
+    def test_prepare_workspace_raises_on_non_filenotfound_oserror(self):
+        """
+        Test that prepare_workspace_dir still raises on serious OS errors.
+
+        Scenario: Workspace exists but rmtree fails (permissions, locks, etc.).
+        """
+        repo = "worldarchitect.ai"
+        workspace_name = "pr-2909-fix-power-absorption-rewards-protocol"
+
+        workspace_path = self.test_root / repo / workspace_name
+        workspace_path.mkdir(parents=True, exist_ok=True)
+
+        with patch("jleechanorg_pr_automation.orchestrated_pr_runner.WORKSPACE_ROOT_BASE", self.test_root):
+            with patch(
+                "jleechanorg_pr_automation.orchestrated_pr_runner.shutil.rmtree",
+                side_effect=PermissionError("[Errno 13] Permission denied"),
+            ):
+                with self.assertRaises(PermissionError):
+                    prepare_workspace_dir(repo, workspace_name)
+
+    def test_prepare_workspace_with_git_worktree_attempts_cleanup(self):
+        """
+        Test that prepare_workspace_dir handles git worktrees correctly.
+
+        Scenario: Workspace is a git worktree that was cleaned up
+        Expected: Should clean up worktree metadata and proceed
+        """
+        repo = "worldarchitect.ai"
+        workspace_name = "pr-2902-claude-test-and-fix-system-prompt-RiZyM"
+
+        # Create workspace with .git file (worktree marker)
+        workspace_path = self.test_root / repo / workspace_name
+        workspace_path.mkdir(parents=True, exist_ok=True)
+        git_file = workspace_path / ".git"
+        git_file.write_text(
+            f"gitdir: {self.test_root / repo / '.git' / 'worktrees' / workspace_name}"
+        )
+
+        with patch("jleechanorg_pr_automation.orchestrated_pr_runner.WORKSPACE_ROOT_BASE", self.test_root):
+            with patch(
+                "jleechanorg_pr_automation.orchestrated_pr_runner.run_cmd",
+                return_value=MagicMock(returncode=0, stdout="", stderr=""),
+            ) as mock_run_cmd:
+                with patch(
+                    "jleechanorg_pr_automation.orchestrated_pr_runner.shutil.rmtree",
+                    side_effect=FileNotFoundError("[Errno 2] No such file or directory"),
+                ):
+                    result = prepare_workspace_dir(repo, workspace_name)
+
+        self.assertEqual(result, self.test_root / repo / workspace_name)
+        self.assertGreaterEqual(mock_run_cmd.call_count, 2, "Should call git worktree remove and prune")
+        self.assertTrue(result.parent.exists(), "Parent directory should exist")
+
+
+if __name__ == "__main__":
+    unittest.main()

jleechanorg_pr_automation/utils.py

@@ -17,7 +17,9 @@ import tempfile
 import threading
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, Any, Optional
+from typing import Any, Dict, Mapping, Optional
+
+from .logging_utils import setup_logging  # noqa: F401
 
 
 class SafeJSONManager:
@@ -46,7 +48,7 @@ class SafeJSONManager:
         with lock:
             try:
                 if os.path.exists(file_path):
-                    with open(file_path, 'r') as f:
+                    with open(file_path) as f:
                         # Add file lock for cross-process safety
                         fcntl.flock(f.fileno(), fcntl.LOCK_SH)
                         try:
@@ -55,7 +57,7 @@ class SafeJSONManager:
                             fcntl.flock(f.fileno(), fcntl.LOCK_UN)
                 else:
                     return default if default is not None else {}
-            except (json.JSONDecodeError, IOError) as e:
+            except (OSError, json.JSONDecodeError) as e:
                 logging.warning(f"Failed to read JSON from {file_path}: {e}")
                 return default if default is not None else {}
 
@@ -78,7 +80,7 @@ class SafeJSONManager:
                 )
 
                 try:
-                    with os.fdopen(fd, 'w') as f:
+                    with os.fdopen(fd, "w") as f:
                         # Add exclusive file lock for cross-process safety
                         fcntl.flock(f.fileno(), fcntl.LOCK_EX)
                         try:
@@ -99,8 +101,8 @@ class SafeJSONManager:
                         except OSError:
                             pass
 
-            except (IOError, OSError) as e:
-                logging.error(f"Failed to write JSON to {file_path}: {e}")
+            except OSError as e:
+                logging.exception(f"Failed to write JSON to {file_path}: {e}")
                 return False
 
     def update_json(self, file_path: str, update_func, lock_timeout: int = 10) -> bool:
@@ -112,7 +114,7 @@ class SafeJSONManager:
                 updated_data = update_func(data)
                 return self.write_json(file_path, updated_data)
             except Exception as e:
-                logging.error(f"Failed to update JSON {file_path}: {e}")
+                logging.exception(f"Failed to update JSON {file_path}: {e}")
                 return False
 
 
@@ -120,37 +122,6 @@ class SafeJSONManager:
 json_manager = SafeJSONManager()
 
 
-def setup_logging(name: str, level: int = logging.INFO,
-                 log_file: Optional[str] = None) -> logging.Logger:
-    """Standardized logging setup for automation components"""
-    logger = logging.getLogger(name)
-
-    # Avoid duplicate handlers
-    if logger.handlers:
-        return logger
-
-    logger.setLevel(level)
-
-    # Create formatter
-    formatter = logging.Formatter(
-        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
-
-    # Console handler
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(formatter)
-    logger.addHandler(console_handler)
-
-    # File handler if specified
-    if log_file:
-        os.makedirs(os.path.dirname(log_file), exist_ok=True)
-        file_handler = logging.FileHandler(log_file)
-        file_handler.setFormatter(formatter)
-        logger.addHandler(file_handler)
-
-    return logger
-
-
 def get_env_config(prefix: str = "AUTOMATION_") -> Dict[str, str]:
     """Get all environment variables with specified prefix"""
     config = {}
@@ -165,31 +136,85 @@ def get_env_config(prefix: str = "AUTOMATION_") -> Dict[str, str]:
 def get_email_config() -> Dict[str, str]:
     """Get email configuration from environment variables"""
     email_config = {
-        'smtp_server': os.getenv('SMTP_SERVER', 'localhost'),
-        'smtp_port': int(os.getenv('SMTP_PORT', '587')),
-        'email_user': os.getenv('EMAIL_USER', ''),
-        'email_pass': os.getenv('EMAIL_PASS', ''),
-        'email_to': os.getenv('EMAIL_TO', ''),
-        'email_from': os.getenv('EMAIL_FROM', os.getenv('EMAIL_USER', ''))
+        "smtp_server": os.getenv("SMTP_SERVER", "localhost"),
+        "smtp_port": int(os.getenv("SMTP_PORT", "587")),
+        "email_user": os.getenv("EMAIL_USER", ""),
+        "email_pass": os.getenv("EMAIL_PASS", ""),
+        "email_to": os.getenv("EMAIL_TO", ""),
+        "email_from": os.getenv("EMAIL_FROM", os.getenv("EMAIL_USER", ""))
     }
     return email_config
 
 
 def validate_email_config(config: Dict[str, str]) -> bool:
     """Validate that required email configuration is present"""
-    required_fields = ['smtp_server', 'email_user', 'email_pass', 'email_to']
+    required_fields = ["smtp_server", "email_user", "email_pass", "email_to"]
     return all(config.get(field) for field in required_fields)
 
 
 def get_automation_limits() -> Dict[str, int]:
-    """Get automation safety limits from environment or defaults"""
-    return {
-        'pr_limit': int(os.getenv('AUTOMATION_PR_LIMIT', '5')),
-        'global_limit': int(os.getenv('AUTOMATION_GLOBAL_LIMIT', '50')),
-        'approval_hours': int(os.getenv('AUTOMATION_APPROVAL_HOURS', '24')),
-        'subprocess_timeout': int(os.getenv('AUTOMATION_SUBPROCESS_TIMEOUT', '300'))
+    """Get automation safety limits from defaults with optional overrides.
+
+    Supports workflow-specific limits:
+    - pr_automation: Default PR monitoring workflow (posts codex comments)
+    - fix_comment: Fix-comment workflow (addresses review comments)
+    - codex_update: Codex update workflow (browser automation)
+    - fixpr: FixPR workflow (resolves conflicts/failing checks)
+    """
+    return get_automation_limits_with_overrides()
+
+
+def coerce_positive_int(value: Any, *, default: int) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return default
+    return parsed if parsed > 0 else default
+
+
+def get_automation_limits_with_overrides(overrides: Optional[Mapping[str, Any]] = None) -> Dict[str, int]:
+    """Internal helper to keep defaults centralized and overrides explicit.
+
+    New limit structure:
+    - pr_limit: 50 total attempts across ALL workflows for a PR
+    - workflow limits: 10 attempts per workflow (counts ALL attempts, not just failures)
+    """
+    # Global PR limit: 50 total attempts across all workflows
+    pr_limit_default = 50
+    pr_limit = coerce_positive_int(os.getenv("AUTOMATION_PR_LIMIT"), default=pr_limit_default)
+
+    # Per-workflow limit: 10 attempts per workflow
+    workflow_limit_default = 10
+
+    defaults: Dict[str, int] = {
+        # Global PR limit: counts ALL attempts across ALL workflows
+        "pr_limit": pr_limit,
+        "global_limit": coerce_positive_int(os.getenv("AUTOMATION_GLOBAL_LIMIT"), default=50),
+        "approval_hours": 24,
+        "subprocess_timeout": 300,
+        # Workflow-specific limits: 10 attempts per workflow (counts ALL attempts)
+        "pr_automation_limit": coerce_positive_int(
+            os.getenv("AUTOMATION_PR_AUTOMATION_LIMIT"), default=workflow_limit_default
+        ),
+        "fix_comment_limit": coerce_positive_int(
+            os.getenv("AUTOMATION_FIX_COMMENT_LIMIT"), default=workflow_limit_default
+        ),
+        "codex_update_limit": coerce_positive_int(
+            os.getenv("AUTOMATION_CODEX_UPDATE_LIMIT"), default=workflow_limit_default
+        ),
+        "fixpr_limit": coerce_positive_int(os.getenv("AUTOMATION_FIXPR_LIMIT"), default=workflow_limit_default),
     }
 
+    if not overrides:
+        return dict(defaults)
+
+    limits = dict(defaults)
+    for key in list(defaults.keys()):
+        if key in overrides:
+            limits[key] = coerce_positive_int(overrides.get(key), default=defaults[key])
+
+    return limits
+
 
 def ensure_directory(file_path: str) -> None:
     """Ensure directory exists for given file path"""
@@ -224,9 +249,9 @@ def parse_timestamp(timestamp_str: str) -> datetime:
 def get_test_email_config() -> Dict[str, str]:
     """Get standardized test email configuration"""
     return {
-        'SMTP_SERVER': 'smtp.example.com',
-        'SMTP_PORT': '587',
-        'EMAIL_USER': 'test@example.com',
-        'EMAIL_PASS': 'testpass',
-        'EMAIL_TO': 'admin@example.com'
+        "SMTP_SERVER": "smtp.example.com",
+        "SMTP_PORT": "587",
+        "EMAIL_USER": "test@example.com",
+        "EMAIL_PASS": "testpass",
+        "EMAIL_TO": "admin@example.com"
     }