2.20 deploy tests to CI_to_DEV

tests_qgis/unit/converter/feature_tests/test_feature_conversions_qgis.py

@@ -0,0 +1,8 @@
+from speckle.converter.features.feature_conversions import (
+    featureToSpeckle,
+    rasterFeatureToSpeckle,
+    featureToNative,
+    bimFeatureToNative,
+    nonGeomFeatureToNative,
+    cadFeatureToNative,
+)

tests_qgis/unit/converter/feature_tests/test_feature_utils_qgis.py

@@ -0,0 +1,129 @@
+import pytest
+from speckle.converter.features.utils import (
+    addFeatVariant,
+    updateFeat,
+    getPolygonFeatureHeight,
+)
+
+from specklepy.objects import Base
+from specklepy_qt_ui.qt_ui.DataStorage import DataStorage
+
+try:
+    from qgis._core import (
+        QgsCoordinateTransform,
+        Qgis,
+        QgsPointXY,
+        QgsGeometry,
+        QgsRasterBandStats,
+        QgsFeature,
+        QgsFields,
+        QgsField,
+        QgsVectorLayer,
+        QgsRasterLayer,
+        QgsCoordinateReferenceSystem,
+        QgsProject,
+        QgsUnitTypes,
+    )
+except ModuleNotFoundError:
+    pass
+
+
+@pytest.fixture()
+def data_storage():
+    sample_obj = DataStorage()
+    sample_obj.project = QgsProject.instance()
+    return sample_obj
+
+
+def test_addFeatVariant():
+    key = "some key"
+    variant = 10  # string
+    value = "value to add"
+    feature = QgsFeature()
+    result = addFeatVariant(key, variant, value, feature)
+    assert isinstance(result, QgsFeature)
+
+
+def test_updateFeat():
+    feat = QgsFeature()
+    fields = QgsFields()
+    fields.append(QgsField("attr1", 4))
+    fields.append(QgsField("attr2", 10))
+    fields.append(QgsField("attr3_attr31", 4))
+    fields.append(QgsField("attr3_attr32", 4))
+    feat.setFields(fields)
+
+    base = Base()
+    base.attr1 = 1
+    base.attr2 = "xx"
+    base.attr3 = Base()
+    base.attr3.attr31 = 222
+    base.attr3.attr32 = 333
+
+    result = updateFeat(feat, fields, base)
+    assert isinstance(result, QgsFeature)
+    assert result["attr1"] == 1
+
+
+def test_getPolygonFeatureHeight(data_storage):
+    feat = QgsFeature()
+    fields = QgsFields()
+    fields.append(QgsField("height_m", 4))
+    feat.setFields(fields)
+    feat["height_m"] = 10
+
+    geomType = "Polygon"
+    layer_name = "layer1"
+    layer = QgsVectorLayer(geomType + "?crs=" + "WGS84", layer_name, "memory")
+    # layer.setCrs(QgsCoordinateReferenceSystem(32630))
+
+    data_storage.project.setCrs(QgsCoordinateReferenceSystem(32630))
+    data_storage.savedTransforms = []
+    data_storage.savedTransforms.append(
+        layer_name + " ('height_m')  ->  Extrude polygon by selected attribute"
+    )
+    result = getPolygonFeatureHeight(feat, layer, data_storage)
+    assert result == 10
+
+
+def test_getPolygonFeatureHeight_geo_crs(data_storage):
+    feat = QgsFeature()
+    fields = QgsFields()
+    fields.append(QgsField("height_m", 4))
+    feat.setFields(fields)
+    feat["height_m"] = 10
+
+    geomType = "Polygon"
+    layer_name = "layer1"
+    layer = QgsVectorLayer(geomType + "?crs=" + "WGS84", layer_name, "memory")
+
+    data_storage.project.setCrs(QgsCoordinateReferenceSystem(4326))
+    data_storage.savedTransforms = []
+    data_storage.savedTransforms.append(
+        layer_name + " ('height_m')  ->  Extrude polygon by selected attribute"
+    )
+    result = getPolygonFeatureHeight(feat, layer, data_storage)
+    assert result is None
+
+
+def test_getPolygonFeatureHeight_ignore(data_storage):
+    feat = QgsFeature()
+    fields = QgsFields()
+    fields.append(QgsField("height_m", 4))
+    feat.setFields(fields)
+    feat["height_m"] = 10
+
+    geomType = "Polygon"
+    layer_name = "layer1"
+    layer = QgsVectorLayer(geomType + "?crs=" + "WGS84", layer_name, "memory")
+    # layer.setCrs(QgsCoordinateReferenceSystem(32630))
+
+    data_storage.project.setCrs(QgsCoordinateReferenceSystem(32630))
+    data_storage.savedTransforms = []
+    data_storage.savedTransforms.append(
+        layer_name
+        + " ('floors')  ->  Extrude polygon by selected attribute (randomly populate)"
+    )
+    result = getPolygonFeatureHeight(feat, layer, data_storage)
+    assert isinstance(result, int)
+    assert 10 <= result <= 20

tests_qgis/unit/converter/geometry_tests/conftest.py

@@ -0,0 +1,127 @@
+import math
+from typing import Union
+import pytest
+from specklepy_qt_ui.qt_ui.DataStorage import DataStorage
+
+from specklepy.objects.encoding import CurveTypeEncoding
+from specklepy.objects.geometry import (
+    Arc,
+    Line,
+    Polyline,
+    Mesh,
+    Point,
+    Plane,
+    Polycurve,
+    Vector,
+)
+from specklepy.objects.GIS.geometry import GisPolygonGeometry
+
+try:
+    from qgis.core import (
+        QgsPoint,
+        QgsLineString,
+        QgsPolygon,
+        QgsProject,
+    )
+except ModuleNotFoundError:
+    pass
+
+
+@pytest.fixture()
+def data_storage():
+    sample_obj = DataStorage()
+    sample_obj.project = QgsProject.instance()
+    return sample_obj
+
+
+@pytest.fixture()
+def qgis_polygon():
+    geom = QgsPolygon()
+    linestring = QgsLineString()
+    linestring.addVertex(QgsPoint(4, 4, 0))
+    linestring.addVertex(QgsPoint(-4, 4, 0))
+    linestring.addVertex(QgsPoint(-4, -4, 0))
+    linestring.addVertex(QgsPoint(4, -4, 0))
+
+    geom.setExteriorRing(linestring)
+    return geom
+
+
+@pytest.fixture()
+def polyline():
+    polyline = Polyline()
+    polyline.value = []
+    polyline.closed = True
+    polyline.units = "m"
+    polyline.value.extend([4, 4, 0])
+    polyline.value.extend([-4, 4, 0])
+    polyline.value.extend([-4, -4, 0])
+    polyline.value.extend([4, -4, 0])
+    return polyline
+
+
+@pytest.fixture()
+def polygon():
+    polyline = Polyline()
+    polyline.value = []
+    polyline.closed = True
+    polyline.units = "m"
+    polyline.value.extend([4, 4, 0])
+    polyline.value.extend([-4, 4, 0])
+    polyline.value.extend([-4, -4, 0])
+    polyline.value.extend([4, -4, 0])
+
+    polyline2 = Polyline()
+    polyline2.value = []
+    polyline2.closed = True
+    polyline2.units = "m"
+    polyline2.value.extend([4, 4, 0])
+    polyline2.value.extend([-4, 4, 0])
+    polyline2.value.extend([-4, -4, 0])
+    polyline2.value.extend([4, -4, 0])
+
+    geom = GisPolygonGeometry()
+    geom.boundary = polyline
+    geom.voids = [polyline2]
+    geom.displayValue = []
+    return geom
+
+
+@pytest.fixture()
+def arc():
+    arc = Arc()
+    arc.startPoint = Point.from_list([-5, 0, 0])
+    arc.midPoint = Point.from_list([0, 5, 0])
+    arc.endPoint = Point.from_list([5, 0, 0])
+    arc.plane = Plane()
+    arc.plane.origin = Point.from_list([-5, 0, 0])
+    arc.units = "m"
+    arc.plane.normal = Vector.from_list([0, 0, 1])
+    arc.plane.origin.units = "m"
+    arc.radius = 5
+    arc.angleRadians = math.pi
+    return arc
+
+
+@pytest.fixture()
+def polycurve():
+    poly = Polycurve()
+    segm1 = Line.from_list(
+        [CurveTypeEncoding.Line.value, -10, 0, 0, -5, 0, 0, -5, 0, 0, 3]
+    )
+    segm2 = Line.from_list(
+        [CurveTypeEncoding.Line.value, -5, 0, 0, 0, 0, 0, -5, 0, 0, 3]
+    )
+    # segm2 = Polyline()
+    # segm3 = Arc()
+    poly.segments = [segm1, segm2]  # , segm3]
+    return poly
+
+
+@pytest.fixture()
+def mesh():
+    mesh_obj = Mesh().create(
+        vertices=[0, 0, 0, 100, 0, 0, 0, 100, 0], faces=[3, 0, 1, 2]
+    )
+    mesh.units = "m"
+    return mesh_obj

tests_qgis/unit/converter/geometry_tests/test_conversions_qgis.py

@@ -0,0 +1,92 @@
+import pytest
+
+
+from speckle.converter.geometry.conversions import (
+    convertToSpeckle,
+    convertToNative,
+    multiPointToNative,
+    multiPolylineToNative,
+    multiPolygonToNative,
+    convertToNativeMulti,
+)
+
+from specklepy.objects import Base
+from specklepy.objects.GIS.geometry import GisPolygonGeometry
+
+from specklepy.objects.geometry import (
+    Line,
+    Mesh,
+    Point,
+    Polyline,
+    Curve,
+    Arc,
+    Circle,
+    Ellipse,
+    Polycurve,
+)
+
+try:
+    from qgis.core import (
+        QgsPoint,
+        QgsFeature,
+        QgsLineString,
+        QgsMultiPoint,
+        QgsMultiLineString,
+        QgsMultiPolygon,
+        QgsPolygon,
+        QgsVectorLayer,
+    )
+except ModuleNotFoundError:
+    pass
+
+
+def test_convertToSpeckle(data_storage):
+    pt = QgsPoint(0, 0, 0)
+    feature = QgsFeature()
+    feature.setGeometry(pt)
+
+    geomType = "Point"
+    layer_name = "layer1"
+
+    layer = QgsVectorLayer(geomType + "?crs=" + "WGS84", layer_name, "memory")
+
+    result = convertToSpeckle(feature, layer, data_storage)
+    assert isinstance(result, tuple)
+    assert isinstance(result[0], Base)
+    assert isinstance(result[1], int)
+
+
+def test_convertToNative_pt(data_storage):
+    pt = Point.from_list([0, 4, 0])
+    pt.units = "m"
+    result = convertToNative(pt, data_storage)
+    assert isinstance(result, QgsPoint)
+
+
+def test_convertToNative_polyline(polyline, data_storage):
+    result = convertToNative(polyline, data_storage)
+    assert isinstance(result, QgsLineString)
+
+
+def test_multiPointToNative(data_storage):
+    pts = [Point.from_list([0, 4, 0]) for i in range(4)]
+    result = multiPointToNative(pts, data_storage)
+    assert isinstance(result, QgsMultiPoint)
+
+
+def test_multiPolylineToNative(polyline, data_storage):
+    polylines = [polyline for i in range(4)]
+    result = multiPolylineToNative(polylines, data_storage)
+    assert isinstance(result, QgsMultiLineString)
+
+
+def test_multiPolygonToNative(polygon, data_storage):
+    polygons = [polygon for i in range(4)]
+    result = multiPolygonToNative(polygons, data_storage)
+    assert isinstance(result, QgsMultiPolygon)
+
+
+def test_convertToNativeMulti(polygon, data_storage):
+    polygons = [polygon for i in range(4)]
+    result = convertToNativeMulti(polygons, data_storage)
+    assert isinstance(result, QgsMultiPolygon)