test error messages

janosh · janosh · commit 56b4936ccc38 · 2023-07-02T13:32:19.000-07:00
diff --git a/pymatgen/analysis/tests/test_structure_matcher.py b/pymatgen/analysis/tests/test_structure_matcher.py
@@ -580,7 +580,7 @@ def test_get_mapping(self):
         # s2 is smaller than s1
         del s2[0]
         del s2[1]
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="subset is larger than superset"):
             sm.get_mapping(s2, s1)
 
     def test_get_supercell_matrix(self):
diff --git a/pymatgen/analysis/xas/tests/test_spectrum.py b/pymatgen/analysis/xas/tests/test_spectrum.py
@@ -78,7 +78,7 @@ def test_validate(self):
             )
 
     def test_stitch_xafs(self):
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="Invalid mode. Only XAFS and L23 are supported"):
             XAS.stitch(self.k_xanes, self.k_exafs, mode="invalid")
         xafs = XAS.stitch(self.k_xanes, self.k_exafs, mode="XAFS")
         assert isinstance(xafs, XAS)
@@ -110,7 +110,7 @@ def test_stitch_l23(self):
         assert np.greater_equal(l23.y, self.l2_xanes.y).all()
         assert len(l23.x) == 100
         self.l2_xanes.spectrum_type = "EXAFS"
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="Only XANES spectrum can be stitched in L23 mode"):
             XAS.stitch(self.l2_xanes, self.l3_xanes, mode="L23")
         self.l2_xanes.absorbing_element = Element("Pt")
         with pytest.raises(ValueError, match="The absorbing elements for spectra are different"):
diff --git a/pymatgen/apps/battery/tests/test_analyzer.py b/pymatgen/apps/battery/tests/test_analyzer.py
@@ -22,10 +22,10 @@ def load_from_internal(self, name, oxidations, working_ion="Li"):
         return BatteryAnalyzer(struct, working_ion)
 
     def setUp(self):
-        self.lifepo4 = self.load_from_internal("LiFePO4", {"Li": 1, "Fe": 2, "P": 5, "O": -2})
-        self.nafepo4 = self.load_from_internal("NaFePO4", {"Na": 1, "Fe": 2, "P": 5, "O": -2}, working_ion="Na")
+        self.li_fe_p_o4 = self.load_from_internal("LiFePO4", {"Li": 1, "Fe": 2, "P": 5, "O": -2})
+        self.na_fe_p_o4 = self.load_from_internal("NaFePO4", {"Na": 1, "Fe": 2, "P": 5, "O": -2}, working_ion="Na")
         self.la2coo4f = self.load_from_internal("La2CoO4F", {"La": 3, "Co": 3, "O": -2, "F": -1}, working_ion="F")
-        self.fepo4 = self.load_from_cif("FePO4a.cif", {"Fe": 3, "P": 5, "O": -2})
+        self.fe_p_o4 = self.load_from_cif("FePO4a.cif", {"Fe": 3, "P": 5, "O": -2})
         self.la2coo4 = self.load_from_cif("La2CoO4.cif", {"La": 3, "Co": 2, "O": -2}, working_ion="F")
         self.lifemnpo4 = self.load_from_cif("Li4Fe3Mn1(PO4)4.cif", {"Li": 1, "Fe": 2, "Mn": 2, "P": 5, "O": -2})
         self.li8nicofe208 = self.load_from_cif(
@@ -34,55 +34,55 @@ def setUp(self):
         self.li3v2p3o12 = self.load_from_internal("Li3V2(PO4)3", {"Li": 1, "V": 3, "O": -2, "P": 5})
         self.mgnif6 = self.load_from_cif("MgNiF6.cif", {"Mg": 2, "Ni": 4, "F": -1}, working_ion="F")
 
-    def test_oxid_check(self):
+    def test_oxide_check(self):
         struct = self.get_structure("LiFePO4")
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="BatteryAnalyzer requires oxidation states assigned to structure"):
             BatteryAnalyzer(struct, "Li")
 
     def test_capacitygrav_calculations(self):
-        lifepo4_cap = 169.89053  # same as fepo4 cap
-        nafepo4_cap = 154.20331
-        la2coo4f_cap = 175.6564
-        li3v2p3o12_cap_remove = 197.25339
-        li3v2p3o12_cap_insert = 127.17129
+        li_fe_p_o4_cap = 169.89053  # same as fe_po4 cap
+        na_fe_p_o4_cap = 154.20331
+        la2_co_o4_f_cap = 175.6564
+        li3_v2_p3_o12_cap_remove = 197.25339
+        li3_v2_p3_o12_cap_insert = 127.17129
 
-        assert self.lifepo4.get_max_capgrav() == approx(lifepo4_cap, abs=1e-3)
-        assert self.lifepo4.get_max_capgrav(remove=False) == 0
-        assert self.lifepo4.get_max_capgrav(insert=False) == approx(lifepo4_cap, abs=1e-3)
+        assert self.li_fe_p_o4.get_max_capgrav() == approx(li_fe_p_o4_cap, abs=1e-3)
+        assert self.li_fe_p_o4.get_max_capgrav(remove=False) == 0
+        assert self.li_fe_p_o4.get_max_capgrav(insert=False) == approx(li_fe_p_o4_cap, abs=1e-3)
 
-        assert self.nafepo4.get_max_capgrav() == approx(nafepo4_cap, abs=1e-3)
-        assert self.nafepo4.get_max_capgrav(remove=False) == 0
+        assert self.na_fe_p_o4.get_max_capgrav() == approx(na_fe_p_o4_cap, abs=1e-3)
+        assert self.na_fe_p_o4.get_max_capgrav(remove=False) == 0
 
-        assert self.fepo4.get_max_capgrav() == approx(lifepo4_cap, abs=1e-3)
-        assert self.fepo4.get_max_capgrav(insert=False) == 0
+        assert self.fe_p_o4.get_max_capgrav() == approx(li_fe_p_o4_cap, abs=1e-3)
+        assert self.fe_p_o4.get_max_capgrav(insert=False) == 0
 
-        assert self.la2coo4f.get_max_capgrav() == approx(la2coo4f_cap, abs=1e-3)
-        assert self.la2coo4.get_max_capgrav() == approx(la2coo4f_cap, abs=1e-3)
+        assert self.la2coo4f.get_max_capgrav() == approx(la2_co_o4_f_cap, abs=1e-3)
+        assert self.la2coo4.get_max_capgrav() == approx(la2_co_o4_f_cap, abs=1e-3)
         assert self.la2coo4.get_max_capgrav(insert=False) == 0
 
-        assert self.li3v2p3o12.get_max_capgrav(insert=False) == approx(li3v2p3o12_cap_remove, abs=1e-3)
-        assert self.li3v2p3o12.get_max_capgrav(remove=False) == approx(li3v2p3o12_cap_insert, abs=1e-3)
+        assert self.li3v2p3o12.get_max_capgrav(insert=False) == approx(li3_v2_p3_o12_cap_remove, abs=1e-3)
+        assert self.li3v2p3o12.get_max_capgrav(remove=False) == approx(li3_v2_p3_o12_cap_insert, abs=1e-3)
 
     def test_capacityvol_calculations(self):
-        lifepo4_cap = 594.17518
-        nafepo4_cap = 542.86104
+        li_fe_p_o4_cap = 594.17518
+        na_fe_p_o4_cap = 542.86104
 
-        fepo4_cap = 624.82289  # this is different than lifepo4 cap if lifepo4 volume not known
+        fe_p_o4_cap = 624.82289  # this is different than li_fe_p_o4_cap cap if li_fe_p_o4 volume not known
 
-        assert self.lifepo4.get_max_capvol() == approx(lifepo4_cap, abs=1e-3)
-        assert self.lifepo4.get_max_capvol(remove=False) == 0
-        assert self.lifepo4.get_max_capvol(insert=False) == approx(lifepo4_cap, abs=1e-3)
+        assert self.li_fe_p_o4.get_max_capvol() == approx(li_fe_p_o4_cap, abs=1e-3)
+        assert self.li_fe_p_o4.get_max_capvol(remove=False) == 0
+        assert self.li_fe_p_o4.get_max_capvol(insert=False) == approx(li_fe_p_o4_cap, abs=1e-3)
 
-        assert self.nafepo4.get_max_capvol() == approx(nafepo4_cap, abs=1e-3)
-        assert self.nafepo4.get_max_capvol(remove=False) == 0
-        assert self.nafepo4.get_max_capvol(insert=False) == approx(nafepo4_cap, abs=1e-3)
+        assert self.na_fe_p_o4.get_max_capvol() == approx(na_fe_p_o4_cap, abs=1e-3)
+        assert self.na_fe_p_o4.get_max_capvol(remove=False) == 0
+        assert self.na_fe_p_o4.get_max_capvol(insert=False) == approx(na_fe_p_o4_cap, abs=1e-3)
 
-        assert self.fepo4.get_max_capvol() == approx(fepo4_cap, abs=1e-3)
-        assert self.fepo4.get_max_capvol(remove=False) == approx(fepo4_cap, abs=1e-3)
-        assert self.fepo4.get_max_capvol(insert=False) == 0
+        assert self.fe_p_o4.get_max_capvol() == approx(fe_p_o4_cap, abs=1e-3)
+        assert self.fe_p_o4.get_max_capvol(remove=False) == approx(fe_p_o4_cap, abs=1e-3)
+        assert self.fe_p_o4.get_max_capvol(insert=False) == 0
 
         # give the lifepo4 volume, should get lifepo4 capacity
-        assert self.fepo4.get_max_capvol(volume=self.lifepo4.struc_oxid.volume) == approx(lifepo4_cap, abs=1e-3)
+        assert self.fe_p_o4.get_max_capvol(volume=self.li_fe_p_o4.struc_oxid.volume) == approx(li_fe_p_o4_cap, abs=1e-3)
 
     def test_ion_removal(self):
         assert self.lifemnpo4.get_removals_int_oxid() == {1, 2, 3, 4}
diff --git a/pymatgen/command_line/gulp_caller.py b/pymatgen/command_line/gulp_caller.py
@@ -373,7 +373,7 @@ def readable(f):
                     gin = "library " + file_name
         if gin:
             return gin + "\n"
-        raise GulpError("GULP Library not found")
+        raise GulpError("GULP library not found")
 
     def buckingham_input(self, structure: Structure, keywords, library=None, uc=True, valence_dict=None):
         """
diff --git a/pymatgen/command_line/tests/test_enumlib_caller.py b/pymatgen/command_line/tests/test_enumlib_caller.py
@@ -86,7 +86,7 @@ def test_rounding_errors(self):
         # This has been fixed by multiplying the base by 100.
         struct = Structure.from_file(os.path.join(PymatgenTest.TEST_FILES_DIR, "Cu7Te5.cif"))
         adaptor = EnumlibAdaptor(struct, 1, 2)
-        with pytest.raises(EnumError):
+        with pytest.raises(EnumError, match="Unable to enumerate structure"):
             adaptor.run()
         adaptor = EnumlibAdaptor(struct, 1, 5)
         adaptor.run()
diff --git a/pymatgen/command_line/tests/test_gulp_caller.py b/pymatgen/command_line/tests/test_gulp_caller.py
@@ -137,7 +137,7 @@ def test_library_line_explicit_path(self):
         assert "lib" in gin
 
     def test_library_line_wrong_file(self):
-        with pytest.raises(GulpError):
+        with pytest.raises(GulpError, match="GULP library not found"):
             self.gio.library_line("temp_to_fail.lib")
 
     def test_buckingham_potential(self):
diff --git a/pymatgen/core/tests/test_periodic_table.py b/pymatgen/core/tests/test_periodic_table.py
@@ -545,7 +545,7 @@ def test_sort(self):
 
     def test_immutable(self):
         sp = Species("Fe", 2, spin=5)
-        with pytest.raises(AttributeError):
+        with pytest.raises(AttributeError, match="property 'spin' of 'Species' object has no setter"):
             sp.spin = 6
         sp.properties["spin"] = 7
         assert sp.spin == 5
diff --git a/pymatgen/electronic_structure/core.py b/pymatgen/electronic_structure/core.py
@@ -18,7 +18,7 @@ class Spin(Enum):
     Usage: Spin.up, Spin.down.
     """
 
-    up, down = (1, -1)
+    up, down = 1, -1
 
     def __int__(self):
         return self.value
diff --git a/pymatgen/electronic_structure/tests/test_cohp.py b/pymatgen/electronic_structure/tests/test_cohp.py
@@ -63,7 +63,7 @@ def test_get_interpolated_value(self):
         icoop_ef = self.coop.get_interpolated_value(self.coop.efermi, integrated=True)
         assert icohp_ef_dict == approx(icohp_ef)
         assert icoop_ef_dict == approx(icoop_ef)
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="ICOHP is empty"):
             self.cohp_only.get_interpolated_value(5.0, integrated=True)
 
     def test_str(self):
@@ -1057,9 +1057,10 @@ def test_get_summed_cohp_by_label_and_orbital_list(self):
         assert_array_equal(cohp_label2.icohp[Spin.up], ref["ICOHP"][Spin.up] * 2.0)
         assert_array_equal(cohp_label2x.icohp[Spin.up], ref["ICOHP"][Spin.up])
         assert_array_equal(cohp_label3.icohp[Spin.up], ref["ICOHP"][Spin.up] + ref2["ICOHP"][Spin.up])
-        with pytest.raises(ValueError):
+        expected_msg = "label_list and orbital_list don't have the same length"
+        with pytest.raises(ValueError, match=expected_msg):
             self.cohp_orb.get_summed_cohp_by_label_and_orbital_list(["1"], ["4px-4pz", "4s-4px"])
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match=expected_msg):
             self.cohp_orb.get_summed_cohp_by_label_and_orbital_list(["1", "2"], ["4s-4px"])
 
     def test_get_summed_cohp_by_label_and_orbital_list_summed_spin_channels(self):
@@ -1085,11 +1086,12 @@ def test_get_summed_cohp_by_label_and_orbital_list_summed_spin_channels(self):
         assert_array_equal(cohp_label2.icohp[Spin.up], ref["ICOHP"][Spin.up] * 2.0)
         assert_array_equal(cohp_label2x.icohp[Spin.up], ref["ICOHP"][Spin.up])
         assert_array_equal(cohp_label3.icohp[Spin.up], ref["ICOHP"][Spin.up] + ref2["ICOHP"][Spin.up])
-        with pytest.raises(ValueError):
+        expected_msg = "label_list and orbital_list don't have the same length"
+        with pytest.raises(ValueError, match=expected_msg):
             self.cohp_orb.get_summed_cohp_by_label_and_orbital_list(
                 ["1"], ["4px-4pz", "4s-4px"], summed_spin_channels=True
             )
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match=expected_msg):
             self.cohp_orb.get_summed_cohp_by_label_and_orbital_list(["1", "2"], ["4s-4px"], summed_spin_channels=True)
 
         # files with spin polarization
diff --git a/pymatgen/electronic_structure/tests/test_core.py b/pymatgen/electronic_structure/tests/test_core.py
@@ -17,7 +17,7 @@ def test_init(self):
     def test_from_int(self):
         assert Spin(1) == Spin.up
         assert Spin(-1) == Spin.down
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="0 is not a valid Spin"):
             Spin(0)
 
     def test_cached(self):
diff --git a/pymatgen/electronic_structure/tests/test_dos.py b/pymatgen/electronic_structure/tests/test_dos.py
@@ -31,7 +31,7 @@ def test_get_gap(self):
 
         assert dos.get_interpolated_value(9.9)[Spin.up] == approx(1.744588888888891, abs=1e-7)
         assert dos.get_interpolated_value(9.9)[Spin.down] == approx(1.756888888888886, abs=1e-7)
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="x is out of range of provided x_values"):
             dos.get_interpolated_value(1000)
 
     def test_get_smeared_densities(self):
@@ -309,7 +309,7 @@ def test_get_gap(self):
 
         assert dos.get_interpolated_value(9.9)[0] == approx(1.744588888888891, abs=1e-7)
         assert dos.get_interpolated_value(9.9)[1] == approx(1.756888888888886, abs=1e-7)
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="x is out of range of provided x_values"):
             dos.get_interpolated_value(1000)
 
         self.assert_all_close(dos.get_cbm_vbm(spin=Spin.up), (3.8729, 1.2992999999999999))
diff --git a/pymatgen/ext/tests/test_matproj.py b/pymatgen/ext/tests/test_matproj.py
@@ -127,7 +127,7 @@ def test_get_data(self):
         for d in data:
             assert set(Composition(d["unit_cell_formula"]).elements).issubset(elements)
 
-        with pytest.raises(MPRestError):
+        with pytest.raises(MPRestError, match="REST query returned with error status code 404"):
             self.rester.get_data("Fe2O3", "badmethod")
 
     def test_get_materials_id_from_task_id(self):
@@ -179,11 +179,10 @@ def test_get_structure_by_material_id(self):
     def test_get_entry_by_material_id(self):
         entry = self.rester.get_entry_by_material_id("mp-19017")
         assert isinstance(entry, ComputedEntry)
-        assert entry.composition.reduced_formula, "LiFePO4"
+        assert entry.composition.reduced_formula == "LiFePO4"
 
-        # "mp-2022" does not exist
-        with pytest.raises(MPRestError):
-            self.rester.get_entry_by_material_id("mp-2022")
+        with pytest.raises(MPRestError, match="material_id = 'mp-2022' does not exist"):
+            self.rester.get_entry_by_material_id("mp-2022")  # "mp-2022" does not exist
 
     def test_query(self):
         criteria = {"elements": {"$in": ["Li", "Na", "K"], "$all": ["O"]}}
@@ -465,9 +464,9 @@ def test_parse_criteria(self):
 
         # Let's test some invalid symbols
 
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="'li' is not a valid Element"):
             _MPResterLegacy.parse_criteria("li-fe")
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="'L' is not a valid Element"):
             _MPResterLegacy.parse_criteria("LO2")
 
         crit = _MPResterLegacy.parse_criteria("POPO2")
diff --git a/pymatgen/io/abinit/inputs.py b/pymatgen/io/abinit/inputs.py
@@ -796,7 +796,7 @@ def add_abiobjects(self, *abi_objects):
         dct = {}
         for obj in abi_objects:
             if not hasattr(obj, "to_abivars"):
-                raise TypeError(f"type {type(obj)}: {obj!r} does not have `to_abivars` method")
+                raise TypeError(f"type {type(obj).__name__} does not have `to_abivars` method")
             dct.update(self.set_vars(obj.to_abivars()))
         return dct
 
diff --git a/pymatgen/io/abinit/tests/test_abiobjects.py b/pymatgen/io/abinit/tests/test_abiobjects.py
@@ -72,7 +72,7 @@ def test_rprim_acell(self):
         )
         self.assert_all_close(l3.matrix, abi_rprimd)
 
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="angdeg and rprimd are mutually exclusive"):
             lattice_from_abivars(acell=[1, 1, 1], angdeg=(90, 90, 90), rprim=np.eye(3))
         with pytest.raises(ValueError):
             lattice_from_abivars(acell=[1, 1, 1], angdeg=(-90, 90, 90))
@@ -105,7 +105,7 @@ def test_znucl_typat(self):
         for itype1, itype2 in zip(def_typat, enforce_typat):
             assert def_znucl[itype1 - 1] == enforce_znucl[itype2 - 1]
 
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="Both enforce_znucl and enforce_typat are required"):
             structure_to_abivars(gan, enforce_znucl=enforce_znucl, enforce_typat=None)
 
 
diff --git a/pymatgen/io/abinit/tests/test_inputs.py b/pymatgen/io/abinit/tests/test_inputs.py
@@ -88,7 +88,7 @@ def test_api(self):
         with pytest.raises(inp.Error):
             inp.set_vars(unit_cell)
 
-        with pytest.raises(TypeError):
+        with pytest.raises(TypeError, match="type dict does not have `to_abivars` method"):
             inp.add_abiobjects({})
 
         with pytest.raises(KeyError):
@@ -177,7 +177,7 @@ def test_api(self):
         pseudo = abiref_file("14si.pspnc")
         pseudo_dir = os.path.dirname(pseudo)
         multi = BasicMultiDataset(structure=structure, pseudos=pseudo)
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="ndtset=-1 cannot be <=0"):
             BasicMultiDataset(structure=structure, pseudos=pseudo, ndtset=-1)
 
         multi = BasicMultiDataset(structure=structure, pseudos=pseudo, pseudo_dir=pseudo_dir)
diff --git a/pymatgen/io/cp2k/tests/test_sets.py b/pymatgen/io/cp2k/tests/test_sets.py
@@ -112,7 +112,7 @@ def test_dft_set(self):
 
         # Validator will trip for kpoints + hfx
         ss.update({"force_eval": {"dft": {"kpoints": {}}}})
-        with pytest.raises(Cp2kValidationError):
+        with pytest.raises(Cp2kValidationError, match="CP2K v2022.1: Does not support hartree fock with kpoints"):
             ss.validate()
 
         ss = DftSet(molecule, basis_and_potential=basis_and_potential, xc_functionals="PBE")
diff --git a/pymatgen/io/tests/test_ase.py b/pymatgen/io/tests/test_ase.py
@@ -164,7 +164,7 @@ def test_get_structure(self):
         atoms = read(os.path.join(PymatgenTest.TEST_FILES_DIR, "POSCAR_overlap"))
         struct = aio.AseAtomsAdaptor.get_structure(atoms)
         assert [s.species_string for s in struct] == atoms.get_chemical_symbols()
-        with pytest.raises(StructureError):
+        with pytest.raises(StructureError, match="Structure contains sites that are less than 0.01 Angstrom apart"):
             struct = aio.AseAtomsAdaptor.get_structure(atoms, validate_proximity=True)
 
     def test_get_structure_mag(self):
diff --git a/pymatgen/io/tests/test_cif.py b/pymatgen/io/tests/test_cif.py
@@ -776,7 +776,7 @@ def test_empty(self):
     def test_bad_cif(self):
         f = self.TEST_FILES_DIR / "bad_occu.cif"
         parser = CifParser(f)
-        with pytest.raises(ValueError):
+        with pytest.raises(ValueError, match="Invalid cif file with no structures"):
             parser.get_structures()
         parser = CifParser(f, occupancy_tolerance=2)
         s = parser.get_structures()[0]
@@ -904,16 +904,16 @@ def test_mcif_detection(self):
 
     def test_get_structures(self):
         # incommensurate structures not currently supported
-        with pytest.raises(NotImplementedError):
+        with pytest.raises(NotImplementedError, match="Incommensurate structures not currently supported"):
             self.mcif_incom.get_structures()
 
         # disordered magnetic structures not currently supported
-        with pytest.raises(NotImplementedError):
+        with pytest.raises(NotImplementedError, match="Disordered magnetic structures not currently supported"):
             self.mcif_disord.get_structures()
 
         # taken from self.mcif_ncl, removing explicit magnetic symmops
         # so that MagneticSymmetryGroup() has to be invoked
-        magcifstr = """
+        mag_cif_str = """
 data_5yOhtAoR
 
 _space_group.magn_name_BNS     "P 4/m' b' m' "
@@ -949,7 +949,7 @@ def test_get_structures(self):
 
         # example with non-collinear spin
         s_ncl = self.mcif_ncl.get_structures(primitive=False)[0]
-        s_ncl_from_msg = CifParser.from_string(magcifstr).get_structures(primitive=False)[0]
+        s_ncl_from_msg = CifParser.from_string(mag_cif_str).get_structures(primitive=False)[0]
         assert s_ncl.formula == "Gd4 B16"
         assert not Magmom.are_collinear(s_ncl.site_properties["magmom"])
 
diff --git a/pymatgen/io/tests/test_core.py b/pymatgen/io/tests/test_core.py
@@ -45,7 +45,7 @@ def __str__(self):
 
 class TestInputFile(PymatgenTest):
     def test_file_io(self):
-        with pytest.raises(FileNotFoundError):
+        with pytest.raises(FileNotFoundError, match="No such file or directory: 'fakepath.cif'"):
             StructInputFile.from_file("fakepath.cif")
 
         sif = StructInputFile.from_file(os.path.join(test_dir, "Li.cif"))
diff --git a/test_files/.pytest-split-durations b/test_files/.pytest-split-durations
