Add tests for bugs found

Author: samaloney

ndcube/extra_coords/tests/test_extra_coords.py

@@ -560,3 +560,21 @@ def test_length1_extra_coord(wave_lut):
     sec = ec[item]
     assert (sec.wcs.pixel_to_world(0) == wave_lut[item]).all()
     assert (sec.wcs.world_to_pixel(wave_lut[item])[0] == [0]).all()
+
+
+def test_str_with_unnamed_table_coordinate(wave_lut):
+    # Regression test: ExtraCoords.__str__ used to do ', '.join(table.names),
+    # which crashes with TypeError if `names` is None. This happens whenever a
+    # BaseTableCoordinate instance is passed directly to `.add()`, since `add`
+    # only sets names via its own `name` argument when it constructs the
+    # coordinate itself, not when an already-built coordinate is passed in.
+    from ndcube.extra_coords.table_coord import QuantityTableCoordinate  # NOQA
+
+    ec = ExtraCoords()
+    coord = QuantityTableCoordinate(wave_lut)
+    assert coord.names is None
+    ec.add("wave", 0, coord)
+
+    # Should not raise.
+    str(ec)
+    repr(ec)

ndcube/tests/test_ndcollection.py

@@ -112,13 +112,45 @@ def test_collection_pop(collection, popped_key, expected_popped, expected_collec
 
 @pytest.mark.parametrize(('collection', 'key', 'expected'), [
     (cube_collection, "cube0", NDCollection([("cube1", cube1), ("cube2", cube2)],
-                                            aligned_axes=aligned_axes[1:]))])
+                                            aligned_axes=aligned_axes[1:])),
+    # Regression test: __delitem__ used to call self.aligned_axes.__delitem__(key)
+    # unconditionally, crashing with AttributeError on a collection with no
+    # aligned axes since self.aligned_axes is None in that case.
+    (unaligned_collection, "cube0", NDCollection([("cube1", cube1), ("cube2", cube2)]))])
 def test_del_collection(collection, key, expected):
     del_collection = collection.copy()
     del del_collection[key]
     helpers.assert_collections_equal(del_collection, expected)
 
 
+def test_slice_by_keys_unaligned_collection():
+    # Regression test: slicing by a sequence of string keys used to crash with
+    # TypeError ("'NoneType' object is not subscriptable") on a collection with
+    # aligned_axes=None, because `self.aligned_axes[item_]` was called
+    # unconditionally instead of being guarded by an is-None check.
+    result = unaligned_collection[("cube0", "cube1")]
+    assert list(result.keys()) == ["cube0", "cube1"]
+    assert result.aligned_axes is None
+
+
+def test_collection_getitem_unsupported_type():
+    # Regression test: the "unsupported slicing type" error message referenced
+    # `axis_item`, a loop variable only bound inside the tuple-handling branch,
+    # so hitting this branch raised NameError instead of the intended TypeError.
+    with pytest.raises(TypeError, match="Unsupported slicing type"):
+        cube_collection[1.5]
+
+
+def test_collection_slice_open_start_negative_stop_with_sliceable_meta():
+    # Regression test: sanitizing a slice item with sliceable meta compared
+    # `item.start < 0` even when `item.start` is None (i.e. an open-ended
+    # slice like `slice(None, -1)`), crashing with
+    # "'<' not supported between instances of 'NoneType' and 'int'".
+    result = cube_collection[slice(None, -1)]
+    expected = cube_collection[slice(0, cube_collection.aligned_dimensions[0] - 1)]
+    helpers.assert_collections_equal(result, expected)
+
+
 @pytest.mark.parametrize(('collection', 'key', 'data', 'aligned_axes', 'expected'), [
     (cube_collection, "cube1", cube2, aligned_axes[2], NDCollection(
         [("cube0", cube0), ("cube1", cube2), ("cube2", cube2)],

ndcube/tests/test_ndcube_slice_and_crop.py

@@ -423,6 +423,17 @@ def test_crop_by_values_1d_dependent(ndcube_4d_ln_lt_l_t):
     helpers.assert_cubes_equal(output, expected)
 
 
+def test_crop_no_points_with_extra_coords_wcs(ndcube_3d_ln_lt_l_ec_time):
+    # Regression test: cropping with zero points is a no-op, but
+    # sanitize_crop_inputs used to return the *un-unwrapped* ExtraCoords
+    # object on that early-exit path, so `wcs.pixel_n_dim` crashed with
+    # AttributeError since ExtraCoords has no such attribute (only
+    # `ExtraCoords.wcs.pixel_n_dim` does).
+    cube = ndcube_3d_ln_lt_l_ec_time
+    output = cube.crop(wcs=cube.extra_coords)
+    helpers.assert_cubes_equal(output, cube)
+
+
 def test_crop_by_extra_coords(ndcube_3d_ln_lt_l_ec_time):
     cube = ndcube_3d_ln_lt_l_ec_time
     lower_corner = (Time("2000-01-01T15:00:00", scale="utc", format="fits"), None)

ndcube/utils/tests/test_utils_cube.py

@@ -4,7 +4,7 @@
 
 from astropy.nddata import StdDevUncertainty
 
-from ndcube.utils.cube import propagate_rebin_uncertainties
+from ndcube.utils.cube import propagate_rebin_uncertainties, sanitize_crop_inputs
 
 
 @pytest.fixture
@@ -99,3 +99,18 @@ def test_propagate_rebin_uncertainties_nan(stacked_pixel_data):
                                            np.nanmean, operation_ignores_mask=False)
     assert type(output) is type(expected)
     assert np.allclose(output.array, expected.array)
+
+
+def test_sanitize_crop_inputs_no_op_unwraps_extra_coords(ndcube_3d_ln_lt_l_ec_time):
+    # Regression test: on the no-op (all-points-None, including zero points)
+    # early-exit path, sanitize_crop_inputs used to return the wcs argument
+    # completely unprocessed, so if it was passed an ExtraCoords object it
+    # would still be an ExtraCoords object rather than being unwrapped to a
+    # low-level WCS like on the normal path. Callers (e.g. NDCube._get_crop_item)
+    # immediately use low-level WCS attributes like `.pixel_n_dim` on the
+    # returned value, which ExtraCoords does not have.
+    cube = ndcube_3d_ln_lt_l_ec_time
+    no_op, points, wcs = sanitize_crop_inputs((), cube.extra_coords)
+    assert no_op is True
+    assert points == []
+    assert hasattr(wcs, "pixel_n_dim")

ndcube/wcs/wrappers/tests/test_compound_wcs.py

@@ -184,3 +184,33 @@ def test_shared_pixel_axis_compound_3d(spectral_cube_3d_fitswcs, time_1d_fitswcs
 
     with pytest.raises(ValueError):
         wcs.world_to_pixel_values((14, -10, -2.6e+10, -7.0))
+
+
+class _NamedPixelAxisWCS:
+    """
+    A minimal low-level WCS stub with a non-empty ``pixel_axis_names``.
+
+    FITS WCS objects always report empty-string pixel axis names, so they
+    can't be used to exercise the case where two WCSes sharing a pixel axis
+    (via ``mapping``) disagree on that axis's name.
+    """
+
+    def __init__(self, pixel_n_dim, pixel_axis_names):
+        self.pixel_n_dim = pixel_n_dim
+        self.array_shape = None
+        self.pixel_bounds = None
+        self.pixel_axis_names = pixel_axis_names
+
+
+def test_pixel_axis_names_shared_axis_different_names():
+    # Regression test: CompoundLowLevelWCS.pixel_axis_names used to build
+    # out_names via `list(self.mapping.inverse(*pixel_names))` and then try to
+    # mutate the *tuple* returned by `Mapping.__call__` in place, raising
+    # "'tuple' object does not support item assignment" whenever a shared
+    # pixel axis had different names in the contributing WCSes.
+    wcs_a = _NamedPixelAxisWCS(1, ('a',))
+    wcs_b = _NamedPixelAxisWCS(1, ('b',))
+
+    compound = CompoundLowLevelWCS(wcs_a, wcs_b, mapping=(0, 0))
+
+    assert compound.pixel_axis_names == ('a / b',)

pytest.ini

@@ -60,3 +60,7 @@ filterwarnings =
     ignore:FigureCanvasAgg is non-interactive, and thus cannot be shown:UserWarning
     # wcsaxes/formatter_locator.py hates angles
     ignore:.*invalid value encountered in do_format.*:RuntimeWarning
+    # asdf warning
+    ignore:.*:asdf.exceptions.AsdfWarning
+    # astropy
+    ignore:.*:astropy.utils.exceptions.AstropyPendingDeprecationWarning