add tests

Author: kolibril13

.github/workflows/tests.yml

@@ -25,6 +25,11 @@ jobs:
               run: blender -b -P tests/python.py -- -m pip install ".[test]"
             - name: Run Tests in Blender
               run: blender -b -P tests/run.py -- -vv tests --cov --cov-report=xml
+            - name: Build and validate extension
+              run: |
+                mkdir -p build
+                blender --factory-startup --command extension build --source-dir typst_importer --output-dir build
+                blender --factory-startup --command extension validate build/*.zip
     
 
 

CHANGELOG.md

@@ -8,6 +8,9 @@
 * Preserve glyph holes with the current `fill_id` and `hide_stroke` drawing attributes.
 * Add a shared Geometry Nodes modifier with an editable Grease Pencil stroke radius.
 * Restore black outlines while retaining each Typst color as the Grease Pencil fill.
+* Restore Geometry Nodes path and visibility animation tools for Blender 5.2.
+* Keep routine imports from purging unrelated orphaned Blender data.
+* Validate extension archives and core importer workflows in CI.
 
 ## v0.3.2
 

build.py

@@ -6,6 +6,8 @@
 
 import glob
 import os
+from pathlib import Path
+import shlex
 import subprocess
 import sys
 from dataclasses import dataclass
@@ -14,9 +16,11 @@
 
 
 
+ROOT_DIR = Path(__file__).resolve().parent
 ADDON_NAME = "typst_importer"
-TOML_PATH = f"./{ADDON_NAME}/blender_manifest.toml"
-WHL_PATH = f"./{ADDON_NAME}/wheels"
+ADDON_DIR = ROOT_DIR / ADDON_NAME
+TOML_PATH = ADDON_DIR / "blender_manifest.toml"
+WHL_PATH = ADDON_DIR / "wheels"
 
 # Instead of reading from pyproject.toml, define the required packages here:
 required_packages = ["typst", "databpy" ,"svg.path" , "lxml"] 
@@ -25,7 +29,7 @@ def run_python(args: str | List[str]):
     python = os.path.realpath(sys.executable)
 
     if isinstance(args, str):
-        args = [python] + args.split(" ")
+        args = [python, *shlex.split(args)]
     elif isinstance(args, list):
         args = [python] + args
     else:
@@ -34,7 +38,7 @@ def run_python(args: str | List[str]):
             "or a list of individual arguments already split"
         )
 
-    subprocess.run(args)
+    subprocess.run(args, check=True)
 
 
 try:
@@ -152,16 +156,20 @@ def build_extension(split: bool = True) -> None:
     for suffix in [".blend1", ".MNSession"]:
         clean_files(suffix=suffix)
 
+    command = [
+        bpy.app.binary_path,
+        "--factory-startup",
+        "--command",
+        "extension",
+        "build",
+        "--source-dir",
+        str(ADDON_DIR),
+        "--output-dir",
+        str(ROOT_DIR),
+    ]
     if split:
-        subprocess.run(
-            f"{bpy.app.binary_path} --command extension build"
-            f" --split-platforms --source-dir {ADDON_NAME} --output-dir ".split(" ")
-        )
-    else:
-        subprocess.run(
-            f"{bpy.app.binary_path} --command extension build "
-            f"--source-dir {ADDON_NAME} --output-dir .".split(" ")
-        )
+        command.append("--split-platforms")
+    subprocess.run(command, check=True)
 
 
 def build(platform) -> None:
@@ -177,4 +185,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()

tests/test_core_workflows_blender52.py

@@ -0,0 +1,155 @@
+"""Blender 5.2 coverage for import and Geometry Nodes utility workflows."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import bpy
+import pytest
+
+import typst_importer
+from typst_importer.node_groups import (
+    create_follow_curve_node_group,
+    modifier_input,
+)
+from typst_importer.operators.path import configure_follow_path_animation
+from typst_importer.operators.textbox_import import ImportFromTextboxAsCurveOperator
+from typst_importer.operators.visibility import toggle_visibility
+from typst_importer.typst_to_svg import deduplicate_materials, typst_express
+
+
+pytestmark = pytest.mark.skipif(
+    bpy.app.version < (5, 2, 0),
+    reason="These workflows require Blender 5.2 or newer",
+)
+
+
+@pytest.fixture(autouse=True)
+def clean_blender_data():
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+    bpy.context.scene.frame_set(1)
+    yield
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+
+
+def _fcurve_frames(obj: bpy.types.Object, data_path: str) -> list[float]:
+    action = obj.animation_data.action
+    slot = obj.animation_data.action_slot
+    fcurve = next(
+        curve
+        for layer in action.layers
+        for strip in layer.strips
+        for curve in strip.channelbag(slot).fcurves
+        if curve.data_path == data_path
+    )
+    return [point.co.x for point in fcurve.keyframe_points]
+
+
+def test_visibility_uses_typed_modifier_input_and_keyframes():
+    mesh = bpy.data.meshes.new("VisibilityMesh")
+    obj = bpy.data.objects.new("VisibilityObject", mesh)
+    bpy.context.scene.collection.objects.link(obj)
+
+    modifier = toggle_visibility(obj, current_frame=5, make_visible=True)
+    input_value, socket = modifier_input(modifier, "Visibility")
+
+    assert input_value.type == "VALUE"
+    assert input_value.value is False
+    data_path = f'modifiers["{modifier.name}"].properties.inputs.{socket.identifier}.value'
+    assert _fcurve_frames(obj, data_path) == [4.0, 5.0]
+
+
+def test_follow_path_uses_typed_object_and_factor_inputs():
+    mesh = bpy.data.meshes.new("FollowerMesh")
+    follower = bpy.data.objects.new("Follower", mesh)
+    bpy.context.scene.collection.objects.link(follower)
+
+    curve_data = bpy.data.curves.new("Path", type="CURVE")
+    path = bpy.data.objects.new("Path", curve_data)
+    bpy.context.scene.collection.objects.link(path)
+    spline = curve_data.splines.new("POLY")
+    spline.points.add(1)
+    spline.points[0].co = (0.0, 0.0, 0.0, 1.0)
+    spline.points[1].co = (2.0, 0.0, 0.0, 1.0)
+
+    modifier = follower.modifiers.new("FollowPath", type="NODES")
+    modifier.node_group = create_follow_curve_node_group()
+    configure_follow_path_animation(follower, modifier, path, current_frame=3)
+
+    object_input, _ = modifier_input(modifier, "Object")
+    factor_input, factor_socket = modifier_input(modifier, "Factor")
+    assert object_input.type == "VALUE"
+    assert object_input.value == path
+    assert factor_input.type == "VALUE"
+    assert factor_input.value == pytest.approx(0.0)
+    factor_path = (
+        f'modifiers["{modifier.name}"].properties.inputs.'
+        f"{factor_socket.identifier}.value"
+    )
+    assert _fcurve_frames(follower, factor_path) == [3.0, 13.0]
+
+    configure_follow_path_animation(follower, modifier, path, current_frame=8)
+    assert _fcurve_frames(follower, factor_path) == [8.0, 18.0]
+
+
+@pytest.mark.parametrize(
+    ("kwargs", "object_type", "fill_mode"),
+    [
+        ({"convert_to_mesh": False}, "CURVE", "BOTH"),
+        ({}, "MESH", None),
+        (
+            {"convert_to_mesh": False, "convert_to_unfilled_path": True},
+            "CURVE",
+            "NONE",
+        ),
+    ],
+)
+def test_typst_import_modes(kwargs, object_type, fill_mode):
+    collection = typst_express(
+        '#rect(width: 12pt, height: 12pt, fill: rgb("#336699"))',
+        name=f"pytest_{object_type}_{fill_mode}",
+        **kwargs,
+    )
+
+    objects = list(collection.objects)
+    assert objects
+    assert {obj.type for obj in objects} == {object_type}
+    if fill_mode is not None:
+        assert all(obj.data.fill_mode == fill_mode for obj in objects)
+
+
+def test_material_deduplication_preserves_unrelated_orphan_data():
+    unrelated_material = bpy.data.materials.new("KeepThisMaterial")
+    collection = bpy.data.collections.new("MaterialDedup")
+    bpy.context.scene.collection.children.link(collection)
+
+    curve = bpy.data.curves.new("ImportedCurve", type="CURVE")
+    material = bpy.data.materials.new("ImportedMaterial")
+    curve.materials.append(material)
+    collection.objects.link(bpy.data.objects.new("ImportedCurve", curve))
+
+    deduplicate_materials(collection)
+
+    assert bpy.data.materials.get(unrelated_material.name) == unrelated_material
+
+
+def test_textbox_curve_importer_smoke_test(tmp_path: Path):
+    typst_file = tmp_path / "textbox_input.typ"
+    typst_file.write_text('#rect(width: 12pt, height: 12pt, fill: rgb("#336699"))')
+
+    collection = ImportFromTextboxAsCurveOperator.import_typst(
+        None,
+        typst_file,
+    )
+
+    assert collection.objects
+    assert {obj.type for obj in collection.objects} == {"CURVE"}
+
+
+def test_addon_registers_and_unregisters_cleanly():
+    typst_importer.register()
+    try:
+        assert hasattr(bpy.ops.import_scene, "import_textbox_grease_pencil")
+        assert hasattr(bpy.ops.export_scene, "typst_svg")
+    finally:
+        typst_importer.unregister()

typst_importer/node_groups.py

@@ -25,6 +25,30 @@ def _interface_input(node_group, name):
     )
 
 
+def modifier_input(modifier, socket_name):
+    """Return a Geometry Nodes modifier input and its interface socket."""
+    socket = _interface_input(modifier.node_group, socket_name)
+    if socket is None:
+        raise ValueError(
+            f"Node group {modifier.node_group.name!r} has no {socket_name!r} input"
+        )
+    return getattr(modifier.properties.inputs, socket.identifier), socket
+
+
+def set_modifier_input_value(modifier, socket_name, value):
+    """Set a Geometry Nodes modifier input with Blender 5.2 typed RNA."""
+    input_value, socket = modifier_input(modifier, socket_name)
+    input_value.type = "VALUE"
+    input_value.value = value
+    return socket
+
+
+def modifier_input_data_path(modifier, socket_name):
+    """Return the Blender RNA path used to keyframe a modifier input."""
+    _, socket = modifier_input(modifier, socket_name)
+    return f'modifiers["{modifier.name}"].properties.inputs.{socket.identifier}.value'
+
+
 def create_grease_pencil_stroke_radius_node_group():
     """Create the shared Blender 5.2 node group for Typst GP outlines.
 
@@ -136,7 +160,6 @@ def add_grease_pencil_stroke_radius_modifier(
         raise ValueError("Grease Pencil stroke radius must be non-negative")
 
     node_group = create_grease_pencil_stroke_radius_node_group()
-    radius_socket = _interface_input(node_group, "Stroke Radius")
     modifier = obj.modifiers.new(
         name=GREASE_PENCIL_STROKE_NODE_GROUP,
         type="NODES",
@@ -146,12 +169,7 @@ def add_grease_pencil_stroke_radius_modifier(
     # Blender 5.2 exposes modifier inputs through a typed RNA interface. The
     # legacy modifier["Socket_2"] ID-property access is unsupported by the
     # current API.
-    modifier_input = getattr(
-        modifier.properties.inputs,
-        radius_socket.identifier,
-    )
-    modifier_input.type = "VALUE"
-    modifier_input.value = float(stroke_radius)
+    set_modifier_input_value(modifier, "Stroke Radius", float(stroke_radius))
     return modifier
 
 

typst_importer/operators/op_utils.py

@@ -11,3 +11,24 @@ def get_or_create_collection(name):
         # Link it to the scene
         bpy.context.scene.collection.children.link(collection)
         return collection
+
+
+def animation_fcurves(obj: bpy.types.Object):
+    """Return the object's active Action f-curves across Blender action APIs."""
+    if obj.animation_data is None or obj.animation_data.action is None:
+        return ()
+
+    action = obj.animation_data.action
+    if hasattr(action, "fcurves"):
+        return action.fcurves
+
+    slot = obj.animation_data.action_slot
+    if slot is None:
+        return ()
+
+    for layer in action.layers:
+        for strip in layer.strips:
+            channelbag = strip.channelbag(slot)
+            if channelbag is not None:
+                return channelbag.fcurves
+    return ()