def test_PA1_measurement_with_inf(self):
"""Test (de)serialization of a measurement with value np.inf."""
measurement = Measurement('PA1', np.inf * u.mag)
json_doc = measurement.json
# a np.inf value is also serialized to None
self.assertEqual(json_doc['value'], None)
# but once it is None, we can only deserialized it to np.nan
new_measurement = Measurement.deserialize(**json_doc)
self.assertEqual(str(new_measurement), 'PA1: nan mag')
def test_PA1_measurement_with_nan(self):
"""Test (de)serialization of a measurement with value np.nan."""
measurement = Measurement('PA1', np.nan * u.mag)
json_doc = measurement.json
# a np.nan value is serialized to None
self.assertEqual(json_doc['value'], None)
# a None value is deserialized to np.nan
new_measurement = Measurement.deserialize(**json_doc)
self.assertEqual(str(new_measurement), 'PA1: nan mag')
def test_PA1_measurement_without_metric(self):
"""Test a measurement without a Metric instance."""
measurement = Measurement('validate_drp.PA1', 0.002 * u.mag)
self.assertIsInstance(measurement.metric_name, Name)
self.assertEqual(measurement.metric_name, Name('validate_drp.PA1'))
self.assertIsNone(measurement.metric)
json_doc = measurement.json
# Units are not converted
self.assertEqual(json_doc['unit'], 'mag')
self.assertFloatsAlmostEqual(json_doc['value'], 0.002)
new_measurement = Measurement.deserialize(**json_doc)
self.assertEqual(measurement, new_measurement)
def test_creation_with_extras(self):
"""Test creating a measurement with an extra."""
measurement = Measurement(
self.pa1,
5. * u.mmag,
extras={'extra1': Datum(10. * u.arcmin, 'Extra 1')})
self.assertIn(str(self.pa1.name), measurement.blobs)
self.assertIn('extra1', measurement.extras)
json_doc = measurement.json
self.assertIn(measurement.extras.identifier, json_doc['blob_refs'])
blobs = BlobSet([b for k, b in measurement.blobs.items()])
new_measurement = Measurement.deserialize(blobs=blobs, **json_doc)
self.assertIn('extra1', new_measurement.extras)
self.assertEqual(measurement, new_measurement)
def test_PA1_measurement_with_metric(self):
"""Standard metric with a given Metric instance."""
measurement = Measurement(self.pa1,
0.002 * u.mag,
blobs=[self.blob1],
notes={'filter_name': 'r'})
measurement.link_blob(self.blob2)
measurement2 = Measurement(self.pa1, 0.002 * u.mag)
self.assertTrue(quantity_allclose(measurement.quantity, 0.002 * u.mag))
self.assertIsInstance(measurement.metric_name, Name)
self.assertEqual(measurement.metric_name, Name('validate_drp.PA1'))
self.assertEqual(measurement.metric, self.pa1)
self.assertNotEqual(measurement.identifier, measurement2.identifier)
# Test blob access
self.assertIn('Blob1', measurement.blobs)
self.assertIn('Blob2', measurement.blobs)
# Test Datum representation
datum = measurement.datum
self.assertTrue(quantity_allclose(datum.quantity, 0.002 * u.mag))
self.assertEqual(datum.label, str(self.pa1.name))
self.assertEqual(datum.description, str(self.pa1.description))
# Test notes (MeasurementNotes)
self.assertEqual(measurement.notes['filter_name'], 'r')
# Add a note
measurement.notes['camera'] = 'MegaCam'
self.assertEqual(measurement.notes['camera'], 'MegaCam')
self.assertEqual(len(measurement.notes), 2)
self.assertIn('camera', measurement.notes)
self.assertIn('filter_name', measurement.notes)
# Prefixed keys
self.assertIn('validate_drp.PA1.camera', measurement.notes)
# test iteration
iterkeys = set([key for key in measurement.notes])
self.assertEqual(len(iterkeys), 2)
self.assertEqual(set(iterkeys), set(measurement.notes.keys()))
itemkeys = set()
for key, value in measurement.notes.items():
self.assertEqual(measurement.notes[key], value)
itemkeys.add(key)
self.assertEqual(itemkeys, iterkeys)
# Test update
measurement.notes.update({'photometric': True, 'facility': 'CFHT'})
self.assertIn('photometric', measurement.notes)
# Test delete
del measurement.notes['photometric']
self.assertNotIn('photometric', measurement.notes)
# Test serialization
json_doc = measurement.json
# Units should be cast to those of the metric
self.assertEqual(json_doc['unit'], 'mmag')
self.assertFloatsAlmostEqual(json_doc['value'], 2.0)
self.assertEqual(json_doc['identifier'], measurement.identifier)
self.assertIsInstance(json_doc['blob_refs'], list)
self.assertIn(self.blob1.identifier, json_doc['blob_refs'])
self.assertIn(self.blob2.identifier, json_doc['blob_refs'])
# No extras, so should not be serialized
self.assertNotIn(measurement.extras.identifier, json_doc['blob_refs'])
# Test deserialization
new_measurement = Measurement.deserialize(blobs=BlobSet(
[self.blob1, self.blob2]),
**json_doc)
# shim in original notes; normally these are deserialized via the
# Job object.
new_measurement.notes.update(measurement.notes)
self.assertEqual(measurement, new_measurement)
self.assertEqual(measurement.identifier, new_measurement.identifier)
self.assertIn('Blob1', measurement.blobs)
self.assertIn('Blob2', measurement.blobs)