From 48f61d5ae367f0c8844c2268c9ff42af8a562532 Mon Sep 17 00:00:00 2001 From: Jan Caha Date: Tue, 16 Jul 2024 11:38:36 +0200 Subject: [PATCH] update tests --- tests/AlgorithmTestCase.py | 163 ---------- .../classes/test_sampling_distance_matrix.py | 1 - tests/conftest.py | 18 ++ tests/custom_assertions.py | 8 + .../create_los/test_tool_create_local_los.py | 10 +- .../test_tool_create_notarget_los.py | 296 +++++++++--------- .../test_tool_create_notarget_los_v2.py | 135 -------- .../test_tool_optimize_point_location.py | 181 +++++------ .../create_points/test_tool_points_around.py | 117 +++---- .../test_tool_points_in_direction.py | 195 +++++------- .../horizons/test_tool_extract_horizons.py | 2 +- 11 files changed, 373 insertions(+), 753 deletions(-) delete mode 100644 tests/AlgorithmTestCase.py delete mode 100644 tests/processing/create_los/test_tool_create_notarget_los_v2.py diff --git a/tests/AlgorithmTestCase.py b/tests/AlgorithmTestCase.py deleted file mode 100644 index beca850..0000000 --- a/tests/AlgorithmTestCase.py +++ /dev/null @@ -1,163 +0,0 @@ -import unittest - -from typing import Any, Dict, List - -from qgis.core import ( - QgsProcessingParameterDefinition, - QgsProcessingAlgorithm, - QgsVectorLayer, - QgsCoordinateReferenceSystem, - QgsProcessingFeedback, - QgsProcessingContext, -) -from qgis._core import QgsWkbTypes - - -class QgsProcessingAlgorithmTestCase(unittest.TestCase): - - def setUp(self) -> None: - self.feedback = QgsProcessingFeedback() - self.context = QgsProcessingContext() - self.alg: QgsProcessingAlgorithm = None - - def assertAlgSettings(self) -> None: - - self.assertIsInstance(self.alg.group(), (str, type(None))) - self.assertIsInstance(self.alg.groupId(), (str, type(None))) - self.assertIsInstance(self.alg.displayName(), str) - self.assertIsInstance(self.alg.name(), str) - self.assertIsInstance(self.alg.createInstance(), type(self.alg)) - self.assertIsInstance(self.alg.helpUrl(), (str, type(None))) - self.assertIsInstance(self.alg.shortHelpString(), (str, type(None))) - - def printAlgorithmParametersDescription(self) -> None: - if self.alg is not None: - print("{}".format(self.alg.name())) - print("----------------------------------") - - params = self.alg.parameterDefinitions() - - for p in params: - print("{} - {} \n\t {} \t{}".format(p.name(), p.type(), p.description(), - p.asScriptCode())) - - print("----------------------------------") - - outputs = self.alg.outputDefinitions() - - for o in outputs: - print("{} - {} \n\t {}".format(o.name(), o.type(), o.description())) - - else: - print("----------------------------------") - print("No algorithm provided!") - print("----------------------------------") - - def assertQgsProcessingParameter( - self, - parameter: QgsProcessingParameterDefinition, - parameter_type: str, - default_value: Any = None, - parent_parameter: str = None, - data_type: int = None, - ) -> None: - - if parameter_type != parameter.type(): - raise AssertionError("QgsProcessingParameter type error: {} != {}.".format( - parameter_type, parameter.type())) - - if default_value is not None: - if default_value != parameter.defaultValue(): - raise AssertionError( - "QgsProcessingParameter default value error: {} != {}.".format( - default_value, parameter.defaultValue())) - - if parent_parameter is not None: - if parent_parameter != parameter.parentLayerParameterName(): - raise AssertionError("QgsProcessingParameter parent layer error: {} != {}.".format( - parent_parameter, parameter.parentLayerParameterName())) - - if data_type is not None: - if data_type != parameter.dataType(): - raise AssertionError("QgsProcessingParameter data type error: {} != {}.".format( - data_type, parameter.dataType())) - - def assertCheckParameterValuesRaisesMessage(self, parameters: Dict, message: str) -> None: - - can_run, param_check_msg = self.alg.checkParameterValues(parameters=parameters, - context=self.context) - if can_run: - raise AssertionError("The `checkParameterValues` for algorithm should return `False`. " - "It returns `{}` instead.".format(can_run)) - - if message not in param_check_msg: - raise AssertionError( - "The provided message `{}` is not part of returned message `{}`.".format( - message, param_check_msg)) - - def assertRunAlgorithm(self, - parameters: Dict, - message: str = "", - allow_none_outputs: bool = False) -> None: - - can_run, param_check_msg = self.alg.checkParameterValues(parameters=parameters, - context=self.context) - - if not can_run: - raise AssertionError("The `checkParameterValues` for algorithm should return `True`. " - "It returns `{}` instead.".format(can_run)) - - if message not in param_check_msg: - raise AssertionError( - "The provided message `{}` is not part of returned message `{}`.".format( - message, param_check_msg)) - - result = self.alg.run(parameters=parameters, context=self.context, feedback=self.feedback) - - if len(result[0]) != len(self.alg.outputDefinitions()): - raise AssertionError( - "Number of provided outputs of the algorithm ({}) " - "does not match the number of outputs specified ({}). Result: {}".format( - len(result[0]), len(self.alg.outputDefinitions()), result)) - - if not allow_none_outputs: - for output, output_value in result[0].items(): - with self.subTest(output_name=output, output_value=output_value): - if output_value is None: - raise AssertionError( - "Output `{}` is `None`, which is not allowed " - "(unless the `allow_none_outputs` is set to `True`).".format(output)) - - def assertFieldNamesInQgsVectorLayer(self, field_names: List[str], - vector_layer: QgsVectorLayer) -> None: - - layer_field_names = vector_layer.fields().names() - - for field in field_names: - with self.subTest(field_name=field): - if field not in layer_field_names: - raise AssertionError( - "Field `{}` not found in fields of QgsVectorLayer [{}].".format( - field, ", ".join(layer_field_names))) - - def assertQgsVectorLayer( - self, - layer: QgsVectorLayer, - geom_type: QgsWkbTypes, - crs: QgsCoordinateReferenceSystem, - ) -> None: - - if not isinstance(layer, QgsVectorLayer): - raise AssertionError("Provided `layer` is not `QgsVectorLayer`. It is: `{}`.".format( - type(layer).__name__)) - - if geom_type != layer.wkbType(): - raise AssertionError( - "Expected `geom type` id `{}` != `{}` of the `layer.wkbType()`.".format( - geom_type, layer.wkbType())) - - if crs: - if layer.sourceCrs().authid() != crs.authid(): - raise AssertionError( - "The authid for `layer` crs ({}) does not match expected `crs` ({}).".format( - layer.sourceCrs().authid(), crs.authid())) diff --git a/tests/classes/test_sampling_distance_matrix.py b/tests/classes/test_sampling_distance_matrix.py index bb83f36..1146732 100755 --- a/tests/classes/test_sampling_distance_matrix.py +++ b/tests/classes/test_sampling_distance_matrix.py @@ -2,7 +2,6 @@ from los_tools.classes.sampling_distance_matrix import SamplingDistanceMatrix from los_tools.constants.field_names import FieldNames -from tests.AlgorithmTestCase import QgsProcessingAlgorithmTestCase def test_creation(table_angle_distance_size: QgsVectorLayer): diff --git a/tests/conftest.py b/tests/conftest.py index 69965b0..1448410 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -154,6 +154,12 @@ def horizon_line_local() -> QgsVectorLayer: return _vector_layer(data_file_path("horizon_line_local.gpkg")) +@pytest.fixture +@clean_qgis_layer +def horizon_line_global() -> QgsVectorLayer: + return _vector_layer(data_file_path("horizon_line_global.gpkg")) + + @pytest.fixture @clean_qgis_layer def layer_point() -> QgsVectorLayer: @@ -176,3 +182,15 @@ def layer_points() -> QgsVectorLayer: @clean_qgis_layer def layer_points_epsg5514() -> QgsVectorLayer: return _vector_layer(data_file_path("points_epsg_5514.gpkg")) + + +@pytest.fixture +@clean_qgis_layer +def layer_size_distance() -> QgsVectorLayer: + return _vector_layer(data_file_path("size_distance.xlsx")) + + +@pytest.fixture +@clean_qgis_layer +def layer_points_in_direction() -> QgsVectorLayer: + return _vector_layer(data_file_path("points_in_direction.gpkg")) diff --git a/tests/custom_assertions.py b/tests/custom_assertions.py index 86dfc9d..36a4978 100644 --- a/tests/custom_assertions.py +++ b/tests/custom_assertions.py @@ -1,6 +1,7 @@ from typing import Any, Dict, List, Optional from qgis.core import ( + Qgis, QgsCoordinateReferenceSystem, QgsProcessingAlgorithm, QgsProcessingContext, @@ -27,6 +28,7 @@ def assert_parameter( default_value: Optional[Any] = None, parent_parameter: Optional[str] = None, data_type: Optional[int] = None, + source_type: Optional[Qgis.ProcessingSourceType] = None, ) -> None: if parameter_type != parameter.type(): raise AssertionError(f"QgsProcessingParameter type error: {parameter_type} != {parameter.type()}.") @@ -47,6 +49,12 @@ def assert_parameter( if data_type != parameter.dataType(): raise AssertionError(f"QgsProcessingParameter data type error: {data_type} != {parameter.dataType()}.") + if source_type is not None: + if source_type != parameter.sourceType(): + raise AssertionError( + f"QgsProcessingParameter source type error: {source_type} != {parameter.sourceType()}." + ) + def assert_check_parameter_values(alg: QgsProcessingAlgorithm, parameters: Dict) -> None: can_run, param_check_msg = alg.checkParameterValues(parameters=parameters, context=QgsProcessingContext()) diff --git a/tests/processing/create_los/test_tool_create_local_los.py b/tests/processing/create_los/test_tool_create_local_los.py index 28ead19..c1ccd85 100644 --- a/tests/processing/create_los/test_tool_create_local_los.py +++ b/tests/processing/create_los/test_tool_create_local_los.py @@ -1,16 +1,8 @@ import pytest -from qgis.core import ( - Qgis, - QgsFeatureRequest, - QgsProcessingContext, - QgsProcessingFeedback, - QgsRasterLayer, - QgsVectorLayer, -) +from qgis.core import Qgis, QgsFeatureRequest, QgsRasterLayer, QgsVectorLayer from los_tools.constants.field_names import FieldNames from los_tools.processing.create_los.tool_create_local_los import CreateLocalLosAlgorithm -from tests.AlgorithmTestCase import QgsProcessingAlgorithmTestCase from tests.custom_assertions import ( assert_algorithm, assert_check_parameter_values, diff --git a/tests/processing/create_los/test_tool_create_notarget_los.py b/tests/processing/create_los/test_tool_create_notarget_los.py index 2d88a32..e8aeb31 100644 --- a/tests/processing/create_los/test_tool_create_notarget_los.py +++ b/tests/processing/create_los/test_tool_create_notarget_los.py @@ -1,155 +1,145 @@ -from qgis.core import (QgsVectorLayer, QgsRasterLayer, QgsFeatureRequest) -from qgis._core import QgsWkbTypes +import pytest +from qgis.core import Qgis, QgsRasterLayer, QgsVectorLayer -from los_tools.processing.create_los.tool_create_notarget_los import CreateNoTargetLosAlgorithm from los_tools.constants.field_names import FieldNames - -from tests.AlgorithmTestCase import QgsProcessingAlgorithmTestCase - -from tests.utils_tests import (get_data_path, get_data_path_results) - - -class CreateNoTargetLosAlgorithmTest(QgsProcessingAlgorithmTestCase): - - def setUp(self) -> None: - - super().setUp() - - self.observers = QgsVectorLayer(get_data_path(file="points.gpkg")) - self.observers_id = "id_point" - self.observers_offset = "observ_offset" - - self.targets = QgsVectorLayer(get_data_path(file="points_in_direction.gpkg")) - self.targets_id = "id_point" - self.targets_origin_id = FieldNames.ID_ORIGINAL_POINT - - self.dsm = QgsRasterLayer(get_data_path(file="dsm.tif")) - - self.output_path = get_data_path_results(file="los_no_target.gpkg") - - self.alg = CreateNoTargetLosAlgorithm() - self.alg.initAlgorithm() - - def test_parameters(self) -> None: - self.assertQgsProcessingParameter(self.alg.parameterDefinition("DemRasters"), - parameter_type="multilayer") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("ObserverPoints"), - parameter_type="source") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("ObserverIdField"), - parameter_type="field", - parent_parameter="ObserverPoints") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("ObserverOffset"), - parameter_type="field", - parent_parameter="ObserverPoints") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("TargetPoints"), - parameter_type="source") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("TargetIdField"), - parameter_type="field", - parent_parameter="TargetPoints") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("TargetDefinitionIdField"), - parameter_type="field", - parent_parameter="TargetPoints") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("LineDensity"), - parameter_type="distance", - default_value=1) - self.assertQgsProcessingParameter(self.alg.parameterDefinition("MaxLoSLength"), - parameter_type="distance", - default_value=0) - self.assertQgsProcessingParameter(self.alg.parameterDefinition("OutputLayer"), - parameter_type="sink") - - def test_alg_settings(self) -> None: - - self.assertAlgSettings() - - def test_check_wrong_params(self) -> None: - - # multiband raster fail - params = { - "DemRasters": [QgsRasterLayer(get_data_path(file="raster_multiband.tif"))], - "ObserverPoints": self.observers, - "ObserverIdField": self.observers_id, - "ObserverOffset": self.observers_offset, - "TargetPoints": self.targets, - "TargetIdField": self.targets_id, - "TargetDefinitionIdField": self.targets_origin_id - } - - self.assertCheckParameterValuesRaisesMessage( - parameters=params, - message="Rasters can only have one band. Currently there are rasters with `3` bands.") - - # observer layer with geographic coordinates - params = { - "DemRasters": [self.dsm], - "ObserverPoints": QgsVectorLayer(get_data_path(file="single_point_wgs84.gpkg")), - "ObserverIdField": self.observers_id, - "ObserverOffset": self.observers_offset, - "TargetPoints": self.targets, - "TargetIdField": self.targets_id, - "TargetDefinitionIdField": self.targets_origin_id - } - - self.assertCheckParameterValuesRaisesMessage( - parameters=params, message="`Observers point layer` crs must be projected.") - - # raster crs != observers crs - params = { - "DemRasters": [QgsRasterLayer(get_data_path(file="dsm_epsg_5514.tif"))], - "ObserverPoints": self.observers, - "ObserverIdField": self.observers_id, - "ObserverOffset": self.observers_offset, - "TargetPoints": self.targets, - "TargetIdField": self.targets_id, - "TargetDefinitionIdField": self.targets_origin_id - } - - self.assertCheckParameterValuesRaisesMessage( - parameters=params, - message="Provided crs template and raster layers crs must be equal.") - - # observers crs != target crs - params = { - "DemRasters": [self.dsm], - "ObserverPoints": self.observers, - "TargetPoints": QgsVectorLayer(get_data_path(file="points_epsg_5514.gpkg")), - "ObserverIdField": self.observers_id, - "ObserverOffset": self.observers_offset, - "TargetIdField": self.targets_id, - "TargetDefinitionIdField": self.targets_origin_id - } - - self.assertCheckParameterValuesRaisesMessage( - parameters=params, - message="`Observers point layer` and `Targets point layer` crs must be equal.") - - def test_run_alg(self) -> None: - - params = { - "DemRasters": [self.dsm], - "ObserverPoints": self.observers, - "ObserverIdField": self.observers_id, - "ObserverOffset": self.observers_offset, - "TargetPoints": self.targets, - "TargetIdField": self.targets_id, - "TargetDefinitionIdField": self.targets_origin_id, - "LineDensity": 1, - "MaxLoSLength": 0, - "OutputLayer": self.output_path, - } - - self.assertRunAlgorithm(parameters=params) - - los_layer = QgsVectorLayer(self.output_path) - - self.assertQgsVectorLayer(los_layer, - geom_type=QgsWkbTypes.LineStringZ, - crs=self.observers.sourceCrs()) - - self.assertFieldNamesInQgsVectorLayer([ - FieldNames.LOS_TYPE, FieldNames.ID_OBSERVER, FieldNames.ID_TARGET, - FieldNames.OBSERVER_OFFSET, FieldNames.AZIMUTH, FieldNames.OBSERVER_X, - FieldNames.OBSERVER_Y - ], los_layer) - - self.assertEqual(self.targets.featureCount(), los_layer.featureCount()) +from los_tools.processing.create_los.tool_create_notarget_los import CreateNoTargetLosAlgorithm +from tests.custom_assertions import ( + assert_algorithm, + assert_check_parameter_values, + assert_field_names_exist, + assert_layer, + assert_parameter, + assert_run, +) +from tests.utils import result_filename + +OBSERVERS_ID = "id_point" +OBSERVERS_OFFSET = "observ_offset" +TARGETS_ID = "id_point" +ORIGINAL_POINT_ID = "id_original_point" + + +def test_parameters() -> None: + alg = CreateNoTargetLosAlgorithm() + alg.initAlgorithm() + + assert_parameter(alg.parameterDefinition("DemRasters"), parameter_type="multilayer") + assert_parameter(alg.parameterDefinition("LineSettingsTable"), parameter_type="vector") + assert_parameter(alg.parameterDefinition("ObserverPoints"), parameter_type="source") + assert_parameter( + alg.parameterDefinition("ObserverIdField"), parameter_type="field", parent_parameter="ObserverPoints" + ) + assert_parameter( + alg.parameterDefinition("ObserverOffset"), parameter_type="field", parent_parameter="ObserverPoints" + ) + assert_parameter(alg.parameterDefinition("TargetPoints"), parameter_type="source") + assert_parameter(alg.parameterDefinition("TargetIdField"), parameter_type="field", parent_parameter="TargetPoints") + assert_parameter( + alg.parameterDefinition("TargetDefinitionIdField"), parameter_type="field", parent_parameter="TargetPoints" + ) + assert_parameter(alg.parameterDefinition("OutputLayer"), parameter_type="sink") + + +def test_alg_settings() -> None: + alg = CreateNoTargetLosAlgorithm() + alg.initAlgorithm() + + assert_algorithm(alg) + + +def test_wrong_params( + raster_small: QgsRasterLayer, + raster_multi_band: QgsRasterLayer, + raster_wrong_crs: QgsRasterLayer, + layer_points: QgsVectorLayer, + layer_point: QgsVectorLayer, + layer_point_wgs84: QgsVectorLayer, + layer_points_epsg5514: QgsVectorLayer, +) -> None: + alg = CreateNoTargetLosAlgorithm() + alg.initAlgorithm() + + # multiband raster fail + params = { + "DemRasters": [raster_multi_band], + "ObserverPoints": layer_points, + "TargetPoints": layer_point, + } + + with pytest.raises(AssertionError, match="Rasters can only have one band"): + assert_check_parameter_values(alg, params) + + # observer layer with geographic coordinates + params = { + "DemRasters": [raster_small], + "ObserverPoints": layer_point_wgs84, + "TargetPoints": layer_point, + } + + with pytest.raises(AssertionError, match="`Observers point layer` crs must be projected."): + assert_check_parameter_values(alg, params) + + # raster crs != observers crs + params = { + "DemRasters": [raster_wrong_crs], + "ObserverPoints": layer_points, + "TargetPoints": layer_point, + } + + with pytest.raises(AssertionError, match="Provided crs template and raster layers crs must be equal"): + assert_check_parameter_values(alg, params) + + # observers crs != target crs + params = { + "DemRasters": [raster_small], + "ObserverPoints": layer_points, + "TargetPoints": layer_points_epsg5514, + } + + with pytest.raises(AssertionError, match="`Observers point layer` and `Targets point layer` crs must be equal."): + assert_check_parameter_values(alg, params) + + +def test_run_alg( + raster_small: QgsRasterLayer, + layer_size_distance: QgsVectorLayer, + layer_points: QgsVectorLayer, + layer_points_in_direction: QgsVectorLayer, +) -> None: + alg = CreateNoTargetLosAlgorithm() + alg.initAlgorithm() + + output_path = result_filename("los_no_target.gpkg") + + params = { + "DemRasters": [raster_small], + "LineSettingsTable": layer_size_distance, + "ObserverPoints": layer_points, + "ObserverIdField": OBSERVERS_ID, + "ObserverOffset": OBSERVERS_OFFSET, + "TargetPoints": layer_points_in_direction, + "TargetIdField": TARGETS_ID, + "TargetDefinitionIdField": ORIGINAL_POINT_ID, + "OutputLayer": output_path, + } + + assert_run(alg, params) + + los_layer = QgsVectorLayer(output_path) + + assert_layer(los_layer, geom_type=Qgis.WkbType.LineStringZ, crs=layer_points.sourceCrs()) + + assert_field_names_exist( + [ + FieldNames.LOS_TYPE, + FieldNames.ID_OBSERVER, + FieldNames.ID_TARGET, + FieldNames.OBSERVER_OFFSET, + FieldNames.AZIMUTH, + FieldNames.OBSERVER_X, + FieldNames.OBSERVER_Y, + ], + los_layer, + ) + + assert layer_points_in_direction.featureCount() == los_layer.featureCount() diff --git a/tests/processing/create_los/test_tool_create_notarget_los_v2.py b/tests/processing/create_los/test_tool_create_notarget_los_v2.py deleted file mode 100644 index 583fb88..0000000 --- a/tests/processing/create_los/test_tool_create_notarget_los_v2.py +++ /dev/null @@ -1,135 +0,0 @@ -from qgis.core import (QgsVectorLayer, QgsRasterLayer) -from qgis._core import QgsWkbTypes - -from los_tools.processing.create_los.tool_create_notarget_los_v2 import CreateNoTargetLosAlgorithmV2 -from los_tools.constants.field_names import FieldNames - -from tests.AlgorithmTestCase import QgsProcessingAlgorithmTestCase - -from tests.utils_tests import (get_data_path, get_data_path_results) - - -class CreateNoTargetLosAlgorithmTest(QgsProcessingAlgorithmTestCase): - - def setUp(self) -> None: - - super().setUp() - - self.observers = QgsVectorLayer(get_data_path(file="points.gpkg")) - self.observers_id = "id_point" - self.observers_offset = "observ_offset" - - self.targets = QgsVectorLayer(get_data_path(file="points_in_direction.gpkg")) - self.targets_id = "id_point" - self.targets_origin_id = FieldNames.ID_ORIGINAL_POINT - - self.dsm = QgsRasterLayer(get_data_path(file="dsm.tif")) - - self.table = QgsVectorLayer(get_data_path(file="size_distance.xlsx")) - - self.output_path = get_data_path_results(file="los_no_target_v2.gpkg") - - self.alg = CreateNoTargetLosAlgorithmV2() - self.alg.initAlgorithm() - - def test_parameters(self) -> None: - - self.assertQgsProcessingParameter(self.alg.parameterDefinition("DemRasters"), - parameter_type="multilayer") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("LineSettingsTable"), - parameter_type="source") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("ObserverPoints"), - parameter_type="source") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("ObserverIdField"), - parameter_type="field", - parent_parameter="ObserverPoints") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("ObserverOffset"), - parameter_type="field", - parent_parameter="ObserverPoints") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("TargetPoints"), - parameter_type="source") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("TargetIdField"), - parameter_type="field", - parent_parameter="TargetPoints") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("TargetDefinitionIdField"), - parameter_type="field", - parent_parameter="TargetPoints") - self.assertQgsProcessingParameter(self.alg.parameterDefinition("OutputLayer"), - parameter_type="sink") - - def test_alg_settings(self) -> None: - - self.assertAlgSettings() - - def test_check_wrong_params(self) -> None: - - # multiband raster fail - params = { - "DemRasters": [get_data_path(file="raster_multiband.tif")], - 'ObserverPoints': self.observers, - 'TargetPoints': self.targets - } - - self.assertCheckParameterValuesRaisesMessage(parameters=params, - message="can only have one band.") - - # observer layer with geographic coordinates - params = { - "DemRasters": [self.dsm], - "ObserverPoints": QgsVectorLayer(get_data_path(file="single_point_wgs84.gpkg")), - 'TargetPoints': self.targets - } - - self.assertCheckParameterValuesRaisesMessage( - parameters=params, message="`Observers point layer` crs must be projected.") - - # raster crs != observers crs - params = { - "DemRasters": [get_data_path(file="dsm_epsg_5514.tif")], - "ObserverPoints": self.observers, - 'TargetPoints': self.targets - } - - self.assertCheckParameterValuesRaisesMessage( - parameters=params, message="Provided crs template and raster layers crs must be equal") - - # observers crs != target crs - params = { - "DemRasters": [self.dsm], - "ObserverPoints": self.observers, - "TargetPoints": QgsVectorLayer(get_data_path(file="points_epsg_5514.gpkg")) - } - - self.assertCheckParameterValuesRaisesMessage( - parameters=params, - message="`Observers point layer` and `Targets point layer` crs must be equal.") - - def test_run_alg(self) -> None: - - params = { - 'DemRasters': [self.dsm], - 'LineSettingsTable': self.table, - 'ObserverPoints': self.observers, - 'ObserverIdField': self.observers_id, - 'ObserverOffset': self.observers_offset, - 'TargetPoints': self.targets, - 'TargetIdField': self.targets_id, - 'TargetDefinitionIdField': self.targets_origin_id, - 'OutputLayer': self.output_path - } - - self.assertRunAlgorithm(parameters=params) - - los_layer = QgsVectorLayer(self.output_path) - - self.assertQgsVectorLayer(los_layer, - geom_type=QgsWkbTypes.LineStringZ, - crs=self.observers.sourceCrs()) - - self.assertFieldNamesInQgsVectorLayer([ - FieldNames.LOS_TYPE, FieldNames.ID_OBSERVER, FieldNames.ID_TARGET, - FieldNames.OBSERVER_OFFSET, FieldNames.AZIMUTH, FieldNames.OBSERVER_X, - FieldNames.OBSERVER_Y - ], los_layer) - - self.assertEqual(self.targets.featureCount(), los_layer.featureCount()) diff --git a/tests/processing/create_points/test_tool_optimize_point_location.py b/tests/processing/create_points/test_tool_optimize_point_location.py index f716291..90c866d 100644 --- a/tests/processing/create_points/test_tool_optimize_point_location.py +++ b/tests/processing/create_points/test_tool_optimize_point_location.py @@ -1,130 +1,105 @@ -import unittest - -from qgis.core import (QgsVectorLayer, QgsRasterLayer, QgsProcessingFeedback, QgsProcessingContext) +import pytest +from qgis.core import Qgis, QgsProcessingContext, QgsProcessingFeedback, QgsRasterLayer, QgsVectorLayer from los_tools.processing.create_points.tool_optimize_point_location import OptimizePointLocationAlgorithm +from tests.custom_assertions import ( + assert_algorithm, + assert_check_parameter_values, + assert_field_names_exist, + assert_layer, + assert_parameter, + assert_run, +) +from tests.utils import result_filename -from tests.AlgorithmTestCase import QgsProcessingAlgorithmTestCase -from tests.utils_tests import (print_alg_params, print_alg_outputs, get_data_path, - get_data_path_results) - - -class OptimizePointLocationAlgorithmTest(QgsProcessingAlgorithmTestCase): - - def setUp(self) -> None: - self.feedback = QgsProcessingFeedback() - self.context = QgsProcessingContext() - - self.points = QgsVectorLayer(get_data_path(file="points.gpkg")) - - self.raster = QgsRasterLayer(get_data_path(file="dsm.tif")) - - self.alg = OptimizePointLocationAlgorithm() - self.alg.initAlgorithm() - - @unittest.skip("printing not necessary `test_show_params()`") - def test_show_params(self) -> None: - print("{}".format(self.alg.name())) - print("----------------------------------") - print_alg_params(self.alg) - print("----------------------------------") - print_alg_outputs(self.alg) - - def test_parameters(self) -> None: - - param_input_raster = self.alg.parameterDefinition("InputRaster") - param_input_points = self.alg.parameterDefinition("InputLayer") - param_distance = self.alg.parameterDefinition("Distance") - param_mask_raster = self.alg.parameterDefinition("MaskRaster") - param_output_layer = self.alg.parameterDefinition("OutputLayer") - - self.assertEqual("raster", param_input_raster.type()) - self.assertEqual("source", param_input_points.type()) - self.assertEqual("distance", param_distance.type()) - self.assertEqual("raster", param_mask_raster.type()) - self.assertEqual("sink", param_output_layer.type()) - - self.assertEqual(30, param_distance.defaultValue()) - - def test_alg_settings(self) -> None: - self.assertAlgSettings() +def test_parameters() -> None: + alg = OptimizePointLocationAlgorithm() + alg.initAlgorithm() - def test_check_wrong_params(self) -> None: + assert_parameter(alg.parameterDefinition("InputRaster"), parameter_type="raster") + assert_parameter(alg.parameterDefinition("InputLayer"), parameter_type="source") + assert_parameter(alg.parameterDefinition("Distance"), parameter_type="distance") + assert_parameter(alg.parameterDefinition("MaskRaster"), parameter_type="raster") + assert_parameter(alg.parameterDefinition("OutputLayer"), parameter_type="sink") - # multiband raster fail - params = {"InputRaster": QgsRasterLayer(get_data_path(file="raster_multiband.tif"))} - can_run, msg = self.alg.checkParameterValues(params, context=self.context) +def test_alg_settings() -> None: + alg = OptimizePointLocationAlgorithm() + alg.initAlgorithm() - self.assertFalse(can_run) - self.assertIn("`Location optimization raster` can only have one band.", msg) + assert_algorithm(alg) - # observer layer with geographic coordinates - params = { - "InputRaster": self.raster, - "InputLayer": QgsVectorLayer(get_data_path(file="single_point_wgs84.gpkg")), - } - can_run, msg = self.alg.checkParameterValues(params, context=self.context) +def test_wrong_params( + raster_multi_band: QgsRasterLayer, + raster_small: QgsRasterLayer, + layer_point_wgs84: QgsVectorLayer, + raster_wrong_crs: QgsRasterLayer, + layer_points: QgsVectorLayer, +) -> None: + alg = OptimizePointLocationAlgorithm() + alg.initAlgorithm() - self.assertFalse(can_run) - self.assertIn("`Input point layer` crs must be projected.", msg) + # multiband raster fail + params = {"InputRaster": raster_multi_band} - # raster crs != observers crs - params = { - "InputRaster": QgsRasterLayer(get_data_path(file="dsm_epsg_5514.tif")), - "InputLayer": self.points - } + with pytest.raises(AssertionError, match="`Location optimization raster` can only have one band."): + assert_check_parameter_values(alg, parameters=params) - can_run, msg = self.alg.checkParameterValues(params, context=self.context) + # observer layer with geographic coordinates + params = { + "InputRaster": raster_small, + "InputLayer": layer_point_wgs84, + } - self.assertFalse(can_run) - self.assertIn("`Input point layer` and `Location optimization raster` crs must be equal.", - msg) + with pytest.raises(AssertionError, match="`Input point layer` crs must be projected."): + assert_check_parameter_values(alg, parameters=params) + # raster crs != observers crs + params = {"InputRaster": raster_wrong_crs, "InputLayer": layer_points} - # mask raster errors - params = { - "InputRaster": self.raster, - "InputLayer": self.points, - "MaskRaster": QgsRasterLayer(get_data_path(file="raster_multiband.tif")) - } + with pytest.raises( + AssertionError, match="`Input point layer` and `Location optimization raster` crs must be equal." + ): + assert_check_parameter_values(alg, parameters=params) - can_run, msg = self.alg.checkParameterValues(params, context=self.context) + # mask raster errors + params = { + "InputRaster": raster_small, + "InputLayer": layer_points, + "MaskRaster": raster_multi_band, + } - self.assertFalse(can_run) - self.assertIn("`Mask raster` can only have one band.", msg) + with pytest.raises(AssertionError, match="`Mask raster` can only have one band."): + assert_check_parameter_values(alg, parameters=params) - params = { - "InputRaster": self.raster, - "InputLayer": self.points, - "MaskRaster": QgsRasterLayer(get_data_path(file="dsm_epsg_5514.tif")) - } + params = { + "InputRaster": raster_small, + "InputLayer": layer_points, + "MaskRaster": raster_wrong_crs, + } - can_run, msg = self.alg.checkParameterValues(params, context=self.context) + with pytest.raises(AssertionError, match="CRS for `Mask raster` and `Location optimization raster` must be equal."): + assert_check_parameter_values(alg, parameters=params) - self.assertFalse(can_run) - self.assertIn("CRS for `Mask raster` and `Location optimization raster` must be equal.", - msg) - def test_run_alg(self): +def test_run_alg(raster_small: QgsRasterLayer, layer_points: QgsVectorLayer) -> None: + alg = OptimizePointLocationAlgorithm() + alg.initAlgorithm() - output_path = get_data_path_results(file="points_optimized.gpkg") + output_path = result_filename("points_optimized.gpkg") - params = { - "InputRaster": self.raster, - "InputLayer": self.points, - "Distance": 10, - "OutputLayer": output_path, - } + params = { + "InputRaster": raster_small, + "InputLayer": layer_points, + "Distance": 10, + "OutputLayer": output_path, + } - self.alg.run(parameters=params, context=self.context, feedback=self.feedback) + assert_run(alg, params) - output_layer = QgsVectorLayer(output_path) + output_layer = QgsVectorLayer(output_path) - self.assertQgsVectorLayer(output_layer, - geom_type=self.points.wkbType(), - crs=self.points.sourceCrs()) + assert_layer(output_layer, geom_type=Qgis.WkbType.Point, crs=layer_points.sourceCrs()) - self.assertIsInstance(output_layer, QgsVectorLayer) - self.assertEqual(self.points.featureCount(), output_layer.featureCount()) + assert layer_points.featureCount() == output_layer.featureCount() diff --git a/tests/processing/create_points/test_tool_points_around.py b/tests/processing/create_points/test_tool_points_around.py index 4151ce9..0a0a225 100644 --- a/tests/processing/create_points/test_tool_points_around.py +++ b/tests/processing/create_points/test_tool_points_around.py @@ -1,89 +1,60 @@ -import unittest +from qgis.core import Qgis, QgsVectorLayer -from qgis.core import (QgsVectorLayer, QgsProcessingFeedback, QgsProcessingContext) - -from los_tools.processing.create_points.tool_points_around import CreatePointsAroundAlgorithm from los_tools.constants.field_names import FieldNames +from los_tools.processing.create_points.tool_points_around import CreatePointsAroundAlgorithm +from tests.custom_assertions import ( + assert_algorithm, + assert_field_names_exist, + assert_layer, + assert_parameter, + assert_run, +) +from tests.utils import result_filename -from tests.AlgorithmTestCase import QgsProcessingAlgorithmTestCase -from tests.utils_tests import (print_alg_params, print_alg_outputs, get_data_path, - get_data_path_results) - - -class CreatePointsAroundAlgorithmTest(QgsProcessingAlgorithmTestCase): - - def setUp(self) -> None: - self.feedback = QgsProcessingFeedback() - self.context = QgsProcessingContext() - - self.points = QgsVectorLayer(get_data_path(file="points.gpkg")) - - self.alg = CreatePointsAroundAlgorithm() - self.alg.initAlgorithm() - - @unittest.skip("printing not necessary `test_show_params()`") - def test_show_params(self) -> None: - print("{}".format(self.alg.name())) - print("----------------------------------") - print_alg_params(self.alg) - print("----------------------------------") - print_alg_outputs(self.alg) - - def test_parameters(self) -> None: - - param_input_layer = self.alg.parameterDefinition("InputLayer") - param_id_field = self.alg.parameterDefinition("IdField") - param_angle_start = self.alg.parameterDefinition("AngleStart") - param_angle_end = self.alg.parameterDefinition("AngleEnd") - param_angle_step = self.alg.parameterDefinition("AngleStep") - param_distance = self.alg.parameterDefinition("Distance") - param_output_layer = self.alg.parameterDefinition("OutputLayer") - - self.assertEqual("source", param_input_layer.type()) - self.assertEqual("field", param_id_field.type()) - self.assertEqual("number", param_angle_start.type()) - self.assertEqual("number", param_angle_end.type()) - self.assertEqual("number", param_angle_step.type()) - self.assertEqual("distance", param_distance.type()) - self.assertEqual("sink", param_output_layer.type()) - self.assertIn("InputLayer", param_distance.dependsOnOtherParameters()) +def test_parameters() -> None: + alg = CreatePointsAroundAlgorithm() + alg.initAlgorithm() - self.assertEqual(0, param_angle_start.defaultValue()) - self.assertEqual(359.999, param_angle_end.defaultValue()) - self.assertEqual(1, param_angle_step.defaultValue()) - self.assertEqual(10, param_distance.defaultValue()) + assert_parameter(alg.parameterDefinition("InputLayer"), parameter_type="source") + assert_parameter(alg.parameterDefinition("IdField"), parameter_type="field", parent_parameter="InputLayer") + assert_parameter(alg.parameterDefinition("AngleStart"), parameter_type="number", default_value=0) + assert_parameter(alg.parameterDefinition("AngleEnd"), parameter_type="number", default_value=359.999) + assert_parameter(alg.parameterDefinition("AngleStep"), parameter_type="number", default_value=1) + assert_parameter(alg.parameterDefinition("Distance"), parameter_type="distance", default_value=10) + assert_parameter(alg.parameterDefinition("OutputLayer"), parameter_type="sink") - def test_alg_settings(self) -> None: - self.assertAlgSettings() +def test_alg_settings() -> None: + alg = CreatePointsAroundAlgorithm() + alg.initAlgorithm() - def test_check_wrong_params(self) -> None: - # does not apply, there are no checks for parameters - pass + assert_algorithm(alg) - def test_run_alg(self): - output_path = get_data_path_results(file="points_around.gpkg") +def test_run(layer_points: QgsVectorLayer) -> None: + alg = CreatePointsAroundAlgorithm() + alg.initAlgorithm() - params = { - "InputLayer": self.points, - "IdField": "id_point", - "AngleStart": 0, - "AngleEnd": 359, - "AngleStep": 1, - "Distance": 5, - "OutputLayer": output_path, - } + output_path = result_filename("points_around.gpkg") - self.alg.run(parameters=params, context=self.context, feedback=self.feedback) + params = { + "InputLayer": layer_points, + "IdField": "id_point", + "AngleStart": 0, + "AngleEnd": 359, + "AngleStep": 1, + "Distance": 5, + "OutputLayer": output_path, + } - output_layer = QgsVectorLayer(output_path) + assert_run(alg, parameters=params) - self.assertIsInstance(output_layer, QgsVectorLayer) + output_layer = QgsVectorLayer(output_path) - self.assertEqual(2160, output_layer.featureCount()) + assert_layer(output_layer, Qgis.WkbType.Point, crs=layer_points.crs()) + assert output_layer.featureCount() == 2160 - self.assertFieldNamesInQgsVectorLayer( - [FieldNames.ID_ORIGINAL_POINT, FieldNames.AZIMUTH, FieldNames.ANGLE_STEP_POINTS], - output_layer) + assert_field_names_exist( + [FieldNames.ID_ORIGINAL_POINT, FieldNames.AZIMUTH, FieldNames.ANGLE_STEP_POINTS], output_layer + ) diff --git a/tests/processing/create_points/test_tool_points_in_direction.py b/tests/processing/create_points/test_tool_points_in_direction.py index e53630d..625b1c1 100644 --- a/tests/processing/create_points/test_tool_points_in_direction.py +++ b/tests/processing/create_points/test_tool_points_in_direction.py @@ -1,147 +1,112 @@ -import unittest - -import numpy as np import math -from qgis.core import (QgsVectorLayer, QgsFeatureRequest, QgsProcessingFeedback, - QgsProcessingContext) +import numpy as np +import pytest +from qgis.core import QgsFeatureRequest, QgsProcessingContext, QgsProcessingFeedback, QgsVectorLayer -from los_tools.processing.create_points.tool_points_in_direction import CreatePointsInDirectionAlgorithm from los_tools.constants.field_names import FieldNames +from los_tools.processing.create_points.tool_points_in_direction import CreatePointsInDirectionAlgorithm +from tests.custom_assertions import ( + assert_algorithm, + assert_check_parameter_values, + assert_field_names_exist, + assert_layer, + assert_parameter, + assert_run, +) +from tests.utils import result_filename -from tests.AlgorithmTestCase import QgsProcessingAlgorithmTestCase -from tests.utils_tests import (print_alg_params, print_alg_outputs, get_data_path, - get_data_path_results) - - -class CreatePointsInDirectionAlgorithmTest(QgsProcessingAlgorithmTestCase): - - def setUp(self) -> None: - self.points = QgsVectorLayer(get_data_path(file="points.gpkg")) - self.points_id_field = "id_point" - self.single_point = QgsVectorLayer(get_data_path(file="single_point.gpkg")) - - self.alg = CreatePointsInDirectionAlgorithm() - self.alg.initAlgorithm() - - self.feedback = QgsProcessingFeedback() - self.context = QgsProcessingContext() - - @unittest.skip("printing not necessary `test_show_params()`") - def test_show_params(self) -> None: - print("{}".format(self.alg.name())) - print("----------------------------------") - print_alg_params(self.alg) - print("----------------------------------") - print_alg_outputs(self.alg) - - def test_parameters(self) -> None: - - param_input_layer = self.alg.parameterDefinition("InputLayer") - param_id_field = self.alg.parameterDefinition("IdField") - param_direction_layer = self.alg.parameterDefinition("DirectionLayer") - param_angle_offset = self.alg.parameterDefinition("AngleOffset") - param_angle_step = self.alg.parameterDefinition("AngleStep") - param_distance = self.alg.parameterDefinition("Distance") - param_output_layer = self.alg.parameterDefinition("OutputLayer") - - self.assertEqual("source", param_input_layer.type()) - self.assertEqual("field", param_id_field.type()) - self.assertEqual("source", param_direction_layer.type()) - self.assertEqual("number", param_angle_offset.type()) - self.assertEqual("number", param_angle_step.type()) - self.assertEqual("distance", param_distance.type()) - self.assertEqual("sink", param_output_layer.type()) - self.assertEqual("InputLayer", param_id_field.parentLayerParameterName()) - self.assertIn("InputLayer", param_distance.dependsOnOtherParameters()) +def test_parameters() -> None: + alg = CreatePointsInDirectionAlgorithm() + alg.initAlgorithm() - self.assertEqual(20, param_angle_offset.defaultValue()) - self.assertEqual(1, param_angle_step.defaultValue()) - self.assertEqual(10, param_distance.defaultValue()) + assert_parameter(alg.parameterDefinition("InputLayer"), parameter_type="source") + assert_parameter(alg.parameterDefinition("IdField"), parameter_type="field", parent_parameter="InputLayer") + assert_parameter(alg.parameterDefinition("DirectionLayer"), parameter_type="source") + assert_parameter(alg.parameterDefinition("AngleOffset"), parameter_type="number", default_value=20) + assert_parameter(alg.parameterDefinition("AngleStep"), parameter_type="number", default_value=1) + assert_parameter(alg.parameterDefinition("Distance"), parameter_type="distance", default_value=10) + assert_parameter(alg.parameterDefinition("OutputLayer"), parameter_type="sink") - def test_alg_settings(self) -> None: - self.assertAlgSettings() +def test_alg_settings() -> None: + alg = CreatePointsInDirectionAlgorithm() + alg.initAlgorithm() - def test_check_wrong_params(self) -> None: + assert_algorithm(alg) - output_path = get_data_path_results(file="points_direction.gpkg") - params = { - "InputLayer": self.points, - "IdField": self.points_id_field, - "DirectionLayer": self.points, - "AngleOffset": 10, - "AngleStep": 0.5, - "Distance": 10, - "OutputLayer": output_path, - } +def test_wrong_params(layer_points: QgsVectorLayer) -> None: + alg = CreatePointsInDirectionAlgorithm() + alg.initAlgorithm() - can_run, msg = self.alg.checkParameterValues(params, context=self.context) + output_path = result_filename("points_direction.gpkg") - self.assertFalse(can_run) - self.assertIn("`Main direction point layer` should only containt one feature.", msg) + params = { + "InputLayer": layer_points, + "IdField": "id_point", + "DirectionLayer": layer_points, + "AngleOffset": 10, + "AngleStep": 0.5, + "Distance": 10, + "OutputLayer": output_path, + } - def test_run_alg(self) -> None: + with pytest.raises(AssertionError, match="`Main direction point layer` should only containt one feature."): + assert_check_parameter_values(alg, parameters=params) - output_path = get_data_path_results(file="points_direction.gpkg") - angle_offset = 20 - angle_step = 1 - distance = 10 +def test_run(layer_points: QgsVectorLayer, layer_point: QgsVectorLayer) -> None: + alg = CreatePointsInDirectionAlgorithm() + alg.initAlgorithm() - params = { - "InputLayer": self.points, - "IdField": self.points_id_field, - "DirectionLayer": self.single_point, - "AngleOffset": angle_offset, - "AngleStep": angle_step, - "Distance": distance, - "OutputLayer": output_path, - } + output_path = result_filename("points_direction.gpkg") - can_run, msg = self.alg.checkParameterValues(params, context=self.context) + angle_offset = 20 + angle_step = 1 + distance = 10 - self.assertTrue(can_run) - self.assertIn("", msg) + params = { + "InputLayer": layer_points, + "IdField": "id_point", + "DirectionLayer": layer_point, + "AngleOffset": angle_offset, + "AngleStep": angle_step, + "Distance": distance, + "OutputLayer": output_path, + } - self.alg.run(parameters=params, context=self.context, feedback=self.feedback) + assert_run(alg, parameters=params) - output_layer = QgsVectorLayer(output_path) + output_layer = QgsVectorLayer(output_path) - self.assertIn(FieldNames.ID_ORIGINAL_POINT, output_layer.fields().names()) - self.assertIn(FieldNames.ID_POINT, output_layer.fields().names()) - self.assertIn(FieldNames.AZIMUTH, output_layer.fields().names()) - self.assertIn(FieldNames.ANGLE_STEP_POINTS, output_layer.fields().names()) + assert_field_names_exist( + [FieldNames.ID_ORIGINAL_POINT, FieldNames.ID_POINT, FieldNames.AZIMUTH, FieldNames.ANGLE_STEP_POINTS], + output_layer, + ) - unique_ids_orig = list( - self.points.uniqueValues(self.points.fields().lookupField(self.points_id_field))) - unique_ids_new = list( - output_layer.uniqueValues(output_layer.fields().lookupField( - FieldNames.ID_ORIGINAL_POINT))) + unique_ids_orig = list(layer_points.uniqueValues(layer_points.fields().lookupField("id_point"))) + unique_ids_new = list(output_layer.uniqueValues(output_layer.fields().lookupField(FieldNames.ID_ORIGINAL_POINT))) - self.assertListEqual(unique_ids_orig, unique_ids_new) + assert unique_ids_orig == unique_ids_new - angles = np.arange(0 - angle_offset, 0 + angle_offset + 0.1 * angle_step, - step=angle_step).tolist() + angles = np.arange(0 - angle_offset, 0 + angle_offset + 0.1 * angle_step, step=angle_step).tolist() - number_of_elements = len(angles) * len(unique_ids_orig) + number_of_elements = len(angles) * len(unique_ids_orig) - self.assertEqual(number_of_elements, output_layer.featureCount()) + assert number_of_elements == output_layer.featureCount() - for id_orig in unique_ids_orig: + for id_orig in unique_ids_orig: - request = QgsFeatureRequest() - request.setFilterExpression("{} = '{}'".format(FieldNames.ID_ORIGINAL_POINT, id_orig)) - order_by_clause = QgsFeatureRequest.OrderByClause(FieldNames.AZIMUTH, ascending=True) - request.setOrderBy(QgsFeatureRequest.OrderBy([order_by_clause])) + request = QgsFeatureRequest() + request.setFilterExpression(f"{FieldNames.ID_ORIGINAL_POINT} = '{id_orig}'") + order_by_clause = QgsFeatureRequest.OrderByClause(FieldNames.AZIMUTH, ascending=True) + request.setOrderBy(QgsFeatureRequest.OrderBy([order_by_clause])) - features = list(output_layer.getFeatures(request)) + features = list(output_layer.getFeatures(request)) - for i in range(0, len(features) - 1): - with self.subTest(id_original_point=id_orig, point_range=i): - self.assertAlmostEqual(features[i].geometry().distance(features[i + - 1].geometry()), - math.radians(angle_step) * distance, - places=5) + for i in range(0, len(features) - 1): + assert features[i].geometry().distance(features[i + 1].geometry()) == pytest.approx( + math.radians(angle_step) * distance, abs=0.00001 + ) diff --git a/tests/processing/horizons/test_tool_extract_horizons.py b/tests/processing/horizons/test_tool_extract_horizons.py index dc26ce9..66e7c18 100644 --- a/tests/processing/horizons/test_tool_extract_horizons.py +++ b/tests/processing/horizons/test_tool_extract_horizons.py @@ -71,7 +71,7 @@ def test_run_alg(los_fixture_name: str, horizon_type: int, additional_fields: ty if horizon_type == 1: horizon_result = NamesConstants.HORIZON_GLOBAL if horizon_type == 2: - horizon_result = NamesConstants.HORIZON_LOCAL + horizon_result = NamesConstants.HORIZON_GLOBAL output_path = result_filename("horizons_local.gpkg")