def test_render_tree(resource_tree):
registry = make_registry(root=resource_tree)
register_view(registry, DummyView, context=Resource)
results = render_tree(registry, root=resource_tree)
assert results[''] == '<div>Hello Utils Site from Utils Site</div>'
assert results['/f1'] == '<div>Hello F1 from F1</div>'
assert results['/f1/d1'] == '<div>Hello D1 from D1</div>'
def __post_init__(self, props, extra_props):
# Set some defaults if they weren't provided
story_defaults = get_story_defaults(self.component)
if self.root is None:
self.root = story_defaults.get('root')
if self.resource is None:
self.resource = story_defaults.get('resource')
if self.scannables is None:
self.scannables = story_defaults.get('scannables', tuple())
if self.plugins is None:
self.plugins = story_defaults.get('plugins', tuple())
if self.singletons is None:
self.singletons = story_defaults.get('singletons', tuple())
# Scan this component package but also any dependent components
component_package = getmodule(self.component)
# Make the registry given this story information
self.themester_registry = make_registry(
root=self.root,
plugins=self.plugins,
scannables=self.scannables + (component_package,),
)
# Props: dataclass or dict?
if hasattr(props, '__annotations__'):
# props is a dataclass so asdict to turn into dictionary
self.combined_props = asdict(props)
elif props is not None:
self.combined_props: Dict[str, Any] = props
if extra_props:
self.combined_props = {**self.combined_props, **extra_props}
def test_make_registry_plugin_root_factory():
""" Register a root factory via wired_setup """
from themester.testing import root_factory
registry = make_registry(plugins=root_factory)
container = registry.create_container()
root: root_factory.SampleRoot = container.get(Root)
assert 'Sample Root' == root.title
def test_render_component_with_singletons():
registry = make_registry()
singletons = ((DummySingleton(), DummySingleton),)
result = render_component(
registry, DummyComponent2,
singletons=singletons,
)
assert result == '<div>Hello Dummy Singleton</div>'
def test_render_view_with_singletons():
registry = make_registry()
singletons = ((DummySingleton(), DummySingleton),)
result = render_view(
registry, DummyView2,
singletons=singletons,
)
assert result == '<div>Hello Dummy Singleton</div>'
def test_render_view():
registry = make_registry()
context = resource = DummyContext()
result = render_view(
registry, DummyView,
context=context,
resource=resource,
)
assert result == '<div>Hello DC from DC</div>'
def test_make_registry_scannables():
from themester.testing import utils_plugin1, utils_plugin2
scannables = (utils_plugin1, utils_plugin2)
registry = make_registry(scannables=scannables)
container = registry.create_container()
result1 = container.get(utils_plugin1.Heading1)
assert utils_plugin1.Heading1 is result1
result2 = container.get(utils_plugin2.Heading2)
assert utils_plugin2.Heading2 is result2
def test_resource_factory(this_page_context):
root = Site(title='Some Site')
registry = make_registry(
plugins=sphinx,
root=root,
)
container = registry.create_container()
container.register_singleton(this_page_context, PageContext)
resource: Document = container.get(Resource)
assert 'Some Page' == resource.title
def nullster_registry():
from themester.stories import root
theme_config = NullsterConfig()
plugins = nullster
registry = make_registry(
root=root,
plugins=plugins,
theme_config=theme_config,
)
return registry
def test_render_template():
registry = make_registry()
context = resource = DummyContext()
register_component(registry, DummyComponent)
template = html('<{DummyComponent} />')
result = render_template(
registry, template,
context=context,
resource=resource,
)
assert result == '<div>Hello DC from DC</div>'
def test_render_vdom():
registry = make_registry()
context = resource = DummyContext()
singletons = ((DummyComponent, DummyComponent),)
vdom = html('<{DummyComponent} />')
result = render_vdom(
registry, vdom,
context=context,
resource=resource,
singletons=singletons,
)
assert result == '<div>Hello DC from DC</div>'
def test_render_registered_view():
""" Instead of passing in the view, it is in the registry already"""
registry = make_registry()
context = resource = DummyContext()
register_view(registry, DummyView, context=DummyContext)
result = render_view(
registry,
context=context,
resource=resource,
)
assert result == '<div>Hello DC from DC</div>'
def test_render_vdom_with_singletons():
registry = make_registry()
singletons = (
(DummyComponent2, DummyComponent2),
(DummySingleton(), DummySingleton),
)
vdom = html('<{DummyComponent2} />')
result = render_vdom(
registry, vdom,
singletons=singletons,
)
assert result == '<div>Hello Dummy Singleton</div>'
def themabaster_registry(theme_config, html_config, sphinx_config):
plugins = (
sphinx,
themabaster,
)
registry = make_registry(
root=root,
plugins=plugins,
theme_config=theme_config,
)
registry.register_singleton(html_config, HTMLConfig)
registry.register_singleton(sphinx_config, SphinxConfig)
return registry
def test_resource_factory_render_component(this_page_context):
root = Site(title='Some Site')
registry = make_registry(
plugins=sphinx,
root=root,
)
# Now we can try to render something
template = html('')
result = render_component(registry,
DummyComponent,
singletons=((this_page_context, PageContext), ))
assert '<div>Hello Some Page</div>' == result
def test_themester_bridge_render(page_context):
tb = ThemesterBridge()
registry = make_registry(
root=Site(),
plugins=(sphinx, nullster),
scannables=sphinx,
)
context = dict(
themester_registry=registry,
page_context=page_context,
)
result = tb.render('', context)
assert '<div><h1>Resource: Some Page</h1><span>Hello Nullster</span></div>' == result
def setup_registry(sphinx_config: Config) -> ServiceRegistry:
""" Make a registry that is Themester-aware """
theme_config: ThemeConfig = getattr(sphinx_config, 'theme_config')
themester_root: Site = getattr(sphinx_config, 'themester_root')
themester_plugins = getattr(sphinx_config, 'themester_plugins')
registry = make_registry(
root=themester_root,
plugins=(themester_sphinx, ) + themester_plugins,
theme_config=theme_config,
)
sc = getattr(sphinx_config, 'sphinx_config')
hc = getattr(sphinx_config, 'html_config')
registry.register_singleton(sc, SphinxConfig)
registry.register_singleton(hc, HTMLConfig)
return registry
def test_make_registry_scannable():
from themester.testing import utils_plugin1
registry = make_registry(scannables=utils_plugin1)
container = registry.create_container()
result = container.get(utils_plugin1.Heading1)
assert utils_plugin1.Heading1 is result
def test_make_registry_root():
root = Site()
registry = make_registry(root=root)
container = registry.create_container()
result = container.get(Root)
assert root is result
def test_make_registry_no_root():
registry = make_registry()
container = registry.create_container()
with pytest.raises(LookupError):
container.get(Root)
def test_make_registry_theme_config():
theme_config = NullsterConfig()
registry = make_registry(theme_config=theme_config)
container = registry.create_container()
result = container.get(ThemeConfig)
assert theme_config is result
def test_make_registry_no_theme_config():
registry = make_registry()
container = registry.create_container()
with pytest.raises(LookupError):
container.get(ThemeConfig)
def test_make_registry_scanner():
registry = make_registry()
container = registry.create_container()
scanner = container.get(Scanner)
assert isinstance(scanner, Scanner)
def test_make_registry_passed_in_root_factory():
from themester.testing.root_factory import root_factory, SampleRoot
registry = make_registry(root_factory=root_factory)
container = registry.create_container()
root: SampleRoot = container.get(Root)
assert 'Sample Root' == root.title
def test_make_registry():
registry = make_registry()
assert isinstance(registry, ServiceRegistry)
def test_make_registry_scannable_root_factory():
from themester.testing import root_factory
registry = make_registry(scannables=root_factory)
container = registry.create_container()
root: root_factory.SampleRoot = container.get(Root)
assert 'Sample Root' == root.title
