def test_as_html():
# str case
assert format_html('{}', as_html(part='foo', context={})) == 'foo'
assert format_html('{}',
as_html(part='<foo>bar</foo>',
context={})) == '<foo>bar</foo>'
assert format_html('{}',
as_html(part=mark_safe('<foo>bar</foo>'),
context={})) == '<foo>bar</foo>'
# Template case
request = req('get')
assert format_html(
'{}', as_html(request=request, part=Template('foo'),
context={})) == 'foo'
assert format_html(
'{}',
as_html(request=request, part=Template('<foo>bar</foo>'),
context={})) == '<foo>bar</foo>'
# __html__ attribute case
assert format_html(
'{}', as_html(part=Struct(__html__=lambda: 'foo'),
context={})) == 'foo'
assert format_html(
'{}',
as_html(part=Struct(__html__=lambda: '<foo>bar</foo>'),
context={})) == '<foo>bar</foo>'
assert format_html(
'{}',
as_html(part=Struct(__html__=lambda: mark_safe('<foo>bar</foo>')),
context={})) == '<foo>bar</foo>'
def test_order_after_name_last():
sorts_right(dict(
foo=Struct(expected_position=0),
quux=Struct(after='qoox', expected_position=3),
qoox=Struct(after=LAST, expected_position=2),
bar=Struct(expected_position=1),
))
def rows(admin, **_):
for app_name, models in items(django_apps.all_models):
has_yielded_header = False
for model_name, model in sorted(items(models), key=lambda x: x[1]._meta.verbose_name_plural):
if not admin.apps.get(f'{app_name}_{model_name}', {}).get('include', False):
continue
if not has_yielded_header:
yield Struct(
name=app_verbose_name_by_label[app_name],
verbose_app_name=app_verbose_name_by_label[app_name],
url=None,
format=lambda row, table, **_: Header(row.name, _name='invalid_name').bind(parent=table).__html__()
)
has_yielded_header = True
yield Struct(
verbose_app_name=app_verbose_name_by_label[app_name],
app_name=app_name,
name=model._meta.verbose_name_plural.capitalize(),
url='%s/%s/' % (app_name, model_name),
format=lambda row, **_: row.name,
)
def test_order_after_name_last():
sorts_right([
Struct(name='foo', expected_position=0),
Struct(name='quux', after='qoox', expected_position=3),
Struct(name='qoox', after=LAST, expected_position=2),
Struct(name='bar', expected_position=1),
])
def test_sort_after_chaining():
sorts_right(
dict(
foo=Struct(after='bar', expected_position=1),
bar=Struct(after=0, expected_position=0),
)
)
def test_order_after_LAST():
sorts_right(dict(
foo=Struct(expected_position=0),
bar=Struct(expected_position=1),
quux=Struct(after=LAST, expected_position=3),
baz=Struct(expected_position=2),
))
def __init__(self, _name=None, **kwargs):
self._declared_members = Struct()
self._bound_members = Struct()
self._evaluate_parameters = None
self._name = _name
super(Traversable, self).__init__(**kwargs)
def test_traverse():
bar = Struct(
_name='bar',
_declared_members=dict(
baz=Struct(_name='baz'),
buzz=Struct(_name='buzz'),
),
)
foo = Struct(
_name='foo',
_declared_members=dict(bar=bar, ),
)
root = StubTraversable(
_name='root',
members=Struct(foo=foo),
)
expected = {
'': '',
'foo': 'foo',
'bar': 'foo/bar',
'baz': 'foo/bar/baz',
'buzz': 'foo/bar/buzz',
}
actual = build_long_path_by_path(root)
assert items(actual) == items(expected)
assert len(keys(actual)) == len(set(keys(actual)))
def test_sort_after_name_chaining():
sorts_right(
dict(
baz=Struct(after='foo', expected_position=2),
foo=Struct(after='bar', expected_position=1),
bar=Struct(after=0, expected_position=0),
))
def test_sort_after_indexes():
sorts_right(
dict(
baz=Struct(after=1, expected_position=2),
foo=Struct(after=0, expected_position=1),
bar=Struct(after=-1, expected_position=0),
))
def test_order_after_name_interleave():
sorts_right(dict(
foo=Struct(expected_position=0),
bar=Struct(expected_position=3),
qoox=Struct(after=1, expected_position=2),
quux=Struct(after='foo', expected_position=1),
))
def test_apply_style_not_affecting_definition_2():
register_style(
'foo_style',
Style(MenuItem__attrs__class__foo=True, ),
)
register_style(
'bar_style',
Style(MenuItem__attrs__class__bar=True, ),
)
class MyPage(Page):
menu = Menu(sub_menu=dict(root=MenuItem()))
class OtherPage(Page):
menu = MyPage.menu
page = MyPage(iommi_style='foo_style').bind(request=Struct(path=''))
assert page.parts.menu.sub_menu.root.attrs['class'] == dict(foo=True)
page = OtherPage(iommi_style='bar_style').bind(request=Struct(path=''))
assert page.parts.menu.sub_menu.root.attrs['class'] == dict(bar=True)
unregister_style('foo_style')
unregister_style('bar_style')
def test_find_target_with_invalid_path():
bar = StubTraversable(_name='bar')
foo = StubTraversable(
_name='foo',
members=Struct(
bar=bar,
),
)
root = StubTraversable(
_name='root',
members=Struct(foo=foo),
)
root = root.bind(request=None)
with pytest.raises(InvalidEndpointPathException) as e:
find_target(path='/foo/bar/baz', root=root)
assert (
str(e.value) == "Given path /foo/bar/baz not found.\n"
" Short alternatives:\n"
" ''\n"
" foo\n"
" bar\n"
" Long alternatives:\n"
" ''\n"
" foo\n"
" foo/bar"
)
def test_order_after_0():
sorts_right([
Struct(name='foo', expected_position=1),
Struct(name='bar', expected_position=2),
Struct(name='quux', after=0, expected_position=0),
Struct(name='baz', expected_position=3),
])
def test_find_target():
bar = 'bar'
foo = Struct(children=lambda: Struct(bar=bar, ), )
root = Struct(children=lambda: Struct(foo=foo), )
target, parents = find_target(path='/foo/bar', root=root)
assert target is bar
assert parents == [root, foo]
def test_sort_after_points_to_nothing_plural():
with pytest.raises(KeyError) as e:
sort_after(dict(
quux=Struct(),
foo=Struct(after='does-not-exist2'),
quux6=Struct(after='does-not-exist'),
))
assert e.value.args[0] == """\
def __init__(self, *args, **kwargs):
for arg in args:
if isinstance(arg, PRESENT):
assert arg.attribute_name not in kwargs, "%s used with PRESENT and kwarg at the same time" % arg.attribute_name
kwargs[arg.attribute_name] = PRESENT
else: # pragma: no cover
assert False, "Unexpected position argument: %s" % (
arg, ) # pragma: no mutate
token_attributes = self.get_declared()
if type(self) is Token:
# Make a fake definition if user did not bother to make a proper sub-class
token_attributes_from_kwargs = [(name, TokenAttribute())
for name in kwargs]
token_attributes = dict(
list(token_attributes.items()) + token_attributes_from_kwargs)
new_kwargs = Struct()
for name, token_attribute in token_attributes.items():
default = token_attribute.default
if token_attribute.default is MISSING:
default = None
new_kwargs[name] = kwargs.pop(name, default)
object.__setattr__(self, '__override__',
kwargs.pop('__override__', False))
assert len(kwargs) == 0, "Unexpected constructor arguments: %s" % (
kwargs, ) # pragma: no mutate
if new_kwargs.name is not None:
for name, token_attribute in token_attributes.items():
if token_attribute.value is not None:
existing_value = new_kwargs[name]
if existing_value is None:
new_kwargs[name] = token_attribute.value(**new_kwargs)
if token_attribute.optional_value is not None:
existing_value = new_kwargs[name]
if existing_value is PRESENT or isinstance(
existing_value, PRESENT):
new_value = token_attribute.optional_value(
**new_kwargs)
# Only update if we got a value (otherwise retain the PRESENT marker)
if new_value is not None:
new_kwargs[name] = new_value
for name, value in new_kwargs.items():
if not isinstance(value, Hashable):
raise ValueError(
"Attribute {} has unhashable value: {}".format(
name, value))
super(Token, self).__init__(**new_kwargs)
def test_order_after_large():
sorts_right(
dict(
foo=Struct(expected_position=2, after=42),
bar=Struct(expected_position=0, ),
quux=Struct(expected_position=3, after=42),
baz=Struct(expected_position=1, after=17),
)
)
def test_sort_after_points_to_nothing_plural():
with pytest.raises(KeyError) as e:
sort_after([
Struct(name='quux'),
Struct(name='foo', after='does-not-exist2'),
Struct(name='quux6', after='does-not-exist'),
])
assert "'Tried to order after does-not-exist, does-not-exist2 but those keys do not exist'" == str(
e.value).replace("u'", "'")
def test_get_display_name():
mock = Struct(_name='foo_bar_TLA')
assert get_display_name(mock) == 'Foo bar TLA'
mock.model_field = Struct()
assert get_display_name(mock) == 'Foo bar TLA'
mock.model_field.verbose_name = None
assert get_display_name(mock) == 'Foo bar TLA'
mock.model_field.verbose_name = 'some other THING'
assert get_display_name(mock) == 'Some other THING'
def children(self):
assert self._is_bound
return Struct(
fields=self.fields,
# TODO: This should be a PagePart
actions=Struct(
name='actions',
children=lambda: self.actions,
_evaluate_attribute_kwargs=lambda: dict(form=self),
),
# TODO: this is a potential name conflict with field and actions above
**setup_endpoint_proxies(self))
def __init__(cls, name, bases, dct):
super(TokenContainerMeta, cls).__init__(name, bases, dct)
prefix = getattr(cls.get_meta(), 'prefix', cls.__name__)
all_tokens = {}
for token_name, token in cls.get_declared().items():
if (token_name in cls.__dict__
and any(token_name in base.get_declared()
for base in bases) and not token.__override__):
raise TypeError(
'Illegal enum value override. Use __override__=True parameter to override.'
)
overrides = Struct()
if token.name is None:
overrides.name = token_name
else:
assert token.name == token_name
if prefix:
assert 'prefix' in token, 'You must define a token attribute called "prefix"'
if token.prefix is None:
overrides.prefix = prefix
if overrides:
new_token = merged(token, overrides)
setattr(cls, token_name, new_token)
token = new_token
if not hasattr(token, '_index'):
global _next_index
# __setattr__ since FrozenStruct is read-only
object.__setattr__(token, '_index', _next_index)
_next_index += 1
if not hasattr(token, '_container'):
# __setattr__ since FrozenStruct is read-only
object.__setattr__(token, '_container',
f"{cls.__module__}.{cls.__name__}")
all_tokens[token.name] = token
cls.tokens = all_tokens
cls.set_declared(cls.tokens)
def test_sort_after_points_to_nothing_plural():
with pytest.raises(KeyError) as e:
sort_after(
dict(
quux=Struct(),
foo=Struct(after='does-not-exist2'),
quux6=Struct(after='does-not-exist'),
))
assert (e.value.args[0] == """\
Tried to order after does-not-exist, does-not-exist2 but those keys do not exist.
Available names:
foo
quux
quux6""")
def test_page_render():
class MyPage(Page):
header = html.h1('Foo')
body = html.div('bar bar')
my_page = MyPage()
request = req('get')
request.user = Struct()
my_page.bind(request=request)
response = my_page.render_to_response()
expected_html = '''
<html>
<head></head>
<body>
<h1> Foo </h1>
<div> bar bar </div>
</body>
</html>
'''
actual = BeautifulSoup(response.content, 'html.parser').prettify()
expected = BeautifulSoup(expected_html, 'html.parser').prettify()
assert actual == expected
def test_escape_quote_freetext():
class MyQuery(Query):
foo = Filter(freetext=True)
query = MyQuery().bind(request=Struct(method='GET', GET={FREETEXT_SEARCH_NAME: '"', '-': '-'}))
assert query.get_query_string() == '(foo:"\\"")'
assert repr(query.get_q()) == repr(Q(**{'foo__icontains': '"'}))
def on_bind(self):
bind_members(self, name='sub_menu')
if self.sort:
self.sub_menu = Struct(
{item._name: item for item in sorted(values(self.sub_menu), key=lambda x: x.display_name)}
)
def collect_members(*, items_dict: Dict = None, items: Dict[str, Any] = None, cls: Type, unapplied_config: Dict) -> Dict[str, Any]:
unbound_items = {}
if items_dict is not None:
for name, x in items_dict.items():
x.name = name
unbound_items[name] = x
if items is not None:
for name, item in items.items():
if not isinstance(item, dict):
item.name = name
unbound_items[name] = item
else:
if name in unbound_items:
unapplied_config[name] = item
else:
item = setdefaults_path(
Namespace(),
item,
call_target__cls=cls,
name=name,
)
unbound_items[name] = item()
return Struct({x.name: x for x in sort_after(list(unbound_items.values()))})
def test_evaluate_attrs_2():
actual = evaluate_attrs(
Struct(attrs=Namespace(
class__table=True,
class__foo=lambda foo: True,
data=1,
data2=lambda foo: foo,
style__foo=1,
style__bar=lambda foo: f'foo{3}',
), ),
foo=3,
)
expected = {
'class': {
'table': True,
'foo': True,
},
'style': {
'foo': 1,
'bar': 'foo3'
},
'data': 1,
'data2': 3,
}
assert actual == expected
def test_empty_class_and_struct_then_something():
assert (str(
evaluate_attrs(Struct(attrs={
'class': {},
'style': {},
'z': 'bar',
}))) == ' z="bar"')
def sink_form_post_handler(form, **_):
if not form.is_valid():
return
values = form.apply(Struct())
return HttpResponse(
format_html("Sink values from form {} was {}", form._name, values))
