Add WHEN THEN EXPECT to tests

Author: henrikjacobsenfys

tests/unit_tests/sample_model/components/test_delta_function.py

@@ -44,35 +44,50 @@ def test_negative_area_warns(self):
         reason="DeltaFunction.evaluate is not implemented yet without resolution convolution"
     )
     def test_evaluate(self, delta_function: DeltaFunction):
+        # WHEN
         x = np.array([0.0, 0.5, 1.0])
-        expected = delta_function.evaluate(x)
+
+        # THEN
+        result = delta_function.evaluate(x)
+
+        # EXPECT
         expected_result = np.zeros_like(x)
-        # expected_result[x == 0.5] = 2.0
-        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+        np.testing.assert_allclose(result, expected_result, rtol=1e-5)
 
     def test_center_is_fixed_if_set_to_None(self):
+        # WHEN THEN
         test_delta = DeltaFunction(
             name="TestDeltaFunction", area=2.0, center=None, unit="meV"
         )
+
+        # EXPECT
         assert test_delta._center.value == 0.0
         assert test_delta._center.fixed is True
 
     def test_get_parameters(self, delta_function: DeltaFunction):
+        # WHEN THEN
         params = delta_function.get_parameters()
+
+        # EXPECT
         assert len(params) == 2
         assert params[0].name == "TestDeltaFunction area"
         assert params[1].name == "TestDeltaFunction center"
         assert all(isinstance(param, Parameter) for param in params)
 
     def test_convert_unit(self, delta_function: DeltaFunction):
+        # WHEN THEN
         delta_function.convert_unit("microeV")
 
+        # EXPECT
         assert delta_function.unit == "microeV"
         assert delta_function._area.value == 2 * 1e3
         assert delta_function._center.value == 0.5 * 1e3
 
     def test_copy(self, delta_function: DeltaFunction):
+        # WHEN THEN
         delta_copy = delta_function.copy()
+
+        # EXPECT
         assert delta_copy is not delta_function
         assert delta_copy.name == "copy of " + delta_function.name
 
@@ -85,7 +100,10 @@ def test_copy(self, delta_function: DeltaFunction):
         assert delta_copy.unit == delta_function.unit
 
     def test_repr(self, delta_function: DeltaFunction):
+        # WHEN THEN
         repr_str = repr(delta_function)
+
+        # EXPECT
         assert "DeltaFunction" in repr_str
         assert "name = TestDeltaFunction" in repr_str
         assert "unit = meV" in repr_str

tests/unit_tests/sample_model/components/test_lorentzian.py

@@ -58,42 +58,66 @@ def test_negative_area_warns(self):
             )
 
     def test_evaluate(self, lorentzian: Lorentzian):
+        # WHEN
         x = np.array([0.0, 0.5, 1.0])
-        expected = lorentzian.evaluate(x)
+
+        # THEN
+        result = lorentzian.evaluate(x)
+
+        # EXPECT
         expected_result = (2.0 / (np.pi * 0.6)) / (1 + ((x - 0.5) / 0.6) ** 2)
-        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+        np.testing.assert_allclose(result, expected_result, rtol=1e-5)
 
     def test_evaluate_scipp_array(self, lorentzian: Lorentzian):
+        # WHEN
         x = sc.array(dims=["x"], values=[0.0, 0.5, 1.0], unit="meV")
-        expected = lorentzian.evaluate(x)
+
+        # THEN
+        result = lorentzian.evaluate(x)
+
+        # EXPECT
         expected_result = (2.0 / (np.pi * 0.6)) / (1 + ((x.values - 0.5) / 0.6) ** 2)
-        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+        np.testing.assert_allclose(result, expected_result, rtol=1e-5)
 
     def test_evaluate_with_different_unit(self, lorentzian: Lorentzian):
+        # WHEN
         x = sc.array(dims=["x"], values=[0.0, 500.0, 1000.0], unit="microeV")
-        expected = lorentzian.evaluate(x)
+
+        # THEN
+        result = lorentzian.evaluate(x)
+
+        # EXPECT
         expected_result = (2.0 * 1e3 / (np.pi * 0.6 * 1e3)) / (
             1 + ((x.values - 0.5 * 1e3) / (0.6 * 1e3)) ** 2
         )
-        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+        np.testing.assert_allclose(result, expected_result, rtol=1e-5)
 
     def test_evaluate_with_incompatible_unit(self, lorentzian: Lorentzian):
+        # WHEN
         x = sc.array(dims=["x"], values=[0.0, 500.0, 1000.0], unit="nm")
+
+        # THEN EXPECT
         with pytest.raises(
             UnitError,
             match="Input x has unit nm, but Lorentzian component has unit meV. Failed to convert Lorentzian to nm.",
         ):
             lorentzian.evaluate(x)
 
     def test_center_is_fixed_if_set_to_None(self):
+        # WHEN
         test_lorentzian = Lorentzian(
             name="TestLorentzian", area=2.0, center=None, width=0.6, unit="meV"
         )
+
+        # THEN EXPECT
         assert test_lorentzian._center.value == 0.0
         assert test_lorentzian._center.fixed is True
 
     def test_get_parameters(self, lorentzian: Lorentzian):
+        # WHEN THEN
         params = lorentzian.get_parameters()
+
+        # EXPECT
         assert len(params) == 3
         assert params[0].name == "TestLorentzian area"
         assert params[1].name == "TestLorentzian center"
@@ -114,15 +138,20 @@ def test_area_matches_parameter(self, lorentzian: Lorentzian):
         assert numerical_area == pytest.approx(lorentzian._area.value, rel=2e-3)
 
     def test_convert_unit(self, lorentzian: Lorentzian):
+        # WHEN THEN
         lorentzian.convert_unit("microeV")
 
+        # EXPECT
         assert lorentzian.unit == "microeV"
         assert lorentzian._area.value == 2 * 1e3
         assert lorentzian._center.value == 0.5 * 1e3
         assert lorentzian._width.value == 0.6 * 1e3
 
     def test_copy(self, lorentzian: Lorentzian):
+        # WHEN THEN
         lorentzian_copy = lorentzian.copy()
+
+        # EXPECT
         assert lorentzian_copy is not lorentzian
         assert lorentzian_copy.name == "copy of " + lorentzian.name
 
@@ -138,7 +167,10 @@ def test_copy(self, lorentzian: Lorentzian):
         assert lorentzian_copy.unit == lorentzian.unit
 
     def test_repr(self, lorentzian: Lorentzian):
+        # WHEN THEN
         repr_str = repr(lorentzian)
+
+        # EXPECT
         assert "Lorentzian" in repr_str
         assert "name = TestLorentzian" in repr_str
         assert "unit = meV" in repr_str

tests/unit_tests/sample_model/components/test_polynomial.py

@@ -43,46 +43,66 @@ def test_negative_value_warns_in_evaluate(self):
             test_polynomial.evaluate(np.array([0.0, 1.0, 2.0]))
 
     def test_evaluate(self, polynomial: Polynomial):
+        # WHEN
         x = np.array([0.0, 1.0, 2.0])
-        expected = polynomial.evaluate(x)
+
+        # THEN
+        result = polynomial.evaluate(x)
+
+        # EXPECT
         expected_result = 1.0 - 2.0 * x + 3.0 * x**2
-        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+        np.testing.assert_allclose(result, expected_result, rtol=1e-5)
 
     def test_evaluate_scipp_array(self, polynomial: Polynomial):
+        # WHEN
         x = sc.array(dims=["x"], values=[0.0, 1.0, 2.0], unit="meV")
-        expected = polynomial.evaluate(x)
+
+        # THEN
+        result = polynomial.evaluate(x)
+
+        # EXPECT
         expected_result = 1.0 - 2.0 * x.values + 3.0 * x.values**2
-        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+        np.testing.assert_allclose(result, expected_result, rtol=1e-5)
 
     def test_evaluate_with_different_unit_error(self, polynomial: Polynomial):
+        # WHEN
         x = sc.array(dims=["x"], values=[0.0, 1.0, 2.0], unit="microeV")
 
+        # THEN EXPECT
         with pytest.raises(
             UnitError,
             match="Change the unit of the Polynomial and try again",
         ):
             polynomial.evaluate(x)
 
     def test_degree(self, polynomial: Polynomial):
+        # WHEN THEN EXPECT
         assert polynomial.degree() == 2
 
     def test_get_parameters(self, polynomial: Polynomial):
+        # WHEN THEN
         params = polynomial.get_parameters()
+
+        # EXPECT
         assert len(params) == 3
         assert params[0].name == "TestPolynomial_c0"
         assert params[1].name == "TestPolynomial_c1"
         assert params[2].name == "TestPolynomial_c2"
         assert all(isinstance(param, Parameter) for param in params)
 
     def test_convert_unit_raises_for_polynomial(self, polynomial):
+        # WHEN THEN EXPECT
         with pytest.raises(
             NotImplementedError,
             match="Unit conversion is not implemented for Polynomial components. The automatic unit converter does not like powers of units.",
         ):
             polynomial.convert_unit("eV")
 
     def test_copy(self, polynomial: Polynomial):
+        # WHEN THEN
         polynomial_copy = polynomial.copy()
+
+        # EXPECT
         assert polynomial_copy is not polynomial
         assert polynomial_copy.name == polynomial.name
         assert len(polynomial_copy.coefficients) == len(polynomial.coefficients)
@@ -93,13 +113,10 @@ def test_copy(self, polynomial: Polynomial):
             assert copied_coeff.fixed == original_coeff.fixed
 
     def test_repr(self, polynomial: Polynomial):
+        # WHEN THEN
         repr_str = repr(polynomial)
+
+        # EXPECT
         assert "Polynomial" in repr_str
         assert "name = TestPolynomial" in repr_str
         assert "coefficients =" in repr_str
-
-
-# @pytest.mark.skip(reason="UserDefinedComponent not implemented yet")
-# class TestUserDefinedComponent:
-#     def test_placeholder(self):
-#         pass

tests/unit_tests/sample_model/components/test_voigt.py

@@ -83,6 +83,7 @@ def test_input_type_validation_raises(self):
             )
 
     def test_negative_gaussian_width_raises(self):
+        # WHEN THEN EXPECT
         with pytest.raises(
             ValueError, match="The gaussian_width of a Voigt must be greater than."
         ):
@@ -96,6 +97,7 @@ def test_negative_gaussian_width_raises(self):
             )
 
     def test_negative_lorentzian_width_raises(self):
+        # WHEN THEN EXPECT
         with pytest.raises(
             ValueError,
             match="The lorentzian_width of a Voigt must be greater than zero.",
@@ -110,6 +112,7 @@ def test_negative_lorentzian_width_raises(self):
             )
 
     def test_negative_area_warns(self):
+        # WHEN THEN EXPECT
         with pytest.warns(UserWarning, match="may not be physically meaningful"):
             Voigt(
                 name="TestVoigt",
@@ -121,26 +124,42 @@ def test_negative_area_warns(self):
             )
 
     def test_evaluate(self, voigt: Voigt):
+        # WHEN
         x = np.array([0.0, 0.5, 1.0])
-        expected = voigt.evaluate(x)
+
+        # THEN
+        result = voigt.evaluate(x)
+
+        # EXPECT
         expected_result = 2.0 * voigt_profile(x - 0.5, 0.6, 0.7)
-        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+        np.testing.assert_allclose(result, expected_result, rtol=1e-5)
 
     def test_evaluate_scipp_array(self, voigt: Voigt):
+        # WHEN
         x = sc.array(dims=["x"], values=[0.0, 0.5, 1.0], unit="meV")
-        expected = voigt.evaluate(x)
+
+        # THEN
+        result = voigt.evaluate(x)
+
+        # EXPECT
         expected_result = 2.0 * voigt_profile(x.values - 0.5, 0.6, 0.7)
-        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+        np.testing.assert_allclose(result, expected_result, rtol=1e-5)
 
     def test_evaluate_with_different_unit(self, voigt: Voigt):
+        # WHEN
         x = sc.array(dims=["x"], values=[0.0, 500.0, 1000.0], unit="microeV")
-        expected = voigt.evaluate(x)
+
+        # THEN
+        result = voigt.evaluate(x)
+
+        # EXPECT
         expected_result = (
             2.0 * 1e3 * voigt_profile(x.values - 0.5 * 1e3, 0.6 * 1e3, 0.7 * 1e3)
         )
-        np.testing.assert_allclose(expected, expected_result, rtol=1e-5)
+        np.testing.assert_allclose(result, expected_result, rtol=1e-5)
 
     def test_evaluate_with_incompatible_unit(self, voigt: Voigt):
+        # WHEN THEN EXPECT
         x = sc.array(dims=["x"], values=[0.0, 500.0, 1000.0], unit="nm")
         with pytest.raises(
             UnitError,
@@ -149,6 +168,7 @@ def test_evaluate_with_incompatible_unit(self, voigt: Voigt):
             voigt.evaluate(x)
 
     def test_center_is_fixed_if_set_to_None(self):
+        # WHEN THEN
         test_voigt = Voigt(
             name="TestVoigt",
             area=2.0,
@@ -157,20 +177,27 @@ def test_center_is_fixed_if_set_to_None(self):
             lorentzian_width=0.7,
             unit="meV",
         )
+
+        # EXPECT
         assert test_voigt._center.value == 0.0
         assert test_voigt._center.fixed is True
 
     def test_convert_unit(self, voigt: Voigt):
+        # WHEN THEN
         voigt.convert_unit("microeV")
 
+        # EXPECT
         assert voigt.unit == "microeV"
         assert voigt._area.value == 2 * 1e3
         assert voigt._center.value == 0.5 * 1e3
         assert voigt._gaussian_width.value == 0.6 * 1e3
         assert voigt._lorentzian_width.value == 0.7 * 1e3
 
     def test_get_parameters(self, voigt: Voigt):
+        # WHEN THEN
         params = voigt.get_parameters()
+
+        # EXPECT
         assert len(params) == 4
         assert params[0].name == "TestVoigt area"
         assert params[1].name == "TestVoigt center"
@@ -196,7 +223,10 @@ def test_area_matches_parameter(self, voigt: Voigt):
         assert numerical_area == pytest.approx(voigt._area.value, rel=2e-3)
 
     def test_copy(self, voigt: Voigt):
+        # WHEN THEN
         voigt_copy = voigt.copy()
+
+        # EXPECT
         assert voigt_copy is not voigt
         assert voigt_copy.name == "copy of " + voigt.name
 
@@ -215,7 +245,10 @@ def test_copy(self, voigt: Voigt):
         assert voigt_copy.unit == voigt.unit
 
     def test_repr(self, voigt: Voigt):
+        # WHEN THEN
         repr_str = repr(voigt)
+
+        # EXPECT
         assert "Voigt" in repr_str
         assert "name = TestVoigt" in repr_str
         assert "unit = meV" in repr_str