imas-python 0.1.dev1618__py3-none-any.whl

imas/test/test_ids_struct_array.py

@@ -0,0 +1,89 @@
+import logging
+import pprint
+from copy import deepcopy
+
+import pytest
+
+from imas.ids_factory import IDSFactory
+from imas.ids_struct_array import IDSStructArray
+
+
+@pytest.fixture
+def struct_array(fake_filled_toplevel) -> IDSStructArray:
+    struct_array = fake_filled_toplevel.wavevector
+    struct_array.resize(3)
+    assert len(struct_array.value) == 3
+    return struct_array
+
+
+@pytest.mark.parametrize("keep", (True, False))
+@pytest.mark.parametrize("target_len", (1, 3, 7))
+def test_resize(keep, target_len, struct_array):
+    pre_struct_array_len = len(struct_array)
+    pre_struct_array = deepcopy(struct_array)
+    n_comp_values = min(target_len, pre_struct_array_len)
+    pre_values = [struct_array[ii] for ii in range(n_comp_values)]
+
+    # Test if resize works for 3->1, 3->3, and 3->7
+    struct_array.resize(target_len, keep=keep)
+
+    # Test if internal data is the right length
+    assert len(struct_array) == target_len
+
+    # Test if internal data is explicitly new (keep = False) or
+    # explicitly kept (keep = True)
+    for ii in range(n_comp_values):
+        if keep:
+            assert (
+                struct_array[ii] is pre_values[ii]
+            ), f"On element {ii} of {struct_array.value} vs {pre_struct_array.value}"
+        else:
+            assert (
+                struct_array[ii] is not pre_values[ii]
+            ), f"On element {ii} of {struct_array.value} vs {pre_struct_array.value}"
+
+
+def test_pretty_print(struct_array):
+    assert (
+        pprint.pformat(struct_array)
+        == "<IDSStructArray (IDS:gyrokinetics, wavevector with 3 items)>"
+    )
+
+
+def test_path_non_indexable_parent(caplog, fake_filled_toplevel):
+    top = fake_filled_toplevel
+    top.wavevector.resize(1)
+    wv = top.wavevector[0]
+    with caplog.at_level(logging.WARNING):
+        assert wv._path == "wavevector[0]"
+        for record in caplog.records:
+            assert record.levelname != "WARNING"
+
+    # Remove the referenced profiles_1d from its parent
+    top.wavevector.resize(0)
+
+    # Check if singular warning is raised
+    with caplog.at_level(logging.WARNING):
+        assert wv._path == "wavevector[?]"
+        assert len(caplog.records) == 1
+        assert caplog.records[0].levelname == "WARNING"
+
+
+def test_struct_array_eq():
+    cp1 = IDSFactory("3.39.0").core_profiles()
+    cp2 = IDSFactory("3.39.0").core_profiles()
+
+    assert cp1.profiles_1d != 1
+    assert cp1.profiles_1d != "profiles_1d"
+
+    assert cp1.profiles_1d == cp2.profiles_1d
+    cp1.profiles_1d.resize(1)
+    assert cp1.profiles_1d != cp2.profiles_1d
+    cp2.profiles_1d.resize(2)
+    assert cp1.profiles_1d != cp2.profiles_1d
+    cp1.profiles_1d.resize(2)
+    assert cp1.profiles_1d == cp2.profiles_1d
+    cp1.profiles_1d[0].time = 1
+    assert cp1.profiles_1d != cp2.profiles_1d
+    cp2.profiles_1d[0].time = 1
+    assert cp1.profiles_1d == cp2.profiles_1d

imas/test/test_ids_structure.py

@@ -0,0 +1,70 @@
+# This file is part of imas-python.
+# You should have received the imas-python LICENSE file with this project.
+import copy
+import pprint
+
+import pytest
+
+from imas.ids_factory import IDSFactory
+from imas.ids_structure import IDSStructure
+
+
+@pytest.fixture
+def structure(fake_filled_toplevel) -> IDSStructure:
+    yield fake_filled_toplevel.ids_properties
+
+
+def test_pretty_print(structure):
+    assert (
+        pprint.pformat(structure) == "<IDSStructure (IDS:gyrokinetics, ids_properties)>"
+    )
+
+
+def test_dict_like_access(fake_filled_toplevel):
+    assert fake_filled_toplevel["ids_properties"] is fake_filled_toplevel.ids_properties
+    node = fake_filled_toplevel.ids_properties.provenance.node
+    assert fake_filled_toplevel["ids_properties/provenance/node"] is node
+    node.resize(1)
+    assert fake_filled_toplevel["ids_properties/provenance/node[0]"] is node[0]
+    assert fake_filled_toplevel["ids_properties/provenance/node[0]"] is node[0]
+    path = node[0].path
+    assert fake_filled_toplevel["ids_properties/provenance/node[0]/path"] is path
+
+
+def test_dict_like_setitem():
+    cp = IDSFactory("3.39.0").core_profiles()
+
+    cp["time"] = [1, 2, 3]
+    assert cp.time[0] == 1, cp.time[2] == 3
+
+    cp["ids_properties/homogeneous_time"] = 1
+    assert cp.ids_properties.homogeneous_time == 1
+
+    provenance_copy = copy.deepcopy(cp.ids_properties.provenance)
+    provenance_copy.node.resize(1)
+    provenance_copy.node[0].path = "test"
+    cp["ids_properties/provenance/node"] = provenance_copy.node
+
+
+def test_structure_eq():
+    cp1 = IDSFactory("3.39.0").core_profiles()
+    cp2 = IDSFactory("3.39.0").core_profiles()
+
+    assert cp1 != 1
+    assert cp1 != "1"
+    assert cp1 != cp1.time
+
+    assert cp1 == cp2
+    assert cp1.ids_properties == cp2.ids_properties
+    cp1.ids_properties.comment = "x"
+    assert cp1 != cp2
+    assert cp1.ids_properties != cp2.ids_properties
+    cp2.ids_properties.comment = "x"
+    assert cp1 == cp2
+    assert cp1.ids_properties == cp2.ids_properties
+    cp2.ids_properties.homogeneous_time = 1
+    assert cp1 != cp2
+    assert cp1.ids_properties != cp2.ids_properties
+    cp1.ids_properties.homogeneous_time = 1
+    assert cp1 == cp2
+    assert cp1.ids_properties == cp2.ids_properties

imas/test/test_ids_toplevel.py

@@ -0,0 +1,55 @@
+"""A testcase checking higher-level IDSToplevel features with a fake
+constant-in-time DD
+"""
+
+import pprint
+from pathlib import Path
+
+import pytest
+
+from imas.ids_factory import IDSFactory
+from imas.ids_toplevel import IDSToplevel
+from imas.test.test_helpers import compare_children, fill_with_random_data
+
+
+@pytest.fixture
+def ids(fake_toplevel_xml: Path):
+    return IDSFactory(xml_path=fake_toplevel_xml).new("gyrokinetics")
+
+
+def test_toplevel_init(ids):
+    assert isinstance(ids, IDSToplevel)
+
+
+def test_structure_xml_noncopy(ids):
+    assert id(list(ids.metadata._structure_xml)[0].attrib) == id(
+        ids.ids_properties.metadata._structure_xml.attrib
+    )
+
+
+def test_metadata_lifecycle_status(ids):
+    assert ids.metadata.lifecycle_status == "alpha"
+    assert ids.wavevector.metadata.structure_reference == "gyrokinetics_wavevector"
+
+
+def test_metadata_non_exist(ids):
+    with pytest.raises(AttributeError):
+        ids.wavevector.metadata.lifecycle_status
+
+
+def test_metadata_attribute_not_exists(ids):
+    with pytest.raises(AttributeError):
+        ids.metadata.blergh
+
+
+def test_pretty_print(ids):
+    assert pprint.pformat(ids) == "<IDSToplevel (IDS:gyrokinetics)>"
+
+
+def test_serialize_nondefault_dd_version():
+    ids = IDSFactory("3.31.0").core_profiles()
+    fill_with_random_data(ids)
+    data = ids.serialize()
+    ids2 = IDSFactory("3.31.0").core_profiles()
+    ids2.deserialize(data)
+    compare_children(ids, ids2)

imas/test/test_ids_validate.py

@@ -0,0 +1,343 @@
+import logging
+from unittest.mock import Mock
+
+import numpy as np
+import pytest
+
+from imas import DBEntry, IDSFactory
+from imas.exception import ValidationError
+from imas.ids_defs import (
+    IDS_TIME_MODE_HETEROGENEOUS,
+    IDS_TIME_MODE_HOMOGENEOUS,
+    IDS_TIME_MODE_INDEPENDENT,
+    MEMORY_BACKEND,
+)
+from imas.test.test_helpers import fill_consistent
+
+
+@pytest.fixture(autouse=True)
+def raise_on_logged_warnings(caplog):
+    """Catch warnings logged by validate() and fail the testcase if there are any."""
+    yield
+    records = [
+        rec for rec in caplog.get_records("call") if rec.levelno >= logging.WARNING
+    ]
+    if records:
+        pytest.fail(f"Warning(s) encountered during test: {records}")
+
+
+def test_validate_time_mode():
+    cp = IDSFactory().core_profiles()
+    with pytest.raises(ValidationError):
+        cp.validate()
+
+    for time_mode in [
+        IDS_TIME_MODE_HOMOGENEOUS,
+        IDS_TIME_MODE_HETEROGENEOUS,
+        IDS_TIME_MODE_INDEPENDENT,
+    ]:
+        cp.ids_properties.homogeneous_time = time_mode
+        cp.validate()
+
+
+def test_validate_time_coordinate_homogeneous():
+    cp = IDSFactory("3.39.0").core_profiles()
+    cp.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    cp.time = np.array([1.0, 2.0])
+    cp.profiles_1d.resize(2)
+    cp.validate()
+
+    cp.profiles_1d.resize(3)
+    with pytest.raises(ValidationError):
+        # non-matching size
+        cp.validate()
+
+
+def test_validate_time_coordinate_heterogeneous_core_profiles():
+    cp = IDSFactory("3.39.0").core_profiles()
+    cp.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
+    cp.profiles_1d.resize(2)
+    with pytest.raises(ValidationError):
+        cp.validate()  # Unset cp.profiles_1d.time
+    cp.profiles_1d[0].time = 1.0
+    with pytest.raises(ValidationError):
+        cp.validate()  # Unset cp.profiles_1d.time
+    cp.profiles_1d[1].time = 2.0
+    cp.validate()
+
+
+def test_validate_time_mode_heterogeneous_pf_active():
+    pfa = IDSFactory("3.39.0").pf_active()
+    pfa.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
+    pfa.coil.resize(1)
+    pfa.coil[0].current.data = np.linspace(0, 1, 10)
+    with pytest.raises(ValidationError):
+        pfa.validate()
+    pfa.coil[0].current.time = np.linspace(0, 1, 9)  # one too short
+    with pytest.raises(ValidationError):
+        pfa.validate()
+    pfa.coil[0].current.time = np.linspace(0, 1, 10)
+    pfa.validate()
+
+    pfa.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    with pytest.raises(ValidationError):
+        pfa.validate()
+    pfa.time = np.linspace(0, 1, 10)
+    pfa.validate()
+
+
+def test_validate_time_mode_independent():
+    cp = IDSFactory("3.39.0").core_profiles()
+    cp.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    cp.validate()
+    cp.profiles_1d.resize(1)
+    with pytest.raises(ValidationError):
+        cp.validate()
+
+
+def test_fixed_size_coordinates_two():
+    mag = IDSFactory("3.39.0").magnetics()
+    mag.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    mag.b_field_pol_probe.resize(1)
+    mag.validate()
+    for bandwidth_size in [0, 1, 2, 3, 4, 1000]:
+        mag.b_field_pol_probe[0].bandwidth_3db = np.linspace(0, 1, bandwidth_size)
+        if bandwidth_size in (0, 2):
+            mag.validate()
+        else:  # coordinate1 = 1...2, so only size 0 or 2 is allowed
+            with pytest.raises(ValidationError):
+                mag.validate()
+
+
+def test_fixed_size_coordinates_three():
+    wall = IDSFactory("3.39.0").wall()
+    wall.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    wall.time = np.linspace(0, 1, 10)
+    wall.global_quantities.electrons.particle_flux_from_wall = np.ones((3, 10))
+    wall.validate()
+    for size in [1, 2, 4, 5]:
+        wall.global_quantities.electrons.particle_flux_from_wall = np.ones((size, 10))
+        with pytest.raises(ValidationError):
+            wall.validate()
+
+
+def test_validate_indirect_coordinates():
+    """Test indirect coordinates like
+    coordinate1=coordinate_system(process(i1)/coordinate_index)/coordinate(1)
+    """
+    amns = IDSFactory("3.39.0").amns_data()
+    amns.ids_properties.homogeneous_time = IDS_TIME_MODE_INDEPENDENT
+    amns.process.resize(1)
+    amns.process[0].charge_state.resize(1)
+    amns.process[0].charge_state[0].table_1d = np.ones(10)
+    with pytest.raises(ValidationError):
+        # unset amns.process[0].coordinate_index
+        amns.validate()
+
+    # create some coordinate systems
+    amns.coordinate_system.resize(3)
+    for i in range(3):
+        amns.coordinate_system[i].coordinate.resize(6)
+        for j in range(6):
+            amns.coordinate_system[i].coordinate[j].label = f"label_{i}_{j}"
+            values = np.linspace(0, 1, 1 + i + j)
+            amns.coordinate_system[i].coordinate[j].values = values
+
+    amns.process[0].coordinate_index = 1
+    amns.process[0].charge_state[0].table_1d = np.ones(1)
+    amns.validate()
+
+    for i in range(6):
+        shape = [1, 2, 3, 4, 5, 6]
+        shape[i] = shape[i] + 1
+        amns.process[0].charge_state[0].table_6d = np.ones(shape)
+        with pytest.raises(ValidationError):
+            amns.validate()
+    amns.process[0].charge_state[0].table_6d = np.ones((1, 2, 3, 4, 5, 6))
+    amns.validate()
+
+    amns.process[0].coordinate_index = 3
+    with pytest.raises(ValidationError):
+        amns.validate()
+    amns.process[0].charge_state[0].table_1d = np.ones(3)
+    amns.process[0].charge_state[0].table_6d = np.ones((3, 4, 5, 6, 7, 8))
+    amns.validate()
+
+
+def test_validate_exclusive_references():
+    distr = IDSFactory("3.39.0").distributions()
+    distr.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    distr.time = np.array([1.0])
+    distr.distribution.resize(1)
+    distr.distribution[0].profiles_2d.resize(1)
+    distr.distribution[0].profiles_2d[0].density = np.ones((2, 3))
+    with pytest.raises(ValidationError):
+        distr.validate()
+
+    distr.distribution[0].profiles_2d[0].grid.r = np.linspace(0, 1, 2)
+    distr.distribution[0].profiles_2d[0].grid.z = np.linspace(0, 1, 3)
+    distr.validate()
+
+    distr.distribution[0].profiles_2d[0].grid.rho_tor_norm = np.linspace(0, 1, 2)
+    with pytest.raises(ValidationError):
+        distr.validate()  # either grid/r or grid/rho_tor_norm can be defined
+
+    distr.distribution[0].profiles_2d[0].grid.r = np.array([])
+    distr.validate()
+
+
+def test_validate_reference_or_fixed_size():
+    waves = IDSFactory("3.39.0").waves()
+    waves.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    waves.time = np.array([1.0])
+    waves.coherent_wave.resize(1)
+    waves.coherent_wave[0].beam_tracing.resize(1)
+    waves.coherent_wave[0].beam_tracing[0].beam.resize(1)
+    waves.validate()
+
+    beam = waves.coherent_wave[0].beam_tracing[0].beam[0]
+    # n_tor coordinate1=beam.length OR 1...1
+    beam.wave_vector.n_tor = np.array([1], dtype=np.int32)
+    waves.validate()
+    beam.wave_vector.n_tor = np.array([1, 2], dtype=np.int32)
+    with pytest.raises(ValidationError):
+        waves.validate()  # beam.length has length 0
+    beam.length = np.array([0.4, 0.5])
+    waves.validate()
+
+
+def test_validate_coordinate_same_as():
+    ml = IDSFactory("3.39.0").mhd_linear()
+    ml.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    ml.time = np.array([1.0])
+    ml.time_slice.resize(1)
+    ml.validate()
+
+    ml.time_slice[0].toroidal_mode.resize(1)
+    tor_mode = ml.time_slice[0].toroidal_mode[0]
+    tor_mode.plasma.grid.dim1 = np.ones(4)
+    tor_mode.plasma.stress_maxwell.imaginary = np.ones((4, 5, 6))
+    with pytest.raises(ValidationError):
+        # The imaginary component has coordinate2/3_same_as the real component
+        # but the real component is still empty
+        ml.validate()
+
+    tor_mode.plasma.stress_maxwell.real = np.ones((4, 5, 6))
+    ml.validate()
+
+    tor_mode.plasma.stress_maxwell.real = np.ones((4, 1, 6))
+    with pytest.raises(ValidationError):
+        ml.validate()  # dimension 2 does not match
+
+    tor_mode.plasma.stress_maxwell.real = np.ones((4, 5, 1))
+    with pytest.raises(ValidationError):
+        ml.validate()  # dimension 3 does not match
+
+
+@pytest.mark.parametrize(
+    "env_value, should_validate",
+    [
+        ("1", False),
+        ("yes", False),
+        ("asdf", False),
+        ("0", True),
+        ("", True),
+        (None, True),
+    ],
+)
+def test_validate_on_put(monkeypatch, env_value, should_validate, requires_imas):
+    dbentry = DBEntry(MEMORY_BACKEND, "test", 1, 1)
+    dbentry.create()
+    ids = dbentry.factory.core_profiles()
+    ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    ids.time = np.array([1.0])
+
+    validate_mock = Mock()
+    monkeypatch.setattr("imas.ids_toplevel.IDSToplevel.validate", validate_mock)
+    if env_value is None:
+        monkeypatch.delenv("IMAS_AL_DISABLE_VALIDATE", raising=False)
+    else:
+        monkeypatch.setenv("IMAS_AL_DISABLE_VALIDATE", env_value)
+
+    dbentry.put(ids)
+    assert validate_mock.call_count == 1 * should_validate
+    dbentry.put_slice(ids)
+    assert validate_mock.call_count == 2 * should_validate
+
+
+def test_validate_ignore_nested_aos():
+    # Ignore coordinates inside an AoS outside our tree, see IMAS-4675
+    equilibrium = IDSFactory("3.39.0").equilibrium()
+    equilibrium.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    equilibrium.time = np.array([1.0])
+    equilibrium.time_slice.resize(1)
+    equilibrium.validate()
+    equilibrium.time_slice[0].ggd.resize(1)
+    # Coordinate of equilibrium time_slice(itime)/ggd = grids_ggd(itime)/grid
+    # where grids_ggd is a (dynamic) AoS outside our tree, so this coordinate check
+    # should be ignored:
+    equilibrium.validate()
+
+
+@pytest.fixture
+def alternative_coordinates_cp():
+    """Test alternative coordinates introduced in DDv4 with IMAS-4725."""
+    cp = IDSFactory("4.0.0").new("core_profiles")
+    cp.ids_properties.homogeneous_time = IDS_TIME_MODE_HETEROGENEOUS
+    cp.profiles_1d.resize(1)
+    cp.profiles_1d[0].time = 1.0
+    cp.validate()
+    return cp
+
+
+# Alternatives for core_profiles profiles_1d/grid/rho_tor_norm
+ALTERNATIVES = ["rho_tor_norm", "rho_tor", "psi", "volume", "area", "surface"]
+ALTERNATIVES += ["rho_pol_norm"]
+
+
+@pytest.fixture(params=ALTERNATIVES)
+def alternative(request):
+    return request.param
+
+
+def test_single_alternative_coordinate_filled(alternative_coordinates_cp, alternative):
+    alternative_coordinates_cp.profiles_1d[0].grid[alternative] = np.ones(3)
+    alternative_coordinates_cp.validate()
+
+
+def test_multiples_alternative_coordinates_filled(alternative_coordinates_cp):
+    grid = alternative_coordinates_cp.profiles_1d[0].grid
+    grid.rho_tor_norm = np.ones(3)
+    grid.rho_tor = np.ones(2)
+    with pytest.raises(ValidationError):
+        alternative_coordinates_cp.validate()  # sizes don't match
+    grid.rho_tor = np.ones(3)
+    alternative_coordinates_cp.validate()  # now they match again
+
+    # Add a third one
+    grid.volume = np.ones(5)
+    with pytest.raises(ValidationError):
+        alternative_coordinates_cp.validate()  # sizes don't match
+    grid.volume = np.ones(3)
+    alternative_coordinates_cp.validate()  # now they match again
+
+
+def test_validate_with_alternative_coordinates(alternative_coordinates_cp, alternative):
+    grid = alternative_coordinates_cp.profiles_1d[0].grid
+    alternative_coordinates_cp.profiles_1d[0].electrons.temperature = np.ones(4)
+    with pytest.raises(ValidationError):
+        alternative_coordinates_cp.validate()  # no coordinates allocated
+
+    # Set to wrong size:
+    grid[alternative] = np.ones(3)
+    with pytest.raises(ValidationError):
+        alternative_coordinates_cp.validate()
+    # Now set to correct size
+    grid[alternative] = np.ones(4)
+    alternative_coordinates_cp.validate()
+
+
+def test_validate_random_fill(ids_name):
+    ids = IDSFactory().new(ids_name)
+    fill_consistent(ids)
+    ids.validate()

imas/test/test_latest_dd_autofill.py

@@ -0,0 +1,74 @@
+"""A testcase checking if writing and then reading works for the latest full
+data dictionary version.
+"""
+
+import copy
+
+import pytest
+
+from imas.ids_defs import (
+    ASCII_SERIALIZER_PROTOCOL,
+    FLEXBUFFERS_SERIALIZER_PROTOCOL,
+    MEMORY_BACKEND,
+)
+from imas.ids_factory import IDSFactory
+from imas.test.test_helpers import (
+    compare_children,
+    fill_with_random_data,
+    open_dbentry,
+)
+from imas.util import visit_children
+
+
+def test_latest_dd_autofill_consistency(ids_name):
+    ids = IDSFactory().new(ids_name)
+    fill_with_random_data(ids)
+
+    # check that each element in ids has _parent set.
+    visit_children(has_parent, ids, leaf_only=False)
+
+
+def has_parent(child):
+    """Check that the child has _parent set"""
+    assert child._parent is not None
+
+
+def test_latest_dd_autofill(ids_name, backend, worker_id, tmp_path):
+    """Write and then read again all IDSToplevels."""
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path)
+    ids = IDSFactory().new(ids_name)
+    fill_with_random_data(ids)
+
+    dbentry.put(ids)
+    ids_ref = copy.deepcopy(ids)
+    # the deepcopy comes after the put() since that updates dd version and AL lang
+
+    dbentry2 = open_dbentry(backend, "a", worker_id, tmp_path)
+    ids = dbentry2.get(ids_name)
+    compare_children(ids, ids_ref)
+
+    dbentry.close()
+    if backend != MEMORY_BACKEND:  # MEM backend already cleaned up, prevent SEGFAULT
+        dbentry2.close()
+
+
+@pytest.mark.parametrize(
+    "serializer", [ASCII_SERIALIZER_PROTOCOL, FLEXBUFFERS_SERIALIZER_PROTOCOL]
+)
+def test_latest_dd_autofill_serialize(serializer, ids_name, has_imas):
+    """Serialize and then deserialize again all IDSToplevels"""
+    if serializer is None:
+        pytest.skip("Unsupported serializer")
+
+    factory = IDSFactory()
+    ids = factory.new(ids_name)
+    fill_with_random_data(ids)
+
+    if not has_imas:
+        return  # rest of the test requires an IMAS install
+    data = ids.serialize(serializer)
+
+    ids2 = factory.new(ids_name)
+    ids2.deserialize(data)
+
+    compare_children(ids, ids2)

imas/test/test_latest_dd_manual.py

@@ -0,0 +1,38 @@
+"""A testcase checking if writing and then reading works for the latest full
+data dictionary version.
+"""
+
+from imas.ids_defs import IDS_TIME_MODE_HOMOGENEOUS, MEMORY_BACKEND
+from imas.ids_factory import IDSFactory
+from imas.test.test_helpers import open_dbentry
+
+
+def test_latest_dd_manual(backend, worker_id, tmp_path):
+    """Write and then read again a single IDSToplevel."""
+    dbentry = open_dbentry(backend, "w", worker_id, tmp_path)
+    ids_name = "pulse_schedule"
+    ids = IDSFactory().new(ids_name)
+    ids.ids_properties.homogeneous_time = IDS_TIME_MODE_HOMOGENEOUS
+    ids.ids_properties.comment = "test"
+
+    assert ids.ids_properties.comment.value == "test"
+
+    dbentry.put(ids)
+
+    dbentry2 = open_dbentry(backend, "a", worker_id, tmp_path)
+    ids2 = dbentry2.get(ids_name)
+    assert ids2.ids_properties.comment.value == "test"
+
+    dbentry.close()
+    if backend != MEMORY_BACKEND:  # MEM backend already cleaned up, prevent SEGFAULT
+        dbentry2.close()
+
+
+def test_dir():
+    """Test calling `dir()` on `IDSFactory` to test if we can see IDSes"""
+    factory = IDSFactory()
+    f_dir = dir(factory)
+    # Check if we can see the first and last stable IDS
+    assert "amns_data" in f_dir, "Could not find amns_data in dir(IDSFactory())"
+    assert "workflow" in f_dir, "Could not find workflow in dir(IDSFactory())"
+    assert "__init__" in f_dir, "Could not find base attributes in dir(IDSFactory())"