{% endfor %}
diff --git a/betty/cotton_candy/assets/templates/entity/page--file.html.j2 b/betty/cotton_candy/assets/templates/entity/page--file.html.j2
index d87045e3a..a7591d866 100644
--- a/betty/cotton_candy/assets/templates/entity/page--file.html.j2
+++ b/betty/cotton_candy/assets/templates/entity/page--file.html.j2
@@ -33,8 +33,8 @@
diff --git a/betty/cotton_candy/assets/templates/entity/page--source.html.j2 b/betty/cotton_candy/assets/templates/entity/page--source.html.j2
index c51215dad..495966e86 100644
--- a/betty/cotton_candy/assets/templates/entity/page--source.html.j2
+++ b/betty/cotton_candy/assets/templates/entity/page--source.html.j2
@@ -19,8 +19,8 @@
{% for fact in facts %}
{% endfor %}
diff --git a/betty/cotton_candy/assets/templates/search/result-place.html.j2 b/betty/cotton_candy/assets/templates/search/result-place.html.j2
index 62a2e9060..cfabc03d4 100644
--- a/betty/cotton_candy/assets/templates/search/result-place.html.j2
+++ b/betty/cotton_candy/assets/templates/search/result-place.html.j2
@@ -1,5 +1,5 @@
{% set embedded=True %}
-{% set entity_type_name_file_part = entity.entity_type() | entity_type_name | camel_case_to_kebab_case %}
+{% set entity_type_name_file_part = entity | entity_type_name | camel_case_to_kebab_case %}
{% include ['entity/label--' + entity_type_name_file_part + '.html.j2', 'entity/label.html.j2'] %}
diff --git a/betty/cotton_candy/gui.py b/betty/cotton_candy/gui.py
index 10355d459..bbc8ac664 100644
--- a/betty/cotton_candy/gui.py
+++ b/betty/cotton_candy/gui.py
@@ -7,7 +7,7 @@
from betty.app import App
from betty.cotton_candy import CottonCandy, _ColorConfiguration, CottonCandyConfiguration
from betty.gui.locale import LocalizedWidget
-from betty.gui.model import EntityReferencesCollector
+from betty.gui.model import EntityReferenceCollectionCollector
if TYPE_CHECKING:
from betty.builtins import _
@@ -20,15 +20,15 @@ def __init__(self, app, color: _ColorConfiguration, *args, **kwargs):
self._color.react(self.repaint)
self.setFixedHeight(24)
self.setFixedWidth(24)
+ self._painter = QPainter(self)
def __del__(self) -> None:
self._color.react.shutdown(self.repaint)
def paintEvent(self, a0: QPaintEvent) -> None:
- painter = QPainter(self)
swatch = QRect(self.rect())
- painter.fillRect(swatch, QBrush(QColor.fromString(self._color.hex)))
- painter.drawRect(swatch)
+ self._painter.fillRect(swatch, QBrush(QColor.fromString(self._color.hex)))
+ self._painter.drawRect(swatch)
class _ColorConfigurationWidget(LocalizedWidget):
@@ -121,7 +121,7 @@ def __init__(self, app: App, *args, **kwargs):
self._featured_entities_label = QLabel()
self._layout.addWidget(self._featured_entities_label)
- self._featured_entities_entity_references_collector = EntityReferencesCollector(
+ self._featured_entities_entity_references_collector = EntityReferenceCollectionCollector(
self._app,
self._app.extensions[CottonCandy].configuration.featured_entities,
lambda: _('Featured entities'),
diff --git a/betty/cotton_candy/search.py b/betty/cotton_candy/search.py
index b24f2a401..95fe3f921 100644
--- a/betty/cotton_candy/search.py
+++ b/betty/cotton_candy/search.py
@@ -18,7 +18,7 @@ def build(self) -> Iterable[Dict]:
])
def _render_entity(self, entity: Entity):
- entity_type_name = get_entity_type_name(entity.entity_type())
+ entity_type_name = get_entity_type_name(entity)
return self._app.jinja2_environment.negotiate_template([
f'search/result-{camel_case_to_snake_case(entity_type_name)}.html.j2',
'search/result.html.j2',
diff --git a/betty/demo/__init__.py b/betty/demo/__init__.py
index 64c76eaaa..72bec8c22 100644
--- a/betty/demo/__init__.py
+++ b/betty/demo/__init__.py
@@ -14,7 +14,7 @@
from betty.model.ancestry import Place, PlaceName, Person, Presence, Subject, PersonName, Link, Source, Citation, Event, \
Enclosure
from betty.model.event_type import Marriage, Birth, Death
-from betty.project import LocaleConfiguration, ProjectExtensionConfiguration, EntityReference
+from betty.project import LocaleConfiguration, ExtensionConfiguration, EntityReference
from betty.serve import Server
from betty.trees import Trees
from betty.wikipedia import Wikipedia
@@ -203,7 +203,7 @@ def public_url(self) -> str:
async def start(self) -> None:
self._stack.enter_context(self._app)
- self._app.project.configuration.extensions.add(ProjectExtensionConfiguration(Demo))
+ self._app.project.configuration.extensions.add(ExtensionConfiguration(Demo))
# Include all of the translations Betty ships with.
self._app.project.configuration.locales.replace([
LocaleConfiguration('en-US', 'en'),
diff --git a/betty/error.py b/betty/error.py
index 2ac8110e5..edded2f4d 100644
--- a/betty/error.py
+++ b/betty/error.py
@@ -1,42 +1,3 @@
-from contextlib import contextmanager
-from textwrap import indent
-from typing import List, Optional, Iterator
-
-
-class ContextError(Exception):
-
- """
- An error with a stack of contextual messages.
- """
-
- def __init__(self, *args, contexts: Optional[List[str]] = None, **kwargs):
- super().__init__(*args, **kwargs)
- self._contexts: List[str] = [] if contexts is None else contexts
-
- def __str__(self):
- return super().__str__() + '\n' + indent('\n'.join(self._contexts), '- ')
-
- def add_context(self, context: str):
- """
- Add a message describing the error's context.
-
- :param context: str
- :return: ExternalContextError
- """
- self._contexts.append(context)
- return self
-
-
-@contextmanager
-def ensure_context(*contexts: str) -> Iterator[None]:
- try:
- yield
- except ContextError as e:
- for context in contexts:
- e.add_context(context)
- raise
-
-
class UserFacingError(Exception):
"""
A user-facing error.
diff --git a/betty/generate.py b/betty/generate.py
index 915f6942e..df16361f3 100644
--- a/betty/generate.py
+++ b/betty/generate.py
@@ -1,24 +1,23 @@
import asyncio
import json
import logging
-import math
import os
import shutil
from pathlib import Path
-from typing import Iterable, Any, TYPE_CHECKING, cast, AsyncContextManager, List
+from typing import TYPE_CHECKING, cast, AsyncContextManager, List, Type
import aiofiles
+import math
from aiofiles import os as aiofiles_os
from aiofiles.threadpool.text import AsyncTextIOWrapper
from babel import Locale
from betty.app import App
-from betty.jinja2 import Environment
from betty.json import JSONEncoder
from betty.locale import bcp_47_to_rfc_1766
-from betty.model import EntityCollection, Entity
-from betty.model.ancestry import File, Person, Place, Event, Citation, Source, Note
+from betty.model import get_entity_type_name, UserFacingEntity, get_entity_type
from betty.openapi import build_specification
+from betty.string import camel_case_to_kebab_case
if TYPE_CHECKING:
from betty.builtins import _
@@ -61,6 +60,12 @@ async def _generate(app: App) -> None:
logger = getLogger()
await app.assets.copytree(Path('public') / 'static', app.project.configuration.www_directory_path)
await app.renderer.render_tree(app.project.configuration.www_directory_path)
+ entity_types = [
+ entity_type
+ for entity_type
+ in app.entity_types
+ if issubclass(entity_type, UserFacingEntity)
+ ]
for locale_configuration in app.project.configuration.locales:
locale = locale_configuration.locale
with app.acquire_locale(locale):
@@ -75,42 +80,27 @@ async def _generate(app: App) -> None:
coroutines = [
*[
coroutine
- for entities, entity_type_name in [
- (app.project.ancestry.entities[File], 'file'),
- (app.project.ancestry.entities[Person], 'person'),
- (app.project.ancestry.entities[Place], 'place'),
- (app.project.ancestry.entities[Event], 'event'),
- (app.project.ancestry.entities[Citation], 'citation'),
- (app.project.ancestry.entities[Source], 'source'),
- ]
+ for entity_type in entity_types
async for coroutine in _generate_entity_type(
www_directory_path,
- cast(EntityCollection[Entity], entities),
- entity_type_name,
+ entity_type,
app,
- locale,
- app.jinja2_environment,
)
],
- _generate_entity_type_list_json(www_directory_path, app.project.ancestry.entities[Note], 'note', app),
- *[
- _generate_entity_json(www_directory_path, note, 'note', app)
- for note in app.project.ancestry.entities[Note]
- ],
_generate_openapi(www_directory_path, app)
]
# Batch all coroutines to reduce the risk of "too many open files" errors.
for i in range(0, len(coroutines), _GENERATE_CONCURRENCY):
await asyncio.gather(*coroutines[i:i + _GENERATE_CONCURRENCY])
- locale_label = Locale.parse(bcp_47_to_rfc_1766(locale)).get_display_name(locale=bcp_47_to_rfc_1766(app.locale))
- logger.info(_('Generated pages for {file_count} files in {locale}.').format(file_count=len(app.project.ancestry.entities[File]), locale=locale_label))
- logger.info(_('Generated pages for {person_count} people in {locale}.').format(person_count=len(app.project.ancestry.entities[Person]), locale=locale_label))
- logger.info(_('Generated pages for {place_count} places in {locale}.').format(place_count=len(app.project.ancestry.entities[Place]), locale=locale_label))
- logger.info(_('Generated pages for {event_count} events in {locale}.').format(event_count=len(app.project.ancestry.entities[Event]), locale=locale_label))
- logger.info(_('Generated pages for {citation_count} citations in {locale}.').format(citation_count=len(app.project.ancestry.entities[Citation]), locale=locale_label))
- logger.info(_('Generated pages for {source_count} sources in {locale}.').format(source_count=len(app.project.ancestry.entities[Source]), locale=locale_label))
- logger.info(_('Generated pages for {note_count} notes in {locale}.').format(note_count=len(app.project.ancestry.entities[Note]), locale=locale_label))
- logger.info(_('Generated OpenAPI documentation in {locale}.').format(locale=locale_label))
+
+ # Log the generated pages.
+ locale_label = Locale.parse(bcp_47_to_rfc_1766(locale)).get_display_name(locale=bcp_47_to_rfc_1766(app.configuration.locale or 'en-US'))
+ for entity_type in entity_types:
+ logger.info(_('Generated pages for {count} {entity_type} in {locale}.').format(
+ count=len(app.project.ancestry.entities[entity_type]),
+ entity_type=entity_type.entity_type_label_plural(),
+ locale=locale_label,
+ ))
def _create_file(path: Path) -> AsyncContextManager[AsyncTextIOWrapper]:
@@ -126,53 +116,57 @@ def _create_json_resource(path: Path) -> AsyncContextManager[AsyncTextIOWrapper]
return _create_file(path / 'index.json')
-async def _generate_entity_type(www_directory_path: Path, entities: Iterable[Any], entity_type_name: str, app: App,
- locale: str, environment: Environment):
- yield _generate_entity_type_list_html(
- www_directory_path, entities,
- entity_type_name,
- environment,
- )
+async def _generate_entity_type(www_directory_path: Path, entity_type: Type[UserFacingEntity], app: App):
+ if entity_type in app.project.configuration.entity_types and app.project.configuration.entity_types[entity_type].generate_html_list:
+ yield _generate_entity_type_list_html(
+ www_directory_path,
+ entity_type,
+ app,
+ )
yield _generate_entity_type_list_json(
www_directory_path,
- entities,
- entity_type_name,
+ entity_type,
app,
)
- for entity in entities:
+ for entity in app.project.ancestry.entities[entity_type]:
async for coroutine in _generate_entity(
www_directory_path,
entity,
- entity_type_name,
app,
- environment,
):
yield coroutine
-async def _generate_entity_type_list_html(www_directory_path: Path, entities: Iterable[Any], entity_type_name: str,
- environment: Environment) -> None:
- entity_type_path = www_directory_path / entity_type_name
- template = environment.negotiate_template([
- f'entity/page-list--{entity_type_name}.html.j2',
+async def _generate_entity_type_list_html(www_directory_path: Path, entity_type: Type[UserFacingEntity], app: App) -> None:
+ entity_type_name_fs = camel_case_to_kebab_case(get_entity_type_name(entity_type))
+ entity_type_path = www_directory_path / entity_type_name_fs
+ template = app.jinja2_environment.negotiate_template([
+ f'entity/page-list--{entity_type_name_fs}.html.j2',
'entity/page-list.html.j2',
])
rendered_html = template.render({
- 'page_resource': '/%s/index.html' % entity_type_name,
- 'entity_type_name': entity_type_name,
- 'entities': entities,
+ 'page_resource': f'/{entity_type_name_fs}/index.html',
+ 'entity_type': entity_type,
+ 'entities': app.project.ancestry.entities[entity_type],
})
async with _create_html_resource(entity_type_path) as f:
await f.write(rendered_html)
+ locale_label = Locale.parse(bcp_47_to_rfc_1766(app.locale)).get_display_name(locale=bcp_47_to_rfc_1766(app.configuration.locale or 'en-US'))
+ getLogger().debug(_('Generated the listing HTML page for {entity_type} entities in {locale}.').format(
+ entity_type=entity_type.entity_type_label_plural(),
+ locale=locale_label,
+ ))
-async def _generate_entity_type_list_json(www_directory_path: Path, entities: Iterable[Any], entity_type_name: str, app: App) -> None:
- entity_type_path = www_directory_path / entity_type_name
+async def _generate_entity_type_list_json(www_directory_path: Path, entity_type: Type[UserFacingEntity], app: App) -> None:
+ entity_type_name = get_entity_type_name(entity_type)
+ entity_type_name_fs = camel_case_to_kebab_case(get_entity_type_name(entity_type))
+ entity_type_path = www_directory_path / entity_type_name_fs
data = {
'$schema': app.static_url_generator.generate('schema.json#/definitions/%sCollection' % entity_type_name, absolute=True),
'collection': []
}
- for entity in entities:
+ for entity in app.project.ancestry.entities[entity_type]:
cast(List[str], data['collection']).append(
app.url_generator.generate(
entity,
@@ -184,27 +178,29 @@ async def _generate_entity_type_list_json(www_directory_path: Path, entities: It
await f.write(rendered_json)
-async def _generate_entity(www_directory_path: Path, entity: Any, entity_type_name: str, app: App, environment: Environment):
- yield _generate_entity_html(www_directory_path, entity, entity_type_name, environment)
- yield _generate_entity_json(www_directory_path, entity, entity_type_name, app)
+async def _generate_entity(www_directory_path: Path, entity: UserFacingEntity, app: App):
+ yield _generate_entity_html(www_directory_path, entity, app)
+ yield _generate_entity_json(www_directory_path, entity, app)
-async def _generate_entity_html(www_directory_path: Path, entity: Any, entity_type_name: str, environment: Environment) -> None:
- entity_path = www_directory_path / entity_type_name / entity.id
- rendered_html = environment.negotiate_template([
- f'entity/page--{entity_type_name}.html.j2',
+async def _generate_entity_html(www_directory_path: Path, entity: UserFacingEntity, app: App) -> None:
+ entity_type_name_fs = camel_case_to_kebab_case(get_entity_type_name(entity))
+ entity_path = www_directory_path / entity_type_name_fs / entity.id
+ rendered_html = app.jinja2_environment.negotiate_template([
+ f'entity/page--{entity_type_name_fs}.html.j2',
'entity/page.html.j2',
]).render({
'page_resource': entity,
- 'entity_type_name': entity_type_name,
+ 'entity_type': get_entity_type(entity),
'entity': entity,
})
async with _create_html_resource(entity_path) as f:
await f.write(rendered_html)
-async def _generate_entity_json(www_directory_path: Path, entity: Any, entity_type_name: str, app: App) -> None:
- entity_path = www_directory_path / entity_type_name / entity.id
+async def _generate_entity_json(www_directory_path: Path, entity: UserFacingEntity, app: App) -> None:
+ entity_type_name_fs = camel_case_to_kebab_case(get_entity_type_name(entity))
+ entity_path = www_directory_path / entity_type_name_fs / entity.id
rendered_json = json.dumps(entity, cls=JSONEncoder.get_factory(app))
async with _create_json_resource(entity_path) as f:
await f.write(rendered_json)
diff --git a/betty/gramps/config.py b/betty/gramps/config.py
index 4a5492616..3533240f0 100644
--- a/betty/gramps/config.py
+++ b/betty/gramps/config.py
@@ -1,14 +1,17 @@
-from typing import Optional, List, Any, Iterable, TYPE_CHECKING
+from pathlib import Path
+from typing import Optional, List, Iterable
from reactives import reactive, ReactiveList
-from betty.config import Path, ConfigurationError, Configuration, ensure_path, DumpedConfiguration
-from betty.error import ensure_context
+from betty.config import Configuration, DumpedConfigurationImport, DumpedConfigurationExport, DumpedConfigurationDict
+from betty.config.dump import DumpedConfigurationList
+from betty.config.load import Loader, Field
from betty.os import PathLike
-
-if TYPE_CHECKING:
- from betty.builtins import _
+try:
+ from typing_extensions import TypeGuard
+except ModuleNotFoundError:
+ from typing import TypeGuard # type: ignore
class FamilyTreeConfiguration(Configuration):
@@ -30,17 +33,16 @@ def file_path(self) -> Optional[Path]:
def file_path(self, file_path: Optional[PathLike]) -> None:
self._file_path = Path(file_path) if file_path else None
- def load(self, dumped_configuration: Any) -> None:
- if not isinstance(dumped_configuration, dict):
- raise ConfigurationError(_('Family tree configuration must be a mapping (dictionary).'))
-
- if 'file' not in dumped_configuration:
- raise ConfigurationError(_('Family tree configuration requires a Gramps file to be set.'), contexts=['`file`'])
-
- with ensure_context('`file`'):
- self.file_path = ensure_path(dumped_configuration['file'])
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
+ loader.assert_record(dumped_configuration, {
+ 'file': Field(
+ True,
+ loader.assert_path, # type: ignore
+ lambda x: loader.assert_setattr(self, 'file_path', x)
+ )
+ })
- def dump(self) -> DumpedConfiguration:
+ def dump(self) -> DumpedConfigurationExport:
return {
'file': str(self.file_path),
}
@@ -58,22 +60,29 @@ def __init__(self, family_trees: Optional[Iterable[FamilyTreeConfiguration]] = N
def family_trees(self) -> List[FamilyTreeConfiguration]:
return self._family_trees
- def load(self, dumped_configuration: DumpedConfiguration) -> None:
- if not isinstance(dumped_configuration, dict):
- raise ConfigurationError(_('Gramps configuration must be a mapping (dictionary).'))
-
- with ensure_context('family_trees'):
- if 'family_trees' not in dumped_configuration or not isinstance(dumped_configuration['family_trees'], list):
- raise ConfigurationError(_('Family trees configuration is required and must must be a list.'))
-
- self._family_trees.clear()
- for i, dumped_family_tree_configuration in enumerate(dumped_configuration['family_trees']):
- with ensure_context(f'`{i}`'):
- family_tree_configuration = FamilyTreeConfiguration()
- family_tree_configuration.load(dumped_family_tree_configuration)
- self._family_trees.append(family_tree_configuration)
-
- def dump(self) -> DumpedConfiguration:
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
+ loader.assert_record(dumped_configuration, {
+ 'family_trees': Field(
+ True,
+ self._load_family_trees, # type: ignore
+ ),
+ })
+
+ def _load_family_trees(self, dumped_configuration, loader: Loader) -> TypeGuard[DumpedConfigurationList[DumpedConfigurationImport]]:
+ loader.on_commit(self._family_trees.clear)
+ return loader.assert_sequence(
+ dumped_configuration,
+ self._load_family_tree, # type: ignore
+ )
+
+ def _load_family_tree(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> TypeGuard[DumpedConfigurationDict[DumpedConfigurationImport]]:
+ with loader.context() as errors:
+ family_tree_configuration = FamilyTreeConfiguration()
+ family_tree_configuration.load(dumped_configuration, loader)
+ loader.on_commit(lambda: self._family_trees.append(family_tree_configuration))
+ return errors.valid
+
+ def dump(self) -> DumpedConfigurationExport:
return {
'family_trees': [
family_tree.dump()
diff --git a/betty/gramps/gui.py b/betty/gramps/gui.py
index e2d84b82e..2cc05235f 100644
--- a/betty/gramps/gui.py
+++ b/betty/gramps/gui.py
@@ -2,6 +2,8 @@
from typing import List, TYPE_CHECKING, Optional
+from betty.config.error import ConfigurationError
+
if TYPE_CHECKING:
from betty.builtins import _
@@ -11,7 +13,7 @@
from reactives import reactive
from betty.app import App
-from betty.config import Path, ConfigurationError
+from betty.config import Path
from betty.gramps import Gramps
from betty.gramps.config import FamilyTreeConfiguration
from betty.gui import BettyWindow, mark_valid, mark_invalid
diff --git a/betty/gramps/loader.py b/betty/gramps/loader.py
index 634e161f2..17670d702 100644
--- a/betty/gramps/loader.py
+++ b/betty/gramps/loader.py
@@ -15,7 +15,7 @@
from betty.load import getLogger
from betty.locale import DateRange, Datey, Date
from betty.media_type import MediaType
-from betty.model import Entity, FlattenedEntityCollection, FlattenedEntity, unflatten
+from betty.model import Entity, FlattenedEntityCollection, FlattenedEntity, unflatten, get_entity_type
from betty.model.ancestry import Ancestry, Note, File, Source, Citation, Place, Event, Person, PersonName, Subject, \
Witness, Beneficiary, Attendee, Presence, PlaceName, Enclosure, HasLinks, Link, HasPrivacy
from betty.model.event_type import Birth, Baptism, Adoption, Cremation, Death, Funeral, Burial, Will, Engagement, \
@@ -153,7 +153,7 @@ def load(self) -> None:
def add_entity(self, entity: Entity) -> None:
self._flattened_entities.add_entity(entity)
- self._added_entity_counts[unflatten(entity).entity_type()] += 1
+ self._added_entity_counts[get_entity_type(unflatten(entity))] += 1
def add_association(self, *args, **kwargs) -> None:
self._flattened_entities.add_association(*args, **kwargs)
@@ -566,7 +566,7 @@ def _load_citation(loader: _Loader, element: ElementTree.Element) -> None:
def _load_citationref(loader: _Loader, owner: Entity, element: ElementTree.Element) -> None:
for citation_handle in _load_handles('citationref', element):
- loader.add_association(unflatten(owner).entity_type(), owner.id, 'citations', Citation, citation_handle)
+ loader.add_association(get_entity_type(unflatten(owner)), owner.id, 'citations', Citation, citation_handle)
def _load_handles(handle_type: str, element: ElementTree.Element) -> Iterable[str]:
@@ -585,7 +585,7 @@ def _load_handle(handle_type: str, element: ElementTree.Element) -> Optional[str
def _load_objref(loader: _Loader, owner: Entity, element: ElementTree.Element) -> None:
file_handles = _load_handles('objref', element)
for file_handle in file_handles:
- loader.add_association(unflatten(owner).entity_type(), owner.id, 'files', File, file_handle)
+ loader.add_association(get_entity_type(unflatten(owner)), owner.id, 'files', File, file_handle)
def _load_urls(owner: HasLinks, element: ElementTree.Element) -> None:
diff --git a/betty/gui/__init__.py b/betty/gui/__init__.py
index 8a1a882d4..374f62b68 100644
--- a/betty/gui/__init__.py
+++ b/betty/gui/__init__.py
@@ -9,7 +9,7 @@
from PyQt6.QtWidgets import QApplication, QWidget
from betty.app import App
-from betty.config import APP_CONFIGURATION_FORMATS
+from betty.config import EXTENSIONS
from betty.error import UserFacingError
from betty.gui.error import ExceptionError, UnexpectedExceptionError
from betty.gui.locale import LocalizedWindow
@@ -19,7 +19,7 @@
def get_configuration_file_filter() -> str:
- return _('Betty project configuration ({extensions})').format(extensions=' '.join(map(lambda format: f'*{format}', APP_CONFIGURATION_FORMATS)))
+ return _('Betty project configuration ({extensions})').format(extensions=' '.join(map(lambda format: f'*.{format}', EXTENSIONS)))
class GuiBuilder:
diff --git a/betty/gui/model.py b/betty/gui/model.py
index d1d6679fc..b82750a5c 100644
--- a/betty/gui/model.py
+++ b/betty/gui/model.py
@@ -5,7 +5,8 @@
from betty.app import App
from betty.gui.locale import LocalizedWidget
-from betty.project import EntityReference, EntityReferences
+from betty.model import UserFacingEntity
+from betty.project import EntityReference, EntityReferenceCollection
if TYPE_CHECKING:
from betty.builtins import _
@@ -14,6 +15,8 @@
class EntityReferenceCollector(LocalizedWidget):
def __init__(self, app: App, entity_reference: EntityReference, label_builder: Optional[Callable[[], str]] = None, caption_builder: Optional[Callable[[], str]] = None):
super().__init__(app)
+ if entity_reference.entity_type and not issubclass(entity_reference.entity_type, UserFacingEntity):
+ raise ValueError(f'The GUI can only collect references for entity types that are user-facing and inherit from {UserFacingEntity.__module__}.{UserFacingEntity.__name__}, but an entity reference for {entity_reference.entity_type.__module__}.{entity_reference.entity_type.__name__} was given..')
self._entity_reference = entity_reference
self._label_builder = label_builder
self._caption_builder = caption_builder
@@ -28,7 +31,8 @@ def _update_entity_type() -> None:
self._entity_reference.entity_type = self._entity_type.currentData()
self._entity_type = QComboBox()
self._entity_type.currentIndexChanged.connect(_update_entity_type) # type: ignore
- for i, entity_type in enumerate(sorted(self._app.entity_types, key=lambda entity_type: entity_type.entity_type_label())):
+ # @todo We use translated labels, and sort by them, but neither is reactive.
+ for i, entity_type in enumerate(sorted(filter(lambda entity_type: isinstance(entity_type, UserFacingEntity), self._app.entity_types), key=lambda entity_type: entity_type.entity_type_label())):
self._entity_type.addItem(entity_type.entity_type_label(), entity_type)
if entity_type == self._entity_reference.entity_type:
self._entity_type.setCurrentIndex(i)
@@ -55,8 +59,8 @@ def _set_translatables(self) -> None:
self._entity_id_label.setText(_('Entity ID'))
-class EntityReferencesCollector(LocalizedWidget):
- def __init__(self, app: App, entity_references: EntityReferences, label_builder: Optional[Callable[[], str]] = None, caption_builder: Optional[Callable[[], str]] = None):
+class EntityReferenceCollectionCollector(LocalizedWidget):
+ def __init__(self, app: App, entity_references: EntityReferenceCollection, label_builder: Optional[Callable[[], str]] = None, caption_builder: Optional[Callable[[], str]] = None):
super().__init__(app)
self._entity_references = entity_references
self._label_builder = label_builder
diff --git a/betty/gui/project.py b/betty/gui/project.py
index bb3269401..5bb02839c 100644
--- a/betty/gui/project.py
+++ b/betty/gui/project.py
@@ -15,9 +15,9 @@
from betty import load, generate
from betty.app import App
-from betty.app.extension import Extension, UserFacingExtension
+from betty.app.extension import UserFacingExtension
from betty.asyncio import sync
-from betty.config import ConfigurationError
+from betty.config.load import ConfigurationValidationError
from betty.gui import get_configuration_file_filter, BettyWindow, GuiBuilder, mark_invalid, mark_valid
from betty.gui.app import BettyMainWindow
from betty.gui.error import catch_exceptions
@@ -27,6 +27,7 @@
from betty.gui.serve import ServeAppWindow
from betty.gui.text import Text, Caption
from betty.locale import rfc_1766_to_bcp_47, bcp_47_to_rfc_1766
+from betty.model import UserFacingEntity
from betty.project import LocaleConfiguration
if TYPE_CHECKING:
@@ -43,6 +44,55 @@ def __init__(self, pane_name: str, project_window: ProjectWindow, *args, **kwarg
self.released.connect(lambda: self._project_window._navigate_to_pane(pane_name)) # type: ignore
+class _GenerateHtmlListForm(LocalizedWidget):
+ def __init__(self, app: App, *args, **kwargs):
+ super().__init__(app, *args, **kwargs)
+ self._form = QFormLayout()
+ self.setLayout(self._form)
+ self._form_label = QLabel()
+ self._form.addRow(self._form_label)
+ self._checkboxes_form = QFormLayout()
+ self._form.addRow(self._checkboxes_form)
+ self._checkboxes: Dict[type[UserFacingEntity], QCheckBox] = {}
+ self._update()
+
+ @reactive(on_trigger_call=True)
+ def _update(self) -> None:
+ entity_types = list(sorted(
+ [
+ entity_type
+ for entity_type
+ in self._app.entity_types
+ if issubclass(entity_type, UserFacingEntity)
+ ],
+ key=lambda x: x.entity_type_label_plural(),
+ ))
+ for entity_type in self._checkboxes.keys():
+ if entity_type not in entity_types:
+ self._form.removeWidget(self._checkboxes[entity_type])
+ del self._checkboxes[entity_type]
+ for row_i, entity_type in enumerate(entity_types):
+ self._update_for_entity_type(entity_type, row_i)
+
+ def _update_for_entity_type(self, entity_type: Type[UserFacingEntity], row_i: int) -> None:
+ if entity_type in self._checkboxes:
+ self._checkboxes_form.insertRow(row_i, self._checkboxes[entity_type])
+ return
+
+ def _update(generate_html_list: bool) -> None:
+ self._app.project.configuration.entity_types[entity_type].generate_html_list = generate_html_list
+ self._checkboxes[entity_type] = QCheckBox()
+ self._checkboxes[entity_type].setChecked(self._app.project.configuration.entity_types[entity_type].generate_html_list)
+ self._checkboxes[entity_type].toggled.connect(_update) # type: ignore
+ self._update_for_entity_type(entity_type, row_i)
+
+ def _do_set_translatables(self) -> None:
+ self._form_label.setText(_('Generate entity listing pages'))
+ for entity_type in self._app.entity_types:
+ if issubclass(entity_type, UserFacingEntity):
+ self._checkboxes[entity_type].setText(entity_type.entity_type_label_plural())
+
+
class _GeneralPane(LocalizedWidget):
def __init__(self, app: App, *args, **kwargs):
super().__init__(app, *args, **kwargs)
@@ -56,6 +106,8 @@ def __init__(self, app: App, *args, **kwargs):
self._build_mode()
self._build_clean_urls()
self._build_content_negotiation()
+ self._generate_html_list_form = _GenerateHtmlListForm(app)
+ self._form.addRow(self._generate_html_list_form)
def _build_title(self) -> None:
def _update_configuration_title(title: str) -> None:
@@ -85,7 +137,7 @@ def _update_configuration_url(url: str) -> None:
with ReactorController.suspend():
configuration.base_url = base_url
configuration.root_path = root_path
- except ConfigurationError as e:
+ except ConfigurationValidationError as e:
mark_invalid(self._configuration_url, str(e))
return
self._app.project.configuration.base_url = base_url
@@ -106,7 +158,7 @@ def _update_configuration_lifetime_threshold(lifetime_threshold_value: str) -> N
try:
self._app.project.configuration.lifetime_threshold = lifetime_threshold
mark_valid(self._configuration_url)
- except ConfigurationError as e:
+ except ConfigurationValidationError as e:
mark_invalid(self._configuration_lifetime_threshold, str(e))
self._configuration_lifetime_threshold = QLineEdit()
self._configuration_lifetime_threshold.setFixedWidth(32)
@@ -289,7 +341,7 @@ def _save_and_close_locale(self) -> None:
try:
with self._app.acquire_locale():
self._app.project.configuration.locales.add(LocaleConfiguration(locale, alias))
- except ConfigurationError as e:
+ except ConfigurationValidationError as e:
mark_invalid(self._alias, str(e))
return
self.close()
@@ -297,10 +349,8 @@ def _save_and_close_locale(self) -> None:
@reactive
class _ExtensionPane(LocalizedWidget):
- def __init__(self, app: App, extension_type: Type[Extension], *args, **kwargs):
+ def __init__(self, app: App, extension_type: Type[UserFacingExtension], *args, **kwargs):
super().__init__(app, *args, **kwargs)
- if not issubclass(extension_type, UserFacingExtension):
- raise ValueError(f'extension_type must be a subclass of {UserFacingExtension}, but {extension_type} was given.')
self._extension_type = extension_type
layout = QVBoxLayout()
@@ -360,10 +410,10 @@ def _set_extension_status(self) -> None:
def _do_set_translatables(self) -> None:
self._extension_description.setText(
- self._extension_type.description(), # type: ignore
+ self._extension_type.description(),
)
self._extension_enabled.setText(_('Enable {extension}').format(
- extension=self._extension_type.label(), # type: ignore
+ extension=self._extension_type.label(),
))
diff --git a/betty/gui/serve.py b/betty/gui/serve.py
index 7f18b0c02..f5e5023c6 100644
--- a/betty/gui/serve.py
+++ b/betty/gui/serve.py
@@ -7,7 +7,7 @@
from betty.app import App
from betty.asyncio import sync
-from betty.config import ConfigurationError
+from betty.config.load import ConfigurationValidationError
from betty.gui import BettyWindow
from betty.gui.text import Text
from betty.serve import Server, AppServer
@@ -131,7 +131,7 @@ def __init__(self, *args, **kwargs):
if not path.isdir(self._app.project.configuration.www_directory_path):
self.close()
- raise ConfigurationError(_('Web root directory "{path}" does not exist.').format(path=self._app.project.configuration.www_directory_path))
+ raise ConfigurationValidationError(_('Web root directory "{path}" does not exist.').format(path=self._app.project.configuration.www_directory_path))
@property
def title(self) -> str:
diff --git a/betty/json.py b/betty/json.py
index 3d9ae2a4a..5f58be2fd 100644
--- a/betty/json.py
+++ b/betty/json.py
@@ -72,7 +72,7 @@ def _encode_schema(self, encoded: Dict, defintion: str) -> None:
@sync
async def _encode_entity(self, encoded: Dict, entity: Entity) -> None:
- self._encode_schema(encoded, upper_camel_case_to_lower_camel_case(get_entity_type_name(entity.entity_type())))
+ self._encode_schema(encoded, upper_camel_case_to_lower_camel_case(get_entity_type_name(entity)))
if 'links' not in encoded:
encoded['links'] = []
diff --git a/betty/locale.py b/betty/locale.py
index e3bf2c02d..b6752f6e9 100644
--- a/betty/locale.py
+++ b/betty/locale.py
@@ -289,7 +289,7 @@ class Translations(NullTranslations):
_stack: Dict[int, List[Translations]] = defaultdict(list)
_thread_id: Optional[int] = None
- def __init__(self, fallback: NullTranslations):
+ def __init__(self, fallback: Optional[NullTranslations] = None):
super().__init__()
self._fallback = fallback
self._previous_context: Translations._Context = None
diff --git a/betty/logging.py b/betty/logging.py
index f24529770..b6b5e0384 100644
--- a/betty/logging.py
+++ b/betty/logging.py
@@ -1,5 +1,5 @@
-from logging import CRITICAL, ERROR, WARNING, INFO, DEBUG, NOTSET, StreamHandler, LogRecord
import sys
+from logging import CRITICAL, ERROR, WARNING, INFO, DEBUG, NOTSET, StreamHandler, LogRecord
class CliHandler(StreamHandler):
diff --git a/betty/model/__init__.py b/betty/model/__init__.py
index 6b48d1d8b..8835c62e3 100644
--- a/betty/model/__init__.py
+++ b/betty/model/__init__.py
@@ -6,12 +6,16 @@
from dataclasses import dataclass
from enum import Enum
from functools import reduce
-from typing import TypeVar, Generic, Callable, List, Optional, Iterable, Any, Type, Union, Set, overload, cast, Iterator
+from typing import TypeVar, Generic, Callable, List, Optional, Iterable, Any, Type, Union, Set, overload, cast, \
+ Iterator, TYPE_CHECKING
try:
- from typing import Self # type: ignore
-except ImportError:
from typing_extensions import Self
+except ModuleNotFoundError:
+ from typing import Self # type: ignore
+
+if TYPE_CHECKING:
+ from betty.builtins import _
from betty.functools import slice_to_range
from betty.importlib import import_any
@@ -33,33 +37,46 @@ class GeneratedEntityId(str):
def __new__(cls, entity_id: Optional[str] = None):
if entity_id is None:
cls._last_id += 1
- entity_id = f'betty-generated-entity-id:{cls._last_id}'
+ entity_id = f'betty-generated-entity-id-{cls._last_id}'
return super().__new__(cls, entity_id)
class Entity:
def __init__(self, entity_id: Optional[str] = None, *args, **kwargs):
+ get_entity_type(self)
self._id = GeneratedEntityId() if entity_id is None else entity_id
super().__init__(*args, **kwargs)
- @classmethod
- def entity_type(cls) -> Type[Entity]:
- for ancestor_cls in cls.__mro__:
- if Entity in ancestor_cls.__bases__:
- return ancestor_cls
- return cls
+ @property
+ def id(self) -> str:
+ return self._id
+
+
+class EntityVariation(Entity):
+ pass
+
+
+class UserFacingEntity(EntityVariation):
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)
@classmethod
def entity_type_label(cls) -> str:
raise NotImplementedError
- @property
- def id(self) -> str:
- return self._id
+ @classmethod
+ def entity_type_label_plural(cls) -> str:
+ raise NotImplementedError
@property
- def label(self) -> Optional[str]:
- return None
+ def label(self) -> str:
+ return self._default_label()
+
+ def _default_label(self) -> str:
+ return _('{entity_type} {entity_id}').format(
+ entity_type=self.entity_type_label(),
+ entity_id=self.id,
+ )
class EntityTypeProvider:
@@ -73,20 +90,61 @@ def entity_types(self) -> Set[Type[Entity]]:
EntityU = TypeVar('EntityU', bound=Entity)
-def get_entity_type_name(entity_type: Type[Entity]) -> str:
+def get_entity_type_name(entity_type_definition: Union[str, Type[Entity], Entity]) -> str:
+ entity_type = get_entity_type(entity_type_definition)
if entity_type.__module__.startswith('betty.model.ancestry'):
return entity_type.__name__
return f'{entity_type.__module__}.{entity_type.__name__}'
-def get_entity_type(entity_type_name: str) -> Type[Entity]:
+class EntityTypeError(ValueError):
+ pass
+
+
+class EntityTypeImportError(EntityTypeError, ImportError):
+ """
+ Raised when an alleged entity type cannot be imported.
+ """
+ def __init__(self, entity_type_name: str):
+ super().__init__(f'Cannot find and import an entity with name "{entity_type_name}".')
+
+
+class EntityTypeInvalidError(EntityTypeError, ImportError):
+ """
+ Raised for types that are not valid entity types.
+ """
+ def __init__(self, entity_type: type):
+ super().__init__(f'{entity_type.__module__}.{entity_type.__name__} is not an entity type class. Entity types must extend {Entity.__module__}.{Entity.__name__} directly, but not {EntityVariation.__module__}.{EntityVariation.__name__}.')
+
+
+@functools.singledispatch
+def get_entity_type(entity_type_definition: Union[str, Type[Entity], Entity, Any]) -> Type[Entity]:
+ raise EntityTypeError(f'Cannot get the entity type for "{entity_type_definition}".')
+
+
+@get_entity_type.register(str)
+def get_entity_type_by_name(entity_type_name: str) -> Type[Entity]:
try:
- return import_any(entity_type_name)
+ entity_type = import_any(entity_type_name)
except ImportError:
try:
- return import_any(f'betty.model.ancestry.{entity_type_name}')
+ entity_type = import_any(f'betty.model.ancestry.{entity_type_name}')
except ImportError:
- raise ValueError(f'Unknown entity type "{entity_type_name}"') from None
+ raise EntityTypeImportError(entity_type_name) from None
+ return get_entity_type(entity_type)
+
+
+@get_entity_type.register(type)
+def get_entity_type_by_type(entity_type: type) -> Type[Entity]:
+ for ancestor_cls in entity_type.__mro__:
+ if ancestor_cls not in (Entity, EntityVariation) and Entity in ancestor_cls.__bases__ and EntityVariation not in ancestor_cls.__bases__:
+ return ancestor_cls
+ raise EntityTypeInvalidError(entity_type)
+
+
+@get_entity_type.register(object)
+def get_entity_type_by_entity(entity: Entity) -> Type[Entity]:
+ return get_entity_type(type(entity))
class EntityCollection(Generic[EntityT]):
@@ -190,7 +248,7 @@ def _assert_entity(self, entity) -> None:
assert (
isinstance(entity, self._entity_type)
or # noqa: W503 W504
- isinstance(entity, FlattenedEntity) and self._entity_type == entity.unflatten().entity_type()
+ isinstance(entity, FlattenedEntity) and self._entity_type == get_entity_type(entity.unflatten())
), message
def prepend(self, *entities: EntityT) -> None:
@@ -490,15 +548,15 @@ def _contains_by_entity(self, other_entity: EntityT) -> bool:
def prepend(self, *entities: EntityT) -> None:
for entity in entities:
- self[entity.entity_type()].prepend(entity)
+ self[get_entity_type(unflatten(entity))].prepend(entity)
def append(self, *entities: EntityT) -> None:
for entity in entities:
- self[unflatten(entity).entity_type()].append(entity)
+ self[get_entity_type(unflatten(entity))].append(entity)
def remove(self, *entities: EntityT) -> None:
for entity in entities:
- self[entity.entity_type()].remove(entity)
+ self[get_entity_type(unflatten(entity))].remove(entity)
def replace(self, *entities: EntityT) -> None:
self.clear()
@@ -739,7 +797,7 @@ def _copy_entity(cls, entity: EntityT) -> EntityT:
copied = copy.copy(entity)
# Copy any associate collections because they belong to a single owning entity.
- for association_registration in _EntityTypeAssociationRegistry.get_associations(entity.entity_type()):
+ for association_registration in _EntityTypeAssociationRegistry.get_associations(get_entity_type(entity)):
private_association_attr_name = f'_{association_registration.attr_name}'
associates = getattr(entity, private_association_attr_name)
if isinstance(associates, _AssociateCollection):
@@ -784,9 +842,9 @@ def add_entity(self, *entities: Entity) -> None:
for entity in entities:
if isinstance(entity, FlattenedEntity):
- entity_type = entity.unflatten().entity_type()
+ entity_type = get_entity_type(entity.unflatten())
else:
- entity_type = entity.entity_type()
+ entity_type = get_entity_type(entity)
entity = self._copy_entity(entity)
self._entities.append(entity)
@@ -802,7 +860,7 @@ def add_entity(self, *entities: Entity) -> None:
entity_type,
entity.id,
association_registration.attr_name,
- associate.unflatten().entity_type() if isinstance(associate, FlattenedEntity) else associate.entity_type(),
+ get_entity_type(associate.unflatten()) if isinstance(associate, FlattenedEntity) else get_entity_type(associate),
associate.id,
)
setattr(unflatten(entity), f'_{association_registration.attr_name}', None)
@@ -813,9 +871,9 @@ def add_association(self, owner_type: Type[Entity], owner_id: str, owner_associa
assert not issubclass(associate_type, FlattenedEntity)
self._associations.append(_FlattenedAssociation(
- owner_type.entity_type(),
+ get_entity_type(owner_type),
owner_id,
owner_association_attr_name,
- associate_type.entity_type(),
+ get_entity_type(associate_type),
associate_id,
))
diff --git a/betty/model/ancestry.py b/betty/model/ancestry.py
index eb4558618..640cb0a42 100644
--- a/betty/model/ancestry.py
+++ b/betty/model/ancestry.py
@@ -10,7 +10,7 @@
from betty.locale import Localized, Datey
from betty.media_type import MediaType
from betty.model import many_to_many, Entity, one_to_many, many_to_one, many_to_one_to_many, \
- MultipleTypesEntityCollection, EntityCollection
+ MultipleTypesEntityCollection, EntityCollection, UserFacingEntity, EntityVariation
from betty.model.event_type import EventType, StartOfLifeEventType, EndOfLifeEventType
from betty.os import PathLike
@@ -37,7 +37,7 @@ def __init__(self, *args, **kwargs):
@many_to_one('entity', 'notes')
-class Note(Entity):
+class Note(UserFacingEntity, Entity):
entity: HasNotes
def __init__(self, note_id: str, text: str):
@@ -48,17 +48,21 @@ def __init__(self, note_id: str, text: str):
def entity_type_label(cls) -> str:
return _('Note')
+ @classmethod
+ def entity_type_label_plural(cls) -> str:
+ return _('Notes')
+
@property
def text(self) -> str:
return self._text
@property
- def label(self) -> Optional[str]:
+ def label(self) -> str:
return self.text
@one_to_many('notes', 'entity')
-class HasNotes(Entity):
+class HasNotes(EntityVariation):
def __init__(self, *args, **kwargs):
assert type(self) != HasNotes
super().__init__(*args, **kwargs)
@@ -118,7 +122,7 @@ def links(self) -> Set[Link]:
@many_to_many('citations', 'facts')
-class HasCitations(Entity):
+class HasCitations(EntityVariation):
def __init__(self, *args, **kwargs):
assert type(self) != HasCitations
super().__init__(*args, **kwargs)
@@ -137,7 +141,7 @@ def citations(self) -> None:
@many_to_many('entities', 'files')
-class File(Described, HasPrivacy, HasMediaType, HasNotes, HasCitations, Entity):
+class File(Described, HasPrivacy, HasMediaType, HasNotes, HasCitations, UserFacingEntity, Entity):
def __init__(self, file_id: Optional[str], path: PathLike, media_type: Optional[MediaType] = None, *args, **kwargs):
super().__init__(file_id, *args, **kwargs)
self._path = Path(path)
@@ -159,17 +163,21 @@ def entities(self) -> None:
def entity_type_label(cls) -> str:
return _('File')
+ @classmethod
+ def entity_type_label_plural(cls) -> str:
+ return _('Files')
+
@property
def path(self) -> Path:
return self._path
@property
- def label(self) -> Optional[str]:
- return self.description
+ def label(self) -> str:
+ return self._default_label() if self.description is None else self.description
@many_to_many('files', 'entities')
-class HasFiles(Entity):
+class HasFiles(EntityVariation):
def __init__(self, *args, **kwargs):
assert type(self) != HasFiles
super().__init__(*args, **kwargs)
@@ -194,7 +202,7 @@ def associated_files(self) -> Iterable[File]:
@many_to_one('contained_by', 'contains')
@one_to_many('contains', 'contained_by')
@one_to_many('citations', 'source')
-class Source(Dated, HasFiles, HasLinks, HasPrivacy, Entity):
+class Source(Dated, HasFiles, HasLinks, HasPrivacy, UserFacingEntity, Entity):
name: Optional[str]
contained_by: Source
author: Optional[str]
@@ -234,14 +242,18 @@ def citations(self) -> None:
def entity_type_label(cls) -> str:
return _('Source')
+ @classmethod
+ def entity_type_label_plural(cls) -> str:
+ return _('Sources')
+
@property
- def label(self) -> Optional[str]:
- return self.name
+ def label(self) -> str:
+ return self._default_label() if not self.name else self.name
@many_to_many('facts', 'citations')
@many_to_one('source', 'citations')
-class Citation(Dated, HasFiles, HasPrivacy, Entity):
+class Citation(Dated, HasFiles, HasPrivacy, UserFacingEntity, Entity):
source: Source
location: Optional[str]
@@ -266,6 +278,10 @@ def facts(self) -> None:
def entity_type_label(cls) -> str:
return _('Citation')
+ @classmethod
+ def entity_type_label_plural(cls) -> str:
+ return _('Citations')
+
class PlaceName(Localized, Dated):
def __init__(self, name: str, locale: Optional[str] = None, date: Optional[Datey] = None, *args, **kwargs):
@@ -300,15 +316,11 @@ def __init__(self, encloses: Optional[Place], enclosed_by: Optional[Place], *arg
self.encloses = encloses # type: ignore
self.enclosed_by = enclosed_by # type: ignore
- @classmethod
- def entity_type_label(cls) -> str:
- return _('Enclosure')
-
@one_to_many('events', 'place')
@one_to_many('enclosed_by', 'encloses')
@one_to_many('encloses', 'enclosed_by')
-class Place(HasLinks, Entity):
+class Place(HasLinks, UserFacingEntity, Entity):
def __init__(self, place_id: Optional[str], names: List[PlaceName], *args, **kwargs):
super().__init__(place_id, *args, **kwargs)
self._names = names
@@ -354,6 +366,10 @@ def events(self) -> None:
def entity_type_label(cls) -> str:
return _('Place')
+ @classmethod
+ def entity_type_label_plural(cls) -> str:
+ return _('Places')
+
@property
def names(self) -> List[PlaceName]:
return self._names
@@ -367,11 +383,11 @@ def coordinates(self, coordinates: Point):
self._coordinates = coordinates
@property
- def label(self) -> Optional[str]:
+ def label(self) -> str:
# @todo Negotiate this by locale and date.
with suppress(IndexError):
return self.names[0].name
- return None
+ return self._default_label()
class PresenceRole:
@@ -436,14 +452,10 @@ def __init__(self, person: Optional[Person], role: PresenceRole, event: Optional
self.role = role
self.event = event # type: ignore
- @classmethod
- def entity_type_label(cls) -> str:
- return _('Presence')
-
@many_to_one('place', 'events')
@one_to_many('presences', 'event')
-class Event(Dated, HasFiles, HasCitations, Described, HasPrivacy, Entity):
+class Event(Dated, HasFiles, HasCitations, Described, HasPrivacy, UserFacingEntity, Entity):
place: Optional[Place]
def __init__(self, event_id: Optional[str], event_type: EventType, date: Optional[Datey] = None, *args, **kwargs):
@@ -467,6 +479,10 @@ def presences(self) -> None:
def entity_type_label(cls) -> str:
return _('Event')
+ @classmethod
+ def entity_type_label_plural(cls) -> str:
+ return _('Events')
+
def __repr__(self) -> str:
return '<%s.%s(%s, date=%s)>' % (self.__class__.__module__, self.__class__.__name__, repr(self.type), repr(self.date))
@@ -496,6 +512,8 @@ class PersonName(Localized, HasCitations, Entity):
def __init__(self, person: Optional[Person], individual: Optional[str] = None, affiliation: Optional[str] = None, *args, **kwargs):
super().__init__(*args, **kwargs)
+ if not individual and not affiliation:
+ raise ValueError('The individual and affiliation names must not both be empty.')
self._individual = individual
self._affiliation = affiliation
# Set the person association last, because the association requires comparisons, and self.__eq__() uses the
@@ -506,6 +524,10 @@ def __init__(self, person: Optional[Person], individual: Optional[str] = None, a
def entity_type_label(cls) -> str:
return _('Person name')
+ @classmethod
+ def entity_type_label_plural(cls) -> str:
+ return _('Person names')
+
def __repr__(self) -> str:
return '<%s.%s(%s, %s, %s)>' % (self.__class__.__module__, self.__class__.__name__, self.individual, self.affiliation, repr(self.person))
@@ -532,8 +554,11 @@ def affiliation(self) -> Optional[str]:
return self._affiliation
@property
- def label(self) -> Optional[str]:
- return _('{individual_name} {affiliation_name}')
+ def label(self) -> str:
+ return _('{individual_name} {affiliation_name}').format(
+ individual_name='…' if not self.individual else self.individual,
+ affiliation_name='…' if not self.affiliation else self.affiliation,
+ )
@total_ordering
@@ -541,9 +566,8 @@ def label(self) -> Optional[str]:
@many_to_many('children', 'parents')
@one_to_many('presences', 'person')
@one_to_many('names', 'person')
-class Person(HasFiles, HasCitations, HasLinks, HasPrivacy, Entity):
+class Person(HasFiles, HasCitations, HasLinks, HasPrivacy, UserFacingEntity, Entity):
def __init__(self, person_id: Optional[str], *args, **kwargs):
-
super().__init__(person_id, *args, **kwargs)
@property
@@ -598,6 +622,10 @@ def names(self) -> None:
def entity_type_label(cls) -> str:
return _('Person')
+ @classmethod
+ def entity_type_label_plural(cls) -> str:
+ return _('People')
+
def __eq__(self, other: Any) -> bool:
if not isinstance(other, Person):
return NotImplemented # pragma: no cover
@@ -656,8 +684,8 @@ def associated_files(self) -> Iterable[File]:
yield file
@property
- def label(self) -> Optional[str]:
- return self.name.label if self.name else None
+ def label(self) -> str:
+ return self.name.label if self.name else self._default_label()
class Ancestry:
diff --git a/betty/openapi.py b/betty/openapi.py
index 98f08b202..30a19ec51 100644
--- a/betty/openapi.py
+++ b/betty/openapi.py
@@ -4,7 +4,6 @@
from betty.app import App
from betty.media_type import EXTENSIONS
-
if TYPE_CHECKING:
from betty.builtins import _
diff --git a/betty/project.py b/betty/project.py
index a056c775e..27f46614d 100644
--- a/betty/project.py
+++ b/betty/project.py
@@ -3,28 +3,52 @@
from collections import OrderedDict
from contextlib import suppress
from pathlib import Path
-from typing import TYPE_CHECKING, Optional, Type, List, Iterable, Dict, Any, Sequence
+from typing import TYPE_CHECKING, Optional, Type, List, Iterable, Any, Sequence, cast
from urllib.parse import urlparse
from babel.core import parse_locale, Locale
from reactives import reactive, scope
-from reactives.factory.type import ReactiveInstance
from betty.app import Extension, ConfigurableExtension
from betty.classtools import repr_instance
-from betty.config import Configuration, DumpedConfiguration, ConfigurationError, minimize_dumped_configuration, \
- Configurable, FileBasedConfiguration
-from betty.error import ensure_context
+from betty.config import Configuration, DumpedConfigurationImport, Configurable, FileBasedConfiguration, \
+ ConfigurationMapping, DumpedConfigurationExport, DumpedConfigurationDict
+from betty.config.dump import minimize, minimize_dict
+from betty.config.load import ConfigurationValidationError, Loader, Field
+from betty.config.validate import validate, validate_positive_number
from betty.importlib import import_any
from betty.locale import bcp_47_to_rfc_1766
-from betty.model import Entity, get_entity_type_name
-from betty.model.ancestry import Ancestry
+from betty.model import Entity, get_entity_type_name, UserFacingEntity, get_entity_type as model_get_entity_type, \
+ EntityTypeImportError, EntityTypeInvalidError, EntityTypeError
+from betty.model.ancestry import Ancestry, Person, Event, Place, Source
from betty.typing import Void
+try:
+ from typing_extensions import TypeGuard
+except ModuleNotFoundError:
+ from typing import TypeGuard # type: ignore
+
if TYPE_CHECKING:
from betty.builtins import _
+def get_entity_type(entity_type_definition: Any) -> Type[Entity]:
+ try:
+ return model_get_entity_type(entity_type_definition)
+ except EntityTypeImportError:
+ raise ConfigurationValidationError(_('Cannot find and import "{entity_type}".').format(
+ entity_type=str(entity_type_definition),
+ ))
+ except EntityTypeInvalidError:
+ raise ConfigurationValidationError(_('"{entity_type}" is not a valid Betty entity type.').format(
+ entity_type=str(entity_type_definition),
+ ))
+ except EntityTypeError:
+ raise ConfigurationValidationError(_('Cannot determine the entity type for "{entity_type}". Did you perhaps make a typo, or could it be that the entity type comes from another package that is not yet installed?').format(
+ entity_type=str(entity_type_definition),
+ ))
+
+
class EntityReference(Configuration):
def __init__(self, entity_type: Optional[Type[Entity]] = None, entity_id: Optional[str] = None, /, entity_type_constraint: Optional[Type[Entity]] = None):
super().__init__()
@@ -60,29 +84,30 @@ def entity_id(self) -> None:
def entity_type_constraint(self) -> Optional[Type[Entity]]:
return self._entity_type_constraint
- def load(self, dumped_configuration: DumpedConfiguration) -> None:
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
if self._entity_type_constraint is None:
- if not isinstance(dumped_configuration, dict):
- raise ConfigurationError(_('The entity reference must be a mapping (dictionary).'))
- with ensure_context('entity_type'):
- if 'entity_type' not in dumped_configuration:
- raise ConfigurationError(_('The entity type is required.'))
- try:
- self._entity_type = import_any(dumped_configuration['entity_type'])
- except ImportError as e:
- raise ConfigurationError(e)
- with ensure_context('entity_id'):
- if 'entity_id' not in dumped_configuration:
- raise ConfigurationError(_('The entity ID is required.'))
- entity_id = dumped_configuration['entity_id']
- else:
- entity_id = dumped_configuration
- if not isinstance(entity_id, str):
- raise ConfigurationError(_('The entity ID must be a string.'))
- self._entity_id = entity_id
- self.react.trigger()
-
- def dump(self) -> DumpedConfiguration:
+ loader.assert_record(dumped_configuration, {
+ 'entity_type': Field(
+ True,
+ self._load_entity_type, # type: ignore
+ ),
+ 'entity_id': Field(
+ True,
+ loader.assert_str, # type: ignore
+ lambda x: loader.assert_setattr(self, 'entity_id', x),
+ ),
+ })
+ elif loader.assert_str(dumped_configuration):
+ loader.assert_setattr(self, 'entity_id', dumped_configuration)
+
+ def _load_entity_type(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> TypeGuard[str]:
+ with loader.context() as errors:
+ if loader.assert_str(dumped_configuration):
+ with loader.catch():
+ loader.assert_setattr(self, 'entity_type', get_entity_type(dumped_configuration))
+ return errors.valid
+
+ def dump(self) -> DumpedConfigurationExport:
if self._entity_id is None:
return Void
if self._entity_type_constraint is None:
@@ -101,7 +126,7 @@ def __eq__(self, other) -> bool:
return self.entity_type == other.entity_type and self.entity_id == other.entity_id
-class EntityReferences(Configuration):
+class EntityReferenceCollection(Configuration):
def __init__(self, entity_references: Optional[List[EntityReference]] = None, /, entity_type_constraint: Optional[Type[Entity]] = None):
super().__init__()
self._entity_type_constraint = entity_type_constraint
@@ -128,37 +153,40 @@ def __delitem__(self, key):
def append(self, entity_reference: EntityReference) -> None:
if self._entity_type_constraint:
if entity_reference.entity_type != self._entity_type_constraint:
- raise ConfigurationError(_('The entity reference must be for an entity of type {expected_entity_type_name} ({expected_entity_type_label}), but instead is for an entity of type {actual_entity_type_name} ({actual_entity_type_label})').format(
+ raise ConfigurationValidationError(_('The entity reference must be for an entity of type {expected_entity_type_name} ({expected_entity_type_label}), but instead is for an entity of type {actual_entity_type_name} ({actual_entity_type_label})').format(
expected_entity_type_name=get_entity_type_name(self._entity_type_constraint),
- expected_entity_type_label=self._entity_type_constraint.entity_type_label(),
+ expected_entity_type_label=self._entity_type_constraint.entity_type_label() if issubclass(self._entity_type_constraint, UserFacingEntity) else get_entity_type_name(self._entity_type_constraint),
actual_entity_type_name=get_entity_type_name(self._entity_type_constraint),
- actual_entity_type_label=self._entity_type_constraint.entity_type_label(),
+ actual_entity_type_label=self._entity_type_constraint.entity_type_label() if issubclass(self._entity_type_constraint, UserFacingEntity) else get_entity_type_name(self._entity_type_constraint),
))
entity_reference = EntityReference(None, entity_reference.entity_id, self._entity_type_constraint)
self._entity_references.append(entity_reference)
self.react.trigger()
- def load(self, dumped_configuration: DumpedConfiguration) -> None:
- if not isinstance(dumped_configuration, list):
- raise ConfigurationError(_('Entity references must be a list.'))
- self._entity_references.clear()
- for i, dumped_entity_reference_configuration in enumerate(dumped_configuration):
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
+ if loader.assert_list(dumped_configuration):
+ loader.on_commit(self._entity_references.clear)
+ loader.assert_sequence(
+ dumped_configuration,
+ self._load_entity_reference, # type: ignore
+ )
+
+ def _load_entity_reference(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> TypeGuard[DumpedConfigurationDict[DumpedConfigurationImport]]:
+ with loader.context() as errors:
entity_reference = EntityReference(entity_type_constraint=self._entity_type_constraint)
- with ensure_context(str(i)):
- entity_reference.load(dumped_entity_reference_configuration)
- self._entity_references.append(entity_reference)
- self.react.trigger()
+ entity_reference.load(dumped_configuration, loader)
+ loader.on_commit(lambda: self._entity_references.append(entity_reference))
+ return errors.valid
- def dump(self) -> DumpedConfiguration:
- return minimize_dumped_configuration([
+ def dump(self) -> DumpedConfigurationExport:
+ return minimize([
entity_reference.dump()
for entity_reference
in self._entity_references
])
-@reactive
-class ProjectExtensionConfiguration(ReactiveInstance):
+class ExtensionConfiguration(Configuration):
def __init__(self, extension_type: Type[Extension], enabled: bool = True, extension_configuration: Optional[Configuration] = None):
super().__init__()
self._extension_type = extension_type
@@ -169,15 +197,6 @@ def __init__(self, extension_type: Type[Extension], enabled: bool = True, extens
extension_configuration.react(self)
self._extension_configuration = extension_configuration
- def __repr__(self):
- return '<{}.{} extension_type={}, enabled={}, extension_configuration={}>'.format(
- self.__class__.__module__,
- self.__class__.__name__,
- self.extension_type.name(),
- self.enabled,
- repr(self.extension_configuration,)
- )
-
def __eq__(self, other):
if not isinstance(other, self.__class__):
return NotImplemented
@@ -206,137 +225,131 @@ def enabled(self, enabled: bool) -> None:
def extension_configuration(self) -> Optional[Configuration]:
return self._extension_configuration
-
-class ProjectExtensionsConfiguration(Configuration):
- def __init__(self, configurations: Optional[Iterable[ProjectExtensionConfiguration]] = None):
- super().__init__()
- self._configurations: Dict[Type[Extension], ProjectExtensionConfiguration] = OrderedDict()
- if configurations is not None:
- for configuration in configurations:
- self.add(configuration)
-
- def __contains__(self, item):
- return item in self._configurations
-
- @scope.register_self
- def __getitem__(self, extension_type: Type[Extension]) -> ProjectExtensionConfiguration:
- return self._configurations[extension_type]
-
- def __delitem__(self, extension_type: Type[Extension]) -> None:
- self.remove(extension_type)
-
- @scope.register_self
- def __iter__(self) -> Iterable[ProjectExtensionConfiguration]:
- return (configuration for configuration in self._configurations.values())
-
- @scope.register_self
- def __len__(self) -> int:
- return len(self._configurations)
-
- def __repr__(self):
- return repr_instance(self, configurations=list(self._configurations.values()))
-
- @scope.register_self
- def __eq__(self, other):
- if not isinstance(other, ProjectExtensionsConfiguration):
- return NotImplemented
- return self._configurations == other._configurations
-
- def remove(self, *extension_types: Type[Extension]) -> None:
- for extension_type in extension_types:
- with suppress(KeyError):
- self._configurations[extension_type].react.shutdown(self)
- del self._configurations[extension_type]
- self.react.trigger()
-
- def clear(self) -> None:
- self.remove(*self._configurations.keys())
-
- def add(self, *configurations: ProjectExtensionConfiguration) -> None:
- for configuration in configurations:
- if configuration.extension_type not in self._configurations:
- self._configurations[configuration.extension_type] = configuration
- configuration.react(self)
- self.react.trigger()
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
+ loader.assert_record(dumped_configuration, {
+ 'enabled': Field(
+ False,
+ loader.assert_bool, # type: ignore
+ lambda x: loader.assert_setattr(self, 'enabled', x),
+ ),
+ 'configuration': Field(
+ False,
+ self._load_extension_configuration, # type: ignore
+ ),
+ })
+
+ def _load_extension_configuration(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> TypeGuard[DumpedConfigurationDict[DumpedConfigurationImport]]:
+ extension_type = self.extension_type
+ if issubclass(extension_type, ConfigurableExtension):
+ cast(ExtensionConfiguration, self.extension_configuration).load(dumped_configuration, loader)
+ return True
+ loader.error(ConfigurationValidationError(_('{extension_type} is not configurable.').format(
+ extension_type=extension_type.name(),
+ )))
+ return False
+
+ def dump(self) -> DumpedConfigurationExport:
+ return minimize_dict({
+ 'enabled': self.enabled,
+ 'configuration': self.extension_configuration.dump() if issubclass(self.extension_type, Configurable) and self.extension_configuration else Void,
+ }, True)
+
+
+class ExtensionConfigurationMapping(ConfigurationMapping[Type[Extension], ExtensionConfiguration]):
+ def _get_key(self, configuration: ExtensionConfiguration) -> Type[Extension]:
+ return configuration.extension_type
+
+ def _load_key(self, dumped_configuration_key: str) -> Type[Extension]:
+ try:
+ return import_any(dumped_configuration_key)
+ except ImportError:
+ raise ConfigurationValidationError(_('{extension_type} is not a valid Betty extension.').format(
+ extension_type=dumped_configuration_key,
+ ))
+
+ def _dump_key(self, configuration_key: Type[Extension]) -> str:
+ return configuration_key.name()
+
+ def _default_configuration_item(self, configuration_key: Type[Extension]) -> ExtensionConfiguration:
+ return ExtensionConfiguration(configuration_key)
def enable(self, *extension_types: Type[Extension]):
for extension_type in extension_types:
try:
self._configurations[extension_type].enabled = True
except KeyError:
- self.add(ProjectExtensionConfiguration(extension_type))
+ self.add(self._default_configuration_item(extension_type))
def disable(self, *extension_types: Type[Extension]):
for extension_type in extension_types:
with suppress(KeyError):
self._configurations[extension_type].enabled = False
- self.react.trigger()
- def load(self, dumped_configuration: DumpedConfiguration) -> None:
- if not isinstance(dumped_configuration, dict):
- raise ConfigurationError(_('App extensions configuration must be a mapping (dictionary).'))
- self.clear()
+class EntityTypeConfiguration(Configuration):
+ def __init__(self, entity_type: Type[Entity], generate_html_list: Optional[bool] = None):
+ super().__init__()
+ self._entity_type = entity_type
+ self.generate_html_list = generate_html_list
- for extension_type_name in dumped_configuration:
- with ensure_context(f'`{extension_type_name}`'):
- try:
- extension_type = import_any(extension_type_name)
- except ImportError as e:
- raise ConfigurationError(e)
+ def __eq__(self, other):
+ if not isinstance(other, self.__class__):
+ return NotImplemented
+ if self.entity_type != other.entity_type:
+ return False
+ if self.generate_html_list != other.generate_html_list:
+ return False
+ return True
- if not issubclass(extension_type, Extension):
- raise ConfigurationError(_('"{extension_type_name}" is not a Betty extension.').format(extension_type_name=extension_type_name))
+ @property
+ def entity_type(self) -> Type[Entity]:
+ return self._entity_type
- dumped_extension_configuration = dumped_configuration[extension_type_name]
+ @reactive # type: ignore
+ @property
+ def generate_html_list(self) -> bool:
+ return self._generate_html_list or False
- if not isinstance(dumped_extension_configuration, dict):
- raise ConfigurationError(_('The configuration must be a mapping (dictionary).'))
+ @generate_html_list.setter
+ def generate_html_list(self, generate_html_list: Optional[bool]) -> None:
+ if not issubclass(self._entity_type, UserFacingEntity):
+ raise ValueError(f'Cannot generate HTML pages for entity types that do not inherit from {UserFacingEntity.__module__}.{UserFacingEntity.__name__}.')
+ self._generate_html_list = generate_html_list
- if 'enabled' in dumped_extension_configuration:
- if not isinstance(dumped_extension_configuration['enabled'], bool):
- raise ConfigurationError(
- 'The extension must be declared enabled (true) or disabled (false).',
- contexts=['`enabled`'],
- )
- enabled = dumped_extension_configuration['enabled']
- else:
- enabled = True
-
- if 'configuration' in dumped_extension_configuration:
- if not issubclass(extension_type, ConfigurableExtension):
- raise ConfigurationError(f'{extension_type_name} is not configurable.', contexts=['`configuration`'])
- extension_configuration = extension_type.default_configuration()
- extension_configuration.load(dumped_extension_configuration['configuration'])
- else:
- extension_configuration = None
-
- self.add(ProjectExtensionConfiguration(
- extension_type,
- enabled,
- extension_configuration,
- ))
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
+ loader.assert_record(dumped_configuration, {
+ 'generate_html_list': Field(
+ False,
+ loader.assert_bool, # type: ignore
+ lambda x: loader.assert_setattr(self, 'generate_html_list', x),
+ ),
+ })
- def dump(self) -> DumpedConfiguration:
- dumped_configuration: Any = {}
- for app_extension_configuration in self:
- extension_type = app_extension_configuration.extension_type
- dumped_configuration[extension_type.name()] = {
- 'enabled': app_extension_configuration.enabled,
- }
- if issubclass(extension_type, Configurable):
- dumped_app_extension_configuration = app_extension_configuration.extension_configuration.dump()
- if dumped_app_extension_configuration is not Void:
- dumped_configuration[extension_type.name()]['configuration'] = dumped_app_extension_configuration
- dumped_configuration[extension_type.name()] = minimize_dumped_configuration(dumped_configuration[extension_type.name()])
- return minimize_dumped_configuration(dumped_configuration)
+ def dump(self) -> DumpedConfigurationExport:
+ return minimize_dict({
+ 'generate_html_list': Void if self._generate_html_list is None else self._generate_html_list,
+ }, True)
+
+
+class EntityTypeConfigurationMapping(ConfigurationMapping[Type[Entity], EntityTypeConfiguration]):
+ def _get_key(self, configuration: EntityTypeConfiguration) -> Type[Entity]:
+ return configuration.entity_type
+
+ def _load_key(self, dumped_configuration_key: str) -> Type[Entity]:
+ return get_entity_type(dumped_configuration_key)
+
+ def _dump_key(self, configuration_key: Type[Entity]) -> str:
+ return get_entity_type_name(configuration_key)
+
+ def _default_configuration_item(self, configuration_key: Type[Entity]) -> EntityTypeConfiguration:
+ return EntityTypeConfiguration(configuration_key)
class LocaleConfiguration:
def __init__(self, locale: str, alias: Optional[str] = None):
self._locale = locale
if alias is not None and '/' in alias:
- raise ConfigurationError(_('Locale aliases must not contain slashes.'))
+ raise ConfigurationValidationError(_('Locale aliases must not contain slashes.'))
self._alias = alias
def __repr__(self):
@@ -365,7 +378,7 @@ def alias(self) -> str:
return self._alias
-class LocalesConfiguration(Configuration):
+class LocaleConfigurationCollection(Configuration):
def __init__(self, configurations: Optional[Sequence[LocaleConfiguration]] = None):
super().__init__()
self._configurations: OrderedDict[str, LocaleConfiguration] = OrderedDict()
@@ -377,7 +390,7 @@ def __getitem__(self, locale: str) -> LocaleConfiguration:
def __delitem__(self, locale: str) -> None:
if len(self._configurations) <= 1:
- raise ConfigurationError(_('Cannot remove the last remaining locale {locale}').format(locale=Locale.parse(bcp_47_to_rfc_1766(locale)).get_display_name()))
+ raise ConfigurationValidationError(_('Cannot remove the last remaining locale {locale}').format(locale=Locale.parse(bcp_47_to_rfc_1766(locale)).get_display_name()))
del self._configurations[locale]
self.react.trigger()
@@ -391,7 +404,7 @@ def __len__(self) -> int:
@scope.register_self
def __eq__(self, other):
- if not isinstance(other, LocalesConfiguration):
+ if not isinstance(other, LocaleConfigurationCollection):
return NotImplemented
return self._configurations == other._configurations
@@ -426,24 +439,38 @@ def default(self, configuration: LocaleConfiguration) -> None:
self._configurations.move_to_end(configuration.locale, False)
self.react.trigger()
- def load(self, dumped_configuration: DumpedConfiguration) -> None:
- if not isinstance(dumped_configuration, list):
- raise ConfigurationError(_('Locales configuration must be a list.'))
-
- if len(dumped_configuration) > 0:
- self._configurations.clear()
- for dumped_locale_configuration in dumped_configuration:
- locale = dumped_locale_configuration['locale']
- try:
- parse_locale(bcp_47_to_rfc_1766(locale))
- except ValueError:
- raise ConfigurationError(_('{locale} is not a valid IETF BCP 47 language tag.').format(locale=locale))
- self.add(LocaleConfiguration(
- locale,
- dumped_locale_configuration['alias'] if 'alias' in dumped_locale_configuration else None,
- ))
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
+ loader.on_commit(self._configurations.clear)
+ loader.assert_sequence(
+ dumped_configuration,
+ self._load_locale, # type: ignore
+ )
- def dump(self) -> DumpedConfiguration:
+ def _load_locale(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> TypeGuard[DumpedConfigurationDict[DumpedConfigurationImport]]:
+ if loader.assert_dict(dumped_configuration):
+ with loader.assert_required_key(
+ dumped_configuration,
+ 'locale',
+ loader.assert_str, # type: ignore
+ ) as (dumped_locale, valid):
+ if valid:
+ try:
+ parse_locale(
+ bcp_47_to_rfc_1766(
+ dumped_locale, # type: ignore
+ ),
+ )
+ except ValueError:
+ loader.error(ConfigurationValidationError(_('{locale} is not a valid IETF BCP 47 language tag.').format(locale=dumped_locale)))
+ else:
+ loader.on_commit(lambda: self.add(LocaleConfiguration(
+ dumped_locale, # type: ignore
+ dumped_configuration['alias'] if 'alias' in dumped_configuration else None, # type: ignore
+ )))
+ return True
+ return False
+
+ def dump(self) -> DumpedConfigurationExport:
dumped_configuration = []
for locale_configuration in self:
dumped_locale_configuration = {
@@ -457,7 +484,6 @@ def dump(self) -> DumpedConfiguration:
class ProjectConfiguration(FileBasedConfiguration):
def __init__(self, base_url: Optional[str] = None):
-
super().__init__()
self._base_url = 'https://example.com' if base_url is None else base_url
self._root_path = ''
@@ -465,10 +491,17 @@ def __init__(self, base_url: Optional[str] = None):
self._content_negotiation = False
self._title = 'Betty'
self._author: Optional[str] = None
- self._extensions = ProjectExtensionsConfiguration()
+ self._entity_types = EntityTypeConfigurationMapping([
+ EntityTypeConfiguration(Person, True),
+ EntityTypeConfiguration(Event, True),
+ EntityTypeConfiguration(Place, True),
+ EntityTypeConfiguration(Source, True),
+ ])
+ self._entity_types.react(self)
+ self._extensions = ExtensionConfigurationMapping()
self._extensions.react(self)
self._debug = False
- self._locales = LocalesConfiguration()
+ self._locales = LocaleConfigurationCollection()
self._locales.react(self)
self._lifetime_threshold = 125
@@ -514,12 +547,12 @@ def base_url(self) -> str:
return self._base_url
@base_url.setter
- def base_url(self, base_url: str):
+ def base_url(self, base_url: str) -> None:
base_url_parts = urlparse(base_url)
if not base_url_parts.scheme:
- raise ConfigurationError(_('The base URL must start with a scheme such as https://, http://, or file://.'))
+ raise ConfigurationValidationError(_('The base URL must start with a scheme such as https://, http://, or file://.'))
if not base_url_parts.netloc:
- raise ConfigurationError(_('The base URL must include a path.'))
+ raise ConfigurationValidationError(_('The base URL must include a path.'))
self._base_url = '%s://%s' % (base_url_parts.scheme, base_url_parts.netloc)
@reactive # type: ignore
@@ -528,7 +561,7 @@ def root_path(self) -> str:
return self._root_path
@root_path.setter
- def root_path(self, root_path: str):
+ def root_path(self, root_path: str) -> None:
self._root_path = root_path.strip('/')
@reactive # type: ignore
@@ -546,12 +579,12 @@ def clean_urls(self) -> bool:
return self._clean_urls or self.content_negotiation
@clean_urls.setter
- def clean_urls(self, clean_urls: bool):
+ def clean_urls(self, clean_urls: bool) -> None:
self._clean_urls = clean_urls
@reactive # type: ignore
@property
- def locales(self) -> LocalesConfiguration:
+ def locales(self) -> LocaleConfigurationCollection:
return self._locales
@property
@@ -559,7 +592,11 @@ def multilingual(self) -> bool:
return len(self.locales) > 1
@property
- def extensions(self) -> ProjectExtensionsConfiguration:
+ def entity_types(self) -> EntityTypeConfigurationMapping:
+ return self._entity_types
+
+ @property
+ def extensions(self) -> ExtensionConfigurationMapping:
return self._extensions
@reactive # type: ignore
@@ -577,63 +614,70 @@ def lifetime_threshold(self) -> int:
return self._lifetime_threshold
@lifetime_threshold.setter
- def lifetime_threshold(self, lifetime_threshold: int):
- if lifetime_threshold < 1:
- raise ConfigurationError(_('The lifetime threshold must be a positive number.'))
+ @validate(validate_positive_number)
+ def lifetime_threshold(self, lifetime_threshold: int) -> None:
self._lifetime_threshold = lifetime_threshold
- def load(self, dumped_configuration: DumpedConfiguration) -> None:
- if not isinstance(dumped_configuration, dict):
- raise ConfigurationError(_('Betty project configuration must be a mapping (dictionary).'))
-
- if 'base_url' not in dumped_configuration or not isinstance(dumped_configuration['base_url'], str):
- raise ConfigurationError(_('The base URL is required and must be a string.'), contexts=['`base_url`'])
- self.base_url = dumped_configuration['base_url']
-
- if 'title' in dumped_configuration:
- if not isinstance(dumped_configuration['title'], str):
- raise ConfigurationError(_('The title must be a string.'), contexts=['`title`'])
- self.title = dumped_configuration['title']
-
- if 'author' in dumped_configuration:
- if not isinstance(dumped_configuration['author'], str):
- raise ConfigurationError(_('The author must be a string.'), contexts=['`author`'])
- self.author = dumped_configuration['author']
-
- if 'root_path' in dumped_configuration:
- if not isinstance(dumped_configuration['root_path'], str):
- raise ConfigurationError(_('The root path must be a string.'), contexts=['`root_path`'])
- self.root_path = dumped_configuration['root_path']
-
- if 'clean_urls' in dumped_configuration:
- if not isinstance(dumped_configuration['clean_urls'], bool):
- raise ConfigurationError(_('Clean URLs must be enabled (true) or disabled (false) with a boolean.'), contexts=['`clean_urls`'])
- self.clean_urls = dumped_configuration['clean_urls']
-
- if 'content_negotiation' in dumped_configuration:
- if not isinstance(dumped_configuration['content_negotiation'], bool):
- raise ConfigurationError(_('Content negotiation must be enabled (true) or disabled (false) with a boolean.'), contexts=['`content_negotiation`'])
- self.content_negotiation = dumped_configuration['content_negotiation']
-
- if 'debug' in dumped_configuration:
- if not isinstance(dumped_configuration['debug'], bool):
- raise ConfigurationError(_('Debugging must be enabled (true) or disabled (false) with a boolean.'), contexts=['`debug`'])
- self.debug = dumped_configuration['debug']
-
- if 'lifetime_threshold' in dumped_configuration:
- if not isinstance(dumped_configuration['lifetime_threshold'], int):
- raise ConfigurationError(_('The lifetime threshold must be an integer.'), contexts=['`lifetime_threshold`'])
- self.lifetime_threshold = dumped_configuration['lifetime_threshold']
-
- if 'locales' in dumped_configuration:
- with ensure_context('`locales`'):
- self._locales.load(dumped_configuration['locales'])
-
- if 'extensions' in dumped_configuration:
- with ensure_context('`extensions`'):
- self._extensions.load(dumped_configuration['extensions'])
-
- def dump(self) -> DumpedConfiguration:
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
+ loader.assert_record(
+ dumped_configuration,
+ {
+ 'base_url': Field(
+ True,
+ loader.assert_str, # type: ignore
+ lambda x: loader.assert_setattr(self, 'base_url', x),
+ ),
+ 'title': Field(
+ False,
+ loader.assert_str, # type: ignore
+ lambda x: loader.assert_setattr(self, 'title', x),
+ ),
+ 'author': Field(
+ False,
+ loader.assert_str, # type: ignore
+ lambda x: loader.assert_setattr(self, 'author', x),
+ ),
+ 'root_path': Field(
+ False,
+ loader.assert_str, # type: ignore
+ lambda x: loader.assert_setattr(self, 'root_path', x),
+ ),
+ 'clean_urls': Field(
+ False,
+ loader.assert_bool, # type: ignore
+ lambda x: loader.assert_setattr(self, 'clean_urls', x),
+ ),
+ 'content_negotiation': Field(
+ False,
+ loader.assert_bool, # type: ignore
+ lambda x: loader.assert_setattr(self, 'content_negotiation', x),
+ ),
+ 'debug': Field(
+ False,
+ loader.assert_bool, # type: ignore
+ lambda x: loader.assert_setattr(self, 'debug', x),
+ ),
+ 'lifetime_threshold': Field(
+ False,
+ loader.assert_int, # type: ignore
+ lambda x: loader.assert_setattr(self, 'lifetime_threshold', x),
+ ),
+ 'locales': Field(
+ False,
+ self._locales.load, # type: ignore
+ ),
+ 'extensions': Field(
+ False,
+ self._extensions.load, # type: ignore
+ ),
+ 'entity_types': Field(
+ False,
+ self._entity_types.load, # type: ignore
+ ),
+ },
+ )
+
+ def dump(self) -> DumpedConfigurationExport:
dumped_configuration = {
'base_url': self.base_url,
'title': self.title,
@@ -650,10 +694,11 @@ def dump(self) -> DumpedConfiguration:
dumped_configuration['debug'] = self.debug
dumped_configuration['locales'] = self.locales.dump()
dumped_configuration['extensions'] = self.extensions.dump()
+ dumped_configuration['entity_types'] = self.entity_types.dump()
if self.lifetime_threshold is not None:
dumped_configuration['lifetime_threshold'] = self.lifetime_threshold
- return minimize_dumped_configuration(dumped_configuration)
+ return minimize(dumped_configuration)
class Project(Configurable[ProjectConfiguration]):
diff --git a/betty/serve.py b/betty/serve.py
index 1c9618528..0dbba660e 100644
--- a/betty/serve.py
+++ b/betty/serve.py
@@ -13,7 +13,6 @@
from betty.error import UserFacingError
from betty.os import ChDir
-
if TYPE_CHECKING:
from betty.builtins import _
diff --git a/betty/tests/anonymizer/test___init__.py b/betty/tests/anonymizer/test___init__.py
index a7cbaa3df..0e529f993 100644
--- a/betty/tests/anonymizer/test___init__.py
+++ b/betty/tests/anonymizer/test___init__.py
@@ -8,7 +8,7 @@
from betty.model.ancestry import Ancestry, Person, File, Source, Citation, PersonName, Presence, Event, Subject, \
HasCitations
from betty.model.event_type import Birth
-from betty.project import ProjectExtensionConfiguration
+from betty.project import ExtensionConfiguration
class TestAnonymousSource:
@@ -333,7 +333,7 @@ async def test_post_parse(self) -> None:
person.private = True
PersonName(person, 'Jane', 'Dough')
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Anonymizer))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Anonymizer))
app.project.ancestry.entities.append(person)
await load(app)
assert 0 == len(person.names)
diff --git a/betty/tests/app/test___init__.py b/betty/tests/app/test___init__.py
index 66e333f54..51571e7fe 100644
--- a/betty/tests/app/test___init__.py
+++ b/betty/tests/app/test___init__.py
@@ -4,8 +4,9 @@
from betty.app import Extension, App, CyclicDependencyError
from betty.app.extension import ConfigurableExtension as GenericConfigurableExtension
-from betty.config import Configuration, ConfigurationError, DumpedConfiguration
-from betty.project import ProjectExtensionConfiguration
+from betty.config import Configuration, DumpedConfigurationImport, DumpedConfigurationExport
+from betty.config.load import Loader
+from betty.project import ExtensionConfiguration
class Tracker:
@@ -27,14 +28,16 @@ def __init__(self, check):
super().__init__()
self.check = check
- def load(self, dumped_configuration: DumpedConfiguration) -> None:
- if not isinstance(dumped_configuration, dict):
- raise ConfigurationError
- if 'check' not in dumped_configuration:
- raise ConfigurationError
- self.check = dumped_configuration['check']
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
+ with loader.assert_required_key(
+ dumped_configuration,
+ 'check',
+ loader.assert_int, # type: ignore
+ ) as (dumped_check, valid):
+ if valid:
+ loader.assert_setattr(self, 'check', dumped_check)
- def dump(self) -> DumpedConfiguration:
+ def dump(self) -> DumpedConfigurationExport:
return {
'check': self.check
}
@@ -91,13 +94,13 @@ def default_configuration(cls) -> ConfigurableExtensionConfiguration:
class TestApp:
def test_extensions_with_one_extension(self) -> None:
with App() as sut:
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(NonConfigurableExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(NonConfigurableExtension))
assert isinstance(sut.extensions[NonConfigurableExtension], NonConfigurableExtension)
def test_extensions_with_one_configurable_extension(self) -> None:
check = 1337
with App() as sut:
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(ConfigurableExtension, True, ConfigurableExtensionConfiguration(
+ sut.project.configuration.extensions.add(ExtensionConfiguration(ConfigurableExtension, True, ConfigurableExtensionConfiguration(
check=check,
)))
assert isinstance(sut.extensions[ConfigurableExtension], ConfigurableExtension)
@@ -105,7 +108,7 @@ def test_extensions_with_one_configurable_extension(self) -> None:
async def test_extensions_with_one_extension_with_single_chained_dependency(self) -> None:
with App() as sut:
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(DependsOnNonConfigurableExtensionExtensionExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(DependsOnNonConfigurableExtensionExtensionExtension))
carrier: List[TrackableExtension] = []
await sut.dispatcher.dispatch(Tracker)(carrier)
assert 3 == len(carrier)
@@ -115,8 +118,8 @@ async def test_extensions_with_one_extension_with_single_chained_dependency(self
async def test_extensions_with_multiple_extensions_with_duplicate_dependencies(self) -> None:
with App() as sut:
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(DependsOnNonConfigurableExtensionExtension))
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(AlsoDependsOnNonConfigurableExtensionExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(DependsOnNonConfigurableExtensionExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(AlsoDependsOnNonConfigurableExtensionExtension))
carrier: List[TrackableExtension] = []
await sut.dispatcher.dispatch(Tracker)(carrier)
assert 3 == len(carrier)
@@ -127,13 +130,13 @@ async def test_extensions_with_multiple_extensions_with_duplicate_dependencies(s
def test_extensions_with_multiple_extensions_with_cyclic_dependencies(self) -> None:
with pytest.raises(CyclicDependencyError):
with App() as sut:
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(CyclicDependencyOneExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(CyclicDependencyOneExtension))
sut.extensions
async def test_extensions_with_comes_before_with_other_extension(self) -> None:
with App() as sut:
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(NonConfigurableExtension))
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(ComesBeforeNonConfigurableExtensionExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(NonConfigurableExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(ComesBeforeNonConfigurableExtensionExtension))
carrier: List[TrackableExtension] = []
await sut.dispatcher.dispatch(Tracker)(carrier)
assert 2 == len(carrier)
@@ -142,7 +145,7 @@ async def test_extensions_with_comes_before_with_other_extension(self) -> None:
async def test_extensions_with_comes_before_without_other_extension(self) -> None:
with App() as sut:
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(ComesBeforeNonConfigurableExtensionExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(ComesBeforeNonConfigurableExtensionExtension))
carrier: List[TrackableExtension] = []
await sut.dispatcher.dispatch(Tracker)(carrier)
assert 1 == len(carrier)
@@ -150,8 +153,8 @@ async def test_extensions_with_comes_before_without_other_extension(self) -> Non
async def test_extensions_with_comes_after_with_other_extension(self) -> None:
with App() as sut:
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(ComesAfterNonConfigurableExtensionExtension))
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(NonConfigurableExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(ComesAfterNonConfigurableExtensionExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(NonConfigurableExtension))
carrier: List[TrackableExtension] = []
await sut.dispatcher.dispatch(Tracker)(carrier)
assert 2 == len(carrier)
@@ -160,7 +163,7 @@ async def test_extensions_with_comes_after_with_other_extension(self) -> None:
async def test_extensions_with_comes_after_without_other_extension(self) -> None:
with App() as sut:
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(ComesAfterNonConfigurableExtensionExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(ComesAfterNonConfigurableExtensionExtension))
carrier: List[TrackableExtension] = []
await sut.dispatcher.dispatch(Tracker)(carrier)
assert 1 == len(carrier)
@@ -170,12 +173,12 @@ def test_extensions_addition_to_configuration(self) -> None:
with App() as sut:
# Get the extensions before making configuration changes to warm the cache.
sut.extensions
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(NonConfigurableExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(NonConfigurableExtension))
assert isinstance(sut.extensions[NonConfigurableExtension], NonConfigurableExtension)
def test_extensions_removal_from_configuration(self) -> None:
with App() as sut:
- sut.project.configuration.extensions.add(ProjectExtensionConfiguration(NonConfigurableExtension))
+ sut.project.configuration.extensions.add(ExtensionConfiguration(NonConfigurableExtension))
# Get the extensions before making configuration changes to warm the cache.
sut.extensions
del sut.project.configuration.extensions[NonConfigurableExtension]
diff --git a/betty/tests/cleaner/test___init__.py b/betty/tests/cleaner/test___init__.py
index efad3e4d2..98b3f48e4 100644
--- a/betty/tests/cleaner/test___init__.py
+++ b/betty/tests/cleaner/test___init__.py
@@ -4,14 +4,14 @@
from betty.model.ancestry import Ancestry, Person, Place, Presence, PlaceName, File, PersonName, Subject, \
Enclosure, Source, Citation, Event
from betty.model.event_type import Birth
-from betty.project import ProjectExtensionConfiguration
+from betty.project import ExtensionConfiguration
class TestCleaner:
async def test_post_parse(self) -> None:
event = Event('E0', Birth())
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Cleaner))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Cleaner))
app.project.ancestry.entities.append(event)
await load(app)
assert [] == list(app.project.ancestry.entities[Event])
diff --git a/betty/tests/config/test___init__.py b/betty/tests/config/test___init__.py
new file mode 100644
index 000000000..0c0dd577a
--- /dev/null
+++ b/betty/tests/config/test___init__.py
@@ -0,0 +1,192 @@
+from contextlib import contextmanager
+from tempfile import NamedTemporaryFile
+from typing import Iterator, Type, Union, Optional, Tuple, Iterable, List, Any
+
+import pytest
+from reactives.tests import assert_reactor_called, assert_in_scope, assert_scope_empty
+
+from betty.app import App
+from betty.config import FileBasedConfiguration, ConfigurationMapping, Configuration, DumpedConfigurationExport, \
+ DumpedConfigurationImport
+from betty.config.error import ConfigurationError, ConfigurationErrorCollection
+from betty.config.load import ConfigurationFormatError, Loader
+
+
+def assert_configuration_error(
+ actual_error: Union[ConfigurationError, ConfigurationErrorCollection],
+ error: Optional[Union[ConfigurationError, Type[ConfigurationError]]] = None,
+ error_type: Optional[Type[ConfigurationError]] = None,
+ error_message: Optional[str] = None,
+ error_contexts: Optional[Tuple[str, ...]] = None,
+) -> List[ConfigurationError]:
+ actual_errors: Iterable[ConfigurationError]
+ if isinstance(actual_error, ConfigurationErrorCollection):
+ actual_errors = actual_error.flatten()
+ else:
+ actual_errors = [actual_error]
+
+ expected_error_type = None
+ expected_error_message = None
+ expected_error_contexts = None
+ if error:
+ expected_error_type = type(error)
+ expected_error_message = str(error)
+ expected_error_contexts = error.contexts
+ if error_type:
+ expected_error_type = error_type
+ if not expected_error_type:
+ expected_error_type = ConfigurationError
+ if error_message:
+ expected_error_message = error_message
+ if error_type:
+ expected_error_contexts = error_contexts
+
+ errors = [
+ actual_error
+ for actual_error
+ in actual_errors
+ if isinstance(actual_error, expected_error_type) or expected_error_message and str(actual_error).startswith(expected_error_message) or expected_error_contexts and expected_error_contexts == actual_error.contexts
+ ]
+ if errors:
+ return errors
+ raise AssertionError('Failed raising a configuration error.')
+
+
+@contextmanager
+def raises_configuration_error(*args, **kwargs) -> Iterator[Loader]:
+ loader = Loader()
+ try:
+ with App():
+ yield loader
+ finally:
+ assert_configuration_error(loader.errors, *args, **kwargs)
+
+
+@contextmanager
+def raises_no_configuration_errors(*args, **kwargs) -> Iterator[Loader]:
+ loader = Loader()
+ try:
+ with App():
+ yield loader
+ finally:
+ try:
+ errors = assert_configuration_error(loader.errors, *args, **kwargs)
+ except AssertionError:
+ loader.commit()
+ return
+ raise AssertionError('Failed not to raise a configuration error') from errors[0]
+
+
+class TestFileBasedConfiguration:
+ def test_configuration_file_path_should_error_unknown_format(self) -> None:
+ configuration = FileBasedConfiguration()
+ with NamedTemporaryFile(mode='r+', suffix='.abc') as f:
+ with pytest.raises(ConfigurationFormatError):
+ configuration.configuration_file_path = f.name
+
+
+class ConfigurationMappingTestDummyConfiguration(Configuration):
+ def __init__(self, configuration_key: str, configuration_value: int):
+ super().__init__()
+ self.key = configuration_key
+ self.value = configuration_value
+
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
+ raise NotImplementedError
+
+ def dump(self) -> DumpedConfigurationExport:
+ raise NotImplementedError
+
+
+class ConfigurationMappingTestDummy(ConfigurationMapping[str, ConfigurationMappingTestDummyConfiguration]):
+ def _get_key(self, configuration: ConfigurationMappingTestDummyConfiguration) -> str:
+ return configuration.key
+
+ def _load_key(self, dumped_configuration_key: str) -> str:
+ return dumped_configuration_key
+
+ def _dump_key(self, configuration_key: str) -> str:
+ return configuration_key
+
+ def _default_configuration_item(self, configuration_key: str) -> ConfigurationMappingTestDummyConfiguration:
+ return ConfigurationMappingTestDummyConfiguration('foo', 123)
+
+
+class TestConfigurationMapping:
+ def test_getitem(self) -> None:
+ configuration = ConfigurationMappingTestDummyConfiguration('foo', 123)
+ sut = ConfigurationMappingTestDummy([configuration])
+ with assert_in_scope(sut):
+ assert configuration == sut['foo']
+
+ def test_delitem(self) -> None:
+ configuration = ConfigurationMappingTestDummyConfiguration('foo', 123)
+ sut = ConfigurationMappingTestDummy([configuration])
+ with assert_scope_empty():
+ with assert_reactor_called(sut):
+ del sut['foo']
+ assert [] == list(sut)
+ assert [] == list(configuration.react._reactors)
+
+ def test_iter(self) -> None:
+ configuration_a = ConfigurationMappingTestDummyConfiguration('foo', 123)
+ configuration_b = ConfigurationMappingTestDummyConfiguration('bar', 456)
+ sut = ConfigurationMappingTestDummy([
+ configuration_a,
+ configuration_b,
+ ])
+ with assert_in_scope(sut):
+ assert [configuration_a, configuration_b] == list(iter(sut))
+
+ def test_len(self) -> None:
+ configuration_a = ConfigurationMappingTestDummyConfiguration('foo', 123)
+ configuration_b = ConfigurationMappingTestDummyConfiguration('bar', 456)
+ sut = ConfigurationMappingTestDummy([
+ configuration_a,
+ configuration_b,
+ ])
+ with assert_in_scope(sut):
+ assert 2 == len(sut)
+
+ def test_eq(self) -> None:
+ configuration_a = ConfigurationMappingTestDummyConfiguration('foo', 123)
+ configuration_b = ConfigurationMappingTestDummyConfiguration('bar', 456)
+ sut = ConfigurationMappingTestDummy([
+ configuration_a,
+ configuration_b,
+ ])
+ other = ConfigurationMappingTestDummy([
+ configuration_a,
+ configuration_b,
+ ])
+ with assert_in_scope(sut):
+ assert other == sut
+
+ def test_add(self) -> None:
+ sut = ConfigurationMappingTestDummy()
+ configuration = ConfigurationMappingTestDummyConfiguration('foo', 123)
+ with assert_scope_empty():
+ with assert_reactor_called(sut):
+ sut.add(configuration)
+ assert configuration == sut['foo']
+ with assert_reactor_called(sut):
+ configuration.react.trigger()
+
+
+class ConfigurationCollectionMappingTestBase:
+ def test(self) -> None:
+ sut = self.get_sut()
+ configuration_key = self.get_configuration_key()
+ configuration = sut._default_configuration_item(configuration_key)
+ assert isinstance(configuration, Configuration)
+ assert configuration_key == sut._get_key(configuration)
+ dumped_configuration_key = sut._dump_key(configuration_key)
+ assert isinstance(dumped_configuration_key, str)
+ loaded_configuration_key = sut._load_key(dumped_configuration_key)
+ assert configuration_key == loaded_configuration_key
+
+ def get_sut(self) -> ConfigurationMapping:
+ raise NotImplementedError
+
+ def get_configuration_key(self) -> Any:
+ raise NotImplementedError
diff --git a/betty/tests/config/test_error.py b/betty/tests/config/test_error.py
new file mode 100644
index 000000000..18b090101
--- /dev/null
+++ b/betty/tests/config/test_error.py
@@ -0,0 +1,66 @@
+from betty.config.error import ConfigurationError, ConfigurationErrorCollection
+
+
+class TestConfigurationError:
+ def test__str__without_contexts(self) -> None:
+ sut = ConfigurationError('Something went wrong!')
+ assert 'Something went wrong!' == str(sut)
+
+ def test__str___with_contexts(self) -> None:
+ sut = ConfigurationError('Something went wrong!')
+ sut = sut.with_context('Somewhere, at some point...')
+ sut = sut.with_context('Somewhere else, too...')
+ assert 'Something went wrong!\n- Somewhere, at some point...\n- Somewhere else, too...' == str(sut)
+
+ def test_with_context(self) -> None:
+ sut = ConfigurationError('Something went wrong!')
+ sut_with_context = sut.with_context('Somewhere, at some point...')
+ assert sut != sut_with_context
+ assert sut_with_context.contexts == ('Somewhere, at some point...',)
+
+
+class TestConfigurationErrorCollection:
+ def test__str__without_errors(self) -> None:
+ sut: ConfigurationErrorCollection[ConfigurationError] = ConfigurationErrorCollection()
+ assert '' == str(sut)
+
+ def test__str___with_one_error(self) -> None:
+ sut: ConfigurationErrorCollection[ConfigurationError] = ConfigurationErrorCollection()
+ sut.append(ConfigurationError('Something went wrong!'))
+ assert 'Something went wrong!' == str(sut)
+
+ def test__str___with_multiple_errors(self) -> None:
+ sut: ConfigurationErrorCollection[ConfigurationError] = ConfigurationErrorCollection()
+ sut.append(ConfigurationError('Something went wrong!'))
+ sut.append(ConfigurationError('Something else went wrong, too!'))
+ assert 'Something went wrong!\nSomething else went wrong, too!' == str(sut)
+
+ def test__str___with_predefined_contexts(self) -> None:
+ sut: ConfigurationErrorCollection[ConfigurationError] = ConfigurationErrorCollection()
+ sut = sut.with_context('Somewhere, at some point...')
+ sut = sut.with_context('Somewhere else, too...')
+ error_1 = ConfigurationError('Something went wrong!')
+ error_2 = ConfigurationError('Something else went wrong, too!')
+ sut.append(error_1)
+ sut.append(error_2)
+ assert not len(error_1.contexts)
+ assert not len(error_2.contexts)
+ assert 'Something went wrong!\n- Somewhere, at some point...\n- Somewhere else, too...\nSomething else went wrong, too!\n- Somewhere, at some point...\n- Somewhere else, too...' == str(sut)
+
+ def test__str___with_postdefined_contexts(self) -> None:
+ sut: ConfigurationErrorCollection[ConfigurationError] = ConfigurationErrorCollection()
+ error_1 = ConfigurationError('Something went wrong!')
+ error_2 = ConfigurationError('Something else went wrong, too!')
+ sut.append(error_1)
+ sut.append(error_2)
+ sut = sut.with_context('Somewhere, at some point...')
+ sut = sut.with_context('Somewhere else, too...')
+ assert not len(error_1.contexts)
+ assert not len(error_2.contexts)
+ assert 'Something went wrong!\n- Somewhere, at some point...\n- Somewhere else, too...\nSomething else went wrong, too!\n- Somewhere, at some point...\n- Somewhere else, too...' == str(sut)
+
+ def test_with_context(self) -> None:
+ sut: ConfigurationErrorCollection[ConfigurationError] = ConfigurationErrorCollection()
+ sut_with_context = sut.with_context('Somewhere, at some point...')
+ assert sut != sut_with_context
+ assert sut_with_context.contexts == ('Somewhere, at some point...',)
diff --git a/betty/tests/config/test_format.py b/betty/tests/config/test_format.py
new file mode 100644
index 000000000..7ed714c57
--- /dev/null
+++ b/betty/tests/config/test_format.py
@@ -0,0 +1,57 @@
+import pytest
+
+from betty.app import App
+from betty.config import ConfigurationFormatError, DumpedConfigurationImport
+from betty.config.format import Yaml, Json
+
+
+class TestJson:
+ def test_load_with_invalid_json(self) -> None:
+ sut = Json()
+ dumped_json = '@'
+ with App():
+ with pytest.raises(ConfigurationFormatError):
+ sut.load(dumped_json)
+
+ def test_load_with_valid_json(self) -> None:
+ sut = Json()
+ dumped_json = '{"hello": [123, "World!"]}'
+ dumped_configuration = sut.load(dumped_json)
+ expected = {
+ 'hello': [123, 'World!']
+ }
+ assert expected == dumped_configuration
+
+ def test_dump(self) -> None:
+ dumped_configuration: DumpedConfigurationImport = {
+ 'hello': [123, 'World!']
+ }
+ sut = Json()
+ dumped_json = sut.dump(dumped_configuration)
+ assert '{"hello": [123, "World!"]}' == dumped_json
+
+
+class TestYaml:
+ def test_load_with_invalid_yaml(self) -> None:
+ sut = Yaml()
+ dumped_yaml = '@'
+ with App():
+ with pytest.raises(ConfigurationFormatError):
+ sut.load(dumped_yaml)
+
+ def test_load_with_valid_yaml(self) -> None:
+ sut = Yaml()
+ dumped_yaml = 'hello:\n- 123\n- World!\n'
+ dumped_configuration = sut.load(dumped_yaml)
+ expected = {
+ 'hello': [123, 'World!']
+ }
+ assert expected == dumped_configuration
+
+ def test_dump(self) -> None:
+ dumped_configuration: DumpedConfigurationImport = {
+ 'hello': [123, 'World!']
+ }
+ sut = Yaml()
+ dumped_yaml = sut.dump(dumped_configuration)
+ assert 'hello:\n- 123\n- World!\n' == dumped_yaml
diff --git a/betty/tests/config/test_load.py b/betty/tests/config/test_load.py
new file mode 100644
index 000000000..908ec227d
--- /dev/null
+++ b/betty/tests/config/test_load.py
@@ -0,0 +1,410 @@
+from tempfile import NamedTemporaryFile, TemporaryDirectory
+from typing import Any
+
+import pytest
+from reactives import reactive
+from reactives.factory.type import ReactiveInstance
+
+from betty.config.error import ConfigurationError
+from betty.config.load import ConfigurationValidationError, Loader, ConfigurationLoadError, Field
+from betty.config.validate import validate
+from betty.tests.config.test___init__ import raises_no_configuration_errors, raises_configuration_error, \
+ assert_configuration_error
+
+
+class TestLoader:
+ def test_commit_without_errors_and_committers(self) -> None:
+ sut = Loader()
+ sut.commit()
+
+ def test_commit_without_errors_with_committers(self) -> None:
+ on_commit_tracker = []
+ sut = Loader()
+ sut.on_commit(lambda: on_commit_tracker.append(True))
+ sut.commit()
+ assert [True] == on_commit_tracker
+
+ def test_commit_with_errors(self) -> None:
+ error = ConfigurationLoadError('Help!')
+ sut = Loader()
+ sut.error(error)
+ with pytest.raises(ConfigurationError):
+ sut.commit()
+
+ def test_catch(self) -> None:
+ sut = Loader()
+ error = ConfigurationLoadError('Help!')
+ with sut.catch():
+ raise error
+ assert_configuration_error(sut.errors, error)
+
+ def test_context_without_contexts(self) -> None:
+ sut = Loader()
+ error = ConfigurationLoadError('Help!')
+ with sut.context() as errors:
+ sut.error(error)
+ assert_configuration_error(errors, error)
+ assert_configuration_error(sut.errors, error)
+
+ def test_context_with_contexts(self) -> None:
+ sut = Loader()
+ error = ConfigurationLoadError('Help!')
+ with sut.context('Somewhere') as errors:
+ sut.error(error)
+ assert_configuration_error(errors, error=error, error_contexts=('Somewhere',))
+ assert_configuration_error(sut.errors, error=error, error_contexts=())
+
+ def test_evaluate_with_errors(self) -> None:
+ sut = Loader()
+ error = ConfigurationLoadError('Help!')
+ sut.error(error)
+ assert_configuration_error(sut.errors, error)
+
+ def test_evaluate_with_committers(self) -> None:
+ sut = Loader()
+ on_commit_tracker = []
+ sut.on_commit(lambda: on_commit_tracker.append(True))
+ sut.commit()
+ assert [True] == on_commit_tracker
+
+ def test_assert_bool_with_valid_value(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_bool(True)
+
+ def test_assert_bool_with_invalid_value(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_bool(123)
+
+ def test_assert_int_with_valid_value(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_int(123)
+
+ def test_assert_int_with_invalid_value(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_int(False)
+
+ def test_assert_float_with_valid_value(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_float(1.23)
+
+ def test_assert_float_with_invalid_value(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_float(False)
+
+ def test_assert_str_with_valid_value(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_str('Hello, world!')
+
+ def test_assert_str_with_invalid_value(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_str(False)
+
+ def test_assert_list_with_list(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_list([])
+
+ def test_assert_list_without_list(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_list(False)
+
+ def test_assert_sequence_without_list(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_sequence(
+ False,
+ loader.assert_str, # type: ignore
+ )
+
+ def test_assert_sequence_with_invalid_item(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError, error_contexts=('0',)) as loader:
+ loader.assert_sequence(
+ [123],
+ loader.assert_str, # type: ignore
+ )
+
+ def test_assert_sequence_with_empty_list(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_sequence(
+ [],
+ loader.assert_str, # type: ignore
+ )
+
+ def test_assert_sequence_with_valid_sequence(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_sequence(
+ ['Hello!'],
+ loader.assert_str, # type: ignore
+ )
+
+ def test_assert_dict_with_dict(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_dict({})
+
+ def test_assert_dict_without_dict(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_dict(False)
+
+ def test_assert_required_key_without_dict(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ with loader.assert_required_key(
+ False,
+ 'hello',
+ loader.assert_str, # type: ignore
+ ) as (dumped_configuration, valid):
+ assert not valid
+ assert dumped_configuration is None
+
+ def test_assert_required_key_without_key(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError, error_contexts=('hello',)) as loader:
+ with loader.assert_required_key(
+ {},
+ 'hello',
+ loader.assert_str, # type: ignore
+ ) as (dumped_configuration, valid):
+ assert not valid
+ assert dumped_configuration is None
+
+ def test_assert_required_key_with_key(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ with loader.assert_required_key(
+ {'hello': 'World!'},
+ 'hello',
+ loader.assert_str, # type: ignore
+ ) as (dumped_configuration, valid):
+ assert valid
+ assert 'World!' == dumped_configuration
+
+ def test_assert_optional_key_without_dict(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ with loader.assert_optional_key(
+ False,
+ 'hello',
+ loader.assert_str, # type: ignore
+ ) as (dumped_configuration, valid):
+ assert not valid
+ assert dumped_configuration is None
+
+ def test_assert_optional_key_without_key(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ with loader.assert_optional_key(
+ {},
+ 'hello',
+ loader.assert_str, # type: ignore
+ ) as (dumped_configuration, valid):
+ assert not valid
+ assert dumped_configuration is None
+
+ def test_assert_optional_key_with_key(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ with loader.assert_optional_key(
+ {'hello': 'World!'},
+ 'hello',
+ loader.assert_str, # type: ignore
+ ) as (dumped_configuration, valid):
+ assert valid
+ assert 'World!' == dumped_configuration
+
+ def test_assert_mapping_without_dict(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_mapping(
+ False,
+ loader.assert_str, # type: ignore
+ )
+
+ def test_assert_mapping_with_invalid_value(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError, error_contexts=('hello',)) as loader:
+ loader.assert_mapping(
+ {'hello': False},
+ loader.assert_str, # type: ignore
+ )
+
+ def test_assert_mapping_with_empty_dict(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_mapping(
+ {},
+ loader.assert_str, # type: ignore
+ )
+
+ def test_assert_mapping_with_valid_mapping(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_mapping(
+ {'hello': 'World!'},
+ loader.assert_str, # type: ignore
+ )
+
+ def test_assert_record_without_fields(self) -> None:
+ with pytest.raises(ValueError):
+ Loader().assert_record({}, {})
+
+ def test_assert_record_with_optional_fields_without_items(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_record(
+ {},
+ {
+ 'foo': Field(
+ False,
+ loader.assert_str, # type: ignore
+ ),
+ },
+ )
+
+ def test_assert_record_with_optional_fields_with_items(self) -> None:
+ tracker = []
+ with raises_no_configuration_errors() as loader:
+ loader.assert_record(
+ {
+ 'foo': 'bar',
+ },
+ {
+ 'foo': Field(
+ False,
+ loader.assert_str, # type: ignore
+ lambda x: tracker.append(x),
+ )
+ },
+ )
+ assert ['bar'] == tracker
+
+ def test_assert_record_with_required_fields_without_items(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_record(
+ {},
+ {
+ 'foo': Field(
+ True,
+ loader.assert_str, # type: ignore
+ ),
+ },
+ )
+
+ def test_assert_record_with_required_fields_with_items(self) -> None:
+ tracker = []
+ with raises_no_configuration_errors() as loader:
+ loader.assert_record(
+ {
+ 'foo': 'bar',
+ },
+ {
+ 'foo': Field(
+ True,
+ loader.assert_str, # type: ignore
+ lambda x: tracker.append(x),
+ )
+ },
+ )
+ assert ['bar'] == tracker
+
+ def test_assert_path_without_str(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_path(False)
+
+ def test_assert_path_with_valid_path(self) -> None:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_path('~/../foo/bar')
+
+ def test_assert_directory_path_without_str(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_directory_path(False)
+
+ def test_assert_directory_path_without_existing_path(self) -> None:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_directory_path('~/../foo/bar')
+
+ def test_assert_directory_path_without_directory_path(self) -> None:
+ with NamedTemporaryFile() as f:
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_directory_path(f.name)
+
+ def test_assert_directory_path_with_valid_path(self) -> None:
+ with TemporaryDirectory() as directory_path:
+ with raises_no_configuration_errors() as loader:
+ loader.assert_directory_path(directory_path)
+ loader.commit()
+
+ @reactive
+ class Instance(ReactiveInstance):
+ def __init__(self):
+ super().__init__()
+ self._some_valid_property = None
+ self._some_valid_reactive_property = None
+ self.some_valid_attribute = None
+
+ def _validate_valid(self, value):
+ return value
+
+ def _validate_invalid(self, value) -> None:
+ raise ConfigurationValidationError()
+
+ @property
+ def some_valid_property(self) -> Any:
+ return self._some_valid_property
+
+ @some_valid_property.setter
+ @validate(_validate_valid)
+ def some_valid_property(self, value: Any):
+ self._some_valid_property = value
+
+ @property
+ def some_invalid_property(self) -> Any:
+ raise NotImplementedError
+
+ @some_invalid_property.setter
+ @validate(_validate_invalid)
+ def some_invalid_property(self, value: Any):
+ raise NotImplementedError
+
+ @reactive # type: ignore
+ @property
+ def some_valid_reactive_property(self) -> Any:
+ return self._some_valid_reactive_property
+
+ @some_valid_reactive_property.setter
+ @validate(_validate_valid)
+ def some_valid_reactive_property(self, value: Any):
+ self._some_valid_reactive_property = value
+
+ @property
+ def some_invalid_reactive_property(self) -> Any:
+ raise NotImplementedError
+
+ @some_invalid_reactive_property.setter
+ @validate(_validate_invalid)
+ def some_invalid_reactive_property(self, value: Any):
+ raise NotImplementedError
+
+ def test_assert_setattr_with_valid_property(self) -> None:
+ instance = self.Instance()
+ attr_name = 'some_valid_property'
+ value = 'Hello, world!'
+ with raises_no_configuration_errors() as loader:
+ loader.assert_setattr(instance, attr_name, value)
+ assert value == instance.some_valid_property
+
+ def test_assert_setattr_with_invalid_property(self) -> None:
+ instance = self.Instance()
+ attr_name = 'some_invalid_property'
+ value = 'Hello, world!'
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_setattr(instance, attr_name, value)
+
+ def test_assert_setattr_with_valid_reactive_property(self) -> None:
+ instance = self.Instance()
+ attr_name = 'some_valid_reactive_property'
+ value = 'Hello, world!'
+ with raises_no_configuration_errors() as loader:
+ loader.assert_setattr(instance, attr_name, value)
+ assert value == instance.some_valid_reactive_property
+
+ def test_assert_setattr_with_valid_attribute(self) -> None:
+ instance = self.Instance()
+ attr_name = 'some_valid_attribute'
+ value = 'Hello, world!'
+ with raises_no_configuration_errors() as loader:
+ loader.assert_setattr(instance, attr_name, value)
+ assert value == instance.some_valid_attribute
+
+ def test_assert_setattr_with_invalid_reactive_property(self) -> None:
+ instance = self.Instance()
+ attr_name = 'some_invalid_reactive_property'
+ value = 'Hello, world!'
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ loader.assert_setattr(instance, attr_name, value)
diff --git a/betty/tests/config/test_validate.py b/betty/tests/config/test_validate.py
new file mode 100644
index 000000000..117a6210d
--- /dev/null
+++ b/betty/tests/config/test_validate.py
@@ -0,0 +1,57 @@
+from typing import Any
+
+import pytest
+
+from betty.app import App
+from betty.config.load import ConfigurationValidationError
+from betty.config.validate import validate_positive_number, validate
+
+
+class TestValidatePositiveNumber:
+ def test_with_invalid_number(self) -> None:
+ with App():
+ with pytest.raises(ConfigurationValidationError):
+ validate_positive_number(None, 0)
+
+ def test_with_valid_number(self) -> None:
+ validate_positive_number(None, 0.1)
+
+
+class TestValidate:
+ class Instance:
+ def __init__(self):
+ self._some_valid_property = None
+
+ def _validate_valid(self, value) -> Any:
+ return value
+
+ @property
+ def some_valid_property(self) -> Any:
+ return self._some_valid_property
+
+ @some_valid_property.setter
+ @validate(_validate_valid)
+ def some_valid_property(self, value: Any):
+ self._some_valid_property = value
+
+ def _validate_invalid(self, value) -> None:
+ raise ConfigurationValidationError()
+
+ @property
+ def some_invalid_property(self) -> Any:
+ raise NotImplementedError
+
+ @some_invalid_property.setter
+ @validate(_validate_invalid)
+ def some_invalid_property(self, value: Any):
+ raise NotImplementedError
+
+ def test_valid_value(self) -> None:
+ instance = self.Instance()
+ instance.some_valid_property = 123
+ assert 123 == instance.some_valid_property
+
+ def test_invalid_value(self) -> None:
+ instance = self.Instance()
+ with pytest.raises(ConfigurationValidationError):
+ instance.some_invalid_property = 123
diff --git a/betty/tests/cotton_candy/test___init__.py b/betty/tests/cotton_candy/test___init__.py
index efa3194da..5a1ff801c 100644
--- a/betty/tests/cotton_candy/test___init__.py
+++ b/betty/tests/cotton_candy/test___init__.py
@@ -3,10 +3,12 @@
import pytest
from betty.app import App
-from betty.config import ConfigurationError, DumpedConfiguration
+from betty.config import DumpedConfigurationImport
+from betty.config.load import ConfigurationValidationError
from betty.cotton_candy import CottonCandyConfiguration, _ColorConfiguration
from betty.model import Entity, get_entity_type_name
from betty.project import EntityReference
+from betty.tests.config.test___init__ import raises_configuration_error, raises_no_configuration_errors
class TestColorConfiguration:
@@ -23,14 +25,15 @@ def test_hex_with_valid_value(self) -> None:
def test_hex_with_invalid_value(self, hex_value: str) -> None:
sut = _ColorConfiguration('#ffffff')
with App():
- with pytest.raises(ConfigurationError):
+ with pytest.raises(ConfigurationValidationError):
sut.hex = hex_value
def test_load_with_valid_hex_value(self) -> None:
hex_value = '#000000'
dumped_configuration = hex_value
sut = _ColorConfiguration('#ffffff')
- sut.load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert hex_value == sut.hex
@pytest.mark.parametrize('dumped_configuration', [
@@ -39,32 +42,34 @@ def test_load_with_valid_hex_value(self) -> None:
'rgb(0,0,0)',
'pink',
])
- def test_load_with_invalid_value(self, dumped_configuration: DumpedConfiguration) -> None:
+ def test_load_with_invalid_value(self, dumped_configuration: DumpedConfigurationImport) -> None:
sut = _ColorConfiguration('#ffffff')
- with App():
- with pytest.raises(ConfigurationError):
- sut.load(dumped_configuration)
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_dump_with_value(self) -> None:
hex_value = '#000000'
assert hex_value == _ColorConfiguration(hex_value=hex_value).dump()
+class CottonCandyConfigurationTestEntity(Entity):
+ pass
+
+
class TestCottonCandyConfiguration:
def test_load_with_minimal_configuration(self) -> None:
dumped_configuration: Dict = {}
- with App():
- CottonCandyConfiguration().load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ CottonCandyConfiguration().load(dumped_configuration, loader)
def test_load_without_dict_should_error(self) -> None:
dumped_configuration = None
- with App():
- with pytest.raises(ConfigurationError):
- CottonCandyConfiguration().load(dumped_configuration)
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ CottonCandyConfiguration().load(dumped_configuration, loader)
def test_load_with_featured_entities(self) -> None:
sut = CottonCandyConfiguration()
- entity_type = Entity
+ entity_type = CottonCandyConfigurationTestEntity
entity_id = '123'
dumped_configuration = {
'featured_entities': [
@@ -74,7 +79,8 @@ def test_load_with_featured_entities(self) -> None:
},
],
}
- sut.load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert entity_type == sut.featured_entities[0].entity_type
assert entity_id == sut.featured_entities[0].entity_id
@@ -84,7 +90,8 @@ def test_load_with_primary_inactive_color(self) -> None:
'primary_inactive_color': hex_value,
}
sut = CottonCandyConfiguration()
- sut.load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert hex_value == sut.primary_inactive_color.hex
def test_load_with_primary_active_color(self) -> None:
@@ -93,7 +100,8 @@ def test_load_with_primary_active_color(self) -> None:
'primary_active_color': hex_value,
}
sut = CottonCandyConfiguration()
- sut.load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert hex_value == sut.primary_active_color.hex
def test_load_with_link_inactive_color(self) -> None:
@@ -102,7 +110,8 @@ def test_load_with_link_inactive_color(self) -> None:
'link_inactive_color': hex_value,
}
sut = CottonCandyConfiguration()
- sut.load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert hex_value == sut.link_inactive_color.hex
def test_load_with_link_active_color(self) -> None:
@@ -111,7 +120,8 @@ def test_load_with_link_active_color(self) -> None:
'link_active_color': hex_value,
}
sut = CottonCandyConfiguration()
- sut.load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert hex_value == sut.link_active_color.hex
def test_dump_with_minimal_configuration(self) -> None:
@@ -126,7 +136,7 @@ def test_dump_with_minimal_configuration(self) -> None:
def test_dump_with_featured_entities(self) -> None:
sut = CottonCandyConfiguration()
- entity_type = Entity
+ entity_type = CottonCandyConfigurationTestEntity
entity_id = '123'
sut.featured_entities.append(EntityReference(entity_type, entity_id))
expected = [
diff --git a/betty/tests/cotton_candy/test_gui.py b/betty/tests/cotton_candy/test_gui.py
index 80861f72e..70ae38e93 100644
--- a/betty/tests/cotton_candy/test_gui.py
+++ b/betty/tests/cotton_candy/test_gui.py
@@ -7,7 +7,7 @@
from betty.app import App
from betty.cotton_candy import CottonCandy, _ColorConfiguration
from betty.cotton_candy.gui import _CottonCandyGuiWidget, _ColorConfigurationWidget
-from betty.model import Entity
+from betty.model import Entity, UserFacingEntity
from betty.project import EntityReference
@@ -32,6 +32,16 @@ def test_reset(self, qtbot: QtBot) -> None:
assert default_hex_value == color_configuration.hex
+class CottonCandyGuiWidgetTestEntity(UserFacingEntity, Entity):
+ @classmethod
+ def entity_type_label(cls) -> str:
+ return cls.__name__
+
+ @classmethod
+ def entity_type_label_plural(cls) -> str:
+ return cls.__name__
+
+
class TestCottonCandyGuiWidget:
def test_add_featured_entities(self, qtbot: QtBot) -> None:
with App() as app:
@@ -49,9 +59,9 @@ def test_add_featured_entities(self, qtbot: QtBot) -> None:
def test_change_featured_entities(self, qtbot: QtBot) -> None:
with App() as app:
app.project.configuration.extensions.enable(CottonCandy)
- entity_reference_1 = EntityReference(Entity, '123')
- entity_reference_2 = EntityReference(Entity, '456')
- entity_reference_3 = EntityReference(Entity, '789')
+ entity_reference_1 = EntityReference(CottonCandyGuiWidgetTestEntity, '123')
+ entity_reference_2 = EntityReference(CottonCandyGuiWidgetTestEntity, '456')
+ entity_reference_3 = EntityReference(CottonCandyGuiWidgetTestEntity, '789')
app.extensions[CottonCandy].configuration.featured_entities.append(entity_reference_1)
app.extensions[CottonCandy].configuration.featured_entities.append(entity_reference_2)
app.extensions[CottonCandy].configuration.featured_entities.append(entity_reference_3)
@@ -67,9 +77,9 @@ def test_change_featured_entities(self, qtbot: QtBot) -> None:
def test_remove_featured_entities(self, qtbot: QtBot) -> None:
with App() as app:
app.project.configuration.extensions.enable(CottonCandy)
- entity_reference_1 = EntityReference(Entity, '123')
- entity_reference_2 = EntityReference(Entity, '456')
- entity_reference_3 = EntityReference(Entity, '789')
+ entity_reference_1 = EntityReference(CottonCandyGuiWidgetTestEntity, '123')
+ entity_reference_2 = EntityReference(CottonCandyGuiWidgetTestEntity, '456')
+ entity_reference_3 = EntityReference(CottonCandyGuiWidgetTestEntity, '789')
app.extensions[CottonCandy].configuration.featured_entities.append(entity_reference_1)
app.extensions[CottonCandy].configuration.featured_entities.append(entity_reference_2)
app.extensions[CottonCandy].configuration.featured_entities.append(entity_reference_3)
diff --git a/betty/tests/cotton_candy/test_search.py b/betty/tests/cotton_candy/test_search.py
index b9807962f..1fca7e464 100644
--- a/betty/tests/cotton_candy/test_search.py
+++ b/betty/tests/cotton_candy/test_search.py
@@ -9,13 +9,12 @@
class TestIndex:
def test_empty(self):
- app = App()
- app.project.configuration.extensions.enable(CottonCandy)
- app.project.configuration.locales.replace([
- LocaleConfiguration('en-US', 'en'),
- LocaleConfiguration('nl-NL', 'nl'),
- ])
- with app:
+ with App() as app:
+ app.project.configuration.extensions.enable(CottonCandy)
+ app.project.configuration.locales.replace([
+ LocaleConfiguration('en-US', 'en'),
+ LocaleConfiguration('nl-NL', 'nl'),
+ ])
indexed = [item for item in Index(app).build()]
assert [] == indexed
@@ -24,13 +23,12 @@ def test_person_without_names(self):
person_id = 'P1'
person = Person(person_id)
- app = App()
- app.project.configuration.extensions.enable(CottonCandy)
- app.project.configuration.locales.replace([
- LocaleConfiguration('en-US', 'en'),
- LocaleConfiguration('nl-NL', 'nl'),
- ])
- with app:
+ with App() as app:
+ app.project.configuration.extensions.enable(CottonCandy)
+ app.project.configuration.locales.replace([
+ LocaleConfiguration('en-US', 'en'),
+ LocaleConfiguration('nl-NL', 'nl'),
+ ])
app.project.ancestry.entities.append(person)
indexed = [item for item in Index(app).build()]
@@ -43,13 +41,12 @@ def test_private_person(self):
PersonName(person, individual_name)
person.private = True
- app = App()
- app.project.configuration.extensions.enable(CottonCandy)
- app.project.configuration.locales.replace([
- LocaleConfiguration('en-US', 'en'),
- LocaleConfiguration('nl-NL', 'nl'),
- ])
- with app:
+ with App() as app:
+ app.project.configuration.extensions.enable(CottonCandy)
+ app.project.configuration.locales.replace([
+ LocaleConfiguration('en-US', 'en'),
+ LocaleConfiguration('nl-NL', 'nl'),
+ ])
app.project.ancestry.entities.append(person)
indexed = [item for item in Index(app).build()]
@@ -65,13 +62,12 @@ def test_person_with_individual_name(self, expected: str, locale: str):
person = Person(person_id)
PersonName(person, individual_name)
- app = App()
- app.project.configuration.extensions.enable(CottonCandy)
- app.project.configuration.locales.replace([
- LocaleConfiguration('en-US', 'en'),
- LocaleConfiguration('nl-NL', 'nl'),
- ])
- with app:
+ with App() as app:
+ app.project.configuration.extensions.enable(CottonCandy)
+ app.project.configuration.locales.replace([
+ LocaleConfiguration('en-US', 'en'),
+ LocaleConfiguration('nl-NL', 'nl'),
+ ])
with app.acquire_locale(locale):
app.project.ancestry.entities.append(person)
indexed = [item for item in Index(app).build()]
@@ -89,13 +85,12 @@ def test_person_with_affiliation_name(self, expected: str, locale: str):
person = Person(person_id)
PersonName(person, None, affiliation_name)
- app = App()
- app.project.configuration.extensions.enable(CottonCandy)
- app.project.configuration.locales.replace([
- LocaleConfiguration('en-US', 'en'),
- LocaleConfiguration('nl-NL', 'nl'),
- ])
- with app:
+ with App() as app:
+ app.project.configuration.extensions.enable(CottonCandy)
+ app.project.configuration.locales.replace([
+ LocaleConfiguration('en-US', 'en'),
+ LocaleConfiguration('nl-NL', 'nl'),
+ ])
with app.acquire_locale(locale):
app.project.ancestry.entities.append(person)
indexed = [item for item in Index(app).build()]
@@ -114,13 +109,12 @@ def test_person_with_individual_and_affiliation_names(self, expected: str, local
person = Person(person_id)
PersonName(person, individual_name, affiliation_name)
- app = App()
- app.project.configuration.extensions.enable(CottonCandy)
- app.project.configuration.locales.replace([
- LocaleConfiguration('en-US', 'en'),
- LocaleConfiguration('nl-NL', 'nl'),
- ])
- with app:
+ with App() as app:
+ app.project.configuration.extensions.enable(CottonCandy)
+ app.project.configuration.locales.replace([
+ LocaleConfiguration('en-US', 'en'),
+ LocaleConfiguration('nl-NL', 'nl'),
+ ])
with app.acquire_locale(locale):
app.project.ancestry.entities.append(person)
indexed = [item for item in Index(app).build()]
@@ -136,13 +130,12 @@ def test_place(self, expected: str, locale: str):
place_id = 'P1'
place = Place(place_id, [PlaceName('Netherlands', 'en'), PlaceName('Nederland', 'nl')])
- app = App()
- app.project.configuration.extensions.enable(CottonCandy)
- app.project.configuration.locales.replace([
- LocaleConfiguration('en-US', 'en'),
- LocaleConfiguration('nl-NL', 'nl'),
- ])
- with app:
+ with App() as app:
+ app.project.configuration.extensions.enable(CottonCandy)
+ app.project.configuration.locales.replace([
+ LocaleConfiguration('en-US', 'en'),
+ LocaleConfiguration('nl-NL', 'nl'),
+ ])
with app.acquire_locale(locale):
app.project.ancestry.entities.append(place)
indexed = [item for item in Index(app).build()]
@@ -154,13 +147,12 @@ def test_file_without_description(self):
file_id = 'F1'
file = File(file_id, __file__)
- app = App()
- app.project.configuration.extensions.enable(CottonCandy)
- app.project.configuration.locales.replace([
- LocaleConfiguration('en-US', 'en'),
- LocaleConfiguration('nl-NL', 'nl'),
- ])
- with app:
+ with App() as app:
+ app.project.configuration.extensions.enable(CottonCandy)
+ app.project.configuration.locales.replace([
+ LocaleConfiguration('en-US', 'en'),
+ LocaleConfiguration('nl-NL', 'nl'),
+ ])
app.project.ancestry.entities.append(file)
indexed = [item for item in Index(app).build()]
@@ -175,13 +167,12 @@ def test_file(self, expected: str, locale: str):
file = File(file_id, __file__)
file.description = '"file" is Dutch for "traffic jam"'
- app = App()
- app.project.configuration.extensions.enable(CottonCandy)
- app.project.configuration.locales.replace([
- LocaleConfiguration('en-US', 'en'),
- LocaleConfiguration('nl-NL', 'nl'),
- ])
- with app:
+ with App() as app:
+ app.project.configuration.extensions.enable(CottonCandy)
+ app.project.configuration.locales.replace([
+ LocaleConfiguration('en-US', 'en'),
+ LocaleConfiguration('nl-NL', 'nl'),
+ ])
with app.acquire_locale(locale):
app.project.ancestry.entities.append(file)
indexed = [item for item in Index(app).build()]
diff --git a/betty/tests/demo/test___init__.py b/betty/tests/demo/test___init__.py
index c99f9a1e4..26cc2e8d0 100644
--- a/betty/tests/demo/test___init__.py
+++ b/betty/tests/demo/test___init__.py
@@ -2,13 +2,13 @@
from betty.demo import Demo
from betty.load import load
from betty.model.ancestry import Person, Place, Event, Source, Citation
-from betty.project import ProjectExtensionConfiguration
+from betty.project import ExtensionConfiguration
class TestDemo:
async def test_load(self):
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Demo))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Demo))
await load(app)
assert 0 != len(app.project.ancestry.entities[Person])
assert 0 != len(app.project.ancestry.entities[Place])
diff --git a/betty/tests/deriver/test___init__.py b/betty/tests/deriver/test___init__.py
index e264e71ab..7c309ff6e 100644
--- a/betty/tests/deriver/test___init__.py
+++ b/betty/tests/deriver/test___init__.py
@@ -8,7 +8,7 @@
from betty.locale import DateRange, Date, Datey
from betty.model.ancestry import Person, Presence, Subject, EventType, Event
from betty.model.event_type import DerivableEventType, CreatableDerivableEventType, Residence
-from betty.project import ProjectExtensionConfiguration
+from betty.project import ExtensionConfiguration
class Ignored(EventType):
@@ -64,7 +64,7 @@ async def test_post_parse(self):
reference_presence.event.date = Date(1970, 1, 1)
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Deriver))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Deriver))
app.project.ancestry.entities.append(person)
await load(app)
@@ -81,7 +81,7 @@ async def test_post_parse(self):
def test_derive_app() -> Iterator[App]:
app = App()
with app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Deriver))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Deriver))
yield app
diff --git a/betty/tests/gramps/test___init__.py b/betty/tests/gramps/test___init__.py
index 0d0eacbc1..69b179e14 100644
--- a/betty/tests/gramps/test___init__.py
+++ b/betty/tests/gramps/test___init__.py
@@ -9,7 +9,7 @@
from betty.load import load
from betty.model.ancestry import Citation, Note, Source, File, \
Event, Person, Place
-from betty.project import ProjectExtensionConfiguration
+from betty.project import ExtensionConfiguration
class TestGramps:
@@ -127,7 +127,7 @@ async def test_load_multiple_family_trees(self):
f.write(family_tree_two_xml)
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Gramps, True, GrampsConfiguration(
+ app.project.configuration.extensions.add(ExtensionConfiguration(Gramps, True, GrampsConfiguration(
family_trees=ReactiveList([
FamilyTreeConfiguration(gramps_family_tree_one_path),
FamilyTreeConfiguration(gramps_family_tree_two_path),
diff --git a/betty/tests/gramps/test_gui.py b/betty/tests/gramps/test_gui.py
index 049a74aaa..8c1c8c44e 100644
--- a/betty/tests/gramps/test_gui.py
+++ b/betty/tests/gramps/test_gui.py
@@ -10,13 +10,13 @@
from betty.gramps import Gramps, GrampsConfiguration
from betty.gramps.config import FamilyTreeConfiguration
from betty.gramps.gui import _AddFamilyTreeWindow
-from betty.project import ProjectExtensionConfiguration
+from betty.project import ExtensionConfiguration
from betty.tests.conftest import AssertWindow, AssertNotWindow
def test_add_family_tree_set_path(assert_not_window: AssertNotWindow, assert_window: AssertWindow, qtbot: QtBot) -> None:
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Gramps))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Gramps))
sut = app.extensions[Gramps]
widget = sut.gui_build()
qtbot.addWidget(widget)
@@ -38,7 +38,7 @@ def test_add_family_tree_set_path(assert_not_window: AssertNotWindow, assert_win
def test_add_family_tree_find_path(assert_window: AssertWindow, mocker: MockerFixture, qtbot: QtBot) -> None:
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Gramps))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Gramps))
sut = app.extensions[Gramps]
widget = sut.gui_build()
qtbot.addWidget(widget)
@@ -59,7 +59,7 @@ def test_add_family_tree_find_path(assert_window: AssertWindow, mocker: MockerFi
def test_remove_family_tree(qtbot) -> None:
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(
+ app.project.configuration.extensions.add(ExtensionConfiguration(
Gramps,
extension_configuration=GrampsConfiguration(
family_trees=ReactiveList([
diff --git a/betty/tests/gui/test_app.py b/betty/tests/gui/test_app.py
index c7aac019d..121854d93 100644
--- a/betty/tests/gui/test_app.py
+++ b/betty/tests/gui/test_app.py
@@ -9,7 +9,7 @@
from betty import fs
from betty.app import App
-from betty.config import ConfigurationError
+from betty.config import ConfigurationFormatError
from betty.gui.app import WelcomeWindow, _AboutBettyWindow, BettyMainWindow, ApplicationConfiguration
from betty.gui.error import ExceptionError
from betty.gui.project import ProjectWindow
@@ -73,7 +73,7 @@ def test_open_project_with_invalid_file_should_error(self, assert_error, mocker:
qtbot.mouseClick(sut.open_project_button, Qt.MouseButton.LeftButton)
error = assert_error(ExceptionError)
- assert isinstance(error.exception, ConfigurationError)
+ assert isinstance(error.exception, ConfigurationFormatError)
def test_open_project_with_valid_file_should_show_project_window(self, assert_window: AssertWindow, mocker: MockerFixture, qtbot: QtBot) -> None:
title = 'My First Ancestry Site'
diff --git a/betty/tests/gui/test_project.py b/betty/tests/gui/test_project.py
index f79287690..3f775d341 100644
--- a/betty/tests/gui/test_project.py
+++ b/betty/tests/gui/test_project.py
@@ -8,9 +8,10 @@
from betty.app import App
from betty.gui.project import ProjectWindow, _AddLocaleWindow, _GenerateWindow, _LocalizationPane, \
- _GeneralPane
+ _GeneralPane, _GenerateHtmlListForm
from betty.gui.serve import ServeAppWindow
from betty.locale import bcp_47_to_rfc_1766
+from betty.model.ancestry import File
from betty.project import ProjectConfiguration, LocaleConfiguration
from betty.tests.conftest import AssertNotWindow, AssertInvalid, AssertWindow, Navigate
@@ -32,6 +33,19 @@ def test_save_project_as_should_create_duplicate_configuration_file(self, mocker
assert json.load(f) == configuration.dump()
+class Test_GenerateHtmlListForm:
+ def test(self, qtbot: QtBot) -> None:
+ with App() as app:
+ sut = _GenerateHtmlListForm(app)
+ qtbot.addWidget(sut)
+ sut.show()
+
+ sut._checkboxes[File].setChecked(True)
+ assert app.project.configuration.entity_types[File].generate_html_list
+ sut._checkboxes[File].setChecked(False)
+ assert not app.project.configuration.entity_types[File].generate_html_list
+
+
class TestGeneralPane:
def test_title(self, qtbot: QtBot) -> None:
with App() as app:
diff --git a/betty/tests/http_api_doc/test___init__.py b/betty/tests/http_api_doc/test___init__.py
index ffcfff425..2cc24c517 100644
--- a/betty/tests/http_api_doc/test___init__.py
+++ b/betty/tests/http_api_doc/test___init__.py
@@ -1,7 +1,7 @@
from betty.app import App
from betty.generate import generate
from betty.http_api_doc import HttpApiDoc
-from betty.project import ProjectExtensionConfiguration
+from betty.project import ExtensionConfiguration
from betty.tests import patch_cache
@@ -9,7 +9,7 @@ class TestHttpApiDoc:
@patch_cache
async def test(self):
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(HttpApiDoc))
+ app.project.configuration.extensions.add(ExtensionConfiguration(HttpApiDoc))
await generate(app)
assert (app.project.configuration.www_directory_path / 'api' / 'index.html').is_file()
assert (app.project.configuration.www_directory_path / 'http-api-doc.js').is_file()
diff --git a/betty/tests/maps/test___init__.py b/betty/tests/maps/test___init__.py
index 82b9f7faa..1482c5438 100644
--- a/betty/tests/maps/test___init__.py
+++ b/betty/tests/maps/test___init__.py
@@ -1,7 +1,7 @@
from betty.app import App
from betty.generate import generate
from betty.maps import Maps
-from betty.project import ProjectExtensionConfiguration
+from betty.project import ExtensionConfiguration
from betty.tests import patch_cache
@@ -10,7 +10,7 @@ class TestMaps:
async def test_post_generate_event(self):
with App() as app:
app.project.configuration.debug = True
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Maps))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Maps))
await generate(app)
with open(app.project.configuration.www_directory_path / 'maps.js', encoding='utf-8') as f:
betty_js = f.read()
diff --git a/betty/tests/model/test___init__.py b/betty/tests/model/test___init__.py
index 81b47800e..01a538a80 100644
--- a/betty/tests/model/test___init__.py
+++ b/betty/tests/model/test___init__.py
@@ -9,14 +9,11 @@
from betty.model import GeneratedEntityId, get_entity_type_name, Entity, get_entity_type, _EntityTypeAssociation, \
_EntityTypeAssociationRegistry, SingleTypeEntityCollection, _AssociateCollection, MultipleTypesEntityCollection, \
one_to_many, many_to_one_to_many, FlattenedEntityCollection, many_to_many, \
- EntityCollection, to_many, many_to_one, to_one, one_to_one
+ EntityCollection, to_many, many_to_one, to_one, one_to_one, EntityVariation, EntityTypeInvalidError, \
+ EntityTypeImportError
from betty.model.ancestry import Person
-class _OtherEntity(Entity):
- pass
-
-
class TestGeneratedEntityid:
def test_pickle(self) -> None:
sut = GeneratedEntityId()
@@ -34,17 +31,19 @@ def test_deepcopy(self) -> None:
assert sut == copied_sut
+class EntityTestEntity(Entity):
+ pass
+
+
class TestEntity:
def test_id(self) -> None:
entity_id = '000000001'
- sut = Entity(entity_id)
+ sut = EntityTestEntity(entity_id)
assert entity_id == sut.id
- def test_entity_type_with_class(self) -> None:
- assert Entity == Entity.entity_type()
- def test_entity_type_with_instance(self) -> None:
- assert Entity == Entity.entity_type()
+class GetEntityTypeNameTestEntity(Entity):
+ pass
class TestGetEntityTypeName:
@@ -52,7 +51,23 @@ def test_with_betty_entity(self) -> None:
assert 'Person' == get_entity_type_name(Person)
def test_with_other_entity(self) -> None:
- assert 'betty.tests.model.test___init__._OtherEntity' == get_entity_type_name(_OtherEntity)
+ assert 'betty.tests.model.test___init__.GetEntityTypeNameTestEntity' == get_entity_type_name(GetEntityTypeNameTestEntity)
+
+
+class GetEntityTypeTestEntity(Entity):
+ pass
+
+
+class GetEntityTypeTestEntityVariation(EntityVariation):
+ pass
+
+
+class GetEntityTypeTestEntityVariationEntity(GetEntityTypeTestEntityVariation, Entity):
+ pass
+
+
+class GetEntityTypeTestInvalidEntityAndEntityVariationSubclass(EntityVariation, Entity):
+ pass
class TestGetEntityType:
@@ -60,12 +75,30 @@ def test_with_betty_entity(self) -> None:
assert Person == get_entity_type('Person')
def test_with_other_entity(self) -> None:
- assert _OtherEntity == get_entity_type('betty.tests.model.test___init__._OtherEntity')
+ assert GetEntityTypeTestEntity == get_entity_type('betty.tests.model.test___init__.GetEntityTypeTestEntity')
def test_with_unknown_entity(self) -> None:
- with pytest.raises(ValueError):
+ with pytest.raises(EntityTypeImportError):
get_entity_type('betty_non_existent.UnknownEntity')
+ def test_without_subclass(self) -> None:
+ with pytest.raises(EntityTypeInvalidError):
+ get_entity_type(Entity)
+
+ def test_with_entity_subclass(self) -> None:
+ assert GetEntityTypeTestEntity == get_entity_type(GetEntityTypeTestEntity)
+
+ def test_with_entity_variation_subclass(self) -> None:
+ with pytest.raises(EntityTypeInvalidError):
+ get_entity_type(GetEntityTypeTestEntityVariation)
+
+ def test_with_entity_variation_entity_subclass(self) -> None:
+ assert GetEntityTypeTestEntityVariationEntity == get_entity_type(GetEntityTypeTestEntityVariationEntity)
+
+ def test_with_invalid_entity_and_entity_variation_inheritance(self) -> None:
+ with pytest.raises(EntityTypeInvalidError):
+ get_entity_type(GetEntityTypeTestInvalidEntityAndEntityVariationSubclass)
+
class Test_EntityTypeAssociationRegistry:
class _ParentEntity(Entity):
@@ -93,9 +126,13 @@ def test_get_associations_with_child_class_should_return_child_associations(self
assert {parent_registration, child_registration} == _EntityTypeAssociationRegistry.get_associations(self._ChildEntity)
+class SingleTypeEntityCollectionTestEntity(Entity):
+ pass
+
+
class TestSingleTypeEntityCollection:
def test_pickle(self) -> None:
- entity = Entity()
+ entity = SingleTypeEntityCollectionTestEntity()
sut = SingleTypeEntityCollection(Entity)
sut.append(entity)
unpickled_sut = pickle.loads(pickle.dumps(sut))
@@ -103,7 +140,7 @@ def test_pickle(self) -> None:
assert entity.id == unpickled_sut[0].id
def test_copy(self) -> None:
- entity = Entity()
+ entity = SingleTypeEntityCollectionTestEntity()
sut = SingleTypeEntityCollection(Entity)
sut.append(entity)
copied_sut = copy.copy(sut)
@@ -111,7 +148,7 @@ def test_copy(self) -> None:
assert entity.id == copied_sut[0].id
def test_deepcopy(self) -> None:
- entity = Entity()
+ entity = SingleTypeEntityCollectionTestEntity()
sut = SingleTypeEntityCollection(Entity)
sut.append(entity)
copied_sut = copy.deepcopy(sut)
@@ -120,9 +157,9 @@ def test_deepcopy(self) -> None:
def test_prepend(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity('1')
- entity2 = Entity('2')
- entity3 = Entity('3')
+ entity1 = SingleTypeEntityCollectionTestEntity('1')
+ entity2 = SingleTypeEntityCollectionTestEntity('2')
+ entity3 = SingleTypeEntityCollectionTestEntity('3')
sut.prepend(entity3)
sut.prepend(entity2)
sut.prepend(entity1)
@@ -134,9 +171,9 @@ def test_prepend(self) -> None:
def test_append(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
sut.append(entity3)
sut.append(entity2)
sut.append(entity1)
@@ -146,40 +183,40 @@ def test_append(self) -> None:
def test_remove(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
- entity4 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
+ entity4 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3, entity4)
sut.remove(entity4, entity2)
assert [entity1, entity3] == list(sut)
def test_replace(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
- entity4 = Entity()
- entity5 = Entity()
- entity6 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
+ entity4 = SingleTypeEntityCollectionTestEntity()
+ entity5 = SingleTypeEntityCollectionTestEntity()
+ entity6 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3)
sut.replace(entity4, entity5, entity6)
assert [entity4, entity5, entity6] == list(sut)
def test_clear(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3)
sut.clear()
assert [] == list(sut)
def test_list(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3)
assert entity1 is sut[0]
assert entity2 is sut[1]
@@ -187,25 +224,25 @@ def test_list(self) -> None:
def test_len(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3)
assert 3 == len(sut)
def test_iter(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3)
assert [entity1, entity2, entity3] == list(list(sut))
def test_getitem_by_index(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3)
assert entity1 is sut[0]
assert entity2 is sut[1]
@@ -215,17 +252,17 @@ def test_getitem_by_index(self) -> None:
def test_getitem_by_indices(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3)
assert [entity1, entity3] == list(sut[0::2])
def test_getitem_by_entity_id(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity('1')
- entity2 = Entity('2')
- entity3 = Entity('3')
+ entity1 = SingleTypeEntityCollectionTestEntity('1')
+ entity2 = SingleTypeEntityCollectionTestEntity('2')
+ entity3 = SingleTypeEntityCollectionTestEntity('3')
sut.append(entity1, entity2, entity3)
assert entity1 is sut['1']
assert entity2 is sut['2']
@@ -235,9 +272,9 @@ def test_getitem_by_entity_id(self) -> None:
def test_delitem_by_index(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3)
del sut[1]
@@ -246,9 +283,9 @@ def test_delitem_by_index(self) -> None:
def test_delitem_by_indices(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3)
del sut[0::2]
@@ -257,9 +294,9 @@ def test_delitem_by_indices(self) -> None:
def test_delitem_by_entity(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1, entity2, entity3)
del sut[entity2]
@@ -268,9 +305,9 @@ def test_delitem_by_entity(self) -> None:
def test_delitem_by_entity_id(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity('1')
- entity2 = Entity('2')
- entity3 = Entity('3')
+ entity1 = SingleTypeEntityCollectionTestEntity('1')
+ entity2 = SingleTypeEntityCollectionTestEntity('2')
+ entity3 = SingleTypeEntityCollectionTestEntity('3')
sut.append(entity1, entity2, entity3)
del sut['2']
@@ -279,8 +316,8 @@ def test_delitem_by_entity_id(self) -> None:
def test_contains_by_entity(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1)
assert entity1 in sut
@@ -288,8 +325,8 @@ def test_contains_by_entity(self) -> None:
def test_contains_by_entity_id(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
sut.append(entity1)
assert entity1.id in sut
@@ -302,22 +339,22 @@ def test_contains_by_entity_id(self) -> None:
])
def test_contains_by_unsupported_typed(self, value: Any) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity = Entity()
+ entity = SingleTypeEntityCollectionTestEntity()
sut.append(entity)
assert value not in sut
def test_set_like_functionality(self) -> None:
sut = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
- entity4 = Entity()
- entity5 = Entity()
- entity6 = Entity()
- entity7 = Entity()
- entity8 = Entity()
- entity9 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
+ entity3 = SingleTypeEntityCollectionTestEntity()
+ entity4 = SingleTypeEntityCollectionTestEntity()
+ entity5 = SingleTypeEntityCollectionTestEntity()
+ entity6 = SingleTypeEntityCollectionTestEntity()
+ entity7 = SingleTypeEntityCollectionTestEntity()
+ entity8 = SingleTypeEntityCollectionTestEntity()
+ entity9 = SingleTypeEntityCollectionTestEntity()
# Ensure duplicates are skipped.
sut.append(entity1, entity2, entity3, entity1, entity2, entity3, entity1, entity2, entity3)
# Ensure skipped duplicates do not affect further new values.
@@ -327,8 +364,8 @@ def test_set_like_functionality(self) -> None:
def test_add(self) -> None:
sut1 = SingleTypeEntityCollection(Entity)
sut2 = SingleTypeEntityCollection(Entity)
- entity1 = Entity()
- entity2 = Entity()
+ entity1 = SingleTypeEntityCollectionTestEntity()
+ entity2 = SingleTypeEntityCollectionTestEntity()
sut1.append(entity1)
sut2.append(entity2)
sut_added = sut1 + sut2
@@ -556,73 +593,75 @@ def test_delitem_by_entity_id(self) -> None:
assert [associate2] == list(sut.removed)
-class TestMultipleTypesEntityCollection:
- class _One(Entity):
- pass
+class MultipleTypesEntityCollectionTestEntityOne(Entity):
+ pass
+
+
+class MultipleTypesEntityCollectionTestEntityOther(Entity):
+ pass
- class _Other(Entity):
- pass
+class TestMultipleTypesEntityCollection:
def test_pickle(self) -> None:
- entity_one = self._One()
- entity_other = self._Other()
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
sut = MultipleTypesEntityCollection()
sut.append(entity_one, entity_other)
unpickled_sut = pickle.loads(pickle.dumps(sut))
assert 2 == len(unpickled_sut)
- assert 1 == len(unpickled_sut[self._One])
- assert 1 == len(unpickled_sut[self._Other])
- assert entity_one.id == unpickled_sut[self._One][0].id
- assert entity_other.id == unpickled_sut[self._Other][0].id
+ assert 1 == len(unpickled_sut[MultipleTypesEntityCollectionTestEntityOne])
+ assert 1 == len(unpickled_sut[MultipleTypesEntityCollectionTestEntityOther])
+ assert entity_one.id == unpickled_sut[MultipleTypesEntityCollectionTestEntityOne][0].id
+ assert entity_other.id == unpickled_sut[MultipleTypesEntityCollectionTestEntityOther][0].id
def test_copy(self) -> None:
- entity_one = self._One()
- entity_other = self._Other()
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
sut = MultipleTypesEntityCollection()
sut.append(entity_one, entity_other)
copied_sut = copy.copy(sut)
assert 2 == len(copied_sut)
- assert 1 == len(copied_sut[self._One])
- assert 1 == len(copied_sut[self._Other])
- assert entity_one.id == copied_sut[self._One][0].id
- assert entity_other.id == copied_sut[self._Other][0].id
+ assert 1 == len(copied_sut[MultipleTypesEntityCollectionTestEntityOne])
+ assert 1 == len(copied_sut[MultipleTypesEntityCollectionTestEntityOther])
+ assert entity_one.id == copied_sut[MultipleTypesEntityCollectionTestEntityOne][0].id
+ assert entity_other.id == copied_sut[MultipleTypesEntityCollectionTestEntityOther][0].id
def test_deepcopy(self) -> None:
- entity_one = self._One()
- entity_other = self._Other()
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
sut = MultipleTypesEntityCollection()
sut.append(entity_one, entity_other)
copied_sut = copy.deepcopy(sut)
assert 2 == len(copied_sut)
- assert 1 == len(copied_sut[self._One])
- assert 1 == len(copied_sut[self._Other])
- assert entity_one.id == copied_sut[self._One][0].id
- assert entity_other.id == copied_sut[self._Other][0].id
+ assert 1 == len(copied_sut[MultipleTypesEntityCollectionTestEntityOne])
+ assert 1 == len(copied_sut[MultipleTypesEntityCollectionTestEntityOther])
+ assert entity_one.id == copied_sut[MultipleTypesEntityCollectionTestEntityOne][0].id
+ assert entity_other.id == copied_sut[MultipleTypesEntityCollectionTestEntityOther][0].id
def test_prepend(self) -> None:
sut = MultipleTypesEntityCollection()
- entity_one = self._One()
- entity_other1 = self._Other()
- entity_other2 = self._Other()
- entity_other3 = self._Other()
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other1 = MultipleTypesEntityCollectionTestEntityOther()
+ entity_other2 = MultipleTypesEntityCollectionTestEntityOther()
+ entity_other3 = MultipleTypesEntityCollectionTestEntityOther()
sut.prepend(entity_one, entity_other1, entity_other2, entity_other3)
- assert [entity_other3, entity_other2, entity_other1] == list(sut[self._Other])
+ assert [entity_other3, entity_other2, entity_other1] == list(sut[MultipleTypesEntityCollectionTestEntityOther])
def test_append(self) -> None:
sut = MultipleTypesEntityCollection()
- entity_one = self._One()
- entity_other1 = self._Other()
- entity_other2 = self._Other()
- entity_other3 = self._Other()
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other1 = MultipleTypesEntityCollectionTestEntityOther()
+ entity_other2 = MultipleTypesEntityCollectionTestEntityOther()
+ entity_other3 = MultipleTypesEntityCollectionTestEntityOther()
sut.append(entity_one, entity_other1, entity_other2, entity_other3)
- assert [entity_other1, entity_other2, entity_other3] == list(sut[self._Other])
+ assert [entity_other1, entity_other2, entity_other3] == list(sut[MultipleTypesEntityCollectionTestEntityOther])
def test_remove(self) -> None:
sut = MultipleTypesEntityCollection()
- entity_one = self._One()
- entity_other = self._Other()
- sut[self._One].append(entity_one)
- sut[self._Other].append(entity_other)
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
+ sut[MultipleTypesEntityCollectionTestEntityOne].append(entity_one)
+ sut[MultipleTypesEntityCollectionTestEntityOther].append(entity_other)
sut.remove(entity_one)
assert [entity_other] == list(list(sut))
sut.remove(entity_other)
@@ -630,8 +669,8 @@ def test_remove(self) -> None:
def test_getitem_by_index(self) -> None:
sut = MultipleTypesEntityCollection()
- entity_one = self._One()
- entity_other = self._Other()
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
sut.append(entity_one, entity_other)
assert entity_one is sut[0]
assert entity_other is sut[1]
@@ -640,19 +679,19 @@ def test_getitem_by_index(self) -> None:
def test_getitem_by_indices(self) -> None:
sut = MultipleTypesEntityCollection()
- entity_one = self._One()
- entity_other = self._Other()
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
sut.append(entity_one, entity_other)
assert [entity_one] == list(sut[0:1:1])
assert [entity_other] == list(sut[1::1])
def test_getitem_by_entity_type(self) -> None:
sut = MultipleTypesEntityCollection()
- entity_one = self._One()
- entity_other = self._Other()
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
sut.append(entity_one, entity_other)
- assert [entity_one] == list(sut[self._One])
- assert [entity_other] == list(sut[self._Other])
+ assert [entity_one] == list(sut[MultipleTypesEntityCollectionTestEntityOne])
+ assert [entity_other] == list(sut[MultipleTypesEntityCollectionTestEntityOther])
# Ensure that getting previously unseen entity types automatically creates and returns a new collection.
assert [] == list(sut[Entity])
@@ -669,9 +708,9 @@ def test_getitem_by_entity_type_name(self) -> None:
def test_delitem_by_index(self) -> None:
sut = MultipleTypesEntityCollection()
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = MultipleTypesEntityCollectionTestEntityOne()
+ entity2 = MultipleTypesEntityCollectionTestEntityOne()
+ entity3 = MultipleTypesEntityCollectionTestEntityOne()
sut.append(entity1, entity2, entity3)
del sut[1]
@@ -680,9 +719,9 @@ def test_delitem_by_index(self) -> None:
def test_delitem_by_indices(self) -> None:
sut = MultipleTypesEntityCollection()
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = MultipleTypesEntityCollectionTestEntityOne()
+ entity2 = MultipleTypesEntityCollectionTestEntityOne()
+ entity3 = MultipleTypesEntityCollectionTestEntityOne()
sut.append(entity1, entity2, entity3)
del sut[0::2]
@@ -691,9 +730,9 @@ def test_delitem_by_indices(self) -> None:
def test_delitem_by_entity(self) -> None:
sut = MultipleTypesEntityCollection()
- entity1 = Entity()
- entity2 = Entity()
- entity3 = Entity()
+ entity1 = MultipleTypesEntityCollectionTestEntityOne()
+ entity2 = MultipleTypesEntityCollectionTestEntityOne()
+ entity3 = MultipleTypesEntityCollectionTestEntityOne()
sut.append(entity1, entity2, entity3)
del sut[entity2]
@@ -702,47 +741,47 @@ def test_delitem_by_entity(self) -> None:
def test_delitem_by_entity_type(self) -> None:
sut = MultipleTypesEntityCollection()
- entity = Entity()
- entity_other = _OtherEntity()
+ entity = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
sut.append(entity, entity_other)
- del sut[Entity.entity_type()]
+ del sut[get_entity_type(MultipleTypesEntityCollectionTestEntityOne)]
assert [entity_other] == list(sut)
def test_delitem_by_entity_type_name(self) -> None:
sut = MultipleTypesEntityCollection()
- entity = Entity()
- entity_other = _OtherEntity()
+ entity = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
sut.append(entity, entity_other)
- del sut[get_entity_type_name(Entity.entity_type())]
+ del sut[get_entity_type_name(MultipleTypesEntityCollectionTestEntityOne)]
assert [entity_other] == list(sut)
def test_iter(self) -> None:
sut = MultipleTypesEntityCollection()
- entity_one = self._One()
- entity_other = self._Other()
- sut[self._One].append(entity_one)
- sut[self._Other].append(entity_other)
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
+ sut[MultipleTypesEntityCollectionTestEntityOne].append(entity_one)
+ sut[MultipleTypesEntityCollectionTestEntityOther].append(entity_other)
assert [entity_one, entity_other] == list(list(sut))
def test_len(self) -> None:
sut = MultipleTypesEntityCollection()
- entity_one = self._One()
- entity_other = self._Other()
- sut[self._One].append(entity_one)
- sut[self._Other].append(entity_other)
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other = MultipleTypesEntityCollectionTestEntityOther()
+ sut[MultipleTypesEntityCollectionTestEntityOne].append(entity_one)
+ sut[MultipleTypesEntityCollectionTestEntityOther].append(entity_other)
assert 2 == len(sut)
def test_contain_by_entity(self) -> None:
sut = MultipleTypesEntityCollection()
- entity_one = self._One()
- entity_other1 = self._Other()
- entity_other2 = self._Other()
- sut[self._One].append(entity_one)
- sut[self._Other].append(entity_other1)
+ entity_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity_other1 = MultipleTypesEntityCollectionTestEntityOther()
+ entity_other2 = MultipleTypesEntityCollectionTestEntityOther()
+ sut[MultipleTypesEntityCollectionTestEntityOne].append(entity_one)
+ sut[MultipleTypesEntityCollectionTestEntityOther].append(entity_other1)
assert entity_one in sut
assert entity_other1 in sut
assert entity_other2 not in sut
@@ -754,7 +793,7 @@ def test_contain_by_entity(self) -> None:
])
def test_contains_by_unsupported_typed(self, value: Any) -> None:
sut = MultipleTypesEntityCollection()
- entity = Entity()
+ entity = MultipleTypesEntityCollectionTestEntityOne()
sut.append(entity)
assert value not in sut
@@ -762,10 +801,10 @@ def test_contains_by_unsupported_typed(self, value: Any) -> None:
def test_add(self) -> None:
sut1 = MultipleTypesEntityCollection()
sut2 = MultipleTypesEntityCollection()
- entity1_one = self._One()
- entity1_other = self._One()
- entity2_one = self._Other()
- entity2_other = self._Other()
+ entity1_one = MultipleTypesEntityCollectionTestEntityOne()
+ entity1_other = MultipleTypesEntityCollectionTestEntityOne()
+ entity2_one = MultipleTypesEntityCollectionTestEntityOther()
+ entity2_other = MultipleTypesEntityCollectionTestEntityOther()
sut1.append(entity1_one, entity1_other)
sut2.append(entity2_one, entity2_other)
sut_added = sut1 + sut2
diff --git a/betty/tests/model/test_ancestry.py b/betty/tests/model/test_ancestry.py
index e19562a81..362ed20bf 100644
--- a/betty/tests/model/test_ancestry.py
+++ b/betty/tests/model/test_ancestry.py
@@ -44,11 +44,13 @@ def test_text(self) -> None:
assert text == sut.text
+class HasNotesTestEntity(HasNotes, Entity):
+ pass
+
+
class TestHasNotes:
def test_notes(self) -> None:
- class _HasNotes(HasNotes):
- pass
- sut = _HasNotes()
+ sut = HasNotesTestEntity()
assert [] == list(sut.notes)
@@ -680,7 +682,7 @@ def test_private(self) -> None:
def test_name_with_names(self) -> None:
sut = Person('P1')
- name = PersonName(sut)
+ name = PersonName(sut, 'Janet')
assert name == sut.name
def test_name_without_names(self) -> None:
@@ -733,7 +735,7 @@ def test_associated_files(self) -> None:
sut.files = [file1, file2, file1] # type: ignore
citation = Mock(Citation)
citation.associated_files = [file3, file4, file2]
- name = PersonName(sut)
+ name = PersonName(sut, 'Janet')
name.citations = [citation] # type: ignore
event = Mock(Event)
event.associated_files = [file5, file6, file4]
diff --git a/betty/tests/privatizer/test___init__.py b/betty/tests/privatizer/test___init__.py
index 22df3138a..a4756850e 100644
--- a/betty/tests/privatizer/test___init__.py
+++ b/betty/tests/privatizer/test___init__.py
@@ -9,7 +9,7 @@
from betty.model.ancestry import Person, Presence, Event, Source, File, Subject, Attendee, Citation, Ancestry
from betty.model.event_type import Death, Birth, Marriage
from betty.privatizer import Privatizer, privatize
-from betty.project import ProjectExtensionConfiguration
+from betty.project import ExtensionConfiguration
def _expand_person(generation: int):
@@ -93,7 +93,7 @@ async def test_post_load(self):
citation.files.append(citation_file)
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Privatizer))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Privatizer))
app.project.ancestry.entities.append(person)
app.project.ancestry.entities.append(source)
app.project.ancestry.entities.append(citation)
diff --git a/betty/tests/test_cli.py b/betty/tests/test_cli.py
index ff9d4a57b..0578a6863 100644
--- a/betty/tests/test_cli.py
+++ b/betty/tests/test_cli.py
@@ -10,10 +10,10 @@
from click.testing import CliRunner
from betty import fs
-from betty.config import DumpedConfiguration
+from betty.config import DumpedConfigurationImport
from betty.error import UserFacingError
from betty.os import ChDir
-from betty.project import ProjectConfiguration, ProjectExtensionConfiguration
+from betty.project import ProjectConfiguration, ExtensionConfiguration
from betty.serve import Server
from betty.tests import patch_cache
@@ -65,7 +65,7 @@ def test_configuration_without_help(self, _, __):
def test_help_with_configuration(self, _, __):
configuration = ProjectConfiguration()
- configuration.extensions.add(ProjectExtensionConfiguration(DummyExtension))
+ configuration.extensions.add(ExtensionConfiguration(DummyExtension))
configuration.write()
runner = CliRunner()
result = runner.invoke(main, ('-c', str(configuration.configuration_file_path), '--help',), catch_exceptions=False)
@@ -82,7 +82,7 @@ def test_help_with_invalid_configuration_file_path(self, _, __):
def test_help_with_invalid_configuration(self, _, __):
with TemporaryDirectory() as working_directory_path:
configuration_file_path = Path(working_directory_path) / 'betty.json'
- dumped_configuration: DumpedConfiguration = {}
+ dumped_configuration: DumpedConfigurationImport = {}
with open(configuration_file_path, 'w') as f:
dump(dumped_configuration, f)
@@ -94,7 +94,7 @@ def test_with_discovered_configuration(self, _, __):
with TemporaryDirectory() as working_directory_path:
with open(Path(working_directory_path) / 'betty.json', 'w') as config_file:
url = 'https://example.com'
- dumped_configuration: DumpedConfiguration = {
+ dumped_configuration: DumpedConfigurationImport = {
'base_url': url,
'extensions': {
DummyExtension.name(): None,
diff --git a/betty/tests/test_config.py b/betty/tests/test_config.py
deleted file mode 100644
index 10d9da391..000000000
--- a/betty/tests/test_config.py
+++ /dev/null
@@ -1,28 +0,0 @@
-from tempfile import NamedTemporaryFile
-
-import pytest
-
-from betty.app import App
-from betty.config import _from_json, _from_yaml, ConfigurationError, FileBasedConfiguration
-
-
-class TestFromJson:
- def test_should_error_if_invalid_json(self) -> None:
- with App():
- with pytest.raises(ConfigurationError):
- _from_json('')
-
-
-class TestFromYaml:
- def test_should_error_if_invalid_yaml(self) -> None:
- with App():
- with pytest.raises(ConfigurationError):
- _from_yaml('"foo')
-
-
-class TestFileBasedConfiguration:
- def test_configuration_file_path_should_error_unknown_format(self) -> None:
- configuration = FileBasedConfiguration()
- with NamedTemporaryFile(mode='r+', suffix='.abc') as f:
- with pytest.raises(ConfigurationError):
- configuration.configuration_file_path = f.name
diff --git a/betty/tests/test_error.py b/betty/tests/test_error.py
deleted file mode 100644
index eb3351b0b..000000000
--- a/betty/tests/test_error.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from betty.error import ContextError
-
-
-class TestContextError:
- def test__str__(self):
- message = 'Something went wrong!'
- context = 'Somewhere, at some point...'
- expected = 'Something went wrong!\n- Somewhere, at some point...'
- sut = ContextError(message)
- sut.add_context(context)
- assert expected == str(sut)
diff --git a/betty/tests/test_generate.py b/betty/tests/test_generate.py
index 75132b2e2..a6403266e 100644
--- a/betty/tests/test_generate.py
+++ b/betty/tests/test_generate.py
@@ -11,7 +11,7 @@
from betty.generate import generate
from betty.model.ancestry import Person, Place, Source, PlaceName, File, Event, Citation
from betty.model.event_type import Birth
-from betty.project import LocaleConfiguration
+from betty.project import LocaleConfiguration, EntityTypeConfiguration
def assert_betty_html(app: App, url_path: str) -> Path:
@@ -98,6 +98,7 @@ async def test_links_for_entity_pages(self):
async def test_files(self):
with App() as app:
+ app.project.configuration.entity_types.add(EntityTypeConfiguration(File, True))
await generate(app)
assert_betty_html(app, '/file/index.html')
assert_betty_json(app, '/file/index.json', 'fileCollection')
diff --git a/betty/tests/test_project.py b/betty/tests/test_project.py
index cc8d39a39..6ac047ef3 100644
--- a/betty/tests/test_project.py
+++ b/betty/tests/test_project.py
@@ -6,23 +6,32 @@
from reactives.tests import assert_reactor_called, assert_in_scope, assert_scope_empty
from betty.app import Extension, App, ConfigurableExtension
-from betty.config import Configuration, Configurable, ConfigurationError, DumpedConfiguration
-from betty.model import Entity, get_entity_type_name
-from betty.project import ProjectExtensionConfiguration, ProjectExtensionsConfiguration, ProjectConfiguration, \
- LocaleConfiguration, LocalesConfiguration, EntityReference, EntityReferences
+from betty.config import Configuration, Configurable, DumpedConfigurationImport, DumpedConfigurationExport, \
+ ConfigurationMapping
+from betty.config.load import ConfigurationValidationError, Loader
+from betty.model import Entity, get_entity_type_name, get_entity_type, UserFacingEntity
+from betty.project import ExtensionConfiguration, ExtensionConfigurationMapping, ProjectConfiguration, \
+ LocaleConfiguration, LocaleConfigurationCollection, EntityReference, EntityReferenceCollection, \
+ EntityTypeConfiguration, EntityTypeConfigurationMapping
+from betty.tests.config.test___init__ import raises_no_configuration_errors, raises_configuration_error, \
+ ConfigurationCollectionMappingTestBase
from betty.typing import Void
+class EntityReferenceTestEntity(Entity):
+ pass
+
+
class TestEntityReference:
def test_entity_type_with_constraint(self) -> None:
- entity_type = Entity
+ entity_type = EntityReferenceTestEntity
sut = EntityReference(entity_type_constraint=entity_type)
assert entity_type == sut.entity_type
with pytest.raises(AttributeError):
sut.entity_type = entity_type
def test_entity_type_without_constraint(self) -> None:
- entity_type = Entity
+ entity_type = EntityReferenceTestEntity
sut = EntityReference()
assert sut.entity_type is None
sut.entity_type = entity_type
@@ -36,31 +45,32 @@ def test_entity_id(self) -> None:
assert entity_id == sut.entity_id
def test_load_with_constraint(self) -> None:
- entity_type_constraint = Entity
+ entity_type_constraint = EntityReferenceTestEntity
sut = EntityReference(entity_type_constraint=entity_type_constraint)
entity_id = '123'
dumped_configuration = entity_id
- sut.load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert entity_id == sut.entity_id
def test_load_with_constraint_without_string_should_error(self) -> None:
- entity_type_constraint = Entity
+ entity_type_constraint = EntityReferenceTestEntity
sut = EntityReference(entity_type_constraint=entity_type_constraint)
entity_id = None
dumped_configuration = entity_id
- with App():
- with pytest.raises(ConfigurationError):
- sut.load(dumped_configuration)
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_load_without_constraint(self) -> None:
sut = EntityReference()
- entity_type = Entity
+ entity_type = EntityReferenceTestEntity
entity_id = '123'
dumped_configuration = {
'entity_type': get_entity_type_name(entity_type),
'entity_id': entity_id,
}
- sut.load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert entity_type == sut.entity_type
assert entity_id == sut.entity_id
@@ -70,9 +80,8 @@ def test_load_without_constraint_without_entity_type_should_error(self) -> None:
dumped_configuration = {
'entity_id': entity_id,
}
- with App():
- with pytest.raises(ConfigurationError):
- sut.load(dumped_configuration)
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_load_without_constraint_without_string_entity_type_should_error(self) -> None:
sut = EntityReference()
@@ -81,8 +90,8 @@ def test_load_without_constraint_without_string_entity_type_should_error(self) -
'entity_type': None,
'entity_id': entity_id,
}
- with pytest.raises(ConfigurationError):
- sut.load(dumped_configuration)
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_load_without_constraint_without_importable_entity_type_should_error(self) -> None:
sut = EntityReference()
@@ -91,29 +100,27 @@ def test_load_without_constraint_without_importable_entity_type_should_error(sel
'entity_type': 'betty.non_existent.Entity',
'entity_id': entity_id,
}
- with pytest.raises(ConfigurationError):
- sut.load(dumped_configuration)
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_load_without_constraint_without_entity_id_should_error(self) -> None:
sut = EntityReference()
- entity_type = Entity
+ entity_type = EntityReferenceTestEntity
dumped_configuration = {
'entity_type': get_entity_type_name(entity_type),
}
- with App():
- with pytest.raises(ConfigurationError):
- sut.load(dumped_configuration)
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_load_without_constraint_without_string_entity_id_should_error(self) -> None:
sut = EntityReference()
- entity_type = Entity
+ entity_type = EntityReferenceTestEntity
dumped_configuration = {
'entity_type': get_entity_type_name(entity_type),
'entity_id': None,
}
- with App():
- with pytest.raises(ConfigurationError):
- sut.load(dumped_configuration)
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_dump_with_constraint(self) -> None:
sut = EntityReference(entity_type_constraint=Entity)
@@ -124,7 +131,7 @@ def test_dump_with_constraint(self) -> None:
def test_dump_without_constraint(self) -> None:
sut = EntityReference()
- entity_type = Entity
+ entity_type = EntityReferenceTestEntity
entity_id = '123'
sut.entity_type = entity_type
sut.entity_id = entity_id
@@ -135,39 +142,44 @@ def test_dump_without_constraint(self) -> None:
assert expected == sut.dump()
-class TestEntityReferences:
+class EntityReferenceCollectionTestEntity(Entity):
+ pass
+
+
+class TestEntityReferenceCollection:
@pytest.mark.parametrize('sut', [
- EntityReferences(),
- EntityReferences(entity_type_constraint=Entity),
+ EntityReferenceCollection(),
+ EntityReferenceCollection(entity_type_constraint=EntityReferenceCollectionTestEntity),
])
- def test_load_without_list_should_error(self, sut: EntityReferences) -> None:
+ def test_load_without_list_should_error(self, sut: EntityReferenceCollection) -> None:
dumped_configuration = None
- with App():
- with pytest.raises(ConfigurationError):
- sut.load(dumped_configuration)
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
@pytest.mark.parametrize('sut', [
- EntityReferences(),
- EntityReferences(entity_type_constraint=Entity),
+ EntityReferenceCollection(),
+ EntityReferenceCollection(entity_type_constraint=EntityReferenceCollectionTestEntity),
])
- def test_load_without_entity_references(self, sut: EntityReferences) -> None:
- dumped_configuration: DumpedConfiguration = []
- sut.load(dumped_configuration)
+ def test_load_without_entity_references(self, sut: EntityReferenceCollection) -> None:
+ dumped_configuration: DumpedConfigurationImport = []
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert [] == list(sut)
def test_load_with_constraint_with_entity_references(self) -> None:
- entity_type = Entity
+ entity_type = EntityReferenceCollectionTestEntity
entity_id = '123'
- sut = EntityReferences(entity_type_constraint=entity_type)
+ sut = EntityReferenceCollection(entity_type_constraint=entity_type)
dumped_configuration = [
entity_id,
]
- sut.load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert [EntityReference(entity_type, entity_id)] == list(sut)
def test_load_without_constraint_with_entity_references(self) -> None:
- sut = EntityReferences()
- entity_type = Entity
+ sut = EntityReferenceCollection()
+ entity_type = EntityReferenceCollectionTestEntity
entity_id = '123'
dumped_configuration = [
{
@@ -175,13 +187,14 @@ def test_load_without_constraint_with_entity_references(self) -> None:
'entity_id': entity_id,
},
]
- sut.load(dumped_configuration)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
assert [EntityReference(entity_type, entity_id)] == list(sut)
def test_dump_with_constraint_with_entity_references(self) -> None:
- entity_type = Entity
+ entity_type = EntityReferenceCollectionTestEntity
entity_id = '123'
- sut = EntityReferences(entity_type_constraint=entity_type)
+ sut = EntityReferenceCollection(entity_type_constraint=entity_type)
sut.append(EntityReference(entity_type, entity_id))
expected = [
entity_id,
@@ -189,14 +202,14 @@ def test_dump_with_constraint_with_entity_references(self) -> None:
assert expected == sut.dump()
def test_dump_with_constraint_without_entity_references(self) -> None:
- sut = EntityReferences(entity_type_constraint=Entity)
+ sut = EntityReferenceCollection(entity_type_constraint=EntityReferenceCollectionTestEntity)
expected = Void
assert expected == sut.dump()
def test_dump_without_constraint_with_entity_references(self) -> None:
- entity_type = Entity
+ entity_type = EntityReferenceCollectionTestEntity
entity_id = '123'
- sut = EntityReferences()
+ sut = EntityReferenceCollection()
sut.append(EntityReference(entity_type, entity_id))
expected = [
{
@@ -207,7 +220,7 @@ def test_dump_without_constraint_with_entity_references(self) -> None:
assert expected == sut.dump()
def test_dump_without_constraint_without_entity_references(self) -> None:
- sut = EntityReferences()
+ sut = EntityReferenceCollection()
expected = Void
assert expected == sut.dump()
@@ -232,7 +245,7 @@ def test_alias_explicit(self):
def test_invalid_alias(self):
locale = 'nl-NL'
alias = '/'
- with pytest.raises(ConfigurationError):
+ with pytest.raises(ConfigurationValidationError):
with App():
LocaleConfiguration(locale, alias)
@@ -248,7 +261,7 @@ def test_eq(self, expected, sut, other):
class TestLocalesConfiguration:
def test_getitem(self) -> None:
locale_configuration_a = LocaleConfiguration('nl-NL')
- sut = LocalesConfiguration([
+ sut = LocaleConfigurationCollection([
locale_configuration_a,
])
with assert_in_scope(sut):
@@ -257,7 +270,7 @@ def test_getitem(self) -> None:
def test_delitem(self) -> None:
locale_configuration_a = LocaleConfiguration('nl-NL')
locale_configuration_b = LocaleConfiguration('en-US')
- sut = LocalesConfiguration([
+ sut = LocaleConfigurationCollection([
locale_configuration_a,
locale_configuration_b,
])
@@ -268,17 +281,17 @@ def test_delitem(self) -> None:
def test_delitem_with_one_remaining_locale_configuration(self) -> None:
locale_configuration_a = LocaleConfiguration('nl-NL')
- sut = LocalesConfiguration([
+ sut = LocaleConfigurationCollection([
locale_configuration_a,
])
with App():
- with pytest.raises(ConfigurationError):
+ with pytest.raises(ConfigurationValidationError):
del sut['nl-NL']
def test_iter(self) -> None:
locale_configuration_a = LocaleConfiguration('nl-NL')
locale_configuration_b = LocaleConfiguration('en-US')
- sut = LocalesConfiguration([
+ sut = LocaleConfigurationCollection([
locale_configuration_a,
locale_configuration_b,
])
@@ -288,7 +301,7 @@ def test_iter(self) -> None:
def test_len(self) -> None:
locale_configuration_a = LocaleConfiguration('nl-NL')
locale_configuration_b = LocaleConfiguration('en-US')
- sut = LocalesConfiguration([
+ sut = LocaleConfigurationCollection([
locale_configuration_a,
locale_configuration_b,
])
@@ -298,11 +311,11 @@ def test_len(self) -> None:
def test_eq(self) -> None:
locale_configuration_a = LocaleConfiguration('nl-NL')
locale_configuration_b = LocaleConfiguration('en-US')
- sut = LocalesConfiguration([
+ sut = LocaleConfigurationCollection([
locale_configuration_a,
locale_configuration_b,
])
- other = LocalesConfiguration([
+ other = LocaleConfigurationCollection([
locale_configuration_a,
locale_configuration_b,
])
@@ -311,7 +324,7 @@ def test_eq(self) -> None:
def test_contains(self) -> None:
locale_configuration_a = LocaleConfiguration('nl-NL')
- sut = LocalesConfiguration([
+ sut = LocaleConfigurationCollection([
locale_configuration_a,
])
with assert_in_scope(sut):
@@ -320,26 +333,26 @@ def test_contains(self) -> None:
def test_repr(self) -> None:
locale_configuration_a = LocaleConfiguration('nl-NL')
- sut = LocalesConfiguration([
+ sut = LocaleConfigurationCollection([
locale_configuration_a,
])
with assert_in_scope(sut):
assert isinstance(repr(sut), str)
def test_add(self) -> None:
- sut = LocalesConfiguration()
+ sut = LocaleConfigurationCollection()
with assert_scope_empty():
with assert_reactor_called(sut):
sut.add(LocaleConfiguration('nl-NL'))
def test_default_without_explicit_locale_configurations(self):
- sut = LocalesConfiguration()
+ sut = LocaleConfigurationCollection()
assert LocaleConfiguration('en-US') == sut.default
def test_default_without_explicit_default(self):
locale_configuration_a = LocaleConfiguration('nl-NL')
locale_configuration_b = LocaleConfiguration('en-US')
- sut = LocalesConfiguration([
+ sut = LocaleConfigurationCollection([
locale_configuration_a,
locale_configuration_b,
])
@@ -348,7 +361,7 @@ def test_default_without_explicit_default(self):
def test_default_with_explicit_default(self):
locale_configuration_a = LocaleConfiguration('nl-NL')
locale_configuration_b = LocaleConfiguration('en-US')
- sut = LocalesConfiguration([
+ sut = LocaleConfigurationCollection([
locale_configuration_a,
])
sut.default = locale_configuration_b
@@ -375,100 +388,120 @@ def configuration_type(cls) -> Type[_DummyConfiguration]:
return _DummyConfiguration
-class TestProjectExtensionConfiguration:
+class TestExtensionConfiguration:
def test_extension_type(self) -> None:
extension_type = _DummyExtension
- sut = ProjectExtensionConfiguration(extension_type)
+ sut = ExtensionConfiguration(extension_type)
assert extension_type == sut.extension_type
def test_enabled(self) -> None:
enabled = True
- sut = ProjectExtensionConfiguration(_DummyExtension, enabled)
+ sut = ExtensionConfiguration(_DummyExtension, enabled)
assert enabled == sut.enabled
with assert_reactor_called(sut):
sut.enabled = False
def test_configuration(self) -> None:
extension_type_configuration = Configuration()
- sut = ProjectExtensionConfiguration(Extension, True, extension_type_configuration)
+ sut = ExtensionConfiguration(Extension, True, extension_type_configuration)
assert extension_type_configuration == sut.extension_configuration
with assert_reactor_called(sut):
extension_type_configuration.react.trigger()
@pytest.mark.parametrize('expected, one, other', [
- (True, ProjectExtensionConfiguration(_DummyExtension, True), ProjectExtensionConfiguration(_DummyExtension, True)),
- (True, ProjectExtensionConfiguration(_DummyExtension, True, None), ProjectExtensionConfiguration(_DummyExtension, True, None)),
- (False, ProjectExtensionConfiguration(_DummyExtension, True, Configuration()), ProjectExtensionConfiguration(_DummyExtension, True, Configuration())),
- (False, ProjectExtensionConfiguration(_DummyExtension, True), ProjectExtensionConfiguration(_DummyExtension, False)),
- (False, ProjectExtensionConfiguration(_DummyExtension, True), ProjectExtensionConfiguration(_DummyConfigurableExtension, True)),
+ (True, ExtensionConfiguration(_DummyExtension, True), ExtensionConfiguration(_DummyExtension, True)),
+ (True, ExtensionConfiguration(_DummyExtension, True, None), ExtensionConfiguration(_DummyExtension, True, None)),
+ (False, ExtensionConfiguration(_DummyExtension, True, Configuration()), ExtensionConfiguration(_DummyExtension, True, Configuration())),
+ (False, ExtensionConfiguration(_DummyExtension, True), ExtensionConfiguration(_DummyExtension, False)),
+ (False, ExtensionConfiguration(_DummyExtension, True), ExtensionConfiguration(_DummyConfigurableExtension, True)),
])
- def test_eq(self, expected: bool, one: ProjectExtensionConfiguration, other: ProjectExtensionConfiguration) -> None:
+ def test_eq(self, expected: bool, one: ExtensionConfiguration, other: ExtensionConfiguration) -> None:
assert expected == (one == other)
-class TestProjectExtensionsConfiguration:
- def test_getitem(self) -> None:
- app_extension_configuration_a = ProjectExtensionConfiguration(DummyConfigurableExtension)
- sut = ProjectExtensionsConfiguration([
- app_extension_configuration_a,
- ])
- with assert_in_scope(sut):
- assert app_extension_configuration_a == sut[DummyConfigurableExtension]
+class TestExtensionConfigurationMapping(ConfigurationCollectionMappingTestBase):
+ def get_sut(self) -> ConfigurationMapping:
+ return ExtensionConfigurationMapping()
- def test_delitem(self) -> None:
- app_extension_configuration = ProjectExtensionConfiguration(DummyConfigurableExtension)
- sut = ProjectExtensionsConfiguration([
- app_extension_configuration,
- ])
- with assert_scope_empty():
- with assert_reactor_called(sut):
- del sut[DummyConfigurableExtension]
- assert [] == list(sut)
- assert [] == list(app_extension_configuration.react._reactors)
+ def get_configuration_key(self) -> Any:
+ return DummyConfigurableExtension
- def test_iter(self) -> None:
- app_extension_configuration_a = ProjectExtensionConfiguration(DummyConfigurableExtension)
- app_extension_configuration_b = ProjectExtensionConfiguration(DummyNonConfigurableExtension)
- sut = ProjectExtensionsConfiguration([
- app_extension_configuration_a,
- app_extension_configuration_b,
- ])
- with assert_in_scope(sut):
- assert [app_extension_configuration_a, app_extension_configuration_b] == list(iter(sut))
- def test_len(self) -> None:
- app_extension_configuration_a = ProjectExtensionConfiguration(DummyConfigurableExtension)
- app_extension_configuration_b = ProjectExtensionConfiguration(DummyNonConfigurableExtension)
- sut = ProjectExtensionsConfiguration([
- app_extension_configuration_a,
- app_extension_configuration_b,
- ])
- with assert_in_scope(sut):
- assert 2 == len(sut)
+class EntityTypeConfigurationTestEntityOne(UserFacingEntity):
+ pass
- def test_eq(self) -> None:
- app_extension_configuration_a = ProjectExtensionConfiguration(DummyConfigurableExtension)
- app_extension_configuration_b = ProjectExtensionConfiguration(DummyNonConfigurableExtension)
- sut = ProjectExtensionsConfiguration([
- app_extension_configuration_a,
- app_extension_configuration_b,
- ])
- other = ProjectExtensionsConfiguration([
- app_extension_configuration_a,
- app_extension_configuration_b,
- ])
- with assert_in_scope(sut):
- assert other == sut
- def test_add(self) -> None:
- sut = ProjectExtensionsConfiguration()
- app_extension_configuration = ProjectExtensionConfiguration(DummyConfigurableExtension)
- with assert_scope_empty():
- with assert_reactor_called(sut):
- sut.add(app_extension_configuration)
- assert app_extension_configuration == sut[DummyConfigurableExtension]
+class EntityTypeConfigurationTestEntityOther(UserFacingEntity):
+ pass
+
+
+class TestEntityTypeConfiguration:
+ def test_entity_type(self) -> None:
+ entity_type = EntityTypeConfigurationTestEntityOne
+ sut = EntityTypeConfiguration(entity_type)
+ assert entity_type == sut.entity_type
+
+ @pytest.mark.parametrize('generate_html_list,', [
+ True,
+ False,
+ ])
+ def test_generate_html_list(self, generate_html_list: bool) -> None:
+ sut = EntityTypeConfiguration(EntityTypeConfigurationTestEntityOne)
with assert_reactor_called(sut):
- app_extension_configuration.react.trigger()
+ sut.generate_html_list = generate_html_list
+ assert generate_html_list == sut.generate_html_list
+
+ def test_load_with_minimal_configuration(self) -> None:
+ dumped_configuration: DumpedConfigurationImport = {}
+ sut = EntityTypeConfiguration(EntityTypeConfigurationTestEntityOne)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+
+ @pytest.mark.parametrize('generate_html_list,', [
+ True,
+ False,
+ ])
+ def test_load_with_generate_html_list(self, generate_html_list: bool) -> None:
+ dumped_configuration = {
+ 'generate_html_list': generate_html_list,
+ }
+ sut = EntityTypeConfiguration(EntityTypeConfigurationTestEntityOne)
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ loader.commit()
+ assert generate_html_list == sut.generate_html_list
+
+ def test_dump_with_minimal_configuration(self) -> None:
+ sut = EntityTypeConfiguration(EntityTypeConfigurationTestEntityOne)
+ expected = Void
+ assert expected == sut.dump()
+
+ def test_dump_with_generate_html_list(self) -> None:
+ sut = EntityTypeConfiguration(EntityTypeConfigurationTestEntityOne, False)
+ expected = {
+ 'generate_html_list': False,
+ }
+ assert expected == sut.dump()
+
+ @pytest.mark.parametrize('expected, one, other', [
+ (True, EntityTypeConfiguration(EntityTypeConfigurationTestEntityOne, True), EntityTypeConfiguration(EntityTypeConfigurationTestEntityOne, True)),
+ (False, EntityTypeConfiguration(EntityTypeConfigurationTestEntityOne, True), EntityTypeConfiguration(EntityTypeConfigurationTestEntityOne, False)),
+ (False, EntityTypeConfiguration(EntityTypeConfigurationTestEntityOne, True), EntityTypeConfiguration(EntityTypeConfigurationTestEntityOther, True)),
+ ])
+ def test_eq(self, expected: bool, one: EntityTypeConfiguration, other: EntityTypeConfiguration) -> None:
+ assert expected == (one == other)
+
+
+class EntityTypeConfigurationMappingTestEntity(UserFacingEntity, Entity):
+ pass
+
+
+class TestEntityTypeConfigurationMapping(ConfigurationCollectionMappingTestBase):
+ def get_sut(self) -> ConfigurationMapping:
+ return EntityTypeConfigurationMapping()
+
+ def get_configuration_key(self) -> Any:
+ return get_entity_type(EntityTypeConfigurationMappingTestEntity)
class TestProjectConfiguration:
@@ -481,13 +514,13 @@ def test_base_url(self):
def test_base_url_without_scheme_should_error(self):
sut = ProjectConfiguration()
with App():
- with pytest.raises(ConfigurationError):
+ with pytest.raises(ConfigurationValidationError):
sut.base_url = '/'
def test_base_url_without_path_should_error(self):
sut = ProjectConfiguration()
with App():
- with pytest.raises(ConfigurationError):
+ with pytest.raises(ConfigurationValidationError):
sut.base_url = 'file://'
def test_root_path(self):
@@ -527,33 +560,36 @@ def test_author_with_author(self):
def test_load_should_load_minimal(self) -> None:
dumped_configuration: Any = ProjectConfiguration().dump()
assert dumped_configuration is not Void
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- assert dumped_configuration['base_url'] == configuration.base_url
- assert 'Betty' == configuration.title
- assert configuration.author is None
- assert not configuration.debug
- assert '' == configuration.root_path
- assert not configuration.clean_urls
- assert not configuration.content_negotiation
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ assert dumped_configuration['base_url'] == sut.base_url
+ assert 'Betty' == sut.title
+ assert sut.author is None
+ assert not sut.debug
+ assert '' == sut.root_path
+ assert not sut.clean_urls
+ assert not sut.content_negotiation
def test_load_should_load_title(self) -> None:
title = 'My first Betty site'
dumped_configuration: Any = ProjectConfiguration().dump()
assert dumped_configuration is not Void
dumped_configuration['title'] = title
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- assert title == configuration.title
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ assert title == sut.title
def test_load_should_load_author(self) -> None:
author = 'Bart'
dumped_configuration: Any = ProjectConfiguration().dump()
assert dumped_configuration is not Void
dumped_configuration['author'] = author
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- assert author == configuration.author
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ assert author == sut.author
def test_load_should_load_locale_locale(self) -> None:
locale = 'nl-NL'
@@ -563,9 +599,10 @@ def test_load_should_load_locale_locale(self) -> None:
dumped_configuration: Any = ProjectConfiguration().dump()
assert dumped_configuration is not Void
dumped_configuration['locales'] = [locale_config]
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- assert LocalesConfiguration([LocaleConfiguration(locale)]) == configuration.locales
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ assert LocaleConfigurationCollection([LocaleConfiguration(locale)]) == sut.locales
def test_load_should_load_locale_alias(self) -> None:
locale = 'nl-NL'
@@ -577,9 +614,10 @@ def test_load_should_load_locale_alias(self) -> None:
dumped_configuration: Any = ProjectConfiguration().dump()
assert dumped_configuration is not Void
dumped_configuration['locales'] = [locale_config]
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- assert LocalesConfiguration([LocaleConfiguration(locale, alias)]) == configuration.locales
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ assert LocaleConfigurationCollection([LocaleConfiguration(locale, alias)]) == sut.locales
def test_load_should_root_path(self) -> None:
configured_root_path = '/betty/'
@@ -587,27 +625,30 @@ def test_load_should_root_path(self) -> None:
dumped_configuration: Any = ProjectConfiguration().dump()
assert dumped_configuration is not Void
dumped_configuration['root_path'] = configured_root_path
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- assert expected_root_path == configuration.root_path
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ assert expected_root_path == sut.root_path
def test_load_should_clean_urls(self) -> None:
clean_urls = True
dumped_configuration: Any = ProjectConfiguration().dump()
assert dumped_configuration is not Void
dumped_configuration['clean_urls'] = clean_urls
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- assert clean_urls == configuration.clean_urls
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ assert clean_urls == sut.clean_urls
def test_load_should_content_negotiation(self) -> None:
content_negotiation = True
dumped_configuration: Any = ProjectConfiguration().dump()
assert dumped_configuration is not Void
dumped_configuration['content_negotiation'] = content_negotiation
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- assert content_negotiation == configuration.content_negotiation
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ assert content_negotiation == sut.content_negotiation
@pytest.mark.parametrize('debug', [
True,
@@ -617,9 +658,10 @@ def test_load_should_load_debug(self, debug: bool) -> None:
dumped_configuration: Any = ProjectConfiguration().dump()
assert dumped_configuration is not Void
dumped_configuration['debug'] = debug
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- assert debug == configuration.debug
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ assert debug == sut.debug
def test_load_should_load_one_extension_with_configuration(self) -> None:
dumped_configuration: Any = ProjectConfiguration().dump()
@@ -632,12 +674,13 @@ def test_load_should_load_one_extension_with_configuration(self) -> None:
'configuration': extension_configuration,
},
}
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- expected = ProjectExtensionConfiguration(DummyConfigurableExtension, True, DummyConfigurableExtensionConfiguration(
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ expected = ExtensionConfiguration(DummyConfigurableExtension, True, DummyConfigurableExtensionConfiguration(
check=1337,
))
- assert expected == configuration.extensions[DummyConfigurableExtension]
+ assert expected == sut.extensions[DummyConfigurableExtension]
def test_load_should_load_one_extension_without_configuration(self) -> None:
dumped_configuration: Any = ProjectConfiguration().dump()
@@ -645,10 +688,11 @@ def test_load_should_load_one_extension_without_configuration(self) -> None:
dumped_configuration['extensions'] = {
DummyNonConfigurableExtension.name(): {},
}
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
- expected = ProjectExtensionConfiguration(DummyNonConfigurableExtension, True)
- assert expected == configuration.extensions[DummyNonConfigurableExtension]
+ sut = ProjectConfiguration()
+ with raises_no_configuration_errors() as loader:
+ sut.load(dumped_configuration, loader)
+ expected = ExtensionConfiguration(DummyNonConfigurableExtension, True)
+ assert expected == sut.extensions[DummyNonConfigurableExtension]
def test_load_extension_with_invalid_configuration_should_raise_error(self):
dumped_configuration: Any = ProjectConfiguration().dump()
@@ -656,10 +700,9 @@ def test_load_extension_with_invalid_configuration_should_raise_error(self):
dumped_configuration['extensions'] = {
DummyConfigurableExtension.name(): 1337,
}
- with App():
- with pytest.raises(ConfigurationError):
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
+ sut = ProjectConfiguration()
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_load_unknown_extension_type_name_should_error(self):
dumped_configuration: Any = ProjectConfiguration().dump()
@@ -667,9 +710,9 @@ def test_load_unknown_extension_type_name_should_error(self):
dumped_configuration['extensions'] = {
'non.existent.type': None,
}
- with pytest.raises(ConfigurationError):
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
+ sut = ProjectConfiguration()
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_load_not_an_extension_type_name_should_error(self):
dumped_configuration: Any = ProjectConfiguration().dump()
@@ -677,52 +720,50 @@ def test_load_not_an_extension_type_name_should_error(self):
dumped_configuration['extensions'] = {
'%s.%s' % (self.__class__.__module__, self.__class__.__name__): None,
}
- with App():
- with pytest.raises(ConfigurationError):
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
+ sut = ProjectConfiguration()
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_load_should_error_if_invalid_config(self) -> None:
dumped_configuration: Dict = {}
- with App():
- with pytest.raises(ConfigurationError):
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
+ sut = ProjectConfiguration()
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
def test_dump_should_dump_minimal(self) -> None:
- configuration = ProjectConfiguration()
- dumped_configuration: Any = configuration.dump()
+ sut = ProjectConfiguration()
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
- assert dumped_configuration['base_url'] == configuration.base_url
- assert 'Betty' == configuration.title
- assert configuration.author is None
- assert not configuration.debug
- assert '' == configuration.root_path
- assert not configuration.clean_urls
- assert not configuration.content_negotiation
+ assert dumped_configuration['base_url'] == sut.base_url
+ assert 'Betty' == sut.title
+ assert sut.author is None
+ assert not sut.debug
+ assert '' == sut.root_path
+ assert not sut.clean_urls
+ assert not sut.content_negotiation
def test_dump_should_dump_title(self) -> None:
title = 'My first Betty site'
- configuration = ProjectConfiguration()
- configuration.title = title
- dumped_configuration: Any = configuration.dump()
+ sut = ProjectConfiguration()
+ sut.title = title
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
assert title == dumped_configuration['title']
def test_dump_should_dump_author(self) -> None:
author = 'Bart'
- configuration = ProjectConfiguration()
- configuration.author = author
- dumped_configuration: Any = configuration.dump()
+ sut = ProjectConfiguration()
+ sut.author = author
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
assert author == dumped_configuration['author']
def test_dump_should_dump_locale_locale(self) -> None:
locale = 'nl-NL'
locale_configuration = LocaleConfiguration(locale)
- configuration = ProjectConfiguration()
- configuration.locales.replace([locale_configuration])
- dumped_configuration: Any = configuration.dump()
+ sut = ProjectConfiguration()
+ sut.locales.replace([locale_configuration])
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
assert [
{
@@ -734,9 +775,9 @@ def test_dump_should_dump_locale_alias(self) -> None:
locale = 'nl-NL'
alias = 'nl'
locale_configuration = LocaleConfiguration(locale, alias)
- configuration = ProjectConfiguration()
- configuration.locales.replace([locale_configuration])
- dumped_configuration: Any = configuration.dump()
+ sut = ProjectConfiguration()
+ sut.locales.replace([locale_configuration])
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
assert [
{
@@ -747,25 +788,25 @@ def test_dump_should_dump_locale_alias(self) -> None:
def test_dump_should_dump_root_path(self) -> None:
root_path = 'betty'
- configuration = ProjectConfiguration()
- configuration.root_path = root_path
- dumped_configuration: Any = configuration.dump()
+ sut = ProjectConfiguration()
+ sut.root_path = root_path
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
assert root_path == dumped_configuration['root_path']
def test_dump_should_dump_clean_urls(self) -> None:
clean_urls = True
- configuration = ProjectConfiguration()
- configuration.clean_urls = clean_urls
- dumped_configuration: Any = configuration.dump()
+ sut = ProjectConfiguration()
+ sut.clean_urls = clean_urls
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
assert clean_urls == dumped_configuration['clean_urls']
def test_dump_should_dump_content_negotiation(self) -> None:
content_negotiation = True
- configuration = ProjectConfiguration()
- configuration.content_negotiation = content_negotiation
- dumped_configuration: Any = configuration.dump()
+ sut = ProjectConfiguration()
+ sut.content_negotiation = content_negotiation
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
assert content_negotiation == dumped_configuration['content_negotiation']
@@ -774,18 +815,18 @@ def test_dump_should_dump_content_negotiation(self) -> None:
False,
])
def test_dump_should_dump_debug(self, debug: bool) -> None:
- configuration = ProjectConfiguration()
- configuration.debug = debug
- dumped_configuration: Any = configuration.dump()
+ sut = ProjectConfiguration()
+ sut.debug = debug
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
assert debug == dumped_configuration['debug']
def test_dump_should_dump_one_extension_with_configuration(self) -> None:
- configuration = ProjectConfiguration()
- configuration.extensions.add(ProjectExtensionConfiguration(DummyConfigurableExtension, True, DummyConfigurableExtensionConfiguration(
+ sut = ProjectConfiguration()
+ sut.extensions.add(ExtensionConfiguration(DummyConfigurableExtension, True, DummyConfigurableExtensionConfiguration(
check=1337,
)))
- dumped_configuration: Any = configuration.dump()
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
expected = {
'enabled': True,
@@ -796,9 +837,9 @@ def test_dump_should_dump_one_extension_with_configuration(self) -> None:
assert expected == dumped_configuration['extensions'][DummyConfigurableExtension.name()]
def test_dump_should_dump_one_extension_without_configuration(self) -> None:
- configuration = ProjectConfiguration()
- configuration.extensions.add(ProjectExtensionConfiguration(DummyNonConfigurableExtension))
- dumped_configuration: Any = configuration.dump()
+ sut = ProjectConfiguration()
+ sut.extensions.add(ExtensionConfiguration(DummyNonConfigurableExtension))
+ dumped_configuration: Any = sut.dump()
assert dumped_configuration is not Void
expected = {
'enabled': True,
@@ -807,10 +848,9 @@ def test_dump_should_dump_one_extension_without_configuration(self) -> None:
def test_dump_should_error_if_invalid_config(self) -> None:
dumped_configuration: Dict = {}
- with App():
- with pytest.raises(ConfigurationError):
- configuration = ProjectConfiguration()
- configuration.load(dumped_configuration)
+ sut = ProjectConfiguration()
+ with raises_configuration_error(error_type=ConfigurationValidationError) as loader:
+ sut.load(dumped_configuration, loader)
class DummyNonConfigurableExtension(Extension):
@@ -829,15 +869,16 @@ def default(cls) -> Configuration:
def __eq__(self, other):
return self.check == other.check and self.default == other.default
- def load(self, dumped_configuration: DumpedConfiguration) -> None:
- if not isinstance(dumped_configuration, dict):
- raise ConfigurationError
-
- if 'check' not in dumped_configuration:
- raise ConfigurationError
- self.check = dumped_configuration['check']
+ def load(self, dumped_configuration: DumpedConfigurationImport, loader: Loader) -> None:
+ with loader.assert_required_key(
+ dumped_configuration,
+ 'check',
+ loader.assert_int, # type: ignore
+ ) as (dumped_check, valid):
+ if valid:
+ loader.assert_setattr(self, 'check', dumped_check)
- def dump(self) -> DumpedConfiguration:
+ def dump(self) -> DumpedConfigurationExport:
return {
'check': self.check,
}
diff --git a/betty/tests/test_url.py b/betty/tests/test_url.py
index 9e7b841d5..f075032d6 100644
--- a/betty/tests/test_url.py
+++ b/betty/tests/test_url.py
@@ -3,7 +3,7 @@
import pytest
from betty.app import App
-from betty.model import Entity
+from betty.model import UserFacingEntity, Entity
from betty.model.ancestry import Person, Place, File, Source, PlaceName, Event, Citation
from betty.model.event_type import Death
from betty.project import LocaleConfiguration
@@ -67,23 +67,25 @@ def test_generate_multilingual(self):
assert '/en/index.html' == sut.generate('/index.html', 'text/html')
-class TestEntityUrlGenerator:
- class UrlyEntity(Entity):
- pass
+class EntityUrlGeneratorTestUrlyEntity(UserFacingEntity, Entity):
+ pass
+
- class NonUrlyEntity(Entity):
- pass
+class EntityUrlGeneratorTestNonUrlyEntity(UserFacingEntity, Entity):
+ pass
+
+class TestEntityUrlGenerator:
def test_generate(self):
with App() as app:
- sut = _EntityUrlGenerator(app, self.UrlyEntity, 'prefix/%s/index.%s')
- assert '/prefix/I1/index.html' == sut.generate(self.UrlyEntity('I1'), 'text/html')
+ sut = _EntityUrlGenerator(app, EntityUrlGeneratorTestUrlyEntity)
+ assert '/betty.tests.test_url.-entity-url-generator-test-urly-entity/I1/index.html' == sut.generate(EntityUrlGeneratorTestUrlyEntity('I1'), 'text/html')
def test_generate_with_invalid_value(self):
with App() as app:
- sut = _EntityUrlGenerator(app, self.UrlyEntity, 'prefix/%s/index.html')
+ sut = _EntityUrlGenerator(app, EntityUrlGeneratorTestUrlyEntity)
with pytest.raises(ValueError):
- sut.generate(self.NonUrlyEntity(), 'text/html')
+ sut.generate(EntityUrlGeneratorTestNonUrlyEntity(), 'text/html')
class TestAppUrlGenerator:
diff --git a/betty/tests/trees/test___init__.py b/betty/tests/trees/test___init__.py
index 4ee500157..a65790008 100644
--- a/betty/tests/trees/test___init__.py
+++ b/betty/tests/trees/test___init__.py
@@ -1,6 +1,6 @@
from betty.app import App
from betty.generate import generate
-from betty.project import ProjectExtensionConfiguration
+from betty.project import ExtensionConfiguration
from betty.tests import patch_cache
from betty.trees import Trees
@@ -10,7 +10,7 @@ class TestTrees:
async def test_post_generate_event(self):
with App() as app:
app.project.configuration.debug = True
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Trees))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Trees))
await generate(app)
with open(app.project.configuration.www_directory_path / 'trees.js', encoding='utf-8') as f:
betty_js = f.read()
diff --git a/betty/tests/wikipedia/test___init__.py b/betty/tests/wikipedia/test___init__.py
index ae0c8d0ca..4b555a955 100644
--- a/betty/tests/wikipedia/test___init__.py
+++ b/betty/tests/wikipedia/test___init__.py
@@ -9,7 +9,7 @@
from pytest_mock import MockerFixture
from betty.media_type import MediaType
-from betty.project import LocaleConfiguration, ProjectExtensionConfiguration
+from betty.project import LocaleConfiguration, ExtensionConfiguration
from betty.tests import patch_cache
try:
@@ -435,7 +435,7 @@ def test_filter(self, aioresponses: aioresponses) -> None:
aioresponses.get(api_url, payload=api_response_body)
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Wikipedia))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Wikipedia))
actual = app.jinja2_environment.from_string(
'{% for entry in (links | wikipedia) %}{{ entry.content }}{% endfor %}').render(links=links)
assert extract == actual
@@ -472,7 +472,7 @@ async def test_post_load(self, aioresponses: aioresponses) -> None:
aioresponses.get(translations_api_url, payload=translations_api_response_body)
with App() as app:
- app.project.configuration.extensions.add(ProjectExtensionConfiguration(Wikipedia))
+ app.project.configuration.extensions.add(ExtensionConfiguration(Wikipedia))
app.project.ancestry.entities.append(resource)
await load(app)
diff --git a/betty/url.py b/betty/url.py
index ec21f17dc..c5322ae44 100644
--- a/betty/url.py
+++ b/betty/url.py
@@ -6,9 +6,9 @@
from betty.app import App
from betty.locale import negotiate_locale
from betty.media_type import EXTENSIONS
-from betty.model import Entity
-from betty.model.ancestry import PersonName, Event, Place, File, Source, Citation, Note, Person
+from betty.model import get_entity_type_name, UserFacingEntity
from betty.project import ProjectConfiguration
+from betty.string import camel_case_to_kebab_case
class ContentNegotiationUrlGenerator:
@@ -38,39 +38,28 @@ def generate(self, resource: Any, absolute: bool = False, ) -> str:
class _EntityUrlGenerator(ContentNegotiationUrlGenerator):
- def __init__(self, app: App, entity_type: Type[Entity], pattern: str):
+ def __init__(self, app: App, entity_type: Type[UserFacingEntity]):
self._app = app
self._entity_type = entity_type
- self._pattern = pattern
+ self._pattern = f'{camel_case_to_kebab_case(get_entity_type_name(entity_type))}/{{entity_id}}/index.{{extension}}'
- def generate(self, entity: Entity, media_type: str, absolute: bool = False) -> str:
+ def generate(self, entity: UserFacingEntity, media_type: str, absolute: bool = False) -> str:
if not isinstance(entity, self._entity_type):
raise ValueError('%s is not a %s' % (type(entity), self._entity_type))
- return _generate_from_path(self._app.project.configuration, self._pattern % (entity.id, EXTENSIONS[media_type]), absolute, self._app.locale)
-
-
-class PersonNameUrlGenerator(ContentNegotiationUrlGenerator):
- def __init__(self, person_url_generator: ContentNegotiationUrlGenerator):
- self._person_url_generator = person_url_generator
-
- def generate(self, name: PersonName, media_type: str, absolute: bool = False) -> str:
- if not isinstance(name, PersonName):
- raise ValueError('%s is not a %s' % (type(name), PersonName))
- return self._person_url_generator.generate(name.person, media_type, absolute)
+ return _generate_from_path(self._app.project.configuration, self._pattern.format(
+ entity_id=entity.id,
+ extension=EXTENSIONS[media_type],
+ ), absolute, self._app.locale)
class AppUrlGenerator(ContentNegotiationUrlGenerator):
def __init__(self, app: App):
- person_url_generator = _EntityUrlGenerator(app, Person, 'person/%s/index.%s')
self._generators = [
- person_url_generator,
- PersonNameUrlGenerator(person_url_generator),
- _EntityUrlGenerator(app, Event, 'event/%s/index.%s'),
- _EntityUrlGenerator(app, Place, 'place/%s/index.%s'),
- _EntityUrlGenerator(app, File, 'file/%s/index.%s'),
- _EntityUrlGenerator(app, Source, 'source/%s/index.%s'),
- _EntityUrlGenerator(app, Citation, 'citation/%s/index.%s'),
- _EntityUrlGenerator(app, Note, 'note/%s/index.%s'),
+ *(
+ _EntityUrlGenerator(app, entity_type)
+ for entity_type in app.entity_types
+ if issubclass(entity_type, UserFacingEntity)
+ ),
ContentNegotiationPathUrlGenerator(app),
]
diff --git a/bin/test b/bin/test
index 625fd8bcb..3d9ffeeb9 100755
--- a/bin/test
+++ b/bin/test
@@ -41,4 +41,4 @@ for package_command in "${PACKAGE_COMMANDS[@]}"; do
echo "$build_output"
exit $build_exit_code
fi
-done
\ No newline at end of file
+done
diff --git a/setup.py b/setup.py
index e22d64ea2..aae529941 100644
--- a/setup.py
+++ b/setup.py
@@ -56,7 +56,7 @@
'PyQt6 ~= 6.4.0',
'pyyaml ~= 6.0.0',
'reactives ~= 0.4.2',
- 'typing_extensions ~= 4.4.0; python_version < "3.10"',
+ 'typing_extensions ~= 4.4.0; python_version < "3.11"',
],
'extras_require': {
'development': [
@@ -67,7 +67,8 @@
'flake8 ~= 5.0.4',
'html5lib ~= 1.1',
'lxml ~= 4.9.1; sys.platform != "win32"',
- 'mypy ~= 0.982',
+ # @todo Set this to ~= 0.992 (or whichever version comes after 0.991) once that version has been released.
+ 'mypy @ git+https://github.com/python/mypy.git@b8c03ab6809aab56928f3cd865edb44944a600a2',
'pip-licenses ~= 4.0.0-rc3',
'pyinstaller ~= 5.0',
'pytest ~= 7.2.0',