def test_update_form_on_signage(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
signa = SignageFactory.create()
else:
signa = SignageFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
signage = "%s" % signa
intervention = InterventionFactory.create()
self.assertIsNone(intervention.signage)
intervention.set_topology(signa)
intervention.save()
self.assertIsNotNone(intervention.signage)
response = self.client.get(intervention.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
# Should be able to save form successfully
form = response.context['form']
data = form.initial
data['disorders'] = data['disorders'][0].pk
data['project'] = ''
data['signage'] = form.fields[
'signage'].initial.pk # because it is set after form init, not form.initial :(
data.update(
**{
'manday_set-TOTAL_FORMS': '0',
'manday_set-INITIAL_FORMS': '0',
'manday_set-MAX_NUM_FORMS': '',
})
# Form URL is modified in form init
formurl = intervention.get_update_url() + '?signage=%s' % signa.pk
response = self.client.post(formurl, data)
self.assertEqual(response.status_code, 302)
def test_creation_form_on_signage_with_errors(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
signa = SignageFactory.create()
else:
signa = SignageFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
signage = "%s" % signa
response = self.client.get(
'%s?target_id=%s&target_type=%s' %
(Intervention.get_add_url(), signa.pk,
ContentType.objects.get_for_model(Signage).pk))
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
data = self.get_good_data()
# If form invalid, it should not fail
data.pop('status')
response = self.client.post(
'%s?target_id=%s&target_type=%s' %
(Intervention.get_add_url(), signa.pk,
ContentType.objects.get_for_model(Signage).pk), data)
self.assertEqual(response.status_code, 200)
self.assertFalse(Intervention.objects.exists())
def get_good_data(self):
good_data = {
'number': '2',
'type': BladeTypeFactory.create().pk,
'condition': InfrastructureConditionFactory.create().pk,
'direction': BladeDirectionFactory.create().pk,
'color': BladeColorFactory.create().pk,
'lines-TOTAL_FORMS': '2',
'lines-INITIAL_FORMS': '0',
'lines-MAX_NUM_FORMS': '1000',
'lines-MIN_NUM_FORMS': '',
'lines-0-number': "2",
'lines-0-text': 'Text 0',
'lines-0-distance': "10",
'lines-0-pictogram_name': 'toto',
'lines-0-time': '00:01:00',
'lines-0-id': '',
'lines-0-DELETE': '',
'lines-1-number': "3",
'lines-1-text': 'Text 1',
'lines-1-distance': "0.2",
'lines-1-pictogram_name': 'coucou',
'lines-1-time': '00:00:10',
'lines-1-id': '',
'lines-1-DELETE': '',
}
if settings.TREKKING_TOPOLOGY_ENABLED:
signage = SignageFactory.create()
good_data['topology'] = '{"lat": 5.1, "lng": 6.6}'
good_data['signage'] = signage.pk
else:
signage = SignageFactory.create(geom='SRID=2154;POINT(5.1 6.6)')
good_data['signage'] = signage.pk
good_data['topology'] = signage.geom.ewkt
return good_data
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_none_implantation_year_filter(self):
self.login()
model = self.factory._meta.model
SignageFactory.create()
response = self.client.get(model.get_list_url())
self.assertNotContains(response, 'option value="" selected>None</option')
def test_creation_form_on_signage(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
signa = SignageFactory.create()
else:
signa = SignageFactory.create(geom='SRID=2154;POINT (700000 6600000)')
signage = "%s" % signa
response = self.client.get('%s?target_id=%s&target_type=%s' % (Intervention.get_add_url(),
signa.pk,
ContentType.objects.get_for_model(Signage).pk
))
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
form = response.context['form']
self.assertEqual(form.initial['target_id'], str(signa.pk))
# Should be able to save form successfully
data = self.get_good_data()
data['target_id'] = signa.pk
response = self.client.post('%s?target_id=%s&target_type=%s' % (Intervention.get_add_url(),
signa.pk,
ContentType.objects.get_for_model(Signage).pk
),
data)
self.assertEqual(response.status_code, 302)
def test_update_form_on_signage(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
signa = SignageFactory.create()
else:
signa = SignageFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
signage = "%s" % signa
intervention = InterventionFactory.create(target=signa)
response = self.client.get(intervention.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
# Should be able to save form successfully
form = response.context['form']
data = form.initial
data['disorders'] = data['disorders'][0].pk
data['project'] = ''
data.update(
**{
'manday_set-TOTAL_FORMS': '0',
'manday_set-INITIAL_FORMS': '0',
'manday_set-MAX_NUM_FORMS': '',
})
# Form URL is modified in form init
formurl = '%s?target_id=%s&target_type=%s' % (
intervention.get_update_url(), signa.pk,
ContentType.objects.get_for_model(Signage).pk)
response = self.client.post(formurl, data)
self.assertEqual(response.status_code, 302)
def test_none_implantation_year_filter(self):
self.login()
model = self.factory._meta.model
SignageFactory.create()
response = self.client.get(model.get_list_url())
self.assertFalse('option value="" selected>None</option' in str(response))
def create_trek_with_infrastructures(obj, create, extracted, **kwargs):
path = obj.paths.all()[0]
signa1 = SignageFactory.create(no_path=True)
signa1.add_path(path, start=0.5, end=0.5)
signa2 = SignageFactory.create(no_path=True)
signa2.add_path(path, start=0.4, end=0.4)
if create:
obj.save()
def test_gps_value_all_cases(self):
path = PathFactory.create(geom=LineString((-4, -4), (4, 4), srid=4326))
signage_N_E = SignageFactory.create(no_path=True)
signage_S_W = SignageFactory.create(no_path=True)
signage_N_E.add_path(path, start=1, end=1)
signage_S_W.add_path(path, start=0, end=0)
self.assertEqual(signage_N_E.gps_value, u'4.0°N, 4.0°E')
self.assertEqual(signage_S_W.gps_value, u'4.0°S, 4.0°W')
def create_trek_with_infrastructures(obj, create, extracted, **kwargs):
path = obj.paths.all()[0]
signa1 = SignageFactory.create(no_path=True)
signa1.add_path(path, start=0.5, end=0.5)
signa2 = SignageFactory.create(no_path=True)
signa2.add_path(path, start=0.4, end=0.4)
if create:
obj.save()
def test_helpers(self):
p = PathFactory.create()
self.assertEqual(len(p.signages), 0)
if settings.TREKKING_TOPOLOGY_ENABLED:
sign = SignageFactory.create(paths=[(p, 0.5, 0.5)])
else:
sign = SignageFactory.create(geom='SRID=2154;POINT (700050 6600050)')
self.assertCountEqual(p.signages, [sign])
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_implantation_year_filter_with_str(self):
filter = SignageFilterSet(data={'implantation_year': 'toto'})
self.login()
model = self.factory._meta.model
i = SignageFactory.create(implantation_year=2015)
i2 = SignageFactory.create(implantation_year=2016)
response = self.client.get(model.get_list_url())
self.assertTrue('<option value="2015">2015</option>' in str(response))
self.assertTrue('<option value="2016">2016</option>' in str(response))
self.assertIn(i, filter.qs)
self.assertIn(i2, filter.qs)
def test_implantation_year_filter(self):
filter = SignageFilterSet(data={'implantation_year': 2015})
self.login()
model = self.factory._meta.model
i = SignageFactory.create(implantation_year=2015)
i2 = SignageFactory.create(implantation_year=2016)
response = self.client.get(model.get_list_url())
self.assertTrue('<option value="2015">2015</option>' in str(response))
self.assertTrue('<option value="2016">2016</option>' in str(response))
self.assertTrue(i in filter.qs)
self.assertFalse(i2 in filter.qs)
def test_implantation_year_filter_with_str(self):
filter = SignageFilterSet(data={'implantation_year': 'toto'})
self.login()
model = self.factory._meta.model
i = SignageFactory.create(implantation_year=2015)
i2 = SignageFactory.create(implantation_year=2016)
response = self.client.get(model.get_list_url())
self.assertContains(response, '<option value="2015">2015</option>')
self.assertContains(response, '<option value="2016">2016</option>')
self.assertIn(i, filter.qs)
self.assertIn(i2, filter.qs)
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_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_basic_format_not_ascii(self):
self.login()
signage = SignageFactory.create(name="ééé")
BladeFactory.create(signage=signage)
for fmt in ('csv', 'shp', 'gpx'):
response = self.client.get(self.model.get_format_list_url() + '?format=' + fmt)
self.assertEqual(response.status_code, 200, "")
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_path_helpers(self):
p = PathFactory.create()
self.assertEquals(len(p.interventions), 0)
self.assertEquals(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.assertItemsEqual(p.interventions, [i1])
i2 = InterventionFactory.create()
i2.set_topology(infra)
i2.save()
self.assertItemsEqual(p.interventions, [i1, i2])
proj = ProjectFactory.create()
proj.interventions.add(i1)
proj.interventions.add(i2)
self.assertItemsEqual(p.projects, [proj])
def test_helpers(self):
infra = InfrastructureFactory.create()
sign = SignageFactory.create()
interv = InterventionFactory.create()
proj = ProjectFactory.create()
self.assertFalse(interv.on_existing_topology)
self.assertEqual(interv.infrastructure, None)
interv.set_topology(infra)
self.assertTrue(interv.on_existing_topology)
self.assertFalse(interv.is_signage)
self.assertTrue(interv.is_infrastructure)
self.assertEqual(interv.signages, [])
self.assertEqual(interv.infrastructures, [infra])
self.assertEqual(interv.infrastructure, infra)
interv.set_topology(sign)
self.assertTrue(interv.on_existing_topology)
self.assertTrue(interv.is_signage)
self.assertFalse(interv.is_infrastructure)
self.assertEqual(interv.signages, [sign])
self.assertEqual(interv.infrastructures, [])
self.assertEqual(interv.signage, sign)
self.assertFalse(interv.in_project)
interv.project = proj
self.assertTrue(interv.in_project)
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_helpers(self):
infra = InfrastructureFactory.create()
sign = SignageFactory.create()
interv = InterventionFactory.create()
proj = ProjectFactory.create()
self.assertFalse(interv.on_existing_topology)
self.assertEquals(interv.infrastructure, None)
interv.set_topology(infra)
self.assertTrue(interv.on_existing_topology)
self.assertFalse(interv.is_signage)
self.assertTrue(interv.is_infrastructure)
self.assertEquals(interv.signages, [])
self.assertEquals(interv.infrastructures, [infra])
self.assertEquals(interv.infrastructure, infra)
interv.set_topology(sign)
self.assertTrue(interv.on_existing_topology)
self.assertTrue(interv.is_signage)
self.assertFalse(interv.is_infrastructure)
self.assertEquals(interv.signages, [sign])
self.assertEquals(interv.infrastructures, [])
self.assertEquals(interv.signage, sign)
self.assertFalse(interv.in_project)
interv.project = proj
self.assertTrue(interv.in_project)
def test_load_signage_with_fields(self):
output = StringIO()
structure = StructureFactory.create(name='structure')
filename = os.path.join(os.path.dirname(__file__), 'data',
'signage.shp')
SignageFactory(name="name")
call_command('loadsignage',
filename,
type_field='label',
name_field='name',
condition_field='condition',
structure_default='structure',
description_field='descriptio',
year_field='year',
verbosity=1,
stdout=output)
self.assertIn('Signages will be linked to %s' % structure,
output.getvalue())
self.assertIn("SignageType 'type' created", output.getvalue())
self.assertIn("Condition Type 'condition' created", output.getvalue())
value = Signage.objects.all()
names = [val.name for val in value]
years = [val.implantation_year for val in value]
self.assertIn('coucou', names)
self.assertIn(2010, years)
self.assertIn(2012, years)
self.assertEquals(value.count(), 3)
def test_update_form_on_signage(self):
self.login()
signa = SignageFactory.create()
signage = u"%s" % signa
intervention = InterventionFactory.create()
self.assertIsNone(intervention.signage)
intervention.set_topology(signa)
intervention.save()
self.assertIsNotNone(intervention.signage)
response = self.client.get(intervention.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
# Should be able to save form successfully
form = response.context['form']
data = form.initial
data['disorders'] = data['disorders'][0].pk
data['project'] = ''
data['signage'] = form.fields['signage'].initial.pk # because it is set after form init, not form.initial :(
data.update(**{
'manday_set-TOTAL_FORMS': '0',
'manday_set-INITIAL_FORMS': '0',
'manday_set-MAX_NUM_FORMS': '',
})
# Form URL is modified in form init
formurl = intervention.get_update_url() + '?signage=%s' % signa.pk
response = self.client.post(formurl, data)
self.assertEqual(response.status_code, 302)
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_helpers_nds(self):
i1 = InterventionFactory.create()
i2 = InterventionFactory.create()
i3 = InterventionFactory.create()
sign = SignageFactory.create(geom="SRID=4326;POINT(0 5)")
i1.set_topology(sign)
infra = InfrastructureFactory.create(geom="SRID=4326;POINT(1 5)")
i2.set_topology(infra)
t = TopologyFactory.create(geom="SRID=4326;POINT(2 5)")
i3.topology = t
proj = ProjectFactory.create()
self.assertCountEqual(proj.paths.all(), [])
self.assertEqual(proj.signages, [])
self.assertEqual(proj.infrastructures, [])
i1.save()
proj.interventions.add(i1)
self.assertEqual(proj.signages, [sign])
self.assertEqual(proj.infrastructures, [])
i2.save()
proj.interventions.add(i2)
self.assertEqual(proj.signages, [sign])
self.assertEqual(proj.infrastructures, [infra])
i3.save()
proj.interventions.add(i3)
self.assertEqual(proj.signages, [sign])
self.assertEqual(proj.infrastructures, [infra])
def get_good_data(self):
return {
'number': '1',
'signage': SignageFactory.create().pk,
'type': BladeTypeFactory.create().pk,
'condition': InfrastructureConditionFactory.create().pk,
'direction': BladeDirectionFactory.create().pk,
'color': BladeColorFactory.create().pk,
'topology': '{"lat": 5.1, "lng": 6.6}',
'lines-TOTAL_FORMS': '2',
'lines-INITIAL_FORMS': '0',
'lines-MAX_NUM_FORMS': '1000',
'lines-MIN_NUM_FORMS': '',
'lines-0-number': "1",
'lines-0-text': 'Text 0',
'lines-0-distance': "10",
'lines-0-pictogram_name': 'toto',
'lines-0-time': '00:01:00',
'lines-0-id': '',
'lines-0-DELETE': '',
'lines-1-number': "2",
'lines-1-text': 'Text 1',
'lines-1-distance': "0.2",
'lines-1-pictogram_name': 'coucou',
'lines-1-time': '00:00:10',
'lines-1-id': '',
'lines-1-DELETE': '',
}
def get_good_data(self):
return {
'number': '1',
'signage': SignageFactory.create().pk,
'type': BladeTypeFactory.create().pk,
'condition': InfrastructureConditionFactory.create().pk,
'direction': BladeDirectionFactory.create().pk,
'color': BladeColorFactory.create().pk,
'topology': '{"lat": 5.1, "lng": 6.6}',
'lines-TOTAL_FORMS': '2',
'lines-INITIAL_FORMS': '0',
'lines-MAX_NUM_FORMS': '1000',
'lines-MIN_NUM_FORMS': '',
'lines-0-number': "1",
'lines-0-text': 'Text 0',
'lines-0-distance': "10",
'lines-0-pictogram_name': 'toto',
'lines-0-time': '00:01:00',
'lines-0-id': '',
'lines-0-DELETE': '',
'lines-1-number': "2",
'lines-1-text': 'Text 1',
'lines-1-distance': "0.2",
'lines-1-pictogram_name': 'coucou',
'lines-1-time': '00:00:10',
'lines-1-id': '',
'lines-1-DELETE': '',
}
def test_update_same_eid(self):
output = StringIO()
filename = os.path.join(os.path.dirname(__file__), 'data', 'signage.shp')
SignageFactory(name="name", eid="eid_2")
call_command('loadsignage', filename, eid_field='eid', type_default='label',
name_default='name', verbosity=2, stdout=output)
self.assertIn("Update : name with eid eid1", output.getvalue())
self.assertEqual(Signage.objects.count(), 2)
def test_delete_redirection(self):
self.login()
signage = SignageFactory.create()
blade = BladeFactory.create(signage=signage)
response = self.client.post(Blade.get_delete_url(blade))
self.assertEqual(response.status_code, 302)
self.assertRedirects(response, signage.get_detail_url(), status_code=302)
def test_helpers(self):
p = PathFactory.create()
self.assertEqual(len(p.signages), 0)
sign = SignageFactory.create(no_path=True)
sign.add_path(path=p, start=0.5, end=0.5)
self.assertCountEqual(p.signages, [sign])
def test_helpers(self):
p = PathFactory.create()
self.assertEquals(len(p.signages), 0)
sign = SignageFactory.create(no_path=True)
sign.add_path(path=p, start=0.5, end=0.5)
self.assertItemsEqual(p.signages, [sign])
def create_trek_with_infrastructures(obj, create, extracted, **kwargs):
if settings.TREKKING_TOPOLOGY_ENABLED:
path = obj.paths.all()[0]
SignageFactory.create(paths=[(path, 0.5, 0.5)])
SignageFactory.create(paths=[(path, 0.4, 0.4)])
if create:
obj.save()
else:
SignageFactory.create(geom='SRID=2154;POINT (700040 6600040)')
SignageFactory.create(geom='SRID=2154;POINT (700050 6600050)')
def test_structure_is_set(self):
self.login()
signa = SignageFactory.create()
response = self.client.post(self._get_add_url() + '?signage=%s' % signa.pk, self.get_good_data())
self.assertEqual(response.status_code, 302)
obj = self.model.objects.last()
self.assertEqual(obj.structure, self.user.profile.structure)
def test_structure_is_set(self):
self.login()
signa = SignageFactory.create()
response = self.client.post(self._get_add_url() + '?signage=%s' % signa.pk, self.get_good_data())
self.assertEqual(response.status_code, 302)
obj = self.model.objects.last()
self.assertEqual(obj.structure, self.user.profile.structure)
def test_deleted_intervention(self):
sign = SignageFactory.create()
i1 = InterventionFactory.create(target=sign)
proj = ProjectFactory.create()
proj.interventions.add(i1)
self.assertEqual(proj.signages, [sign])
i1.delete()
self.assertEqual(proj.signages, [])
def test_infrastructure(self):
i = InterventionFactory.create()
self.assertFalse(i.on_existing_topology)
infra = InfrastructureFactory.create()
i.set_topology(infra)
self.assertTrue(i.on_existing_topology)
sign = SignageFactory.create()
i.set_topology(sign)
self.assertTrue(i.on_existing_topology)
def test_infrastructure(self):
i = InterventionFactory.create()
self.assertFalse(i.on_existing_topology)
infra = InfrastructureFactory.create()
i.set_topology(infra)
self.assertTrue(i.on_existing_topology)
sign = SignageFactory.create()
i.set_topology(sign)
self.assertTrue(i.on_existing_topology)
def test_deleted_intervention(self):
i1 = InterventionFactory.create()
sign = SignageFactory.create()
i1.set_topology(sign)
i1.save()
proj = ProjectFactory.create()
proj.interventions.add(i1)
self.assertEqual(proj.signages, [sign])
i1.delete()
self.assertEqual(proj.signages, [])
def test_deleted_intervention(self):
i1 = InterventionFactory.create()
sign = SignageFactory.create()
i1.set_topology(sign)
i1.save()
proj = ProjectFactory.create()
proj.interventions.add(i1)
self.assertEquals(proj.signages, [sign])
i1.delete()
self.assertEquals(proj.signages, [])
def test_csv_format_with_lines(self):
self.login()
signage = SignageFactory.create(name="ééé")
blade = BladeFactory.create(signage=signage)
LineFactory.create(blade=blade, number=3)
response = self.client.get(self.model.get_format_list_url() + '?format=csv')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content.split(b'\r\n')[0], b"ID,City,Signage,Printed elevation,Code,Type,Color,"
b"Direction,Condition,Coordinates (WGS 84 / Pseudo-Mercator),Number 1,Text 1,"
b"Distance 1,Time 1,Pictogram 1,Number 2,Text 2,"
b"Distance 2,Time 2,Pictogram 2")
def test_creation_form_on_signage(self):
self.login()
signa = SignageFactory.create()
signage = u"%s" % signa
response = self.client.get(Intervention.get_add_url() + '?signage=%s' % signa.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
form = response.context['form']
self.assertEqual(form.initial['signage'], signa)
# Should be able to save form successfully
data = self.get_good_data()
data['signage'] = signa.pk
response = self.client.post(Intervention.get_add_url() + '?signage=%s' % signa.pk, data)
self.assertEqual(response.status_code, 302)
def test_creation_form_on_signage_with_errors(self):
self.login()
signa = SignageFactory.create()
signage = u"%s" % signa
response = self.client.get(Intervention.get_add_url() + '?signage=%s' % signa.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
form = response.context['form']
self.assertEqual(form.initial['signage'], signa)
data = self.get_good_data()
data['signage'] = signa.pk
# If form invalid, it should not fail
data.pop('status')
response = self.client.post(Intervention.get_add_url() + '?signage=%s' % signa.pk, data)
self.assertEqual(response.status_code, 200)
def setUp(self):
self.source_a = RecordSourceFactory()
self.source_b = RecordSourceFactory()
self.portal_a = TargetPortalFactory()
self.portal_b = TargetPortalFactory()
information_desks = InformationDeskFactory.create()
self.trek_1 = TrekWithPublishedPOIsFactory.create(sources=(self.source_a, ),
portals=(self.portal_b,),
published=True)
self.trek_1.information_desks.add(information_desks)
self.attachment_1 = AttachmentFactory.create(content_object=self.trek_1,
attachment_file=get_dummy_uploaded_image())
self.trek_2 = TrekFactory.create(sources=(self.source_b,),
published=True)
self.trek_3 = TrekFactory.create(portals=(self.portal_b,
self.portal_a),
published=True)
self.trek_4 = TrekFactory.create(portals=(self.portal_a,),
published=True)
self.poi_1 = trek_models.POI.objects.first()
self.attachment_poi_image_1 = AttachmentFactory.create(content_object=self.poi_1,
attachment_file=get_dummy_uploaded_image())
self.attachment_poi_image_2 = AttachmentFactory.create(content_object=self.poi_1,
attachment_file=get_dummy_uploaded_image())
self.attachment_poi_file = AttachmentFactory.create(content_object=self.poi_1,
attachment_file=get_dummy_uploaded_file())
infrastructure = InfrastructureFactory.create(no_path=True, name="INFRA_1")
infrastructure.add_path(self.trek_1.paths.first(), start=0, end=0)
signage = SignageFactory.create(no_path=True, name="SIGNA_1")
signage.add_path(self.trek_1.paths.first(), start=0, end=0)
SensitiveAreaFactory.create(published=True)
self.touristic_content = TouristicContentFactory(
geom='SRID=%s;POINT(700001 6600001)' % settings.SRID, published=True)
self.touristic_event = TouristicEventFactory(
geom='SRID=%s;POINT(700001 6600001)' % settings.SRID, published=True)
self.attachment_touristic_content = AttachmentFactory.create(content_object=self.touristic_content,
attachment_file=get_dummy_uploaded_image())
self.attachment_touristic_event = AttachmentFactory.create(content_object=self.touristic_event,
attachment_file=get_dummy_uploaded_image())
def test_helpers(self):
i1 = InterventionFactory.create()
i2 = InterventionFactory.create()
i3 = InterventionFactory.create()
sign = SignageFactory.create()
i1.set_topology(sign)
p1 = sign.paths.get()
infra = InfrastructureFactory.create()
i2.set_topology(infra)
p2 = infra.paths.get()
t = TopologyFactory.create(no_path=True)
PathAggregationFactory.create(topo_object=t, path=p1)
i3.topology = t
proj = ProjectFactory.create()
self.assertItemsEqual(proj.paths.all(), [])
self.assertEquals(proj.signages, [])
self.assertEquals(proj.infrastructures, [])
i1.save()
proj.interventions.add(i1)
self.assertItemsEqual(proj.paths.all(), [p1])
self.assertEquals(proj.signages, [sign])
self.assertEquals(proj.infrastructures, [])
i2.save()
proj.interventions.add(i2)
self.assertItemsEqual(proj.paths.all(), [p1, p2])
self.assertEquals(proj.signages, [sign])
self.assertEquals(proj.infrastructures, [infra])
i3.save()
proj.interventions.add(i3)
self.assertItemsEqual(proj.paths.all(), [p1, p2])
self.assertEquals(proj.signages, [sign])
self.assertEquals(proj.infrastructures, [infra])
def create_signage_intervention(obj, create, extracted, **kwargs):
infra = SignageFactory.create()
obj.set_topology(infra)
if create:
obj.save()
def test_description_in_detail_page(self):
signa = SignageFactory.create(description="<b>Beautiful !</b>")
self.login()
response = self.client.get(signa.get_detail_url())
self.assertContains(response, "<b>Beautiful !</b>")
def _post_add_form(self):
signa = SignageFactory.create()
self._post_form(self._get_add_url() + '?signage=%s' % signa.pk)