pytest-optional-dependencies 0.1.2__tar.gz

pytest_optional_dependencies-0.1.2/.github/.deployment.md

@@ -0,0 +1,22 @@
+# Build & Deploy
+
+Note: If you're not Brian, don't try this.
+
+## Modify version
+
+Change the version in pyproject.toml
+
+## Update Changelog
+
+Update changelog.md
+
+## Tag
+
+```
+(ok) $ git tag -a 2.4.1 -m 'some message'
+(ok) $ git push --tags
+```
+
+## Release
+
+Go to [new release](https://github.com/okken/pytest-optional-dependencies/releases/new) and manually create one based on the above tag.

pytest_optional_dependencies-0.1.2/.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+github: okken

pytest_optional_dependencies-0.1.2/.github/workflows/main.yml

@@ -0,0 +1,46 @@
+name: Python package
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  FORCE_COLOR: "1"
+  TOX_TESTENV_PASSENV: FORCE_COLOR
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v5
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+          # allow-prereleases: true # needed for 3.14 
+      - name: Install Tox and any other packages
+        run: pip install tox tox-uv
+      - name: Run Tox
+        run: tox -e py
+
+  static-analysis:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v5
+      - name: Setup Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.14"
+      - name: Install Tox and any other packages
+        run: pip install tox tox-uv
+      - name: Run Tox quality checks
+        run: tox -e lint,format

pytest_optional_dependencies-0.1.2/.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,23 @@
+name: Publish to PyPI
+
+on: push
+
+jobs:
+  build-n-publish:
+    name: Build and publish to PyPI and TestPyPI
+    if: startsWith(github.ref, 'refs/tags')
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+    steps:
+    - uses: actions/checkout@v5
+    - name: Set up Python 3.12
+      uses: actions/setup-python@v6
+      with:
+        python-version: "3.12"
+    - name: Install pypa/build
+      run: python -m pip install build --user
+    - name: Build a binary wheel and a source tarball
+      run: python -m build --sdist --wheel --outdir dist/
+    - name: Publish to PyPI 
+      uses: pypa/gh-action-pypi-publish@release/v1

pytest_optional_dependencies-0.1.2/.gitignore

@@ -0,0 +1,15 @@
+*.egg-info
+*.pyc
+.tox
+dist/
+__pycache__
+.coverage
+.idea/
+cov_html/
+venv/
+README.html
+build/
+htmlcov/
+*.swp
+.python-version
+.vscode/

pytest_optional_dependencies-0.1.2/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+## Unreleased
+
+### Nothing her yet
+
+## 0.1.2
+
+### Added
+
+- Initial optional-dependencies plugin.
+

pytest_optional_dependencies-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) collect-filter contributors
+
+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_optional_dependencies-0.1.2/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: pytest-optional-dependencies
+Version: 0.1.2
+Summary: Don't test code that won't load due to missing imports. A pytest plugin to skip tests that require optional dependencies that are not installed.
+Project-URL: Homepage, https://github.com/okken/pytest-optional-dependencies
+Project-URL: Repository, https://github.com/okken/pytest-optional-dependencies
+Project-URL: Issues, https://github.com/okken/pytest-optional-dependencies/issues
+Author: Brian Okken
+License: MIT
+License-File: LICENSE
+Keywords: collection,imports,plugin,pytest,testing
+Classifier: Framework :: Pytest
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: pytest>=8.0
+Provides-Extra: dev
+Requires-Dist: hatchling>=1.25; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: tox>=4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pytest-optional-dependencies
+
+Don't test code that won't load due to missing imports. 
+A pytest plugin to skip tests that require optional dependencies that are not installed.
+
+Collection-time optional dependency handling for pytest.
+
+This plugin allows specific missing imports to be treated as optional so collection can continue without errors.
+
+## Features
+
+* --optional-dependency MODULE (repeatable, also accepts comma-separated values).
+    * specify which dependencies to skip/deselect based on their absence
+* --optional-dependencies-any 
+    * to treat any missing module import as optional.
+* --optional-dependencies-action 
+    * to control optional import handling: skip (default) or deselect.
+* Configuration options
+  * optional_dependencies 
+  * optional_dependencies_any 
+  * optional_dependencies_action 
+* --report-optional-dependencies
+    * Report what was filtered and why.
+
+## Install
+
+```bash
+uv pip install pytest-optional-dependencies
+```
+
+Or with pip:
+
+```bash
+python -m pip install pytest-optional-dependencies
+```
+
+## Compatibility
+
+- Python: 3.10+
+- pytest: 8.0+
+
+## CLI options
+
+- --optional-dependency MODULE
+- --optional-dependencies-any
+- --optional-dependencies-action {deselect,skip}
+- --report-optional-dependencies
+
+## Configuration
+
+pytest.ini:
+
+```ini
+[pytest]
+optional_dependencies =
+    optional_dependency
+    some_namespace.submodule
+optional_dependencies_any = false
+optional_dependencies_action = skip
+```
+
+pyproject.toml:
+
+```toml
+[tool.pytest.ini_options]
+optional_dependencies = [
+  "optional_dependency",
+  "some_namespace.submodule",
+]
+optional_dependencies_any = false
+optional_dependencies_action = "skip"
+```
+
+## Example
+
+```bash
+pytest -q --optional-dependency optional_dependency --report-optional-dependencies
+pytest -q --optional-dependency optional_dependency --optional-dependencies-action skip
+```
+
+## Development
+
+```bash
+python -m pytest -q
+```
+
+## License
+
+MIT. See LICENSE.

pytest_optional_dependencies-0.1.2/README.md

@@ -0,0 +1,89 @@
+# pytest-optional-dependencies
+
+Don't test code that won't load due to missing imports. 
+A pytest plugin to skip tests that require optional dependencies that are not installed.
+
+Collection-time optional dependency handling for pytest.
+
+This plugin allows specific missing imports to be treated as optional so collection can continue without errors.
+
+## Features
+
+* --optional-dependency MODULE (repeatable, also accepts comma-separated values).
+    * specify which dependencies to skip/deselect based on their absence
+* --optional-dependencies-any 
+    * to treat any missing module import as optional.
+* --optional-dependencies-action 
+    * to control optional import handling: skip (default) or deselect.
+* Configuration options
+  * optional_dependencies 
+  * optional_dependencies_any 
+  * optional_dependencies_action 
+* --report-optional-dependencies
+    * Report what was filtered and why.
+
+## Install
+
+```bash
+uv pip install pytest-optional-dependencies
+```
+
+Or with pip:
+
+```bash
+python -m pip install pytest-optional-dependencies
+```
+
+## Compatibility
+
+- Python: 3.10+
+- pytest: 8.0+
+
+## CLI options
+
+- --optional-dependency MODULE
+- --optional-dependencies-any
+- --optional-dependencies-action {deselect,skip}
+- --report-optional-dependencies
+
+## Configuration
+
+pytest.ini:
+
+```ini
+[pytest]
+optional_dependencies =
+    optional_dependency
+    some_namespace.submodule
+optional_dependencies_any = false
+optional_dependencies_action = skip
+```
+
+pyproject.toml:
+
+```toml
+[tool.pytest.ini_options]
+optional_dependencies = [
+  "optional_dependency",
+  "some_namespace.submodule",
+]
+optional_dependencies_any = false
+optional_dependencies_action = "skip"
+```
+
+## Example
+
+```bash
+pytest -q --optional-dependency optional_dependency --report-optional-dependencies
+pytest -q --optional-dependency optional_dependency --optional-dependencies-action skip
+```
+
+## Development
+
+```bash
+python -m pytest -q
+```
+
+## License
+
+MIT. See LICENSE.

pytest_optional_dependencies-0.1.2/examples/README.md

@@ -0,0 +1,27 @@
+## Example test files for pytest-optional-dependencies
+
+Run from this folder so pytest picks this pyproject.toml:
+
+```bash
+cd examples
+```
+
+- pyproject.toml
+  - sets optional_dependencies = ["missing_dependency", "vendor_only_package"]
+  - sets optional_dependencies_any = false
+  - defaults optional missing imports to skip reporting behavior.
+
+- test_bad_dependency.py
+  - imports bad_dependency.
+  - default behavior is a collection error.
+  - use --optional-dependency bad_dependency to skip collection for the file.
+
+- test_optional_dependency.py
+  - imports missing_dependency.
+  - because missing_dependency is listed as optional in config, it is reported as skipped and no collection error is raised.
+
+- test_simple.py
+  - ordinary passing test for baseline behavior.
+
+Use --report-optional-dependencies to print optional-dependency policy and per-file skip reasons.
+Use --optional-dependencies-action deselect to override the default and hide optional missing imports from skip counts.

pytest_optional_dependencies-0.1.2/examples/pyproject.toml

@@ -0,0 +1,4 @@
+[tool.pytest.ini_options]
+optional_dependencies = ["missing_dependency", "vendor_only_package"]
+optional_dependencies_any = false
+optional_dependencies_action = "skip"

pytest_optional_dependencies-0.1.2/examples/test_bad_dependency.py

@@ -0,0 +1,5 @@
+import bad_dependency
+
+
+def test_bad_dependency():
+    bad_dependency.some_function()

pytest_optional_dependencies-0.1.2/examples/test_optional_dependency.py

@@ -0,0 +1,5 @@
+import missing_dependency
+
+
+def test_optional_dependency():
+    missing_dependency.some_function()

pytest_optional_dependencies-0.1.2/examples/test_simple.py

@@ -0,0 +1,2 @@
+def test_simple():
+    assert True

pytest_optional_dependencies-0.1.2/pyproject.toml

@@ -0,0 +1,51 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pytest-optional-dependencies"
+version = "0.1.2"
+description = "Don't test code that won't load due to missing imports. A pytest plugin to skip tests that require optional dependencies that are not installed."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies = ["pytest>=8.0"]
+authors = [{ name = "Brian Okken" }]
+keywords = ["pytest", "plugin", "collection", "imports", "testing"]
+classifiers = [
+  "Framework :: Pytest",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Topic :: Software Development :: Testing",
+]
+
+[project.urls]
+Homepage = "https://github.com/okken/pytest-optional-dependencies"
+Repository = "https://github.com/okken/pytest-optional-dependencies"
+Issues = "https://github.com/okken/pytest-optional-dependencies/issues"
+
+[project.entry-points.pytest11]
+optional-dependencies = "pytest_optional_dependencies.plugin"
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "tox>=4.0", "hatchling>=1.25"]
+
+[dependency-groups]
+dev = ["coverage[toml]>=7.0", "ruff>=0.6.0", "build>=1.2.0", "twine>=5.1.0"]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+addopts = "-ra"
+testpaths = ["tests"]
+pytester_example_dir = "examples"
+
+[tool.coverage.run]
+branch = true
+source = ["pytest_optional_dependencies", "tests"]
+concurrency = ["multiprocessing"]
+parallel = true
+sigterm = true
+
+[tool.coverage.report]
+fail_under = 100

pytest_optional_dependencies-0.1.2/src/pytest_optional_dependencies/__init__.py

@@ -0,0 +1,4 @@
+"""pytest-optional-dependencies plugin package."""
+
+__all__ = ["__version__"]
+__version__ = "0.1.0"

pytest_optional_dependencies-0.1.2/src/pytest_optional_dependencies/plugin.py

@@ -0,0 +1,288 @@
+"""
+pytest-optional-dependencies: Handle missing imports gracefully during test collection.
+
+This plugin allows tests to be skipped or deselected if they fail collection due to
+missing optional dependency imports. This is useful when a package has optional extras
+that may not be installed in all test environments.
+"""
+
+import pytest
+
+
+# Use pytest's StashKey for thread-safe storage of plugin state
+FILTER_EVENTS_KEY = pytest.StashKey[list[str]]()
+ACCEPTABLE_MISSING_MODULES_KEY = pytest.StashKey[set[str]]()
+OPTIONAL_DEPENDENCIES_ANY_KEY = pytest.StashKey[bool]()
+OPTIONAL_DEPENDENCIES_ACTION_KEY = pytest.StashKey[str]()
+
+
+class _DeselectedCollectorNode:
+    """Minimal object for pytest_deselected accounting."""
+
+    def __init__(self, nodeid):
+        self.nodeid = nodeid
+
+
+def _extract_missing_module_name(longrepr_text):
+    """Extract the module name from a ModuleNotFoundError/ImportError message.
+
+    Why: pytest's longreprtext contains the full error traceback. We need to parse
+    the specific error message to extract just the missing module name. The error
+    message format is: "No module named 'module.name'" with either single or double
+    quotes depending on Python version and context.
+    """
+    no_module_prefix = "No module named "
+    if no_module_prefix not in longrepr_text:
+        return None
+
+    missing_part = longrepr_text.split(no_module_prefix, 1)[1].strip()
+    if not missing_part:
+        return None
+
+    # Extract the quoted module name. The quote character (single or double) indicates
+    # where the module name begins, and we find the closing quote.
+    quote = missing_part[0]
+    if quote in {'"', "'"}:
+        end_idx = missing_part.find(quote, 1)
+        if end_idx > 1:
+            return missing_part[1:end_idx]
+    return None
+
+
+def _normalize_module_names(raw_values):
+    """Convert raw config values into a normalized set of module names.
+
+    Why: Config values can come from either CLI (--optional-dependency flag, can be
+    repeated) or ini file (comma-separated lists). We need to handle both formats
+    uniformly. CLI passes a list, ini passes strings. This function flattens them
+    and handles comma-separated values so users can write either:
+      optional_dependencies = numpy,scipy
+      optional_dependencies = numpy
+                              scipy
+    in their ini file, or use --optional-dependency multiple times on the CLI.
+    """
+    modules = set()
+    for value in raw_values:
+        if not value:
+            continue
+        for part in str(value).split(","):
+            module = part.strip()
+            if module:
+                modules.add(module)
+    return modules
+
+
+def _get_optional_missing_module(report, config):
+    """Check if a collection failure is due to an optional missing import.
+
+    Why this function exists: During collection, if a test module imports an optional
+    dependency that's not installed, the entire test collection fails. We need to:
+    1. Detect if the failure was actually due to a missing import (not another error)
+    2. Extract which module was missing
+    3. Check if that module is in our list of acceptable-to-skip missing modules
+
+    Returns: The missing module name if it's an optional dependency we should skip,
+    or None if this failure shouldn't be handled by this plugin.
+    """
+    if not report.failed:
+        return None
+
+    longrepr_text = getattr(report, "longreprtext", "")
+    # Check for ModuleNotFoundError or ImportError - only then is a missing module
+    # the root cause. Other import errors (syntax errors, etc.) shouldn't be skipped.
+    if (
+        "ImportError" not in longrepr_text
+        and "ModuleNotFoundError" not in longrepr_text
+    ):
+        return None
+
+    missing_module = _extract_missing_module_name(longrepr_text)
+    if not missing_module:
+        return None
+
+    # If optional_dependencies_any is set, skip ANY missing module import error.
+    # This is useful for test environments where many optional deps might be missing.
+    if config.stash.get(OPTIONAL_DEPENDENCIES_ANY_KEY, False):
+        return missing_module
+
+    # Treat submodules as acceptable if top-level package is listed.
+    # Why: If user specifies "sklearn" as optional, they likely mean sklearn and all
+    # its submodules (sklearn.ensemble, sklearn.preprocessing, etc.). Without this,
+    # a test importing sklearn.ensemble would fail even if sklearn is listed.
+    optional_dependencies = config.stash.get(ACCEPTABLE_MISSING_MODULES_KEY, set())
+    top_level = missing_module.split(".", 1)[0]
+    if missing_module in optional_dependencies or top_level in optional_dependencies:
+        return missing_module
+    return None
+
+
+def _record_filter_event(config, message):
+    """Record a filtering decision for the debug report if --report-optional-dependencies is set.
+
+    Why: Users can pass --report-optional-dependencies to see which tests were skipped and why.
+    This helps them verify the plugin is working as intended and debug any issues.
+    """
+    if config.getoption("report_optional_dependencies"):
+        config.stash[FILTER_EVENTS_KEY].append(message)
+
+
+@pytest.hookimpl(hookwrapper=True, tryfirst=True)
+def pytest_make_collect_report(collector):
+    """Intercept collection failures and convert optional-dependency failures to skips/passes.
+
+    Why tryfirst=True: We need to run before other plugins that might fail on import errors.
+    Why hookwrapper=True: We need to intercept the report AFTER collection happens but BEFORE
+    pytest processes it further. This allows us to change the outcome from "failed" to "skipped".
+    """
+    outcome = yield
+    report = outcome.get_result()
+
+    missing_module = _get_optional_missing_module(report, collector.config)
+    if missing_module:
+        action = collector.config.stash.get(OPTIONAL_DEPENDENCIES_ACTION_KEY, "skip")
+        _record_filter_event(
+            collector.config,
+            f"{report.nodeid}: missing module '{missing_module}' is optional ({action})",
+        )
+
+        if action == "skip":
+            # Mark as skipped so the test still appears in output (good for visibility)
+            report.outcome = "skipped"
+            report.longrepr = (
+                str(collector.path),
+                0,
+                f"missing module '{missing_module}' is configured as optional",
+            )
+        else:
+            # Deselect collection node so it is reflected in pytest deselected counts.
+            collector.config.hook.pytest_deselected(
+                items=[_DeselectedCollectorNode(report.nodeid)]
+            )
+            report.outcome = "passed"
+            report.longrepr = None
+        outcome.force_result(report)
+
+
+def pytest_addoption(parser):
+    """Register command-line and ini-file options for this plugin."""
+    group = parser.getgroup("Optional dependencies")
+
+    # CLI options for specifying optional dependencies (can be used multiple times)
+    group.addoption(
+        "--optional-dependency",
+        action="append",
+        default=[],
+        metavar="MODULE",
+        help="Treat a missing module as an optional dependency during collection",
+    )
+    group.addoption(
+        "--optional-dependencies-any",
+        action="store_true",
+        default=False,
+        help="Treat any missing-module import as optional during collection",
+    )
+    group.addoption(
+        "--optional-dependencies-action",
+        action="store",
+        default=None,
+        choices=("deselect", "skip"),
+        help="How to report optional missing imports: skip (default) or deselect",
+    )
+
+    # Ini file options (alternative to CLI for permanent project configuration)
+    parser.addini(
+        "optional_dependencies",
+        "Optional dependencies that may be missing during collection import",
+        type="linelist",
+        default=[],
+    )
+    parser.addini(
+        "optional_dependencies_any",
+        "If true, treat any missing-module import as optional during collection",
+        type="bool",
+        default=False,
+    )
+    parser.addini(
+        "optional_dependencies_action",
+        "How optional missing imports are reported: skip (default) or deselect",
+        default="skip",
+    )
+
+    # Reporting option
+    if not getattr(parser, "_pytest_optional_dependencies_report_option_added", False):
+        group.addoption(
+            "--report-optional-dependencies",
+            action="store_true",
+            default=False,
+            help="Report optional-dependency collection decisions and their reasons",
+        )
+        parser._pytest_optional_dependencies_report_option_added = True
+
+
+def pytest_configure(config):
+    """Initialize plugin state at the start of the test session.
+
+    Why: We need to prepare the config.stash with initial values before collection starts,
+    and also parse/merge CLI options with ini file settings. CLI options have priority.
+    """
+    config.stash[FILTER_EVENTS_KEY] = []
+
+    # Merge optional dependencies from both ini file and CLI (CLI takes precedence)
+    configured_missing_imports = _normalize_module_names(
+        config.getini("optional_dependencies")
+    )
+    cli_missing_imports = _normalize_module_names(
+        config.getoption("optional_dependency")
+    )
+    config.stash[ACCEPTABLE_MISSING_MODULES_KEY] = (
+        configured_missing_imports | cli_missing_imports
+    )
+
+    # Set the "treat any missing import" flag if either CLI or ini is enabled
+    config.stash[OPTIONAL_DEPENDENCIES_ANY_KEY] = bool(
+        config.getini("optional_dependencies_any")
+    ) or bool(config.getoption("optional_dependencies_any"))
+
+    # Determine action (skip or deselect) - CLI takes precedence over ini file
+    action = config.getoption("optional_dependencies_action") or config.getini(
+        "optional_dependencies_action"
+    )
+    if action not in {"deselect", "skip"}:
+        raise pytest.UsageError(
+            "optional_dependencies_action must be either 'deselect' or 'skip'"
+        )
+    config.stash[OPTIONAL_DEPENDENCIES_ACTION_KEY] = action
+
+
+def pytest_collection_finish(session):
+    """Print debug report about optional dependencies if --report-optional-dependencies was set.
+
+    Why: Users need visibility into what the plugin did. This report shows the configured
+    policy and a log of every collection decision made, helping them debug issues.
+    """
+    config = session.config
+    if not config.getoption("report_optional_dependencies"):
+        return
+
+    optional_dependencies_any = config.stash.get(OPTIONAL_DEPENDENCIES_ANY_KEY, False)
+    optional_dependencies = sorted(
+        config.stash.get(ACCEPTABLE_MISSING_MODULES_KEY, set())
+    )
+    action = config.stash.get(OPTIONAL_DEPENDENCIES_ACTION_KEY, "skip")
+
+    print("optional dependency policy:")
+    print(f"  optional dependencies any: {optional_dependencies_any}")
+    print(f"  optional dependencies action: {action}")
+    if optional_dependencies:
+        print("  optional dependencies: " + ", ".join(optional_dependencies))
+    else:
+        print("  optional dependencies: (none)")
+
+    events = config.stash.get(FILTER_EVENTS_KEY, [])
+    print("optional dependency report:")
+    if not events:
+        print("  no optional imports were skipped")
+        return
+
+    for event in events:
+        print(f"  - {event}")

pytest_optional_dependencies-0.1.2/tests/conftest.py

@@ -0,0 +1 @@
+pytest_plugins = ("pytester",)

pytest_optional_dependencies-0.1.2/tests/test_helpers.py

@@ -0,0 +1,98 @@
+"""Unit tests for internal helper functions in the optional-dependencies plugin."""
+
+from pytest_optional_dependencies.plugin import (
+    _get_optional_missing_module,
+    _extract_missing_module_name,
+    _normalize_module_names,
+    pytest_addoption,
+)
+
+
+def test_extract_missing_module_name_no_prefix():
+    """Line 28: return None when 'No module named' is not in the text."""
+    assert _extract_missing_module_name("SomeOtherError: something went wrong") is None
+
+
+def test_extract_missing_module_name_empty_after_prefix():
+    """Line 32: return None when nothing follows 'No module named '."""
+    assert _extract_missing_module_name("No module named ") is None
+
+
+def test_extract_missing_module_name_unquoted():
+    """Line 41: return None when the module name is not quoted."""
+    assert _extract_missing_module_name("No module named bad_module") is None
+
+
+def test_extract_missing_module_name_empty_quoted():
+    """Cover the branch where quotes exist but no module name is inside them."""
+    assert _extract_missing_module_name("No module named ''") is None
+
+
+def test_extract_missing_module_name_single_quoted():
+    """Happy path: single-quoted module name is extracted correctly."""
+    assert _extract_missing_module_name("No module named 'bad_module'") == "bad_module"
+
+
+def test_extract_missing_module_name_double_quoted():
+    """Happy path: double-quoted module name is extracted correctly."""
+    assert _extract_missing_module_name('No module named "bad_module"') == "bad_module"
+
+
+def test_normalize_module_names_empty_string():
+    """Line 59: empty string values are skipped (continue branch)."""
+    result = _normalize_module_names(["", "good_module"])
+    assert result == {"good_module"}
+
+
+def test_normalize_module_names_trailing_comma():
+    """Line 62->60: parts that strip to empty string are skipped."""
+    result = _normalize_module_names(["good_module,"])
+    assert result == {"good_module"}
+
+
+def test_normalize_module_names_comma_only():
+    """Both empty-value and empty-part branches: comma-only value."""
+    result = _normalize_module_names([","])
+    assert result == set()
+
+
+def test_get_optional_missing_module_returns_none_when_name_not_extracted():
+    """Line 90: return None when ImportError text has no extractable module name."""
+
+    class Report:
+        failed = True
+        longreprtext = "ImportError: cannot import name something"
+
+    class Config:
+        stash = {}
+
+    assert _get_optional_missing_module(Report(), Config()) is None
+
+
+def test_pytest_addoption_skips_shared_report_option_when_already_added():
+    """Line 199->exit: guard prevents adding duplicate --report option."""
+
+    class Group:
+        def __init__(self):
+            self.options = []
+
+        def addoption(self, *args, **kwargs):
+            self.options.append((args, kwargs))
+
+    class Parser:
+        def __init__(self):
+            self._pytest_optional_dependencies_report_option_added = True
+            self.ini = []
+            self.group = Group()
+
+        def getgroup(self, _name):
+            return self.group
+
+        def addini(self, *args, **kwargs):
+            self.ini.append((args, kwargs))
+
+    parser = Parser()
+    pytest_addoption(parser)
+
+    added_option_names = [opt_args[0] for (opt_args, _kwargs) in parser.group.options]
+    assert "--report-optional-dependencies" not in added_option_names

pytest_optional_dependencies-0.1.2/tests/test_missing_imports.py

@@ -0,0 +1,272 @@
+import textwrap
+
+
+def test_missing_is_error_with_no_flag(pytester):
+    pytester.copy_example("test_simple.py")
+    pytester.copy_example("test_bad_dependency.py")
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "E   ModuleNotFoundError: No module named 'bad_dependency'*",
+        ]
+    )
+    result.assert_outcomes(errors=1)
+    assert result.ret == 2
+
+
+def test_missing_is_not_collected_with_flag(pytester):
+    pytester.copy_example("test_simple.py")
+    pytester.copy_example("test_bad_dependency.py")
+
+    result = pytester.runpytest(
+        "-v",
+        "--optional-dependency",
+        "bad_dependency",
+    )
+    result.stdout.fnmatch_lines(
+        [
+            "*collected 1 item / 1 skipped*",
+            "test_simple.py::test_simple PASSED*",
+        ]
+    )
+    result.assert_outcomes(passed=1, skipped=1)
+    assert result.ret == 0
+
+
+def test_only_optional_missing_module_is_skipped_by_default(pytester):
+    pytester.copy_example("test_bad_dependency.py")
+
+    result = pytester.runpytest(
+        "-v",
+        "--optional-dependency",
+        "bad_dependency",
+    )
+    result.assert_outcomes(skipped=1)
+    assert result.ret == 5
+
+
+def test_report(pytester):
+    pytester.copy_example("test_bad_dependency.py")
+
+    result = pytester.runpytest(
+        "-q",
+        "--optional-dependency",
+        "bad_dependency",
+        "--report-optional-dependencies",
+    )
+    result.stdout.fnmatch_lines(
+        [
+            "optional dependency policy:",
+            "  optional dependencies any: False",
+            "  optional dependencies action: skip",
+            "*optional dependencies:*bad_dependency*",
+            "*test_bad_dependency.py: missing module 'bad_dependency' is optional (skip)",
+        ]
+    )
+
+
+def test_report_any(pytester):
+    pytester.copy_example("test_bad_dependency.py")
+
+    result = pytester.runpytest(
+        "-q",
+        "--optional-dependencies-any",
+        "--report-optional-dependencies",
+    )
+    result.stdout.fnmatch_lines(
+        [
+            "optional dependency policy:",
+            "  optional dependencies any: True",
+            "  optional dependencies action: skip",
+            "*test_bad_dependency.py: missing module 'bad_dependency' is optional (skip)",
+        ]
+    )
+
+
+def test_ini_optional_dependencies_any(pytester):
+    pytester.copy_example("test_bad_dependency.py")
+    pytester.makepyprojecttoml(
+        textwrap.dedent("""
+        [tool.pytest.ini_options]
+        optional_dependencies_any = true
+    """)
+    )
+
+    result = pytester.runpytest()
+    result.assert_outcomes(skipped=1)
+    assert result.ret == 5
+
+
+def test_ini_optional_dependency(pytester):
+    pytester.copy_example("test_bad_dependency.py")
+    pytester.makepyprojecttoml(
+        textwrap.dedent("""
+        [tool.pytest.ini_options]
+        optional_dependencies = ["bad_dependency"]
+    """)
+    )
+
+    result = pytester.runpytest(
+        "-q",
+        "--report-optional-dependencies",
+    )
+    result.assert_outcomes(skipped=1)
+    assert result.ret == 5
+
+
+def test_multiple_optional_dependencies_via_cli(pytester):
+    pytester.copy_example("test_simple.py")
+    pytester.copy_example("test_bad_dependency.py")
+    pytester.copy_example("test_optional_dependency.py")
+
+    result = pytester.runpytest(
+        "-v",
+        "--optional-dependency",
+        "bad_dependency",
+        "--optional-dependency",
+        "missing_dependency",
+        "--report-optional-dependencies",
+    )
+    result.stdout.fnmatch_lines(
+        [
+            "*test_bad_dependency.py: missing module 'bad_dependency' is optional (skip)",
+            "*test_optional_dependency.py: missing module 'missing_dependency' is optional (skip)",
+        ]
+    )
+    assert result.ret == 0
+    result.assert_outcomes(passed=1, skipped=2)
+
+
+def test_multiple_optional_dependencies_via_ini(pytester):
+    pytester.makepyprojecttoml(
+        textwrap.dedent("""
+        [tool.pytest.ini_options]
+        optional_dependencies = [
+            "missing_dependency",
+            "bad_dependency",
+        ]
+    """)
+    )
+    pytester.copy_example("test_simple.py")
+    pytester.copy_example("test_bad_dependency.py")
+    pytester.copy_example("test_optional_dependency.py")
+
+    result = pytester.runpytest(
+        "-v",
+        "--report-optional-dependencies",
+    )
+    result.stdout.fnmatch_lines(
+        [
+            "*collected 1 item / 2 skipped*",
+            "*optional dependencies:*bad_dependency*missing_dependency*",
+            "*test_bad_dependency.py: missing module 'bad_dependency' is optional (skip)",
+            "*test_optional_dependency.py: missing module 'missing_dependency' is optional (skip)",
+        ]
+    )
+    assert result.ret == 0
+    result.assert_outcomes(passed=1, skipped=2)
+
+
+def test_action_deselect_via_cli_reports_deselected(pytester):
+    pytester.copy_example("test_simple.py")
+    pytester.copy_example("test_bad_dependency.py")
+
+    result = pytester.runpytest(
+        "-q",
+        "--optional-dependency",
+        "bad_dependency",
+        "--optional-dependencies-action",
+        "deselect",
+        "--report-optional-dependencies",
+    )
+    result.stdout.fnmatch_lines(
+        [
+            "optional dependency policy:",
+            "  optional dependencies action: deselect",
+            "*test_bad_dependency.py: missing module 'bad_dependency' is optional (deselect)",
+        ]
+    )
+    result.assert_outcomes(passed=1, deselected=1)
+
+
+def test_report_with_no_skips(pytester):
+    """Exercise the 'no optional imports were skipped' path in pytest_collection_finish."""
+    pytester.copy_example("test_simple.py")
+
+    result = pytester.runpytest(
+        "-q",
+        "--optional-dependency",
+        "bad_dependency",
+        "--report-optional-dependencies",
+    )
+    result.stdout.fnmatch_lines(["*no optional imports were skipped*"])
+    result.assert_outcomes(passed=1)
+
+
+def test_invalid_action_raises_usage_error(pytester):
+    """Exercise the UsageError for invalid optional_dependencies_action value."""
+    pytester.copy_example("test_simple.py")
+    pytester.makepyprojecttoml(
+        textwrap.dedent("""
+        [tool.pytest.ini_options]
+        optional_dependencies_action = "invalid"
+    """)
+    )
+
+    result = pytester.runpytest("-q")
+    result.stderr.fnmatch_lines(
+        ["*optional_dependencies_action must be either 'deselect' or 'skip'*"]
+    )
+    assert result.ret != 0
+
+
+def test_non_import_error_is_not_skipped(pytester):
+    """Exercise the path where the collection error is not an ImportError."""
+    pytester.makepyfile(
+        textwrap.dedent("""
+        raise ValueError("not an import error")
+
+        def test_something():
+            pass
+    """)
+    )
+
+    result = pytester.runpytest("-q", "--optional-dependencies-any")
+    result.assert_outcomes(errors=1)
+
+
+def test_normalize_empty_and_comma_values(pytester):
+    """Exercise _normalize_module_names with empty/trailing-comma values."""
+    pytester.copy_example("test_simple.py")
+    pytester.copy_example("test_bad_dependency.py")
+    pytester.makepyprojecttoml(
+        textwrap.dedent("""
+        [tool.pytest.ini_options]
+        optional_dependencies = ["bad_dependency,", ","]
+    """)
+    )
+
+    result = pytester.runpytest("-q")
+    result.assert_outcomes(passed=1, skipped=1)
+
+
+def test_action_deselect_via_ini_reports_deselected(pytester):
+    pytester.copy_example("test_simple.py")
+    pytester.copy_example("test_bad_dependency.py")
+    pytester.makepyprojecttoml(
+        textwrap.dedent("""
+        [tool.pytest.ini_options]
+        optional_dependencies = ["bad_dependency"]
+        optional_dependencies_action = "deselect"
+    """)
+    )
+
+    result = pytester.runpytest("-q", "--report-optional-dependencies")
+    result.stdout.fnmatch_lines(
+        [
+            "*optional dependencies action: deselect*",
+            "*test_bad_dependency.py: missing module 'bad_dependency' is optional (deselect)",
+        ]
+    )
+    result.assert_outcomes(passed=1, deselected=1)

pytest_optional_dependencies-0.1.2/tox.ini

@@ -0,0 +1,46 @@
+[tox]
+envlist = py310,py311,py312,py313,py314,lint,format,build,twine
+isolated_build = true
+skip_missing_interpreters = true
+
+[testenv]
+description = Run optional-dependencies test suite with pytest
+deps =
+    pytest>=8.0
+    coverage[toml]
+commands =
+    coverage run -m pytest -q
+    coverage combine
+    coverage report
+
+[testenv:lint]
+description = Run Ruff checks
+skip_install = true
+deps =
+    ruff>=0.6.0
+commands =
+    ruff check src tests examples
+
+[testenv:format]
+description = Check Ruff formatting
+skip_install = true
+deps =
+    ruff>=0.6.0
+commands =
+    ruff format --check src tests examples
+
+[testenv:build]
+description = Build source and wheel distributions
+skip_install = true
+deps =
+    build>=1.2.0
+commands =
+    python -m build
+
+[testenv:twine]
+description = Validate distribution metadata with twine
+skip_install = true
+deps =
+    twine>=5.1.0
+commands =
+    python -m twine check dist/*