def test_update_form_on_infrastructure(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create()
else:
infra = InfrastructureFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
infrastr = "%s" % infra
intervention = InterventionFactory.create(target=infra)
response = self.client.get(intervention.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
# 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_add_url(
), infra.pk, ContentType.objects.get_for_model(Infrastructure).pk)
response = self.client.post(formurl, data)
self.assertEqual(response.status_code, 302)
def test_unset_structure_without_structure_keep_pk(self):
structure = StructureFactory.create(name="Test")
infratype_no_structure = InfrastructureTypeFactory.create(
label="type1", structure=None, pictogram=None)
InfrastructureFactory.create(name='infra1',
type=infratype_no_structure)
infratype_structure = InfrastructureTypeFactory.create(
label="type2", structure=structure, pictogram=None)
InfrastructureFactory.create(name='infra2', type=infratype_structure)
self.assertEqual(InfrastructureType.objects.count(), 2)
self.assertIsNone(infratype_no_structure.structure)
self.assertIsNotNone(infratype_structure.structure)
old_pk_no_structure = infratype_no_structure.pk
old_pk_structure = infratype_structure.pk
call_command('unset_structure', '--all', verbosity=0)
type1 = InfrastructureType.objects.get(label="type1")
type2 = InfrastructureType.objects.get(label="type1")
new_pk_no_structure = type1.pk
new_pk_structure = type2.pk
self.assertEqual(old_pk_no_structure, new_pk_no_structure)
self.assertNotEqual(old_pk_structure, new_pk_structure)
self.assertIsNone(type1.structure)
self.assertIsNone(type2.structure)
def test_none_implantation_year_filter(self):
self.login()
model = self.factory._meta.model
InfrastructureFactory.create()
response = self.client.get(model.get_list_url())
self.assertFalse('option value="" selected>None</option' in str(response))
def test_creation_form_on_infrastructure_with_errors(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create()
else:
infra = InfrastructureFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
infrastr = "%s" % infra
response = self.client.get(
'%s?target_id=%s&target_type=%s' %
(Intervention.get_add_url(), infra.pk,
ContentType.objects.get_for_model(Infrastructure).pk))
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
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(), infra.pk,
ContentType.objects.get_for_model(Infrastructure).pk), data)
self.assertEqual(response.status_code, 200)
def test_update_form_on_infrastructure(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create()
else:
infra = InfrastructureFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
infrastr = "%s" % infra
intervention = InterventionFactory.create()
intervention.set_topology(infra)
intervention.save()
response = self.client.get(intervention.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
# Should be able to save form successfully
form = response.context['form']
data = form.initial
data['disorders'] = data['disorders'][0].pk
data['project'] = ''
data['infrastructure'] = form.fields[
'infrastructure'].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(
) + '?infrastructure=%s' % infra.pk
response = self.client.post(formurl, data)
self.assertEqual(response.status_code, 302)
def create_trek_with_infrastructures(obj, create, extracted, **kwargs):
path = obj.paths.all()[0]
infra1 = InfrastructureFactory.create(no_path=True)
infra1.add_path(path, start=0.5, end=0.5)
infra2 = InfrastructureFactory.create(no_path=True)
infra2.add_path(path, start=0.4, end=0.4)
if create:
obj.save()
def test_none_implantation_year_filter(self):
self.login()
model = self.factory._meta.model
InfrastructureFactory.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]
infra1 = InfrastructureFactory.create(no_path=True)
infra1.add_path(path, start=0.5, end=0.5)
infra2 = InfrastructureFactory.create(no_path=True)
infra2.add_path(path, start=0.4, end=0.4)
if create:
obj.save()
def test_helpers(self):
p = PathFactory.create()
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create(paths=[p])
else:
infra = InfrastructureFactory.create(geom=p.geom)
self.assertCountEqual(p.infrastructures, [infra])
def create_infrastructure_point_intervention(obj, create, extracted, **kwargs):
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create(no_path=True)
infra.add_path(PathFactory.create(), start=0.5, end=0.5)
else:
infra = InfrastructureFactory.create(geom='SRID=2154;POINT (700040 6600040)')
obj.set_topology(infra)
if create:
obj.save()
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 create_infrastructure_point_intervention(obj, create, extracted,
**kwargs):
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create(paths=[(PathFactory.create(),
0.5, 0.5)])
else:
infra = InfrastructureFactory.create(
geom='SRID=2154;POINT (700040 6600040)')
obj.target = infra
if create:
obj.save()
def test_implantation_year_filter(self):
filter = InfrastructureFilterSet(data={'implantation_year': 2015})
self.login()
model = self.factory._meta.model
i = InfrastructureFactory.create(implantation_year=2015)
i2 = InfrastructureFactory.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 = InfrastructureFilterSet(data={'implantation_year': 'toto'})
self.login()
model = self.factory._meta.model
i = InfrastructureFactory.create(implantation_year=2015)
i2 = InfrastructureFactory.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_implantation_year_filter_with_str(self):
filter = InfrastructureFilterSet(data={'implantation_year': 'toto'})
self.login()
model = self.factory._meta.model
i = InfrastructureFactory.create(implantation_year=2015)
i2 = InfrastructureFactory.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_command_unset_structure(self):
structure1 = StructureFactory.create(name="coucou")
structure2 = StructureFactory.create(name="coco")
infratype1 = InfrastructureTypeFactory.create(label="annyeong",
structure=structure1,
pictogram=None)
infratype2 = InfrastructureTypeFactory.create(label="annyeong",
structure=structure2,
pictogram=None)
path = PathFactory.create(name="pass")
usage1 = UsageFactory.create(usage="hello", structure=structure1)
usage2 = UsageFactory.create(usage="hello", structure=structure2)
path.usages.add(usage1)
path.usages.add(usage2)
infrastructure1 = InfrastructureFactory.create(name='pissenlit',
type=infratype1)
infrastructure2 = InfrastructureFactory.create(name='rhododendron',
type=infratype2)
self.assertEqual(InfrastructureType.objects.count(), 2)
self.assertEqual(Usage.objects.count(), 2)
self.assertEqual(infrastructure1.type.label, 'annyeong')
self.assertEqual(infrastructure1.type.structure.name, 'coucou')
self.assertEqual(infrastructure2.type.label, 'annyeong')
self.assertEqual(infrastructure2.type.structure.name, 'coco')
self.assertEqual(path.usages.count(), 2)
self.assertEqual(usage1.structure.name, 'coucou')
self.assertEqual(usage2.structure.name, 'coco')
output = StringIO()
call_command('unset_structure', '--all', verbosity=2, stdout=output)
response = output.getvalue()
self.assertIn("Create hello", response)
self.assertEqual(InfrastructureType.objects.count(), 1)
self.assertEqual(Usage.objects.count(), 1)
infra = Infrastructure.objects.first()
self.assertEqual(infra.type.label, 'annyeong')
self.assertEqual(infra.type.structure, None)
path_usages = Path.objects.first().usages.first()
self.assertEqual(path_usages.usage, 'hello')
self.assertEqual(path_usages.structure, None)
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 _prepare(cls, create, **kwargs):
intervention = super(InfrastructureInterventionFactory, cls)._prepare(create, **kwargs)
infra = InfrastructureFactory.create()
intervention.set_infrastructure(infra)
if create:
intervention.save()
return intervention
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_infrastructure(sign)
i1.save()
self.assertItemsEqual(p.interventions, [i1])
i2 = InterventionFactory.create()
i2.set_infrastructure(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_delete_topology(self):
infra = InfrastructureFactory.create()
interv = InterventionFactory.create(target=infra)
interv.save()
infra.delete()
self.assertEqual(Infrastructure.objects.existing().count(), 0)
self.assertEqual(Intervention.objects.existing().count(), 0)
def test_helpers(self):
infra = InfrastructureFactory.create()
sign = SignageFactory.create()
interv = InterventionFactory.create()
proj = ProjectFactory.create()
self.assertFalse(interv.on_infrastructure)
self.assertEquals(interv.infrastructure, None)
interv.set_infrastructure(infra)
self.assertTrue(interv.on_infrastructure)
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_infrastructure(sign)
self.assertTrue(interv.on_infrastructure)
self.assertTrue(interv.is_signage)
self.assertFalse(interv.is_infrastructure)
self.assertEquals(interv.signages, [sign])
self.assertEquals(interv.infrastructures, [])
self.assertEquals(interv.infrastructure, sign)
self.assertFalse(interv.in_project)
interv.project = proj
self.assertTrue(interv.in_project)
def test_helpers(self):
p = PathFactory.create()
infra = InfrastructureFactory.create(no_path=True)
infra.add_path(path=p)
self.assertItemsEqual(p.infrastructures, [infra])
def setUp(self):
self.intervention = InterventionFactory.create()
self.project = ProjectFactory.create()
self.project.interventions.add(self.intervention)
self.project.interventions.add(InterventionFactory.create())
infra = InfrastructureFactory.create()
self.intervention.set_infrastructure(infra)
self.intervention.save()
path = infra.paths.get()
self.signagemgt = SignageManagementEdgeFactory.create(no_path=True)
self.signagemgt.add_path(path, start=0.3, end=0.7)
self.workmgt = WorkManagementEdgeFactory.create(no_path=True)
self.workmgt.add_path(path, start=0.3, end=0.7)
self.competencemgt = CompetenceEdgeFactory.create(no_path=True)
self.competencemgt.add_path(path, start=0.3, end=0.7)
self.cityedge = CityEdgeFactory.create(no_path=True)
self.cityedge.add_path(path, start=0.3, end=0.7)
self.districtedge = DistrictEdgeFactory.create(no_path=True)
self.districtedge.add_path(path, start=0.3, end=0.7)
self.restricted = RestrictedAreaEdgeFactory.create(no_path=True)
self.restricted.add_path(path, start=0.3, end=0.7)
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_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_load_infrastructure(self):
output = StringIO()
structure = StructureFactory.create(name='structure')
filename = os.path.join(os.path.dirname(__file__), 'data',
'signage.shp')
building = InfrastructureFactory(name="name", implantation_year=2010)
call_command('loadinfrastructure',
filename,
'--infrastructure',
type_default='label',
name_default='name',
condition_default='condition',
structure_default='structure',
description_default='description',
year_default=2010,
verbosity=2,
stdout=output)
self.assertIn('Infrastructures will be linked to %s' % structure,
output.getvalue())
self.assertIn('2 objects created.', output.getvalue())
value = Infrastructure.objects.all()
self.assertEquals(building.name, value[1].name)
self.assertEquals(building.implantation_year,
value[1].implantation_year)
self.assertEquals(value.count(), 3)
def test_update_form_on_infrastructure(self):
self.login()
infra = InfrastructureFactory.create()
infrastr = u"%s" % infra
intervention = InterventionFactory.create()
intervention.set_infrastructure(infra)
intervention.save()
response = self.client.get(intervention.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
# Should be able to save form successfully
form = response.context['form']
data = form.initial
data['project'] = ''
data['infrastructure'] = form.fields[
'infrastructure'].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(
) + '?infrastructure=%s' % infra.pk
response = self.client.post(formurl, data)
self.assertEqual(response.status_code, 302)
def test_load_infrastructure_with_fields(self):
output = StringIO()
structure = StructureFactory.create(name='structure')
filename = os.path.join(os.path.dirname(__file__), 'data',
'signage.shp')
InfrastructureFactory(name="name")
call_command('loadinfrastructure',
filename,
'--infrastructure',
type_field='label',
name_field='name',
condition_field='condition',
structure_default='structure',
description_field='descriptio',
year_field='year',
verbosity=1,
stdout=output)
self.assertIn('Infrastructures will be linked to %s' % structure,
output.getvalue())
self.assertIn("InfrastructureType 'type' created", output.getvalue())
self.assertIn("Condition Type 'condition' created", output.getvalue())
value = Infrastructure.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_infrastructure(self):
self.login()
infra = InfrastructureFactory.create()
infrastr = u"%s" % infra
intervention = InterventionFactory.create()
intervention.set_infrastructure(infra)
intervention.save()
response = self.client.get(intervention.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
# Should be able to save form successfully
form = response.context['form']
data = form.initial
data['project'] = ''
data['infrastructure'] = form.fields['infrastructure'].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() + '?infrastructure=%s' % infra.pk
response = self.client.post(formurl, data)
self.assertEqual(response.status_code, 302)
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_topology(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_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_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 create_infrastructure_point_intervention(obj, create, extracted,
**kwargs):
infra = InfrastructureFactory.create(no_path=True)
infra.add_path(PathFactory.create(), start=0.5, end=0.5)
obj.set_infrastructure(infra)
if create:
obj.save()
def test_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_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 setUp(self):
self.intervention = InterventionFactory.create()
self.project = ProjectFactory.create()
self.project.interventions.add(self.intervention)
self.project.interventions.add(InterventionFactory.create())
infra = InfrastructureFactory.create()
self.intervention.set_topology(infra)
self.intervention.save()
path = infra.paths.get()
self.signagemgt = SignageManagementEdgeFactory.create(no_path=True)
self.signagemgt.add_path(path, start=0.3, end=0.7)
self.workmgt = WorkManagementEdgeFactory.create(no_path=True)
self.workmgt.add_path(path, start=0.3, end=0.7)
self.competencemgt = CompetenceEdgeFactory.create(no_path=True)
self.competencemgt.add_path(path, start=0.3, end=0.7)
self.cityedge = CityEdgeFactory.create(no_path=True)
self.cityedge.add_path(path, start=0.3, end=0.7)
self.districtedge = DistrictEdgeFactory.create(no_path=True)
self.districtedge.add_path(path, start=0.3, end=0.7)
self.restricted = RestrictedAreaEdgeFactory.create(no_path=True)
self.restricted.add_path(path, start=0.3, end=0.7)
def test_helpers(self):
p = PathFactory.create()
infra = InfrastructureFactory.create(no_path=True)
infra.add_path(path=p)
self.assertCountEqual(p.infrastructures, [infra])
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 test_update_same_eid(self):
output = StringIO()
filename = os.path.join(os.path.dirname(__file__), 'data', 'infrastructure.shp')
InfrastructureFactory(name="name", eid="eid_2")
call_command('loadinfrastructure', 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(Infrastructure.objects.count(), 2)
def test_delete_topology(self):
infra = InfrastructureFactory.create()
interv = InterventionFactory.create()
interv.set_infrastructure(infra)
interv.save()
infra.delete()
self.assertEqual(Infrastructure.objects.existing().count(), 0)
self.assertEqual(Intervention.objects.existing().count(), 0)
def _prepare(cls, create, **kwargs):
intervention = super(InfrastructurePointInterventionFactory, cls)._prepare(create, **kwargs)
infra = InfrastructureFactory.create(no_path=True)
infra.add_path(PathFactory.create(), start=0.5, end=0.5)
intervention.set_infrastructure(infra)
if create:
intervention.save()
return intervention
def create_trek_with_infrastructures(obj, create, extracted, **kwargs):
if settings.TREKKING_TOPOLOGY_ENABLED:
path = obj.paths.all()[0]
InfrastructureFactory.create(paths=[(path, 0.5, 0.5)])
InfrastructureFactory.create(paths=[(path, 0.4, 0.4)])
if create:
obj.save()
else:
InfrastructureFactory.create(geom='SRID=2154;POINT (700040 6600040)')
InfrastructureFactory.create(geom='SRID=2154;POINT (700050 6600050)')
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_infrastructure)
infra = InfrastructureFactory.create()
i.set_infrastructure(infra)
self.assertTrue(i.on_infrastructure)
sign = SignageFactory.create()
i.set_infrastructure(sign)
self.assertTrue(i.on_infrastructure)
def test_command_unset_structure(self):
structure1 = StructureFactory.create(name="coucou")
structure2 = StructureFactory.create(name="coco")
infratype1 = InfrastructureTypeFactory.create(label="annyeong", structure=structure1, pictogram=None)
infratype2 = InfrastructureTypeFactory.create(label="annyeong", structure=structure2, pictogram=None)
path = PathFactory.create(name="pass")
usage1 = UsageFactory.create(usage="hello", structure=structure1)
usage2 = UsageFactory.create(usage="hello", structure=structure2)
path.usages.add(usage1)
path.usages.add(usage2)
infrastructure1 = InfrastructureFactory.create(name='pissenlit', type=infratype1)
infrastructure2 = InfrastructureFactory.create(name='rhododendron', type=infratype2)
self.assertEqual(InfrastructureType.objects.count(), 2)
self.assertEqual(Usage.objects.count(), 2)
self.assertEqual(infrastructure1.type.label, 'annyeong')
self.assertEqual(infrastructure1.type.structure.name, 'coucou')
self.assertEqual(infrastructure2.type.label, 'annyeong')
self.assertEqual(infrastructure2.type.structure.name, 'coco')
self.assertEqual(path.usages.count(), 2)
self.assertEqual(usage1.structure.name, 'coucou')
self.assertEqual(usage2.structure.name, 'coco')
output = StringIO()
call_command('unset_structure', '--all', verbosity=2, stdout=output)
response = output.getvalue()
self.assertIn("Create hello", response)
self.assertEqual(InfrastructureType.objects.count(), 1)
self.assertEqual(Usage.objects.count(), 1)
infra = Infrastructure.objects.first()
self.assertEqual(infra.type.label, 'annyeong')
self.assertEqual(infra.type.structure, None)
path_usages = Path.objects.first().usages.first()
self.assertEqual(path_usages.usage, 'hello')
self.assertEqual(path_usages.structure, None)
def test_denormalized_fields(self):
interv = InterventionFactory.create(width = 10.0, height = 10.0)
interv.reload()
self.assertEqual(interv.area, 100.0)
infra = InfrastructureFactory.create()
infra.save()
self.assertNotEqual(infra.length, 0.0)
interv.set_infrastructure(infra)
interv.save()
self.assertEqual(interv.length, infra.length)
def test_deleted_infrastructure(self):
i1 = InterventionFactory.create()
infra = InfrastructureFactory.create()
i1.set_infrastructure(infra)
proj = ProjectFactory.create()
proj.interventions.add(i1)
self.assertEquals(proj.infrastructures, [infra])
infra.delete()
self.assertEquals(proj.infrastructures, [])
def test_helpers(self):
p = PathFactory.create()
self.assertEquals(len(p.infrastructures), 0)
sign = SignageFactory.create(no_path=True)
PathAggregationFactory.create(topo_object=sign, path=p, start_position=0.5, end_position=0.5)
self.assertItemsEqual(p.signages, [sign])
infra = InfrastructureFactory.create(no_path=True)
PathAggregationFactory.create(topo_object=infra, path=p)
self.assertItemsEqual(p.infrastructures, [infra])
def test_form_on_infrastructure(self):
self.login()
infra = InfrastructureFactory.create()
infrastr = u"%s" % infra
# For creation
response = self.client.get(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
# For edition
intervention = InterventionFactory.create()
intervention.set_infrastructure(infra)
response = self.client.get(infra.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
def test_denormalized_fields(self):
infra = InfrastructureFactory.create()
infra.save()
self.assertNotEqual(infra.length, 0.0)
# After setting related infrastructure
interv = InterventionFactory.create()
interv.set_infrastructure(infra)
interv.save()
self.assertEqual(interv.length, infra.length)
# After update related infrastructure
infra.length = 3.14
infra.save()
interv.reload()
self.assertEqual(interv.length, infra.length)
def test_creation_form_on_infrastructure(self):
self.login()
infra = InfrastructureFactory.create()
infrastr = u"%s" % infra
response = self.client.get(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
form = response.context['form']
self.assertEqual(form.initial['infrastructure'], infra)
# Should be able to save form successfully
data = self.get_good_data()
data['infrastructure'] = infra.pk
response = self.client.post(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk, data)
self.assertEqual(response.status_code, 302)
def test_creation_form_on_infrastructure_with_errors(self):
self.login()
infra = InfrastructureFactory.create()
infrastr = u"%s" % infra
response = self.client.get(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
form = response.context['form']
self.assertEqual(form.initial['infrastructure'], infra)
data = self.get_good_data()
data['infrastructure'] = infra.pk
# If form invalid, it should not fail
data.pop('status')
response = self.client.post(Intervention.get_add_url() + '?infrastructure=%s' % infra.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 test_description_in_detail_page(self):
infra = InfrastructureFactory.create(description="<b>Beautiful !</b>")
self.login()
response = self.client.get(infra.get_detail_url())
self.assertContains(response, "<b>Beautiful !</b>")
def create_infrastructure_point_intervention(obj, create, extracted, **kwargs):
infra = InfrastructureFactory.create(no_path=True)
infra.add_path(PathFactory.create(), start=0.5, end=0.5)
obj.set_topology(infra)
if create:
obj.save()
def create_infrastructure_intervention(obj, create, extracted, **kwargs):
infra = InfrastructureFactory.create()
obj.set_topology(infra)
if create:
obj.save()
