Merge pull request #693 from RocketPy-Team/tst/generic-surfaces

TST: generic surfaces

tests/conftest.py

@@ -18,6 +18,8 @@
     "tests.fixtures.monte_carlo.stochastic_fixtures",
     "tests.fixtures.monte_carlo.stochastic_motors_fixtures",
     "tests.fixtures.sensors.sensors_fixtures",
+    "tests.fixtures.generic_surfaces.generic_surfaces_fixtures",
+    "tests.fixtures.generic_surfaces.linear_generic_surfaces_fixtures",
 ]
 
 

tests/fixtures/generic_surfaces/generic_surfaces_fixtures.py

@@ -0,0 +1,42 @@
+import pandas as pd
+import pytest
+
+
+@pytest.fixture(scope="session")
+def filename_valid_coeff(tmpdir_factory):
+    """Creates temporary files used to test if generic surfaces
+    initializes correctly from CSV files"""
+    filename = tmpdir_factory.mktemp("aero_surface_data").join("valid_coefficients.csv")
+    pd.DataFrame(
+        {
+            "alpha": [0, 1, 2, 3, 0.1],
+            "mach": [3, 2, 1, 0, 0.2],
+            "cL": [4, 2, 2, 4, 5],
+        }
+    ).to_csv(filename, index=False)
+
+    return filename
+
+
+@pytest.fixture(
+    params=(
+        {
+            "alpha": [0, 1, 2, 3, 0.1],
+            "cL": [4, 2, 2, 4, 5],
+            "mach": [3, 2, 1, 0, 0.2],
+        },
+        {
+            "a": [0, 1, 2, 3, 0.1],
+            "b": [4, 2, 2, 4, 5],
+        },
+    )
+)
+def filename_invalid_coeff(tmpdir_factory, request):
+    """Creates temporary CSV files used to test if generic surfaces
+    raises errors when initialized incorrectly from CSV files"""
+    filename = tmpdir_factory.mktemp("aero_surface_data").join(
+        "tmp_invalid_coefficients.csv"
+    )
+    pd.DataFrame(request.param).to_csv(filename, index=False)
+
+    return filename

tests/fixtures/generic_surfaces/linear_generic_surfaces_fixtures.py

@@ -0,0 +1,44 @@
+import pandas as pd
+import pytest
+
+
+@pytest.fixture(scope="session")
+def filename_valid_coeff_linear_generic_surface(tmpdir_factory):
+    """Creates temporary files used to test if a linear generic surface
+    initializes correctly from CSV files"""
+    filename = tmpdir_factory.mktemp("aero_surface_data").join(
+        "valid_coefficients_lgs.csv"
+    )
+    pd.DataFrame(
+        {
+            "alpha": [0, 1, 2, 3, 0.1],
+            "mach": [3, 2, 1, 0, 0.2],
+            "cL_0": [4, 2, 2, 4, 5],
+        }
+    ).to_csv(filename, index=False)
+
+    return filename
+
+
+@pytest.fixture(
+    params=(
+        {
+            "alpha": [0, 1, 2, 3, 0.1],
+            "cL_0": [4, 2, 2, 4, 5],
+            "mach": [3, 2, 1, 0, 0.2],
+        },
+        {
+            "a": [0, 1, 2, 3, 0.1],
+            "b": [4, 2, 2, 4, 5],
+        },
+    )
+)
+def filename_invalid_coeff_linear_generic_surface(tmpdir_factory, request):
+    """Creates temporary CSV files used to test if a linear generic surface
+    raises errors when initialized incorrectly from CSV files"""
+    filename = tmpdir_factory.mktemp("aero_surface_data").join(
+        "tmp_invalid_coefficients_lgs.csv"
+    )
+    pd.DataFrame(request.param).to_csv(filename, index=False)
+
+    return filename

tests/unit/test_generic_surfaces.py

@@ -0,0 +1,91 @@
+import pytest
+
+from rocketpy import Function, GenericSurface
+from rocketpy.mathutils import Vector
+
+REFERENCE_AREA = 1
+REFERENCE_LENGTH = 1
+
+
+@pytest.mark.parametrize(
+    "coefficients",
+    [
+        "cL",
+        {"invalid_name": 0},
+        {"cL": "inexistent_file.csv"},
+        {"cL": Function(lambda x1, x2, x3, x4, x5, x6: 0)},
+        {"cL": lambda x1: 0},
+        {"cL": {}},
+    ],
+)
+def test_invalid_initialization(coefficients):
+    """Checks if generic surface raises errors in initialization
+    when coefficient argument is invalid"""
+
+    with pytest.raises((ValueError, TypeError)):
+        GenericSurface(
+            reference_area=REFERENCE_AREA,
+            reference_length=REFERENCE_LENGTH,
+            coefficients=coefficients,
+        )
+
+
+def test_invalid_initialization_from_csv(filename_invalid_coeff):
+    """Checks if generic surfaces raises errors when initialized incorrectly
+    from a csv file"""
+    with pytest.raises(ValueError):
+        GenericSurface(
+            reference_area=REFERENCE_AREA,
+            reference_length=REFERENCE_LENGTH,
+            coefficients={"cL": str(filename_invalid_coeff)},
+        )
+
+
+@pytest.mark.parametrize(
+    "coefficients",
+    [
+        {},
+        {"cL": 0},
+        {
+            "cL": 0,
+            "cQ": Function(lambda x1, x2, x3, x4, x5, x6, x7: 0),
+            "cD": lambda x1, x2, x3, x4, x5, x6, x7: 0,
+        },
+    ],
+)
+def test_valid_initialization(coefficients):
+    """Checks if generic surface initializes correctly when coefficient
+    argument is valid"""
+
+    GenericSurface(
+        reference_area=REFERENCE_AREA,
+        reference_length=REFERENCE_LENGTH,
+        coefficients=coefficients,
+    )
+
+
+def test_valid_initialization_from_csv(filename_valid_coeff):
+    """Checks if generic surfaces initializes correctly when
+    coefficients is set from a csv file"""
+    GenericSurface(
+        reference_area=REFERENCE_AREA,
+        reference_length=REFERENCE_LENGTH,
+        coefficients={"cL": str(filename_valid_coeff)},
+    )
+
+
+def test_compute_forces_and_moments():
+    """Checks if there are not logical errors in
+    compute forces and moments"""
+
+    gs_object = GenericSurface(REFERENCE_AREA, REFERENCE_LENGTH, {})
+    forces_and_moments = gs_object.compute_forces_and_moments(
+        stream_velocity=Vector((0, 0, 0)),
+        stream_speed=0,
+        stream_mach=0,
+        rho=0,
+        cp=Vector((0, 0, 0)),
+        omega=(0, 0, 0),
+        reynolds=0,
+    )
+    assert forces_and_moments == (0, 0, 0, 0, 0, 0)

tests/unit/test_linear_generic_surfaces.py

@@ -0,0 +1,91 @@
+import pytest
+
+from rocketpy import Function, LinearGenericSurface
+from rocketpy.mathutils import Vector
+
+REFERENCE_AREA = 1
+REFERENCE_LENGTH = 1
+
+
+@pytest.mark.parametrize(
+    "coefficients",
+    [
+        "cL_0",
+        {"invalid_name": 0},
+        {"cL_0": "inexistent_file.csv"},
+        {"cL_0": Function(lambda x1, x2, x3, x4, x5, x6: 0)},
+        {"cL_0": lambda x1: 0},
+        {"cL_0": {}},
+    ],
+)
+def test_invalid_initialization(coefficients):
+    """Checks if linear generic surface raises errors in initialization
+    when coefficient argument is invalid"""
+
+    with pytest.raises((ValueError, TypeError)):
+        LinearGenericSurface(
+            reference_area=REFERENCE_AREA,
+            reference_length=REFERENCE_LENGTH,
+            coefficients=coefficients,
+        )
+
+
+def test_invalid_initialization_from_csv(filename_invalid_coeff_linear_generic_surface):
+    """Checks if linear generic surfaces raises errors when initialized incorrectly
+    from a csv file"""
+    with pytest.raises(ValueError):
+        LinearGenericSurface(
+            reference_area=REFERENCE_AREA,
+            reference_length=REFERENCE_LENGTH,
+            coefficients={"cL_0": str(filename_invalid_coeff_linear_generic_surface)},
+        )
+
+
+@pytest.mark.parametrize(
+    "coefficients",
+    [
+        {},
+        {"cL_0": 0},
+        {
+            "cL_0": 0,
+            "cQ_0": Function(lambda x1, x2, x3, x4, x5, x6, x7: 0),
+            "cD_0": lambda x1, x2, x3, x4, x5, x6, x7: 0,
+        },
+    ],
+)
+def test_valid_initialization(coefficients):
+    """Checks if linear generic surface initializes correctly when coefficient
+    argument is valid"""
+
+    LinearGenericSurface(
+        reference_area=REFERENCE_AREA,
+        reference_length=REFERENCE_LENGTH,
+        coefficients=coefficients,
+    )
+
+
+def test_valid_initialization_from_csv(filename_valid_coeff_linear_generic_surface):
+    """Checks if linear generic surfaces initializes correctly when
+    coefficients is set from a csv file"""
+    LinearGenericSurface(
+        reference_area=REFERENCE_AREA,
+        reference_length=REFERENCE_LENGTH,
+        coefficients={"cL_0": str(filename_valid_coeff_linear_generic_surface)},
+    )
+
+
+def test_compute_forces_and_moments():
+    """Checks if there are not logical errors in
+    compute forces and moments"""
+
+    lgs_object = LinearGenericSurface(REFERENCE_AREA, REFERENCE_LENGTH, {})
+    forces_and_moments = lgs_object.compute_forces_and_moments(
+        stream_velocity=Vector((0, 0, 0)),
+        stream_speed=1,
+        stream_mach=0,
+        rho=0,
+        cp=Vector((0, 0, 0)),
+        omega=(0, 0, 0),
+        reynolds=0,
+    )
+    assert forces_and_moments == (0, 0, 0, 0, 0, 0)