def test_clean(self) -> None:
ancestry = Ancestry()
onymous_event = Event('E0', Birth())
Presence(Person('P0'), Subject(), onymous_event)
ancestry.entities.append(onymous_event)
anonymous_event = Event('E1', Birth())
ancestry.entities.append(anonymous_event)
onymous_place = Place('P0', [PlaceName('Amsterdam')])
onymous_place.events.append(onymous_event)
ancestry.entities.append(onymous_place)
anonymous_place = Place('P1', [PlaceName('Almelo')])
ancestry.entities.append(anonymous_place)
onmyous_place_because_encloses_onmyous_places = Place(
'P3', [PlaceName('Netherlands')])
Enclosure(onymous_place, onmyous_place_because_encloses_onmyous_places)
Enclosure(anonymous_place,
onmyous_place_because_encloses_onmyous_places)
ancestry.entities.append(onmyous_place_because_encloses_onmyous_places)
clean(ancestry)
self.assertEquals([onymous_event], list(ancestry.entities[Event]))
self.assertEquals(
[onymous_place, onmyous_place_because_encloses_onmyous_places],
list(ancestry.entities[Place]))
self.assertNotIn(
anonymous_place,
onmyous_place_because_encloses_onmyous_places.encloses)
def _load_place(loader: _Loader, element: ElementTree.Element) -> None:
place_handle = element.get('handle')
names = []
for name_element in _xpath(element, './ns:pname'):
# The Gramps language is a single ISO language code, which is a valid BCP 47 locale.
language = name_element.get('lang')
date = _load_date(name_element)
name = PlaceName(name_element.get('value'), locale=language, date=date)
names.append(name)
place = Place(element.get('id'), names)
coordinates = _load_coordinates(element)
if coordinates:
place.coordinates = coordinates
_load_urls(place, element)
loader.add_entity(FlattenedEntity(place, place_handle))
for enclosed_by_handle in _load_handles('placeref', element):
identifiable_enclosure = FlattenedEntity(Enclosure(None, None))
loader.add_entity(identifiable_enclosure)
loader.add_association(Enclosure, identifiable_enclosure.id,
'encloses', Place, place_handle)
loader.add_association(Enclosure, identifiable_enclosure.id,
'enclosed_by', Place, enclosed_by_handle)
def test_encloses(self) -> None:
sut = Place('P1', [PlaceName('The Place')])
self.assertCountEqual([], sut.encloses)
enclosed_place = Place('P2', [PlaceName('The Other Place')])
enclosure = Enclosure(enclosed_place, sut)
self.assertIn(enclosure, sut.encloses)
self.assertEquals(sut, enclosure.enclosed_by)
sut.encloses.remove(enclosure)
self.assertCountEqual([], sut.encloses)
self.assertIsNone(enclosure.enclosed_by)
async def test_with_enclosing_place_without_place_context(self):
place = Place('P0', [PlaceName('The Place')])
enclosing_place = Place('P1', [PlaceName('The Enclosing Place')])
Enclosure(place, enclosing_place)
all_enclosing_place = Place('P2',
[PlaceName('The All-enclosing Place')])
Enclosure(enclosing_place, all_enclosing_place)
expected = '<div class="meta">in <address><a href="/place/P1/index.html"><span>The Enclosing Place</span></a></address>, <address><a href="/place/P2/index.html"><span>The All-enclosing Place</span></a></address></div>'
async with self._render(data={
'place': place,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_without_enclosing_places(self):
place = Place('P0', [PlaceName('The Place')])
expected = '<div class="meta"></div>'
async with self._render(data={
'place': place,
}) as (actual, _):
self.assertEqual(expected, actual)
def test_clean_should_clean_event(self) -> None:
ancestry = Ancestry()
source = Source('S1', 'The Source')
ancestry.entities.append(source)
citation = Citation('C1', source)
ancestry.entities.append(citation)
file = File('F1', __file__)
ancestry.entities.append(file)
place = Place('P0', [PlaceName('The Place')])
ancestry.entities.append(place)
event = Event('E0', Birth())
event.citations.append(citation)
event.files.append(file)
event.place = place
ancestry.entities.append(event)
clean(ancestry)
self.assertNotIn(event.id, ancestry.entities[Event])
self.assertIsNone(event.place)
self.assertNotIn(event, place.events)
self.assertNotIn(place.id, ancestry.entities[Place])
self.assertNotIn(event, citation.facts)
self.assertNotIn(citation.id, ancestry.entities[Citation])
self.assertNotIn(event, file.entities)
self.assertNotIn(file.id, ancestry.entities[File])
def test_clean_should_not_clean_event_with_presences_with_people(
self) -> None:
ancestry = Ancestry()
source = Source('S1', 'The Source')
ancestry.entities.append(source)
citation = Citation('C1', source)
ancestry.entities.append(citation)
file = File('F1', __file__)
ancestry.entities.append(file)
place = Place('P0', [PlaceName('The Place')])
ancestry.entities.append(place)
person = Person('P0')
event = Event('E0', Birth())
event.citations.append(citation)
event.files.append(file)
event.place = place
ancestry.entities.append(event)
Presence(person, Subject(), event)
clean(ancestry)
self.assertEqual(event, ancestry.entities[Event][event.id])
self.assertIn(event, place.events)
self.assertEqual(place, ancestry.entities[Place][place.id])
self.assertIn(event, citation.facts)
self.assertEqual(citation, ancestry.entities[Citation][citation.id])
self.assertIn(event, file.entities)
self.assertEqual(file, ancestry.entities[File][file.id])
class Test(TemplateTestCase):
template_file = 'label/place.html.j2'
@parameterized.expand([
('<address><a href="/place/P0/index.html"><span>The Place</span></a></address>',
{
'place': Place('P0', [PlaceName('The Place')]),
}),
('<address><a href="/place/P0/index.html"><span lang="en">The Place</span></a></address>',
{
'place': Place('P0', [PlaceName('The Place', 'en')]),
}),
('<address><a href="/place/P0/index.html"><span lang="nl">De Plaats</span></a></address>',
{
'place':
Place(
'P0',
[PlaceName('The Place', 'en'),
PlaceName('De Plaats', 'nl')]),
'locale':
'nl',
}),
('<address><span>The Place</span></address>', {
'place': Place('P0', [PlaceName('The Place')]),
'embedded': True,
}),
('<address><a href="/place/P0/index.html"><span lang="nl">De Nieuwe Plaats</span></a></address>',
{
'place':
Place('P0', [
PlaceName('The Old Place',
'en',
date=DateRange(None, Date(1969, 12, 31))),
PlaceName('De Nieuwe Plaats',
'nl',
date=DateRange(Date(1970, 1, 1)))
]),
'locale':
'nl',
'date_context':
Date(1970, 1, 1),
})
])
@sync
async def test(self, expected, data):
async with self._render(data=data) as (actual, _):
self.assertEqual(expected, actual)
class TestResourceTest(TemplateTestCase):
@parameterized.expand([
('true', Person, Person('P1')),
('false', Person, Place('P1', [PlaceName('The Place')])),
('true', Place, Place('P1', [PlaceName('The Place')])),
('false', Place, Person('P1')),
('false', Place, 999),
('false', Person, object()),
])
@sync
async def test(self, expected, entity_type: Type[Entity], data) -> None:
template = f'{{% if data is {camel_case_to_snake_case(get_entity_type_name(entity_type))}_entity %}}true{{% else %}}false{{% endif %}}'
async with self._render(template_string=template,
data={
'data': data,
}) as (actual, _):
self.assertEquals(expected, actual)
async def test_with_place(self):
event = Event(None, Birth())
event.place = Place('P0', [PlaceName('The Place')])
expected = 'in <address><a href="/place/P0/index.html"><span>The Place</span></a></address>'
async with self._render(data={
'event': event,
}) as (actual, _):
self.assertEqual(expected, actual)
def test_place(self) -> None:
place = Place('1', [PlaceName('one')])
sut = Event(None, Mock(EventType))
sut.place = place
self.assertEquals(place, sut.place)
self.assertIn(sut, place.events)
sut.place = None
self.assertEquals(None, sut.place)
self.assertNotIn(sut, place.events)
def test_events(self) -> None:
sut = Place('P1', [PlaceName('The Place')])
event = Event('1', Birth())
sut.events.append(event)
self.assertIn(event, sut.events)
self.assertEquals(sut, event.place)
sut.events.remove(event)
self.assertCountEqual([], sut.events)
self.assertEquals(None, event.place)
async def test_with_place_is_place_context(self):
event = Event(None, Birth())
place = Place('P0', [PlaceName('The Place')])
event.place = place
expected = ''
async with self._render(data={
'event': event,
'place_context': place,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_place(self):
configuration = Configuration(self._output_directory.name,
'https://ancestry.example.com')
app = App(configuration)
async with app:
place = Place('PLACE1', [PlaceName('one')])
app.ancestry.entities.append(place)
await generate(app)
self.assert_betty_html(app, '/place/%s/index.html' % place.id)
self.assert_betty_json(app, '/place/%s/index.json' % place.id, 'place')
async def test_embedded(self):
event = Event(None, Birth())
event.date = Date(1970)
event.place = Place('P0', [PlaceName('The Place')])
event.citations.append(Citation(None, Source(None, 'The Source')))
expected = '1970 in <address><span>The Place</span></address>'
async with self._render(data={
'event': event,
'embedded': True,
}) as (actual, _):
self.assertEqual(expected, actual)
async def test_place_should_encode_minimal(self):
place_id = 'the_place'
name = 'The Place'
place = Place(place_id, [PlaceName(name)])
expected = {
'$schema':
'/schema.json#/definitions/place',
'@context': {
'enclosedBy': 'https://schema.org/containedInPlace',
'encloses': 'https://schema.org/containsPlace',
'events': 'https://schema.org/event'
},
'@type':
'https://schema.org/Place',
'id':
place_id,
'names': [
{
'name': name,
},
],
'enclosedBy': [],
'encloses': [],
'events': [],
'links': [
{
'url': '/en/place/the_place/index.json',
'relationship': 'canonical',
'mediaType': 'application/json',
},
{
'url': '/nl/place/the_place/index.json',
'relationship': 'alternate',
'locale': 'nl-NL',
},
{
'url': '/en/place/the_place/index.html',
'relationship': 'alternate',
'mediaType': 'text/html',
},
],
}
await self.assert_encodes(expected, place, 'place')
async def test_place(self, expected: str, locale: str):
place_id = 'P1'
place = Place(
place_id,
[PlaceName('Netherlands', 'en'),
PlaceName('Nederland', 'nl')])
with TemporaryDirectory() as output_directory_path:
configuration = Configuration(output_directory_path,
'https://example.com')
configuration.locales.replace([
LocaleConfiguration('en-US', 'en'),
LocaleConfiguration('nl-NL', 'nl'),
])
async with App(configuration).with_locale(locale) as app:
app.ancestry.entities.append(place)
indexed = [item for item in Index(app).build()]
self.assertEquals('netherlands nederland', indexed[0]['text'])
self.assertIn(expected, indexed[0]['result'])
class AppUrlGeneratorTest(TestCase):
@parameterized.expand([
('/index.html', '/index.html'),
('/person/P1/index.html', Person('P1')),
('/event/E1/index.html', Event('E1', Death())),
('/place/P1/index.html', Place('P1', [PlaceName('Place 1')])),
('/file/F1/index.html', File('F1', '/tmp')),
('/source/S1/index.html', Source('S1', 'Source 1')),
('/citation/C1/index.html', Citation('C1', Source('Source 1'))),
])
def test_generate(self, expected: str, resource: Any):
configuration = Configuration('/tmp', 'https://example.com')
sut = AppUrlGenerator(configuration)
self.assertEquals(expected, sut.generate(resource, 'text/html'))
def test_generate_with_invalid_value(self):
configuration = Configuration('/tmp', 'https://example.com')
sut = AppUrlGenerator(configuration)
with self.assertRaises(ValueError):
sut.generate(9, 'text/html')
async def test_event_should_encode_full(self):
event = Event('the_event', Birth())
event.date = DateRange(Date(2000, 1, 1), Date(2019, 12, 31))
event.place = Place('the_place', [PlaceName('The Place')])
Presence(Person('the_person'), Subject(), event)
event.citations.append(Citation('the_citation', Source('The Source')))
expected = {
'$schema':
'/schema.json#/definitions/event',
'@context': {
'place': 'https://schema.org/location',
},
'@type':
'https://schema.org/Event',
'id':
'the_event',
'type':
'birth',
'presences': [
{
'@context': {
'person': 'https://schema.org/actor',
},
'role': 'subject',
'person': '/en/person/the_person/index.json',
},
],
'citations': [
'/en/citation/the_citation/index.json',
],
'date': {
'start': {
'year': 2000,
'month': 1,
'day': 1,
},
'end': {
'year': 2019,
'month': 12,
'day': 31,
},
},
'place':
'/en/place/the_place/index.json',
'links': [
{
'url': '/en/event/the_event/index.json',
'relationship': 'canonical',
'mediaType': 'application/json',
},
{
'url': '/nl/event/the_event/index.json',
'relationship': 'alternate',
'locale': 'nl-NL',
},
{
'url': '/en/event/the_event/index.html',
'relationship': 'alternate',
'mediaType': 'text/html',
},
],
}
await self.assert_encodes(expected, event, 'event')
async def load(self) -> None:
amsterdam = Place('betty-demo-amsterdam', [PlaceName('Amsterdam')])
amsterdam.coordinates = Point(52.366667, 4.9)
amsterdam.links.add(Link('https://nl.wikipedia.org/wiki/Amsterdam'))
self._app.ancestry.entities.append(amsterdam)
ilpendam = Place('betty-demo-ilpendam', [PlaceName('Ilpendam')])
ilpendam.coordinates = Point(52.465556, 4.951111)
ilpendam.links.add(Link('https://nl.wikipedia.org/wiki/Ilpendam'))
self._app.ancestry.entities.append(ilpendam)
personal_accounts = Source('betty-demo-personal-accounts',
'Personal accounts')
self._app.ancestry.entities.append(personal_accounts)
cite_first_person_account = Citation('betty-demo-first-person-account',
personal_accounts)
self._app.ancestry.entities.append(cite_first_person_account)
bevolkingsregister_amsterdam = Source(
'betty-demo-bevolkingsregister-amsterdam',
'Bevolkingsregister Amsterdam')
bevolkingsregister_amsterdam.author = 'Gemeente Amsterdam'
bevolkingsregister_amsterdam.publisher = 'Gemeente Amsterdam'
self._app.ancestry.entities.append(bevolkingsregister_amsterdam)
david_marinus_lankester = Person('betty-demo-david-marinus-lankester')
PersonName(david_marinus_lankester, 'David Marinus', 'Lankester')
self._app.ancestry.entities.append(david_marinus_lankester)
geertruida_van_ling = Person('betty-demo-geertruida-van-ling')
PersonName(geertruida_van_ling, 'Geertruida', 'Van Ling')
self._app.ancestry.entities.append(geertruida_van_ling)
marriage_of_dirk_jacobus_lankester_and_jannigje_palsen = Event(
'betty-demo-marriage-of-dirk-jacobus-lankester-and-jannigje-palsen',
Marriage(), Date(1922, 7, 4))
marriage_of_dirk_jacobus_lankester_and_jannigje_palsen.place = ilpendam
self._app.ancestry.entities.append(
marriage_of_dirk_jacobus_lankester_and_jannigje_palsen)
birth_of_dirk_jacobus_lankester = Event(
'betty-demo-birth-of-dirk-jacobus-lankester', Birth(),
Date(1897, 8, 25))
birth_of_dirk_jacobus_lankester.place = amsterdam
self._app.ancestry.entities.append(birth_of_dirk_jacobus_lankester)
death_of_dirk_jacobus_lankester = Event(
'betty-demo-death-of-dirk-jacobus-lankester', Death(),
Date(1986, 8, 18))
death_of_dirk_jacobus_lankester.place = amsterdam
self._app.ancestry.entities.append(death_of_dirk_jacobus_lankester)
dirk_jacobus_lankester = Person('betty-demo-dirk-jacobus-lankester')
PersonName(dirk_jacobus_lankester, 'Dirk Jacobus', 'Lankester')
Presence(dirk_jacobus_lankester, Subject(),
birth_of_dirk_jacobus_lankester)
Presence(dirk_jacobus_lankester, Subject(),
death_of_dirk_jacobus_lankester)
Presence(dirk_jacobus_lankester, Subject(),
marriage_of_dirk_jacobus_lankester_and_jannigje_palsen)
dirk_jacobus_lankester.parents.append(david_marinus_lankester,
geertruida_van_ling)
self._app.ancestry.entities.append(dirk_jacobus_lankester)
birth_of_marinus_david_lankester = Event(
'betty-demo-birth-of-marinus-david', Birth(),
DateRange(Date(1874, 1, 15),
Date(1874, 3, 21),
start_is_boundary=True,
end_is_boundary=True))
birth_of_marinus_david_lankester.place = amsterdam
self._app.ancestry.entities.append(birth_of_marinus_david_lankester)
death_of_marinus_david_lankester = Event(
'betty-demo-death-of-marinus-david', Death(), Date(1971))
death_of_marinus_david_lankester.place = amsterdam
self._app.ancestry.entities.append(death_of_marinus_david_lankester)
marinus_david_lankester = Person('betty-demo-marinus-david-lankester')
PersonName(marinus_david_lankester, 'Marinus David', 'Lankester')
Presence(marinus_david_lankester, Subject(),
birth_of_marinus_david_lankester)
Presence(marinus_david_lankester, Subject(),
death_of_marinus_david_lankester)
marinus_david_lankester.parents.append(david_marinus_lankester,
geertruida_van_ling)
self._app.ancestry.entities.append(marinus_david_lankester)
birth_of_jacoba_gesina_lankester = Event(
'betty-demo-birth-of-jacoba-gesina', Birth(), Date(1900, 3, 14))
birth_of_jacoba_gesina_lankester.place = amsterdam
self._app.ancestry.entities.append(birth_of_jacoba_gesina_lankester)
jacoba_gesina_lankester = Person('betty-demo-jacoba-gesina-lankester')
PersonName(jacoba_gesina_lankester, 'Jacoba Gesina', 'Lankester')
Presence(jacoba_gesina_lankester, Subject(),
birth_of_jacoba_gesina_lankester)
jacoba_gesina_lankester.parents.append(david_marinus_lankester,
geertruida_van_ling)
self._app.ancestry.entities.append(jacoba_gesina_lankester)
jannigje_palsen = Person('betty-demo-jannigje-palsen')
PersonName(jannigje_palsen, 'Jannigje', 'Palsen')
Presence(jannigje_palsen, Subject(),
marriage_of_dirk_jacobus_lankester_and_jannigje_palsen)
self._app.ancestry.entities.append(jannigje_palsen)
marriage_of_johan_de_boer_and_liberta_lankester = Event(
'betty-demo-marriage-of-johan-de-boer-and-liberta-lankester',
Marriage(), Date(1953, 6, 19))
marriage_of_johan_de_boer_and_liberta_lankester.place = amsterdam
self._app.ancestry.entities.append(
marriage_of_johan_de_boer_and_liberta_lankester)
cite_birth_of_liberta_lankester_from_bevolkingsregister_amsterdam = Citation(
'betty-demo-birth-of-liberta-lankester-from-bevolkingsregister-amsterdam',
bevolkingsregister_amsterdam)
cite_birth_of_liberta_lankester_from_bevolkingsregister_amsterdam.location = 'Amsterdam'
self._app.ancestry.entities.append(
cite_birth_of_liberta_lankester_from_bevolkingsregister_amsterdam)
birth_of_liberta_lankester = Event(
'betty-demo-birth-of-liberta-lankester', Birth(),
Date(1929, 12, 22))
birth_of_liberta_lankester.place = amsterdam
birth_of_liberta_lankester.citations.append(
cite_birth_of_liberta_lankester_from_bevolkingsregister_amsterdam)
self._app.ancestry.entities.append(birth_of_liberta_lankester)
death_of_liberta_lankester = Event(
'betty-demo-death-of-liberta-lankester', Death(),
Date(2015, 1, 17))
death_of_liberta_lankester.place = amsterdam
death_of_liberta_lankester.citations.append(cite_first_person_account)
self._app.ancestry.entities.append(death_of_liberta_lankester)
liberta_lankester = Person('betty-demo-liberta-lankester')
PersonName(liberta_lankester, 'Liberta', 'Lankester')
PersonName(liberta_lankester, 'Betty')
Presence(liberta_lankester, Subject(), birth_of_liberta_lankester)
Presence(liberta_lankester, Subject(), death_of_liberta_lankester)
Presence(liberta_lankester, Subject(),
marriage_of_johan_de_boer_and_liberta_lankester)
liberta_lankester.parents.append(dirk_jacobus_lankester,
jannigje_palsen)
self._app.ancestry.entities.append(liberta_lankester)
birth_of_johan_de_boer = Event('betty-demo-birth-of-johan-de-boer',
Birth(), Date(1930, 6, 20))
birth_of_johan_de_boer.place = amsterdam
self._app.ancestry.entities.append(birth_of_johan_de_boer)
death_of_johan_de_boer = Event('betty-demo-death-of-johan-de-boer',
Death(), Date(1999, 3, 10))
death_of_johan_de_boer.place = amsterdam
death_of_johan_de_boer.citations.append(cite_first_person_account)
self._app.ancestry.entities.append(death_of_johan_de_boer)
johan_de_boer = Person('betty-demo-johan-de-boer')
PersonName(johan_de_boer, 'Johan', 'De Boer')
PersonName(johan_de_boer, 'Hans')
Presence(johan_de_boer, Subject(), birth_of_johan_de_boer)
Presence(johan_de_boer, Subject(), death_of_johan_de_boer)
Presence(johan_de_boer, Subject(),
marriage_of_johan_de_boer_and_liberta_lankester)
self._app.ancestry.entities.append(johan_de_boer)
parent_of_bart_feenstra_child_of_liberta_lankester = Person(
'betty-demo-parent-of-bart-feenstra-child-of-liberta-lankester')
PersonName(parent_of_bart_feenstra_child_of_liberta_lankester,
'Bart\'s parent')
parent_of_bart_feenstra_child_of_liberta_lankester.parents.append(
johan_de_boer, liberta_lankester)
self._app.ancestry.entities.append(
parent_of_bart_feenstra_child_of_liberta_lankester)
bart_feenstra = Person('betty-demo-bart-feenstra')
PersonName(bart_feenstra, 'Bart', 'Feenstra')
bart_feenstra.parents.append(
parent_of_bart_feenstra_child_of_liberta_lankester)
self._app.ancestry.entities.append(bart_feenstra)
def test_coordinates(self) -> None:
name = PlaceName('The Place')
sut = Place('P1', [name])
coordinates = Point()
sut.coordinates = coordinates
self.assertEquals(coordinates, sut.coordinates)
def test_names(self) -> None:
name = PlaceName('The Place')
sut = Place('P1', [name])
self.assertCountEqual([name], sut.names)
def test_links(self) -> None:
sut = Place('P1', [PlaceName('The Place')])
self.assertCountEqual([], sut.links)
def test_id(self) -> None:
place_id = 'C1'
sut = Place(place_id, [PlaceName('one')])
self.assertEquals(place_id, sut.id)
async def test_place_should_encode_full(self):
place_id = 'the_place'
name = 'The Place'
locale = 'nl-NL'
latitude = 12.345
longitude = -54.321
coordinates = Point(latitude, longitude)
place = Place(place_id, [PlaceName(name, locale)])
place.coordinates = coordinates
Enclosure(place, Place('the_enclosing_place', []))
Enclosure(Place('the_enclosed_place', []), place)
link = Link('https://example.com/the-place')
link.label = 'The Place Online'
place.links.add(link)
place.events.append(Event('E1', Birth()))
expected = {
'$schema':
'/schema.json#/definitions/place',
'@context': {
'enclosedBy': 'https://schema.org/containedInPlace',
'encloses': 'https://schema.org/containsPlace',
'events': 'https://schema.org/event',
'coordinates': 'https://schema.org/geo',
},
'@type':
'https://schema.org/Place',
'id':
place_id,
'names': [
{
'name': name,
'locale': 'nl-NL',
},
],
'events': [
'/en/event/E1/index.json',
],
'links': [
{
'url': '/en/place/the_place/index.json',
'relationship': 'canonical',
'mediaType': 'application/json',
},
{
'url': '/nl/place/the_place/index.json',
'relationship': 'alternate',
'locale': 'nl-NL',
},
{
'url': '/en/place/the_place/index.html',
'relationship': 'alternate',
'mediaType': 'text/html',
},
{
'url': 'https://example.com/the-place',
'label': 'The Place Online',
},
],
'coordinates': {
'@context': {
'latitude': 'https://schema.org/latitude',
'longitude': 'https://schema.org/longitude',
},
'@type': 'https://schema.org/GeoCoordinates',
'latitude': latitude,
'longitude': longitude,
},
'encloses': [
'/en/place/the_enclosed_place/index.json',
],
'enclosedBy': [
'/en/place/the_enclosing_place/index.json',
],
}
await self.assert_encodes(expected, place, 'place')