feat: enhance testing framework with Docker support and new fixtures

- Introduced Docker fixtures using pytest-docker-tools for improved container management during tests.
- Added a `prepared_config_dir` fixture to create and manage UnrealIRCd configuration files for testing.
- Updated controller and base controller classes to support Docker container integration.
- Enhanced test cases to utilize the new Docker fixtures, improving isolation and reliability of tests.
- Refactored existing tests to leverage the new controller setup, ensuring better organization and maintainability.
- Cleaned up and optimized various test files for consistency and clarity.

Author: kzndotsh

tests/conftest.py

@@ -7,16 +7,78 @@
 """
 
 import importlib
-import pytest
-import docker
-import requests
 import os
 import time
 from pathlib import Path
-from typing import Generator, Optional, Type
 
-from .utils.base_test_cases import BaseServerTestCase
+import docker
+import pytest
+
+# Docker fixtures using pytest-docker-tools
+from pytest_docker_tools import container, image
+
 from .controllers.base_controllers import BaseServerController, TestCaseControllerConfig
+from .utils.base_test_cases import BaseServerTestCase
+
+unrealircd_image = image(name="ircatlchat-unrealircd:latest")
+
+
+@pytest.fixture(scope="function")
+def prepared_config_dir(tmp_path):
+    """Create and prepare a temporary directory with UnrealIRCd config files."""
+    import shutil
+    from pathlib import Path
+
+    config_dir = tmp_path / "container_config"
+    config_dir.mkdir(exist_ok=True)
+
+    # Source directory with real configs
+    source_dir = Path("src/backend/unrealircd/conf")
+
+    # Copy all config files
+    for config_file in source_dir.glob("*.conf"):
+        dest_file = config_dir / config_file.name
+        shutil.copy2(config_file, dest_file)
+        dest_file.chmod(0o644)  # Make readable by anyone
+
+    # Copy subdirectories
+    for subdir in ["help", "aliases", "tls"]:
+        if (source_dir / subdir).exists():
+            shutil.copytree(source_dir / subdir, config_dir / subdir, dirs_exist_ok=True)
+            # Set permissions on subdirectory files
+            for file in (config_dir / subdir).rglob("*"):
+                if file.is_file():
+                    file.chmod(0o644)
+
+    # Copy other necessary files
+    for pattern in ["*.list", "*.default.conf", "*.optional.conf"]:
+        for file in source_dir.glob(pattern):
+            dest_file = config_dir / file.name
+            shutil.copy2(file, dest_file)
+            dest_file.chmod(0o644)
+
+    print(f"DEBUG: Prepared config dir: {config_dir}")
+    print(f"DEBUG: Files in config dir: {list(config_dir.glob('*'))}")
+    print(f"DEBUG: unrealircd.conf exists: {(config_dir / 'unrealircd.conf').exists()}")
+
+    return config_dir
+
+
+unrealircd_container = container(
+    image="{unrealircd_image.id}",
+    ports={
+        "6667/tcp": None,  # Main IRC port
+        "6697/tcp": None,  # TLS port
+    },
+    volumes={
+        "{prepared_config_dir}": {"bind": "/home/unrealircd/unrealircd/conf", "mode": "rw"},
+    },
+    command=[
+        "-t",  # Test configuration
+        "-F",  # Don't fork
+    ],
+    scope="function",
+)
 
 
 def pytest_addoption(parser):
@@ -42,22 +104,22 @@ def pytest_configure(config):
     try:
         module = importlib.import_module(module_name)
     except ImportError:
-        pytest.exit("Cannot import module {}".format(module_name), 1)
+        pytest.exit(f"Cannot import module {module_name}", 1)
 
     controller_class = module.get_irctest_controller_class()
     if issubclass(controller_class, BaseServerController):
         from . import server_tests as module
     else:
         pytest.exit(
-            "{}.Controller should be a subclass of irctest.basecontroller.BaseServerController".format(module_name),
+            f"{module_name}.Controller should be a subclass of irctest.basecontroller.BaseServerController",
             1,
         )
 
     if services_module_name is not None:
         try:
             services_module = importlib.import_module(services_module_name)
         except ImportError:
-            pytest.exit("Cannot import module {}".format(services_module_name), 1)
+            pytest.exit(f"Cannot import module {services_module_name}", 1)
         controller_class.services_controller_class = services_module.get_irctest_controller_class()
 
     BaseServerTestCase.controllerClass = controller_class
@@ -177,6 +239,19 @@ def mock_docker_container(mocker):
     return mock_container
 
 
+@pytest.fixture
+def controller(unrealircd_container):
+    """Controller instance with Docker container support."""
+    from .controllers.unrealircd_controller import get_unrealircd_controller_class
+
+    controller_class = get_unrealircd_controller_class()
+    config = TestCaseControllerConfig()
+    return controller_class(config, container_fixture=unrealircd_container)
+
+
+# Removed autouse controller injection - tests should explicitly request controller fixture when needed
+
+
 @pytest.fixture
 def mock_requests_get(mocker):
     """Mock requests.get for testing HTTP calls."""
@@ -204,6 +279,7 @@ def is_service_running(self, service_name: str) -> bool:
 
             result = subprocess.run(
                 ["docker", "compose", "ps", service_name],
+                check=False,
                 cwd=self.project_root,
                 capture_output=True,
                 text=True,
@@ -219,6 +295,7 @@ def get_service_logs(self, service_name: str, tail: int = 50) -> str:
 
             result = subprocess.run(
                 ["docker", "compose", "logs", "--tail", str(tail), service_name],
+                check=False,
                 cwd=self.project_root,
                 capture_output=True,
                 text=True,
@@ -264,7 +341,7 @@ def wait_for_irc_server(self, timeout: int = 30) -> bool:
 
         return False
 
-    def send_irc_command(self, command: str) -> Optional[str]:
+    def send_irc_command(self, command: str) -> str | None:
         """Send a command to the IRC server and get response."""
         import socket
 
@@ -399,3 +476,23 @@ def setup_test_environment(project_root: Path, tmp_path_factory):
     test_env_vars = ["TESTING", "DOCKER_COMPOSE_FILE"]
     for var in test_env_vars:
         os.environ.pop(var, None)
+
+
+def _inject_controller_if_needed(request):
+    """Helper to inject controller only when needed."""
+    if hasattr(request.instance, "setup_method"):
+        # Check if this is an integration test that needs Docker
+        if any(marker in ["integration", "irc", "docker", "atheme", "webpanel"] for marker in request.keywords):
+            # Only request controller fixture when actually needed
+            controller = request.getfixturevalue("controller")
+            request.instance.controller = controller
+            # Set up connection details
+            container_ports = controller.get_container_ports()
+            request.instance.hostname = "localhost"
+            request.instance.port = container_ports.get("6667/tcp", 6667)
+
+
+@pytest.fixture(autouse=True)
+def inject_controller(request):
+    """Automatically inject controller fixture into test classes that need it."""
+    _inject_controller_if_needed(request)

tests/controllers/__init__.py

@@ -7,18 +7,18 @@
 from .atheme_controller import get_atheme_controller_class
 from .base_controllers import (
     BaseController,
-    DirectoryBasedController,
     BaseServerController,
     BaseServicesController,
+    DirectoryBasedController,
     ProcessStopped,
 )
 from .unrealircd_controller import get_unrealircd_controller_class
 
 __all__ = [
     "BaseController",
-    "DirectoryBasedController",
     "BaseServerController",
     "BaseServicesController",
+    "DirectoryBasedController",
     "ProcessStopped",
     "get_atheme_controller_class",
     "get_unrealircd_controller_class",

tests/controllers/atheme_controller.py

@@ -3,79 +3,12 @@
 Adapted from irctest's Atheme controller for our testing infrastructure.
 """
 
-from typing import Optional
+import shutil
+from pathlib import Path
 
 from .base_controllers import BaseServicesController, DirectoryBasedController
 
 
-TEMPLATE_CONFIG = """
-me {{
-    name "My.Little.Services";
-    sid "001";
-    description "test services";
-    uplink "My.Little.Server";
-}}
-
-numeric "001";
-
-connpass {{
-    password "password";
-}}
-
-log {{
-    method {{
-        file {{
-            filename "{log_file}";
-        }}
-    }}
-    level {{
-        all;
-    }}
-}}
-
-modules {{
-    load "modules/protocol/unreal4";
-    load "modules/backend/file";
-    load "modules/crypto/pbkdf2";
-    load "modules/crypto/scram-sha";
-}}
-
-database {{
-    type "file";
-    name "{db_file}";
-}}
-
-nickserv {{
-    guestnick "Guest";
-}}
-
-chanserv {{
-    maxchans "100";
-}}
-
-operserv {{
-    autokill "30";
-    akilltime "30";
-}}
-
-global {{
-    language "en";
-}}
-
-serverinfo {{
-    name "My.Little.Services";
-    description "test services";
-    numeric "001";
-    reconnect "10";
-    netname "ExampleNET";
-}}
-
-ulines {{
-    "My.Little.Services";
-}}
-"""
-
-
 class AthemeController(BaseServicesController, DirectoryBasedController):
     """Controller for managing Atheme services during testing."""
 
@@ -85,10 +18,20 @@ def __init__(self, *args, **kwargs):
         self.services_port: int | None = None
 
     def create_config(self) -> None:
-        """Create the configuration directory and basic files."""
+        """Create the configuration directory and copy real config files."""
         super().create_config()
+
         if self.directory:
-            (self.directory / "atheme.conf").touch()
+            # Source directory with real configs
+            source_dir = Path(__file__).parent.parent.parent / "src" / "backend" / "atheme" / "conf"
+
+            # Copy all config files (just like UnrealIRCd does)
+            for config_file in source_dir.glob("*.conf"):
+                shutil.copy2(config_file, self.directory / config_file.name)
+
+            # For testing, we need to modify the uplink configuration
+            # The production config has hardcoded values, but tests need dynamic ones
+            # We'll update it in the run() method with the correct hostname/port
 
     def run(self, protocol: str, server_hostname: str, server_port: int) -> None:
         """Start the Atheme services."""
@@ -100,28 +43,24 @@ def run(self, protocol: str, server_hostname: str, server_port: int) -> None:
         self.create_config()
 
         if self.directory:
-            # Create log and database files
-            log_file = self.directory / "atheme.log"
-            db_file = self.directory / "services.db"
+            config_file = self.directory / "atheme.conf"
 
-            config_content = TEMPLATE_CONFIG.format(
-                log_file=log_file,
-                db_file=db_file,
-            )
+            # Update the config file with the correct server connection details
+            if config_file.exists():
+                content = config_file.read_text()
+                # Replace the uplink configuration with test values
+                import re
 
-            config_file = self.directory / "atheme.conf"
-            with config_file.open("w") as f:
-                f.write(config_content)
+                content = re.sub(r'uplink "[^"]*" \{', 'uplink "test.server" {', content)
+                content = re.sub(r'host = "[^"]*";', f'host = "{server_hostname}";', content)
+                content = re.sub(r"port = \d+;", f"port = {server_port};", content)
+                config_file.write_text(content)
 
             self.proc = self.execute(
                 [
                     "atheme-services",
                     "-f",
                     config_file,
-                    "-p",
-                    str(server_port),
-                    "-h",
-                    server_hostname,
                 ]
             )