Improving psf_pytest.py #26 (#28)

The `test_psf.py` parametrised and decorated.

.travis.yml

@@ -88,8 +88,8 @@ matrix:
                EVENT_TYPE='pull_request push cron'
         #- os: linux
         #  env: PYTHON_VERSION=2.7 ASTROPY_VERSION=lts
-        - os: linux
-          env: ASTROPY_VERSION=lts
+        # - os: linux
+        #   env: ASTROPY_VERSION=lts
 
         # Try all python versions and Numpy versions. Since we can assume that
         # the Numpy developers have taken care of testing Numpy with different

gunagala/tests/test_psf.py

@@ -32,14 +32,14 @@ def test_base():
         psf_base = PSF(FWHM=1 / 30 * u.arcminute)
 
 
-def test_moffat(psf_moffat):
-    assert isinstance(psf_moffat, MoffatPSF)
-    assert isinstance(psf_moffat, PSF)
-
-
-def test_pix(psf_pixellated):
-    assert isinstance(psf_pixellated, PixellatedPSF)
-    assert isinstance(psf_pixellated, PSF)
+@pytest.mark.parametrize("psf, type", [
+    (psf_moffat(), MoffatPSF),
+    (psf_pixellated(), PixellatedPSF)],
+    ids=["moffat", "pixellated"]
+)
+def test_instance(psf, type):
+    assert isinstance(psf, type)
+    assert isinstance(psf, PSF)
 
 
 def test_FWHM(psf_moffat):
@@ -51,51 +51,35 @@ def test_FWHM(psf_moffat):
     psf_moffat.FWHM = 2 * u.arcsecond
 
 
-def test_pixel_scale(psf_moffat):
-    psf_moffat.pixel_scale = 2.85 * u.arcsecond / u.pixel
-    assert psf_moffat.pixel_scale == 2.85 * u.arcsecond / u.pixel
-
-
-def test_pixel_scale_pix(psf_pixellated):
-    psf_pixellated.pixel_scale = (1 / 3) * u.arcsecond / u.pixel
-    assert psf_pixellated.pixel_scale == (1 / 3) * u.arcsecond / u.pixel
-    psf_pixellated.pixel_scale = (2 / 3) * u.arcsecond / u.pixel
-
-
-# @pytest.mark.parametrize("psf, expected_n_pix", [
-#     (psf_moffat(), 4.25754067000986),
-#     (psf_pixellated(), 21.06994544)],
-#     ids=["moffat", "pixellated"]
-# )
-# def test_n_pix(psf, expected_n_pix):
-#     print(psf, psf.n_pix)
-#     assert psf.n_pix / u.pixel == pytest.approx(expected_n_pix)
-
-
-def test_n_pix(psf_moffat):
-    assert psf_moffat.n_pix == 4.25754067000986 * u.pixel
-
-
-def test_n_pix_pix(psf_pixellated):
-    assert psf_pixellated.n_pix / u.pixel == pytest.approx(21.069945447)
-
-
-# @pytest.mark.parametrize("psf, expected_peak", [
-#     (psf_moffat(), 0.7134084656751443),
-#     (psf_pixellated(), 0.08073066)],
-#     ids=["moffat", "pixellated"]
-# )
-# def test_n_pix(psf, expected_peak):
-#     print(psf, psf.peak)
-#     assert psf.peak * u.pixel == pytest.approx(expected_peak)
+@pytest.mark.parametrize("psf, t_pixel_scale, pixel_scale", [
+    (psf_moffat(), 2.85, 2.85),
+    (psf_pixellated(), (1 / 3), (2 / 3))],
+    ids=["moffat", "pixellated"]
+)
+def test_pixel_scale(psf, t_pixel_scale, pixel_scale):
+    psf.pixel_scale = t_pixel_scale * u.arcsecond / u.pixel
+    assert psf.pixel_scale == t_pixel_scale * u.arcsecond / u.pixel
+    psf.pixel_scale = pixel_scale * u.arcsecond / u.pixel
 
 
-def test_peak(psf_moffat):
-    assert psf_moffat.peak == 0.7134084656751443 / u.pixel
+@pytest.mark.parametrize("psf, expected_n_pix, pixel_scale", [
+    (psf_moffat(), 4.25754067000986, 2.85),
+    (psf_pixellated(), 21.06994544, (2 / 3))],
+    ids=["moffat", "pixellated"]
+)
+def test_n_pix(psf, expected_n_pix, pixel_scale):
+    psf.pixel_scale = pixel_scale * u.arcsecond / u.pixel
+    assert psf.n_pix.to(u.pixel).value == pytest.approx(expected_n_pix)
 
 
-def test_peak_pix(psf_pixellated):
-    assert psf_pixellated.peak * u.pixel == pytest.approx(0.08073066)
+@pytest.mark.parametrize("psf, expected_peak, pixel_scale", [
+    (psf_moffat(), 0.7134084656751443, 2.85),
+    (psf_pixellated(), 0.08073066, (2 / 3))],
+    ids=["moffat", "pixellated"]
+)
+def test_peak(psf, expected_peak, pixel_scale):
+    psf.pixel_scale = pixel_scale * u.arcsecond / u.pixel
+    assert psf.peak.to(1 / (u.pixel)).value == pytest.approx(expected_peak)
 
 
 def test_shape(psf_moffat):
@@ -109,36 +93,39 @@ def test_shape(psf_moffat):
 
 @pytest.mark.parametrize("psf, image_size", [
     (psf_moffat(), (21, 21)),
-    (psf_pixellated(), (21, 21))],
-    ids=["moffat", "pixellated"]
-)
-def test_pixellated_square(psf, image_size):
-    assert isinstance(psf.pixellated(), np.ndarray)
-    assert psf.pixellated().shape == image_size
-    assert (psf.pixellated() >= 0).all()
-    assert np.isfinite(psf.pixellated()).all()
-
-
-@pytest.mark.parametrize("psf, image_size", [
+    (psf_pixellated(), (21, 21)),
     (psf_moffat(), (7, 9)),
     (psf_pixellated(), (7, 9))],
-    ids=["moffat", "pixellated"]
+    ids=["moffat_square",
+         "pixellated_square",
+         "moffat_rectangle",
+         "pixellated_rectangle"]
 )
-def test_pixellated_rectangle(psf, image_size):
-    assert isinstance(psf.pixellated(size=(7.2, 9.2)), np.ndarray)
-    assert psf.pixellated(size=(7.2, 9.2)).shape == image_size
-    assert (psf.pixellated(size=(7.2, 9.2)) >= 0).all()
-    assert np.isfinite(psf.pixellated(size=(7.2, 9.2))).all()
-
-
-@pytest.mark.parametrize("psf, image_size", [
-    (psf_moffat(), (21, 21)),
-    (psf_pixellated(), (21, 21))],
-    ids=["moffat", "pixellated"]
-)
-def test_pixellated_offsets(psf, image_size):
+def test_pixellated_dimension(psf, image_size):
     assert isinstance(psf.pixellated(), np.ndarray)
-    assert psf.pixellated().shape == image_size
+    assert isinstance(psf.pixellated(size=(
+        image_size[0] + 0.2, image_size[1] + 0.2)), np.ndarray)
+    assert psf.pixellated(size=(
+        image_size[0] + 0.2, image_size[1] + 0.2)).shape == image_size
+    assert (psf.pixellated(size=(
+        image_size[0] + 0.2, image_size[1] + 0.2)) >= 0).all()
+    assert np.isfinite(psf.pixellated(size=(
+        image_size[0] + 0.2, image_size[1] + 0.2))).all()
+
+
+@pytest.mark.parametrize("psf, offset", [
+    (psf_moffat(), (0.0, 0.0)),
+    (psf_pixellated(), (0.0, 0.0)),
+    (psf_moffat(), (0.3, -0.7)),
+    (psf_pixellated(), (0.3, -0.7))],
+    ids=["moffat_centre_offsets",
+         "pixellated_centre_offsets",
+         "moffat_noncentre_offsets",
+         "pixellated_noncentre_offsets"]
+)
+def test_offsets(psf, offset):
+    assert isinstance(psf.pixellated(offsets=offset), np.ndarray)
+    assert psf.pixellated().shape == (21, 21)
     assert (psf.pixellated() >= 0).all()
     assert np.isfinite(psf.pixellated()).all()
 
@@ -148,6 +135,6 @@ def test_pixellated_offsets(psf, image_size):
     (psf_pixellated(), (-1.3, 1.3))],
     ids=["moffat", "pixellated"]
 )
-def test_pixellated(psf, test_size):
+def test_pixellated_invalid_size(psf, test_size):
     with pytest.raises(ValueError):
         psf.pixellated(size=test_size)