test: adjust tests to new defaults

Author: 404Simon

tests/test_config.py

@@ -15,9 +15,9 @@
 class TestExtractionConfig:
     def test_defaults(self):
         c = ExtractionConfig()
-        assert c.branches is True
-        assert c.branch_text is True
-        assert c.summary is True
+        assert c.branches is False
+        assert c.branch_text is False
+        assert c.summary is False
         assert c.fractal_dimension is False
         assert c.vessel_radius is False
 
@@ -223,7 +223,7 @@ def test_save_creates_valid_json(self, tmp_path):
             raw = json.load(f)
 
         assert raw["schema_version"] == CONFIG_SCHEMA_VERSION
-        assert raw["extraction"]["branches"] is True
+        assert raw["extraction"]["branches"] is False
         assert raw["output"]["write_summary_csv"] is True
 
     def test_load_missing_file(self, tmp_path):

tests/test_napari_layers.py

@@ -37,53 +37,60 @@ def branch_data(self, graph):
     def features(self, skeleton, graph, branch_data):
         return _features_for(skeleton, graph, branch_data)
 
-    def test_default_config_returns_layers(
+    def test_with_config_returns_layers(
         self, skeleton, graph, branch_data, features
     ):
         layers = extract_skeleton_layers(
             skeleton,
             "test",
             graph,
             branch_data,
+            config=ExtractionConfig(branches=True, summary=True),
             features=features,
         )
         assert len(layers) > 0
-        assert all(isinstance(layer, tuple) and len(layer) == 3 for layer in layers)
+        for layer in layers:
+            assert isinstance(layer, tuple) and len(layer) == 3
+            assert isinstance(layer[1], dict)
+            assert isinstance(layer[2], str)
 
-    def test_default_config_includes_branch_layer(
+    def test_with_config_includes_branch_layer(
         self, skeleton, graph, branch_data, features
     ):
         layers = extract_skeleton_layers(
             skeleton,
             "test",
             graph,
             branch_data,
+            config=ExtractionConfig(branches=True, summary=True),
             features=features,
         )
         layer_types = [layer[2] for layer in layers]
         assert "shapes" in layer_types
 
-    def test_default_config_includes_summary_layer(
+    def test_with_config_includes_summary_layer(
         self, skeleton, graph, branch_data, features
     ):
         layers = extract_skeleton_layers(
             skeleton,
             "test",
             graph,
             branch_data,
+            config=ExtractionConfig(branches=True, summary=True),
             features=features,
         )
         layer_names = [layer[1].get("name", "") for layer in layers]
         assert any("_summary" in name for name in layer_names)
 
-    def test_default_config_includes_two_point_layers(
+    def test_with_config_includes_two_point_layers(
         self, skeleton, graph, branch_data, features
     ):
         layers = extract_skeleton_layers(
             skeleton,
             "test",
             graph,
             branch_data,
+            config=ExtractionConfig(branches=True, branch_text=True, summary=True),
             features=features,
         )
         layer_types = [layer[2] for layer in layers]
@@ -104,7 +111,7 @@ def test_branches_disabled(self, skeleton, graph, branch_data, features):
         assert "shapes" not in layer_types
 
     def test_branch_text_disabled(self, skeleton, graph, branch_data, features):
-        config = ExtractionConfig(branches=True, branch_text=False)
+        config = ExtractionConfig(branches=True, branch_text=False, summary=True)
         layers = extract_skeleton_layers(
             skeleton,
             "test",
@@ -118,7 +125,7 @@ def test_branch_text_disabled(self, skeleton, graph, branch_data, features):
         assert not any("branch_text" in name for name in layer_names)
 
     def test_summary_disabled(self, skeleton, graph, branch_data):
-        config = ExtractionConfig(summary=False)
+        config = ExtractionConfig(branches=True, branch_text=True, summary=False)
         layers = extract_skeleton_layers(
             skeleton,
             "test",
@@ -131,20 +138,6 @@ def test_summary_disabled(self, skeleton, graph, branch_data):
         layer_names = [layer[1].get("name", "") for layer in layers]
         assert not any("summary" in name for name in layer_names)
 
-    def test_summary_disabled_no_features_needed(self, skeleton, graph, branch_data):
-        config = ExtractionConfig(summary=False)
-        layers = extract_skeleton_layers(
-            skeleton,
-            "test",
-            graph,
-            branch_data,
-            config=config,
-            features=None,
-        )
-        assert len(layers) > 0
-        layer_names = [l[1].get("name", "") for l in layers]
-        assert not any("_summary" in name for name in layer_names)
-
     def test_with_features_passed(self, skeleton, graph, branch_data, features):
         config = ExtractionConfig(summary=True)
         layers = extract_skeleton_layers(
@@ -196,8 +189,10 @@ def test_layer_names_include_base_name(
             base_name,
             graph,
             branch_data,
+            config=ExtractionConfig(branches=True, summary=True),
             features=features,
         )
+        assert len(layers) > 0
         for layer in layers:
             assert base_name in layer[1].get("name", "")
 
@@ -207,6 +202,7 @@ def test_branch_layer_has_properties(self, skeleton, graph, branch_data, feature
             "test",
             graph,
             branch_data,
+            config=ExtractionConfig(branches=True, summary=True),
             features=features,
         )
         branch_layer = [l for l in layers if l[2] == "shapes"][0]
@@ -237,6 +233,7 @@ def test_empty_skeleton(self):
             "empty",
             graph,
             branch_data,
+            config=ExtractionConfig(summary=True),
             features=features,
         )
         summary = [l for l in layers if "_summary" in l[1].get("name", "")]
@@ -250,6 +247,7 @@ def test_branch_text_layer_has_text_config(
             "test",
             graph,
             branch_data,
+            config=ExtractionConfig(branches=True, branch_text=True, summary=True),
             features=features,
         )
         text_layers = [

tests/test_pipeline.py

@@ -52,60 +52,35 @@ def cross_image(self):
         return img
 
     @pytest.fixture
-    def default_config(self):
+    def analysis_config(self):
+        """Shared config with branches and summary enabled."""
         return PipelineConfig(
-            extraction=ExtractionConfig(),
+            extraction=ExtractionConfig(branches=True, summary=True),
             output=OutputConfig(),
         )
 
-    def test_empty_image_returns_empty_result(self, default_config):
+    def test_empty_image_returns_empty_result(self, analysis_config):
         img = np.zeros((32, 32), dtype=np.uint8)
-        result = analyze_binary_image(img, "test", default_config)
+        result = analyze_binary_image(img, "test", analysis_config)
         assert not result.skeleton.any()
         assert result.layers == []
         assert result.summary_features == {}
         assert result.branch_records == []
         assert result.radius_matrix is None
 
-    def test_all_zero_image_is_empty(self, default_config):
-        result = analyze_binary_image(np.zeros((8, 8)), "z", default_config)
-        assert not result.skeleton.any()
-
-    def test_cross_produces_skeleton(self, cross_image, default_config):
-        result = analyze_binary_image(cross_image, "cross", default_config)
+    def test_cross_produces_skeleton(self, cross_image, analysis_config):
+        result = analyze_binary_image(cross_image, "cross", analysis_config)
         assert result.skeleton.any()
         assert result.skeleton.dtype == np.uint8
         assert result.skeleton.shape == cross_image.shape
 
-    def test_non_binary_input_is_binarized(self, default_config):
+    def test_non_binary_input_is_binarized(self, analysis_config):
         img = np.zeros((20, 20), dtype=np.int32)
         img[10, 5:15] = 200
-        result = analyze_binary_image(img, "test", default_config)
+        result = analyze_binary_image(img, "test", analysis_config)
         assert result.skeleton.any()
         assert set(np.unique(result.skeleton)) <= {0, 1}
 
-    def test_layers_have_three_element_tuples(self, cross_image, default_config):
-        result = analyze_binary_image(cross_image, "test", default_config)
-        assert len(result.layers) > 0
-        for layer in result.layers:
-            assert len(layer) == 3
-            assert isinstance(layer[1], dict)
-            assert isinstance(layer[2], str)
-
-    def test_base_name_in_layer_metadata(self, cross_image, default_config):
-        result = analyze_binary_image(cross_image, "myimage", default_config)
-        found = False
-        for layer in result.layers:
-            if "name" in layer[1]:
-                found = True
-                break
-        assert found, "No layer has a 'name' key in metadata"
-
-    def test_summary_features_not_empty(self, cross_image, default_config):
-        result = analyze_binary_image(cross_image, "cross", default_config)
-        assert len(result.summary_features) > 0
-        assert "num_endpoints" in result.summary_features
-
     def test_summary_disabled_returns_empty_features(self, cross_image):
         config = PipelineConfig(
             extraction=ExtractionConfig(summary=False),
@@ -114,18 +89,8 @@ def test_summary_disabled_returns_empty_features(self, cross_image):
         result = analyze_binary_image(cross_image, "cross", config)
         assert result.summary_features == {}
 
-    def test_summary_disabled_in_pipeline_config(self):
-        img = np.zeros((16, 16), dtype=np.uint8)
-        img[8, 4:12] = 1
-        config = PipelineConfig(
-            extraction=ExtractionConfig(summary=False),
-            output=OutputConfig(),
-        )
-        result = analyze_binary_image(img, "line", config)
-        assert result.summary_features == {}
-
-    def test_branches_enabled_by_default(self, cross_image, default_config):
-        result = analyze_binary_image(cross_image, "cross", default_config)
+    def test_branches_enabled(self, cross_image, analysis_config):
+        result = analyze_binary_image(cross_image, "cross", analysis_config)
         assert len(result.branch_records) > 0
         assert isinstance(result.branch_records[0], dict)
 
@@ -139,7 +104,7 @@ def test_branches_disabled_returns_empty_records(self, cross_image):
 
     def test_vessel_radius_enabled(self, cross_image):
         config = PipelineConfig(
-            extraction=ExtractionConfig(vessel_radius=True),
+            extraction=ExtractionConfig(vessel_radius=True, summary=True),
             output=OutputConfig(),
         )
         result = analyze_binary_image(cross_image, "cross", config)
@@ -148,13 +113,13 @@ def test_vessel_radius_enabled(self, cross_image):
         assert result.radius_matrix.any()
         assert result.summary_features["mean_radius"] > 0
 
-    def test_vessel_radius_disabled_radius_none(self, cross_image, default_config):
-        result = analyze_binary_image(cross_image, "cross", default_config)
+    def test_vessel_radius_disabled_radius_none(self, cross_image, analysis_config):
+        result = analyze_binary_image(cross_image, "cross", analysis_config)
         assert result.radius_matrix is None
 
     def test_radius_stats_in_summary_when_enabled(self, cross_image):
         config = PipelineConfig(
-            extraction=ExtractionConfig(vessel_radius=True),
+            extraction=ExtractionConfig(vessel_radius=True, summary=True),
             output=OutputConfig(),
         )
         result = analyze_binary_image(cross_image, "cross", config)
@@ -172,13 +137,13 @@ def test_radius_stats_in_summary_when_enabled(self, cross_image):
             assert key in result.summary_features
             assert result.summary_features[key] > 0
 
-    def test_fractal_dimension_disabled_by_default(self, cross_image, default_config):
-        result = analyze_binary_image(cross_image, "cross", default_config)
+    def test_fractal_dimension_disabled_by_default(self, cross_image, analysis_config):
+        result = analyze_binary_image(cross_image, "cross", analysis_config)
         assert result.summary_features["fractal_dimension"] == 0.0
 
     def test_fractal_dimension_enabled(self, cross_image):
         config = PipelineConfig(
-            extraction=ExtractionConfig(fractal_dimension=True),
+            extraction=ExtractionConfig(fractal_dimension=True, summary=True),
             output=OutputConfig(),
         )
         result = analyze_binary_image(cross_image, "cross", config)
@@ -225,7 +190,9 @@ def test_3d_image(self):
         vol = np.zeros((16, 16, 16), dtype=np.uint8)
         vol[8, 8, :] = 1
         vol[8, :, 8] = 1
-        config = PipelineConfig(extraction=ExtractionConfig(), output=OutputConfig())
+        config = PipelineConfig(
+            extraction=ExtractionConfig(summary=True), output=OutputConfig()
+        )
         result = analyze_binary_image(vol, "vol", config)
         assert result.skeleton.any()
         assert len(result.summary_features) > 0
@@ -234,18 +201,20 @@ def test_3d_image_with_radius(self):
         vol = np.zeros((12, 12, 12), dtype=np.uint8)
         vol[6, 6, :] = 1
         config = PipelineConfig(
-            extraction=ExtractionConfig(vessel_radius=True, fractal_dimension=True),
+            extraction=ExtractionConfig(
+                vessel_radius=True, fractal_dimension=True, summary=True
+            ),
             output=OutputConfig(),
         )
         result = analyze_binary_image(vol, "vol3d", config)
         assert result.radius_matrix is not None
         assert result.radius_matrix.shape == vol.shape
         assert result.summary_features["mean_radius"] > 0
 
-    def test_cross_topology_num_endpoints(self, cross_image, default_config):
-        result = analyze_binary_image(cross_image, "cross", default_config)
+    def test_cross_topology_num_endpoints(self, cross_image, analysis_config):
+        result = analyze_binary_image(cross_image, "cross", analysis_config)
         assert result.summary_features["num_endpoints"] == 4
 
-    def test_cross_topology_num_bifurcations(self, cross_image, default_config):
-        result = analyze_binary_image(cross_image, "cross", default_config)
+    def test_cross_topology_num_bifurcations(self, cross_image, analysis_config):
+        result = analyze_binary_image(cross_image, "cross", analysis_config)
         assert result.summary_features["num_bifurcations"] == 1