""" Tests for fits helpers For FITS binary table tests see formatstest.py """ #c Copyright 2008-2024, the GAVO project #c #c This program is free software, covered by the GNU GPL. See the #c COPYING file in the source distribution. import os import re import unittest from gavo.helpers import testhelpers from gavo import base from gavo import utils from gavo.helpers import fitstricks from gavo.utils import fitstools from gavo.utils import pyfits _fitsData = utils.getDirtyBytes( b"""eJzt0b0KwjAUhmH/f+7i3IFWZwfFCgEthXboGm0LHZpIUofevaeIuCRIwUm+B76teTnQRFzic0i0 I4eUVnTTqtSmttRoOok0IdtIlUuTux4QHUQai8zd2264J42RLeWykdS098Jd+Yj2mUjIc1/XU4/6 WhjS5btc1YWylVbW3wvcvWD97RpPb+O9r7cwS8Po6P0f/XtdDAAAAAB+ZvAy5I14Y96EN+XNeHPe grfs+R0AAAAAwF96ApwhgT4= """) _nastyHeaderData = utils.getDirtyBytes( b""" eJztkctOwzAQRX/lrsgGFbpjwyKUQCOah5pQdesm08TIskvsNCpfj90WCaQWqRLsfOSVH2c8d4o4 yWcRcI8TlKc2f+chLvN4ecZ3d7kvDZdxgTO+28t90bKM0se/63eWpc+LcGZ9QdlyDbsYhJINtkz0 BNMyg4ELgY7ee96RPa6UNFzaw4p1Nbi0lwhrbjSugkmWlnH6aicStMRq6kZAWJmeCbG7dhetQcmK QFuSGJgrt+qbQx0lxQ66VQPV6DfWBnzzDa19YQZ1rM8MVxKCS9IYnJbVb6wiadyzs0zjaB7OJ1Pk efiCfPw0Rr6I5kWcpS6D8egwkwA3yJOw2Ld1aARb6rQr+YNJliRRWmIfniF9DKtVG1r3tmfUnDVS fdjvyZ3NsOlIO4s+5qZdciRq/TVfN1yPx+PxeDyef+QT1lS2XQ== """) def getAFITSPath(): return os.path.join(base.getConfig("inputsDir"), "data", "ex.fits") class SortHeadersTest(unittest.TestCase): """tests for sortHeaders. """ def assertHeaderSequence(self, hdr, keySeq): for expected, card in zip(keySeq, hdr.cards): self.assertEqual(expected, card.keyword) def testHeadersPreserved(self): """tests for sortHeaders preserving the incoming headers by default. """ with testhelpers.testFile("test.fits", _fitsData) as ff: with pyfits.open(ff) as hdus: hdr = fitstools.sortHeaders(hdus[0].header) self.assertHeaderSequence(hdr, ["SIMPLE", "BITPIX", "NAXIS", "NAXIS1", "NAXIS2", "EXTEND",]) def testWithCommentsAndHistory(self): """tests for sortHeaders sorting comment and history cards. """ with testhelpers.testFile("test.fits", _fitsData) as ff: with pyfits.open(ff) as hdus: hdr = hdus[0].header hdr.add_comment("Foo1") hdr.add_history("this header added for testing") hdr.add_comment("This is at the end.") hdr = fitstools.sortHeaders(hdr) self.assertHeaderSequence(hdr, ["SIMPLE", "BITPIX", "NAXIS", "NAXIS1", "NAXIS2", "EXTEND", "", "HISTORY", "", "COMMENT", "COMMENT"]) def testCommentFilter(self): """tests for deletion of unwanted comment cards. """ with testhelpers.testFile("test.fits", _fitsData) as ff: with pyfits.open(ff) as hdus: hdr = hdus[0].header hdr.add_comment("to delete") hdr.add_comment("keep this one") hdr.add_comment("and delete this") hdr.add_comment("and also delete this") hdr.add_comment("but keep this") hdr = fitstools.sortHeaders(hdr, lambda arg: "delete" in arg) self.assertHeaderSequence(hdr, ["SIMPLE", "BITPIX", "NAXIS", "NAXIS1", "NAXIS2", "EXTEND", "", "COMMENT", "COMMENT"]) def testOrder(self): """tests for ordering of critical keywords. """ hdr = pyfits.PrimaryHDU().header hdr.set("NAXIS1", 200) hdr.set("NAXIS2", 400) # EXTEND is now before NAXIS1 hdr = fitstools.sortHeaders(hdr) self.assertHeaderSequence(hdr, ["SIMPLE", "BITPIX", "NAXIS", "NAXIS1", "NAXIS2", "EXTEND"]) hdr = pyfits.PrimaryHDU().header del hdr["EXTEND"] hdr.set("NAXIS1", 200) hdr.set("FLOB", "Worong") hdr.set("EXTEND", "F") # EXTEND is now way behind NAXIS1 hdr = fitstools.sortHeaders(hdr) self.assertHeaderSequence(hdr, ["SIMPLE", "BITPIX", "NAXIS", "NAXIS1", "EXTEND", "FLOB"]) def testWithCardSequence(self): cardsIn = [pyfits.Card(*args) for args in ( ("SIMPLE", True), ("BITPIX", 0), ("NAXIS", 0), ("BOOKS", "Plenty"), ("CROOKS", 5), ("HOOKS", "None"))] hdr = fitstools.sortHeaders(cardsIn, cardSequence=(("SIMPLE", True), ("HOOKS", True), (pyfits.Card(value="---- Separator ----"), None), ("CROOKS", True))) self.assertEqual( re.sub(" *", lambda mat: "(%d)"%len(mat.group(0)), str(hdr)), "SIMPLE(2)=(20)T(50)BITPIX(2)=(20)0(50)NAXIS(3)=(20)0(50)" "HOOKS(3)=(1)'None(4)'(68)----(1)Separator(1)----(53)" "CROOKS(2)=(20)5(50)BOOKS(3)=(1)'Plenty(2)'(60)END(2317)") class FITSWriteTest(testhelpers.VerboseTest): """tests for correct FITS writing. """ def _assertOverwriteWorks(self, inFileName): with pyfits.open(inFileName) as hdus: hdr = hdus[0].header hdr.set("TELESCOP", "Python Telescope") hdr.set("APERTURE", 23) fitstools.replacePrimaryHeaderInPlace(inFileName, hdr) with pyfits.open(inFileName) as hdus: hdu = hdus[0] self.assertEqual(hdu.header["TELESCOP"], "Python Telescope") self.assertEqual(hdu.header["BITPIX"], 32) self.assertEqual(hdu.header["NAXIS1"], 10) self.assertEqual(hdu.data[1][4], 4) def testInPlaceSameSize(self): with testhelpers.testFile("test.fits", _fitsData) as ff: self._assertOverwriteWorks(ff) def testInPlaceGZ(self): with testhelpers.testFile("test.fits.gz", _fitsData, writeGz=True) as ff: self.assertRaisesWithMsg(NotImplementedError, "replacePrimaryHeaderInPlace no longer supports gzipped files.", fitstools.replacePrimaryHeaderInPlace, (ff, None)) def testInPlaceLonger(self): with testhelpers.testFile("test.fits", _fitsData) as ff: with pyfits.open(ff) as hdus: hdr = hdus[0].header for num in range(50): hdr.set("KEY%d"%num, num) fitstools.replacePrimaryHeaderInPlace(ff, hdr) with pyfits.open(ff) as hdus: hdu = hdus[0] self.assertEqual(hdu.header["NAXIS1"], 10) self.assertEqual(hdu.header["KEY48"], 48) self.assertEqual(hdu.data[1][4], 4) def testInPlaceShorter(self): with testhelpers.testFile("test.fits", _fitsData) as ff: with pyfits.open(ff) as hdus: hdr = hdus[0].header oldhdr = hdr.copy() for num in range(50): hdr.set("KEY%d"%num, num) fitstools.replacePrimaryHeaderInPlace(ff, hdr) fitstools.replacePrimaryHeaderInPlace(ff, oldhdr) # if things have worked, there's now >= 50 cards of padding # in the header, and the end card is in the second after # all the padding with open(ff, "rb") as f: firstBlock = f.read(fitstools.FITS_BLOCK_SIZE) self.assertFalse(fitstools.END_CARD in firstBlock) secondBlock = f.read(fitstools.FITS_BLOCK_SIZE) self.assertTrue(fitstools.END_CARD in secondBlock) self.assertTrue(secondBlock.startswith(b" "*2000)) with pyfits.open(ff) as hdus: hdu = hdus[0] self.assertEqual(hdu.header["NAXIS1"], 10) self.assertEqual(hdu.data[1][4], 4) self.assertRaises(KeyError, lambda: hdu.header["KEY48"]) def testWithContinueCards(self): hdr = pyfits.Header() hdr.set("LONGVAL", "This is a long value that will require a" " continue card in the fits header. Actually, there once even" " was a bug that only showed up when two contination lines" " were adjacent") hdr.add_comment("There were times when the combination of comment" " and continue cards were a problem") hdr.add_comment("This test will hopefully diagnoze any regressions" " in these fields") serialized = fitstools.serializeHeader(hdr) self.assertEqual(len(serialized), fitstools.FITS_BLOCK_SIZE) self.assertEqual(serialized[:9], b"LONGVAL =") self.assertEqual(serialized[80:89], b"CONTINUE ") self.assertEqual(serialized[160:169], b"CONTINUE ") self.assertEqual(serialized[240:249], b"COMMENT T") self.assertEqual(serialized[320:331], b"COMMENT a ") self.assertEqual(serialized[400:409], b"COMMENT T") self.assertEqual(serialized[480:489], b"END ") def testRoundtrip(self): with testhelpers.testFile("test.fits", _nastyHeaderData) as ff: with open(ff, "rb") as f: hdr = fitstools.readPrimaryHeaderQuick(f) self.assertEqual(fitstools.serializeHeader(hdr), _nastyHeaderData) class ParseCardsTest(testhelpers.VerboseTest): def testFailsForJunk(self): self.assertRaises(ValueError, fitstools.parseCards, "jfkdl") def testParses(self): input = ("NAXIS1 = 22757 / length of data axis 1 " " NAXIS2 = 22757 / length of data a" "xis 2 CTYPE1 = 'RA---TAN-SIP' / TAN " "(gnomic) projection + SIP distortions CTYPE2 = 'DEC--TAN-SIP' " " / TAN (gnomic) projection + SIP distortions ") cards = fitstools.parseCards(input) for card, (exKey, exVal) in zip(cards, [ ("NAXIS1", 22757), ("NAXIS2", 22757), ("CTYPE1", "RA---TAN-SIP"), ("CTYPE2", "DEC--TAN-SIP"),]): self.assertEqual(card.keyword, exKey) self.assertEqual(card.value, exVal) def testEndCard(self): input = ("NAXIS1 = 22757 / length of data axis 1 " " NAXIS2 = 22757 / length of data a" "xis 2 END " " CTYPE2 = 'DEC--TAN-SIP' " " / TAN (gnomic) projection + SIP distortions ") self.assertEqual(len(fitstools.parseCards(input)), 2) def testEmptyCardIgnored(self): input = ("NAXIS1 = 22757 / length of data axis 1 " " NAXIS2 = 22757 / length of data a" "xis 2 " " CTYPE2 = 'DEC--TAN-SIP' " " / TAN (gnomic) projection + SIP distortions ") self.assertEqual(len(fitstools.parseCards(input)), 3) class ScalingTest(testhelpers.VerboseTest): def testIterRowsBscale(self): with open(getAFITSPath(), "rb") as f: hdr = fitstools.readPrimaryHeaderQuick(f) colIter = fitstools.iterFITSRows(hdr, f) col = next(colIter) self.assertEqual(len(col), 12) self.assertEqual(col[-1], 8472.) self.assertEqual(len(list(colIter)), 22) def testIterScaledRows2(self): with open(getAFITSPath(), "rb") as f: pixelRows = list(fitstools.iterScaledRows(f, 2)) self.assertEqual(len(pixelRows), 11) self.assertEqual(len(pixelRows[0]), 6) self.assertEqual(pixelRows[0][-1], 8227.75) def testIterScaledRows5(self): with open(getAFITSPath(), "rb") as f: pixelRows = list(fitstools.iterScaledRows(f, 5)) self.assertEqual(len(pixelRows), 4) self.assertEqual(len(pixelRows[0]), 2) self.assertEqual(int(pixelRows[0][-1]), 8621) def testIterScaledRowsSlow(self): with open(getAFITSPath(), "rb") as f: pixelRows = list(fitstools.iterScaledRows(f, 5, slow=True)) self.assertEqual(len(pixelRows), 4) self.assertEqual(len(pixelRows[0]), 2) self.assertEqual(int(pixelRows[0][-1]), 8621) def testIterScaledRowsWidth(self): with open(getAFITSPath(), "rb") as f: pixelRows = list(fitstools.iterScaledRows(f, destSize=5)) self.assertEqual(len(pixelRows), 4) self.assertEqual(len(pixelRows[0]), 2) self.assertEqual(int(pixelRows[0][-1]), 8621) class ReadHeaderTest(testhelpers.VerboseTest): def testMaxBlocks(self): with testhelpers.testFile("bad.fits", " "*8000) as inName: with open(inName, "rb") as f: self.assertRaisesWithMsg(fitstools.FITSError, 'No end card found within 2 blocks', fitstools.readHeaderBytes, (f, 2)) def testPrematureEOF(self): with testhelpers.testFile("bad.fits", " "*80) as inName: with open(inName, "rb") as f: self.assertRaisesWithMsg(EOFError, 'Premature end of file while reading header', fitstools.readHeaderBytes, (f,)) def testTextSourceRejected(self): inName = os.path.join(base.getConfig("inputsDir"), "data", "ex.fits") with open(inName, "r") as f: self.assertRaisesWithMsg(IOError, 'fitstools only works with files opened in binary mode.', fitstools.readHeaderBytes, (f,)) class FITSCutoutTest(testhelpers.VerboseTest): def setUp(self): self.hdus = pyfits.open( os.path.join(base.getConfig("inputsDir"), "data", "excube.fits")) self.origHDU = self.hdus[0] def tearDown(self): self.hdus.close() def testSimpleCutout1(self): res = fitstools.cutoutFITS(self.origHDU, (1, 2, 3)) self.assertEqual(res.header["NAXIS1"], 2) self.assertEqual(res.header["CRPIX1"], 36.) self.assertEqual(res.header["NAXIS"], 3) self.assertEqual(res.header["NAXIS2"], 7) self.assertEqual(res.header["CALIFAID"], 935) self.assertAlmostEqual(res.data[0][0][0], 0.01679336) self.assertAlmostEqual(res.data[-1][-1][-1], -0.01980321) def testOpenCutout2(self): res = fitstools.cutoutFITS(self.origHDU, (2, -1, 3)) self.assertEqual(res.header["NAXIS1"], 11) self.assertEqual(res.header["NAXIS2"], 3) self.assertEqual(res.header["CRPIX2"], 33.) self.assertAlmostEqual(res.data[0][0][0], 0.02511436) self.assertAlmostEqual(res.data[-1][-1][-1], 0.09358116) def testOpenCutout3(self): res = fitstools.cutoutFITS(self.origHDU, (3, 3, 10000)) self.assertEqual(res.header["NAXIS3"], 2) self.assertEqual(res.header["CRPIX3"], -1.) self.assertAlmostEqual(res.data[0][0][0], 0.03102851) self.assertAlmostEqual(res.data[-1][-1][-1], 0.07562912) def testMultiCutout(self): res = fitstools.cutoutFITS(self.origHDU, (1, 6, 8), (2, 3, 3), (3, 2, 4)) self.assertEqual(res.header["NAXIS1"], 3) self.assertEqual(res.header["CRPIX1"], 32) self.assertEqual(res.header["NAXIS2"], 1) self.assertEqual(res.header["CRPIX2"], 31) self.assertEqual(res.header["NAXIS3"], 3) self.assertEqual(res.header["CRPIX3"], 0) self.assertAlmostEqual(res.data[0][0][0], 0.0155675) self.assertAlmostEqual(res.data[-1][-1][-1], 0.05489994) def testSwappedLimits(self): res = fitstools.cutoutFITS(self.origHDU, (1, 8, 7)) self.assertEqual(res.header["NAXIS1"], 1) self.assertAlmostEqual(res.data[0][0][0], -0.01717306) def testMinOutOfLimit(self): res = fitstools.cutoutFITS(self.origHDU, (1, 13, 15)) self.assertEqual(res.header["NAXIS1"], 1) self.assertAlmostEqual(res.data[0][0][0], 0.0558035) self.assertEqual(res.header["CRPIX1"], 27.) def testMaxOutOfLimit(self): res = fitstools.cutoutFITS(self.origHDU, (1, -13, -12)) self.assertEqual(res.header["NAXIS1"], 1) self.assertAlmostEqual(res.data[0][0][0], 0.02511436) self.assertEqual(res.header["CRPIX1"], 37.) class WCSAxisTest(testhelpers.VerboseTest): def testTransformations(self): ax = fitstools.WCSAxis("test", 4, 9, 0.5) self.assertEqual(ax.pixToPhys(10), 4.5) self.assertEqual(ax.physToPix(4.5), 10) def testPix0Transformation(self): ax = fitstools.WCSAxis("test", 0, -9, -3) self.assertEqual(ax.pix0ToPhys(10), -60) self.assertEqual(ax.physToPix0(-60), 10) def testLimits(self): ax = fitstools.WCSAxis("test", -30, 2000, 0.25, axisLength=400) self.assertEqual(ax.getLimits(), (-529.75, -430.0)) def testNoneTrafo(self): ax = fitstools.WCSAxis("test", 4, 9, 0.5) self.assertEqual(ax.pixToPhys(None), None) self.assertEqual(ax.physToPix(None), None) def testNone0Trafo(self): ax = fitstools.WCSAxis("test", 4, 9, 0.5) self.assertEqual(ax.pix0ToPhys(None), None) self.assertEqual(ax.physToPix0(None), None) class WCSFromHeaderTest(testhelpers.VerboseTest): _baseHdr = { "CTYPE1": 'WAVELEN ', "CTYPE2": 'RA---TAN', "CTYPE3": 'DEC--TAN', "CRVAL1": 496.0, "CRVAL2": 148.75004, "CRVAL3": -1.50138888, "CRPIX1": 1, "CRPIX2": 32.5, "CRPIX3": 1, "CDELT1": 0.269, "CDELT2": -2.7777777777777E-05, "CDELT3": 1.0, "CUNIT1": 'nm ', "CNAME2": "FOOCOL "} def testMultiDRejected(self): hdr = self._baseHdr.copy() hdr["PC2_1"] = 23.3 self.assertRaisesWithMsg(ValueError, "FITS axis 2 appears not separable. WCSAxis cannot handle this.", fitstools.WCSAxis.fromHeader, (hdr, 2)) def testSelfCDOk(self): hdr = self._baseHdr.copy() hdr["CD2_2"] = 148.75 hdr["CD1_1"] = 23.3 self.assertEqual( fitstools.WCSAxis.fromHeader(hdr, 2).physToPix(23), 4527033.940000127) def testNameInferenceCtype(self): ax = fitstools.WCSAxis.fromHeader(self._baseHdr, 1) self.assertEqual(ax.name, "WAVELEN_1") def testNameInferenceCname(self): ax = fitstools.WCSAxis.fromHeader(self._baseHdr, 2) self.assertEqual(ax.name, "FOOCOL_2") def testNameInferenceCleanedCtype(self): ax = fitstools.WCSAxis.fromHeader(self._baseHdr, 3) self.assertEqual(ax.name, "DEC_3") def testNameInferenceFallback(self): hdr = self._baseHdr.copy() del hdr["CTYPE3"] ax = fitstools.WCSAxis.fromHeader(hdr, 3) self.assertEqual(ax.name, "COO_3") def testOtherData(self): ax = fitstools.WCSAxis.fromHeader(self._baseHdr, 1) self.assertEqual(ax.crval, 496.0) self.assertEqual(ax.crpix, 1) self.assertEqual(ax.cdelt, 0.269) self.assertEqual(ax.cunit, "nm") self.assertEqual(ax.ctype, "WAVELEN") def testEmptyUnitBecomesNone(self): ax = fitstools.WCSAxis.fromHeader(self._baseHdr, 2) self.assertEqual(ax.cunit, None) class ESODescriptorsTest(testhelpers.VerboseTest): def testSimple(self): descs = fitstools._ESODescriptorsParser(""" 'WSTART' ,'R*8 ' , 1, 6,'3E23.15',' ',' ' 3.983291748046876E+03 4.011743652343751E+03 4.040604980468751E+03 4.069884765625001E+03 4.099591796875001E+03 4.129735839843751E+03 'NPTOT' ,'I*4 ' , 1, 14,'7I10',' ',' ' 552 556 560 564 568 572 576 581 585 589 594 598 603 608 """).result self.assertEqual(descs, { 'WSTART': [3983.291748046876, 4011.743652343751, 4040.604980468751, 4069.884765625001, 4099.591796875001, 4129.735839843751], 'NPTOT': [552, 556, 560, 564, 568, 572, 576, 581, 585, 589, 594, 598, 603, 608], }) def testShortArray(self): self.assertRaisesWithMsg(base.SourceParseError, "At character 183: Expected a float here, offending ''", fitstools._ESODescriptorsParser, (""" 'WSTART' ,'R*8 ' , 1, 6,'3E23.15',' ',' ' 3.983291748046876E+03 4.011743652343751E+03 4.040604980468751E+03 4.069884765625001E+03 4.099591796875001E+03""",)) # Maybe do a test with a real header here? class _TemplatedHeader(testhelpers.TestResource): fitstricks.registerTemplate('dachstest', fitstricks.MINIMAL_IMAGE_TEMPLATE+[ pyfits.Card(value="---- Separator"), ("ADDLATER", "This is inserted later"), ("CHGLATER", "This is changed later"), ("TESTVAL", "Just some random junk"),]) def make(self, dependents): hdr = fitstricks.makeHeaderFromTemplate("dachstest", BITPIX=8, NAXIS1=3, NAXIS2=4, TESTVAL="Really", CHGLATER=23) class _(object): fits = hdr ser = str(hdr) return _ _templatedHeader = _TemplatedHeader() class _ExtendedTemplatedHeader(testhelpers.TestResource): resources = [("base", _templatedHeader)] def make(self, dependents): base = dependents["base"].fits.copy() base.add_history("Changed by someone else") base.add_comment("This is snide") base.add_comment("Da-te-dum") hdr = fitstricks.updateTemplatedHeader(base, ADDLATER=42.25, CHGLATER=24) class _(object): fits = hdr ser = str(hdr) return _ class TemplatingTest(testhelpers.VerboseTest): resources = [("base", _templatedHeader), ("mod", _ExtendedTemplatedHeader())] def testParmeterSwallowed(self): self.assertEqual(self.base.fits["NAXIS1"], 3) def testOmittedHeadersOmitted(self): self.assertFalse("BZERO" in self.base.fits) def testHeaderSequence(self): self.assertEqual([c.keyword for c in self.base.fits.cards], ['SIMPLE', 'EXTEND', 'BITPIX', 'NAXIS', 'NAXIS1', 'NAXIS2', '', 'CHGLATER', 'TESTVAL', 'HISTORY']) def testNiceSeparator(self): self.assertTrue("2nd axis ---- Separator" in self.base.ser) def testCustomComment(self): self.assertTrue("'Really ' / Just some random junk" in self.base.ser) def testCreationHistoryPresent(self): self.assertTrue("HISTORY GAVO DaCHS template used: dachstest" in self.base.ser) def testModifiedHeaderSequence(self): self.assertEqual([c.keyword for c in self.mod.fits.cards], ['SIMPLE', 'EXTEND', 'BITPIX', 'NAXIS', 'NAXIS1', 'NAXIS2', '', 'ADDLATER', 'CHGLATER', 'TESTVAL', 'HISTORY', 'HISTORY', '', 'COMMENT', 'COMMENT']) def testUpdateAdds(self): self.assertEqual(self.mod.fits["ADDLATER"], 42.25) def testUpdateChanges(self): self.assertEqual(self.base.fits["CHGLATER"], 23) self.assertEqual(self.mod.fits["CHGLATER"], 24) def testHistoryPreserved(self): self.assertTrue("HISTORY Changed by someone else" in self.mod.ser) def testCommentsPreserved(self): self.assertTrue("COMMENT Da-te-dum" in self.mod.ser) class HistoryTest(testhelpers.VerboseTest): def testAddingHistory(self): with pyfits.open(getAFITSPath()) as hdus: hdr = hdus[0].header fitstricks.addHistoryCard( hdr, "DaCHS test processing: adding History", "DaCHS test processing") histCards = hdr["history"] self.assertEqual(histCards[0], "Created by the Astrometry.net suite.") # astrometry.net and WCS cruft in 1-9 self.assertEqual(histCards[10], utils.EqualingRE( r"\d\d\d\d-\d\d-\d\d DaCHS test processing: adding History")) def testRewritingHistory(self): with pyfits.open(getAFITSPath()) as hdus: hdr = hdus[0].header fitstricks.addHistoryCard(hdr, "DaCHS test processing: adding History", "DaCHS test processing") histCards = hdr["history"] fitstricks.addHistoryCard(hdr, "Overwritten history.", "DaCHS test processing") self.assertEqual(histCards[10], utils.EqualingRE( r"\d\d\d\d-\d\d-\d\d Overwritten history.")) def testLongHistoryRejected(self): with pyfits.open(getAFITSPath()) as hdus: hdr = hdus[0].header fitstricks.addHistoryCard(hdr, "x"*61, "xxxxxxx") self.assertRaisesWithMsg(ValueError, "History entries must not exceed 61 characters.", fitstricks.addHistoryCard, (hdr, "x"*62, "xxxxx")) histCards = hdr["history"] self.assertEqual(len(histCards), 11) if __name__=="__main__": testhelpers.main(WCSFromHeaderTest)