thrillwiki_django_no_react/backend/tests/accessibility/test_wcag_compliance.py

"""
Automated WCAG 2.1 AA Compliance Tests

This module provides automated accessibility testing using axe-core via Selenium.
Tests verify WCAG 2.1 AA compliance across key pages of the ThrillWiki application.

Requirements:
    - selenium
    - axe-selenium-python
    - Chrome browser with ChromeDriver

Installation:
    pip install selenium axe-selenium-python

Usage:
    python manage.py test backend.tests.accessibility

Note: These tests require a running server and browser. They are skipped if
dependencies are not installed or if running in CI without browser support.
"""

import os
import unittest

from django.contrib.auth import get_user_model
from django.test import LiveServerTestCase, TestCase, override_settings
from django.urls import reverse

# Check if selenium and axe are available
try:
    from selenium import webdriver
    from selenium.webdriver.chrome.options import Options
    from selenium.webdriver.common.by import By
    from selenium.webdriver.support import expected_conditions as EC
    from selenium.webdriver.support.ui import WebDriverWait
    HAS_SELENIUM = True
except ImportError:
    HAS_SELENIUM = False

try:
    from axe_selenium_python import Axe
    HAS_AXE = True
except ImportError:
    HAS_AXE = False


User = get_user_model()


def skip_if_no_browser():
    """Decorator to skip tests if browser dependencies are not available."""
    if not HAS_SELENIUM:
        return unittest.skip("Selenium not installed")
    if not HAS_AXE:
        return unittest.skip("axe-selenium-python not installed")
    if os.environ.get('CI') and not os.environ.get('BROWSER_TESTS'):
        return unittest.skip("Browser tests disabled in CI")
    return lambda func: func


class AccessibilityTestMixin:
    """Mixin providing common accessibility testing utilities."""

    def run_axe_audit(self, url_name=None, url=None):
        """
        Run axe accessibility audit on a page.

        Args:
            url_name: Django URL name to reverse
            url: Full URL (alternative to url_name)

        Returns:
            dict: Axe results containing violations and passes
        """
        if url_name:
            url = f'{self.live_server_url}{reverse(url_name)}'
        elif not url:
            raise ValueError("Either url_name or url must be provided")

        self.driver.get(url)
        WebDriverWait(self.driver, 10).until(
            EC.presence_of_element_located((By.TAG_NAME, "body"))
        )

        axe = Axe(self.driver)
        axe.inject()
        results = axe.run()

        return results

    def assert_no_critical_violations(self, results, page_name="page"):
        """
        Assert no critical or serious accessibility violations.

        Args:
            results: Axe audit results
            page_name: Name of page for error messages
        """
        critical_violations = [
            v for v in results.get('violations', [])
            if v.get('impact') in ('critical', 'serious')
        ]

        if critical_violations:
            violation_details = "\n".join([
                f"- {v['id']}: {v['description']} (impact: {v['impact']})"
                for v in critical_violations
            ])
            self.fail(
                f"Critical accessibility violations found on {page_name}:\n"
                f"{violation_details}"
            )

    def assert_wcag_aa_compliant(self, results, page_name="page"):
        """
        Assert WCAG 2.1 AA compliance (no violations at all).

        Args:
            results: Axe audit results
            page_name: Name of page for error messages
        """
        violations = results.get('violations', [])

        if violations:
            violation_details = "\n".join([
                f"- {v['id']}: {v['description']} (impact: {v['impact']})"
                for v in violations
            ])
            self.fail(
                f"WCAG 2.1 AA violations found on {page_name}:\n"
                f"{violation_details}"
            )


@skip_if_no_browser()
@override_settings(DEBUG=True)
class WCAGComplianceTests(AccessibilityTestMixin, LiveServerTestCase):
    """
    Automated WCAG 2.1 AA compliance tests for ThrillWiki.

    These tests use axe-core via Selenium to automatically detect
    accessibility issues across key pages.
    """

    @classmethod
    def setUpClass(cls):
        super().setUpClass()

        # Configure Chrome for headless testing
        chrome_options = Options()
        chrome_options.add_argument('--headless')
        chrome_options.add_argument('--no-sandbox')
        chrome_options.add_argument('--disable-dev-shm-usage')
        chrome_options.add_argument('--disable-gpu')
        chrome_options.add_argument('--window-size=1920,1080')

        try:
            cls.driver = webdriver.Chrome(options=chrome_options)
            cls.driver.implicitly_wait(10)
        except Exception as e:
            raise unittest.SkipTest(f"Chrome WebDriver not available: {e}") from None

    @classmethod
    def tearDownClass(cls):
        if hasattr(cls, 'driver'):
            cls.driver.quit()
        super().tearDownClass()

    def test_homepage_accessibility(self):
        """Test homepage WCAG 2.1 AA compliance."""
        results = self.run_axe_audit(url_name='home')
        self.assert_no_critical_violations(results, "homepage")

    def test_park_list_accessibility(self):
        """Test park list page WCAG 2.1 AA compliance."""
        results = self.run_axe_audit(url_name='parks:park_list')
        self.assert_no_critical_violations(results, "park list")

    def test_ride_list_accessibility(self):
        """Test ride list page WCAG 2.1 AA compliance."""
        results = self.run_axe_audit(url_name='rides:global_ride_list')
        self.assert_no_critical_violations(results, "ride list")

    def test_manufacturer_list_accessibility(self):
        """Test manufacturer list page WCAG 2.1 AA compliance."""
        results = self.run_axe_audit(url_name='rides:manufacturer_list')
        self.assert_no_critical_violations(results, "manufacturer list")

    def test_login_page_accessibility(self):
        """Test login page WCAG 2.1 AA compliance."""
        results = self.run_axe_audit(url_name='account_login')
        self.assert_no_critical_violations(results, "login page")

    def test_signup_page_accessibility(self):
        """Test signup page WCAG 2.1 AA compliance."""
        results = self.run_axe_audit(url_name='account_signup')
        self.assert_no_critical_violations(results, "signup page")


class HTMLAccessibilityTests(TestCase):
    """
    Unit tests for accessibility features in rendered HTML.

    These tests don't require a browser and verify that templates
    render correct accessibility attributes.
    """

    def test_homepage_has_main_landmark(self):
        """Verify homepage has a main landmark."""
        response = self.client.get(reverse('home'))
        self.assertContains(response, '<main')

    def test_homepage_has_skip_link(self):
        """Verify homepage has skip to content link."""
        response = self.client.get(reverse('home'))
        # Skip link should be present
        self.assertContains(response, 'skip', msg_prefix="Should have skip link")

    def test_navigation_has_aria_labels(self):
        """Verify navigation elements have ARIA labels."""
        response = self.client.get(reverse('home'))
        # Header should have aria-label or be wrapped in nav
        self.assertTrue(
            b'aria-label' in response.content or b'<nav' in response.content,
            "Navigation should have ARIA attributes"
        )

    def test_images_have_alt_text(self):
        """Verify images have alt attributes."""
        response = self.client.get(reverse('home'))
        content = response.content.decode('utf-8')

        # Find all img tags
        import re
        img_tags = re.findall(r'<img[^>]*>', content)

        for img in img_tags:
            self.assertIn(
                'alt=',
                img,
                f"Image missing alt attribute: {img[:100]}"
            )

    def test_form_fields_have_labels(self):
        """Verify form fields have associated labels."""
        response = self.client.get(reverse('account_login'))
        content = response.content.decode('utf-8')

        # Find input elements (excluding hidden and submit)
        import re
        inputs = re.findall(
            r'<input[^>]*type=["\'](?!hidden|submit)[^"\']*["\'][^>]*>',
            content
        )

        for inp in inputs:
            # Each input should have id attribute for label association
            self.assertTrue(
                'id=' in inp or 'aria-label' in inp,
                f"Input missing id or aria-label: {inp[:100]}"
            )

    def test_buttons_are_accessible(self):
        """Verify buttons have accessible names."""
        response = self.client.get(reverse('home'))
        content = response.content.decode('utf-8')

        import re
        # Find button elements
        buttons = re.findall(r'<button[^>]*>.*?</button>', content, re.DOTALL)

        for button in buttons:
            # Button should have text content or aria-label
            has_text = bool(re.search(r'>([^<]+)<', button))
            has_aria = 'aria-label' in button

            self.assertTrue(
                has_text or has_aria,
                f"Button missing accessible name: {button[:100]}"
            )


class KeyboardNavigationTests(TestCase):
    """
    Tests for keyboard navigation requirements.

    These tests verify that interactive elements are keyboard accessible.
    """

    def test_interactive_elements_are_focusable(self):
        """Verify interactive elements don't have tabindex=-1."""
        response = self.client.get(reverse('home'))
        content = response.content.decode('utf-8')

        # Links and buttons should not have tabindex=-1 (unless intentionally hidden)
        import re
        problematic = re.findall(
            r'<(a|button)[^>]*tabindex=["\']?-1["\']?[^>]*>',
            content
        )

        # Filter out elements that are legitimately hidden
        for elem in problematic:
            self.assertIn(
                'aria-hidden',
                elem,
                f"Interactive element has tabindex=-1 without aria-hidden: {elem}"
            )

    def test_modals_have_escape_handler(self):
        """Verify modal templates include escape key handling."""
        from django.template.loader import get_template

        template = get_template('components/modals/modal_inner.html')
        source = template.template.source

        self.assertIn(
            'escape',
            source.lower(),
            "Modal should handle Escape key"
        )

    def test_dropdowns_have_keyboard_support(self):
        """Verify dropdown menus support keyboard navigation."""
        response = self.client.get(reverse('home'))
        content = response.content.decode('utf-8')

        # Check for aria-expanded on dropdown triggers
        if 'dropdown' in content.lower() or 'menu' in content.lower():
            self.assertIn(
                'aria-expanded',
                content,
                "Dropdown should have aria-expanded attribute"
            )


class ARIAAttributeTests(TestCase):
    """
    Tests for correct ARIA attribute usage.
    """

    def test_modal_has_dialog_role(self):
        """Verify modal has role=dialog."""
        from django.template.loader import get_template

        template = get_template('components/modals/modal_inner.html')
        source = template.template.source

        self.assertIn(
            'role="dialog"',
            source,
            "Modal should have role=dialog"
        )

    def test_modal_has_aria_modal(self):
        """Verify modal has aria-modal=true."""
        from django.template.loader import get_template

        template = get_template('components/modals/modal_inner.html')
        source = template.template.source

        self.assertIn(
            'aria-modal="true"',
            source,
            "Modal should have aria-modal=true"
        )

    def test_breadcrumb_has_navigation_role(self):
        """Verify breadcrumbs use nav element with aria-label."""
        from django.template.loader import get_template

        template = get_template('components/navigation/breadcrumbs.html')
        source = template.template.source

        self.assertIn(
            '<nav',
            source,
            "Breadcrumbs should use nav element"
        )
        self.assertIn(
            'aria-label',
            source,
            "Breadcrumbs nav should have aria-label"
        )