def test_zones_api_no_geom(self):
zone = GeoZoneFactory(geom=None)
url = url_for('api.zones', ids=[zone.id])
response = self.get(url)
self.assert200(response)
self.assertEqual(len(response.json['features']), 1)
feature = response.json['features'][0]
self.assertEqual(feature['type'], 'Feature')
assert_json_equal(feature['geometry'], {
'type': 'MultiPolygon',
'coordinates': [],
})
self.assertEqual(feature['id'], zone.id)
properties = feature['properties']
self.assertEqual(properties['name'], zone.name)
self.assertEqual(properties['code'], zone.code)
self.assertEqual(properties['level'], zone.level)
self.assertEqual(properties['parents'], zone.parents)
self.assertEqual(properties['population'], zone.population)
self.assertEqual(properties['area'], zone.area)
self.assertEqual(properties['keys'], zone.keys)
self.assertEqual(properties['logo'], zone.logo_url(external=True))
def test_suggest_towns(self):
arles_sur_tech = GeoZoneFactory(
id='fr:commune:66009@1942-01-01', level='fr:commune',
parents=[self.bdr.id], name='Arles-sur-Tech', code='66009',
keys={'postal': '66150'}, population=2687, area=0,
validity={'start': '1942-01-01', 'end': '9999-12-31'})
response = self.get(
url_for('api.suggest_territory'), qs={'q': 'arles'})
self.assert200(response)
results = response.json
self.assertEqual(len(results), 2)
# Arles must be first given the population.
self.assertEqual(results[0]['id'], self.arles.id)
self.assertEqual(results[1]['id'], arles_sur_tech.id)
def test_zones_api_one(self):
zone = GeoZoneFactory()
url = url_for('api.zones', ids=[zone.id])
response = self.get(url)
self.assert200(response)
self.assertEqual(len(response.json['features']), 1)
feature = response.json['features'][0]
self.assertEqual(feature['type'], 'Feature')
assert_json_equal(feature['geometry'], zone.geom)
self.assertEqual(feature['id'], zone.id)
properties = feature['properties']
self.assertEqual(properties['name'], zone.name)
self.assertEqual(properties['code'], zone.code)
self.assertEqual(properties['level'], zone.level)
self.assertEqual(properties['parents'], zone.parents)
self.assertEqual(properties['population'], zone.population)
self.assertEqual(properties['area'], zone.area)
self.assertEqual(properties['keys'], zone.keys)
self.assertEqual(properties['logo'], zone.logo_url(external=True))
def test_suggest_zones_no_match(self):
'''It should not provide zones suggestions if no match'''
for i in range(3):
GeoZoneFactory(name=5 * '{0}'.format(i),
code=3 * '{0}'.format(i),
is_current=True)
response = self.get(url_for('api.suggest_zones'),
qs={
'q': 'xxxxxx',
'size': '5'
})
self.assert200(response)
self.assertEqual(len(response.json), 0)
def test_suggest_town_and_county(self):
bouchet = GeoZoneFactory(
id='fr:commune:26054@1942-01-01', level='fr:commune',
parents=[self.bdr.id], name='Bouchet', code='26054',
keys={'postal': '26790'}, population=1305, area=0,
validity={'start': '1942-01-01', 'end': '9999-12-31'})
response = self.get(
url_for('api.suggest_territory'), qs={'q': 'bouche'})
self.assert200(response)
results = response.json
self.assertEqual(len(results), 2)
# BDR must be first given the population.
self.assertEqual(results[0]['id'], self.bdr.id)
self.assertEqual(results[1]['id'], bouchet.id)
def test_with_gouvfr_region_territory_datasets(self):
paca = GeoZoneFactory(id='fr/region/93',
level='fr/region',
name='Provence Alpes Côtes dAzur')
response = self.client.get(
url_for('territories.territory', territory=paca))
self.assert200(response)
data = response.data.decode('utf-8')
self.assertIn(paca.name, data)
base_datasets = self.get_context_variable('base_datasets')
self.assertEqual(len(base_datasets), 8)
for dataset in base_datasets:
self.assertIn(
'<div data-udata-territory-id="{dataset.slug}"'.format(
dataset=dataset), data)
def test_with_gouvfr_county_territory_datasets(self):
bdr = GeoZoneFactory(id='fr/county/13',
level='fr/county',
name='Bouches-du-Rhône')
response = self.client.get(
url_for('territories.territory', territory=bdr))
self.assert200(response)
data = response.data.decode('utf-8')
self.assertIn(bdr.name, data)
base_datasets = self.get_context_variable('base_datasets')
self.assertEqual(len(base_datasets), 11)
for dataset in base_datasets:
self.assertIn(
'<div data-udata-territory-id="{dataset.slug}"'.format(
dataset=dataset), data)
def test_not_suggest_country(self):
GeoZoneFactory(id='country:fr', level='country', name='France')
response = self.get(url_for('api.suggest_territory'), qs={'q': 'fra'})
self.assert200(response)
results = response.json
self.assertEqual(len(results), 0)
response = self.get(url_for('api.suggest_territory'), qs={'q': 'fran'})
self.assert200(response)
results = response.json
self.assertEqual(len(results), 0)
response = self.get(url_for('api.suggest_territory'),
qs={'q': 'franc'})
self.assert200(response)
results = response.json
self.assertEqual(len(results), 0)
def test_suggest_drom_com_by_code(self):
guyane = GeoZoneFactory(id='fr:departement:973@1860-07-01',
level='fr:departement',
name='Guyane',
code='973',
population=250109,
area=0,
validity={
'start': '1860-07-01',
'end': '9999-12-31'
})
response = self.get(url_for('api.suggest_territory'), qs={'q': '973'})
self.assert200(response)
results = response.json
self.assertEqual(len(results), 1)
self.assertEqual(results[0]['id'], guyane.id)
def test_suggest_corsica_by_county_code(self):
haute_corse = GeoZoneFactory(id='fr:departement:2b@1976-01-01',
level='fr:departement',
name='Haute-Corse',
code='2b',
population=168640,
area=0,
validity={
'start': '1976-01-01',
'end': '9999-12-31'
})
response = self.get(url_for('api.suggest_territory'), qs={'q': '2b'})
self.assert200(response)
results = response.json
self.assertEqual(len(results), 1)
self.assertEqual(results[0]['id'], haute_corse.id)
def known_spatial_text_slug(app):
with app.app_context():
zone = GeoZoneFactory(validity=None)
data = {
'name': faker.unique_string(),
'title': faker.sentence(),
'notes': faker.paragraph(),
'resources': [{
'url': faker.unique_url()
}],
'extras': [{
'key': 'spatial-text',
'value': zone.slug
}]
}
return data, {'zone': zone}
def test_oembeds_api_for_territory_dataset_not_registered(self):
'''Should raise 400 on unregistered territory dataset'''
country = faker.country_code()
level = 'commune'
zone = GeoZoneFactory(level='{0}:{1}'.format(country, level),
validity={
'start': '1942-01-01',
'end': '9999-12-31'
})
TestDataset = territory_dataset_factory()
TERRITORY_DATASETS[level] = {}
reference = 'territory-{0}:{1}'.format(zone.id, TestDataset.id)
url = url_for('api.oembeds', references=reference)
response = self.get(url)
self.assert400(response)
self.assertEqual(response.json['message'],
'Unknown territory dataset id.')
def test_suggest_corsica_by_code(self):
bastia = GeoZoneFactory(id='fr:commune:2b033@1976-01-01',
level='fr:commune',
name='Bastia',
code='2b033',
population=4479,
area=0,
validity={
'start': '1976-01-01',
'end': '9999-12-31'
})
response = self.get(url_for('api.suggest_territory'),
qs={'q': '2b033'})
self.assert200(response)
results = response.json
self.assertEqual(len(results), 1)
self.assertEqual(results[0]['id'], bastia.id)
def test_oembed_town_territory_api_get(self):
'''It should fetch a town territory in the oembed format.'''
arles = GeoZoneFactory(id='fr/town/13004',
level='fr/town',
name='Arles',
code='13004',
population=52439)
licence_ouverte = LicenseFactory(id='fr-lo', title='Licence Ouverte')
odbl_license = LicenseFactory(id='odc-odbl', title='ODbL')
LicenseFactory(id='notspecified', title='Not Specified')
town_datasets = TERRITORY_DATASETS['town']
for territory_dataset_class in town_datasets.values():
organization = OrganizationFactory(
id=territory_dataset_class.organization_id)
territory = territory_dataset_class(arles)
reference = 'territory-{id}'.format(id=territory.slug)
response = self.get(url_for('api.oembeds', references=reference))
self.assert200(response)
data = json.loads(response.data)[0]
self.assertIn('html', data)
self.assertIn('width', data)
self.assertIn('maxwidth', data)
self.assertIn('height', data)
self.assertIn('maxheight', data)
self.assertTrue(data['type'], 'rich')
self.assertTrue(data['version'], '1.0')
self.assertIn(territory.title, data['html'])
self.assertIn(cgi.escape(territory.url), data['html'])
self.assertIn('alt="{name}"'.format(name=organization.name),
data['html'])
self.assertIn(md(territory.description, source_tooltip=True),
data['html'])
self.assertIn('Download from localhost', data['html'])
self.assertIn('Add to your own website', data['html'])
if territory_dataset_class not in (town_datasets['comptes_t'], ):
if territory_dataset_class == town_datasets['ban_odbl_t']:
license = odbl_license
else:
license = licence_ouverte
self.assertIn('License: {title}'.format(title=license.title),
data['html'])
self.assertIn('© {license_id}'.format(license_id=license.id),
data['html'])
self.assertIn(
'<a data-tooltip="Source" href="http://localhost/datasets',
data['html'])
def test_oembed_region_territory_api_get(self):
'''It should fetch a region territory in the oembed format.'''
midi_pyrenees = GeoZoneFactory(id='fr/region/73',
level='fr/region',
name='Midi-Pyrénées',
code='73')
licence_ouverte = LicenseFactory(id='fr-lo', title='Licence Ouverte')
LicenseFactory(id='notspecified', title='Not Specified')
for territory_dataset_class in TERRITORY_DATASETS['region'].values():
organization = OrganizationFactory(
id=territory_dataset_class.organization_id)
territory = territory_dataset_class(midi_pyrenees)
reference = 'territory-{id}'.format(id=territory.slug)
response = self.get(url_for('api.oembeds', references=reference))
self.assert200(response)
data = json.loads(response.data)[0]
self.assertIn('html', data)
self.assertIn('width', data)
self.assertIn('maxwidth', data)
self.assertIn('height', data)
self.assertIn('maxheight', data)
self.assertTrue(data['type'], 'rich')
self.assertTrue(data['version'], '1.0')
self.assertIn(territory.title, data['html'])
self.assertIn(cgi.escape(territory.url), data['html'])
self.assertIn('alt="{name}"'.format(name=organization.name),
data['html'])
self.assertIn(md(territory.description, source_tooltip=True),
data['html'])
self.assertIn('Download from localhost', data['html'])
self.assertIn('Add to your own website', data['html'])
if territory_dataset_class not in (
TERRITORY_DATASETS['region']['comptes_r'],
TERRITORY_DATASETS['region']['zonages_r']):
self.assertIn(
'License: {title}'.format(title=licence_ouverte.title),
data['html'])
self.assertIn(
'© {license_id}'.format(license_id=licence_ouverte.id),
data['html'])
self.assertIn(
'<a data-tooltip="Source" href="http://localhost/datasets',
data['html'])
def test_oembeds_api_for_territory(self):
'''It should fetch a territory in the oembed format.'''
country = faker.country_code().lower()
level = 'commune'
zone = GeoZoneFactory(level='{0}:{1}'.format(country, level))
TestDataset = territory_dataset_factory()
TERRITORY_DATASETS[level][TestDataset.id] = TestDataset
reference = 'territory-{0}:{1}'.format(zone.id, TestDataset.id)
url = url_for('api.oembeds', references=reference)
response = self.get(url)
self.assert200(response)
data = json.loads(response.data)[0]
self.assertIn('html', data)
self.assertIn('width', data)
self.assertIn('maxwidth', data)
self.assertIn('height', data)
self.assertIn('maxheight', data)
self.assertTrue(data['type'], 'rich')
self.assertTrue(data['version'], '1.0')
self.assertIn(zone.name, data['html'])
self.assertIn('placeholders/default.png', data['html'])
def test_only_suggest_current_zones(self):
'''It should only suggest current zones'''
with self.autoindex():
for i in range(4):
GeoZoneFactory(name='test-{0}-{1}'.format(i, 'current' if i % 2 else 'legacy'),
is_current=i % 2)
response = self.get(
url_for('api.suggest_zones'), qs={'q': 'test', 'size': '5'})
self.assert200(response)
self.assertEqual(len(response.json), 2)
for suggestion in response.json:
self.assertIn('id', suggestion)
self.assertIn('name', suggestion)
self.assertIn('code', suggestion)
self.assertIn('level', suggestion)
self.assertIn('keys', suggestion)
self.assertIsInstance(suggestion['keys'], dict)
self.assertTrue(suggestion['name'].endswith('-current'))
def test_oembeds_api_for_territory(self, api):
'''It should fetch a territory in the oembed format.'''
country = faker.country_code().lower()
level = 'commune'
zone = GeoZoneFactory(level='{0}:{1}'.format(country, level))
TestDataset = territory_dataset_factory()
TERRITORY_DATASETS[level][TestDataset.id] = TestDataset
reference = 'territory-{0}:{1}'.format(zone.id, TestDataset.id)
url = url_for('api.oembeds', references=reference)
response = api.get(url)
assert200(response)
data = response.json[0]
assert 'html' in data
assert 'width' in data
assert 'maxwidth' in data
assert 'height' in data
assert 'maxheight' in data
assert data['type'] == 'rich'
assert data['version'] == '1.0'
assert zone.name in data['html']
assert 'placeholders/default.png' in data['html']
def test_suggest_zones_on_name(self):
'''It should suggest zones based on its name'''
with self.autoindex():
for i in range(4):
GeoZoneFactory(name='test-{0}'.format(i)
if i % 2 else faker.word())
response = self.get(
url_for('api.suggest_zones'), qs={'q': 'test', 'size': '5'})
self.assert200(response)
self.assertEqual(len(response.json), 2)
for suggestion in response.json:
self.assertIn('id', suggestion)
self.assertIn('name', suggestion)
self.assertIn('code', suggestion)
self.assertIn('level', suggestion)
self.assertIn('keys', suggestion)
self.assertIsInstance(suggestion['keys'], dict)
self.assertTrue(suggestion['name'].startswith('test'))
def test_zones_api_many(self):
zones = [GeoZoneFactory() for _ in range(3)]
url = url_for('api.zones', ids=zones)
response = self.get(url)
self.assert200(response)
self.assertEqual(len(response.json['features']), len(zones))
for zone, feature in zip(zones, response.json['features']):
self.assertEqual(feature['type'], 'Feature')
assert_json_equal(feature['geometry'], zone.geom)
self.assertEqual(feature['id'], zone.id)
properties = feature['properties']
self.assertEqual(properties['name'], zone.name)
self.assertEqual(properties['code'], zone.code)
self.assertEqual(properties['level'], zone.level)
self.assertEqual(properties['parents'], zone.parents)
self.assertEqual(properties['population'], zone.population)
self.assertEqual(properties['area'], zone.area)
self.assertEqual(properties['keys'], zone.keys)
self.assertEqual(properties['logo'], zone.logo_url(external=True))
def test_suggest_zones_on_extra_list_key(self):
'''It should suggest zones based on any list key'''
with self.autoindex():
for i in range(4):
GeoZoneFactory(
name='in' if i % 2 else 'not-in',
keys={str(i): ['test-{0}'.format(i)
if i % 2 else faker.word()]}
)
response = self.get(url_for('api.suggest_zones'),
qs={'q': 'test', 'size': '5'})
self.assert200(response)
self.assertEqual(len(response.json), 2)
for suggestion in response.json:
self.assertIn('id', suggestion)
self.assertIn('name', suggestion)
self.assertIn('code', suggestion)
self.assertIn('level', suggestion)
self.assertIn('keys', suggestion)
self.assertIsInstance(suggestion['keys'], dict)
self.assertEqual(suggestion['name'], 'in')
def test_suggest_zones_unicode(self):
'''It should suggest zones based on its name'''
for i in range(4):
GeoZoneFactory(name='testé-{0}'.format(i) if i %
2 else faker.word(),
is_current=True)
response = self.get(url_for('api.suggest_zones'),
qs={
'q': 'testé',
'size': '5'
})
self.assert200(response)
self.assertEqual(len(response.json), 2)
for suggestion in response.json:
self.assertIn('id', suggestion)
self.assertIn('name', suggestion)
self.assertIn('code', suggestion)
self.assertIn('level', suggestion)
self.assertIn('keys', suggestion)
self.assertIsInstance(suggestion['keys'], dict)
self.assertIn('testé', suggestion['name'])
def test_resolve_zone_without_slug_nor_trailing_slash(self, client):
zone = GeoZoneFactory(validity=None)
url = '/territory/{level}/{code}@latest'
response = client.get(url.format(**zone._data))
assert200(response)
def test_serialize_zone_without_validity(self):
zone = GeoZoneFactory(validity=None)
url = url_for('territory_tester', territory=zone)
expected = '/territory/{level}/{code}@latest/{slug}'
assert url == expected.format(**zone._data)
def test_serialize_default_prefix_zone_without_validity(self):
zone = GeoZoneFactory(level='fr:level', validity=None)
url = url_for('territory_tester', territory=zone)
expected = '/territory/level/{code}@latest/{slug}'
assert url == expected.format(**zone._data)
def test_resolve_default_prefix_zone_without_validity(self, client):
zone = GeoZoneFactory(level='fr:level', validity=None)
url = '/territory/level/{code}@latest/{slug}'
response = client.get(url.format(**zone._data))
assert200(response)
def test_resolve_zone_with_validity(self, client):
zone = GeoZoneFactory()
url = '/territory/{level}/{code}@{validity.start}/{slug}'
response = client.get(url.format(**zone._data))
assert200(response)
def test_resolve_zone_without_optionnal_slug(self, client):
zone = GeoZoneFactory(validity=None)
url = '/territory/{level}/{code}@latest/'
response = client.get(url.format(**zone._data))
assert200(response)