def test_split_tee_1(self):
"""
C
A +---===+===---+ B
A' | B'
+ AB exists with topology A'B'.
D Add CD.
"""
ab = PathFactory.create(name="AB", geom=LineString((0, 0, 0), (4, 0, 0)))
# Create a topology
topology = TopologyFactory.create(no_path=True)
topology.add_path(ab, start=0.25, end=0.75)
topogeom = topology.geom
# Topology covers 1 path
self.assertEqual(len(topology.paths.all()), 1)
cd = PathFactory.create(geom=LineString((2, 0, 0), (2, 2, 0)))
cb = Path.objects.filter(name="AB").exclude(pk=ab.pk)[0]
# Topology now covers 2 paths
self.assertEqual(len(topology.paths.all()), 2)
# AB and AB2 has one topology each
self.assertEqual(len(ab.aggregations.all()), 1)
self.assertEqual(len(cb.aggregations.all()), 1)
# Topology position became proportional
aggr_ab = ab.aggregations.all()[0]
aggr_cb = cb.aggregations.all()[0]
self.assertEqual((0.5, 1.0), (aggr_ab.start_position, aggr_ab.end_position))
self.assertEqual((0.0, 0.5), (aggr_cb.start_position, aggr_cb.end_position))
topology.reload()
self.assertNotEqual(topology.geom, topogeom)
self.assertEqual(topology.geom.coords[0], topogeom.coords[0])
self.assertEqual(topology.geom.coords[-1], topogeom.coords[-1])
def test_manager_can_delete(self):
self.login()
path = PathFactory()
response = self.client.get(path.get_detail_url())
self.assertEqual(response.status_code, 200)
response = self.client.post(path.get_delete_url())
self.assertEqual(response.status_code, 302)
def test_snapping_is_idempotent(self):
PathFactory.create(geom=LineString((0, 0), (9.8, 0), (9.9, 0), (10, 0)))
path_snapped = PathFactory.create(geom=LineString((10, 0.1), (10, 10)))
old_geom = path_snapped.geom
path_snapped.geom = old_geom
path_snapped.save()
self.assertEqual(path_snapped.geom.coords, old_geom.coords)
def test_split_tee_2(self):
"""
C
A +---+---=====--+ B
| A' B'
+ AB exists with topology A'B'.
D Add CD
"""
ab = PathFactory.create(name="AB", geom=LineString((0, 0, 0), (4, 0, 0)))
# Create a topology
topology = TopologyFactory.create(no_path=True)
topology.add_path(ab, start=0.5, end=0.75)
topogeom = topology.geom
# Topology covers 1 path
self.assertEqual(len(ab.aggregations.all()), 1)
self.assertEqual(len(topology.paths.all()), 1)
self.assertEqual(topology.paths.all()[0], ab)
cd = PathFactory.create(geom=LineString((1, 0, 0), (1, 2, 0)))
# CB was just created
cb = Path.objects.filter(name="AB").exclude(pk=ab.pk)[0]
# AB has no topology anymore
self.assertEqual(len(ab.aggregations.all()), 0)
# Topology now still covers 1 path, but the new one
self.assertEqual(len(topology.paths.all()), 1)
self.assertEqual(len(cb.aggregations.all()), 1)
self.assertEqual(topology.paths.all()[0].pk, cb.pk)
topology.reload()
self.assertEqual(topology.geom, topogeom)
def test_split_on_update_7(self):
"""
C
A +-----------+ B A +-----X---+ B
:
C X-------+ D :
+ D
"""
ab = PathFactory.create(name="AB", geom=LineString((0, 0, 0), (4, 0, 0)))
cd = PathFactory.create(name="CD", geom=LineString((0, 1, 0), (4, 1, 0)))
topology = TopologyFactory.create(no_path=True)
topology.add_path(cd, start=0.0, end=0.0)
self.assertEqual(len(topology.paths.all()), 1)
cd.geom = LineString((2, 0, 0), (2, -2, 0))
cd.save()
cb = Path.objects.filter(name="AB").exclude(pk=ab.pk)[0]
self.assertEqual(len(ab.aggregations.all()), 1)
self.assertEqual(len(cb.aggregations.all()), 1)
self.assertEqual(len(cd.aggregations.all()), 1)
self.assertEqual(len(topology.paths.all()), 3)
aggr_ab = ab.aggregations.all()[0]
aggr_cb = cb.aggregations.all()[0]
aggr_cd = cd.aggregations.all()[0]
self.assertEqual((1.0, 1.0), (aggr_ab.start_position, aggr_ab.end_position))
self.assertEqual((0.0, 0.0), (aggr_cb.start_position, aggr_cb.end_position))
self.assertEqual((0.0, 0.0), (aggr_cd.start_position, aggr_cd.end_position))
def test_helpers(self):
trek = TrekFactory.create(no_path=True)
p1 = PathFactory.create(geom=LineString((0, 0), (4, 4)))
p2 = PathFactory.create(geom=LineString((4, 4), (8, 8)))
poi = POIFactory.create(no_path=True)
PathAggregationFactory.create(topo_object=trek, path=p1,
start_position=0.5)
PathAggregationFactory.create(topo_object=trek, path=p2)
PathAggregationFactory.create(topo_object=poi, path=p1,
start_position=0.6, end_position=0.6)
# /!\ District are automatically linked to paths at DB level
d1 = DistrictFactory.create(geom=MultiPolygon(
Polygon(((-2, -2), (3, -2), (3, 3), (-2, 3), (-2, -2)))))
# Ensure related objects are accessible
self.assertItemsEqual(trek.pois, [poi])
self.assertItemsEqual(poi.treks, [trek])
self.assertItemsEqual(trek.districts, [d1])
# Ensure there is no duplicates
PathAggregationFactory.create(topo_object=trek, path=p1,
end_position=0.5)
self.assertItemsEqual(trek.pois, [poi])
self.assertItemsEqual(poi.treks, [trek])
d2 = DistrictFactory.create(geom=MultiPolygon(
Polygon(((3, 3), (9, 3), (9, 9), (3, 9), (3, 3)))))
self.assertItemsEqual(trek.districts, [d1, d2])
def test_default_stake(self):
i = InterventionFactory.create()
i.stake = None
self.assertTrue(i.stake is None)
i.save()
self.assertTrue(i.stake is None)
lowstake = StakeFactory.create()
highstake = StakeFactory.create()
if lowstake > highstake:
tmp = lowstake
lowstake = highstake
highstake = tmp
# Add paths to topology
infra = InfrastructureFactory.create(no_path=True)
infra.add_path(PathFactory.create(stake=lowstake))
infra.add_path(PathFactory.create(stake=highstake))
infra.add_path(PathFactory.create(stake=lowstake))
i.set_infrastructure(infra)
# Stake is not None anymore
i.save()
self.assertFalse(i.stake is None)
# Make sure it took higher stake
self.assertEqual(i.stake, highstake)
def test_delete_cascade(self):
p1 = PathFactory.create()
p2 = PathFactory.create()
t = TrekFactory.create(no_path=True)
t.add_path(p1)
t.add_path(p2)
# Everything should be all right before delete
self.assertTrue(t.published)
self.assertFalse(t.deleted)
self.assertEqual(t.aggregations.count(), 2)
# When a path is deleted
p1.delete()
t = Trek.objects.get(pk=t.pk)
self.assertFalse(t.published)
self.assertFalse(t.deleted)
self.assertEqual(t.aggregations.count(), 1)
# Reset published status
t.published = True
t.save()
# When all paths are deleted
p2.delete()
t = Trek.objects.get(pk=t.pk)
self.assertFalse(t.published)
self.assertTrue(t.deleted)
self.assertEqual(t.aggregations.count(), 0)
def test_point_geom_3d(self):
"""
+
/ \
/ X \
+ +
"""
p1 = PathFactory.create(geom=LineString((0, 0, 1000), (4, 4, 2000)))
p2 = PathFactory.create(geom=LineString((4, 4, 2000), (8, 0, 0)))
poi = Point(3, 1, srid=settings.SRID)
position, distance = Path.interpolate(p1, poi)
self.assertTrue(almostequal(0.5, position))
self.assertTrue(almostequal(-1.414, distance))
# Verify that deserializing this, we obtain the same original coordinates
# (use lat/lng as in forms)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({'lat': poi.y, 'lng': poi.x})
# Computed topology properties match original interpolation
self.assertTrue(almostequal(0.5, poitopo.aggregations.all()[0].start_position))
self.assertTrue(almostequal(-1.414, poitopo.offset))
# Resulting geometry
self.assertTrue(almostequal(3, poitopo.geom.x))
self.assertTrue(almostequal(1, poitopo.geom.y))
self.assertTrue(almostequal(0, poitopo.geom.z))
def test_junction_point(self):
p1 = PathFactory.create(geom=LineString((0, 0, 0), (2, 2, 2)))
p2 = PathFactory.create(geom=LineString((0, 0, 0), (2, 0, 0)))
p3 = PathFactory.create(geom=LineString((0, 2, 2), (0, 0, 0)))
# Create a junction point topology
t = TopologyFactory.create(no_path=True)
self.assertEqual(len(t.paths.all()), 0)
pa = PathAggregationFactory.create(topo_object=t, path=p1,
start_position=0.0, end_position=0.0)
self.assertItemsEqual(t.paths.all(), [p1, p2, p3])
# Update to a non junction point topology
pa.end_position = 0.4
pa.save()
self.assertItemsEqual(t.paths.all(), [p1])
# Update to a junction point topology
pa.end_position = 0.0
pa.save()
self.assertItemsEqual(t.paths.all(), [p1, p2, p3])
def test_latestupdate_delete(self):
for i in range(10):
PathFactory.create()
t1 = dbnow()
self.assertTrue(t1 > Path.latest_updated())
(Path.objects.all()[0]).delete()
self.assertFalse(t1 > Path.latest_updated())
def test_topology_geom(self):
p1 = PathFactory.create(geom=LineString((0, 0, 0), (2, 2, 2)))
p2 = PathFactory.create(geom=LineString((2, 2, 2), (2, 0, 0)))
p3 = PathFactory.create(geom=LineString((2, 0, 0), (4, 0, 0)))
# Type Point
t = TopologyFactory.create(no_path=True)
PathAggregationFactory.create(topo_object=t, path=p1,
start_position=0.5, end_position=0.5)
t = Topology.objects.get(pk=t.pk)
self.assertEqual(t.geom, Point((1, 1, 1)))
# 50% of path p1, 100% of path p2
t = TopologyFactory.create(no_path=True)
PathAggregationFactory.create(topo_object=t, path=p1,
start_position=0.5)
PathAggregationFactory.create(topo_object=t, path=p2)
t = Topology.objects.get(pk=t.pk)
self.assertEqual(t.geom, LineString((1, 1, 1), (2, 2, 2), (2, 0, 0)))
# 100% of path p2 and p3, with offset of 1
t = TopologyFactory.create(no_path=True, offset=1)
PathAggregationFactory.create(topo_object=t, path=p2)
PathAggregationFactory.create(topo_object=t, path=p3)
t.save()
self.assertEqual(t.geom, LineString((3, 2, 2), (3, 1, 0), (4, 1, 0)))
# Change offset, geometry is computed again
t.offset = 0.5
t.save()
self.assertEqual(t.geom, LineString((2.5, 2, 2), (2.5, 0.5, 0), (4, 0.5, 0)))
def test_spoon_loop(self):
"""
=====<====
|| ||
+-------===<===>===+=====>===
"""
p1 = PathFactory.create(geom=LineString((0, 0, 0), (10, 0, 0)))
p2 = PathFactory.create(geom=LineString((10, 0, 0), (10, 5, 0),
(20, 5, 0), (20, 0, 0),
(10, 0, 0)))
topo = TopologyFactory.create(no_path=True)
topo.add_path(p1, start=0.3, end=1)
topo.add_path(p2, start=1, end=0.4)
topo.add_path(p2, start=0.4, end=0.4)
topo.add_path(p2, start=0.4, end=0.2)
topo.add_path(p2, start=0.2, end=0.2)
topo.add_path(p2, start=0.2, end=0)
topo.add_path(p1, start=1, end=0.3)
topo.save()
self.assertEqual(topo.geom, LineString((3, 0, 0), (10, 0, 0), (20, 0, 0), (20, 5, 0),
(17, 5, 0), (11, 5, 0), # extra point due middle aggregation
(10, 5, 0), (10, 0, 0), (3, 0, 0)))
# Deserializing should work too
topod = Topology.deserialize("""
[{"positions":{"0":[0.3,1],"1":[1, 0.4]},"paths":[%(pk1)s,%(pk2)s]},
{"positions":{"0":[0.4, 0.2]},"paths":[%(pk2)s]},
{"positions":{"0":[0.2,0],"1":[1,0.3]},"paths":[%(pk2)s,%(pk1)s]}]""" % {'pk1': p1.pk, 'pk2': p2.pk})
self.assertEqual(topo.geom, topod.geom)
self.assertEqual(len(topod.aggregations.all()), 7)
def test_spoon_loop_2(self):
"""
=====>====
|| ||
+-------===<===>===+=====<===
"""
p1 = PathFactory.create(geom=LineString((0, 0, 0), (10, 0, 0)))
p2 = PathFactory.create(geom=LineString((10, 0, 0), (10, 5, 0),
(20, 5, 0), (20, 0, 0),
(10, 0, 0)))
topo = TopologyFactory.create(no_path=True)
topo.add_path(p1, start=0.3, end=1)
topo.add_path(p2, start=0, end=0.4)
topo.add_path(p2, start=0.4, end=0.4)
topo.add_path(p2, start=0.4, end=0.8)
topo.add_path(p2, start=0.8, end=0.8)
topo.add_path(p2, start=0.8, end=1.0)
topo.add_path(p1, start=1, end=0.3)
topo.save()
self.assertEqual(topo.geom, LineString((3, 0, 0), (10, 0, 0), (10, 5, 0),
(17, 5, 0), (20, 5, 0), # extra point due middle aggregation
(20, 0, 0), (16, 0, 0), (10, 0, 0), (3, 0, 0)))
# De/Serializing should work too
serialized = """
[{"kind": "TOPOLOGY","positions":{"0":[0.3,1],"1":[0, 0.4]},"paths":[%(pk1)s,%(pk2)s],"offset": 0.0},
{"kind": "TOPOLOGY","positions":{"0":[0.4, 0.8]},"paths":[%(pk2)s],"offset": 0.0},
{"kind": "TOPOLOGY","positions":{"0":[0.8,1],"1":[1,0.3]},"paths":[%(pk2)s,%(pk1)s],"offset": 0.0}]""" % {'pk1': p1.pk, 'pk2': p2.pk}
self.assertEqual(json.loads(serialized), json.loads(topo.serialize()))
topod = Topology.deserialize(serialized)
self.assertEqual(topo.geom, topod.geom)
self.assertEqual(len(topod.aggregations.all()), 7)
def test_upload(self):
path = PathFactory(length=1)
response = self.client.get(path.get_update_url())
f = get_dummy_uploaded_image()
data = {"filetype": FileTypeFactory().pk, "title": "title1", "legend": "legend1", "attachment_file": f}
response = self.client.post(add_url_for_obj(path), data=data)
self.assertEquals(response.status_code, 302)
att = Attachment.objects.attachments_for_object(path).get()
self.assertEqual(att.title, data["title"])
self.assertEqual(att.legend, data["legend"])
self.assertEqual(att.filetype.pk, data["filetype"])
f.open()
self.assertEqual(att.attachment_file.readlines(), f.readlines())
# Check that if title is given, filename is title
self.assertTrue(att.attachment_file.name, "title1")
# Check that if no title is give, filename is original name
data["title"] = ""
response = self.client.post(add_url_for_obj(path), data=data)
att = Attachment.objects.attachments_for_object(path)[0]
self.assertTrue(att.attachment_file.name, "image")
def test_show_delete_multiple_path_in_list(self):
path_1 = PathFactory.create(name="path_1", geom=LineString((0, 0), (4, 0)))
PathFactory.create(name="path_2", geom=LineString((2, 2), (2, -2)))
poi = POIFactory.create(no_path=True)
poi.add_path(path_1, start=0, end=0)
response = self.client.get(reverse('core:path_list'))
self.assertIn('<a href="#delete" id="btn-delete" role="button">', response.content)
def test_split_tee_1(self):
"""
C
A +-----X----+ B
|
+ AB exists with topology at C.
D Add CD.
"""
ab = PathFactory.create(name="AB", geom=LineString((0, 0, 0), (4, 0, 0)))
topology = TopologyFactory.create(no_path=True)
topology.add_path(ab, start=0.5, end=0.5)
self.assertEqual(len(topology.paths.all()), 1)
cd = PathFactory.create(geom=LineString((2, 0, 0), (2, 2, 0)))
cb = Path.objects.filter(name="AB").exclude(pk=ab.pk)[0]
self.assertEqual(len(topology.paths.all()), 3)
self.assertEqual(len(ab.aggregations.all()), 1)
aggr_ab = ab.aggregations.all()[0]
self.assertEqual(len(cb.aggregations.all()), 1)
aggr_cb = cb.aggregations.all()[0]
self.assertEqual(len(cd.aggregations.all()), 1)
aggr_cd = cd.aggregations.all()[0]
self.assertEqual((1.0, 1.0), (aggr_ab.start_position, aggr_ab.end_position))
self.assertEqual((0.0, 0.0), (aggr_cb.start_position, aggr_cb.end_position))
self.assertEqual((0.0, 0.0), (aggr_cd.start_position, aggr_cd.end_position))
def test_split_on_update(self):
""" + E
:
||
A +-----------+ B A +----++---+ B
||
C +-====-+ D C +--===+ D
"""
ab = PathFactory.create(name="AB", geom=LineString((0, 0, 0), (4, 0, 0)))
cd = PathFactory.create(name="CD", geom=LineString((0, -1, 0), (4, -1, 0)))
# Create a topology
topology = TopologyFactory.create(no_path=True)
topology.add_path(cd, start=0.3, end=0.9)
self.assertEqual(len(topology.paths.all()), 1)
cd.geom = LineString((0, -1, 0), (2, -1, 0), (2, 2, 0))
cd.save()
cd2 = Path.objects.filter(name="CD").exclude(pk=cd.pk)[0]
self.assertEqual(len(topology.paths.all()), 2)
self.assertEqual(len(cd.aggregations.all()), 1)
self.assertEqual(len(cd2.aggregations.all()), 1)
aggr_cd = cd.aggregations.all()[0]
aggr_cd2 = cd2.aggregations.all()[0]
self.assertEqual((0.5, 1.0), (aggr_cd.start_position, aggr_cd.end_position))
self.assertEqual((0.0, 0.75), (aggr_cd2.start_position, aggr_cd2.end_position))
def test_delete_multiple_path(self):
path_1 = PathFactory.create(name="path_1", geom=LineString((0, 0), (4, 0)))
path_2 = PathFactory.create(name="path_2", geom=LineString((2, 2), (2, -2)))
poi = POIFactory.create(no_path=True, name="POI_1")
poi.add_path(path_1, start=0, end=0)
infrastructure = InfrastructureFactory.create(no_path=True, name="INFRA_1")
infrastructure.add_path(path_1, start=0, end=1)
signage = SignageFactory.create(no_path=True, name="SIGNA_1")
signage.add_path(path_1, start=0, end=1)
trail = TrailFactory.create(no_path=True, name="TRAIL_1")
trail.add_path(path_2, start=0, end=1)
service = ServiceFactory.create(no_path=True)
service.add_path(path_2, start=0, end=1)
InterventionFactory.create(topology=signage, name="INTER_1")
response = self.client.get(reverse('core:multiple_path_delete', args=['%s,%s' % (path_1.pk, path_2.pk)]))
self.assertIn("POI_1", response.content)
self.assertIn("INFRA_1", response.content)
self.assertIn("SIGNA_1", response.content)
self.assertIn("TRAIL_1", response.content)
self.assertIn("ServiceType", response.content)
self.assertIn("INTER_1", response.content)
response = self.client.post(reverse('core:multiple_path_delete', args=['%s,%s' % (path_1.pk, path_2.pk)]))
self.assertEqual(response.status_code, 302)
self.assertEqual(Path.objects.count(), 2)
self.assertEqual(Path.objects.filter(pk__in=[path_1.pk, path_2.pk]).count(), 0)
def test_split_tee_3(self):
"""
C
A +--=====--+---+ B
A' B' |
+ AB exists with topology A'B'.
D Add CD
"""
ab = PathFactory.create(name="AB", geom=LineString((0, 0, 0), (4, 0, 0)))
# Create a topology
topology = TopologyFactory.create(no_path=True)
topology.add_path(ab, start=0.3, end=0.6)
topogeom = topology.geom
# Topology covers 1 path
self.assertEqual(len(ab.aggregations.all()), 1)
self.assertEqual(len(topology.paths.all()), 1)
self.assertEqual(topology.paths.all()[0], ab)
cd = PathFactory.create(geom=LineString((3, 0, 0), (3, 2, 0)))
cb = Path.objects.filter(name="AB").exclude(pk=ab.pk)[0]
# CB does not have any
self.assertEqual(len(cb.aggregations.all()), 0)
# AB has still its topology
self.assertEqual(len(ab.aggregations.all()), 1)
# But start/end have changed
aggr_ab = ab.aggregations.all()[0]
self.assertEqual((0.4, 0.8), (aggr_ab.start_position, aggr_ab.end_position))
topology.reload()
self.assertEqual(topology.geom, topogeom)
def test_split_twice(self):
"""
C D
+ +
| |
A +--==+===+==--+ B
| |
+---+
"""
ab = PathFactory.create(name="AB", geom=LineString((0, 0, 0), (4, 0, 0)))
# Create a topology
topology = TopologyFactory.create(no_path=True)
topology.add_path(ab, start=0.1, end=0.9)
topogeom = topology.geom
self.assertEqual(len(topology.paths.all()), 1)
cd = PathFactory.create(name="CD", geom=LineString((1, 2, 0), (1, -2, 0),
(3, -2, 0), (3, 2, 0)))
self.assertEqual(len(topology.paths.all()), 3)
self.assertEqual(len(ab.aggregations.all()), 1)
aggr_ab = ab.aggregations.all()[0]
self.assertEqual((0.4, 1.0), (aggr_ab.start_position, aggr_ab.end_position))
ab2 = Path.objects.filter(name="AB").exclude(pk=ab.pk)[0]
ab3 = Path.objects.filter(name="AB").exclude(pk__in=[ab.pk, ab2.pk])[0]
aggr_ab2 = ab2.aggregations.all()[0]
aggr_ab3 = ab3.aggregations.all()[0]
self.assertEqual((0.0, 1.0), (aggr_ab2.start_position, aggr_ab2.end_position))
self.assertEqual((0.0, 0.6), (aggr_ab3.start_position, aggr_ab3.end_position))
topology.reload()
self.assertNotEqual(topology.geom, topogeom)
self.assertEqual(topology.geom.coords[0], topogeom.coords[0])
self.assertEqual(topology.geom.coords[-1], topogeom.coords[-1])
def test_merge_works(self):
self.login()
p1 = PathFactory.create(name="AB", geom=LineString((0, 0), (1, 0)))
p2 = PathFactory.create(name="BC", geom=LineString((1, 0), (2, 0)))
response = self.client.post(reverse('core:merge_path'), {'path[]': [p1.pk, p2.pk]})
self.assertIn('success', response.json())
self.logout()
def test_delete_show_topologies(self):
self.login()
path = PathFactory(name="PATH_AB", geom=LineString((0, 0), (4, 0)))
poi = POIFactory.create(name='POI', no_path=True)
poi.add_path(path, start=0.5, end=0.5)
trail = TrailFactory.create(name='Trail', no_path=True)
trail.add_path(path, start=0.1, end=0.2)
trek = TrekFactory.create(name='Trek', no_path=True)
trek.add_path(path, start=0.2, end=0.3)
service = ServiceFactory.create(no_path=True, type__name='ServiceType')
service.add_path(path, start=0.2, end=0.3)
signage = SignageFactory.create(name='Signage', no_path=True)
signage.add_path(path, start=0.2, end=0.2)
infrastructure = InfrastructureFactory.create(name='Infrastructure', no_path=True)
infrastructure.add_path(path, start=0.2, end=0.2)
intervention1 = InterventionFactory.create(topology=signage, name='Intervention1')
t = TopologyFactory.create(no_path=True)
t.add_path(path, start=0.2, end=0.5)
intervention2 = InterventionFactory.create(topology=t, name='Intervention2')
response = self.client.get(path.get_delete_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Different topologies are linked with this path')
self.assertContains(response, '<a href="/poi/%d/">POI</a>' % poi.pk)
self.assertContains(response, '<a href="/trail/%d/">Trail</a>' % trail.pk)
self.assertContains(response, '<a href="/trek/%d/">Trek</a>' % trek.pk)
self.assertContains(response, '<a href="/service/%d/">ServiceType</a>' % service.pk)
self.assertContains(response, '<a href="/signage/%d/">Signage</a>' % signage.pk)
self.assertContains(response, '<a href="/infrastructure/%d/">Infrastructure</a>' % infrastructure.pk)
self.assertContains(response, '<a href="/intervention/%d/">Intervention1</a>' % intervention1.pk)
self.assertContains(response, '<a href="/intervention/%d/">Intervention2</a>' % intervention2.pk)
def test_split_twice(self):
"""
C D
+ +
| |
A +--+---+--+ B
| |
+---+
"""
ab = PathFactory.create(name="AB", geom=LineString((0, 0, 0), (4, 0, 0)))
cd = PathFactory.create(name="CD", geom=LineString((1, 2, 0), (1, -2, 0),
(3, -2, 0), (3, 2, 0)))
ab.reload()
self.assertEqual(ab.length, 1)
self.assertEqual(cd.length, 2)
ab_clones = Path.objects.filter(name="AB").exclude(pk=ab.pk)
cd_clones = Path.objects.filter(name="CD").exclude(pk=cd.pk)
self.assertEqual(len(ab_clones), 2)
self.assertEqual(len(cd_clones), 2)
self.assertEqual(ab_clones[0].geom, LineString((1, 0, 0), (3, 0, 0)))
self.assertEqual(ab_clones[1].geom, LineString((3, 0, 0), (4, 0, 0)))
self.assertEqual(cd_clones[0].geom, LineString((1, 0, 0), (1, -2, 0),
(3, -2, 0), (3, 0, 0)))
self.assertEqual(cd_clones[1].geom, LineString((3, 0, 0), (3, 2, 0)))
def test_return_path_serialized(self):
"""
Same as test_return_path() but from deserialization.
"""
p1 = PathFactory.create(geom=LineString((0, 0), (10, 0)))
p2 = PathFactory.create(geom=LineString((5, 0), (5, 10), (10, 10)))
p3 = Path.objects.filter(name=p1.name).exclude(pk=p1.pk)[0] # Was splitted :)
topo = Topology.deserialize(
"""
[{"offset":0,
"positions":{"0":[0.5,1],
"1":[0.0, 0.8]},
"paths":[%(p1)s,%(p2)s]
},
{"offset":0,
"positions":{"0":[0.8,0.0],
"1":[0.0, 0.5]},
"paths":[%(p2)s,%(p3)s]
}
]
"""
% {"p1": p1.pk, "p2": p2.pk, "p3": p3.pk}
)
topo.save()
self.assertEqual(topo.geom, LineString((2.5, 0), (5, 0), (5, 10), (7, 10), (5, 10), (5, 0), (7.5, 0)))
def test_delete_view_multiple_path(self):
path_1 = PathFactory.create(name="path_1", geom=LineString((0, 0), (4, 0)))
path_2 = PathFactory.create(name="path_2", geom=LineString((2, 2), (2, -2)))
poi = POIFactory.create(no_path=True)
poi.add_path(path_1, start=0, end=0)
response = self.client.get(reverse('core:multiple_path_delete', args=['%s,%s' % (path_1.pk, path_2.pk)]))
self.assertEqual(response.status_code, 200)
self.assertIn('Do you really wish to delete', response.content)
def test_merge_fails_donttouch(self):
self.login()
p3 = PathFactory.create(name="AB", geom=LineString((0, 0), (1, 0)))
p4 = PathFactory.create(name="BC", geom=LineString((500, 0), (1000, 0)))
response = self.client.post(reverse('core:merge_path'), {'path[]': [p3.pk, p4.pk]})
self.assertIn('error', response.json())
self.logout()
def get_good_data(self):
PathFactory.create()
return {
'name': 'test',
'description': 'oh',
'structure': default_structure().pk,
'type': InfrastructureTypeFactory.create(type=INFRASTRUCTURE_TYPES.BUILDING).pk,
'topology': '{"lat": 0.42, "lng": 0.666}'
}
def get_good_data(self):
PathFactory.create()
return {
"name": "test",
"description": "oh",
"structure": default_structure().pk,
"type": InfrastructureTypeFactory.create(type=INFRASTRUCTURE_TYPES.BUILDING).pk,
"topology": '{"lat": 0.42, "lng": 0.666}',
}
def get_good_data(self):
PathFactory.create()
return {
'name_fr': 'test',
'name_en': 'test',
'description_fr': 'ici',
'description_en': 'here',
'type': POITypeFactory.create().pk,
'topology': '{"lat": 5.1, "lng": 6.6}'
}
def test_detail_target_objects(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
path = PathFactory.create(geom=LineString((200, 200), (300, 300)))
signa = SignageFactory.create(paths=[(path, .5, .5)])
signa.save()
infrastructure = InfrastructureFactory.create(paths=[(path, .5, .5)])
infrastructure.save()
poi = POIFactory.create(paths=[(path, .5, .5)])
trek = TrekFactory.create(paths=[(path, .5, .5)])
service = ServiceFactory.create(paths=[(path, .5, .5)])
topo = TopologyFactory.create(paths=[(path, .5, .5)])
topo.save()
path_other = PathFactory.create(geom=LineString((10000, 0), (10010, 0)))
signa_other = SignageFactory.create(paths=[(path_other, .5, .5)])
signa_other.save()
else:
signa = SignageFactory.create(geom='SRID=2154;POINT (250 250)')
infrastructure = InfrastructureFactory.create(geom='SRID=2154;POINT (250 250)')
poi = POIFactory.create(geom='SRID=2154;POINT (250 250)')
trek = TrekFactory.create(geom='SRID=2154;POINT (250 250)')
service = ServiceFactory.create(geom='SRID=2154;POINT (250 250)')
topo = TopologyFactory.create(geom='SRID=2154;POINT (250 250)')
signa_other = SignageFactory.create(geom='SRID=2154;POINT (10005 0)')
intervention_signa = InterventionFactory.create(target=signa)
intervention_infra = InterventionFactory.create(target=infrastructure)
intervention_poi = InterventionFactory.create(target=poi)
intervention_trek = InterventionFactory.create(target=trek)
intervention_service = InterventionFactory.create(target=service)
intervention_topo = InterventionFactory.create(target=topo)
blade = BladeFactory(signage=signa, number="1")
intervention_blade = InterventionFactory.create(target=blade)
intervention_other = InterventionFactory.create(target=signa_other)
response = self.client.get(signa.get_detail_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, intervention_signa.target_display)
self.assertContains(response, intervention_infra.target_display)
self.assertContains(response, intervention_poi.target_display)
self.assertContains(response, intervention_trek.target_display)
self.assertContains(response, intervention_service.target_display)
self.assertContains(response, intervention_blade.target_display)
self.assertContains(response, intervention_topo.target_display)
self.assertNotContains(response, intervention_other.target_display)
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_form_default_stake(self):
self.login()
good_data = self.get_good_data()
good_data['stake'] = ''
good_data['topology'] = """
{"offset":0,"positions":{"0":[0.8298653170816073,1],"2":[0,0.04593024777973237]},"paths":[%s,%s,%s]}
""" % (PathFactory.create().pk, PathFactory.create().pk,
PathFactory.create().pk)
response = self.client.post(Intervention.get_add_url(), good_data)
self.assertEqual(response.status_code, 302)
response = self.client.get(response._headers['location'][1])
self.assertTrue('object' in response.context)
intervention = response.context['object']
self.assertFalse(intervention.stake is None)
def test_dates(self):
t1 = dbnow()
p = PathFactory()
t2 = dbnow()
self.assertTrue(t1 < p.date_insert < t2,
msg='Date interval failed: %s < %s < %s' %
(t1, p.date_insert, t2))
p.name = "Foo"
p.save()
t3 = dbnow()
self.assertTrue(t2 < p.date_update < t3,
msg='Date interval failed: %s < %s < %s' %
(t2, p.date_update, t3))
def test_troncons_link(self):
p1 = PathFactory.create(geom=LineString((0, 0, 0), (1, 1, 1)))
p2 = PathFactory.create(geom=LineString((1, 1, 1), (3, 3, 3)))
p3 = PathFactory.create(geom=LineString((3, 3, 3), (4, 4, 4)))
p4 = PathFactory.create(
geom=LineString((4, 1, 1), (6, 2, 2), (4, 3, 3)))
# Paths should not be linked to anything at this stage
self.assertEquals(p1.aggregations.count(), 0)
self.assertEquals(p2.aggregations.count(), 0)
self.assertEquals(p3.aggregations.count(), 0)
c1 = City.objects.create(code='005177',
name='Trifouillis-les-oies',
geom=MultiPolygon(
Polygon(((0, 0), (2, 0), (2, 4), (0, 4),
(0, 0)),
srid=settings.SRID)))
c2 = City.objects.create(code='005179',
name='Trifouillis-les-poules',
geom=MultiPolygon(
Polygon(((2, 0), (5, 0), (5, 4), (2, 4),
(2, 0)),
srid=settings.SRID)))
# There should be automatic link after insert
self.assertEquals(p1.aggregations.count(), 1)
self.assertEquals(p2.aggregations.count(), 2)
self.assertEquals(p3.aggregations.count(), 1)
self.assertEquals(p4.aggregations.count(), 2)
c1.geom = MultiPolygon(
Polygon(((1.5, 0), (2, 0), (2, 4), (1.5, 4), (1.5, 0)),
srid=settings.SRID))
c1.save()
# Links should have been updated after geom update
self.assertEquals(p1.aggregations.count(), 0)
self.assertEquals(p2.aggregations.count(), 2)
self.assertEquals(p3.aggregations.count(), 1)
self.assertEquals(p4.aggregations.count(), 2)
c1.delete()
# Links should have been updated after delete
self.assertEquals(p1.aggregations.count(), 0)
self.assertEquals(p2.aggregations.count(), 1)
self.assertEquals(p3.aggregations.count(), 1)
self.assertEquals(p4.aggregations.count(), 2)
def test_deserialize_point(self):
PathFactory.create()
# Take a point
p = Point(2, 1, 0, srid=settings.SRID)
p.transform(settings.API_SRID)
closest = Path.closest(p)
# Check closest path
self.assertEqual(closest.geom.coords, ((1.0, 1.0, 0.0), (2.0, 2.0, 0.0)))
# The point has same x as first point of path, and y to 0 :
topology = Topology.deserialize('{"lng": %s, "lat": %s}' % (p.x, p.y))
self.assertAlmostEqual(topology.offset, -0.7071, 3)
self.assertEqual(len(topology.paths.all()), 1)
pagg = topology.aggregations.get()
self.assertTrue(almostequal(pagg.start_position, 0.5))
self.assertTrue(almostequal(pagg.end_position, 0.5))
def setUpTestData(cls):
p1 = PathFactory()
cls.seek_path = PathFactory(geom=getRandomLineStringInBounds())
topo_1 = TopologyFactory.create(paths=[p1])
seek_topo = TopologyFactory.create(paths=[cls.seek_path])
it_p1 = InterventionFactory.create(target=topo_1)
seek_it = InterventionFactory.create(target=seek_topo)
cls.seek_proj = ProjectFactory.create()
cls.seek_proj.interventions.add(seek_it)
proj_1 = ProjectFactory.create()
proj_1.interventions.add(it_p1)
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_pois_should_be_ordered_by_progression(self):
p1 = PathFactory.create(geom=LineString((0, 0), (4, 4)))
p2 = PathFactory.create(geom=LineString((4, 4), (8, 8)))
self.trek = TrekFactory.create(paths=[p1, p2])
self.trek_reverse = TrekFactory.create(paths=[(p2, 0.8, 0), (p1, 1, 0.2)])
self.poi1 = POIFactory.create(paths=[(p1, 0.8, 0.8)])
self.poi2 = POIFactory.create(paths=[(p1, 0.3, 0.3)])
self.poi3 = POIFactory.create(paths=[(p2, 0.5, 0.5)])
pois = self.trek.pois
self.assertEqual([self.poi2, self.poi1, self.poi3], list(pois))
pois = self.trek_reverse.pois
self.assertEqual([self.poi3, self.poi1, self.poi2], list(pois))
def test_merge_fails_parameters(self):
"""
Should fail if path[] length != 2
"""
self.login()
p1 = PathFactory.create()
p2 = PathFactory.create()
response = self.client.post(reverse('core:merge_path'),
{'path[]': [p1.pk]})
self.assertIn('error', response.json())
response = self.client.post(reverse('core:merge_path'),
{'path[]': [p1.pk, p1.pk, p2.pk]})
self.assertIn('error', response.json())
self.logout()
def get_good_data(self):
PathFactory.create()
return {
'name':
'test',
'description':
'oh',
'type':
InfrastructureTypeFactory.create(
type=INFRASTRUCTURE_TYPES.BUILDING).pk,
'condition':
InfrastructureConditionFactory.create().pk,
'topology':
'{"lat": 0.42, "lng": 0.666}'
}
def test_recompute_pk_no_reverse(self):
"""
A---------------B + C-------------------D A----------------BC----------------D
| | |--| | => | | |--| |
E1 (0.2) | E3 (0.2, 0.3) | E1 (0.1) | E3 (0.6, 0.65) E4 (0.9)
E2 (0.6) E4 (0.8) E2 (0.3)
In case of AB == CD, matching B and C
"""
path_AB = PathFactory.create(name="PATH_AB", geom=LineString((0, 1), (10, 1)))
path_CD = PathFactory.create(name="PATH_CD", geom=LineString((10, 1), (20, 1)))
e1 = TopologyFactory.create(geom=Point(2, 2))
a1 = PathAggregationFactory.create(path=path_AB, topo_object=e1)
e2 = TopologyFactory.create(geom=Point(6, 1))
a2 = PathAggregationFactory.create(path=path_AB, topo_object=e2)
e3 = TopologyFactory.create(geom=LineString((2, 1), (3, 1),))
a3 = PathAggregationFactory.create(path=path_CD, topo_object=e3)
e4 = TopologyFactory.create(geom=Point(8, 2))
a4 = PathAggregationFactory.create(path=path_CD, topo_object=e4)
path_AB_original_length = path_AB.length
path_CD_original_length = path_CD.length
path_AB.merge_path(path_CD)
self.assertEqual(path_AB.geom, LineString((0, 1), (10, 1), (20, 1), srid=settings.SRID))
# reload updated objects
a1_updated = PathAggregation.objects.get(pk=a1.pk)
a2_updated = PathAggregation.objects.get(pk=a2.pk)
a3_updated = PathAggregation.objects.get(pk=a3.pk)
a4_updated = PathAggregation.objects.get(pk=a4.pk)
# test pk recompute on path_1 : new pk = old pk * old_path_1_length / new_path_1_length
self.assertEqual(a1_updated.start_position, a1.start_position * (path_AB_original_length / path_AB.length))
self.assertEqual(a1_updated.end_position, a1.end_position * (path_AB_original_length / path_AB.length))
self.assertEqual(a2_updated.start_position, a2.start_position * (path_AB_original_length / path_AB.length))
self.assertEqual(a2_updated.end_position, a1.end_position * (path_AB_original_length / path_AB.length))
# test pk recompute on path_2 : new pk = old pk * old_path_2_length / new_path_1_length + old_path_1_length / new_path_1_length
self.assertEqual(a3_updated.start_position, a3.start_position * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length)
self.assertEqual(a3_updated.end_position, a3.end_position * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length)
self.assertEqual(a4_updated.start_position, a4.start_position * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length)
self.assertEqual(a4_updated.end_position, a4.end_position * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length)
def test_extent(self):
p1 = PathFactory.create()
lng_min, lat_min, lng_max, lat_max = p1.extent
self.assertAlmostEqual(lng_min, 3.0)
self.assertAlmostEqual(lat_min, 46.499999999999936)
self.assertAlmostEqual(lng_max, 3.0013039767202154)
self.assertAlmostEqual(lat_max, 46.50090044234927)
def test_opposite_paths(self):
"""
A C
B +-------+-------+ D
"""
ab = PathFactory.create(geom=LineString((5, 0), (0, 0)))
cd = PathFactory.create(geom=LineString((5, 0), (10, 0)))
topo = TopologyFactory.create(paths=[(ab, 0.2, 0), (cd, 0, 0.2)])
expected = LineString((4, 0), (5, 0), (6, 0), srid=settings.SRID)
self.assertEqual(topo.geom, expected)
# Now let's have some fun, reverse BA :)
ab.reverse()
ab.save()
topo.reload()
self.assertEqual(topo.geom, expected)
def test_trek_all_reverse(self):
"""
+----<===+=======+====|----->
"""
p1 = PathFactory.create(geom=LineString((0, 0), (10, 0)))
p2 = PathFactory.create(geom=LineString((10, 0), (20, 0)))
p3 = PathFactory.create(geom=LineString((20, 0), (30, 0)))
topo = TopologyFactory.create(paths=[(p3, 0.2, 0), (p2, 1,
0), (p1, 1, 0.9)])
self.assertEqual(
topo.geom,
LineString((22.0, 0.0), (20.0, 0.0), (10.0, 0.0), (9.0, 0.0),
srid=settings.SRID))
def test_point_geom_not_moving(self):
r"""
Modify path, point not moving
+ +
| |
\ X / X
/ \
| |
+ +
"""
p1 = PathFactory.create(
geom=LineString((0, 0), (0, 5), (5, 10), (0, 15), (0, 20)))
poi = Point(10, 10, srid=settings.SRID)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({'lat': poi.y, 'lng': poi.x})
self.assertEqual(0.5, poitopo.aggregations.all()[0].start_position)
self.assertAlmostEqual(-5, poitopo.offset, places=6)
# It should have kept its position !
self.assertAlmostEqual(10, poitopo.geom.x, places=6)
self.assertAlmostEqual(10, poitopo.geom.y, places=6)
# Change path, it should still be in the same position
p1.geom = LineString((0, 0), (0, 5), (-5, 10), (0, 15), (0, 20))
p1.save()
poitopo.reload()
self.assertAlmostEqual(10, poitopo.geom.x, places=6)
self.assertAlmostEqual(10, poitopo.geom.y, places=6)
def test_point_offset_updated(self):
"""
Shorten path, offset updated.
X X
+-----------+ +------+
"""
p1 = PathFactory.create(geom=LineString((0, 0), (20, 0)))
poi = Point(10, 10, srid=settings.SRID)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({'lat': poi.y, 'lng': poi.x})
poitopo.save()
self.assertAlmostEqual(0.5,
poitopo.aggregations.all()[0].start_position,
places=6)
self.assertAlmostEqual(10, poitopo.offset, places=6)
p1.geom = LineString((0, 0), (0, 5))
p1.save()
poitopo.reload()
self.assertAlmostEqual(11.180339887, poitopo.offset, places=6)
# Not moved:
self.assertAlmostEqual(10, poitopo.geom.x, places=6)
self.assertAlmostEqual(10, poitopo.geom.y, places=6)
def test_path_helpers(self):
p = PathFactory.create()
self.assertEqual(len(p.interventions), 0)
self.assertEqual(len(p.projects), 0)
sign = SignageFactory.create(no_path=True)
sign.add_path(p, start=0.5, end=0.5)
infra = InfrastructureFactory.create(no_path=True)
infra.add_path(p)
i1 = InterventionFactory.create()
i1.set_topology(sign)
i1.save()
self.assertCountEqual(p.interventions, [i1])
i2 = InterventionFactory.create()
i2.set_topology(infra)
i2.save()
self.assertCountEqual(p.interventions, [i1, i2])
proj = ProjectFactory.create()
proj.interventions.add(i1)
proj.interventions.add(i2)
self.assertCountEqual(p.projects, [proj])
def test_path_merge_with_other_path_next_ws(self):
"""
F
|
|
E
A---------------B + C-------------------D
Do not merge !
"""
path_AB = PathFactory.create(name="PATH_AB",
geom=LineString((0, 1), (10, 1)))
path_CD = PathFactory.create(name="PATH_CD",
geom=LineString((10, 1), (20, 1)))
PathFactory.create(name="PATH_EF", geom=LineString((10, 1), (10, 5)))
self.assertEqual(path_AB.merge_path(path_CD), 2)
def create_infrastructure_point_intervention(obj, create, extracted,
**kwargs):
infra = InfrastructureFactory.create(no_path=True)
infra.add_path(PathFactory.create(), start=0.5, end=0.5)
obj.set_infrastructure(infra)
if create:
obj.save()
def test_save_path_with_edit_draft_path_and_edit_path(self):
"""
Check save path without permission change_path save with draft=True
"""
draft_path = PathFactory(name="draft",
geom=LineString((0, 2), (4, 2)),
draft=True)
self.user.user_permissions.add(
Permission.objects.get(codename='change_path'))
self.user.user_permissions.add(
Permission.objects.get(codename='change_draft_path'))
self.client.login(username=self.user.username, password='******')
data = self.get_good_data()
data['draft'] = True
response = self.client.post('/path/edit/%s/' % draft_path.pk, data)
self.assertEqual(response.status_code, 302)
self.assertTrue(Path.objects.get(pk=draft_path.pk).draft)
# You can change a draft path to a normal path.
data['draft'] = False
response = self.client.post('/path/edit/%s/' % draft_path.pk, data)
self.assertEqual(response.status_code, 302)
self.assertFalse(Path.objects.get(pk=draft_path.pk).draft)
# You can't change a normal path back to a draft path.
data['draft'] = True
response = self.client.post('/path/edit/%s/' % draft_path.pk, data)
self.assertEqual(response.status_code, 302)
self.assertFalse(Path.objects.get(pk=draft_path.pk).draft)
def test_tiles(self, mock_tileslist, mock_tiles):
output = StringIO()
p = PathFactory.create(geom=LineString((0, 0), (0, 10)))
trek_multi = TrekFactory.create(published=True,
paths=[(p, 0, 0.1), (p, 0.2, 0.3)])
management.call_command('sync_rando',
os.path.join('var', 'tmp'),
url='http://localhost:8000',
verbosity=2,
languages='en',
stdout=output)
zfile = zipfile.ZipFile(
os.path.join('var', 'tmp', 'zip', 'tiles', 'global.zip'))
for finfo in zfile.infolist():
ifile_global = zfile.open(finfo)
if ifile_global.name.startswith('tiles/'):
self.assertEqual(ifile_global.readline(), b'I am a png')
zfile_trek = zipfile.ZipFile(
os.path.join('var', 'tmp', 'zip', 'tiles',
'{}.zip'.format(trek_multi.pk)))
for finfo in zfile_trek.infolist():
ifile_trek = zfile_trek.open(finfo)
if ifile_trek.name.startswith('tiles/'):
self.assertEqual(ifile_trek.readline(), b'I am a png')
self.assertIn("tiles/global.zip", output.getvalue())
self.assertIn("tiles/{pk}.zip".format(pk=trek_multi.pk),
output.getvalue())
def test_trek_all_reverse(self):
"""
+----<===+=======+====|----->
"""
p1 = PathFactory.create(geom=LineString((0, 0), (10, 0)))
p2 = PathFactory.create(geom=LineString((10, 0), (20, 0)))
p3 = PathFactory.create(geom=LineString((20, 0), (30, 0)))
topo = TopologyFactory.create(no_path=True)
topo.add_path(p3, start=0.2, end=0)
topo.add_path(p2, start=1, end=0)
topo.add_path(p1, start=1, end=0.9)
topo.save()
self.assertEqual(topo.geom, LineString((22.0, 0.0), (20.0, 0.0), (10.0, 0.0), (9.0, 0.0)))
def test_json_graph_simple(self):
path = PathFactory(geom=LineString((0, 0), (1, 1)))
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
graph = response.json()
self.assertDictEqual({'edges': {str(path.pk): {'id': path.pk, 'length': 1.4142135623731, 'nodes_id': [1, 2]}},
'nodes': {'1': {'2': path.pk}, '2': {'1': path.pk}}}, graph)
def test_deleted_pois(self):
p1 = PathFactory.create(geom=LineString((0, 0), (4, 4)))
trek = TrekFactory.create(paths=[p1])
poi = POIFactory.create(paths=[(p1, 0.6, 0.6)])
self.assertCountEqual(trek.pois, [poi])
poi.delete()
self.assertCountEqual(trek.pois, [])
def test_update_infrastructure(self):
self.login()
target_year = 2017
if settings.TREKKING_TOPOLOGY_ENABLED:
intervention = InfrastructureInterventionFactory.create()
else:
intervention = InfrastructureInterventionFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
infra = intervention.infrastructure
# Save infrastructure form
response = self.client.get(infra.get_update_url())
form = response.context['form']
data = form.initial
data['name'] = 'modified'
data['implantation_year'] = target_year
if settings.TREKKING_TOPOLOGY_ENABLED:
data['topology'] = '{"paths": [%s]}' % PathFactory.create().pk
else:
data['geom'] = 'SRID=4326;POINT (2.0 6.6)'
response = self.client.post(infra.get_update_url(), data)
self.assertEqual(response.status_code, 302)
# Check that intervention was not deleted (bug #783)
intervention.reload()
self.assertFalse(intervention.deleted)
self.assertEqual(intervention.infrastructure.name, 'modified')
self.assertEqual(intervention.infrastructure.implantation_year,
target_year)
def get_good_data(self):
InterventionStatusFactory.create() # in case not any in db
path = PathFactory.create()
return {
'name': 'test',
'date': '2012-08-23',
'structure': default_structure().pk,
'disorders': InterventionDisorderFactory.create().pk,
'comments': '',
'slope': 0,
'area': 0,
'subcontract_cost': 0.0,
'stake': StakeFactory.create().pk,
'height': 0.0,
'project': '',
'width': 0.0,
'length': 0.0,
'status': InterventionStatus.objects.all()[0].pk,
'heliport_cost': 0.0,
'material_cost': 0.0,
'topology': '{"paths": [%s]}' % path.pk,
'manday_set-TOTAL_FORMS': '2',
'manday_set-INITIAL_FORMS': '0',
'manday_set-MAX_NUM_FORMS': '',
'manday_set-0-nb_days': '48.75',
'manday_set-0-job': InterventionJobFactory.create().pk,
'manday_set-0-id': '',
'manday_set-0-DELETE': '',
'manday_set-1-nb_days': '12',
'manday_set-1-job': InterventionJobFactory.create().pk,
'manday_set-1-id': '',
'manday_set-1-DELETE': '',
}
def test_point_offset_kept(self):
"""
Shorten path, offset kept.
X X
+-----------+ +------+
"""
p1 = PathFactory.create(geom=LineString((0, 0), (20, 0)))
poi = Point(5, 10, srid=settings.SRID)
poi.transform(settings.API_SRID)
poitopo = Topology.deserialize({'lat': poi.y, 'lng': poi.x})
self.assertTrue(
almostequal(0.25,
poitopo.aggregations.all()[0].start_position))
self.assertTrue(almostequal(10, poitopo.offset))
p1.geom = LineString((0, 0), (10, 0))
p1.save()
poitopo.reload()
self.assertTrue(almostequal(10, poitopo.offset))
# Not moved:
self.assertTrue(almostequal(5, poitopo.geom.x))
self.assertTrue(almostequal(10, poitopo.geom.y))
def test_json_graph_headers(self):
"""
Last modified depends on
"""
PathFactory(geom=LineString((0, 0), (1, 1)))
response = self.client.get(self.url)
self.assertNotEqual(response['Cache-Control'], None)
def test_helpers(self):
p = PathFactory.create()
infra = InfrastructureFactory.create(no_path=True)
infra.add_path(path=p)
self.assertCountEqual(p.infrastructures, [infra])
