pytest-playwright-axe 0.0.1b0__py3-none-any.whl

pytest_playwright_axe/__init__.py

@@ -0,0 +1,3 @@
+from .axe import Axe, OPTIONS_WCAG_22AA
+__all__ = [Axe, OPTIONS_WCAG_22AA]
+__version__ = "0.0.1-beta"

pytest_playwright_axe/axe.py

@@ -0,0 +1,376 @@
+import logging
+import os
+import json
+from html import escape
+import re
+from datetime import datetime
+from playwright.sync_api import Page
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+AXE_PATH = Path(__file__).parent / "resources" / "axe.js"
+PATH_FOR_REPORT = Path(os.getcwd()) / "axe-reports"
+
+WCAG_KEYS = {
+    'wcag2a': 'WCAG 2.0 (A)',
+    'wcag2aa': 'WCAG 2.0 (AA)',
+    'wcag2aaa': 'WCAG 2.0 (AAA)',
+    'wcag21a': 'WCAG 2.1 (A)',
+    'wcag21aa': 'WCAG 2.1 (AA)',
+    'wcag22a': 'WCAG 2.2 (A)',
+    'wcag22aa': 'WCAG 2.2 (AA)',
+    'best-practice': 'Best Practice'
+}
+
+KEY_MAPPING = {
+    "testEngine": "Test Engine",
+    "testRunner": "Test Runner",
+    "testEnvironment": "Test Environment",
+    "toolOptions": "Tool Options",
+    "timestamp": "Timestamp",
+    "url": "URL",
+}
+
+WCAG_22AA_RULESET = ['wcag2a', 'wcag21a', 'wcag2aa',
+                     'wcag21aa', 'wcag22a', 'wcag22aa', 'best-practice']
+OPTIONS_WCAG_22AA = "{runOnly: {type: 'tag', values: " + \
+    str(WCAG_22AA_RULESET) + "}}"
+
+
+class Axe:
+    """
+    This utility allows for interaction with axe-core, to allow for accessibility scanning of pages
+    under test to identify any accessibility concerns.
+    """
+
+    @staticmethod
+    def run(page: Page,
+            filename: str = "",
+            output_directory: str = PATH_FOR_REPORT,
+            context: str = "",
+            options: str = "",
+            report_on_violation_only: bool = False,
+            strict_mode: bool = False,
+            html_report_generated: bool = True,
+            json_report_generated: bool = True) -> dict:
+        """
+        This runs axe-core against the page provided.
+
+        Args:
+            page (playwright.sync_api.Page): The page object to execute axe-core against.
+            filename (str): [Optional] The filename to use for the outputted reports. If not provided, defaults to the URL under test.
+            context (str): [Optional] If provided, a stringified JavaScript object to denote the context axe-core should use.
+            options (str): [Optional] If provided, a stringified JavaScript object to denote the options axe-core should use.
+            report_on_violation_only (bool): [Optional] If true, only generates an Axe report if a violation is detected. If false (default), always generate a report.
+            strict_mode (bool): [Optional] If true, raise an exception if a violation is detected. If false (default), proceed with test execution.
+            html_report_generated (bool): [Optional] If true (default), generates a html report for the page scanned. If false, no html report is generated.
+            json_report_generated (bool): [Optional] If true (default), generates a json report for the page scanned. If false, no json report is generated.
+
+        Returns:
+            dict: A Python dictionary with the axe-core output of the page scanned.
+        """
+
+        page.evaluate(AXE_PATH.read_text(encoding="UTF-8"))
+
+        response = page.evaluate(
+            "axe.run(" + Axe._build_run_command(context, options) + ").then(results => {return results;})")
+
+        logger.info(f"""Axe scan summary of [{response["url"]}]: Passes = {len(response["passes"])},
+                    Violations = {len(response["violations"])}, Inapplicable = {len(response["inapplicable"])},
+                    Incomplete = {len(response["incomplete"])}""")
+
+        violations_detected = len(response["violations"]) > 0
+        if not report_on_violation_only or (report_on_violation_only and violations_detected):
+            if html_report_generated:
+                Axe._create_html_report(response, output_directory, filename)
+            if json_report_generated:
+                Axe._create_json_report(response, output_directory, filename)
+
+        if violations_detected and strict_mode:
+            raise AxeAccessibilityException(
+                f"Axe Accessibility Violation detected on page: {response["url"]}")
+
+        return response
+
+    @staticmethod
+    def run_list(page: Page,
+                 page_list: list[str],
+                 use_list_for_filename: bool = True,
+                 output_directory: str = PATH_FOR_REPORT,
+                 context: str = "",
+                 options: str = "",
+                 report_on_violation_only: bool = False,
+                 strict_mode: bool = False,
+                 html_report_generated: bool = True,
+                 json_report_generated: bool = True) -> dict:
+        """
+        This runs axe-core against a list of pages provided.
+
+        NOTE: It is recommended to set a --base-url value when running Playwright using this functionality, so you only need to pass in a partial URL within the page_list.
+
+        Args:
+            page (playwright.sync_api.Page): The page object to execute axe-core against.
+            page_list (list[playwright.sync_api.Page): A list of URLs to execute against.
+            use_list_for_filename (bool): If true, based filenames off the list provided. If false, use the full URL under test for the filename.
+            context (str): [Optional] If provided, a stringified JavaScript object to denote the context axe-core should use.
+            options (str): [Optional] If provided, a stringified JavaScript object to denote the options axe-core should use.
+            report_on_violation_only (bool): [Optional] If true, only generates an Axe report if a violation is detected. If false (default), always generate a report.
+            strict_mode (bool): [Optional] If true, raise an exception if a violation is detected. If false (default), proceed with test execution.
+            html_report_generated (bool): [Optional] If true (default), generates a html report for the page scanned. If false, no html report is generated.
+            json_report_generated (bool): [Optional] If true (default), generates a json report for the page scanned. If false, no json report is generated.
+
+        Returns:
+            dict: A Python dictionary with the axe-core output of all the pages scanned, with the page list used as the key for each report.
+        """
+        results = {}
+        for selected_page in page_list:
+            page.goto(selected_page)
+            filename = Axe._modify_filename_for_report(
+                selected_page) if use_list_for_filename else ""
+            results[selected_page] = Axe.run(
+                page,
+                filename=filename,
+                output_directory=output_directory,
+                context=context,
+                options=options,
+                report_on_violation_only=report_on_violation_only,
+                strict_mode=strict_mode,
+                html_report_generated=html_report_generated,
+                json_report_generated=json_report_generated
+            )
+        return results
+
+    @staticmethod
+    def _build_run_command(context: str = "", options: str = "") -> str:
+        return_str = context if len(context) > 0 else ""
+        return_str += ", " if len(return_str) > 0 and len(options) > 0 else ""
+        return_str += options if len(options) > 0 else ""
+
+        return return_str
+
+    @staticmethod
+    def _modify_filename_for_report(filename_to_modify: str) -> str:
+        if filename_to_modify[-1] == "/":
+            filename_to_modify = filename_to_modify[:-1]
+        for item_to_remove in ["http://", "https://"]:
+            filename_to_modify = filename_to_modify.replace(item_to_remove, "")
+        filename_to_modify = re.sub(r'[^a-zA-Z0-9-_]', '_', filename_to_modify)
+
+        return filename_to_modify
+
+    @staticmethod
+    def _create_path_for_report(path_for_report: str, filename: str) -> Path:
+        if not os.path.exists(path_for_report):
+            os.mkdir(path_for_report)
+
+        return path_for_report / filename
+
+    @staticmethod
+    def _create_json_report(data: dict, path_for_report: str, filename_override: str = "") -> None:
+        filename = f"{Axe._modify_filename_for_report(data["url"])}.json" if filename_override == "" else f"{filename_override}.json"
+        full_path = Axe._create_path_for_report(path_for_report, filename)
+
+        with open(full_path, 'w') as file:
+            file.writelines(json.dumps(data))
+
+        logger.info(f"JSON report generated: {full_path}")
+
+    @staticmethod
+    def _create_html_report(data: dict, path_for_report: str, filename_override: str = "") -> None:
+        filename = f"{Axe._modify_filename_for_report(data["url"])}.html" if filename_override == "" else f"{filename_override}.html"
+        full_path = Axe._create_path_for_report(path_for_report, filename)
+
+        with open(full_path, 'w') as file:
+            file.writelines(Axe._generate_html(data))
+
+        logger.info(f"HTML report generated: {full_path}")
+
+    @staticmethod
+    def _generate_html(data: dict) -> str:
+        def css_styling() -> str:
+            return """
+                <style>
+                    body { font-family: Arial, sans-serif; margin: 20px; }
+                    h1, h2, h3 { color: #333; }
+                    table { width: 100%; border-collapse: collapse; margin-bottom: 20px; }
+                    th, td { border: 1px solid #ccc; padding: 8px; text-align: left; }
+                    th { background-color: #f4f4f4; }
+                    pre { background-color: #f9f9f9; padding: 10px; border: 1px solid #ddd; }
+                    code { background-color: #f9f9f9; padding: 2px 4px; border-radius: 4px; word-wrap: break-word; word-break: break-all; white-space: pre-wrap; }
+                    p { margin: 10px 0; }
+                    div { padding: 10px; border: 1px solid #ddd; }
+                </style>"""
+
+        def wcag_tagging(tags: list[str]) -> str:
+            wcag_tags = []
+            for tag in tags:
+                if tag in WCAG_KEYS:
+                    wcag_tags.append(WCAG_KEYS[tag])
+            return ", ".join(wcag_tags)
+
+        # --- HTML Generation ---
+
+        # HTML header
+        html = f"<!DOCTYPE html><html><head>{css_styling()}<title>Axe Accessibility Report</title></head><body>"
+
+        # HTML body
+        # Title and URL
+        html += "<h1>Axe Accessibility Report</h1>"
+        html += f"""<p>This is an axe-core accessibility summary generated on
+                    {datetime.strptime(data["timestamp"], "%Y-%m-%dT%H:%M:%S.%fZ").strftime("%d/%m/%Y %H:%M")}
+                    for: <strong>{data['url']}</strong></p>"""
+
+        # Violations
+        # Summary
+        html += "<h2>Violations Found</h2>"
+        if len(data['violations']) > 0:
+            html += f"<p>{len(data['violations'])} violations found.</p>"
+
+            html += "<table><tr>"
+            for header in [("#", "2", "text-align: center; "), ("Description", "53", ""), ("Axe Rule ID", "15", ""), ("WCAG", "15", ""), ("Impact", "10", ""), ("Count", "5", "text-align: center; ")]:
+                html += f'<th style="{header[2]}width: {header[1]}%">{header[0]}</th>'
+
+            violation_count = 1
+            violation_section = ""
+            for violation in data['violations']:
+                violations_table = ""
+
+                html += "<tr>"
+                html += f'<td style="text-align: center;">{violation_count}</td>'
+                html += f"<td>{escape(violation['description'])}</td>"
+                html += f'<td><a href="{violation['helpUrl']}" target="_blank">{violation['id']}</a></td>'
+                html += f"<td>{wcag_tagging(violation['tags'])}</td>"
+                html += f"<td>{violation['impact']}</td>"
+                html += f'<td style="text-align: center;">{len(violation['nodes'])}</td>'
+                html += "</tr>"
+
+                violation_count += 1
+
+                violations_table += "<table><tr>"
+                node_count = 1
+                for header in [("#", "2", "text-align: center; "), ("Description", "49", ""), ("Fix Information", "49", "")]:
+                    violations_table += f'<th style="{header[2]}width: {header[1]}%">{header[0]}</th>'
+
+                for node in violation['nodes']:
+                    violations_table += f'<tr><td style="text-align: center;">{node_count}</td>'
+                    violations_table += '<td><p>Element Location:</p>'
+                    violations_table += f"<pre><code>{escape("<br>".join(node['target']))}</code></pre>"
+                    violations_table += f'<p>HTML:</p><pre><code>{escape(node['html'])}</code></pre></td>'
+                    violations_table += f"<td>{str(escape(node['failureSummary'])).replace("Fix any of the following:", "<strong>Fix any of the following:</strong><br />").replace("\n ", "<br /> &bullet;")}</td></tr>"
+                    node_count += 1
+                violations_table += "</table>"
+
+                violation_section += f'<table><tr><td style="width: 100%"><h3>{escape(violation['description'])}</h3>'
+                violation_section += f'<p><strong>Axe Rule ID:</strong> <a href="{violation['helpUrl']}" target="_blank">{violation['id']}</a><br />'
+                violation_section += f"<strong>WCAG:</strong> {wcag_tagging(violation['tags'])}<br />"
+                violation_section += f"<strong>Impact:</strong> {violation['impact']}<br />"
+                violation_section += f"<strong>Tags:</strong> {", ".join(violation['tags'])}</p>"
+                violation_section += violations_table
+                violation_section += "</td></tr></table>"
+
+            html += "</table>"
+            html += violation_section
+        else:
+            html += "<p>No violations found.</p>"
+
+        # Passed Checks (Collapsible)
+        html += "<h2>Passed Checks</h2>"
+        if len(data['passes']) > 0:
+            html += "<table><tr>"
+            for header in [("#", "2", "text-align: center; "), ("Description", "50", ""), ("Axe Rule ID", "15", ""), ("WCAG", "18", ""), ("Nodes Passed Count", "15", "text-align: center; ")]:
+                html += f'<th style="{header[2]}width: {header[1]}%">{header[0]}</th>'
+
+            pass_count = 1
+            for passed in data['passes']:
+                violations_table = ""
+
+                html += "<tr>"
+                html += f'<td style="text-align: center;">{pass_count}</td>'
+                html += f"<td>{escape(passed['description'])}</td>"
+                html += f'<td><a href="{passed['helpUrl']}" target="_blank">{passed['id']}</a></td>'
+                html += f"<td>{wcag_tagging(passed['tags'])}</td>"
+                html += f'<td style="text-align: center;">{len(passed['nodes'])}</td>'
+                html += "</tr>"
+
+                pass_count += 1
+
+            html += "</table>"
+        else:
+            html += "<p>No passed checks found.</p>"
+
+        # Incomplete Checks (Collapsible)
+        html += "<h2>Incomplete Checks</h2>"
+        if len(data['incomplete']) > 0:
+            html += "<table><tr>"
+            for header in [("#", "2", "text-align: center; "), ("Description", "50", ""), ("Axe Rule ID", "15", ""), ("WCAG", "18", ""), ("Nodes Incomplete Count", "15", "text-align: center; ")]:
+                html += f'<th style="{header[2]}width: {header[1]}%">{header[0]}</th>'
+
+            incomplete_count = 1
+            for incomplete in data['incomplete']:
+                violations_table = ""
+
+                html += "<tr>"
+                html += f'<td style="text-align: center;">{incomplete_count}</td>'
+                html += f"<td>{escape(incomplete['description'])}</td>"
+                html += f'<td><a href="{incomplete['helpUrl']}" target="_blank">{incomplete['id']}</a></td>'
+                html += f"<td>{wcag_tagging(incomplete['tags'])}</td>"
+                html += f'<td style="text-align: center;">{len(incomplete['nodes'])}</td>'
+                html += "</tr>"
+
+                incomplete_count += 1
+
+            html += "</table>"
+        else:
+            html += "<p>No incomplete checks found.</p>"
+
+        # Inapplicable Checks (Collapsible)
+        html += "<h2>Inapplicable Checks</h2>"
+        if len(data['inapplicable']) > 0:
+            html += "<table><tr>"
+            for header in [("#", "2", "text-align: center; "), ("Description", "60", ""), ("Axe Rule ID", "20", ""), ("WCAG", "18", "")]:
+                html += f'<th style="{header[2]}width: {header[1]}%">{header[0]}</th>'
+
+            inapplicable_count = 1
+            for inapplicable in data['inapplicable']:
+
+                html += "<tr>"
+                html += f'<td style="text-align: center;">{inapplicable_count}</td>'
+                html += f"<td>{escape(inapplicable['description'])}</td>"
+                html += f'<td><a href="{inapplicable['helpUrl']}" target="_blank">{inapplicable['id']}</a></td>'
+                html += f"<td>{wcag_tagging(inapplicable['tags'])}</td>"
+                html += "</tr>"
+
+                inapplicable_count += 1
+
+            html += "</table>"
+        else:
+            html += "<p>No inapplicable checks found.</p>"
+
+        # Execution Details (Collapsible)
+        html += "<h2>Execution Details</h2>"
+
+        html += "<table><tr>"
+        for header in [("Data", "20"), ("Details", "80")]:
+            html += f'<th style="width: {header[1]}%">{header[0]}</th>'
+
+        for key in ["testEngine", "testRunner", "testEnvironment", "toolOptions", "timestamp", "url"]:
+            if key in data:
+                html += f"<tr><td>{KEY_MAPPING[key]}</td>"
+                if isinstance(data[key], dict):
+                    sub_data = ""
+                    for sub_key in data[key]:
+                        sub_data += f"{sub_key}: <i>{escape(str(data[key][sub_key]))}</i><br />"
+                    html += f"<td>{sub_data}</td></tr>"
+                else:
+                    html += f"<td>{escape(str(data[key]))}</td></tr>"
+
+        html += "</table>"
+
+        # Close tags
+        html += "</body></html>"
+
+        return html
+
+
+class AxeAccessibilityException(Exception):
+    pass

pytest_playwright_axe-0.0.1b0.dist-info/METADATA

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: pytest-playwright-axe
+Version: 0.0.1b0
+Summary: An axe-core integration for accessibility testing using Playwright Python.
+Author-email: Dave Harding <dave@punkamania.org>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/davethepunkyone/pytest-playwright-axe
+Project-URL: Repository, https://github.com/davethepunkyone/pytest-playwright-axe
+Project-URL: Issues, https://github.com/davethepunkyone/pytest-playwright-axe/issues
+Keywords: accessibility,playwright,axe,axe-core,pytest,wcag,testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Topic :: Software Development :: Testing
+Classifier: Framework :: Pytest
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENCE.md
+Requires-Dist: pytest-playwright>=0.5.1
+Dynamic: license-file
+
+# Playwright Axe
+
+This is a utility for Playwright Python that allows for the execution of [axe-core](https://github.com/dequelabs/axe-core), a JavaScript
+library used for scanning for accessibility issues and providing guidance on how to resolve these issues.
+
+## Table of Contents
+
+- [Playwright Axe](#playwright-axe)
+  - [Table of Contents](#table-of-contents)
+  - [Setup](#setup)
+  - [Using the Axe class](#using-the-axe-class)
+  - [.run(): Single page scan](#run-single-page-scan)
+    - [Required arguments](#required-arguments)
+    - [Optional arguments](#optional-arguments)
+    - [Returns](#returns)
+    - [Example usage](#example-usage)
+  - [.run\_list(): Multiple page scan](#run_list-multiple-page-scan)
+    - [Required arguments](#required-arguments-1)
+    - [Optional arguments](#optional-arguments-1)
+    - [Returns](#returns-1)
+    - [Example usage](#example-usage-1)
+  - [Licence](#licence)
+  - [Acknowledgements](#acknowledgements)
+
+## Setup
+
+You can clone this whole repository using the code below:
+
+```shell
+git clone https://github.com/davethepunkyone/playwright-axe.git
+```
+
+## Using the Axe class
+
+You can initialise the Axe class by using the following code in your test file:
+
+    from utils.axe import Axe
+
+This Axe module has been designed as a static class, so you do not need to instantiate it when you want to run a scan on a page you have navigated to using Playwright.
+
+## .run(): Single page scan
+
+To conduct a scan, you can just use the following once the page you want to check is at the right location:
+
+    Axe.run(page)
+
+This will inject the axe-core code into the page and then execute the axe.run() command, generating an accessibility report for the page being tested.
+
+By default, the `Axe.run(page)` command will do the following:
+
+- Scan the page passed in to the WCAG 2.2 AA standard
+- Generate a HTML and JSON report with the findings in the `axe-reports` directory, regardless of if any violations are found
+- Any steps after the `Axe.run()` command will continue to execute, and it will not cause the test in progress to fail (it runs a passive scan of the page)
+- Will return the full response from axe-core as a dict object if the call is set to a variable, e.g. `axe_results = Axe.run(page)` will populate `axe_results` to interact with as required
+
+### Required arguments
+
+The following are required for `Axe.run()`:
+
+| Argument | Format                   | Description                                  |
+| -------- | ------------------------ | -------------------------------------------- |
+| page     | playwright.sync_api.Page | A Playwright Page on the page to be checked. |
+
+### Optional arguments
+
+The `Axe.run(page)` has the following optional arguments that can be passed in:
+
+| Argument                   | Format      | Supported Values                                                                            | Default Value                                                                          | Description                                                                                                                                                      |
+| -------------------------- | ----------- | ------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ruleset`                  | `list[str]` | Any provided by [axe-core](https://www.deque.com/axe/core-documentation/api-documentation/) | `['wcag2a', 'wcag21a', 'wcag2aa', 'wcag21aa', 'wcag22a', 'wcag22aa', 'best-practice']` | The tags that axe-core uses to filter specific checks. Defaulted to rules used for the WCAG 2.2 AA standard.                                                     |
+| `filename`                 | `str`       | A string valid for a filename (e.g. `test_report`)                                          |                                                                                        | If provided, HTML and JSON reports will save with the filename provided. If not provided (default), the URL of the page under test will be used as the filename. |
+| `report_on_violation_only` | `bool`      | `True`, `False`                                                                             | `False`                                                                                | If True, HTML and JSON reports will only be generated if at least one violation is found.                                                                        |
+| `strict_mode`              | `bool`      | `True`, `False`                                                                             | `False`                                                                                | If True, when a violation is found an AxeAccessibilityException is raised, causing a test failure.                                                               |
+| `html_report_generated`    | `bool`      | `True`, `False`                                                                             | `True`                                                                                 | If True, a HTML report will be generated summarising the axe-core findings.                                                                                      |
+| `json_report_generated`    | `bool`      | `True`, `False`                                                                             | `True`                                                                                 | If True, a JSON report will be generated with the full axe-core findings.                                                                                        |
+
+### Returns
+
+This function can be used independently, but when set to a variable returns a `dict` with the axe-core results.
+
+### Example usage
+
+    from utils.axe import Axe
+    from playwright.sync_api import Page
+
+    def test_axe_example(page: Page) -> None:
+        page.goto("https://github.com/nhs-england-tools/playwright-python-blueprint")
+        Axe.run(page)
+
+## .run_list(): Multiple page scan
+
+To scan multiple URLs within your application, you can use the following method:
+
+    Axe.run_list(page, page_list)
+
+This runs the `Axe.run()` function noted above against each URL provided in the `page_list` argument, and will generate reports as required.
+
+### Required arguments
+
+The following are required for `Axe.run_list()`:
+
+| Argument  | Format                   | Description                                                        |
+| --------- | ------------------------ | ------------------------------------------------------------------ |
+| page      | playwright.sync_api.Page | A Playwright Page object to drive navigation to each page to test. |
+| page_list | list[str]                | A list of URLs to execute against                                  |
+
+> NOTE: It is heavily recommended that when using the `run_list` command, that you set a `--base-url` either via the pytest.ini file or by passing in the value when using the `pytest` command in the command line. By doing this, the list you pass in will not need to contain the base URL value and therefore make any scanning transferrable between environments.
+
+### Optional arguments
+
+The `Axe.run_list(page, page_list)` function has the following optional arguments that can be passed in:
+
+| Argument                   | Format      | Supported Values                                                                            | Default Value                                                                          | Description                                                                                                     |
+| -------------------------- | ----------- | ------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `use_list_for_filename`    | `bool`      | `True`, `False`                                                                             | `True`                                                                                 | If True, the filename will be derived from the value provided in the list. If False, the full URL will be used. |
+| `ruleset`                  | `list[str]` | Any provided by [axe-core](https://www.deque.com/axe/core-documentation/api-documentation/) | `['wcag2a', 'wcag21a', 'wcag2aa', 'wcag21aa', 'wcag22a', 'wcag22aa', 'best-practice']` | The tags that axe-core uses to filter specific checks. Defaulted to rules used for the WCAG 2.2 AA standard.    |
+| `report_on_violation_only` | `bool`      | `True`, `False`                                                                             | `False`                                                                                | If True, HTML and JSON reports will only be generated if at least one violation is found.                       |
+| `strict_mode`              | `bool`      | `True`, `False`                                                                             | `False`                                                                                | If True, when a violation is found an AxeAccessibilityException is raised, causing a test failure.              |
+| `html_report_generated`    | `bool`      | `True`, `False`                                                                             | `True`                                                                                 | If True, a HTML report will be generated summarising the axe-core findings.                                     |
+| `json_report_generated`    | `bool`      | `True`, `False`                                                                             | `True`                                                                                 | If True, a JSON report will be generated with the full axe-core findings.                                       |
+
+### Returns
+
+This function can be used independently, but when set to a variable returns a `dict` with the axe-core results for all pages scanned (using the URL value in the list provided as the key).
+
+### Example usage
+
+When using the following command: `pytest --base-url https://www.github.com`:
+
+    from utils.axe import Axe
+    from playwright.sync_api import Page
+
+    def test_accessibility(page: Page) -> None:
+        # A list of URLs to loop through
+        urls_to_check = [
+            "nhs-england-tools/playwright-python-blueprint",
+            "nhs-england-tools/playwright-python-blueprint/wiki"
+            ]
+
+        Axe.run_list(page, urls_to_check)
+
+
+## Licence
+
+Unless stated otherwise, the codebase is released under the [MIT License](LICENCE.md). This covers both the codebase and any sample code in the documentation.
+
+## Acknowledgements
+
+This package was created based on work initially designed for the 
+[NHS England Playwright Python Blueprint](https://github.com/nhs-england-tools/playwright-python-blueprint).

pytest_playwright_axe-0.0.1b0.dist-info/RECORD

@@ -0,0 +1,7 @@
+pytest_playwright_axe/__init__.py,sha256=qKmVgHi4zuSkJ4Jn_O1umfvNoi-AlOjpdaFj1IC69eY,105
+pytest_playwright_axe/axe.py,sha256=m3QobCq4AX6aqh5ibxnnchpx4At0vX6AvqGL6iSlcPA,18214
+pytest_playwright_axe-0.0.1b0.dist-info/licenses/LICENCE.md,sha256=01A33sc4wm4kXRR9t-vhyO_pBFJf6YrxNJENpL6Ky7I,1093
+pytest_playwright_axe-0.0.1b0.dist-info/METADATA,sha256=gqrKpw1-3weam66qTLK2Yu7HdmzSeh85E4Gf-l6H25c,12507
+pytest_playwright_axe-0.0.1b0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+pytest_playwright_axe-0.0.1b0.dist-info/top_level.txt,sha256=Ah5OmwisfHaedWQ-PUV3HvC8ISjwKvGQxK7JNDo5pbw,22
+pytest_playwright_axe-0.0.1b0.dist-info/RECORD,,

pytest_playwright_axe-0.0.1b0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pytest_playwright_axe-0.0.1b0.dist-info/licenses/LICENCE.md

@@ -0,0 +1,21 @@
+# MIT Licence
+
+Copyright (c) 2025 Dave Harding.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pytest_playwright_axe-0.0.1b0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pytest_playwright_axe