b47669403b
This commit: 1. Formats all of our existing code using `black`. 2. Adds a note about using `black` to `CONTRIBUTING.rst`. 3. Runs `black --check` as part of CI (failing builds that aren't properly formatted).
424 lines
16 KiB
Python
424 lines
16 KiB
Python
# -*- coding: utf-8 -*-
|
|
import unittest
|
|
|
|
from mongoengine import *
|
|
from mongoengine.connection import get_db
|
|
|
|
__all__ = ("GeoFieldTest",)
|
|
|
|
|
|
class GeoFieldTest(unittest.TestCase):
|
|
def setUp(self):
|
|
connect(db="mongoenginetest")
|
|
self.db = get_db()
|
|
|
|
def _test_for_expected_error(self, Cls, loc, expected):
|
|
try:
|
|
Cls(loc=loc).validate()
|
|
self.fail("Should not validate the location {0}".format(loc))
|
|
except ValidationError as e:
|
|
self.assertEqual(expected, e.to_dict()["loc"])
|
|
|
|
def test_geopoint_validation(self):
|
|
class Location(Document):
|
|
loc = GeoPointField()
|
|
|
|
invalid_coords = [{"x": 1, "y": 2}, 5, "a"]
|
|
expected = "GeoPointField can only accept tuples or lists of (x, y)"
|
|
|
|
for coord in invalid_coords:
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
invalid_coords = [[], [1], [1, 2, 3]]
|
|
for coord in invalid_coords:
|
|
expected = "Value (%s) must be a two-dimensional point" % repr(coord)
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
invalid_coords = [[{}, {}], ("a", "b")]
|
|
for coord in invalid_coords:
|
|
expected = "Both values (%s) in point must be float or int" % repr(coord)
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
invalid_coords = [21, 4, "a"]
|
|
for coord in invalid_coords:
|
|
expected = "GeoPointField can only accept tuples or lists of (x, y)"
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
def test_point_validation(self):
|
|
class Location(Document):
|
|
loc = PointField()
|
|
|
|
invalid_coords = {"x": 1, "y": 2}
|
|
expected = (
|
|
"PointField can only accept a valid GeoJson dictionary or lists of (x, y)"
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "MadeUp", "coordinates": []}
|
|
expected = 'PointField type must be "Point"'
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "Point", "coordinates": [1, 2, 3]}
|
|
expected = "Value ([1, 2, 3]) must be a two-dimensional point"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [5, "a"]
|
|
expected = "PointField can only accept lists of [x, y]"
|
|
for coord in invalid_coords:
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
invalid_coords = [[], [1], [1, 2, 3]]
|
|
for coord in invalid_coords:
|
|
expected = "Value (%s) must be a two-dimensional point" % repr(coord)
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
invalid_coords = [[{}, {}], ("a", "b")]
|
|
for coord in invalid_coords:
|
|
expected = "Both values (%s) in point must be float or int" % repr(coord)
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
Location(loc=[1, 2]).validate()
|
|
Location(
|
|
loc={"type": "Point", "coordinates": [81.4471435546875, 23.61432859499169]}
|
|
).validate()
|
|
|
|
def test_linestring_validation(self):
|
|
class Location(Document):
|
|
loc = LineStringField()
|
|
|
|
invalid_coords = {"x": 1, "y": 2}
|
|
expected = "LineStringField can only accept a valid GeoJson dictionary or lists of (x, y)"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "MadeUp", "coordinates": [[]]}
|
|
expected = 'LineStringField type must be "LineString"'
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "LineString", "coordinates": [[1, 2, 3]]}
|
|
expected = (
|
|
"Invalid LineString:\nValue ([1, 2, 3]) must be a two-dimensional point"
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [5, "a"]
|
|
expected = "Invalid LineString must contain at least one valid point"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[1]]
|
|
expected = (
|
|
"Invalid LineString:\nValue (%s) must be a two-dimensional point"
|
|
% repr(invalid_coords[0])
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[1, 2, 3]]
|
|
expected = (
|
|
"Invalid LineString:\nValue (%s) must be a two-dimensional point"
|
|
% repr(invalid_coords[0])
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[{}, {}]], [("a", "b")]]
|
|
for coord in invalid_coords:
|
|
expected = (
|
|
"Invalid LineString:\nBoth values (%s) in point must be float or int"
|
|
% repr(coord[0])
|
|
)
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
Location(loc=[[1, 2], [3, 4], [5, 6], [1, 2]]).validate()
|
|
|
|
def test_polygon_validation(self):
|
|
class Location(Document):
|
|
loc = PolygonField()
|
|
|
|
invalid_coords = {"x": 1, "y": 2}
|
|
expected = (
|
|
"PolygonField can only accept a valid GeoJson dictionary or lists of (x, y)"
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "MadeUp", "coordinates": [[]]}
|
|
expected = 'PolygonField type must be "Polygon"'
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "Polygon", "coordinates": [[[1, 2, 3]]]}
|
|
expected = "Invalid Polygon:\nValue ([1, 2, 3]) must be a two-dimensional point"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[5, "a"]]]
|
|
expected = (
|
|
"Invalid Polygon:\nBoth values ([5, 'a']) in point must be float or int"
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[]]]
|
|
expected = "Invalid Polygon must contain at least one valid linestring"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[1, 2, 3]]]
|
|
expected = "Invalid Polygon:\nValue ([1, 2, 3]) must be a two-dimensional point"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[{}, {}]], [("a", "b")]]
|
|
expected = "Invalid Polygon:\nBoth values ([{}, {}]) in point must be float or int, Both values (('a', 'b')) in point must be float or int"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[1, 2], [3, 4]]]
|
|
expected = "Invalid Polygon:\nLineStrings must start and end at the same point"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
Location(loc=[[[1, 2], [3, 4], [5, 6], [1, 2]]]).validate()
|
|
|
|
def test_multipoint_validation(self):
|
|
class Location(Document):
|
|
loc = MultiPointField()
|
|
|
|
invalid_coords = {"x": 1, "y": 2}
|
|
expected = "MultiPointField can only accept a valid GeoJson dictionary or lists of (x, y)"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "MadeUp", "coordinates": [[]]}
|
|
expected = 'MultiPointField type must be "MultiPoint"'
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "MultiPoint", "coordinates": [[1, 2, 3]]}
|
|
expected = "Value ([1, 2, 3]) must be a two-dimensional point"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[]]
|
|
expected = "Invalid MultiPoint must contain at least one valid point"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[1]], [[1, 2, 3]]]
|
|
for coord in invalid_coords:
|
|
expected = "Value (%s) must be a two-dimensional point" % repr(coord[0])
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
invalid_coords = [[[{}, {}]], [("a", "b")]]
|
|
for coord in invalid_coords:
|
|
expected = "Both values (%s) in point must be float or int" % repr(coord[0])
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
Location(loc=[[1, 2]]).validate()
|
|
Location(
|
|
loc={
|
|
"type": "MultiPoint",
|
|
"coordinates": [[1, 2], [81.4471435546875, 23.61432859499169]],
|
|
}
|
|
).validate()
|
|
|
|
def test_multilinestring_validation(self):
|
|
class Location(Document):
|
|
loc = MultiLineStringField()
|
|
|
|
invalid_coords = {"x": 1, "y": 2}
|
|
expected = "MultiLineStringField can only accept a valid GeoJson dictionary or lists of (x, y)"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "MadeUp", "coordinates": [[]]}
|
|
expected = 'MultiLineStringField type must be "MultiLineString"'
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "MultiLineString", "coordinates": [[[1, 2, 3]]]}
|
|
expected = "Invalid MultiLineString:\nValue ([1, 2, 3]) must be a two-dimensional point"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [5, "a"]
|
|
expected = "Invalid MultiLineString must contain at least one valid linestring"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[1]]]
|
|
expected = (
|
|
"Invalid MultiLineString:\nValue (%s) must be a two-dimensional point"
|
|
% repr(invalid_coords[0][0])
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[1, 2, 3]]]
|
|
expected = (
|
|
"Invalid MultiLineString:\nValue (%s) must be a two-dimensional point"
|
|
% repr(invalid_coords[0][0])
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[[{}, {}]]], [[("a", "b")]]]
|
|
for coord in invalid_coords:
|
|
expected = (
|
|
"Invalid MultiLineString:\nBoth values (%s) in point must be float or int"
|
|
% repr(coord[0][0])
|
|
)
|
|
self._test_for_expected_error(Location, coord, expected)
|
|
|
|
Location(loc=[[[1, 2], [3, 4], [5, 6], [1, 2]]]).validate()
|
|
|
|
def test_multipolygon_validation(self):
|
|
class Location(Document):
|
|
loc = MultiPolygonField()
|
|
|
|
invalid_coords = {"x": 1, "y": 2}
|
|
expected = "MultiPolygonField can only accept a valid GeoJson dictionary or lists of (x, y)"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "MadeUp", "coordinates": [[]]}
|
|
expected = 'MultiPolygonField type must be "MultiPolygon"'
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = {"type": "MultiPolygon", "coordinates": [[[[1, 2, 3]]]]}
|
|
expected = (
|
|
"Invalid MultiPolygon:\nValue ([1, 2, 3]) must be a two-dimensional point"
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[[5, "a"]]]]
|
|
expected = "Invalid MultiPolygon:\nBoth values ([5, 'a']) in point must be float or int"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[[]]]]
|
|
expected = "Invalid MultiPolygon must contain at least one valid Polygon"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[[1, 2, 3]]]]
|
|
expected = (
|
|
"Invalid MultiPolygon:\nValue ([1, 2, 3]) must be a two-dimensional point"
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[[{}, {}]]], [[("a", "b")]]]
|
|
expected = "Invalid MultiPolygon:\nBoth values ([{}, {}]) in point must be float or int, Both values (('a', 'b')) in point must be float or int"
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
invalid_coords = [[[[1, 2], [3, 4]]]]
|
|
expected = (
|
|
"Invalid MultiPolygon:\nLineStrings must start and end at the same point"
|
|
)
|
|
self._test_for_expected_error(Location, invalid_coords, expected)
|
|
|
|
Location(loc=[[[[1, 2], [3, 4], [5, 6], [1, 2]]]]).validate()
|
|
|
|
def test_indexes_geopoint(self):
|
|
"""Ensure that indexes are created automatically for GeoPointFields.
|
|
"""
|
|
|
|
class Event(Document):
|
|
title = StringField()
|
|
location = GeoPointField()
|
|
|
|
geo_indicies = Event._geo_indices()
|
|
self.assertEqual(geo_indicies, [{"fields": [("location", "2d")]}])
|
|
|
|
def test_geopoint_embedded_indexes(self):
|
|
"""Ensure that indexes are created automatically for GeoPointFields on
|
|
embedded documents.
|
|
"""
|
|
|
|
class Venue(EmbeddedDocument):
|
|
location = GeoPointField()
|
|
name = StringField()
|
|
|
|
class Event(Document):
|
|
title = StringField()
|
|
venue = EmbeddedDocumentField(Venue)
|
|
|
|
geo_indicies = Event._geo_indices()
|
|
self.assertEqual(geo_indicies, [{"fields": [("venue.location", "2d")]}])
|
|
|
|
def test_indexes_2dsphere(self):
|
|
"""Ensure that indexes are created automatically for GeoPointFields.
|
|
"""
|
|
|
|
class Event(Document):
|
|
title = StringField()
|
|
point = PointField()
|
|
line = LineStringField()
|
|
polygon = PolygonField()
|
|
|
|
geo_indicies = Event._geo_indices()
|
|
self.assertIn({"fields": [("line", "2dsphere")]}, geo_indicies)
|
|
self.assertIn({"fields": [("polygon", "2dsphere")]}, geo_indicies)
|
|
self.assertIn({"fields": [("point", "2dsphere")]}, geo_indicies)
|
|
|
|
def test_indexes_2dsphere_embedded(self):
|
|
"""Ensure that indexes are created automatically for GeoPointFields.
|
|
"""
|
|
|
|
class Venue(EmbeddedDocument):
|
|
name = StringField()
|
|
point = PointField()
|
|
line = LineStringField()
|
|
polygon = PolygonField()
|
|
|
|
class Event(Document):
|
|
title = StringField()
|
|
venue = EmbeddedDocumentField(Venue)
|
|
|
|
geo_indicies = Event._geo_indices()
|
|
self.assertIn({"fields": [("venue.line", "2dsphere")]}, geo_indicies)
|
|
self.assertIn({"fields": [("venue.polygon", "2dsphere")]}, geo_indicies)
|
|
self.assertIn({"fields": [("venue.point", "2dsphere")]}, geo_indicies)
|
|
|
|
def test_geo_indexes_recursion(self):
|
|
class Location(Document):
|
|
name = StringField()
|
|
location = GeoPointField()
|
|
|
|
class Parent(Document):
|
|
name = StringField()
|
|
location = ReferenceField(Location)
|
|
|
|
Location.drop_collection()
|
|
Parent.drop_collection()
|
|
|
|
Parent(name="Berlin").save()
|
|
info = Parent._get_collection().index_information()
|
|
self.assertNotIn("location_2d", info)
|
|
info = Location._get_collection().index_information()
|
|
self.assertIn("location_2d", info)
|
|
|
|
self.assertEqual(len(Parent._geo_indices()), 0)
|
|
self.assertEqual(len(Location._geo_indices()), 1)
|
|
|
|
def test_geo_indexes_auto_index(self):
|
|
|
|
# Test just listing the fields
|
|
class Log(Document):
|
|
location = PointField(auto_index=False)
|
|
datetime = DateTimeField()
|
|
|
|
meta = {"indexes": [[("location", "2dsphere"), ("datetime", 1)]]}
|
|
|
|
self.assertEqual([], Log._geo_indices())
|
|
|
|
Log.drop_collection()
|
|
Log.ensure_indexes()
|
|
|
|
info = Log._get_collection().index_information()
|
|
self.assertEqual(
|
|
info["location_2dsphere_datetime_1"]["key"],
|
|
[("location", "2dsphere"), ("datetime", 1)],
|
|
)
|
|
|
|
# Test listing explicitly
|
|
class Log(Document):
|
|
location = PointField(auto_index=False)
|
|
datetime = DateTimeField()
|
|
|
|
meta = {
|
|
"indexes": [{"fields": [("location", "2dsphere"), ("datetime", 1)]}]
|
|
}
|
|
|
|
self.assertEqual([], Log._geo_indices())
|
|
|
|
Log.drop_collection()
|
|
Log.ensure_indexes()
|
|
|
|
info = Log._get_collection().index_information()
|
|
self.assertEqual(
|
|
info["location_2dsphere_datetime_1"]["key"],
|
|
[("location", "2dsphere"), ("datetime", 1)],
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|