diff options
Diffstat (limited to 'archaeological_finds/tests.py')
| -rw-r--r-- | archaeological_finds/tests.py | 339 |
1 files changed, 168 insertions, 171 deletions
diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py index f6d436ebe..b04fa085a 100644 --- a/archaeological_finds/tests.py +++ b/archaeological_finds/tests.py @@ -2526,13 +2526,13 @@ class GeomaticTest(FindInit, TestCase): profile.save() find = self.finds[0] - base_find = find.base_finds.all()[0] + base_find_pt = find.base_finds.all()[0] srs, __ = SpatialReferenceSystem.objects.get_or_create( txt_idx="wgs84", defaults={"srid": 4326, "label": "WGS84", "auth_name": "EPSG"}, ) - base_find_pt = models.BaseFind.objects.get(pk=base_find.pk) + base_find_pt = models.BaseFind.objects.get(pk=base_find_pt.pk) # with point geom = GEOSGeometry("POINT({} {} {})".format(2, 43, 1), srid=4326) @@ -2540,46 +2540,46 @@ class GeomaticTest(FindInit, TestCase): base_find_pt.multi_polygon = None base_find_pt.save() base_find_pt = models.BaseFind.objects.get(pk=base_find_pt.pk) - dic = { + dic_pt_t = { "type": "Feature", "geometry": {"type": "MultiPolygon", "coordinates": []}, } res = base_find_pt.get_geo_items(get_polygons=True) - self.assertEqual(dic, res) - dic["geometry"] = {"type": "Point", "coordinates": [2.0, 43.0]} + self.assertEqual(dic_pt_t, res) + dic_pt_f = copy.deepcopy(dic_pt_t) + dic_pt_f["geometry"] = {"type": "Point", "coordinates": [2.0, 43.0]} res = base_find_pt.get_geo_items(get_polygons=False) - self.assertEqual(dic, res) + self.assertEqual(dic_pt_f, res) # test API with point - find = models.BaseFind.objects.all()[0] response = self.client.get(reverse("api-get-geo-point", kwargs={"pk": 0})) self.assertEqual(response.status_code, 404) - response = self.client.get(reverse("api-get-geo-point", kwargs={"pk": find.pk})) + response = self.client.get(reverse("api-get-geo-point", kwargs={"pk": base_find_pt.pk})) self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dic).encode("utf-8"), response.content) - - # test context record with point for base find - cr = ContextRecord.objects.get(pk=base_find_pt.context_record.pk) - pk = cr.pk - cr.point = geom - cr.multi_polygon = None - cr.multi_polygon_source = None - cr.multi_polygon_source_item = None - cr.save() - cr = ContextRecord.objects.get(pk=pk) - - dic_copy = copy.deepcopy(dic) - dic["properties"] = {"associated base finds": {"Find 1": dic_copy}} - self.assertEqual(dic, cr.get_geo_items(False)) - - dic2_copy = copy.deepcopy(dic_copy) - dic2_copy["geometry"] = {"type": "MultiPolygon", "coordinates": []} - dic2 = { + self.assertIn(json.dumps(dic_pt_f).encode("utf-8"), response.content) + + # test context record with point as base find + cr_pt_pt = ContextRecord.objects.get(pk=base_find_pt.context_record.pk) + pk = cr_pt_pt.pk + cr_pt_pt.point = geom + cr_pt_pt.multi_polygon = None + cr_pt_pt.multi_polygon_source = None + cr_pt_pt.multi_polygon_source_item = None + cr_pt_pt.save() + cr_pt_pt = ContextRecord.objects.get(pk=pk) + + dic_pt_f_copy = copy.deepcopy(dic_pt_f) + dic_pt_pt_f = copy.deepcopy(dic_pt_f) + dic_pt_pt_f["properties"] = {"associated base finds": {"Find 1": dic_pt_f_copy}} + self.assertEqual(dic_pt_pt_f, cr_pt_pt.get_geo_items(False)) + + dic_pt_t_copy = copy.deepcopy(dic_pt_t) + dic_pt_pt_t = { "type": "Feature", "geometry": {"type": "MultiPolygon", "coordinates": []}, - "properties": {"associated base finds": {"Find 1": dic2_copy}}, + "properties": {"associated base finds": {"Find 1": dic_pt_t_copy}}, } - self.assertEqual(dic2, cr.get_geo_items(True)) + self.assertEqual(dic_pt_pt_t, cr_pt_pt.get_geo_items(True)) # test of API for point context record with point as base find response = self.client.get( @@ -2588,11 +2588,11 @@ class GeomaticTest(FindInit, TestCase): self.assertEqual(response.status_code, 404) response = self.client.get( reverse( - "api-get-geo-points-from-context", kwargs={"context_record_pk": cr.pk} + "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_pt_pt.pk} ) ) self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dic).encode("utf-8"), response.content) + self.assertIn(json.dumps(dic_pt_pt_f).encode("utf-8"), response.content) response = self.client.get( reverse( @@ -2602,18 +2602,18 @@ class GeomaticTest(FindInit, TestCase): self.assertEqual(response.status_code, 404) response = self.client.get( reverse( - "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr.pk} + "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_pt_pt.pk} ) ) self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dic2).encode("utf-8"), response.content) + self.assertIn(json.dumps(dic_pt_pt_t).encode("utf-8"), response.content) # the context record is a multi-polygon limit = ( "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2))," "((6 3,9 2,9 4,6 3)))" ) - dict_poly = { + dic_poly_t = { "type": "Feature", "geometry": { "type": "MultiPolygon", @@ -2627,27 +2627,28 @@ class GeomaticTest(FindInit, TestCase): }, } - cr = ContextRecord.objects.get(pk=base_find.context_record.pk) - pk = cr.pk - cr.multi_polygon = "SRID=4326;" + limit - cr.multi_polygon_source = "P" - cr.multi_polygon_source_item = str(ContextRecord._meta.verbose_name) - cr.save() - cr = ContextRecord.objects.get(pk=pk) + cr_poly_pt = ContextRecord.objects.get(pk=base_find_pt.context_record.pk) + pk = cr_poly_pt.pk + cr_poly_pt.multi_polygon = "SRID=4326;" + limit + cr_poly_pt.multi_polygon_source = "P" + cr_poly_pt.multi_polygon_source_item = str(ContextRecord._meta.verbose_name) + cr_poly_pt.save() + cr_poly_pt = ContextRecord.objects.get(pk=pk) - dic_poly_based = copy.deepcopy(dict_poly) - dic_poly_based["properties"] = {"associated base finds": {"Find 1": dic2_copy}} - self.assertEqual(dic_poly_based, cr.get_geo_items(True)) + dic_poly_pt_t = copy.deepcopy(dic_poly_t) + dic_poly_pt_t["properties"] = {"associated base finds": {"Find 1": dic_pt_t}} + self.assertEqual(dic_poly_pt_t, cr_poly_pt.get_geo_items(True)) - dict_centroid = { + dic_poly_f = { "type": "Feature", "geometry": {"type": "Point", "coordinates": [3.86111, 3.02778]}, } - dic_poly_centroid_based = copy.deepcopy(dict_centroid) - dic_poly_centroid_based["properties"] = { - "associated base finds": {"Find 1": dic_copy} + dic_pt_f_copy = copy.deepcopy(dic_pt_f) + dic_poly_pt_f = copy.deepcopy(dic_poly_f) + dic_poly_pt_f["properties"] = { + "associated base finds": {"Find 1": dic_pt_f_copy} } - self.assertEqual(dic_poly_centroid_based, cr.get_geo_items(False)) + self.assertEqual(dic_poly_pt_f, cr_poly_pt.get_geo_items(False)) # test of API for point context record with multipolygon as base find response = self.client.get( @@ -2656,12 +2657,12 @@ class GeomaticTest(FindInit, TestCase): self.assertEqual(response.status_code, 404) response = self.client.get( reverse( - "api-get-geo-points-from-context", kwargs={"context_record_pk": cr.pk} + "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_poly_pt.pk} ) ) self.assertEqual(response.status_code, 200) self.assertIn( - json.dumps(dic_poly_centroid_based).encode("utf-8"), response.content + json.dumps(dic_poly_pt_f).encode("utf-8"), response.content ) response = self.client.get( @@ -2672,26 +2673,30 @@ class GeomaticTest(FindInit, TestCase): self.assertEqual(response.status_code, 404) response = self.client.get( reverse( - "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr.pk} + "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_poly_pt.pk} ) ) self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dic_poly_based).encode("utf-8"), response.content) + self.assertIn(json.dumps(dic_poly_pt_t).encode("utf-8"), response.content) - # with multi-polygon for base find - base_find = models.BaseFind.objects.get(pk=base_find.pk) - base_find.multi_polygon = "SRID=4326;" + limit - base_find.point_source = None - base_find.point_2d = None - base_find.point = None - base_find.save() - - base_find = models.BaseFind.objects.get(pk=base_find.pk) - - res_poly = base_find.get_geo_items(get_polygons=True) - self.assertEqual(dict_poly, res_poly) - res_centroid = base_find.get_geo_items(get_polygons=False) - self.assertEqual(dict_centroid, res_centroid) + # we add a base find which is a multi-polygon + default = { + "label": "Find 2", + "history_modifier": base_find_pt.history_modifier, + "context_record": base_find_pt.context_record, + } + base_find_poly = models.BaseFind.objects.create(**default) + base_find_poly.multi_polygon = "SRID=4326;" + limit + base_find_poly.point_source = None + base_find_poly.point_2d = None + base_find_poly.point = None + base_find_poly.save() + base_find_poly = models.BaseFind.objects.get(pk=base_find_poly.pk) + + res_poly = base_find_poly.get_geo_items(get_polygons=True) + self.assertEqual(dic_poly_t, res_poly) + res_centroid = base_find_poly.get_geo_items(get_polygons=False) + self.assertEqual(dic_poly_f, res_centroid) # test API with polygon response = self.client.get(reverse("api-get-geo-polygons", kwargs={"pk": 0})) @@ -2699,94 +2704,76 @@ class GeomaticTest(FindInit, TestCase): response = self.client.get( reverse( "api-get-geo-polygons", - kwargs={"pk": base_find.pk}, + kwargs={"pk": base_find_poly.pk}, ) ) self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dict_poly).encode("utf-8"), response.content) + self.assertIn(json.dumps(dic_poly_t).encode("utf-8"), response.content) response = self.client.get( reverse( "api-get-geo-point", - kwargs={"pk": base_find.pk}, + kwargs={"pk": base_find_poly.pk}, ) ) self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dict_centroid).encode("utf-8"), response.content) - - # context record is a polygon (and base find also) - cr = ContextRecord.objects.get(pk=base_find.context_record.pk) - pk = cr.pk - cr.multi_polygon = "SRID=4326;" + limit - cr.multi_polygon_source = "P" - cr.multi_polygon_source_item = str(ContextRecord._meta.verbose_name) - cr.save() - cr = ContextRecord.objects.get(pk=pk) - - dict_poly_copy = copy.deepcopy(dict_poly) - dict_poly["properties"] = {"associated base finds": {"Find 1": dict_poly_copy}} - self.assertEqual(dict_poly, cr.get_geo_items(True)) - - dict_centroid_copy = copy.deepcopy(dict_centroid) - dict_centroid["properties"] = { - "associated base finds": {"Find 1": dict_centroid_copy} + self.assertIn(json.dumps(dic_poly_f).encode("utf-8"), response.content) + + # context record is a polygon + # (and one base find is a point and the other is a polygon) + self.assertEqual(base_find_pt.context_record.pk, base_find_poly.context_record.pk) + cr_poly_poly_and_pt = ContextRecord.objects.get(pk=base_find_pt.context_record.pk) + pk = cr_poly_poly_and_pt.pk + cr_poly_poly_and_pt.multi_polygon = "SRID=4326;" + limit + cr_poly_poly_and_pt.multi_polygon_source = "P" + cr_poly_poly_and_pt.multi_polygon_source_item = str(ContextRecord._meta.verbose_name) + cr_poly_poly_and_pt.save() + cr_poly_poly_and_pt = ContextRecord.objects.get(pk=pk) + + dic_poly_t_copy = copy.deepcopy(dic_poly_t) + dic_poly_poly_and_pt_t = copy.deepcopy(dic_poly_t) + dic_poly_poly_and_pt_t["properties"] = { + "associated base finds": { + "Find 1": dic_pt_t_copy, + "Find 2": dic_poly_t_copy, + } } - self.assertEqual(dict_centroid, cr.get_geo_items(False)) - - # test of API for multipolygon context record with multipolygon as base find - response = self.client.get( - reverse("api-get-geo-points-from-context", kwargs={"context_record_pk": 0}) - ) - self.assertEqual(response.status_code, 404) - response = self.client.get( - reverse( - "api-get-geo-points-from-context", kwargs={"context_record_pk": cr.pk} - ) - ) - self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dict_centroid).encode("utf-8"), response.content) - - response = self.client.get( - reverse( - "api-get-geo-polygons-from-context", kwargs={"context_record_pk": 0} - ) - ) - self.assertEqual(response.status_code, 404) - response = self.client.get( - reverse( - "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr.pk} - ) - ) - self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dict_poly).encode("utf-8"), response.content) - - # context record is a point (and base find a polygon) - cr = ContextRecord.objects.get(pk=base_find_pt.context_record.pk) - pk = cr.pk - cr.point = geom - cr.multi_polygon = None - cr.multi_polygon_source = None - cr.multi_polygon_source_item = None - cr.save() - cr = ContextRecord.objects.get(pk=pk) - - dic2["properties"] = {"associated base finds": {"Find 1": dict_poly_copy}} - self.assertEqual(dic2, cr.get_geo_items(True)) + dic_poly_poly_and_pt_t_2 = copy.deepcopy(dic_poly_poly_and_pt_t) + dic_poly_poly_and_pt_t_2['properties']['associated base finds'] = { + "Find 2": dic_poly_t_copy, + "Find 1": dic_pt_t_copy, + } + self.assertEqual(dic_poly_poly_and_pt_t, cr_poly_poly_and_pt.get_geo_items(True)) - dic["properties"] = {"associated base finds": {"Find 1": dict_centroid_copy}} - self.assertEqual(dic, cr.get_geo_items(False)) + dic_poly_f_copy = copy.deepcopy(dic_poly_f) + dic_poly_poly_and_pt_f = copy.deepcopy(dic_poly_f) + dic_poly_poly_and_pt_f["properties"] = { + "associated base finds": { + "Find 1": dic_pt_f_copy, + "Find 2": dic_poly_f_copy, + } + } + dic_poly_poly_and_pt_f_2 = copy.deepcopy(dic_poly_poly_and_pt_f) + dic_poly_poly_and_pt_f_2['properties']['associated base finds'] = { + "Find 2": dic_poly_f_copy, + "Find 1": dic_pt_f_copy, + } + self.assertEqual(dic_poly_poly_and_pt_f, cr_poly_poly_and_pt.get_geo_items(False)) - # test of API for point context record with multipolygon as base find + # test of API for multipolygon context record with a multipolygon and a point as base find response = self.client.get( reverse("api-get-geo-points-from-context", kwargs={"context_record_pk": 0}) ) self.assertEqual(response.status_code, 404) response = self.client.get( reverse( - "api-get-geo-points-from-context", kwargs={"context_record_pk": cr.pk} + "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_poly_poly_and_pt.pk} ) ) self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dic).encode("utf-8"), response.content) + try: + self.assertIn(json.dumps(dic_poly_poly_and_pt_f).encode("utf-8"), response.content) + except: + self.assertIn(json.dumps(dic_poly_poly_and_pt_f_2).encode("utf-8"), response.content) response = self.client.get( reverse( @@ -2796,61 +2783,68 @@ class GeomaticTest(FindInit, TestCase): self.assertEqual(response.status_code, 404) response = self.client.get( reverse( - "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr.pk} + "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_poly_poly_and_pt.pk} ) ) self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dic2).encode("utf-8"), response.content) - - # context record is a polygon, one base find is a polygon and the other a point - cr = ContextRecord.objects.get(pk=base_find.context_record.pk) - pk = cr.pk - cr.multi_polygon = "SRID=4326;" + limit - cr.multi_polygon_source = "P" - cr.multi_polygon_source_item = str(ContextRecord._meta.verbose_name) - cr.save() - cr = ContextRecord.objects.get(pk=pk) - - default = { - "label": "Find 2", - "history_modifier": base_find.history_modifier, - "context_record": base_find.context_record, - } - base_find_pt = models.BaseFind.objects.create(**default) - base_find_pt.point = geom - base_find_pt.multi_polygon = None - base_find_pt.save() - base_find_pt = models.BaseFind.objects.get(pk=base_find_pt.pk) - self.base_finds.append(base_find_pt) - - dict_poly["properties"] = { + try: + self.assertIn(json.dumps(dic_poly_poly_and_pt_t).encode("utf-8"), response.content) + except: + self.assertIn(json.dumps(dic_poly_poly_and_pt_t_2).encode("utf-8"), response.content) + + # context record is a point, base find 1 a point and base find 2 a polygon + cr_pt_poly_and_pt = ContextRecord.objects.get(pk=base_find_poly.context_record.pk) + pk = cr_pt_poly_and_pt.pk + cr_pt_poly_and_pt.point = geom + cr_pt_poly_and_pt.multi_polygon = None + cr_pt_poly_and_pt.multi_polygon_source = None + cr_pt_poly_and_pt.multi_polygon_source_item = None + cr_pt_poly_and_pt.save() + cr_pt_poly_and_pt = ContextRecord.objects.get(pk=pk) + + dic_pt_poly_and_pt_t = copy.deepcopy(dic_pt_pt_t) + dic_pt_poly_and_pt_t["properties"] = { "associated base finds": { - "Find 2": dic2_copy, - "Find 1": dict_poly_copy, + "Find 2": dic_poly_t_copy, + "Find 1": dic_pt_t_copy, } } - self.assertEqual(dict_poly, cr.get_geo_items(True)) + dic_pt_poly_and_pt_t_2 = copy.deepcopy(dic_pt_poly_and_pt_t) + dic_pt_poly_and_pt_t["properties"]["associated base finds"] = { + "Find 1": dic_pt_t_copy, + "Find 2": dic_poly_t_copy, + } + self.assertEqual(dic_pt_poly_and_pt_t, cr_pt_poly_and_pt.get_geo_items(True)) - dict_centroid["properties"] = { + dic_pt_poly_and_pt_f = copy.deepcopy(dic_pt_pt_f) + dic_pt_poly_and_pt_f["properties"] = { "associated base finds": { - "Find 2": dic_copy, - "Find 1": dict_centroid_copy, + "Find 1": dic_pt_f_copy, + "Find 2": dic_poly_f_copy, } } - self.assertEqual(dict_centroid, cr.get_geo_items(False)) + dic_pt_poly_and_pt_f_2 = copy.deepcopy(dic_pt_poly_and_pt_f) + dic_pt_poly_and_pt_f["properties"]["associated base finds"] = { + "Find 2": dic_poly_f_copy, + "Find 1": dic_pt_f_copy, + } + self.assertEqual(dic_pt_poly_and_pt_f, cr_pt_poly_and_pt.get_geo_items(False)) - # test of API for multipolygon context record with a multipolygon and a point as base find + # test of API for point context record with multipolygon as base find response = self.client.get( reverse("api-get-geo-points-from-context", kwargs={"context_record_pk": 0}) ) self.assertEqual(response.status_code, 404) response = self.client.get( reverse( - "api-get-geo-points-from-context", kwargs={"context_record_pk": cr.pk} + "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_pt_poly_and_pt.pk} ) ) self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dict_centroid).encode("utf-8"), response.content) + try: + self.assertIn(json.dumps(dic_pt_poly_and_pt_f).encode("utf-8"), response.content) + except: + self.assertIn(json.dumps(dic_pt_poly_and_pt_f_2).encode("utf-8"), response.content) response = self.client.get( reverse( @@ -2860,11 +2854,14 @@ class GeomaticTest(FindInit, TestCase): self.assertEqual(response.status_code, 404) response = self.client.get( reverse( - "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr.pk} + "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_pt_poly_and_pt.pk} ) ) self.assertEqual(response.status_code, 200) - self.assertIn(json.dumps(dict_poly).encode("utf-8"), response.content) + try: + self.assertIn(json.dumps(dic_pt_poly_and_pt_t).encode("utf-8"), response.content) + except: + self.assertIn(json.dumps(dic_pt_poly_and_pt_t_2).encode("utf-8"), response.content) |