Add fixtures and improve Blender subprocess isolation

Author: mondeja

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.0.2
+current_version = 0.0.3
 
 [bumpversion:file:pytest_blender/__init__.py]
 

README.md

@@ -14,9 +14,11 @@ Blender in headless mode using its builtin Python interpreter.
 pip install pytest-blender
 ```
 
-## Usage
+## Documentation
 
-### Install dependencies in Blender Python interpreter
+### Usage
+
+#### Install dependencies in Blender Python interpreter
 
 Before execute it, you need to install your testing dependencies inside the
 builtin Blender Python interpreter. To get the interpreter location you can
@@ -35,7 +37,7 @@ with `--blender-executable` option:
 pytest-blender --blender-executable ~/blender-2.91.2-linux64/blender
 ```
 
-### Execute tests
+#### Execute tests
 
 After installing dependencies, just call pytest as usually.
 
@@ -52,7 +54,7 @@ cachedir: .pytest_cache
 rootdir: /home/mondeja/files/code/pytest-blender
 collected 1 item
 
-tests/test_import_bpy.py::test_inside_blender <module 'bpy' from '/usr/share/blender/scripts/modules/bpy/__init__.py'>
+tests/test_bpy_import.py::test_inside_blender <module 'bpy' from '/usr/share/blender/scripts/modules/bpy/__init__.py'>
 PASSED
 =========================== 1 passed in 0.01s ==================================
 ```
@@ -73,11 +75,34 @@ platform linux -- Python 3.7.7, pytest-6.2.2, py-1.10.0, pluggy-0.13.1
 rootdir: ~/pytest-blender
 collected 1 item
 
-tests/test_import_bpy.py .                                                [100%]
+tests/test_bpy_import.py .                                                [100%]
 
 ============================== 1 passed in 0.00s ===============================
 ```
 
+### Reference
+
+#### Fixtures
+
+<a name="blender_executable" href="#blender_executable">#</a> <b>blender_executable</b> ⇒ `str`
+
+Returns the path of the executable that has started the current Blender session.
+
+<a name="blender_version" href="#blender_version">#</a> <b>blender_version</b> ⇒ `str`
+
+Returns the version of Blender running in the current session.
+
+<a name="blender_python_executable" href="#blender_python_executable">#</a> <b>blender_python_executable</b> ⇒ `str`
+
+Returns the path of the Python executable builtin in the Blender release of the
+currently running session.
+
+<a name="blender_python_version" href="#blender_python_version">#</a> <b>blender_python_version</b> ⇒ `str`
+
+Returns the version of the Python executable builtin in the Blender release of
+the currently running session.
+
+
 [pypi-link]: https://pypi.org/project/pytest-blender
 [pypi-version-badge-link]: https://img.shields.io/pypi/v/pytest-blender
 [pypi-pyversions-badge-link]: https://img.shields.io/pypi/pyversions/pytest-blender

pytest_blender/__init__.py

@@ -1 +1 @@
-__version__ = "0.0.2"
+__version__ = "0.0.3"

pytest_blender/__main__.py

@@ -1,9 +1,8 @@
 import argparse
-import os
-import subprocess
 import sys
 
 from pytest_blender import __version__
+from pytest_blender.run_pytest import get_blender_binary_path_python
 from pytest_blender.utils import which_blender_by_os
 
 
@@ -46,22 +45,7 @@ def parse_args(args):
 
 def run(args):
     opts = parse_args(args)
-
-    stdout = subprocess.check_output(
-        [
-            opts.blender_executable,
-            "-b",
-            "--python-expr",
-            "import bpy;print(bpy.app.binary_path_python)",
-        ]
-    )
-
-    blender_python_path = None
-    for line in stdout.decode("utf-8").splitlines():
-        if line.startswith(os.sep):
-            blender_python_path = line
-            break
-    sys.stdout.write(f"{blender_python_path}\n")
+    sys.stdout.write(f"{get_blender_binary_path_python(opts.blender_executable)}\n")
 
     return 0
 

pytest_blender/plugin.py

@@ -19,15 +19,21 @@ def pytest_addoption(parser):
     )
 
 
-@pytest.hookimpl(tryfirst=True)
-def pytest_configure(config):
-    # parse blender executable location
+def _get_blender_executable(config):
     blender_executable = config.getoption("--blender-executable")
     if hasattr(blender_executable, "__call__"):
-        blender_executable = blender_executable()
-    else:
-        blender_executable = blender_executable[0]
+        return blender_executable()
+    return blender_executable[0]
+
+
+@pytest.fixture
+def get_blender_version():
+    stdout = subprocess.check_output([_get_blender_executable(), "--version"])
+    return stdout.splitlines()[0].split(" ")[1]
+
 
+@pytest.hookimpl(tryfirst=True)
+def pytest_configure(config):
     # build propagated CLI args
     propagated_cli_args = []
     _inside_root_invocation_arg = False
@@ -40,6 +46,8 @@ def pytest_configure(config):
             continue
         propagated_cli_args.append(arg)
 
+    blender_executable = _get_blender_executable(config)
+
     # run pytest using blender
     proc = subprocess.Popen(
         [
@@ -51,6 +59,8 @@ def pytest_configure(config):
                 "run_pytest.py",
             ),
             "--",
+            "--pytest-blender-executable",
+            blender_executable,
             *propagated_cli_args,  # propagate command line arguments
         ],
         stdout=sys.stdout,

pytest_blender/run_pytest.py

@@ -1,4 +1,15 @@
+"""Script ran by ``plugin.py`` module using a builtin Blender Python interpreter.
+
+Keep in mind that may be some functions here that, although are used in other
+parts of the package like ``get_blender_binary_path_python``, can't be located
+outside this module because the installation of `pytest-blender` in the Blender
+builtin Python intepreter shouldn't be mandatory, so avoid
+``from pytest_blender...`` imports in this module.
+"""
+
+import os
 import shlex
+import subprocess
 import sys
 
 import pytest
@@ -13,9 +24,113 @@ def _join(value):
         return join(value)
 
 
+# this function can't be in 'utils'
+def get_blender_binary_path_python(blender_executable):
+    stdout = subprocess.check_output(
+        [
+            blender_executable,
+            "-b",
+            "--python-expr",
+            "import bpy;print(bpy.app.binary_path_python)",
+        ]
+    )
+
+    blender_python_path = None
+    for line in stdout.decode("utf-8").splitlines():
+        if line.startswith(os.sep):
+            blender_python_path = line
+            break
+    return blender_python_path
+
+
+def main():
+    raw_argv = shlex.split(_join(sys.argv).split(" -- ")[1:][0])
+
+    # disable self-propagation, if installed in Blender Python interpreter
+    argv = ["-p", "no:pytest-blender"]
+
+    # parse Blender executable location, propagated from hook
+    blender_executable, _inside_bexec_arg = (None, None)
+    for arg in raw_argv:
+        if arg == "--pytest-blender-executable":
+            _inside_bexec_arg = True
+            continue
+        elif _inside_bexec_arg:
+            blender_executable = arg
+            _inside_bexec_arg = False
+            continue
+        argv.append(arg)
+
+    class PytestBlenderPlugin:
+        def _blender_python_executable(self, request):
+            blender_python_executable = request.config.cache.get(
+                "pytest-blender/blender-python-executable",
+                None,
+            )
+            if blender_python_executable is None:
+                blender_python_executable = get_blender_binary_path_python(
+                    blender_executable,
+                )
+                request.config.cache.set(
+                    "pytest-blender/blender-python-executable",
+                    blender_python_executable,
+                )
+            return blender_python_executable
+
+        @pytest.fixture
+        def blender_executable(self):
+            return blender_executable
+
+        @pytest.fixture
+        def blender_python_executable(self, request):
+            return self._blender_python_executable(request)
+
+        @pytest.fixture
+        def blender_version(self, request):
+            blender_version = request.config.cache.get(
+                "pytest-blender/blender-version",
+                None,
+            )
+            if blender_version is None:
+                version_stdout = subprocess.check_output(
+                    [blender_executable, "--version"]
+                )
+                blender_version = (
+                    version_stdout.decode("utf-8").splitlines()[0].split(" ")[1]
+                )
+                request.config.cache.set(
+                    "pytest-blender/blender-version",
+                    blender_version,
+                )
+            return blender_version
+
+        @pytest.fixture
+        def blender_python_version(self, request):
+            blender_python_version = request.config.cache.get(
+                "pytest-blender/blender-python-version",
+                None,
+            )
+            if blender_python_version is None:
+                blender_python_executable = self._blender_python_executable(request)
+                blender_python_version_stdout = subprocess.check_output(
+                    [
+                        blender_python_executable,
+                        "--version",
+                    ]
+                )
+                blender_python_version = (
+                    blender_python_version_stdout.decode("utf-8")
+                    .splitlines()[0]
+                    .split(" ")[1]
+                )
+                request.config.cache.set(
+                    "pytest-blender/blender-python-version",
+                    blender_python_version,
+                )
+            return blender_python_version
+
+    return pytest.main(argv, plugins=[PytestBlenderPlugin()])
+
+
 if __name__ == "__main__":
-    if sys.argv[-1] == "--":
-        argv = []
-    else:
-        argv = shlex.split(_join(sys.argv).split(" -- ")[1:][0])
-    sys.exit(pytest.main(argv))
+    sys.exit(main())

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = pytest_blender
-version = 0.0.2
+version = 0.0.3
 description = Blender addons tester for Pytest.
 long_description = file: README.md
 long_description_content_type = text/markdown

tests/test_fixtures.py

@@ -0,0 +1,38 @@
+"""pytest-blender fixtures tests."""
+
+import os
+import re
+import subprocess
+
+
+def test_blender_executable(blender_executable):
+    assert os.path.isfile(blender_executable)
+    assert "blender" in os.path.basename(blender_executable).lower()
+
+
+def test_blender_python_executable(blender_python_executable):
+    assert os.path.isfile(blender_python_executable)
+    assert "python" in os.path.basename(blender_python_executable)
+
+
+def test_blender_version(blender_executable, blender_version):
+    stdout = subprocess.check_output([blender_executable, "--version"])
+    expected_blender_version = stdout.decode("utf-8").splitlines()[0].split(" ")[1]
+
+    assert expected_blender_version == blender_version
+    assert re.match(r"\d+\.\d", blender_version)
+
+
+def test_blender_python_version(blender_python_version, blender_python_executable):
+    blender_python_version_stdout = subprocess.check_output(
+        [
+            blender_python_executable,
+            "--version",
+        ]
+    )
+    expected_blender_python_version = (
+        blender_python_version_stdout.decode("utf-8").splitlines()[0].split(" ")[1]
+    )
+
+    assert blender_python_version == expected_blender_python_version
+    assert re.match(r"\d+\.\d\.?\d*", blender_python_version)