Replace most pytest xfails with raises(Error), in line with best practice

Signed-off-by: Håkon Wiik Ånes <hwaanes@gmail.com>

Author: hakonanes

diffsims/tests/generators/test_diffraction_generator.py

@@ -248,36 +248,36 @@ def test_defaults(self, diffraction_calculator_atomic, local_structure):
 
         np.testing.assert_allclose(diffraction1, diffraction2, 1e-6, 1e-6)
 
-    @pytest.mark.xfail(raises=NotImplementedError)
     def test_mode(self, diffraction_calculator_atomic, local_structure):
-        diffraction = diffraction_calculator_atomic.calculate_ed_data(
-            local_structure, probe, 1, mode="other"
-        )
+        with pytest.raises(NotImplementedError):
+            _ = diffraction_calculator_atomic.calculate_ed_data(
+                local_structure, probe, 1, mode="other"
+            )
 
-    @pytest.mark.xfail(raises=ValueError, strict=True)
     def test_bad_ZERO(self, diffraction_calculator_atomic, local_structure):
-        _ = diffraction_calculator_atomic.calculate_ed_data(
-            local_structure, probe, 1, ZERO=-1
-        )
+        with pytest.raises(ValueError):
+            _ = diffraction_calculator_atomic.calculate_ed_data(
+                local_structure, probe, 1, ZERO=-1
+            )
 
 
 @pytest.mark.parametrize("scattering_param", ["lobato", "xtables"])
 def test_param_check(scattering_param):
     generator = DiffractionGenerator(300, scattering_params=scattering_param)
 
 
-@pytest.mark.xfail(raises=NotImplementedError)
 def test_invalid_scattering_params():
     scattering_param = "_empty"
-    generator = DiffractionGenerator(300, scattering_params=scattering_param)
+    with pytest.raises(NotImplementedError):
+        _ = DiffractionGenerator(300, scattering_params=scattering_param)
 
 
-@pytest.mark.xfail(faises=NotImplementedError)
 def test_invalid_shape_model():
-    generator = DiffractionGenerator(300, shape_factor_model="dracula")
+    with pytest.raises(NotImplementedError):
+        _ = DiffractionGenerator(300, shape_factor_model="dracula")
 
 
 @pytest.mark.parametrize("shape", [(10, 20), (20, 10)])
 def test_param_check_atomic(shape):
     detector = [np.linspace(-1, 1, s) for s in shape]
-    generator = AtomicDiffractionGenerator(300, detector, True)
+    _ = AtomicDiffractionGenerator(300, detector, True)

diffsims/tests/generators/test_rotation_list_generator.py

@@ -94,6 +94,6 @@ def test_get_beam_directions_grid_size(crystal_system, desired_size):
     assert grid.shape[0] == desired_size
 
 
-@pytest.mark.xfail()
 def test_invalid_mesh_beam_directions():
-    _ = get_beam_directions_grid("cubic", 10, mesh="invalid")
+    with pytest.raises(NotImplementedError):
+        _ = get_beam_directions_grid("cubic", 10, mesh="invalid")

diffsims/tests/generators/test_simulation_generator.py

@@ -126,6 +126,13 @@ def test_init(self, diffraction_calculator: SimulationGenerator):
         assert diffraction_calculator.approximate_precession == True
         assert diffraction_calculator.minimum_intensity == 1e-20
 
+    def test_repr(self, diffraction_calculator):
+        assert repr(diffraction_calculator) == (
+            "SimulationGenerator(accelerating_voltage=300, "
+            "scattering_params=lobato, "
+            "approximate_precession=True)"
+        )
+
     def test_matching_results(
         self, diffraction_calculator: SimulationGenerator, local_structure
     ):
@@ -245,35 +252,32 @@ def test_multiphase_multirotation_simulation():
     big_silicon = make_phase(10)
     rot = Rotation.from_euler([[0, 0, 0], [0.1, 0.1, 0.1]])
     rot2 = Rotation.from_euler([[0, 0, 0], [0.1, 0.1, 0.1], [0.2, 0.2, 0.2]])
-    sim = generator.calculate_diffraction2d(
-        [silicon, big_silicon], rotation=[rot, rot2]
-    )
+    _ = generator.calculate_diffraction2d([silicon, big_silicon], rotation=[rot, rot2])
 
 
 def test_multiphase_multirotation_simulation_error():
     generator = SimulationGenerator(300)
     silicon = make_phase(5)
     big_silicon = make_phase(10)
     rot = Rotation.from_euler([[0, 0, 0], [0.1, 0.1, 0.1]])
-    rot2 = Rotation.from_euler([[0, 0, 0], [0.1, 0.1, 0.1], [0.2, 0.2, 0.2]])
+    _ = Rotation.from_euler([[0, 0, 0], [0.1, 0.1, 0.1], [0.2, 0.2, 0.2]])
     with pytest.raises(ValueError):
-        sim = generator.calculate_diffraction2d([silicon, big_silicon], rotation=[rot])
+        _ = generator.calculate_diffraction2d([silicon, big_silicon], rotation=[rot])
 
 
 @pytest.mark.parametrize("scattering_param", ["lobato", "xtables"])
 def test_param_check(scattering_param):
-    generator = SimulationGenerator(300, scattering_params=scattering_param)
+    _ = SimulationGenerator(300, scattering_params=scattering_param)
 
 
-@pytest.mark.xfail(raises=NotImplementedError)
 def test_invalid_scattering_params():
-    scattering_param = "_empty"
-    generator = SimulationGenerator(300, scattering_params=scattering_param)
+    with pytest.raises(NotImplementedError):
+        _ = SimulationGenerator(300, scattering_params="_empty")
 
 
-@pytest.mark.xfail(faises=NotImplementedError)
 def test_invalid_shape_model():
-    generator = SimulationGenerator(300, shape_factor_model="dracula")
+    with pytest.raises(NotImplementedError):
+        _ = SimulationGenerator(300, shape_factor_model="dracula")
 
 
 def test_same_simulation_results():

diffsims/tests/library/test_structure_library.py

@@ -44,23 +44,13 @@ def test_from_orientations_method():
     np.testing.assert_equal(library.struct_lib["b"], (2, 4))
 
 
-@pytest.mark.xfail(reason="Functionality removed")
-def test_from_systems_methods():
-    identifiers = ["a", "b"]
-    structures = [1, 2]
-    systems = ["cubic", "hexagonal"]
-    library = StructureLibrary.from_crystal_systems(
-        identifiers, structures, systems, resolution=2
-    )
-
-
 @pytest.mark.parametrize(
     "identifiers, structures, orientations",
     [
         (["a"], [1, 2], [3, 4]),
         (["a"], [1], [3, 4]),
     ],
 )
-@pytest.mark.xfail(raises=ValueError)
 def test_constructor_parameter_validation_errors(identifiers, structures, orientations):
-    StructureLibrary(identifiers, structures, orientations)
+    with pytest.raises(ValueError):
+        _ = StructureLibrary(identifiers, structures, orientations)

diffsims/tests/patterns/test_detector_functions.py

@@ -120,13 +120,13 @@ def test_frac_kwarg(self, pattern):
         z1 = add_dead_pixels(pattern, fraction=fraction)
         assert np.sum(z1 == 0) == 6  # we should have 6 dead pixels!
 
-    @pytest.mark.xfail(strict=True)
     def test_bad_kwarg_choices_a(self, pattern):
-        _ = add_dead_pixels(pattern, n=None, fraction=None)
+        with pytest.raises(ValueError):
+            _ = add_dead_pixels(pattern, n=None, fraction=None)
 
-    @pytest.mark.xfail(strict=True)
     def test_bad_kwarg_choices_b(self, pattern):
-        _ = add_dead_pixels(pattern, n=6, fraction=0.2)
+        with pytest.raises(ValueError):
+            _ = add_dead_pixels(pattern, n=6, fraction=0.2)
 
 
 class TestDetectorGainOffset:

diffsims/tests/sims/test_diffraction_simulation.py

@@ -16,6 +16,7 @@
 # You should have received a copy of the GNU General Public License
 # along with diffsims.  If not, see <http://www.gnu.org/licenses/>.
 
+import matplotlib.pyplot as plt
 import numpy as np
 import pytest
 
@@ -86,6 +87,7 @@ def profile_simulation():
 
 def test_plot_profile_simulation(profile_simulation):
     profile_simulation.get_plot()
+    plt.close()
 
 
 class TestDiffractionSimulation:
@@ -320,4 +322,6 @@ def test_plot_method(self, units_in):
             intensities=np.array([3.0, 5.0, 2.0]),
             calibration=[1, 2],
         )
-        ax, sp = short_sim.plot(units=units_in, show_labels=True)
+        _ = short_sim.plot(units=units_in, show_labels=True)
+
+        plt.close()

diffsims/tests/simulations/test_simulations1d.py

@@ -15,11 +15,11 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with diffsims.  If not, see <http://www.gnu.org/licenses/>.
-import matplotlib.pyplot as plt
-import pytest
 
-from orix.crystal_map import Phase
+import matplotlib.pyplot as plt
 import numpy as np
+from orix.crystal_map import Phase
+import pytest
 
 from diffsims.tests.generators.test_simulation_generator import make_phase
 from diffsims.simulations import Simulation1D
@@ -57,8 +57,10 @@ def test_init(self, simulation1d):
     @pytest.mark.parametrize("with_labels", [True, False])
     def test_plot(self, simulation1d, annotate, ax, with_labels):
         if ax == "new":
-            fig, ax = plt.subplots()
-        fig = simulation1d.plot(annotate_peaks=annotate, ax=ax, with_labels=with_labels)
+            _, ax = plt.subplots()
+        _ = simulation1d.plot(annotate_peaks=annotate, ax=ax, with_labels=with_labels)
+
+        plt.close()
 
     def test_repr(self, simulation1d):
         assert simulation1d.__repr__() == "Simulation1D(name: Al, wavelength: 0.025)"

diffsims/tests/simulations/test_simulations2d.py

@@ -16,12 +16,12 @@
 # You should have received a copy of the GNU General Public License
 # along with diffsims.  If not, see <http://www.gnu.org/licenses/>.
 
-import numpy as np
-import pytest
-
 from diffpy.structure import Structure, Atom, Lattice
+import matplotlib.pyplot as plt
+import numpy as np
 from orix.crystal_map import Phase
 from orix.quaternion import Rotation
+import pytest
 
 from diffsims.simulations import Simulation2D
 from diffsims.generators.simulation_generator import SimulationGenerator
@@ -80,6 +80,7 @@ def test_iter(self, single_simulation):
 
     def test_plot(self, single_simulation):
         single_simulation.plot()
+        plt.close()
 
     def test_num_rotations(self, single_simulation):
         assert single_simulation._num_rotations() == 1
@@ -245,9 +246,11 @@ def test_irot_slice(self, multi_simulation):
 
     def test_plot(self, multi_simulation):
         multi_simulation.plot()
+        plt.close()
 
     def test_plot_rotation(self, multi_simulation):
         multi_simulation.plot_rotations()
+        plt.close()
 
     def test_iter(self, multi_simulation):
         multi_simulation.phase_index = 0
@@ -370,8 +373,11 @@ def test_plot(self, multi_simulation, show_labels, units, include_zero_beam):
             calibration=0.1,
         )
 
+        plt.close()
+
     def test_plot_rotation(self, multi_simulation):
         multi_simulation.plot_rotations()
+        plt.close()
 
     def test_iter(self, multi_simulation):
         multi_simulation.phase_index = 0

diffsims/tests/utils/test_discretise_utils.py

@@ -62,14 +62,10 @@ def test_getA(Z, returnFunc):
         assert len(a) == len(b)
 
 
-@pytest.mark.xfail(raises=ValueError)
-def test_2_atoms_getA():
-    get_atoms(np.array([0, 1]))
-
-
-@pytest.mark.xfail(raises=ValueError)
-def test_max_atom_getA():
-    get_atoms("Es")
+@pytest.mark.parametrize("atoms", [np.array([0, 1]), "Es"])
+def tests_get_atoms_raises(atoms):
+    with pytest.raises(ValueError):
+        get_atoms(atoms)
 
 
 @pytest.mark.parametrize(
@@ -82,13 +78,7 @@ def test_max_atom_getA():
 )
 def test_rebin(r):
     x = [np.linspace(0, 1, 10), np.linspace(0, 1, 21), np.linspace(0, 1, 32)]
-    loc = np.concatenate(
-        [
-            0 * np.linspace(0, 1, 500)[:, None],
-        ]
-        * 3,
-        axis=1,
-    )
+    loc = np.concatenate([0 * np.linspace(0, 1, 500)[:, None]] * 3, axis=1)
     k = 1
     mem = 1e5
     rebin(x, loc, r, k, mem)

diffsims/tests/utils/test_fourier_transform.py

@@ -206,9 +206,9 @@ def test_DFT(rX, rY):
         np.testing.assert_allclose(f, IFT(g, axes=axes), 1e-5, 1e-5)
 
 
-@pytest.mark.xfail(raises=ValueError)
 def test_fail_DFT():
-    get_DFT()
+    with pytest.raises(ValueError):
+        get_DFT()
 
 
 @pytest.mark.parametrize(

diffsims/tests/utils/test_probe_utils.py

@@ -85,10 +85,10 @@ def _random_array(shape, n=0):
     return x.reshape(shape)
 
 
-@pytest.mark.xfail(raises=NotImplementedError)
 def test_null_probe():
     p = ProbeFunction()
-    p(1)
+    with pytest.raises(NotImplementedError):
+        p(1)
 
 
 @pytest.fixture(params=[(10, 11, 12)])

diffsims/tests/utils/test_sim_utils.py

@@ -114,25 +114,25 @@ def test_kinematic_simulator_xtables_scattering_params():
     )
 
 
-@pytest.mark.xfail(raises=NotImplementedError)
 def test_kinematic_simulator_invalid_scattering_params():
     atomic_coordinates = np.asarray([[0, 0, 0]])  # structure.cart_coords
-    sim = simulate_kinematic_scattering(
-        atomic_coordinates,
-        "Si",
-        300.0,
-        simulation_size=32,
-        illumination="gaussian_probe",
-        scattering_params="_empty",
-    )
+    with pytest.raises(NotImplementedError):
+        simulate_kinematic_scattering(
+            atomic_coordinates,
+            "Si",
+            300.0,
+            simulation_size=32,
+            illumination="gaussian_probe",
+            scattering_params="_empty",
+        )
 
 
-@pytest.mark.xfail(raises=ValueError)
 def test_kinematic_simulator_invalid_illumination():
     atomic_coordinates = np.asarray([[0, 0, 0]])  # structure.cart_coords
-    sim = simulate_kinematic_scattering(
-        atomic_coordinates, "Si", 300.0, simulation_size=32, illumination="gaussian"
-    )
+    with pytest.raises(ValueError):
+        simulate_kinematic_scattering(
+            atomic_coordinates, "Si", 300.0, simulation_size=32, illumination="gaussian"
+        )
 
 
 @pytest.mark.parametrize(

diffsims/tests/utils/test_vector_utils.py

@@ -19,8 +19,7 @@
 import numpy as np
 import pytest
 
-from diffsims.utils.vector_utils import get_angle_cartesian
-from diffsims.utils.vector_utils import get_angle_cartesian_vec
+from diffsims.utils.vector_utils import get_angle_cartesian, get_angle_cartesian_vec
 
 
 @pytest.mark.parametrize(
@@ -47,6 +46,6 @@ def test_get_angle_cartesian_vec(a, b, expected_angles):
     np.testing.assert_allclose(angles, expected_angles)
 
 
-@pytest.mark.xfail(raises=ValueError)
 def test_get_angle_cartesian_vec_input_validation():
-    get_angle_cartesian_vec(np.empty((2, 3)), np.empty((5, 3)))
+    with pytest.raises(ValueError):
+        get_angle_cartesian_vec(np.empty((2, 3)), np.empty((5, 3)))