rubin-sim 2.6.1.dev2__py3-none-any.whl

tests/maf/test_onedslicer.py

@@ -0,0 +1,245 @@
+import unittest
+import warnings
+
+import numpy as np
+
+from rubin_sim.maf.slicers import OneDSlicer, UniSlicer
+
+
+def make_data_values(size=100, min_val=0.0, max_val=1.0, random=-1):
+    """Generate a simple array of numbers, evenly arranged between min/max,
+    but (optional) random order."""
+    datavalues = np.arange(0, size, dtype="float")
+    datavalues *= (float(max_val) - float(min_val)) / (datavalues.max() - datavalues.min())
+    datavalues += min_val
+    if random > 0:
+        rng = np.random.RandomState(random)
+        randorder = rng.rand(size)
+        randind = np.argsort(randorder)
+        datavalues = datavalues[randind]
+    datavalues = np.array(list(zip(datavalues)), dtype=[("testdata", "float")])
+    return datavalues
+
+
+class TestOneDSlicerSetup(unittest.TestCase):
+    def setUp(self):
+        self.testslicer = OneDSlicer(slice_col_name="testdata")
+
+    def tearDown(self):
+        del self.testslicer
+        self.testslicer = None
+
+    def test_slicertype(self):
+        """Test instantiation of slicer sets slicer type as expected."""
+        self.assertEqual(self.testslicer.slicer_name, self.testslicer.__class__.__name__)
+        self.assertEqual(self.testslicer.slicer_name, "OneDSlicer")
+
+    def test_setup_slicer_bins(self):
+        """Test setting up slicer using defined bins."""
+        dvmin = 0
+        dvmax = 1
+        nvalues = 1000
+        bins = np.arange(dvmin, dvmax + 0.05, 0.1)
+        dv = make_data_values(nvalues, dvmin, dvmax, random=4)
+        # Used right bins?
+        self.testslicer = OneDSlicer(slice_col_name="testdata", bins=bins)
+        self.testslicer.setup_slicer(dv)
+        np.testing.assert_equal(self.testslicer.bins, bins)
+        self.assertEqual(self.testslicer.nslice, len(bins) - 1)
+
+    def test_setup_slicer_nbins_zeros(self):
+        """Test what happens if give slicer test data that is all
+        single-value."""
+        dv = np.zeros(100, float)
+        dv = np.array(list(zip(dv)), dtype=[("testdata", "float")])
+        bin_size = 0.1
+        self.testslicer = OneDSlicer(slice_col_name="testdata", bin_size=bin_size)
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            self.testslicer.setup_slicer(dv)
+            self.assertIn("creasing bin_max", str(w[-1].message))
+        self.assertEqual(self.testslicer.nslice, 2)
+
+    def test_setup_slicer_limits(self):
+        """Test setting up slicer using bin_min/max."""
+        bin_min = 0
+        bin_max = 1
+        dvmin = -0.5
+        dvmax = 1.5
+        dv = make_data_values(1000, dvmin, dvmax, random=342)
+        self.testslicer = OneDSlicer(slice_col_name="testdata", bin_min=bin_min, bin_max=bin_max)
+        self.testslicer.setup_slicer(dv)
+        self.assertAlmostEqual(self.testslicer.bins.min(), bin_min)
+        self.assertAlmostEqual(self.testslicer.bins.max(), bin_max)
+
+    def test_setup_slicer_binsize(self):
+        """Test setting up slicer using bin_size."""
+        dvmin = 0
+        dvmax = 1
+        dv = make_data_values(1000, dvmin, dvmax, random=8977)
+        # Test basic use.
+        bin_size = 0.5
+        self.testslicer = OneDSlicer(slice_col_name="testdata", bin_size=bin_size)
+        self.testslicer.setup_slicer(dv)
+        self.assertEqual(self.testslicer.nslice, (dvmax - dvmin) / bin_size)
+
+    def test_setup_slicer_freedman(self):
+        """Test that setting up the slicer using bins=None works."""
+        dvmin = 0
+        dvmax = 1
+        dv = make_data_values(1000, dvmin, dvmax, random=2234)
+        self.testslicer = OneDSlicer(slice_col_name="testdata", bins=None)
+        self.testslicer.setup_slicer(dv)
+        # How many bins do you expect from optimal bin_size?
+        from rubin_sim.maf.utils import optimal_bins
+
+        bins = optimal_bins(dv["testdata"])
+        np.testing.assert_equal(self.testslicer.nslice, bins)
+
+
+class TestOneDSlicerIteration(unittest.TestCase):
+    def setUp(self):
+        self.testslicer = OneDSlicer(slice_col_name="testdata")
+        dvmin = 0
+        dvmax = 1
+        nvalues = 1000
+        self.bins = np.arange(dvmin, dvmax, 0.01)
+        dv = make_data_values(nvalues, dvmin, dvmax, random=5678)
+        self.testslicer = OneDSlicer(slice_col_name="testdata", bins=self.bins)
+        self.testslicer.setup_slicer(dv)
+
+    def tearDown(self):
+        del self.testslicer
+        self.testslicer = None
+
+    def test_iteration(self):
+        """Test iteration."""
+        for i, s in enumerate(self.testslicer):
+            self.assertEqual(s["slice_point"]["sid"], i)
+            self.assertEqual(s["slice_point"]["bin_left"], self.bins[i])
+            self.assertEqual(s["slice_point"]["bin_right"], self.bins[i + 1])
+        # Iteration stops while i<= nslice ..
+        # nslice = len(bins)-1 (and bins[i+2] is out of range
+        # but bins[i+1] is last RH edge of bins
+        self.assertEqual(i, self.testslicer.nslice - 1)
+
+    def test_get_item(self):
+        """Test that can return an individual indexed values of the slicer."""
+        for i in [0, 10, 20]:
+            self.assertEqual(self.testslicer[i]["slice_point"]["sid"], i)
+            self.assertEqual(self.testslicer[i]["slice_point"]["bin_left"], self.bins[i])
+
+
+class TestOneDSlicerEqual(unittest.TestCase):
+    def setUp(self):
+        self.testslicer = OneDSlicer(slice_col_name="testdata")
+
+    def tearDown(self):
+        del self.testslicer
+        self.testslicer = None
+
+    def test_equivalence(self):
+        """Test equals method."""
+        # Note that two OneD slicers will be considered equal if
+        # they are both the same kind of slicer AND have the same bins.
+        # Set up self..
+        dvmin = 0
+        dvmax = 1
+        nvalues = 1000
+        bins = np.arange(dvmin, dvmax, 0.01)
+        dv = make_data_values(nvalues, dvmin, dvmax, random=32499)
+        # Set up reference
+        self.testslicer = OneDSlicer(slice_col_name="testdata", bins=bins)
+        self.testslicer.setup_slicer(dv)
+        # Set up another slicer to match
+        # (same bins, although not the same data).
+        dv2 = make_data_values(nvalues + 100, dvmin, dvmax, random=334)
+        testslicer2 = OneDSlicer(slice_col_name="testdata", bins=bins)
+        testslicer2.setup_slicer(dv2)
+        self.assertTrue(self.testslicer == testslicer2)
+        self.assertFalse(self.testslicer != testslicer2)
+        # Set up another slicer that should not match
+        # (different bins, based on data)
+        dv2 = make_data_values(nvalues, dvmin + 1, dvmax + 1, random=445)
+        testslicer2 = OneDSlicer(slice_col_name="testdata", bins=None)
+        testslicer2.setup_slicer(dv2)
+        self.assertTrue(self.testslicer != testslicer2)
+        self.assertFalse(self.testslicer == testslicer2)
+        # Set up a different kind of slicer that should not match.
+        dv2 = make_data_values(100, 0, 1, random=12)
+        testslicer2 = UniSlicer()
+        testslicer2.setup_slicer(dv2)
+        self.assertTrue(self.testslicer != testslicer2)
+        self.assertFalse(self.testslicer == testslicer2)
+        # Get another oneDslicer that is not set up, and check equivalence.
+        testslicer2 = OneDSlicer(slice_col_name="testdata")
+        self.assertTrue(self.testslicer != testslicer2)
+        self.assertFalse(self.testslicer == testslicer2)
+        testslicer2 = OneDSlicer(slice_col_name="testdata", bin_min=0, bin_max=1, bin_size=0.5)
+        testslicer3 = OneDSlicer(slice_col_name="testdata", bin_min=0, bin_max=1, bin_size=0.5)
+        self.assertTrue(testslicer2 == testslicer3)
+        self.assertFalse(testslicer2 != testslicer3)
+        testslicer3 = OneDSlicer(slice_col_name="testdata", bin_min=0, bin_max=1)
+        self.assertFalse(testslicer2 == testslicer3)
+        self.assertTrue(testslicer2 != testslicer3)
+        usebins = np.arange(0, 1, 0.1)
+        testslicer2 = OneDSlicer(slice_col_name="testdata", bins=usebins)
+        testslicer3 = OneDSlicer(slice_col_name="testdata", bins=usebins)
+        self.assertTrue(testslicer2 == testslicer3)
+        self.assertFalse(testslicer2 != testslicer3)
+        testslicer3 = OneDSlicer(slice_col_name="testdata", bins=usebins + 1)
+        self.assertFalse(testslicer2 == testslicer3)
+        self.assertTrue(testslicer2 != testslicer3)
+
+
+class TestOneDSlicerSlicing(unittest.TestCase):
+    long_message = True
+
+    def setUp(self):
+        self.testslicer = OneDSlicer(slice_col_name="testdata")
+
+    def tearDown(self):
+        del self.testslicer
+        self.testslicer = None
+
+    def test_slicing(self):
+        """Test slicing."""
+        dvmin = 0
+        dvmax = 1
+        stepsize = 0.01
+        bins = np.arange(dvmin, dvmax + stepsize / 2, stepsize)
+        # Test that testbinner raises appropriate error before it's set up
+        # (first time)
+        self.assertRaises(NotImplementedError, self.testslicer._slice_sim_data, 0)
+        # test that we're not dumping extra visits into the 'last bin'
+        # (that it's closed both sides)
+        nvalues = 1000
+        dv = make_data_values(nvalues, 0, 2, random=560)
+        bins = np.arange(0, 1.05, 0.1)
+        self.testslicer = OneDSlicer(slice_col_name="testdata", bins=bins)
+        nbins = len(bins) - 1
+        self.testslicer.setup_slicer(dv)
+        for i, s in enumerate(self.testslicer):
+            self.assertEqual(len(s["idxs"]), nvalues / float(nbins) / 2.0)
+
+    def test_night_slicing(self):
+        """Test slicing with 'night' column"""
+        numval = 1000
+        vals = np.arange(0, numval, 1) / (numval / 50)
+        nights = np.floor(vals)
+        np.random.shuffle(nights)
+        # If you were doing by-hand comparison, this can be useful
+        # bins = np.arange(0, 50.5, 1)
+        # vals, bb = np.histogram(nights, bins=bins)
+        vals = make_data_values(len(nights), random=10)
+        vals = np.array(list(zip(nights, vals["testdata"])), dtype=[("night", "int"), ("testdata", "float")])
+        test_slicer = OneDSlicer(slice_col_name="night", bins=np.arange(0, 50.5, 1))
+        test_slicer.setup_slicer(vals)
+        for s in test_slicer:
+            self.assertTrue(vals[s["idxs"]]["night"].min() >= s["slice_point"]["bin_left"])
+            self.assertTrue(vals[s["idxs"]]["night"].max() < s["slice_point"]["bin_right"])
+            self.assertEqual(len(s["idxs"]), numval / 50)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_opsimutils.py

@@ -0,0 +1,80 @@
+import os
+import sqlite3
+import unittest
+
+import numpy as np
+from rubin_scheduler.data import get_data_dir
+
+import rubin_sim.maf.utils.opsim_utils as opsimUtils
+
+TEST_DB = "example_v3.4_0yrs.db"
+
+
+class TestOpsimUtils(unittest.TestCase):
+    def test_scale_benchmarks(self):
+        """Test scaling the design and stretch benchmarks for the
+        length of the run.
+        """
+        # First test that method returns expected dictionaries.
+        for i in ("design", "stretch"):
+            benchmark = opsimUtils.scale_benchmarks(10.0, i)
+            self.assertIsInstance(benchmark, dict)
+            expectedkeys = (
+                "Area",
+                "nvisitsTotal",
+                "nvisits",
+                "seeing",
+                "skybrightness",
+                "singleVisitDepth",
+            )
+            expectedfilters = ("u", "g", "r", "i", "z", "y")
+            for k in expectedkeys:
+                self.assertIn(k, benchmark)
+            expecteddictkeys = (
+                "nvisits",
+                "seeing",
+                "skybrightness",
+                "singleVisitDepth",
+            )
+            for k in expecteddictkeys:
+                for f in expectedfilters:
+                    self.assertIn(f, benchmark[k])
+
+    def test_calc_coadded_depth(self):
+        """Test the expected coadded depth calculation."""
+        benchmark = opsimUtils.scale_benchmarks(10, "design")
+        coadd = opsimUtils.calc_coadded_depth(benchmark["nvisits"], benchmark["singleVisitDepth"])
+        for f in coadd:
+            self.assertLess(coadd[f], 1000)
+        singlevisits = {"u": 1, "g": 1, "r": 1, "i": 1, "z": 1, "y": 1}
+        coadd = opsimUtils.calc_coadded_depth(singlevisits, benchmark["singleVisitDepth"])
+        for f in coadd:
+            self.assertAlmostEqual(coadd[f], benchmark["singleVisitDepth"][f])
+
+    def test_get_sim_data(self):
+        """Test that we can get simulation data"""
+        database_file = os.path.join(get_data_dir(), "tests", TEST_DB)
+        dbcols = ["fieldRA", "fieldDec", "scheduler_note"]
+        sql = "night < 10"
+        full_sql = "SELECT fieldRA, fieldDec, scheduler_note FROM observations where night < 10;"
+        # Check that we get data the usual way
+        data = opsimUtils.get_sim_data(database_file, sql, dbcols)
+        assert np.size(data) > 0
+
+        # Check that we can pass a connection object
+        con = sqlite3.connect(database_file)
+        data = opsimUtils.get_sim_data(con, sql, dbcols)
+        con.close()
+        assert np.size(data) > 0
+
+        # Check that kwarg overrides sqlconstraint and dbcols
+        data = opsimUtils.get_sim_data(database_file, "blah blah", ["nocol"], full_sql_query=full_sql)
+        assert np.size(data) > 0
+
+        # Check that bad file raises an error
+        with self.assertRaises(FileNotFoundError):
+            opsimUtils.get_sim_data("not_a_file.db", sql, ["nocol"])
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_plotters.py

@@ -0,0 +1,134 @@
+# imports
+import unittest
+
+import numpy as np
+from matplotlib.figure import Figure
+from rubin_scheduler.scheduler.model_observatory import ModelObservatory
+
+import rubin_sim.maf as maf
+
+
+class TestPlotters(unittest.TestCase):
+    def setUp(self):
+        # Set a seed to make the tests reproducible
+        self.rng = np.random.default_rng(seed=1234)
+
+    def test_healpix_plotters(self):
+        # Set up a metric bundle to send to plotters
+        bundle1 = maf.create_empty_metric_bundle()
+        nside = 64
+        bundle1.slicer = maf.HealpixSlicer(nside=nside)
+        bundle1._setup_metric_values()
+        bundle1.metric_values += self.rng.uniform(size=len(bundle1.slicer))
+        # First test healpix sky map - just that it runs.
+        bundle1.set_plot_funcs([maf.HealpixSkyMap()])
+        figs = bundle1.plot()
+        self.assertTrue(isinstance(figs["SkyMap"], Figure))
+        # Test healpix histogram - just that it runs
+        bundle1.set_plot_funcs([maf.HealpixHistogram()])
+        figs = bundle1.plot()
+        self.assertTrue(isinstance(figs["Histogram"], Figure))
+        # Test power spectrum
+        bundle1.set_plot_funcs([maf.HealpixPowerSpectrum()])
+        figs = bundle1.plot()
+        self.assertTrue(isinstance(figs["PowerSpectrum"], Figure))
+
+    def test_base_skymap(self):
+        bundle1 = maf.create_empty_metric_bundle()
+        npoints = 1000
+        ra = self.rng.uniform(low=0, high=360, size=npoints)
+        dec = self.rng.uniform(low=-90, high=90, size=npoints)
+        bundle1.slicer = maf.UserPointsSlicer(ra, dec)
+        bundle1._setup_metric_values()
+        bundle1.metric_values += self.rng.uniform(size=len(bundle1.slicer))
+        # Test skymap
+        bundle1.set_plot_funcs([maf.BaseSkyMap()])
+        figs = bundle1.plot()
+        self.assertTrue(isinstance(figs["SkyMap"], Figure))
+        # Test healpix histogram - just that it runs
+        bundle1.set_plot_funcs([maf.BaseHistogram()])
+        figs = bundle1.plot()
+        self.assertTrue(isinstance(figs["Histogram"], Figure))
+
+    def test_oned_plotter(self):
+        bundle1 = maf.create_empty_metric_bundle()
+        npoints = 100
+        bins = np.arange(0, npoints, 1)
+        bundle1.slicer = maf.OneDSlicer(slice_col_name="test", bins=bins)
+        bundle1.slicer.slice_points = {"bins": bins}
+        bundle1.slicer.nslice = len(bins) - 1
+        bundle1.slicer.shape = len(bins) - 1
+        bundle1._setup_metric_values()
+        bundle1.metric_values += self.rng.uniform(size=len(bundle1.slicer))
+        # Test plotter
+        bundle1.set_plot_funcs([maf.OneDBinnedData()])
+        figs = bundle1.plot()
+        self.assertTrue(isinstance(figs["BinnedData"], Figure))
+
+    def test_hpxmap_plotter(self):
+        bundle = maf.create_empty_metric_bundle()
+        nside = 64
+        bundle.slicer = maf.HealpixSlicer(nside=nside)
+        bundle._setup_metric_values()
+        bundle.metric_values += self.rng.uniform(size=len(bundle.slicer))
+
+        plotter = maf.HpxmapPlotter()
+        bundle.set_plot_funcs([plotter])
+        _ = bundle.plot()
+
+    def test_visit_perimeter_plotter(self):
+        model_observatory = ModelObservatory(init_load_length=1)
+
+        num_points = 5
+        field_ra = np.arange(30, 30 + num_points, dtype=float)
+        field_dec = np.arange(-60, -60 + num_points, dtype=float)
+        rot_sky_pos = np.arange(num_points, dtype=float) % 360
+
+        names = ["fieldRA", "fieldDec", "rotSkyPos"]
+        dtypes = [float] * 3
+        data = np.empty(field_ra.size, dtype=list(zip(names, dtypes)))
+        data["fieldRA"] = field_ra
+        data["fieldDec"] = field_dec
+        data["rotSkyPos"] = rot_sky_pos
+
+        unmasked_data = np.empty(dtype=object, shape=(1,))
+        unmasked_data[0] = data
+        masked_data = np.ma.MaskedArray(data=unmasked_data, mask=False, fill_value=-666, dtype=object)
+
+        bundle = maf.create_empty_metric_bundle()
+        bundle.slicer = maf.UniSlicer()
+        bundle._setup_metric_values()
+        bundle.metric_values = masked_data
+
+        def compute_camera_perimeter(ra, decl, rotation):
+            # just a quadrangle for this unit test.
+            # the math isn't quite right for an actual square,
+            # but good enough for a unit test.
+            size = 1.0
+            ras = [
+                ra - 0.5 * size * np.cos(np.radians(decl)) * np.sin(np.radians(rotation)),
+                ra - 0.5 * size * np.cos(np.radians(decl)) * np.cos(np.radians(rotation)),
+                ra + 0.5 * size * np.cos(np.radians(decl)) * np.sin(np.radians(rotation)),
+                ra + 0.5 * size * np.cos(np.radians(decl)) * np.cos(np.radians(rotation)),
+            ]
+            decls = [
+                decl + 0.5 * size * np.cos(np.radians(rotation)),
+                decl - 0.5 * size * np.sin(np.radians(rotation)),
+                decl - 0.5 * size * np.cos(np.radians(rotation)),
+                decl + 0.5 * size * np.sin(np.radians(rotation)),
+            ]
+            return ras, decls
+
+        plot_dict = {
+            "camera_perimeter_func": compute_camera_perimeter,
+            "model_observatory": model_observatory,
+            "decorations": ["ecliptic", "galactic_plane", "sun", "moon", "horizon"],
+        }
+        plotter = maf.VisitPerimeterPlotter()
+        bundle.set_plot_funcs([plotter])
+        bundle.set_plot_dict(plot_dict)
+        _ = bundle.plot()
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_resultsdb.py

@@ -0,0 +1,145 @@
+import os
+import shutil
+import tempfile
+import unittest
+import warnings
+
+import numpy as np
+
+import rubin_sim.maf.db as db
+
+
+class TestResultsDb(unittest.TestCase):
+    def setUp(self):
+        self.out_dir = "Out"
+        self.metric_name = "Count ExpMJD"
+        self.slicer_name = "OneDSlicer"
+        self.run_name = "fakeopsim"
+        self.sql_constraint = ""
+        self.info_label = "Dithered"
+        self.metric_data_file = "testmetricdatafile.npz"
+        self.plot_type = "BinnedData"
+        self.plot_name = "testmetricplot_BinnedData.png"
+        self.summary_stat_name1 = "Mean"
+        self.summary_stat_value1 = 20
+        self.summary_stat_name2 = "Median"
+        self.summary_stat_value2 = 18
+        self.summary_stat_name3 = "TableFrac"
+        self.summary_stat_value3 = np.empty(10, dtype=[("name", "|S12"), ("value", float)])
+        for i in range(10):
+            self.summary_stat_value3["name"] = "test%d" % (i)
+            self.summary_stat_value3["value"] = i
+        self.display_dict = {
+            "group": "seeing",
+            "subgroup": "all",
+            "order": 1,
+            "caption": "lalalalal",
+        }
+
+    def test_db_creation(self):
+        # Test default sqlite file created.
+        tempdir = tempfile.mkdtemp(prefix="resDb")
+        resultsdb = db.ResultsDb(out_dir=tempdir)
+        self.assertTrue(os.path.isfile(os.path.join(tempdir, "resultsDb_sqlite.db")))
+        resultsdb.close()
+        # Test that get appropriate exception if directory doesn't exist.
+        sqlitefilename = os.path.join(self.out_dir + "test", "testDb_sqlite.db")
+        self.assertRaises(ValueError, db.ResultsDb, database=sqlitefilename)
+        shutil.rmtree(tempdir)
+
+    def test_add_data(self):
+        tempdir = tempfile.mkdtemp(prefix="resDb")
+        results_db = db.ResultsDb(out_dir=tempdir)
+        # Add metric.
+        metric_id = results_db.update_metric(
+            self.metric_name,
+            self.slicer_name,
+            self.run_name,
+            self.sql_constraint,
+            self.info_label,
+            self.metric_data_file,
+        )
+        # Try to re-add metric
+        # (should get back same metric id as previous, with no add).
+        metric_id2 = results_db.update_metric(
+            self.metric_name,
+            self.slicer_name,
+            self.run_name,
+            self.sql_constraint,
+            self.info_label,
+            self.metric_data_file,
+        )
+        self.assertEqual(metric_id, metric_id2)
+        run1 = results_db.session.query(db.MetricRow).filter_by(metric_id=metric_id).all()
+        self.assertEqual(len(run1), 1)
+        # Add plot.
+        results_db.update_plot(metric_id, self.plot_type, self.plot_name)
+        # Add normal summary statistics.
+        results_db.update_summary_stat(metric_id, self.summary_stat_name1, self.summary_stat_value1)
+        results_db.update_summary_stat(metric_id, self.summary_stat_name2, self.summary_stat_value2)
+        # Add something like tableFrac summary statistic.
+        results_db.update_summary_stat(metric_id, self.summary_stat_name3, self.summary_stat_value3)
+        # Test get warning when try to add a non-conforming summary stat
+        # (not 'name' & 'value' cols).
+        teststat = np.empty(10, dtype=[("col", "|S12"), ("value", float)])
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            results_db.update_summary_stat(metric_id, "testfail", teststat)
+            self.assertIn("not save", str(w[-1].message))
+        # Test we get warning when try to add a string (non-conforming)
+        # summary stat.
+        teststat = "teststring"
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            results_db.update_summary_stat(metric_id, "testfail", teststat)
+            self.assertIn("not save", str(w[-1].message))
+        shutil.rmtree(tempdir)
+
+
+class TestUseResultsDb(unittest.TestCase):
+    def setUp(self):
+        self.out_dir = "Out"
+        self.metric_name = "Count ExpMJD"
+        self.slicer_name = "OneDSlicer"
+        self.run_name = "fakeopsim"
+        self.constraint = ""
+        self.info_label = "Dithered"
+        self.metric_data_file = "testmetricdatafile.npz"
+        self.plot_type = "BinnedData"
+        self.plot_name = "testmetricplot_BinnedData.png"
+        self.summary_stat_name1 = "Mean"
+        self.summary_stat_value1 = 20
+        self.summary_stat_name2 = "Median"
+        self.summary_stat_value2 = 18
+        self.tempdir = tempfile.mkdtemp(prefix="resDb")
+        self.results_db = db.ResultsDb(self.tempdir)
+        self.metric_id = self.results_db.update_metric(
+            self.metric_name,
+            self.slicer_name,
+            self.run_name,
+            self.constraint,
+            self.info_label,
+            self.metric_data_file,
+        )
+        self.results_db.update_plot(self.metric_id, self.plot_type, self.plot_name)
+        self.results_db.update_summary_stat(self.metric_id, self.summary_stat_name1, self.summary_stat_value1)
+        self.results_db.update_summary_stat(self.metric_id, self.summary_stat_name2, self.summary_stat_value2)
+
+    def testget_ids(self):
+        mids = self.results_db.get_all_metric_ids()
+        self.assertEqual(mids[0], self.metric_id)
+        mid = self.results_db.get_metric_id(self.metric_name)
+        self.assertEqual(mid[0], self.metric_id)
+        mid = self.results_db.get_metric_id("notreal")
+        self.assertEqual(len(mid), 0)
+
+    def testshow_summary(self):
+        self.results_db.get_summary_stats()
+
+    def tearDown(self):
+        self.results_db.close()
+        shutil.rmtree(self.tempdir)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/maf/test_schedviewmetrics.py

@@ -0,0 +1,14 @@
+import unittest
+
+import numpy as np
+
+import rubin_sim.maf.metrics as metrics
+
+
+class TestSchedviewMetrics(unittest.TestCase):
+    def test_age_metric(self):
+        data = np.rec.fromrecords([(1, 60000)], names="id,observationStartMJD")
+
+        assert metrics.AgeMetric(60002).run(data) == 2
+        assert metrics.AgeMetric(60002.5).run(data) == 2.5
+        assert np.isnan(metrics.AgeMetric(70000.0).run(data))