def test_almost_touching_linestrings_with_same_name_and_parent_id_get_merged(
session, tables):
# the following geometries do not touch directly but has to be merged
session.add(
tables.osm_linestring(id=1,
name="Oberseestrasse",
parent_id=1337,
osm_id=24055427,
geometry=WKTElement(
"""LINESTRING(981453.976751762
5978726.11248254,981467.114366002 5978716.22031828,981491.02892942
5978722.30674579,981536.264123906 5978726.22239555)""",
srid=3857)))
session.add(
tables.osm_linestring(id=2,
name="Oberseestrasse",
parent_id=1337,
osm_id=308577271,
geometry=WKTElement(
"""LINESTRING(981558.359202398
5978726.38726504,981674.610293174 5978708.37529047)""",
srid=3857)))
session.commit()
merge_corresponding_linestrings()
assert session.query(
tables.osm_merged_linestring).get(1).member_ids == [1, 2]
assert session.query(tables.osm_linestring).get(1).merged_into == 24055427
assert session.query(tables.osm_linestring).get(2).merged_into == 24055427
def test_osm_polygon_country_code_get_set_with_most_intersecting_country(
session, tables):
session.add(
tables.country_osm_grid(country_code='CH',
geometry=WKTElement(
"POLYGON((0 0,4 0,4 1,0 1,0 0))",
srid=3857)))
session.add(
tables.country_osm_grid(country_code='DE',
geometry=WKTElement(
"POLYGON((0 0,4 0,4 4,0 4,0 0))",
srid=3857)))
session.add(
tables.osm_polygon(id=1,
name="Some country with missing country_code",
place_rank=4,
geometry=WKTElement(
"POLYGON((0 0,4 0,4 4,0 4,0 0))", srid=3857)))
session.commit()
set_country_codes()
assert session.query(tables.osm_polygon).get(1).country_code == 'de'
def test_PolygonDataColumn_auto_db(mocker):
raws = [
WKTElement("POLYGON ((0 0, 1 0, 1 1, 0 0))"),
WKTElement("POLYGON ((0 0 0, 1 0 0, 1 1 0, 0 0 0))")
]
for raw in raws:
mock_list = [raw]
mocker.patch('dtocean_core.data.definitions.get_one_from_column',
return_value=mock_list,
autospec=True)
meta = CoreMetaData({
"identifier": "test",
"structure": "test",
"title": "test",
"tables": ["mock.mock", "position"]
})
test = PolygonDataColumn()
query_factory = InterfaceFactory(AutoQuery)
QueryCls = query_factory(meta, test)
query = QueryCls()
query.meta.result = meta
query.connect()
result = test.get_data(query.data.result, meta)
assert result.exterior.coords[0][0] == 0.
assert result.exterior.coords[1][0] == 1.
def test_Raster(self):
polygon = WKTElement('POLYGON((0 0,1 1,0 1,0 0))', srid=4326)
o = Ocean(polygon.ST_AsRaster(5, 5))
session.add(o)
session.flush()
session.expire(o)
assert isinstance(o.rast, RasterElement)
height = session.execute(o.rast.ST_Height()).scalar()
assert height == 5
width = session.execute(o.rast.ST_Width()).scalar()
assert width == 5
# The top left corner is covered by the polygon
top_left_point = WKTElement('Point(0 1)', srid=4326)
top_left = session.execute(o.rast.ST_Value(top_left_point)).scalar()
assert top_left == 1
# The bottom right corner has NODATA
bottom_right_point = WKTElement('Point(1 0)', srid=4326)
bottom_right = session.execute(
o.rast.ST_Value(bottom_right_point)).scalar()
assert bottom_right is None
def test_insert_geog_poi(self):
conn = self.conn
conn.execute(
Poi.__table__.insert(),
[{
'geog': 'SRID=4326;POINT(1 1)'
}, {
'geog': WKTElement('POINT(1 1)', srid=4326)
}, {
'geog': WKTElement('SRID=4326;POINT(1 1)', extended=True)
}, {
'geog': from_shape(Point(1, 1), srid=4326)
}])
results = conn.execute(Poi.__table__.select())
rows = results.fetchall()
for row in rows:
assert isinstance(row[2], WKBElement)
wkt = session.execute(row[2].ST_AsText()).scalar()
assert wkt == 'POINT(1 1)'
srid = session.execute(row[2].ST_SRID()).scalar()
assert srid == 4326
assert row[2] == from_shape(Point(1, 1), srid=4326)
def create_a_dummy_object_instance():
geo2d = GeometryModel()
geo2d.type = 'position2d'
geo2d.geometry_type = 'POINT'
geo2d.geometry = WKTElement('POINT(0 0)')
geo3d = GeometryModel()
geo3d.type = 'primitive3d'
geo3d.geometry_type = 'POINTZ'
#geo3d.geometry_type = 'LINESTRINGZ'
#geo3d.geometry_type = 'POLYGONZ'
geo3d.geometry = WKTElement('POINT(0 0 0)')
#geo3d.geometry = WKTElement('LINESTRING Z (2 2 6,1.5 1.5 7,1 1 8,0.5 0.5 8,0 0 10)')
#geo3d.geometry = WKTElement('POLYGON((0 0 8, 0 1 8, 1 1 8, 1 0 8, 0 0 8))')
obj_desc = ObjectDescription()
obj_desc.type = 'test_object'
obj_desc.geometry_model2d = geo2d
obj_desc.geometry_model3d = geo3d
pose = Pose()
pose.ref_system = 'origin'
pose.pose = '1,2,1,0,0,0,1'
obj_inst = ObjectInstance()
obj_inst.alias = '6'
obj_inst.pose = pose
obj_inst.object_description = obj_desc
db().add(obj_inst)
db().commit()
def test_osm_polygon_parent_id_get_set_with_nearest_rank(
session, schema, tables):
session.add(
tables.osm_polygon(id=1,
name="Some Polygon with missing parent",
place_rank=20,
type='city',
geometry_center=WKTElement("POINT(2 2)",
srid=3857)))
session.add(
tables.osm_polygon(
id=2,
name="Some Polygon with higher rank, covering the other polygon",
place_rank=8,
type='continent',
geometry=WKTElement("POLYGON((0 0,4 0,4 4,0 4,0 0))", srid=3857)))
session.add(
tables.osm_polygon(
id=3,
name="Some Polygon with same rank, covering the other polygon",
place_rank=16,
type='country',
geometry=WKTElement("POLYGON((0 0,4 0,4 4,0 4,0 0))", srid=3857)))
session.commit()
set_parent_ids()
assert session.query(tables.osm_polygon).get(1).parent_id == 3
def test_when_street_with_same_parent_id_but_almost_same_name_exists(
session, tables):
session.add(
tables.osm_housenumber(id=1,
parent_id=1337,
osm_id=88267051,
normalized_street="bochslenrasse",
geometry_center=WKTElement(
"POINT(653642.999259018 6623211.41263188)",
srid=3857)))
session.add(
tables.osm_linestring(id=2,
osm_id=42,
parent_id=1337,
normalized_name="bochslenstrasse",
geometry=WKTElement(
"""LINESTRING(653664.707113796
6623110.56066385,653621.291404239
6623312.26459991)""",
srid=3857)))
session.commit()
set_street_ids_by_street_name()
assert session.query(tables.osm_housenumber).get(1).street_id == 42
def test_when_housenumber_street_contains_full_street_name(session, tables):
session.add(
tables.osm_housenumber(id=1,
parent_id=1337,
osm_id=88267051,
normalized_street="citepreville19",
geometry_center=WKTElement(
"POINT(653642.999259018 6623211.41263188)",
srid=3857)))
session.add(
tables.osm_linestring(id=2,
osm_id=42,
parent_id=1337,
normalized_name="citepreville",
geometry=WKTElement(
"""LINESTRING(653664.707113796
6623110.56066385,653621.291404239
6623312.26459991)""",
srid=3857)))
session.commit()
set_street_ids_by_street_name()
assert session.query(tables.osm_housenumber).get(1).street_id == 42
def test_touching_linestrings_with_same_name_and_parent_id_get_merged(
session, tables):
session.add(
tables.osm_linestring(
id=1,
osm_id=1111,
name="Rigiweg",
parent_id=1337,
geometry=WKTElement(
"""LINESTRING(944848.776557897 5985402.86960293,
944850.474743831 5985427.66032806,944850.064193386
5985444.35251452)""",
srid=3857)))
session.add(
tables.osm_linestring(
id=2,
osm_id=2222,
name="Rigiweg",
parent_id=1337,
geometry=WKTElement(
"""LINESTRING(944850.064193386 5985444.35251452,
944841.125390515 5985474.18953402,944830.553716556 5985520.36149253,
944826.821439784 5985550.17127335)""",
srid=3857)))
session.commit()
merge_corresponding_linestrings()
assert session.query(
tables.osm_merged_linestring).get(1).member_ids == [1, 2]
assert session.query(tables.osm_linestring).get(1).merged_into == 1111
assert session.query(tables.osm_linestring).get(2).merged_into == 1111
def test_multiple_touching_linestrings_with_same_name_and_parent_id_get_merged(
session, tables):
# following geometries are simplified from the osm linestring with the osm_id 35901448
session.add(
tables.osm_linestring(
id=1,
osm_id=1111,
name="Dorfstrasse",
parent_id=1337,
geometry=WKTElement(
"""LINESTRING(945262.014242162 5985606.22988835,
945125.963423109 5985669.20516832,944921.48130943 5985680.63151807,
944732.478813664 5985815.76883825,
944577.598658291 5985883.07702847)""",
srid=3857)))
session.add(
tables.osm_linestring(
id=2,
osm_id=2222,
name="Dorfstrasse",
parent_id=1337,
geometry=WKTElement("""LINESTRING(944410.8312014 5985761.48265348,
944216.360920161 5985861.25509228)""",
srid=3857)))
session.add(
tables.osm_linestring(
id=3,
osm_id=3333,
name="Dorfstrasse",
parent_id=1337,
geometry=WKTElement("""LINESTRING(944410.8312014 5985761.48265348,
944577.598658291 5985883.07702847)""",
srid=3857)))
session.add(
tables.osm_linestring(
id=4,
osm_id=4444,
name="Dorfstrasse",
parent_id=1337,
geometry=WKTElement(
"""LINESTRING(945286.283371876 5985592.46613797,
945284.781130476 5985609.66739185,945262.014242162 5985606.22988835,
945266.045101078 5985588.14864235,
945286.283371876 5985592.46613797)""",
srid=3857)))
session.commit()
merge_corresponding_linestrings()
assert session.query(
tables.osm_merged_linestring).get(1).member_ids == [1, 2, 3, 4]
assert session.query(tables.osm_linestring).get(1).merged_into == 1111
assert session.query(tables.osm_linestring).get(2).merged_into == 1111
assert session.query(tables.osm_linestring).get(3).merged_into == 1111
assert session.query(tables.osm_linestring).get(4).merged_into == 1111
def on_get(self, req, resp, args):
page = args.get('page', 1)
per_page_limit = args.get('limit', PER_PAGE_LIMIT)
buses = self.session.query(Bus).filter()
if args.get('bbox'):
bounding_box = BoundingBox(args.get('bbox'))
polygon_text = bounding_box.to_polygon_text()
bbox = WKTElement(polygon_text, srid=4326)
buses = buses.filter(Bus.geom.contained(bbox))
elif args.get('center_lat') and args.get('center_lon'):
if args.get('radius'):
radius = float(args.get('radius')) / 1000.0
bounding_box = get_bounding_box(
latitude_in_degrees=args.get('center_lat'),
longitude_in_degrees=args.get('center_lon'),
half_side_in_km=radius)
polygon_text = bounding_box.to_polygon_text()
bbox = WKTElement(polygon_text, srid=4326)
buses = buses.filter(Bus.geom.contained(bbox))
else:
pt = WKTElement('POINT({0} {1})'.format(
args['center_lon'], args['center_lat']),
srid=4326)
buses = buses.order_by(Bus.geom.distance_box(pt))
if args.get(
'direction_id'
) != None: # explicit None cast (because direction_id=0 exists)
buses = buses.filter(Bus.direction_id == args['direction_id'])
if args.get('route_id'):
buses = buses.filter(
Bus.original_route_id == args['route_id'].upper())
# detect temporary condition of duplicated records
if buses.distinct(Bus.fetched_at).count() > 1:
last_fetch = self.session.query(func.max(
Bus.fetched_at)).filter().scalar()
buses = buses.filter(Bus.fetched_at == last_fetch)
bus_schema = BusSchema_v1()
paginator = pager(buses, page, per_page_limit)
# serializer results
bus_schema = BusSchema_v1()
results = bus_schema.dump(paginator.items, many=True).data
# build body
body = dict(
has_next=paginator.has_next,
total_results=paginator.total,
total_pages=paginator.pages,
results=results,
page_size=len(results),
page_number=paginator.page,
)
resp.body = json.dumps(body, ensure_ascii=False)
def test_function_call(self):
e = WKTElement('SRID=3857;POINT(1 2 3)', extended=True)
f = e.ST_Buffer(2)
eq_sql(f, 'ST_Buffer('
'ST_GeomFromEWKT(:ST_GeomFromEWKT_1), '
':ST_Buffer_1)')
assert f.compile().params == {
u'ST_Buffer_1': 2,
u'ST_GeomFromEWKT_1': 'SRID=3857;POINT(1 2 3)'
}
def test_function_call(self):
e = WKTElement(self._ewkt, extended=True)
f = e.ST_Buffer(2)
eq_sql(f, 'ST_Buffer('
'ST_GeomFromEWKT(:ST_GeomFromEWKT_1), '
':ST_Buffer_1)')
assert f.compile().params == {
u'ST_Buffer_1': 2,
u'ST_GeomFromEWKT_1': self._ewkt
}
def area_interseccion(ageb, poligono):
# Geometría de la intersección del polígono de entrada con el ageb
interseccion = session.scalar(
ageb.geom.ST_Intersection(WKTElement(str(shape(poligono)), srid=4326)))
# Convertimos la geometría de la intersección en formato WKTElement
interseccion_wkte = WKTElement(str(to_shape(interseccion)), srid=4326)
# Obtenemos el área de la geometría de la interseccion
area_interseccion = session.scalar(
select([func.ST_Area(func.ST_Transform(interseccion_wkte, 4486))]))
return area_interseccion
def test_neq_other_types(self):
a = WKBElement(self._ewkb, extended=True)
b = WKBElement(self._wkb, srid=self._srid)
c = WKTElement(self._wkt, srid=self._srid)
d = WKTElement(self._ewkt, extended=True)
e = WKBElement(self._hex, extended=True)
all_elements = [a, b, c, d, None, 1, "test"]
for i, j in permutations(all_elements, 2):
assert i != j
for i in all_elements[1:]:
assert i != e and e != i
def test_function_call(self):
e = WKTElement('POINT(1 2)')
f = e.ST_Buffer(2)
eq_sql(f, 'ST_Buffer('
'ST_GeomFromText(:ST_GeomFromText_1, :ST_GeomFromText_2), '
':ST_Buffer_1)')
assert f.compile().params == {
u'ST_Buffer_1': 2,
u'ST_GeomFromText_1': 'POINT(1 2)',
u'ST_GeomFromText_2': -1
}
def test_ST_Equal_WKTElement_WKTElement(self):
expr = func.ST_Equals(WKTElement('POINT(1 2)'),
WKTElement('POINT(1 2)'))
eq_sql(expr, 'ST_Equals('
'ST_GeomFromText(:ST_GeomFromText_1, :ST_GeomFromText_2), '
'ST_GeomFromText(:ST_GeomFromText_3, :ST_GeomFromText_4))')
assert expr.compile().params == {
u'ST_GeomFromText_1': 'POINT(1 2)',
u'ST_GeomFromText_2': -1,
u'ST_GeomFromText_3': 'POINT(1 2)',
u'ST_GeomFromText_4': -1,
}
def test_ST_Equal_WKTElement_WKTElement(self):
expr = func.ST_Equals(WKTElement('SRID=3857;POINT(1 2 3)',
extended=True),
WKTElement('SRID=3857;POINT(1 2 3)',
extended=True))
eq_sql(expr, 'ST_Equals('
'ST_GeomFromEWKT(:ST_GeomFromEWKT_1), '
'ST_GeomFromEWKT(:ST_GeomFromEWKT_2))')
assert expr.compile().params == {
u'ST_GeomFromEWKT_1': 'SRID=3857;POINT(1 2 3)',
u'ST_GeomFromEWKT_2': 'SRID=3857;POINT(1 2 3)',
}
def by_location(cls, location, distance_threshold=0.025):
location = WKTElement(location.to_wkt(), srid=4326)
distance = func.ST_Distance(cls.location_wkt, location)
airport = DBSession.query(cls, distance.label('distance')) \
.order_by(distance).first()
if airport is not None and (distance_threshold is None or
airport.distance < distance_threshold):
return airport.Airport
else:
return None
def test_osm_polygon_with_empty_geometries_get_deleted(session, schema,
tables):
session.add(
tables.osm_polygon(
geometry=WKTElement('POLYGON((1 2, 3 4, 5 6, 1 2))', srid=3857)))
session.add(
tables.osm_polygon(geometry=WKTElement('POLYGON EMPTY', srid=3857)))
session.commit()
delete_unusable_entries()
assert session.query(tables.osm_polygon).count(), 1
def test_eq(self):
a = WKBElement(self._ewkb, extended=True)
b = WKBElement(self._wkb, srid=self._srid)
c = WKTElement(self._wkt, srid=self._srid)
d = WKTElement(self._ewkt, extended=True)
e = WKBElement(self._hex, extended=True)
assert a == a
assert b == b
assert c == c
assert d == d
assert e == e
assert a == e and e == a
def test_function_call(self):
from geoalchemy2.elements import WKTElement
e = WKTElement('POINT(1 2)')
f = e.ST_Buffer(2)
eq_sql(
f, 'ST_Buffer('
'ST_GeomFromText(:ST_GeomFromText_1, :ST_GeomFromText_2), '
':param_1)')
eq_(
f.compile().params, {
u'param_1': 2,
u'ST_GeomFromText_1': 'POINT(1 2)',
u'ST_GeomFromText_2': -1
})
def test_Raster(self):
polygon = WKTElement('POLYGON((0 0,1 1,0 1,0 0))', srid=4326)
o = Ocean(polygon.ST_AsRaster(5, 5))
session.add(o)
session.flush()
session.expire(o)
assert isinstance(o.rast, RasterElement)
rast_data = (
'01000001009A9999999999C93F9A9999999999C9BF0000000000000000000000000000F03'
'F00000000000000000000000000000000E610000005000500440001010101010101010100'
'010101000001010000000100000000'
)
assert o.rast.data == rast_data
assert session.execute(
select([Ocean.rast.ST_Height(), Ocean.rast.ST_Width()])
).fetchall() == [(5, 5)]
# Set rast to None
o.rast = None
# Insert in DB
session.flush()
session.expire(o)
# Check what was updated in DB
assert o.rast is None
cols = [Ocean.id, Ocean.rast]
if SQLA_LT_2:
assert session.execute(select(cols)).fetchall() == [(1, None)]
else:
assert session.execute(select(*cols)).fetchall() == [(1, None)]
# Reset rast to initial value
o.rast = RasterElement(rast_data)
# Insert in DB
session.flush()
session.expire(o)
# Check what was updated in DB
assert o.rast.data == rast_data
assert session.execute(
select([Ocean.rast.ST_Height(), Ocean.rast.ST_Width()])
).fetchall() == [(5, 5)]
def get(self):
parser = reqparse.RequestParser()
parser.add_argument('lng', type=float, required=True,
help='longitude is required')
parser.add_argument('lat', type=float, required=True,
help='latitude is required')
parser.add_argument('query', required=True,
help='query is required')
args = parser.parse_args()
point = WKTElement('POINT({0} {1})'.format(args['lng'], args['lat']),
srid=4326)
looking_for = '%{0}%'.format(args['query'])
stations = db.session.query(Station).filter(
or_(Station.name.ilike(looking_for),
Station.address.ilike(looking_for))
).order_by(func.ST_Distance(Station.position, point)).all()
payload = {'q': args['query'], 'lat': args['lat'], 'lon': args['lng']}
r = requests.get('http://photon.komoot.de/api/', params=payload)
poiList = []
for st in stations:
poiList.append(Poi(st.name, st.address, st.position))
responsejson = r.json()
for feature in responsejson['features']:
print feature
address = ''
if 'street' in feature['properties']:
address = feature['properties']['street']
if 'city' in feature['properties']:
address = address + ' - %s' % feature['properties']['city']
if 'state' in feature['properties']:
address = address + ' - %s' % feature['properties']['state']
if 'country' in feature['properties']:
address = address + ' - %s' % feature['properties']['country']
lon = feature['geometry']['coordinates'][0]
lat = feature['geometry']['coordinates'][1]
pos = WKTElement('POINT({0} {1})'.format(lon, lat), srid=4326)
poiList.append(Poi(feature['properties']['name'], address, pos))
return poiList
def test_insert(self):
conn = self.conn
# Issue inserts using DBAPI's executemany() method. This tests the
# Geometry type's bind_processor and bind_expression functions.
conn.execute(
Lake.__table__.insert(),
[{
'geom': 'SRID=4326;LINESTRING(0 0,1 1)'
}, {
'geom': WKTElement('LINESTRING(0 0,2 2)', srid=4326)
}, {
'geom': WKTElement('SRID=4326;LINESTRING(0 0,2 2)',
extended=True)
}, {
'geom': from_shape(LineString([[0, 0], [3, 3]]), srid=4326)
}])
results = conn.execute(Lake.__table__.select())
rows = results.fetchall()
row = rows[0]
assert isinstance(row[1], WKBElement)
wkt = session.execute(row[1].ST_AsText()).scalar()
assert wkt == 'LINESTRING(0 0,1 1)'
srid = session.execute(row[1].ST_SRID()).scalar()
assert srid == 4326
row = rows[1]
assert isinstance(row[1], WKBElement)
wkt = session.execute(row[1].ST_AsText()).scalar()
assert wkt == 'LINESTRING(0 0,2 2)'
srid = session.execute(row[1].ST_SRID()).scalar()
assert srid == 4326
row = rows[2]
assert isinstance(row[1], WKBElement)
wkt = session.execute(row[1].ST_AsText()).scalar()
assert wkt == 'LINESTRING(0 0,2 2)'
srid = session.execute(row[1].ST_SRID()).scalar()
assert srid == 4326
row = rows[3]
assert isinstance(row[1], WKBElement)
wkt = session.execute(row[1].ST_AsText()).scalar()
assert wkt == 'LINESTRING(0 0,3 3)'
srid = session.execute(row[1].ST_SRID()).scalar()
assert srid == 4326
def locations(self, locations):
points = [
"{} {}".format(location.longitude, location.latitude)
for location in locations
]
wkt = "LINESTRING({})".format(",".join(points))
self._locations = WKTElement(wkt, srid=4326)
def get_nearest(cls, lat, lon):
"""
Find the nearest point to the input coordinates.
Convert the input coordinates to a WKT point and query for nearest point.
"""
pt = WKTElement('POINT({0} {1})'.format(lon, lat), srid=4326)
return cls.query.order_by(cls.point.distance_box(pt)).first()
def on_get(self, req, resp, args):
page = args.get('page', 1)
per_page_limit = args.get('limit', PER_PAGE_LIMIT)
bip_spots = self.session.query(BipSpot).filter()
if args.get('center_lat') and args.get('center_lon'):
BipSpot.add_geometry_column() # @@TODO: fix this
pt = WKTElement('POINT({0} {1})'.format(args['center_lon'],
args['center_lat']),
srid=4326)
bip_spots = bip_spots.order_by(BipSpot.geom.distance_box(pt))
paginator = pager(bip_spots, page, per_page_limit)
# serializer results
bip_spot_schema = BipSpotSchema_v1()
results = bip_spot_schema.dump(paginator.items, many=True).data
# build body
body = dict(
has_next=paginator.has_next,
total_results=paginator.total,
total_pages=paginator.pages,
results=results,
page_size=len(results),
page_number=paginator.page,
)
resp.body = json.dumps(body, ensure_ascii=False)
def test_insert(self):
conn = self.conn
# Issue two inserts using DBAPI's executemany() method. This tests
# the Geometry type's bind_processor and bind_expression functions.
conn.execute(Lake.__table__.insert(), [
{'geom': 'SRID=4326;LINESTRING(0 0,1 1)'},
{'geom': WKTElement('LINESTRING(0 0,2 2)', srid=4326, use_st_prefix=False)}
# Having WKBElement objects as bind values is not supported, so
# the following does not work:
# {'geom': from_shape(LineString([[0, 0], [3, 3]], srid=4326)}
])
results = conn.execute(Lake.__table__.select())
rows = results.fetchall()
row = rows[0]
assert isinstance(row[1], WKBElement)
wkt = session.execute(row[1].ST_AsText()).scalar()
assert wkt == 'LINESTRING(0 0, 1 1)'
srid = session.execute(row[1].ST_SRID()).scalar()
assert srid == 4326
row = rows[1]
assert isinstance(row[1], WKBElement)
wkt = session.execute(row[1].ST_AsText()).scalar()
assert wkt == 'LINESTRING(0 0, 2 2)'
srid = session.execute(row[1].ST_SRID()).scalar()
assert srid == 4326
def test_get_all_communities(client):
community_id = 1
name = "Test community"
boundaries = WKTElement(
"MULTIPOLYGON(((43.643911 -79.376321, 43.644268 -79.372738, 43.642071 -79.372620, 43.641993 -79.375881, 43.643911 -79.376321)))",
4326)
expected_boundaries = {
'coordinates': [[[[43.643911, -79.376321], [43.644268, -79.372738],
[43.642071, -79.37262], [43.641993, -79.375881],
[43.643911, -79.376321]]]],
'type':
'MultiPolygon'
}
community = Community.add_comunity(
Community.from_dict({
"id": community_id,
"name": name,
"boundaries": boundaries
}))
assert community is not None
assert Community.get_all_communities is not None
# user details with correct auth
rv = client.get("/community", headers=get_headers())
body = json.loads(rv.get_data(as_text=True))
assert rv.status_code == 200
assert body[0]["id"] == community_id
assert body[0]["name"] == name
print(body[0]["boundaries"])
assert body[0]["boundaries"] == expected_boundaries
