def test_sum_path_two(self):
self.login()
PathFactory()
PathFactory()
response = self.client.get('/api/path/paths.json')
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content)['sumPath'], 0.3)
def test_city_with_path_ends_on_border(self):
"""
| |
|p1 |p2
| |
+--------+----+---+
| |
| | City
| |
+-----------------+
"""
# Create a path before city to test one trigger
p1 = PathFactory(geom=LineString((1, 1), (1, 2)))
p1.save()
c = City(code='005178',
name='Trifouillis-les-marmottes',
geom=MultiPolygon(
Polygon(((0, 0), (2, 0), (2, 1), (0, 1), (0, 0)),
srid=settings.SRID)))
c.save()
# Create a path after city to the the another trigger
p2 = PathFactory(geom=LineString((1.5, 2), (1.5, 1)))
p2.save()
self.assertEqual(len(p1.cities), 1)
self.assertEqual(len(p2.cities), 1)
def test_permission_view_delete_path_with_2_permissions(self):
"""
Check user can delete a normal path and draft path if user has :
delete_draft_path permission and delete_path
"""
self.client.login(username=self.user.username, password='******')
path = PathFactory(name="PATH_AB", geom=LineString((0, 0), (4, 0)))
draft_path = PathFactory(name="PATH_BC",
geom=LineString((0, 2), (4, 2)),
draft=True)
response = self.client.post('/path/delete/%s/' % path.pk)
self.assertEqual(response.status_code, 302)
response = self.client.post('/path/delete/%s/' % draft_path.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(Path.objects.count(), 2)
self.user.user_permissions.add(
Permission.objects.get(codename='delete_path'))
self.user.user_permissions.add(
Permission.objects.get(codename='delete_draft_path'))
self.client.login(username=self.user.username, password='******')
response = self.client.post('/path/delete/%s/' % path.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(Path.objects.count(), 1)
response = self.client.post('/path/delete/%s/' % draft_path.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(Path.objects.count(), 0)
def test_permission_view_change_path_with_draft_permission(self):
"""
Check user can edit a draft path if user has change_draft_path permission only
but can not edit normal path
Check draft checkbox not visible if user have only change_draft_path
"""
self.client.login(username=self.user.username, password='******')
path = PathFactory(name="PATH_AB", geom=LineString((0, 0), (4, 0)))
draft_path = PathFactory(name="PATH_AB",
geom=LineString((0, 0), (4, 0)),
draft=True)
response = self.client.get('/path/edit/%s/' % path.pk)
self.assertEqual(response.status_code, 302)
response = self.client.get('/path/edit/%s/' % draft_path.pk)
self.assertEqual(response.status_code, 302)
self.user.user_permissions.add(
Permission.objects.get(codename='change_draft_path'))
self.client.login(username=self.user.username, password='******')
response = self.client.post('/path/edit/%s/' % path.pk)
self.assertEqual(response.status_code, 302)
response = self.client.get('/path/edit/%s/' % draft_path.pk)
self.assertEqual(response.status_code, 200)
self.assertNotContains(response, 'name="draft"')
def test_paths_bystructure(self):
PathFactory(length=1)
PathFactory(length=70)
password = '******'
user = PathManagerFactory(password=password)
result = self.client.login(username=user.username, password=password)
self.assertTrue(result, u"The client successfully logged in")
response = self.client.get(reverse('core:path_list'))
self.assertEquals(response.status_code, 200)
def create_form_params(range_start='', range_end=''):
"""Return range form parameter as used in geotrek.core.filters.PathFilter"""
return { 'length_0': range_end, 'length_1': range_start }
def test_response_content(length_range, queryset):
response = self.client.get(reverse('core:path_json_list'), data=create_form_params(*length_range))
self.assertEquals(response.status_code, 200)
# We check the 'map_obj_pk' json attribute that should contain the paths' pk (used by map)
jsondict = json.loads(response.content)
# The JSON should only contain filtered paths
self.assertListEqual(
sorted(jsondict['map_obj_pk']),
sorted(list(queryset.values_list('pk', flat=True))),
)
# Simulate ajax call to populate the list
# The path returned as json should be all paths
test_response_content(['', ''], Path.objects.all())
# Simulate ajax call to populate the list, but this time with a range filter
length_range = [50, 100]
test_response_content(length_range, Path.objects.filter(length__range=length_range))
def test_permission_view_change_path_with_2_permissions(self):
"""
Check draft checkbox visible if user have 2 permissions : change_path, change_draft_path
"""
self.client.login(username=self.user.username, password='******')
path = PathFactory(name="PATH_AB", geom=LineString((0, 0), (4, 0)))
draft_path = PathFactory(name="draft_path",
geom=LineString((0, 0), (4, 0)),
draft=True)
response = self.client.get('/path/edit/%s/' % path.pk)
self.assertEqual(response.status_code, 302)
response = self.client.get('/path/edit/%s/' % draft_path.pk)
self.assertEqual(response.status_code, 302)
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='******')
response = self.client.get('/path/edit/%s/' % path.pk)
self.assertEqual(response.status_code, 200)
self.assertNotIn('name="draft"', response.content)
response = self.client.get('/path/edit/%s/' % draft_path.pk)
self.assertEqual(response.status_code, 200)
self.assertIn('name="draft"', response.content)
def test_paths_bystructure(self):
user = UserFactory()
p1 = PathFactory()
p2 = PathFactory(structure=Structure.objects.create(name="other"))
self.assertEqual(user.profile.structure, p1.structure)
self.assertNotEqual(user.profile.structure, p2.structure)
self.assertEqual(len(Structure.objects.all()), 2)
self.assertEqual(len(Path.objects.all()), 2)
self.assertTrue(p1 in Path.objects.filter(
structure=user.profile.structure))
self.assertFalse(p2 in Path.objects.filter(
structure=user.profile.structure))
# Change user structure on-the-fly
profile = user.profile
profile.structure = p2.structure
profile.save()
self.assertEqual(user.profile.structure.name, "other")
self.assertFalse(p1 in Path.objects.filter(
structure=user.profile.structure))
self.assertTrue(p2 in Path.objects.filter(
structure=user.profile.structure))
def test_python_graph_from_path(self):
p_1_1 = (1., 1.)
p_2_2 = (2., 2.)
p_3_3 = (3., 3.)
p_4_4 = (4., 4.)
p_5_5 = (5., 5.)
def gen_random_point():
"""Return unique (non-conflicting) point"""
return ((0., x + 1.) for x in xrange(10, 100))
r_point = gen_random_point().next
e_1_2 = PathFactory(geom=LineString(p_1_1, r_point(), p_2_2))
e_2_3 = PathFactory(geom=LineString(p_2_2, r_point(), p_3_3))
# Non connex
e_4_5 = PathFactory(geom=LineString(p_4_4, r_point(), p_5_5))
graph = {
'nodes': {
1: {
2: e_1_2.pk
},
2: {
1: e_1_2.pk,
3: e_2_3.pk
},
3: {
2: e_2_3.pk
},
4: {
5: e_4_5.pk
},
5: {
4: e_4_5.pk
}
},
'edges': {
e_1_2.pk: {
'nodes_id': [1, 2],
'length': e_1_2.length,
'id': e_1_2.pk
},
e_2_3.pk: {
'nodes_id': [2, 3],
'length': e_2_3.length,
'id': e_2_3.pk
},
e_4_5.pk: {
'nodes_id': [4, 5],
'length': e_4_5.length,
'id': e_4_5.pk
}
}
}
computed_graph = graph_edges_nodes_of_qs(Path.objects.all())
self.assertDictEqual(computed_graph, graph)
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])
InterventionFactory.create(target=topo_1)
cls.seek_inter = InterventionFactory.create(target=seek_topo)
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_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_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_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_city_with_topo(self):
"""
+-----------------+
| S |
| +---x---+ |
| | | | City
| |p | |
| O O |
| |
+-----------------+
"""
c = City(code='005178',
name='Trifouillis-les-marmottes',
geom=MultiPolygon(
Polygon(((0, 0), (2, 0), (2, 2), (0, 2), (0, 0)),
srid=settings.SRID)))
c.save()
if settings.TREKKING_TOPOLOGY_ENABLED:
p = PathFactory(
geom=LineString((0.5, 0.5), (0.5, 1.5), (1.5, 1.5), (1.5,
0.5)))
p.save()
signage = SignageFactory.create(paths=[(p, 0.5, 0.5)])
else:
signage = SignageFactory.create(
geom=Point(1, 1.5, srid=settings.SRID))
self.assertEqual(len(signage.cities), 1)
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_couches_sig_link(self):
"""
+-----------------+ -
| |ra2 |
| +-------+ | |
| _ _| _ _ _|_ _ | - C
| |p | | |
| O O | |
| |ra1 |
+-----------------+ -
"""
# Fake restricted areas
RestrictedAreaFactory.create(
geom=MultiPolygon(Polygon(((0, 0), (2, 0), (2, 1), (0, 1), (0,
0)))))
RestrictedAreaFactory.create(
geom=MultiPolygon(Polygon(((0, 1), (2, 1), (2, 2), (0, 2), (0,
1)))))
# Fake city
c = City(code='005178',
name='Trifouillis-les-marmottes',
geom=MultiPolygon(
Polygon(((0, 0), (2, 0), (2, 2), (0, 2), (0, 0)),
srid=settings.SRID)))
c.save()
# Fake paths in these areas
p = PathFactory(
geom=LineString((0.5, 0.5), (0.5, 1.5), (1.5, 1.5), (1.5, 0.5)))
p.save()
self.assertEqual(len(p.areas), 2)
self.assertEqual(len(p.cities), 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_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_trail_filters(self):
PathFactory()
qs = PathFilterSet().qs
self.assertEqual(qs.count(), 2)
data = {'trail': [self.trail]}
qs = PathFilterSet(data=data).qs
self.assertEqual(qs.count(), 1)
def test_sum_path_filter_cities(self):
self.login()
p1 = PathFactory(geom=LineString((0, 0), (0, 1000), srid=settings.SRID))
city = CityFactory(code='09000', geom=MultiPolygon(Polygon(((200, 0), (300, 0), (300, 100), (200, 100), (200, 0)), srid=settings.SRID)))
self.assertEquals(p1.aggregations.count(), 0)
response = self.client.get('/api/path/paths.json?city=%s' % city.code)
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content)['sumPath'], 0.0)
def test_json_graph_headers(self):
"""
Last modified depends on
"""
PathFactory(geom=LineString((0, 0), (1, 1)))
response = self.client.get(self.url)
last_modified = response['Last-Modified']
expires = response['Expires']
self.assertNotEqual(expires, None)
self.assertEqual(expires, last_modified)
def test_save_path_with_only_edit_path(self):
"""
Check save path without permission change_draft_path save with draft=False
"""
path = PathFactory(name="path", geom=LineString((0, 2), (4, 2)))
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.client.login(username=self.user.username, password='******')
data = self.get_good_data()
response = self.client.post('/path/edit/%s/' % path.pk, data)
self.assertEqual(response.status_code, 302)
self.assertFalse(Path.objects.first().draft)
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)
def test_python_graph_from_path(self):
p_1_1 = (1., 1., 0.)
p_2_2 = (2., 2., 0.)
p_3_3 = (3., 3., 0.)
p_4_4 = (4., 4., 0.)
p_5_5 = (5., 5., 0.)
def gen_random_point():
"""Return unique (non-conflicting) point"""
return ((0., x + 1., 0.) for x in xrange(10, 100))
r_point = gen_random_point().next
e_1_2 = PathFactory(geom=LineString(p_1_1, r_point(), p_2_2))
e_2_3 = PathFactory(geom=LineString(p_2_2, r_point(), p_3_3))
# Non connex
e_4_5 = PathFactory(geom=LineString(p_4_4, r_point(), p_5_5))
# Add an edge with the p_1_1 in its center
# e_5_1_6 = PathFactory(geom=LineString(p_5_5, r_point(), p_1_1, r_point(), p_6_6))
graph = {
p_1_1: {
p_2_2: e_1_2,
},
p_2_2: {
p_1_1: e_1_2,
p_3_3: e_2_3,
},
p_3_3: {
p_2_2: e_2_3,
},
# Non connex
p_4_4: {p_5_5: e_4_5},
p_5_5: {p_4_4: e_4_5},
}
computed_graph = graph_of_qs(Path.objects.all())
self.assertDictEqual(computed_graph, graph)
def test_sum_path_filter_districts(self):
self.login()
p1 = PathFactory(geom=LineString((0, 0), (0, 1000), srid=settings.SRID))
district = DistrictFactory(geom=MultiPolygon(Polygon(((200, 0), (300, 0), (300, 100), (200, 100), (200, 0)), srid=settings.SRID)))
district2 = DistrictFactory(geom=MultiPolygon(
Polygon(((0, 0), (1000, 0), (1000, 1000), (0, 1000), (0, 0)), srid=settings.SRID)))
self.assertEqual(p1.aggregations.count(), 1)
response = self.client.get('/api/path/paths.json?district=%s' % district.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['sumPath'], 0.0)
response = self.client.get('/api/path/paths.json?district=%s' % district2.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['sumPath'], 1.0)
def test_sum_path_filter_cities(self):
self.login()
p1 = PathFactory(geom=LineString((0, 0), (0, 1000), srid=settings.SRID))
city = CityFactory(code='09000', geom=MultiPolygon(Polygon(((200, 0), (300, 0), (300, 100), (200, 100), (200, 0)), srid=settings.SRID)))
city2 = CityFactory(code='09001', geom=MultiPolygon(
Polygon(((0, 0), (1000, 0), (1000, 1000), (0, 1000), (0, 0)), srid=settings.SRID)))
self.assertEqual(len(p1.cities), 1)
response = self.client.get('/api/path/paths.json?city=%s' % city.code)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['sumPath'], 0.0)
response = self.client.get('/api/path/paths.json?city=%s' % city2.code)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()['sumPath'], 1.0)
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_list_attachments_in_details(self):
"""Test that the list is correctly displayed on the detail page of path"""
path = PathFactory(length=1)
AttachmentFactory(obj=path, creator=self.user)
response = self.client.get(path.get_detail_url())
self.assertTemplateUsed(response,
template_name='paperclip/details.html')
self.assertItemsEqual(
Attachment.objects.attachments_for_object(path),
response.context['attachments_list'],
)
def test_structure_restricted(self):
p = PathFactory()
# Login
user = PathManagerFactory(password="******")
success = self.client.login(username=user.username, password="******")
self.assertTrue(success)
# Try to edit path from same structure
response = self.client.get(p.get_update_url())
self.assertEqual(response.status_code, 200)
# Try to edit path from other structure
p.structure = StructureFactory(name="Other")
p.save()
self.assertNotEqual(p.structure, user.profile.structure)
response = self.client.get(p.get_update_url())
self.assertEqual(response.status_code, 302)
def test_city_with_topo_3(self):
"""
+-------+
_ _ | _ _ _ | _ _
| |p | |
| O X S | City
| |
+-----------------+
"""
c = City(code='005178', name='Trifouillis-les-marmottes',
geom=MultiPolygon(Polygon(((0, 0), (2, 0), (2, 1), (0, 1), (0, 0)),
srid=settings.SRID)))
c.save()
p = PathFactory(geom=LineString((0.5, 0.5), (0.5, 1.5), (1.5, 1.5), (1.5, 0.5)))
p.save()
signage = SignageFactory.create(paths=[(p, 1, 1)])
self.assertEqual(signage.city_edges.count(), 1)
def test_draft_permission_detail(self):
path = PathFactory(name="DRAFT_PATH", draft=True)
user = UserFactory(password='******')
p = user.profile
p.save()
perm_add_draft_path = Permission.objects.get(codename='add_draft_path')
perm_delete_draft_path = Permission.objects.get(codename='delete_draft_path')
perm_change_draft_path = Permission.objects.get(codename='change_draft_path')
perm_read_path = Permission.objects.get(codename='read_path')
user.user_permissions.add(perm_delete_draft_path)
user.user_permissions.add(perm_read_path)
user.user_permissions.add(perm_change_draft_path)
user.user_permissions.add(perm_add_draft_path)
self.client.login(username=user.username, password='******')
response = self.client.get(path.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, path.get_delete_url())
