Ejemplo n.º 1
0
#!/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")
Ejemplo n.º 2
0
        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")
Ejemplo n.º 3
0
#        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")
Ejemplo n.º 4
0
            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")
Ejemplo n.º 5
0
    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()
Ejemplo n.º 6
0
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")
Ejemplo n.º 7
0
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")
Ejemplo n.º 8
0
#!/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")
Ejemplo n.º 9
0
        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")
Ejemplo n.º 10
0
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")
Ejemplo n.º 11
0
        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")
Ejemplo n.º 12
0
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")
Ejemplo n.º 13
0
#!/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")
Ejemplo n.º 14
0
    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")
Ejemplo n.º 15
0
                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")
Ejemplo n.º 16
0
        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")
Ejemplo n.º 17
0
        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")
Ejemplo n.º 18
0
            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")
Ejemplo n.º 19
0
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")
Ejemplo n.º 20
0
        # 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")
Ejemplo n.º 21
0
#        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")
Ejemplo n.º 22
0
#!/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")
Ejemplo n.º 23
0
        # 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")
Ejemplo n.º 24
0
#                     "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")
Ejemplo n.º 25
0
        # 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()

Ejemplo n.º 26
0
        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")