Refactor tests (#115)

* Refactor tests

* Update tests/tests/test_integration/test_gui/test_tracks.py

Co-authored-by: Alessandro Felder <[email protected]>

* fix typo

---------

Co-authored-by: Alessandro Felder <[email protected]>

brainreg_segment/segmentation_panels/tracks.py

@@ -233,21 +233,21 @@ def add_track(self):
             self.point_size,
         )
 
-    def add_track_from_existing_layer(self, overrride=False):
+    def add_track_from_existing_layer(self, override=False):
         print("Adding track from existing layer\n")
         selected_layer = self.parent.viewer.layers.selection.active
         try:
             add_track_from_existing_layer(
                 selected_layer, self.parent.track_layers
             )
-            if not overrride:
+            if not override:
                 display_info(
                     self.parent,
                     "Layer added",
                     f"Added layer: {str(selected_layer)}.",
                 )
         except TypeError:
-            if not overrride:
+            if not override:
                 display_info(
                     self.parent,
                     "Unsupported layer type",

tests/conftest.py

@@ -1,3 +1,4 @@
+import shutil
 from pathlib import Path
 
 import pytest
@@ -24,3 +25,16 @@ def segmentation_widget(make_napari_viewer):
     widget = SegmentationWidget(viewer)
     viewer.window.add_dock_widget(widget)
     return widget
+
+
+@pytest.fixture
+def segmentation_widget_with_data_atlas_space(tmp_path, segmentation_widget):
+    tmp_input_dir = tmp_path / "brainreg_output"
+    shutil.copytree(brainreg_dir, tmp_input_dir)
+    segmentation_widget.standard_space = True
+    segmentation_widget.plugin = (
+        "brainglobe-napari-io.brainreg_read_dir_standard_space"
+    )
+    segmentation_widget.directory = Path(tmp_input_dir)
+    segmentation_widget.load_brainreg_directory()
+    return segmentation_widget

tests/tests/test_integration/test_gui/test_gui.py

@@ -1,9 +1,6 @@
-import shutil
-from filecmp import cmp
 from pathlib import Path
 
 import numpy as np
-import pandas as pd
 
 brainreg_dir = Path.cwd() / "tests" / "data" / "brainreg_output"
 
@@ -127,117 +124,3 @@ def check_paths(widget):
         widget.paths.tracks_directory
         == brainreg_dir / "manual_segmentation" / "standard_space" / "tracks"
     )
-
-
-def test_tracks(segmentation_widget, tmp_path, rtol=1e-10):
-    tmp_input_dir = tmp_path / "brainreg_output"
-    test_tracks_dir = (
-        tmp_input_dir / "manual_segmentation" / "standard_space" / "tracks"
-    )
-    validate_tracks_dir = (
-        brainreg_dir / "manual_segmentation" / "standard_space" / "tracks"
-    )
-    shutil.copytree(brainreg_dir, tmp_input_dir)
-    segmentation_widget.standard_space = True
-    segmentation_widget.plugin = (
-        "brainglobe-napari-io.brainreg_read_dir_standard_space"
-    )
-    segmentation_widget.directory = Path(tmp_input_dir)
-    segmentation_widget.load_brainreg_directory()
-
-    assert len(segmentation_widget.viewer.layers) == 4
-    assert len(segmentation_widget.track_layers) == 1
-    segmentation_widget.track_seg.add_track()
-    assert len(segmentation_widget.viewer.layers) == 5
-    assert len(segmentation_widget.track_layers) == 2
-    assert segmentation_widget.track_layers[0].name == "test_track"
-    assert segmentation_widget.track_layers[1].name == "track_1"
-    assert len(segmentation_widget.track_layers[0].data) == 6
-
-    # importing existing track
-    points = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3]])
-    test_layer = segmentation_widget.viewer.add_points(
-        points, name="test_track2"
-    )
-    segmentation_widget.viewer.layers.selection.select_only(test_layer)
-    segmentation_widget.track_seg.add_track_from_existing_layer(overrride=True)
-    assert len(segmentation_widget.viewer.layers) == 6
-    assert len(segmentation_widget.track_layers) == 3
-
-    # analysis
-    segmentation_widget.track_seg.run_track_analysis(override=True)
-    regions_validate = pd.read_csv(validate_tracks_dir / "test_track.csv")
-    regions_test = pd.read_csv(test_tracks_dir / "test_track.csv")
-    pd.testing.assert_frame_equal(regions_validate, regions_test)
-
-    # saving
-    segmentation_widget.save(override=True)
-    points_validate = pd.read_hdf(validate_tracks_dir / "test_track.points")
-    points_test = pd.read_hdf(test_tracks_dir / "test_track.points")
-    np.testing.assert_allclose(points_validate, points_test, rtol=rtol)
-
-    # export
-    segmentation_widget.export_to_brainrender(override=True)
-    spline_validate = pd.read_hdf(validate_tracks_dir / "test_track.h5")
-    spline_test = pd.read_hdf(test_tracks_dir / "test_track.h5")
-    pd.testing.assert_frame_equal(spline_test, spline_validate)
-
-    # surface points
-    segmentation_widget.track_seg.add_surface_points()
-    assert len(segmentation_widget.track_layers[0].data) == 7
-
-
-def test_regions(segmentation_widget, tmp_path, rtol=1e-10):
-    tmp_input_dir = tmp_path / "brainreg_output"
-    test_regions_dir = (
-        tmp_input_dir / "manual_segmentation" / "standard_space" / "regions"
-    )
-    validate_regions_dir = (
-        brainreg_dir / "manual_segmentation" / "standard_space" / "regions"
-    )
-    shutil.copytree(brainreg_dir, tmp_input_dir)
-    segmentation_widget.standard_space = True
-    segmentation_widget.plugin = (
-        "brainglobe-napari-io.brainreg_read_dir_standard_space"
-    )
-    segmentation_widget.directory = Path(tmp_input_dir)
-    segmentation_widget.load_brainreg_directory()
-
-    assert len(segmentation_widget.viewer.layers) == 4
-    assert len(segmentation_widget.label_layers) == 1
-    segmentation_widget.region_seg.add_new_region()
-    assert len(segmentation_widget.viewer.layers) == 5
-    assert len(segmentation_widget.label_layers) == 2
-    assert segmentation_widget.label_layers[0].name == "test_region"
-    assert segmentation_widget.label_layers[1].name == "region_1"
-
-    # importing existing region
-    test_layer = segmentation_widget.viewer.add_labels(
-        segmentation_widget.label_layers[0].data, name="test_region_2"
-    )
-    segmentation_widget.viewer.layers.selection.select_only(test_layer)
-    segmentation_widget.region_seg.add_region_from_existing_layer(
-        override=True
-    )
-    assert len(segmentation_widget.viewer.layers) == 6
-    assert len(segmentation_widget.label_layers) == 3
-
-    # analysis
-    segmentation_widget.region_seg.run_region_analysis(override=True)
-    region_csv_validate = pd.read_csv(validate_regions_dir / "test_region.csv")
-    region_csv_test = pd.read_csv(test_regions_dir / "test_region.csv")
-    pd.testing.assert_frame_equal(region_csv_test, region_csv_validate)
-
-    summary_csv_validate = pd.read_csv(validate_regions_dir / "summary.csv")
-    summary_csv_test = pd.read_csv(test_regions_dir / "summary.csv")
-    pd.testing.assert_frame_equal(summary_csv_test, summary_csv_validate)
-
-    # saving
-    segmentation_widget.save(override=True)
-
-    # export
-    segmentation_widget.export_to_brainrender(override=True)
-    cmp(
-        validate_regions_dir / "test_region.obj",
-        test_regions_dir / "test_region.obj",
-    )

tests/tests/test_integration/test_gui/test_regions.py

@@ -0,0 +1,90 @@
+from filecmp import cmp
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+brainreg_dir = Path.cwd() / "tests" / "data" / "brainreg_output"
+validate_regions_dir = (
+    brainreg_dir / "manual_segmentation" / "standard_space" / "regions"
+)
+
+
+@pytest.fixture
+def test_regions_dir(tmpdir):
+    tmp_input_dir = tmpdir / "brainreg_output"
+    test_regions_dir = (
+        tmp_input_dir / "manual_segmentation" / "standard_space" / "regions"
+    )
+    return test_regions_dir
+
+
+def test_region_widget_layer_numbers(
+    segmentation_widget_with_data_atlas_space, test_regions_dir
+):
+    assert len(segmentation_widget_with_data_atlas_space.viewer.layers) == 4
+    assert len(segmentation_widget_with_data_atlas_space.label_layers) == 1
+
+
+def test_add_new_region(
+    segmentation_widget_with_data_atlas_space, test_regions_dir
+):
+    segmentation_widget_with_data_atlas_space.region_seg.add_new_region()
+    assert len(segmentation_widget_with_data_atlas_space.viewer.layers) == 5
+    assert len(segmentation_widget_with_data_atlas_space.label_layers) == 2
+    assert (
+        segmentation_widget_with_data_atlas_space.label_layers[0].name
+        == "test_region"
+    )
+    assert (
+        segmentation_widget_with_data_atlas_space.label_layers[1].name
+        == "region_1"
+    )
+
+
+def test_add_existing_region(
+    segmentation_widget_with_data_atlas_space, test_regions_dir
+):
+    test_layer = segmentation_widget_with_data_atlas_space.viewer.add_labels(
+        segmentation_widget_with_data_atlas_space.label_layers[0].data,
+        name="test_region_2",
+    )
+    segmentation_widget_with_data_atlas_space.viewer.layers.selection.select_only(
+        test_layer
+    )
+    segmentation_widget_with_data_atlas_space.region_seg.add_region_from_existing_layer(
+        override=True
+    )
+    assert len(segmentation_widget_with_data_atlas_space.viewer.layers) == 5
+    assert len(segmentation_widget_with_data_atlas_space.label_layers) == 2
+
+
+def test_region_analysis(
+    segmentation_widget_with_data_atlas_space, test_regions_dir
+):
+    segmentation_widget_with_data_atlas_space.region_seg.run_region_analysis(
+        override=True
+    )
+    region_csv_validate = pd.read_csv(validate_regions_dir / "test_region.csv")
+    region_csv_test = pd.read_csv(test_regions_dir / "test_region.csv")
+    pd.testing.assert_frame_equal(region_csv_test, region_csv_validate)
+
+    summary_csv_validate = pd.read_csv(validate_regions_dir / "summary.csv")
+    summary_csv_test = pd.read_csv(test_regions_dir / "summary.csv")
+    pd.testing.assert_frame_equal(summary_csv_test, summary_csv_validate)
+
+
+def test_region_save(segmentation_widget_with_data_atlas_space):
+    segmentation_widget_with_data_atlas_space.save(override=True)
+
+
+def test_region_export(
+    segmentation_widget_with_data_atlas_space, test_regions_dir
+):
+    segmentation_widget_with_data_atlas_space.export_to_brainrender(
+        override=True
+    )
+    cmp(
+        validate_regions_dir / "test_region.obj",
+        test_regions_dir / "test_region.obj",
+    )

tests/tests/test_integration/test_gui/test_tracks.py

@@ -0,0 +1,103 @@
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pytest
+
+brainreg_dir = Path.cwd() / "tests" / "data" / "brainreg_output"
+validate_tracks_dir = (
+    brainreg_dir / "manual_segmentation" / "standard_space" / "tracks"
+)
+
+
+@pytest.fixture
+def test_tracks_dir(tmpdir):
+    tmp_input_dir = tmpdir / "brainreg_output"
+    test_tracks_dir = (
+        tmp_input_dir / "manual_segmentation" / "standard_space" / "tracks"
+    )
+    return test_tracks_dir
+
+
+def test_track_widget_layer_numbers(
+    segmentation_widget_with_data_atlas_space, test_tracks_dir
+):
+    assert len(segmentation_widget_with_data_atlas_space.viewer.layers) == 4
+    assert len(segmentation_widget_with_data_atlas_space.track_layers) == 1
+
+
+def test_add_new_track(
+    segmentation_widget_with_data_atlas_space, test_tracks_dir
+):
+    segmentation_widget_with_data_atlas_space.track_seg.add_track()
+    assert len(segmentation_widget_with_data_atlas_space.viewer.layers) == 5
+    assert len(segmentation_widget_with_data_atlas_space.track_layers) == 2
+    assert (
+        segmentation_widget_with_data_atlas_space.track_layers[0].name
+        == "test_track"
+    )
+    assert (
+        segmentation_widget_with_data_atlas_space.track_layers[1].name
+        == "track_1"
+    )
+    assert (
+        len(segmentation_widget_with_data_atlas_space.track_layers[0].data)
+        == 6
+    )
+
+
+def test_add_existing_track(
+    segmentation_widget_with_data_atlas_space, test_tracks_dir
+):
+    segmentation_widget = segmentation_widget_with_data_atlas_space
+
+    # importing existing track
+    points = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3]])
+    test_layer = segmentation_widget.viewer.add_points(
+        points, name="test_track2"
+    )
+    segmentation_widget.viewer.layers.selection.select_only(test_layer)
+    segmentation_widget.track_seg.add_track_from_existing_layer(override=True)
+    assert len(segmentation_widget.viewer.layers) == 5
+    assert len(segmentation_widget.track_layers) == 2
+
+
+def test_add_surface_point(
+    segmentation_widget_with_data_atlas_space, test_tracks_dir
+):
+    segmentation_widget_with_data_atlas_space.track_seg.add_surface_points()
+    assert (
+        len(segmentation_widget_with_data_atlas_space.track_layers[0].data)
+        == 7
+    )
+
+
+def test_track_analysis(
+    segmentation_widget_with_data_atlas_space, test_tracks_dir
+):
+    segmentation_widget_with_data_atlas_space.track_seg.run_track_analysis(
+        override=True
+    )
+    regions_validate = pd.read_csv(validate_tracks_dir / "test_track.csv")
+    regions_test = pd.read_csv(test_tracks_dir / "test_track.csv")
+    pd.testing.assert_frame_equal(regions_validate, regions_test)
+
+
+def test_track_save(
+    segmentation_widget_with_data_atlas_space, test_tracks_dir, rtol=1e-10
+):
+    segmentation_widget_with_data_atlas_space.save(override=True)
+    points_validate = pd.read_hdf(validate_tracks_dir / "test_track.points")
+    points_test = pd.read_hdf(test_tracks_dir / "test_track.points")
+    np.testing.assert_allclose(points_validate, points_test, rtol=rtol)
+
+
+def test_track_export(
+    segmentation_widget_with_data_atlas_space, test_tracks_dir
+):
+    segmentation_widget_with_data_atlas_space.export_to_brainrender(
+        override=True
+    )
+    spline_validate = pd.read_hdf(validate_tracks_dir / "test_track.h5")
+    spline_test = pd.read_hdf(test_tracks_dir / "test_track.h5")
+    pd.testing.assert_frame_equal(spline_test, spline_validate)