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))