#!/usr/bin/python3 import dballe import unittest class TestVersion(unittest.TestCase): def test_version(self): version = dballe.__version__ if __name__ == "__main__": from testlib import main main("test-version")
ids = self.db.insert_data(data, False, True) attrs = dballe.Record() attrs["B33209"] = 98 self.db.attr_insert_data(ids["B12101"], attrs) data.update( rep_memo="synop", lat=0.0, lon=0.0, ident="#000000", level=(103, 2000), trange=(254, 0, 0), datetime=datetime.datetime(1005, 1, 1, 1, 1, 1), B12101=271.96) ids = self.db.insert_data(data, False, True) attrs = dballe.Record() attrs["B33209"] = 100 self.db.attr_insert_data(ids["B12101"], attrs) query = dballe.Record() out = io.StringIO() dbacsv.export(self.db, query, out) lines = out.getvalue().splitlines() self.assertEqual(lines[2], "1005-01-01 01:01:00,270.96,98") self.assertEqual(lines[3], "1005-01-01 01:01:01,271.96,100") if __name__ == "__main__": from testlib import main main("test_csv")
# self.assertEqual(info.var, "B01001") def testLookup(self): table = wreport.Vartable.get_bufr(master_table_version_number=24) info = table["B01001"] self.assertEqual(info.type, "integer") self.assertEqual(info.len, 3) self.assertEqual(info.unit, "NUMERIC") def testLookupMissing(self): table = wreport.Vartable.get_bufr(master_table_version_number=24) with self.assertRaises(KeyError): table["B63254"] # def testIterate(self): # table = wreport.Vartable("dballe") # selected = None # count = 0 # for entry in table: # if entry.var == "B12101": # selected = entry # count += 1 # self.assertGreater(count, 100) # self.assertEqual(count, len(table)) # self.assertIsNotNone(selected) if __name__ == "__main__": from testlib import main main("vartable")
decoded = list(fimp) self.assertEqual(sys.getrefcount(importer), 3) # importer, fimp, getrefcount self.assertEqual(sys.getrefcount(f), 4) # __enter__ result, f, fimp, getrefcount self.assertEqual(sys.getrefcount(importer), 3) # importer, fimp, getrefcount self.assertEqual(sys.getrefcount(f), 3) # f, fimp, getrefcount self.assertEqual(len(decoded), 1) def test_issue197(self): pathname = test_pathname("bufr/gts-acars-uk1.bufr") with dballe.File(pathname) as f: binmsg = next(f) importer = dballe.Importer("BUFR") msgs = importer.from_binary(binmsg) with msgs[0].query_data() as m: with self.assertRaises(RuntimeError) as e: m.data self.assertEqual( str(e.exception), "cannot access values on a cursor before or after iteration") if __name__ == "__main__": from testlib import main main("test-importer")
def test_max_phys_1_forward(self): self.rit.set_max_phys(1) # First physical record is a batch of 2 keys. eq(BPKEYS[:2], keyfrom(self.rit.forward)) def test_max_phys_1_reverse(self): self.rit.set_max_phys(1) # Last physical record is non-batch. eq(RBPKEYS[:1], keyfrom(self.rit.reverse)) def test_max_phys_2_forward(self): self.rit.set_max_phys(2) # First 2 records contain 3 keys. eq(BPKEYS[:3], keyfrom(self.rit.forward)) def test_max_phys_2_reverse(self): self.rit.set_max_phys(2) # Last 2 records contain 4 keys. eq(RBPKEYS[:4], keyfrom(self.rit.reverse)) def test_max_lo_non_batch(self): # Begin iteration from non-batch record. self.rit.set_lo('BB', closed=True) # Continue for 2 physical records (BB, BC, BD) self.rit.set_max_phys(2) eq(BPKEYS[2:5], keyfrom(self.rit.forward)) if __name__ == '__main__': testlib.main()
import dballe import unittest class TestBinaryMessage(unittest.TestCase): def test_create_full(self): msg = dballe.BinaryMessage(b"BUFR7777", "BUFR", offset=0, index=1, pathname="test.bufr") self.assertEqual(msg.encoding, "BUFR") self.assertEqual(msg.offset, 0) self.assertEqual(msg.index, 1) self.assertEqual(msg.pathname, "test.bufr") self.assertEqual(bytes(msg), b"BUFR7777") def test_create_minimal(self): msg = dballe.BinaryMessage(b"BUFR7777", "BUFR") self.assertEqual(msg.encoding, "BUFR") self.assertEqual(msg.offset, None) self.assertEqual(msg.index, None) self.assertEqual(msg.pathname, None) if __name__ == "__main__": from testlib import main main("test-binarymessage")
import wreport import unittest class Varinfo(unittest.TestCase): def testEmptyVarinfo(self): self.assertRaises(NotImplementedError, wreport.Varinfo) def testData(self): table = wreport.Vartable.get_bufr(master_table_version_number=24) info = table["B01001"] self.assertEqual(info.code, "B01001") self.assertEqual(info.desc, "WMO block number") self.assertEqual(info.unit, "NUMERIC") self.assertEqual(info.scale, 0) self.assertEqual(info.len, 3) self.assertEqual(info.bit_ref, 0) self.assertEqual(info.bit_len, 7) self.assertEqual(info.type, "integer") def testStringification(self): table = wreport.Vartable.get_bufr(master_table_version_number=24) info = table["B01001"] self.assertTrue(str(info).startswith("B01001")) self.assertTrue(repr(info).startswith("Varinfo('B01001")) if __name__ == "__main__": from testlib import main main("varinfo")
#!/usr/bin/python # coding: utf-8 from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals import dballe import unittest class Describe(unittest.TestCase): def testLevel(self): self.assertIn("surface", dballe.describe_level(1)) def testTrange(self): self.assertIn("Accumulation", dballe.describe_trange(1)) if __name__ == "__main__": from testlib import main main("test_core")
self.assertEqual(type(var.enq()), int) self.assertEqual(var.enq(), 1) var = wreport.Var(self.table["B05001"], 1.12345) self.assertEqual(type(var.enq()), float) self.assertEqual(var.enq(), 1.12345) var = wreport.Var(self.table["B01019"], "ciao") self.assertIsInstance(var.enq(), string_types) self.assertEqual(var.enq(), "ciao") def testGet(self): var = wreport.Var(self.table["B01001"]) self.assertIsNone(var.get()) self.assertIs(var.get("foo"), "foo") var = wreport.Var(self.table["B01001"], 1) self.assertIs(var.get(), 1) var = wreport.Var(self.table["B05001"], 1.12345) self.assertEqual(var.get(), 1.12345) var = wreport.Var(self.table["B01019"], "ciao") self.assertEqual(var.get(), "ciao") def testEq(self): var = wreport.Var(self.table["B01001"], 1) self.assertEqual(var, var) self.assertEqual(var, wreport.Var(self.table["B01001"], 1)) self.assertNotEqual(var, wreport.Var(self.table["B01001"], 2)) self.assertNotEqual(var, wreport.Var(self.table["B01002"], 1)) self.assertIsNot(var, None) self.assertIsNot(wreport.Var(self.table["B01001"]), None) if __name__ == "__main__": from testlib import main main("var")
from __future__ import print_function from __future__ import unicode_literals import wreport import unittest class Varinfo(unittest.TestCase): def testEmptyVarinfo(self): self.assertRaises(NotImplementedError, wreport.Varinfo) def testData(self): table = wreport.Vartable.get_bufr(master_table_version_number=24) info = table["B01001"] self.assertEqual(info.code, "B01001") self.assertEqual(info.desc, "WMO block number") self.assertEqual(info.unit, "NUMERIC") self.assertEqual(info.scale, 0) self.assertEqual(info.len, 3) self.assertEqual(info.bit_ref, 0) self.assertEqual(info.bit_len, 7) self.assertEqual(info.type, "integer") def testStringification(self): table = wreport.Vartable.get_bufr(master_table_version_number=24) info = table["B01001"] self.assertTrue(str(info).startswith("B01001")) self.assertTrue(repr(info).startswith("Varinfo('B01001")) if __name__ == "__main__": from testlib import main main("varinfo")
query = dballe.Record() query["rep_memo"] = "synop" vars = read(self.db.query_station_data(query), indexes, checkConflicts=True) self.assertEqual(sorted(vars.keys()), ["B01001", "B01002", "B01019"]) def testExportSyncAna(self): # Export some data indexes = (AnaIndex(), DateTimeIndex()) query = dballe.Record() query["rep_memo"] = 'synop' query["level"] = (1,) query["trange"] = (4, -21600, 0) vars = read(self.db.query_data(query), indexes, checkConflicts=True) self.assertEqual(sorted(vars.keys()), ["B13011"]) # Freeze all the indexes for i in range(len(indexes)): indexes[i].freeze() # Export the pseudoana data in sync with the data query.clear() query["rep_memo"] = "synop" anas = read(self.db.query_station_data(query), (indexes[0],), checkConflicts=True) self.assertEqual(sorted(anas.keys()), ["B01001", "B01002", "B01019"]) self.assertEqual(anas["B01001"].dims[0], vars["B13011"].dims[0]) if __name__ == "__main__": from testlib import main main("test_volnd")
from testlibmsg import MessageTestMixin class TestExporter(MessageTestMixin, unittest.TestCase): def test_create(self): msg = self.make_gts_acars_uk1_message() exporter = dballe.Exporter("BUFR") binmsg = exporter.to_binary(msg) self.assertEqual(binmsg[:4], b"BUFR") self.assertEqual(binmsg[-4:], b"7777") binmsg1 = exporter.to_binary([msg]) self.assertEqual(binmsg1, binmsg) binmsg2 = exporter.to_binary((msg, msg)) self.assertNotEqual(binmsg2, binmsg) self.assertEqual(binmsg2[:4], b"BUFR") self.assertEqual(binmsg2[-4:], b"7777") binmsg3 = exporter.to_binary((msg for i in range(2))) self.assertEqual(binmsg3, binmsg2) with self.assertRaises(ValueError): exporter.to_binary([]) if __name__ == "__main__": from testlib import main main("test-exporter")
#!/usr/bin/python3 import wreport import unittest class Wreport(unittest.TestCase): def test_convert_units(self): self.assertAlmostEqual(wreport.convert_units("K", "C", 273.15), 0.0, places=4) if __name__ == "__main__": from testlib import main main("wreport")
Station = dballe.DBStation def testCreateEmpty(self): t = self.assertContents((None, None, None, None, None)) self.assertIsNone(t.report) self.assertIsNone(t.id) self.assertIsNone(t.lat) self.assertIsNone(t.lon) self.assertIsNone(t.ident) def testCreatePartial(self): t = self.assertContents(("foo", 2, 3.0, 4.0, None)) self.assertEqual(t.report, "foo") self.assertEqual(t.id, 2) self.assertEqual(t.lat, 3.0) self.assertEqual(t.lon, 4.0) self.assertIsNone(t.ident) def testCreateFull(self): t = self.assertContents(("foo", 2, 3.0, 4.0, "bar")) self.assertEqual(t.report, "foo") self.assertEqual(t.id, 2) self.assertEqual(t.lat, 3.0) self.assertEqual(t.lon, 4.0) self.assertEqual(t.ident, "bar") if __name__ == "__main__": from testlib import main main("test-types")
with dballe.File(fd, "BUFR") as f: self.assertContents(f, pathname=r"^<_io\.BytesIO object at") def test_refcounting(self): file = dballe.File(self.pathname) self.assertEqual(sys.getrefcount(file), 2) # file, getrefcount with file as f: self.assertEqual(sys.getrefcount(file), 4) # file, __enter__ result, f, getrefcount self.assertEqual(sys.getrefcount(f), 4) # file, __enter__ result, f, getrefcount for msg in f: self.assertEqual( sys.getrefcount(f), 5 ) # file, __enter__ result, f, __iter__ result, getrefcount self.assertEqual(sys.getrefcount(msg), 2) # msg, getrefcount data = bytes(msg) self.assertEqual(sys.getrefcount(msg), 2) # msg, getrefcount self.assertEqual(sys.getrefcount(data), 2) # data, getrefcount self.assertEqual(sys.getrefcount(msg), 2) # msg, getrefcount self.assertEqual(sys.getrefcount(f), 4) # file, __enter__ result, f, getrefcount self.assertEqual(sys.getrefcount(file), 3) # file, f, _getrefcount self.assertEqual(sys.getrefcount(f), 3) # file, f, _getrefcount if __name__ == "__main__": from testlib import main main("test-file")
with importer.from_file(test_pathname("bufr/issue160.bufr")) as f: for msgs in f: for msg in msgs: for d in msg.query_station_data(): codes.append(d["var"]) self.assertCountEqual( codes, ("B01019", "B07030", "B07031", "B01194", "B04001", "B04002", "B04003", "B04004", "B04005", "B04006", "B05001", "B06001")) def test_issue213(self): importer = dballe.Importer("BUFR") count_msg = 0 count_data = 0 with importer.from_file( test_pathname("bufr/generic-onlystation.bufr")) as f: for msgs in f: for msg in msgs: count_msg += 1 for d in msg.query_data(): d["trange"] count_data += 1 self.assertEqual(count_msg, 1) self.assertEqual(count_data, 0) if __name__ == "__main__": from testlib import main main("test-message")
self.assertEqual(type(var.enq()), float) self.assertEqual(var.enq(), 1.12345) var = wreport.Var(self.table["B01019"], "ciao") self.assertIsInstance(var.enq(), string_types) self.assertEqual(var.enq(), "ciao") def testGet(self): var = wreport.Var(self.table["B01001"]) self.assertIsNone(var.get()) self.assertIs(var.get("foo"), "foo") var = wreport.Var(self.table["B01001"], 1) self.assertIs(var.get(), 1) var = wreport.Var(self.table["B05001"], 1.12345) self.assertEqual(var.get(), 1.12345) var = wreport.Var(self.table["B01019"], "ciao") self.assertEqual(var.get(), "ciao") def testEq(self): var = wreport.Var(self.table["B01001"], 1) self.assertEqual(var, var) self.assertEqual(var, wreport.Var(self.table["B01001"], 1)) self.assertNotEqual(var, wreport.Var(self.table["B01001"], 2)) self.assertNotEqual(var, wreport.Var(self.table["B01002"], 1)) self.assertIsNot(var, None) self.assertIsNot(wreport.Var(self.table["B01001"]), None) if __name__ == "__main__": from testlib import main main("var")
tr.attr_insert_data(ids["B12101"], attrs) data.update(rep_memo="synop", lat=0.0, lon=0.0, ident="#000000", level=(103, 2000), trange=(254, 0, 0), datetime=datetime.datetime(1005, 1, 1, 1, 1, 1), B12101=271.96) ids = tr.insert_data(data, False, True) attrs = {} attrs["B33209"] = 100 tr.attr_insert_data(ids["B12101"], attrs) out = io.StringIO() dbacsv.export(tr, {}, out) lines = out.getvalue().splitlines() self.assertEqual(lines[2], "1005-01-01 01:01:00,270.96,98") self.assertEqual(lines[3], "1005-01-01 01:01:01,271.96,100") class TestCSVV7(CSVMixin, unittest.TestCase): DB_FORMAT = "V7" if __name__ == "__main__": from testlib import main main("test-csv")
class XapianExplorerTestMixin: DEFAULT_EXPLORER_NAME = "test-explorer" def _explorer(self, name=None, *args, **kw): if name is not None and name.endswith(".json"): raise ValueError("Do not use .json extension in explorer name") return super()._explorer(name, *args, **kw) class DballeV7ExplorerXapianTest(XapianExplorerTestMixin, unittest.TestCase): DB_FORMAT = "V7" class DballeV7ExplorerJSONTest(JSONExplorerTestMixin, unittest.TestCase): DB_FORMAT = "V7" class DballeV7DBExplorerXapianTest(XapianExplorerTestMixin, DBExplorerTestMixin, unittest.TestCase): DB_FORMAT = "V7" class DballeV7DBExplorerJSONTest(JSONExplorerTestMixin, DBExplorerTestMixin, unittest.TestCase): DB_FORMAT = "V7" if __name__ == "__main__": from testlib import main main("test-explorer")
# query.settimerange(dballe.TimeRange(0,0,0)) vars = volnd.read( self.db.query_data(query), (volnd.AnaIndex(), volnd.NetworkIndex(), volnd.LevelIndex(), volnd.TimeRangeIndex()), ) # print "ana:", vars["B10004"].dims[0] # print "net:", vars["B10004"].dims[1] # print vars["B10004"] # rpy.r.print_(rconvert.vnddata_to_r(vars['B10004'])) # rpy.r.assign('pippo', rconvert.vnddata_to_r(vars['B10004'])) # rpy.r.save('pippo', file='/tmp/pippo') rconvert.volnd_save_to_r(vars, "/tmp/pippo") def test_bug1(self): # Second test case reported by Paolo query = dballe.Record() # query.setd("latmin", 10.) # query.setd("latmax", 60.) # query.setd("lonmin", -10.) # query.setd("lonmax", 40.) query["var"] = "B13011" vars = volnd.read(self.db.query_data(query), (volnd.AnaIndex(), volnd.DateTimeIndex()), checkConflicts=False) rconvert.volnd_save_to_r(vars, "/tmp/pippo") if __name__ == "__main__": from testlib import main main("test_rconvert")
#!/usr/bin/python3 import dballe import unittest class Describe(unittest.TestCase): def testLevel(self): self.assertIn("surface", dballe.describe_level(1)) def testTrange(self): self.assertIn("Accumulation", dballe.describe_trange(1)) if __name__ == "__main__": from testlib import main main("test_core")
# CREX with io.open(os.getenv("DBA_TESTDATA") + "/crex/test-synop0.crex", "rb") as fp: self.db.reset() self.assertEqual(self.db.load(fp, "CREX"), 1) # BUFR loaded as CREX yields no results with io.open(os.getenv("DBA_TESTDATA") + "/bufr/vad.bufr", "rb") as fp: self.db.reset() self.assertEqual(self.db.load(fp, "CREX"), 0) def testQueryVolnd(self): from testlib import fill_volnd self.db.reset() fill_volnd(self.db) query = dballe.Record() query["var"] = "B10004" query["datetime"] = datetime.datetime(2007, 1, 1, 0, 0, 0) reports = [] for cur in self.db.query_data(query): reports.append(cur["rep_memo"]) s = "synop" t = "temp" self.assertEqual(reports, [s, t, s, t, s, t, s, s, t, s, t]) if __name__ == "__main__": from testlib import main main("test_db")
# "mobile": 0, # "datetime": datetime.datetime(1945, 4, 25, 10, 0, 0), # "level": (10, 11, 15, 22), # "trange": (20, 111, 222), # "rep_memo": "synop", # "B01011": "test", # }, can_replace=True, can_add_stations=True) # tr2.insert_data({ # "lat": 12.34560, "lon": 76.54320, # "mobile": 0, # "datetime": datetime.datetime(1945, 4, 25, 10, 0, 0), # "level": (10, 11, 15, 22), # "trange": (20, 111, 222), # "rep_memo": "synop", # "B01011": "test", # }, can_replace=True, can_add_stations=True) class DballeV7Test(FullDBTestMixin, AttrTestMixin, unittest.TestCase): DB_FORMAT = "V7" class DballeV7TransactionTest(TransactionTestMixin, CommonDBTestMixin, AttrTestMixin, unittest.TestCase): DB_FORMAT = "V7" if __name__ == "__main__": from testlib import main main("test-db")
# input endpoints, and does not support the paging interface. service = client.connect(**self.opts.kwargs) count = len(service.inputs.list()) self.check_iterable(service.inputs, count) def test_jobs(self): # The Jobs REST API endpoint does not support the paging interface. service = client.connect(**self.opts.kwargs) count = len(service.jobs.list()) self.check_iterable(service.jobs, count) def test_loggers(self): service = client.connect(**self.opts.kwargs) self.check_collection(service.loggers) def test_messages(self): service = client.connect(**self.opts.kwargs) self.check_collection(service.messages) def test_roles(self): service = client.connect(**self.opts.kwargs) self.check_collection(service.roles) def test_users(self): service = client.connect(**self.opts.kwargs) self.check_collection(service.users) if __name__ == "__main__": testlib.main()
with self.db.transaction() as tr: # Export some data indexes = (AnaIndex(), DateTimeIndex()) query = {} query["rep_memo"] = 'synop' query["level"] = (1,) query["trange"] = (4, -21600, 0) vars = read(tr.query_data(query), indexes, checkConflicts=True) self.assertEqual(sorted(vars.keys()), ["B13011"]) # Freeze all the indexes for i in range(len(indexes)): indexes[i].freeze() # Export the pseudoana data in sync with the data query.clear() query["rep_memo"] = "synop" anas = read(tr.query_station_data(query), (indexes[0],), checkConflicts=True) self.assertEqual(sorted(anas.keys()), ["B01001", "B01002", "B01019"]) self.assertEqual(anas["B01001"].dims[0], vars["B13011"].dims[0]) class TestReadV7(ReadMixin, unittest.TestCase): DB_FORMAT = "V7" if __name__ == "__main__": from testlib import main main("test-volnd")