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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_split_cross_on_deleted(self): """ Paths should not be splitted if they cross deleted paths. (attribute delete=True) """ ab = PathFactory.create(name="AB", geom=LineString((0, 0, 0), (4, 0, 0))) self.assertEqual(len(Path.objects.all()), 1) ab.delete() self.assertEqual(len(Path.objects.all()), 0) cd = PathFactory.create(name="CD", geom=LineString((2, -2, 0), (2, 2, 0))) self.assertEqual(len(Path.objects.all()), 1)
def test_recompute_pk_reverse_AB_CD(self): """ A---------------B + C-------------------D B----------------AD----------------C | | |--| | => | | | |--| E1 (0.2) | E3 (0.2, 0.3) | | E1 (0.4) | E3 (0.8, 0.9) E2 (0.6) E4 (0.8) E2 (0.2) E4 (0.6) In case of AB == CD, matching A and D """ path_AB = PathFactory.create(name="PATH_AB", geom=LineString((10, 1), (0, 1))) path_CD = PathFactory.create(name="PATH_CD", geom=LineString((20, 1), (10, 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))) # 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, (1 - a1.start_position) * (path_AB_original_length / path_AB.length)) self.assertEqual(a1_updated.end_position, (1 - a1.end_position) * (path_AB_original_length / path_AB.length)) self.assertEqual(a2_updated.start_position, (1 - a2.start_position) * (path_AB_original_length / path_AB.length)) self.assertEqual(a2_updated.end_position, (1 - 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, (1 - a3.start_position) * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length) self.assertEqual(a3_updated.end_position, (1 - a3.end_position) * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length) self.assertEqual(a4_updated.start_position, (1 - a4.start_position) * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length) self.assertEqual(a4_updated.end_position, (1 - a4.end_position) * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length) # test offset changes e1_updated = Topology.objects.get(pk=e1.pk) self.assertEqual(e1_updated.offset, -e1.offset) e4_updated = Topology.objects.get(pk=e4.pk) self.assertEqual(e4_updated.offset, -e4.offset)
def test_path_merge_without_snap(self): """ A B C D A D |---------| + |---------| --> |------------------| Test five cases : 1 - A match with C : unification D-C-A-B 2 - A match with D : unification C-D-A-B 3 - B match with C : unification A-B-C-D 4 - B match with D : unification A-B-D-C 5 - no match : no unification """ path_AB = PathFactory.create(name="PATH_AB", geom=LineString((0, 0), (4, 0))) path_CD = PathFactory.create(name="PATH_CD", geom=LineString((4, 0), (8, 0))) original_AB_length = path_AB.length original_CD_length = path_CD.length self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual(path_AB.geom, LineString((0, 0), (4, 0), (8, 0))) self.assertEqual(path_AB.length, original_AB_length + original_CD_length) path_AB = PathFactory.create(name="path_AB", geom=LineString((4, 0), (0, 0))) path_CD = PathFactory.create(name="path_CD", geom=LineString((4, 0), (8, 0))) original_AB_length = path_AB.length original_CD_length = path_CD.length self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual(path_AB.geom, LineString((0, 0), (4, 0), (8, 0))) self.assertEqual(path_AB.length, original_AB_length + original_CD_length) path_AB = PathFactory.create(name="path_AB", geom=LineString((4, 0), (0, 0))) path_CD = PathFactory.create(name="path_CD", geom=LineString((8, 0), (4, 0))) original_AB_length = path_AB.length original_CD_length = path_CD.length self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual(path_AB.geom, LineString((0, 0), (4, 0), (8, 0))) self.assertEqual(path_AB.length, original_AB_length + original_CD_length) path_AB = PathFactory.create(name="path_AB", geom=LineString((0, 0), (4, 0))) path_CD = PathFactory.create(name="path_CD", geom=LineString((8, 0), (4, 0))) original_AB_length = path_AB.length original_CD_length = path_CD.length self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual(path_AB.geom, LineString((0, 0), (4, 0), (8, 0))) self.assertEqual(path_AB.length, original_AB_length + original_CD_length) path_AB = PathFactory.create(name="PATH_AB", geom=LineString((0, 0), (4, 0))) path_CD = PathFactory.create(name="PATH_CD", geom=LineString((50, 0), (100, 0))) original_AB_length = path_AB.length self.assertEqual(path_AB.merge_path(path_CD), False) self.assertEqual(path_AB.length, original_AB_length)
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), Point(11, 10))) 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), Point(1, 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, [ u'id', u'name', u'period', u'type', u'domain', u'constraint', u'global_cos', u'interventi', u'interven_1', u'comments', u'contractor', u'project_ow', u'project_ma', u'founders', u'related_st', u'insertion_', u'update_dat', u'cities', u'districts', u'restricted' ]) 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.assertEquals(len(feature.geom.geos), 1) self.assertAlmostEqual(feature.geom.geos[0].x, it_point.geom.x) self.assertAlmostEqual(feature.geom.geos[0].y, it_point.geom.y) 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_snapping_choose_closest_point(self): # Line with several points in less than PATH_SNAPPING_DISTANCE 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))) self.assertEqual(path_snapped.geom.coords, ((10, 0), (10, 10)))
def test_path_merge_with_snap(self): """ A B C D A D |---------| + |---------| --> |------------------| Test five cases : 1 - A match with C : unification D-C-A-B 2 - A match with D : unification C-D-A-B 3 - B match with C : unification A-B-C-D 4 - B match with D : unification A-B-D-C 5 - no match : no unification """ path_AB = PathFactory.create(name="PATH_AB", geom=LineString((0, 0), (15, 0))) path_CD = PathFactory.create(name="PATH_CD", geom=LineString((16, 0), (30, 0))) self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual( path_AB.geom, LineString((0, 0), (15, 0), (16, 0), (30, 0), srid=settings.SRID)) path_AB.delete() path_CD.delete() path_AB = PathFactory.create(name="path_AB", geom=LineString((15, 0), (0, 0))) path_CD = PathFactory.create(name="path_CD", geom=LineString((16, 0), (30, 0))) self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual( path_AB.geom, LineString((0, 0), (15, 0), (16, 0), (30, 0), srid=settings.SRID)) path_AB.delete() path_CD.delete() path_AB = PathFactory.create(name="path_AB", geom=LineString((15, 0), (0, 0))) path_CD = PathFactory.create(name="path_CD", geom=LineString((30, 0), (16, 0))) self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual( path_AB.geom, LineString((0, 0), (15, 0), (16, 0), (30, 0), srid=settings.SRID)) path_AB.delete() path_CD.delete() path_AB = PathFactory.create(name="path_AB", geom=LineString((0, 0), (15, 0))) path_CD = PathFactory.create(name="path_CD", geom=LineString((30, 0), (16, 0))) self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual( path_AB.geom, LineString((0, 0), (15, 0), (16, 0), (30, 0), srid=settings.SRID)) path_AB.delete() path_CD.delete() path_AB = PathFactory.create(name="PATH_AB", geom=LineString((0, 0), (5, 0))) path_CD = PathFactory.create(name="PATH_CD", geom=LineString((50, 0), (100, 0))) self.assertEqual(path_AB.merge_path(path_CD), False)
def test_recompute_pk_reverse_AB_CD(self): """ A---------------B + C-------------------D B----------------AD----------------C | | |--| | => | | | |--| E1 (0.2) | E3 (0.2, 0.3) | | E1 (0.4) | E3 (0.8, 0.9) E2 (0.6) E4 (0.8) E2 (0.2) E4 (0.6) In case of AB == CD, matching A and D """ path_AB = PathFactory.create(name="PATH_AB", geom=LineString((10, 1), (0, 1))) path_CD = PathFactory.create(name="PATH_CD", geom=LineString((20, 1), (10, 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, (1 - a1.start_position) * (path_AB_original_length / path_AB.length)) self.assertEqual(a1_updated.end_position, (1 - a1.end_position) * (path_AB_original_length / path_AB.length)) self.assertEqual(a2_updated.start_position, (1 - a2.start_position) * (path_AB_original_length / path_AB.length)) self.assertEqual(a2_updated.end_position, (1 - 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, (1 - a3.start_position) * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length) self.assertEqual(a3_updated.end_position, (1 - a3.end_position) * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length) self.assertEqual(a4_updated.start_position, (1 - a4.start_position) * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length) self.assertEqual(a4_updated.end_position, (1 - a4.end_position) * (path_CD_original_length / path_AB.length) + path_AB_original_length / path_AB.length) # test offset changes e1_updated = Topology.objects.get(pk=e1.pk) self.assertEqual(e1_updated.offset, -e1.offset) e4_updated = Topology.objects.get(pk=e4.pk) self.assertEqual(e4_updated.offset, -e4.offset)
def test_extent(self): p1 = PathFactory.create() self.assertEqual(p1.extent, (3.0, 46.499999999999936, 3.0013039767202154, 46.50090044234927))
def test_valid_geometry_can_be_saved(self): PathFactory.create(geom=LineString((0, 0), (2, 0), (1, 1)))
def test_snapping_3d_extremities(self): PathFactory.create(geom=LineString(((0, 0, 0), (10, 0, 1000)))) path_snapped = PathFactory.create( geom=LineString((8, 0, 0), (-50, -50, 0))) self.assertEqual(path_snapped.geom.coords, ((8, 0, 0), (-50, -50, 0)))
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 line = PathFactory.create(geom=LineString(Point(10, 10), Point(11, 10))) topo_line = TopologyFactory.create(paths=[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), Point(1, 0), srid=settings.SRID)) topo_point = Topology._topologypoint(lng, lat, None) topo_point.save() self.assertEqual(topo_point.paths.get(), closest_path) # Create one intervention by geometry (point/linestring) it_point = InterventionFactory.create(target=topo_point) it_line = InterventionFactory.create(target=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() shapefiles = pfl.path_directory devnull = open(os.devnull, "wb") pfl.serialize(Project.objects.all(), stream=devnull, delete=False, fields=ProjectFormatList.columns) shapefiles = [shapefile for shapefile in os.listdir(shapefiles) if shapefile[-3:] == "shp"] datasources = [gdal.DataSource(os.path.join(pfl.path_directory, s)) for s in shapefiles] layers = [ds[0] for ds in datasources] self.assertEqual(len(datasources), 2) geom_type_layer = {layer.name: layer for layer in layers} geom_types = geom_type_layer.keys() self.assertIn('MultiPoint', geom_types) self.assertIn('MultiLineString', geom_types) for layer in layers: self.assertEqual(layer.srs.name, 'RGF93_Lambert_93') self.assertCountEqual(layer.fields, [ 'id', 'name', 'period', 'type', 'domain', 'constraint', 'global_cos', 'interventi', 'comments', 'contractor', 'project_ow', 'project_ma', 'founders', 'related_st', 'insertion_', 'update_dat', 'cities', 'districts', 'restricted' ]) self.assertEqual(len(layers[0]), 1) self.assertEqual(len(layers[1]), 1) for feature in geom_type_layer['MultiPoint']: self.assertEqual(str(feature['id']), str(proj.pk)) self.assertEqual(len(feature.geom.geos), 1) self.assertAlmostEqual(feature.geom.geos[0].x, it_point.geom.x) self.assertAlmostEqual(feature.geom.geos[0].y, it_point.geom.y) for feature in geom_type_layer['MultiLineString']: self.assertEqual(str(feature['id']), str(proj.pk)) self.assertTrue(feature.geom.geos.equals(it_line.geom))
def test_no_trail_csv(self): p1 = PathFactory.create() self.assertEqual(p1.trails_csv_display, 'None')
def test_trail_csv(self): p1 = PathFactory.create() t1 = TrailFactory.create(paths=[p1]) self.assertEqual(p1.trails_csv_display, t1.name)
def test_trails_verbose_name(self): path = PathFactory.create() self.assertEqual(path.trails_verbose_name, 'Trails')
def create_path(): PathFactory.create( geom=LineString((0, 0), (2, 0), (1, 1), (1, -1)))
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))) 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.assertContains(response, 'Do you really wish to delete')
def test_path_merge_without_snap(self): """ A B C D A D |---------| + |---------| --> |------------------| Test five cases : 1 - A match with C : unification D-C-A-B 2 - A match with D : unification C-D-A-B 3 - B match with C : unification A-B-C-D 4 - B match with D : unification A-B-D-C 5 - no match : no unification """ path_AB = PathFactory.create(name="PATH_AB", geom=LineString((0, 0), (4, 0))) path_CD = PathFactory.create(name="PATH_CD", geom=LineString((4, 0), (8, 0))) original_AB_length = path_AB.length original_CD_length = path_CD.length self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual(path_AB.geom, LineString((0.0, 0.0), (4.0, 0.0), (8.0, 0.0), srid=settings.SRID)) self.assertEqual(path_AB.length, original_AB_length + original_CD_length) path_AB.delete() path_CD.delete() path_AB = PathFactory.create(name="path_AB", geom=LineString((4, 0), (0, 0))) path_CD = PathFactory.create(name="path_CD", geom=LineString((4, 0), (8, 0))) original_AB_length = path_AB.length original_CD_length = path_CD.length self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual(path_AB.geom, LineString((0, 0), (4, 0), (8, 0), srid=settings.SRID)) self.assertEqual(path_AB.length, original_AB_length + original_CD_length) path_AB.delete() path_CD.delete() path_AB = PathFactory.create(name="path_AB", geom=LineString((4, 0), (0, 0))) path_CD = PathFactory.create(name="path_CD", geom=LineString((8, 0), (4, 0))) original_AB_length = path_AB.length original_CD_length = path_CD.length self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual(path_AB.geom, LineString((0, 0), (4, 0), (8, 0), srid=settings.SRID)) self.assertEqual(path_AB.length, original_AB_length + original_CD_length) path_AB.delete() path_CD.delete() path_AB = PathFactory.create(name="path_AB", geom=LineString((0, 0), (4, 0))) path_CD = PathFactory.create(name="path_CD", geom=LineString((8, 0), (4, 0))) original_AB_length = path_AB.length original_CD_length = path_CD.length self.assertEqual(path_AB.merge_path(path_CD), True) self.assertEqual(path_AB.geom, LineString((0, 0), (4, 0), (8, 0), srid=settings.SRID)) self.assertEqual(path_AB.length, original_AB_length + original_CD_length) path_AB = PathFactory.create(name="PATH_AB", geom=LineString((0, 0), (4, 0))) path_CD = PathFactory.create(name="PATH_CD", geom=LineString((50, 0), (100, 0))) original_AB_length = path_AB.length self.assertEqual(path_AB.merge_path(path_CD), False) self.assertEqual(path_AB.length, original_AB_length)
def test_interpolate_reproj(self): p = PathFactory.create() self.assertEqual(p.interpolate(Point(3, 46.5, srid=4326)), (0, 0))
def test_modify_self_intersection_raises_integrity_error(self): p = PathFactory.create(geom=LineString((0, 0), (2, 0), (1, 1))) p.geom = LineString((0, 0), (2, 0), (1, 1), (1, -1)) self.assertRaises(IntegrityError, p.save)
def test_geom(self): t = TrailFactory.create() self.assertTrue(t.geom is None) p = PathFactory.create() t.paths.add(p) self.assertFalse(t.geom is None)
def test_snap_reproj(self): p = PathFactory.create() snap = p.snap(Point(3, 46.5, srid=4326)) self.assertEqual(snap.x, 700000) self.assertEqual(snap.y, 6600000)
def test_snapping_3d(self): PathFactory.create(geom=LineString(((0, 0, 0), (5, 0, 1000), (6, 0, 0)))) path_snapped = PathFactory.create( geom=LineString((0, 0, 0), (5.2, 0, 0))) self.assertEqual(path_snapped.geom.coords, ((0, 0, 0), (5, 0, 1000)))
def get_good_data(self): path = PathFactory.create() return { 'physical_type': PhysicalTypeFactory.create().pk, 'topology': '{"paths": [%s]}' % path.pk, }
def test_trail_csv(self): p1 = PathFactory.create() t1 = TrailFactory.create(no_path=True) t1.add_path(p1) self.assertEqual(p1.trails_csv_display, t1.name)
def get_good_data(self): path = PathFactory.create() return { 'land_type': LandTypeFactory.create().pk, 'topology': '{"paths": [%s]}' % path.pk, }
def setUp(self): self.cmd = Command() self.filename = os.path.join(os.path.dirname(__file__), 'data', 'poi.shp') self.path = PathFactory.create()
def get_good_data(self): path = PathFactory.create() return { 'name_fr': 'Hoho', 'name_it': '', 'name_en': '', 'departure_fr': '', 'departure_it': '', 'departure_en': '', 'arrival_fr': '', 'arrival_en': '', 'arrival_it': '', 'published': '', 'difficulty': '', 'route': '', 'description_teaser_fr': '', 'description_teaser_it': '', 'description_teaser_en': '', 'description_fr': '', 'description_it': '', 'description_en': '', 'ambiance_fr': '', 'ambiance_it': '', 'ambiance_en': '', 'access_fr': '', 'access_it': '', 'access_en': '', 'disabled_infrastructure_fr': '', 'disabled_infrastructure_it': '', 'disabled_infrastructure_en': '', 'duration': '0', 'is_park_centered': '', 'advised_parking': 'Very close', 'parking_location': 'POINT (1.0 1.0)', 'public_transport': 'huhu', 'advice_fr': '', 'advice_it': '', 'advice_en': '', 'themes': ThemeFactory.create().pk, 'networks': TrekNetworkFactory.create().pk, 'usages': UsageFactory.create().pk, 'web_links': WebLinkFactory.create().pk, 'information_desk': InformationDeskFactory.create().pk, 'topology': '{"paths": [%s]}' % path.pk, 'trek_relationship_a-TOTAL_FORMS': '2', 'trek_relationship_a-INITIAL_FORMS': '0', 'trek_relationship_a-MAX_NUM_FORMS': '', 'trek_relationship_a-0-id': '', 'trek_relationship_a-0-trek_b': TrekFactory.create().pk, 'trek_relationship_a-0-has_common_edge': 'on', 'trek_relationship_a-0-has_common_departure': 'on', 'trek_relationship_a-0-is_circuit_step': '', 'trek_relationship_a-1-id': '', 'trek_relationship_a-1-trek_b': TrekFactory.create().pk, 'trek_relationship_a-1-has_common_edge': '', 'trek_relationship_a-1-has_common_departure': '', 'trek_relationship_a-1-is_circuit_step': 'on', }
def setUp(self): self.path = PathFactory.create()
def get_good_data(self): path = PathFactory.create() return { 'organization': OrganismFactory.create().pk, 'topology': '{"paths": [%s]}' % path.pk, }
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))) POIFactory.create(paths=[(path_1, 0, 0)]) response = self.client.get(reverse('core:path_list')) self.assertContains(response, '<a href="#delete" id="btn-delete" role="button">')
def test_length(self): p1 = PathFactory.build() self.assertEqual(p1.length, 0) p2 = PathFactory.create() self.assertNotEqual(p2.length, 0)