def test_passed_in_not_field():
    @dataclass
    class Root:
        pass

    passed_in = dict(xxx=111)
    di = dict()
    with pytest.raises(ValueError):
        make_context(Root, props=passed_in, di=di)
def test_field_missing_di():
    @dataclass
    class Root:
        name: str = dataclasses.field(metadata=dict(di=True))

    passed_in = dict()
    di = dict()
    with pytest.raises(KeyError) as excinfo:
        make_context(Root, props=passed_in, di=di)
    expected = 'Dependency injector cannot find type "str"'
    assert expected in str(excinfo.value)
    def _callblock(self, *args, caller):
        env = self.environment
        component_class = env.components[self.tag_name]

        # Render any child nodes inside the "tags" for this
        # component's usage.
        # TODO Find a way for this to not get access to the
        # global context
        children = caller()

        # Make an instance of this component, to be used as the
        # template context
        di = dict()
        component = make_context(component_class,
                                 self.props,
                                 di,
                                 children=children)

        # Now render
        template = env.load_template(component)
        if template is None:
            # No Jinja2 template, this component should implement render
            result = component.render()
        else:
            d = dataclasses.asdict(component)
            result = template.render(**d)
        return result
def test_none_di_props():
    @dataclass
    class Root:
        name: str = 'default'

    component = make_context(Root)
    assert 'default' == component.name
def test_field_extra_context():
    @dataclass
    class Root:
        name: str

    extra_context = dict(name='extra stuff')
    component = make_context(Root, extra_context=extra_context)
    assert 'extra stuff' == component.name
def test_field_di():
    @dataclass
    class Root:
        name: str = dataclasses.field(metadata=dict(di=True))

    passed_in = dict()
    di = {str: 'DI Forever'}
    component = make_context(Root, props=passed_in, di=di)
    assert 'DI Forever' == component.name
def test_field_default():
    @dataclass
    class Root:
        name: str = 'DEFAULT'

    passed_in = dict()
    di = dict()
    component = make_context(Root, props=passed_in, di=di)
    assert 'DEFAULT' == component.name
def test_passed_in_is_field():
    @dataclass
    class Root:
        name: str

    passed_in = dict(name='hello')
    di = dict()
    component = make_context(Root, props=passed_in, di=di)
    assert 'hello' == component.name
def test_simplest():
    @dataclass
    class Root:
        pass

    passed_in = dict()
    di = dict()
    actual = make_context(Root, props=passed_in, di=di)
    assert dict() == dataclasses.asdict(actual)
Example #10
0
def test_field_passed_in_and_di():
    @dataclass
    class Root:
        name: str = dataclasses.field(metadata=dict(di=True))

    passed_in = dict(name='hello')
    di = dict()
    component = make_context(Root, props=passed_in, di=di)
    assert 'hello' == component.name
Example #11
0
def test_props_extra_context_di():
    @dataclass
    class Root:
        name: str = dataclasses.field(metadata=dict(di=True))

    passed_in = dict(name='hello')
    extra_context = dict(name='extra stuff')
    di = dict()
    component = make_context(Root,
                             props=passed_in,
                             extra_context=extra_context,
                             di=di)
    assert 'hello' == component.name