def test_serializer_model_no_geofield(self):
self.serializer = ZipShapeSerializer()
response = HttpResponse()
with self.assertRaisesRegex(
ValueError,
"No geodjango geometry fields found in this model"):
self.serializer.serialize(Difficulty.objects.all(),
stream=response,
fields=['id', 'name'],
delete=False)
class ShapefileSerializer(TestCase):
def setUp(self):
self.point1 = MushroomSpot.objects.create(serialized='SRID=%s;POINT(0 0)' % settings.SRID)
self.line1 = MushroomSpot.objects.create(serialized='SRID=%s;LINESTRING(0 0, 10 0)' % settings.SRID)
self.multipoint = MushroomSpot.objects.create(serialized='SRID=%s;MULTIPOINT((1 1), (2 2))' % settings.SRID)
MushroomSpot.geomfield = GeometryField(name='geom', srid=2154)
self.serializer = ZipShapeSerializer()
devnull = open(os.devnull, "wb")
self.serializer.serialize(MushroomSpot.objects.all(), stream=devnull,
fields=['id', 'name', 'number', 'size', 'boolean'], delete=False)
def tearDown(self):
for layer_file in self.serializer.layers.values():
for subfile in shapefile_files(layer_file):
os.remove(subfile)
def getShapefileLayers(self):
shapefiles = self.serializer.layers.values()
datasources = [gdal.DataSource(s) for s in shapefiles]
layers = [ds[0] for ds in datasources]
return layers
def test_serializer_creates_one_layer_per_type(self):
self.assertEquals(len(self.serializer.layers), 3)
def test_each_layer_has_records_by_type(self):
layer_point, layer_multipoint, layer_linestring = self.getShapefileLayers()
self.assertEquals(len(layer_point), 1)
self.assertEquals(len(layer_linestring), 1)
self.assertEquals(len(layer_multipoint), 1)
def test_each_layer_has_a_different_geometry_type(self):
layer_types = [l.geom_type.name for l in self.getShapefileLayers()]
self.assertItemsEqual(layer_types, ['MultiPoint', 'Point', 'LineString'])
def test_layer_has_right_projection(self):
for layer in self.getShapefileLayers():
self.assertEquals(layer.srs.name, 'RGF93_Lambert_93')
self.assertItemsEqual(layer.fields, ['id', 'name', 'number', 'size', 'boolean'])
def test_geometries_come_from_records(self):
layer_point, layer_multipoint, layer_linestring = self.getShapefileLayers()
feature = layer_point[0]
self.assertEquals(str(feature['id']), str(self.point1.pk))
self.assertTrue(feature.geom.geos.equals(self.point1.geom))
feature = layer_point[0]
self.assertEquals(str(feature['id']), str(self.point1.pk))
self.assertTrue(feature.geom.geos.equals(self.point1.geom))
feature = layer_point[0]
self.assertEquals(str(feature['id']), str(self.point1.pk))
self.assertTrue(feature.geom.geos.equals(self.point1.geom))
class ShapefileSerializer(TransactionTestCase):
def setUp(self):
self.point1 = MushroomSpot.objects.create(serialized='SRID=%s;POINT(0 0)' % settings.SRID)
self.line1 = MushroomSpot.objects.create(serialized='SRID=%s;LINESTRING(0 0, 10 0)' % settings.SRID)
self.multipoint = MushroomSpot.objects.create(serialized='SRID=%s;MULTIPOINT((1 1), (2 2))' % settings.SRID)
MushroomSpot.geomfield = GeometryField(name='geom', srid=2154)
self.serializer = ZipShapeSerializer()
devnull = open(os.devnull, "wb")
self.serializer.serialize(MushroomSpot.objects.all(), stream=devnull,
fields=['id', 'name', 'number', 'size', 'boolean'], delete=False)
def tearDown(self):
for layer_file in self.serializer.layers.values():
for subfile in shapefile_files(layer_file):
os.remove(subfile)
def getShapefileLayers(self):
shapefiles = self.serializer.layers.values()
datasources = [gdal.DataSource(s) for s in shapefiles]
layers = [ds[0] for ds in datasources]
return layers
def test_serializer_creates_one_layer_per_type(self):
self.assertEquals(len(self.serializer.layers), 3)
def test_each_layer_has_records_by_type(self):
layer_point, layer_multipoint, layer_linestring = self.getShapefileLayers()
self.assertEquals(len(layer_point), 1)
self.assertEquals(len(layer_linestring), 1)
self.assertEquals(len(layer_multipoint), 1)
def test_each_layer_has_a_different_geometry_type(self):
layer_types = [l.geom_type.name for l in self.getShapefileLayers()]
self.assertItemsEqual(layer_types, ['MultiPoint', 'Point', 'LineString'])
def test_layer_has_right_projection(self):
for layer in self.getShapefileLayers():
self.assertEquals(layer.srs.name, 'RGF93_Lambert_93')
self.assertItemsEqual(layer.fields, ['id', 'name', 'number', 'size', 'boolean'])
def test_geometries_come_from_records(self):
layer_point, layer_multipoint, layer_linestring = self.getShapefileLayers()
feature = layer_point[0]
self.assertEquals(str(feature['id']), str(self.point1.pk))
self.assertTrue(feature.geom.geos.equals(self.point1.geom))
feature = layer_point[0]
self.assertEquals(str(feature['id']), str(self.point1.pk))
self.assertTrue(feature.geom.geos.equals(self.point1.geom))
feature = layer_point[0]
self.assertEquals(str(feature['id']), str(self.point1.pk))
self.assertTrue(feature.geom.geos.equals(self.point1.geom))
def setUp(self):
self.point1 = MushroomSpot.objects.create(serialized='SRID=%s;POINT(0 0)' % settings.SRID)
self.line1 = MushroomSpot.objects.create(serialized='SRID=%s;LINESTRING(0 0, 10 0)' % settings.SRID)
self.multipoint = MushroomSpot.objects.create(serialized='SRID=%s;MULTIPOINT((1 1), (2 2))' % settings.SRID)
MushroomSpot.geomfield = GeometryField(name='geom', srid=2154)
self.serializer = ZipShapeSerializer()
devnull = open(os.devnull, "wb")
self.serializer.serialize(MushroomSpot.objects.all(), stream=devnull,
fields=['id', 'name', 'number', 'size', 'boolean'], delete=False)
def test_serializer_model_geofield_do_not_exist(self):
app_settings['GEOM_FIELD_NAME'] = 'do_not_exist'
self.serializer = ZipShapeSerializer()
PathFactory.create()
response = HttpResponse()
with self.assertRaisesRegex(
ValueError,
"Geodjango geometry field not found with the name 'do_not_exist', "
"fields available are: 'geom_3d, geom, geom_cadastre'"):
self.serializer.serialize(Path.objects.all(),
stream=response,
fields=['id', 'name'],
delete=False)
app_settings['GEOM_FIELD_NAME'] = 'geom'
def test_serializer_model_geofield_multiple(self):
app_settings['GEOM_FIELD_NAME'] = None
self.serializer = ZipShapeSerializer()
PathFactory.create()
response = HttpResponse()
with self.assertRaisesRegex(
ValueError,
"More than one geodjango geometry field found, please specify which "
"to use by name using the 'geo_field' keyword. "
"Available fields are: 'geom_3d, geom, geom_cadastre'"):
self.serializer.serialize(Path.objects.all(),
stream=response,
fields=['id', 'name'],
delete=False)
app_settings['GEOM_FIELD_NAME'] = 'geom'
def setUp(self):
self.point1 = MushroomSpot.objects.create(
serialized='SRID=%s;POINT(0 0)' % settings.SRID)
self.point1.tags.add(Tag.objects.create(label="Tag1"))
self.point1.tags.add(Tag.objects.create(label="Tag2"))
self.line1 = MushroomSpot.objects.create(
serialized='SRID=%s;LINESTRING(0 0, 10 0)' % settings.SRID)
self.multipoint = MushroomSpot.objects.create(
serialized='SRID=%s;MULTIPOINT((1 1), (2 2))' % settings.SRID)
MushroomSpot.geomfield = GeometryField(name='geom', srid=settings.SRID)
self.serializer = ZipShapeSerializer()
response = HttpResponse()
self.serializer.serialize(
MushroomSpot.objects.all(),
stream=response,
fields=['id', 'name', 'number', 'size', 'boolean', 'tags'],
delete=False)
def setUp(self):
self.point1 = MushroomSpot.objects.create(serialized='SRID=%s;POINT(0 0)' % settings.SRID)
self.line1 = MushroomSpot.objects.create(serialized='SRID=%s;LINESTRING(0 0, 10 0)' % settings.SRID)
self.multipoint = MushroomSpot.objects.create(serialized='SRID=%s;MULTIPOINT((1 1), (2 2))' % settings.SRID)
MushroomSpot.geomfield = GeometryField(name='geom', srid=2154)
self.serializer = ZipShapeSerializer()
devnull = open(os.devnull, "wb")
self.serializer.serialize(MushroomSpot.objects.all(), stream=devnull,
fields=['id', 'name', 'number', 'size', 'boolean'], delete=False)
def setUp(self):
self.point1 = MushroomSpot.objects.create(serialized='SRID=%s;POINT(0 0)' % settings.SRID)
self.point1.tags.add(Tag.objects.create(label="Tag1"))
self.point1.tags.add(Tag.objects.create(label="Tag2"))
self.line1 = MushroomSpot.objects.create(serialized='SRID=%s;LINESTRING(0 0, 10 0)' % settings.SRID)
self.multipoint = MushroomSpot.objects.create(serialized='SRID=%s;MULTIPOINT((1 1), (2 2))' % settings.SRID)
MushroomSpot.geomfield = GeometryField(name='geom', srid=settings.SRID)
self.serializer = ZipShapeSerializer()
response = HttpResponse()
self.serializer.serialize(MushroomSpot.objects.all(), stream=response,
fields=['id', 'name', 'number', 'size', 'boolean', 'tags'], delete=False)
def setUp(self):
self.point1 = DiveFactory.create()
self.point1.themes.add(ThemeFactory.create(label="Tag1"))
self.point1.themes.add(ThemeFactory.create(label="Tag2"))
self.line1 = DiveFactory.create(geom='SRID=%s;LINESTRING(0 0, 10 0)' %
settings.SRID)
self.multiline = DiveFactory.create(
geom='SRID=%s;MULTILINESTRING((10 10, 20 20, 10 40),'
'(40 40, 30 30, 40 20, 30 10))' % settings.SRID)
self.multipoint = DiveFactory.create(
geom='SRID=%s;MULTIPOINT((1 1), (2 2))' % settings.SRID)
self.polygon = DiveFactory.create(
geom='SRID=%s;POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))' % settings.SRID)
self.multipolygon = DiveFactory.create(
geom='SRID=%s;MULTIPOLYGON(((0 0, 0 1, 1 1, 1 0, 0 0)),'
'((2 2, 2 3, 3 3, 3 2, 2 2)))' % settings.SRID)
self.serializer = ZipShapeSerializer()
response = HttpResponse()
self.serializer.serialize(Dive.objects.all(),
stream=response,
fields=['id', 'name'],
delete=False)
def test_shape_mixed(self):
"""
Test that a project made of intervention of different geom create multiple files.
Check that those files are each of a different type (Point/LineString) and that
the project and the intervention are correctly referenced in it.
"""
# Create topology line
topo_line = TopologyFactory.create(no_path=True)
line = PathFactory.create(geom=LineString(Point(10, 10, 0), Point(11, 10, 0)))
PathAggregationFactory.create(topo_object=topo_line, path=line)
# Create a topology point
lng, lat = tuple(Point(1, 1, srid=settings.SRID).transform(settings.API_SRID, clone=True))
closest_path = PathFactory(geom=LineString(Point(0, 0, 0), Point(1, 0, 0), srid=settings.SRID))
topo_point = TopologyHelper._topologypoint(lng, lat, None).reload()
self.assertEquals(topo_point.paths.get(), closest_path)
# Create one intervention by geometry (point/linestring)
it_point = InterventionFactory.create(topology=topo_point)
it_line = InterventionFactory.create(topology=topo_line)
# reload
it_point = type(it_point).objects.get(pk=it_point.pk)
it_line = type(it_line).objects.get(pk=it_line.pk)
proj = ProjectFactory.create()
proj.interventions.add(it_point)
proj.interventions.add(it_line)
# instanciate the class based view 'abnormally' to use create_shape directly
# to avoid making http request, authent and reading from a zip
pfl = ZipShapeSerializer()
devnull = open(os.devnull, "wb")
pfl.serialize(Project.objects.all(), stream=devnull, delete=False,
fields=ProjectFormatList.columns)
self.assertEquals(len(pfl.layers), 2)
ds_point = gdal.DataSource(pfl.layers.values()[0])
layer_point = ds_point[0]
ds_line = gdal.DataSource(pfl.layers.values()[1])
layer_line = ds_line[0]
self.assertEquals(layer_point.geom_type.name, 'MultiPoint')
self.assertEquals(layer_line.geom_type.name, 'LineString')
for layer in [layer_point, layer_line]:
self.assertEquals(layer.srs.name, 'RGF93_Lambert_93')
self.assertItemsEqual(layer.fields, ['domain', 'name', 'type', 'period', 'id'])
self.assertEquals(len(layer_point), 1)
self.assertEquals(len(layer_line), 1)
for feature in layer_point:
self.assertEquals(str(feature['id']), str(proj.pk))
self.assertTrue(feature.geom.geos.equals(it_point.geom))
for feature in layer_line:
self.assertEquals(str(feature['id']), str(proj.pk))
self.assertTrue(feature.geom.geos.equals(it_line.geom))
# Clean-up temporary shapefiles
for layer_file in pfl.layers.values():
for subfile in shapefile_files(layer_file):
os.remove(subfile)
class ShapefileSerializer(TestCase):
def setUp(self):
self.point1 = DiveFactory.create()
self.point1.themes.add(ThemeFactory.create(label="Tag1"))
self.point1.themes.add(ThemeFactory.create(label="Tag2"))
self.line1 = DiveFactory.create(geom='SRID=%s;LINESTRING(0 0, 10 0)' %
settings.SRID)
self.multiline = DiveFactory.create(
geom='SRID=%s;MULTILINESTRING((10 10, 20 20, 10 40),'
'(40 40, 30 30, 40 20, 30 10))' % settings.SRID)
self.multipoint = DiveFactory.create(
geom='SRID=%s;MULTIPOINT((1 1), (2 2))' % settings.SRID)
self.polygon = DiveFactory.create(
geom='SRID=%s;POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))' % settings.SRID)
self.multipolygon = DiveFactory.create(
geom='SRID=%s;MULTIPOLYGON(((0 0, 0 1, 1 1, 1 0, 0 0)),'
'((2 2, 2 3, 3 3, 3 2, 2 2)))' % settings.SRID)
self.serializer = ZipShapeSerializer()
response = HttpResponse()
self.serializer.serialize(Dive.objects.all(),
stream=response,
fields=['id', 'name'],
delete=False)
def tearDown(self):
for layer_file in self.serializer.layers.values():
for subfile in shapefile_files(layer_file):
os.remove(subfile)
def getShapefileLayers(self):
shapefiles = self.serializer.layers.values()
datasources = [gdal.DataSource(s) for s in shapefiles]
layers = [ds[0] for ds in datasources]
return layers
def test_serializer_creates_one_layer_per_type(self):
self.assertEqual(len(self.serializer.layers), 6)
def test_each_layer_has_records_by_type(self):
layer_point, layer_linestring, layer_polygon, layer_multipoint, \
layer_multilinestring, layer_multipolygon = self.getShapefileLayers()
self.assertEqual(len(layer_point), 1)
self.assertEqual(len(layer_linestring), 1)
self.assertEqual(len(layer_multipoint), 1)
self.assertEqual(len(layer_polygon), 1)
self.assertEqual(len(layer_multilinestring), 1)
self.assertEqual(len(layer_multipolygon), 1)
def test_each_layer_has_a_different_geometry_type(self):
layer_types = [
layer.geom_type.name for layer in self.getShapefileLayers()
]
self.assertCountEqual(layer_types, [
'LineString', 'Polygon', 'MultiPoint', 'Point', 'LineString',
'Polygon'
])
def test_layer_has_right_projection(self):
for layer in self.getShapefileLayers():
self.assertIn(layer.srs.name,
('RGF93_Lambert_93', 'RGF93 / Lambert-93'))
self.assertCountEqual(layer.fields, ['id', 'name'])
def test_geometries_come_from_records(self):
layer_point, layer_linestring, layer_polygon, layer_multipoint, \
layer_multilinestring, layer_multipolygon = self.getShapefileLayers()
feature = layer_point[0]
self.assertEqual(str(feature['id']), str(self.point1.pk))
self.assertTrue(feature.geom.geos.equals(self.point1.geom))
feature = layer_multipoint[0]
self.assertEqual(str(feature['id']), str(self.multipoint.pk))
self.assertTrue(feature.geom.geos.equals(self.multipoint.geom))
feature = layer_linestring[0]
self.assertEqual(str(feature['id']), str(self.line1.pk))
self.assertTrue(feature.geom.geos.equals(self.line1.geom))
feature = layer_multilinestring[0]
self.assertEqual(str(feature['id']), str(self.multiline.pk))
self.assertTrue(feature.geom.geos.equals(self.multiline.geom))
feature = layer_polygon[0]
self.assertEqual(str(feature['id']), str(self.polygon.pk))
self.assertTrue(feature.geom.geos.equals(self.polygon.geom))
feature = layer_multipolygon[0]
self.assertEqual(str(feature['id']), str(self.multipolygon.pk))
self.assertTrue(feature.geom.geos.equals(self.multipolygon.geom))
def test_attributes(self):
layer_point, layer_linestring, layer_polygon, layer_multipoint, \
layer_multilinestring, layer_multipolygon = self.getShapefileLayers()
feature = layer_point[0]
self.assertEqual(feature['name'].value, self.point1.name)
def test_serializer_model_no_geofield(self):
self.serializer = ZipShapeSerializer()
response = HttpResponse()
with self.assertRaisesRegex(
ValueError,
"No geodjango geometry fields found in this model"):
self.serializer.serialize(Difficulty.objects.all(),
stream=response,
fields=['id', 'name'],
delete=False)
def test_serializer_model_geofield_multiple(self):
app_settings['GEOM_FIELD_NAME'] = None
self.serializer = ZipShapeSerializer()
PathFactory.create()
response = HttpResponse()
with self.assertRaisesRegex(
ValueError,
"More than one geodjango geometry field found, please specify which "
"to use by name using the 'geo_field' keyword. "
"Available fields are: 'geom_3d, geom, geom_cadastre'"):
self.serializer.serialize(Path.objects.all(),
stream=response,
fields=['id', 'name'],
delete=False)
app_settings['GEOM_FIELD_NAME'] = 'geom'
def test_serializer_model_geofield_do_not_exist(self):
app_settings['GEOM_FIELD_NAME'] = 'do_not_exist'
self.serializer = ZipShapeSerializer()
PathFactory.create()
response = HttpResponse()
with self.assertRaisesRegex(
ValueError,
"Geodjango geometry field not found with the name 'do_not_exist', "
"fields available are: 'geom_3d, geom, geom_cadastre'"):
self.serializer.serialize(Path.objects.all(),
stream=response,
fields=['id', 'name'],
delete=False)
app_settings['GEOM_FIELD_NAME'] = 'geom'
def test_serializer_shape_write_special_srid(self):
geo_field = geo_field_from_model(Dive, 'geom')
get_geom, geom_type, srid = info_from_geo_field(geo_field)
dives = [
dive for dive in Dive.objects.all()
if dive.geom.geom_type == 'Point'
]
ds = DataSource(
shape_write(dives, Dive, ['id', 'name'], get_geom, 'POINT', 2154,
3812))
layer = ds[0]
for feature in layer:
self.assertEqual(feature.geom.wkt,
'POINT (-315454.738110134 -6594196.36395464)')
def test_shape_mixed(self):
"""
Test that a project made of intervention of different geom create multiple files.
Check that those files are each of a different type (Point/LineString) and that
the project and the intervention are correctly referenced in it.
"""
# Create topology line
topo_line = TopologyFactory.create(no_path=True)
line = PathFactory.create(
geom=LineString(Point(10, 10, 0), Point(11, 10, 0)))
PathAggregationFactory.create(topo_object=topo_line, path=line)
# Create a topology point
lng, lat = tuple(
Point(1, 1, srid=settings.SRID).transform(settings.API_SRID,
clone=True))
closest_path = PathFactory(geom=LineString(
Point(0, 0, 0), Point(1, 0, 0), srid=settings.SRID))
topo_point = TopologyHelper._topologypoint(lng, lat, None).reload()
self.assertEquals(topo_point.paths.get(), closest_path)
# Create one intervention by geometry (point/linestring)
it_point = InterventionFactory.create(topology=topo_point)
it_line = InterventionFactory.create(topology=topo_line)
# reload
it_point = type(it_point).objects.get(pk=it_point.pk)
it_line = type(it_line).objects.get(pk=it_line.pk)
proj = ProjectFactory.create()
proj.interventions.add(it_point)
proj.interventions.add(it_line)
# instanciate the class based view 'abnormally' to use create_shape directly
# to avoid making http request, authent and reading from a zip
pfl = ZipShapeSerializer()
devnull = open(os.devnull, "wb")
pfl.serialize(Project.objects.all(),
stream=devnull,
delete=False,
fields=ProjectFormatList.columns)
self.assertEquals(len(pfl.layers), 2)
ds_point = gdal.DataSource(pfl.layers.values()[0])
layer_point = ds_point[0]
ds_line = gdal.DataSource(pfl.layers.values()[1])
layer_line = ds_line[0]
self.assertEquals(layer_point.geom_type.name, 'MultiPoint')
self.assertEquals(layer_line.geom_type.name, 'LineString')
for layer in [layer_point, layer_line]:
self.assertEquals(layer.srs.name, 'RGF93_Lambert_93')
self.assertItemsEqual(layer.fields,
['domain', 'name', 'type', 'period', 'id'])
self.assertEquals(len(layer_point), 1)
self.assertEquals(len(layer_line), 1)
for feature in layer_point:
self.assertEquals(str(feature['id']), str(proj.pk))
self.assertTrue(feature.geom.geos.equals(it_point.geom))
for feature in layer_line:
self.assertEquals(str(feature['id']), str(proj.pk))
self.assertTrue(feature.geom.geos.equals(it_line.geom))
# Clean-up temporary shapefiles
for layer_file in pfl.layers.values():
for subfile in shapefile_files(layer_file):
os.remove(subfile)
def test_shape_mixed(self):
"""
Test that a project made of intervention of different geom create multiple files.
Check that those files are each of a different type (Point/LineString) and that
the project and the intervention are correctly referenced in it.
"""
# Create topology line
topo_line = TopologyFactory.create(no_path=True)
line = PathFactory.create(geom=LineString(Point(10, 10, 0), Point(11, 10, 0)))
PathAggregationFactory.create(topo_object=topo_line, path=line)
# Create a topology point
lng, lat = tuple(Point(1, 1, srid=settings.SRID).transform(settings.API_SRID, clone=True))
closest_path = PathFactory(geom=LineString(Point(0, 0, 0), Point(1, 0, 0), srid=settings.SRID))
topo_point = TopologyHelper._topologypoint(lng, lat, None).reload()
self.assertEquals(topo_point.paths.get(), closest_path)
# Create one intervention by geometry (point/linestring)
it_point = InterventionFactory.create(topology=topo_point)
it_line = InterventionFactory.create(topology=topo_line)
# reload
it_point = type(it_point).objects.get(pk=it_point.pk)
it_line = type(it_line).objects.get(pk=it_line.pk)
proj = ProjectFactory.create()
proj.interventions.add(it_point)
proj.interventions.add(it_line)
shp_creator = shape_exporter.ShapeCreator()
# instanciate the class based view 'abnormally' to use create_shape directly
# to avoid making http request, authent and reading from a zip
pfl = ZipShapeSerializer()
pfl.create_shape(shp_creator, Project.objects.all(), ProjectFormatList.columns)
self.assertEquals(len(shp_creator.shapes), 2)
ds_point = gdal.DataSource(shp_creator.shapes[0][1])
layer_point = ds_point[0]
ds_line = gdal.DataSource(shp_creator.shapes[1][1])
layer_line = ds_line[0]
self.assertEquals(layer_point.geom_type.name, "MultiPoint")
self.assertEquals(layer_line.geom_type.name, "LineString")
for layer in [layer_point, layer_line]:
self.assertEquals(layer.srs.name, "RGF93_Lambert_93")
self.assertItemsEqual(layer.fields, ["domain", "name", "type", "period", "id"])
self.assertEquals(len(layer_point), 1)
self.assertEquals(len(layer_line), 1)
for feature in layer_point:
self.assertEquals(str(feature["id"]), str(proj.pk))
self.assertTrue(feature.geom.geos.equals(it_point.geom))
for feature in layer_line:
self.assertEquals(str(feature["id"]), str(proj.pk))
self.assertTrue(feature.geom.geos.equals(it_line.geom))
