Tests created

The solid motor integrations test was created and the solid and hybrid motors unit tests were modified to add checks to the new only_radial_burning class and parameters. Also a correction was made in the hybrid unit tests to fix the test time.

Author: caioessouza

flight.json

@@ -0,0 +1,15 @@
+from unittest.mock import patch
+
+@patch("matplotlib.pyplot.show")
+def test_solid_motor_info(mock_show, cesaroni_m1670):
+    """Tests the SolidMotor.all_info() method.
+
+    Parameters
+    ----------
+    mock_show : mock
+        Mock of the matplotlib.pyplot.show function.
+    hybrid_motor : rocketpy.HybridMotor
+        The SolidMotor object to be used in the tests.
+    """
+    assert cesaroni_m1670.info() is None
+    assert cesaroni_m1670.all_info() is None

tests/integration/test_solidmotor.py

@@ -121,7 +121,7 @@ def test_hybrid_motor_center_of_mass(hybrid_motor, spherical_oxidizer_tank):
     propellant_center_of_mass = propellant_balance / (grain_mass + oxidizer_mass)
     center_of_mass = balance / (grain_mass + oxidizer_mass + DRY_MASS)
 
-    for t in np.linspace(0, 100, 100):
+    for t in np.linspace(0, BURN_TIME, 100):
         assert pytest.approx(
             hybrid_motor.center_of_propellant_mass(t)
         ) == propellant_center_of_mass(t)
@@ -170,9 +170,45 @@ def test_hybrid_motor_inertia(hybrid_motor, spherical_oxidizer_tank):
         + DRY_MASS * (-hybrid_motor.center_of_mass + CENTER_OF_DRY_MASS) ** 2
     )
 
-    for t in np.linspace(0, 100, 100):
+    for t in np.linspace(0, BURN_TIME, 100):
         assert pytest.approx(hybrid_motor.propellant_I_11(t)) == propellant_inertia(t)
         assert pytest.approx(hybrid_motor.I_11(t)) == inertia(t)
 
         # Assert cylindrical symmetry
         assert pytest.approx(hybrid_motor.propellant_I_22(t)) == propellant_inertia(t)
+
+def test_hybrid_motor_only_radial_burn_behavior(hybrid_motor):
+    """
+    Test if only_radial_burn flag in HybridMotor propagates to its SolidMotor
+    and affects burn_area calculation.
+    """
+    motor = hybrid_motor
+
+    # Activates the radial burning
+    motor.solid.only_radial_burn = True
+    assert motor.solid.only_radial_burn is True
+
+    # Calculates the expected initial area
+    burn_area_radial = (
+        2
+        * np.pi
+        * (motor.solid.grain_inner_radius(0) * motor.solid.grain_height(0))
+        * motor.solid.grain_number
+    )
+
+    assert np.isclose(motor.solid.burn_area(0), burn_area_radial, atol=1e-12)
+
+    # Deactivates the radial burning and recalculate the geometry
+    motor.solid.only_radial_burn = False
+    motor.solid.evaluate_geometry()
+    assert motor.solid.only_radial_burn is False
+
+    # In this case the burning area also considers tha bases of the grain
+    inner_radius = motor.solid.grain_inner_radius(0)
+    outer_radius = motor.solid.grain_outer_radius
+    burn_area_total = (
+        burn_area_radial
+        + 2 * np.pi * (outer_radius**2 - inner_radius**2) * motor.solid.grain_number
+    )
+    assert np.isclose(motor.solid.burn_area(0), burn_area_total, atol=1e-12)
+    assert motor.solid.burn_area(0) > burn_area_radial

tests/unit/test_hybridmotor.py

@@ -279,3 +279,32 @@ def test_reshape_thrust_curve_asserts_resultant_thrust_curve_correct(
 
     assert thrust_reshaped[1][1] == 100 * (tuple_parametric[1] / 7539.1875)
     assert thrust_reshaped[7][1] == 2034 * (tuple_parametric[1] / 7539.1875)
+
+def test_only_radial_burn_parameter_effect(cesaroni_m1670):
+    # Tests if the only_radial_burn flag is properly set
+    motor = cesaroni_m1670
+    motor.only_radial_burn = True
+    assert motor.only_radial_burn is True
+
+    # When only_radial_burn is active, burn_area should consider only radial area
+    burn_area_radial = 2 * np.pi * (motor.grain_inner_radius(0) * motor.grain_height(0)) * motor.grain_number
+    assert np.isclose(motor.burn_area(0), burn_area_radial, atol=1e-12)
+
+def test_evaluate_geometry_updates_properties(cesaroni_m1670):
+    # Checks if after instantiation, grain_inner_radius and grain_height are valid functions
+    motor = cesaroni_m1670
+
+    assert hasattr(motor, "grain_inner_radius")
+    assert hasattr(motor, "grain_height")
+
+    # Checks if the domain of grain_inner_radius function is consistent
+    times = motor.grain_inner_radius.x_array
+    values = motor.grain_inner_radius.y_array
+
+    assert times[0] == 0  # expected initial time
+    assert values[0] == motor.grain_initial_inner_radius  # expected initial inner radius
+    assert values[-1] <= motor.grain_outer_radius  # final inner radius should be less or equal than outer radius
+
+    # Evaluates without error
+    val = motor.grain_inner_radius(0.5)  # evaluate at intermediate time
+    assert isinstance(val, float)