better tests

Author: lgrcia

test/test.py

@@ -3,20 +3,18 @@
 import matplotlib.pyplot as plt
 import shutil
 import unittest
-import os
 import shutil
-from os import path
 import shutil
 from pathlib import Path
-from prose import Telescope, blocks, load
+from prose import Telescope, blocks
 from prose.reports import Report, Summary
-from prose.utils import register
+from prose.utils import register_args
+from prose.tess import TFOPObservation
 
 
 RAW = Path("synthetic_dataset")
-REDUCED = "synthetic_dataset"
+REDUCED = "test/synthetic_dataset"
 PHOT = "/Users/lgrcia/data/test_data_prose/Io_2021-11-28_TOI-4508.01_g'.phot"
-OBS = Observation(PHOT)
 
 # Removing existing folders
 if RAW.exists():
@@ -31,10 +29,12 @@
 
 class TestReport(unittest.TestCase):
 
+    OBS = Observation(PHOT)
+
     def test_summary_report(self):
 
         # The summary template
-        summary = Summary(OBS)
+        summary = Summary(self.OBS)
 
         # The report
         report = Report([summary])
@@ -51,7 +51,7 @@ def test_fits_manager(self):
         fm = FitsManager(destination)
         result_file = TEST_FODLER / "test_fits_manager.txt"
         file = open(result_file, "w")
-        file.write(fm.print(repr=True))
+        file.write(fm.__repr__())
         file.close()
 
     def test_files(self):
@@ -62,12 +62,12 @@ def test_files(self):
         fm = FitsManager(destination)
         result_file = TEST_FODLER / "test_fm_files.txt"
         file = open(result_file, "w")
-        file.write("\n".join(fm.files(imtype="dark", exposure=8, exposure_tolerance=1)))
+        file.write("\n".join(fm.files(type="dark", exposure=8, tolerance=1, path=True).path.values))
         file.close()
 
 class TestReduction(unittest.TestCase):
 
-    def test_OLD_reduction(self):
+    def test_pipeline_reduction(self):
 
         # generate dataset
         import numpy as np
@@ -84,9 +84,9 @@ def test_OLD_reduction(self):
         })
 
         fm = FitsManager(RAW, depth=2)
-        destination = fm.obs_name
-        calib = Calibration(**fm.observation_files(0), overwrite=True)
-        calib.run(fm.images, TEST_FODLER / destination)
+        destination = fm.label(1)
+        calib = Calibration(**fm.observation_files(1), overwrite=True)
+        calib.run(fm.all_images, TEST_FODLER / destination)
 
         photometry = AperturePhotometry(
             files=calib.images,
@@ -95,7 +95,7 @@ def test_OLD_reduction(self):
         )
         photometry.run(calib.phot)
 
-        o = load(calib.phot)
+        o = Observation(calib.phot)
         o.target = 0
         o.broeg2005()
         o.plot()
@@ -108,7 +108,7 @@ def test_OLD_reduction(self):
 
         shutil.rmtree(RAW)
 
-    def test_OLD_empty_calibration(self):
+    def test_pipeline_empty_calibration(self):
 
         # generate dataset
         import numpy as np
@@ -125,143 +125,124 @@ def test_OLD_empty_calibration(self):
         })
 
         fm = FitsManager(RAW, depth=2)
-        destination = fm.obs_name
+        destination = fm.label(1)
         calib = Calibration(bias=[], darks=[], flats=[], overwrite=True)
-        calib.run(fm.images, TEST_FODLER / destination)
+        calib.run(fm.all_images, TEST_FODLER / destination)
+
+
+class TestTFOPObservation(unittest.TestCase):
+
+    OBS = TFOPObservation(PHOT)
+
+    def __init__(self, *args, **kwargs):
+        unittest.TestCase.__init__(self, *args, **kwargs)
+
+    def test_tess_ids(self):
+        result_file = TEST_FODLER / "tess-properties.txt"
+        file = open(result_file, "w")
+        assert self.OBS.tic_id == '170789802', "wrong tic id"
+        assert self.OBS.gaia_from_toi == "4877792060261482752", "Wrong gaia from TOI"
+        file.write(f"- TIC-id: {self.OBS.tic_id }\n")
+        file.write(f"- Gaia from TOI: {self.OBS.gaia_from_toi}\n")
+        file.write(f"- TOI-label: {self.OBS.tfop_prefix}\n")
+
+    def test_gaia_from_toi(self):
+        assert self.OBS.gaia_from_toi == "4877792060261482752", "Wrong gaia from TOI"
+
 
 class TestObservation(unittest.TestCase):
 
+    OBS = Observation(PHOT)
+
     def __init__(self, *args, **kwargs):
         unittest.TestCase.__init__(self, *args, **kwargs)
 
     def test_properties(self):
         result_file = TEST_FODLER / "properties.txt"
         file = open(result_file, "w")
-        file.write(f"- simbad: {OBS.simbad}\n")
-        file.write(f"- label: {OBS.label}\n")
-        file.write(f"- date: {OBS.date}\n")
-        file.write(f"- night_date: {OBS.night_date}\n")
-        file.write(f"- telescope_name: {OBS.stack.telescope.name}\n")
-        file.write(f"- xlabel: {OBS.xlabel}\n")
-
-    def test_tess_ids(self):
-        result_file = TEST_FODLER / "tess-properties.txt"
-        file = open(result_file, "w")
-        assert OBS.tic_id == '170789802', "wrong tic id"
-        assert OBS.gaia_from_toi == "4877792060261482752", "Wrong gaia from TOI"
-        file.write(f"- TIC-id: {OBS.tic_id }\n")
-        file.write(f"- Gaia from TOI: {OBS.gaia_from_toi}\n")
-        file.write(f"- TOI-label: {OBS.tfop_prefix}\n")
+        file.write(f"- simbad: {self.OBS.simbad}\n")
+        file.write(f"- label: {self.OBS.label}\n")
+        file.write(f"- date: {self.OBS.date}\n")
+        file.write(f"- night_date: {self.OBS.night_date}\n")
+        file.write(f"- telescope_name: {self.OBS.stack.telescope.name}\n")
+        file.write(f"- xlabel: {self.OBS.xlabel}\n")
 
     def test_set_gaia_target(self):
         result_file = TEST_FODLER / "test_set_gaia_target.png"
         gaia = "Gaia DR2 4877792060261482752"
-        OBS.set_catalog_target("gaia", gaia)
-        OBS.target = 18
-        OBS.stack.show_cutout(OBS.target)
-        OBS.stack.plot_catalog('gaia', label=True)
+        self.OBS.set_catalog_target("gaia", gaia)
+        self.OBS.stack.show_cutout(self.OBS.target)
+        self.OBS.stack.plot_catalog('gaia', label=True)
         plt.title(f"expected {gaia}")
         plt.savefig(result_file)
         plt.close()
 
     def test_diff(self):
         result_file = TEST_FODLER / "test_diff.png"
-        OBS.target = 18
-        OBS.broeg2005()
-        OBS.plot()
+        self.OBS.target = 18
+        self.OBS.broeg2005()
+        self.OBS.plot()
         plt.savefig(result_file)
         plt.close()
 
     def test_plot(self):
         result_file = TEST_FODLER / "test_plot.png"
-        OBS.plot()
+        self.OBS.plot()
         plt.savefig(result_file)
         plt.close()
 
     def test_plot_systeamtics(self):
         result_file = TEST_FODLER / "test_systematics.png"
-        OBS.plot_systematics()
+        self.OBS.plot_systematics()
         plt.savefig(result_file)
         plt.close()
 
     def test_plot_comps_lcs(self):
         result_file = TEST_FODLER / "test_plot_comps_lcs.png"
-        OBS.plot_comps_lcs()
+        self.OBS.plot_comps_lcs()
         plt.savefig(result_file)
         plt.close()
 
     def test_show_stars(self):
         result_file = TEST_FODLER / "test_show_stars.png"
-        OBS.show_stars()
+        self.OBS.show_stars()
         plt.savefig(result_file)
         plt.close()
 
     def test_plot_psf_model(self):
         result_file = TEST_FODLER / "test_plot_psf_model_target.png"
-        OBS.plot_psf_model()
+        self.OBS.plot_psf_model()
         plt.savefig(result_file)
         plt.close()
         result_file = TEST_FODLER / "test_plot_psf_model_other_star.png"
-        OBS.plot_psf_model(star=110, model=blocks.Moffat2D)
+        self.OBS.plot_psf_model(star=110, model=blocks.Moffat2D)
         plt.savefig(result_file)
         plt.close()
 
     def test_noise_stats(self):
         result_file = TEST_FODLER / "noise_stats.txt"
         file = open(result_file, "w")
-        noise = OBS.noise_stats(verbose=False)
+        noise = self.OBS.noise_stats(verbose=False)
         file.write(f"white (pont2006)\t{noise['pont_white']:.3e}\n"
                    f"red (pont2006)\t{noise['pont_red']:.3e}\n"
                    f"white (binned)\t\t{noise['binned_white']:.3e}\n")
 
-    def test_gaia_from_toi(self):
-        assert OBS.gaia_from_toi == "4877792060261482752", "Wrong gaia from TOI"
-
     def test_plate_solve(self):
         result_file = TEST_FODLER / "test_plate_solve.png"
-        OBS.plate_solve()
-        OBS.query_catalog('gaia')
-        gaias = OBS.stack.catalogs["gaia"][["x", "y"]].values
-        OBS.stack.show(frame=True)
+        self.OBS.plate_solve()
+        self.OBS.query_catalog('gaia')
+        gaias = self.OBS.stack.catalogs["gaia"][["x", "y"]].values
+        self.OBS.stack.show(frame=True)
         viz.plot_marks(*gaias.T, color="y")
         plt.savefig(result_file)
         plt.close()
 
+
+class TestArgsRegistration(unittest.TestCase):
+
+    def __init__(self, *args, **kwargs):
+        unittest.TestCase.__init__(self, *args, **kwargs)
+
+
 if __name__ == "__main__":
-    unittest.main()
-
-    class Test:
-        def __init__(self, a, b):
-            register(locals())
-            self.a = a
-
-    t = Test(2, 3)
-    print("{'a': 2, 'b': 3} {}")
-    print(t.args, t.kwargs, "\n")
-
-    class Test:
-        def __init__(self, a, b=4):
-            register(locals())
-            self.a = a
-            
-    t = Test(2, 3)
-    print("{'a': 2} {'b': 3}")
-    print(t.args, t.kwargs, "\n")
-
-    class Test:
-        def __init__(self, a, *args):
-            register(locals())
-            self.a = a
-            
-    t = Test(2, 5)
-    print("{'a': 2, '0': 5} {}")
-    print(t.args, t.kwargs, "\n")
-
-    class Test:
-        def __init__(self, a, **kwargs):
-            register(locals())
-            self.a = a
-            
-    t = Test(2, g=5)
-    print("{'a': 2} {'g': 5}")
-    print(t.args, t.kwargs, "\n")
+    unittest.main()