You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
209 lines
7.0 KiB
209 lines
7.0 KiB
import pytest
|
|
|
|
from jinja2 import Environment
|
|
from jinja2 import Markup
|
|
|
|
|
|
class MyDict(dict):
|
|
pass
|
|
|
|
|
|
class TestTestsCase:
|
|
def test_defined(self, env):
|
|
tmpl = env.from_string("{{ missing is defined }}|{{ true is defined }}")
|
|
assert tmpl.render() == "False|True"
|
|
|
|
def test_even(self, env):
|
|
tmpl = env.from_string("""{{ 1 is even }}|{{ 2 is even }}""")
|
|
assert tmpl.render() == "False|True"
|
|
|
|
def test_odd(self, env):
|
|
tmpl = env.from_string("""{{ 1 is odd }}|{{ 2 is odd }}""")
|
|
assert tmpl.render() == "True|False"
|
|
|
|
def test_lower(self, env):
|
|
tmpl = env.from_string("""{{ "foo" is lower }}|{{ "FOO" is lower }}""")
|
|
assert tmpl.render() == "True|False"
|
|
|
|
# Test type checks
|
|
@pytest.mark.parametrize(
|
|
"op,expect",
|
|
(
|
|
("none is none", True),
|
|
("false is none", False),
|
|
("true is none", False),
|
|
("42 is none", False),
|
|
("none is true", False),
|
|
("false is true", False),
|
|
("true is true", True),
|
|
("0 is true", False),
|
|
("1 is true", False),
|
|
("42 is true", False),
|
|
("none is false", False),
|
|
("false is false", True),
|
|
("true is false", False),
|
|
("0 is false", False),
|
|
("1 is false", False),
|
|
("42 is false", False),
|
|
("none is boolean", False),
|
|
("false is boolean", True),
|
|
("true is boolean", True),
|
|
("0 is boolean", False),
|
|
("1 is boolean", False),
|
|
("42 is boolean", False),
|
|
("0.0 is boolean", False),
|
|
("1.0 is boolean", False),
|
|
("3.14159 is boolean", False),
|
|
("none is integer", False),
|
|
("false is integer", False),
|
|
("true is integer", False),
|
|
("42 is integer", True),
|
|
("3.14159 is integer", False),
|
|
("(10 ** 100) is integer", True),
|
|
("none is float", False),
|
|
("false is float", False),
|
|
("true is float", False),
|
|
("42 is float", False),
|
|
("4.2 is float", True),
|
|
("(10 ** 100) is float", False),
|
|
("none is number", False),
|
|
("false is number", True),
|
|
("true is number", True),
|
|
("42 is number", True),
|
|
("3.14159 is number", True),
|
|
("complex is number", True),
|
|
("(10 ** 100) is number", True),
|
|
("none is string", False),
|
|
("false is string", False),
|
|
("true is string", False),
|
|
("42 is string", False),
|
|
('"foo" is string', True),
|
|
("none is sequence", False),
|
|
("false is sequence", False),
|
|
("42 is sequence", False),
|
|
('"foo" is sequence', True),
|
|
("[] is sequence", True),
|
|
("[1, 2, 3] is sequence", True),
|
|
("{} is sequence", True),
|
|
("none is mapping", False),
|
|
("false is mapping", False),
|
|
("42 is mapping", False),
|
|
('"foo" is mapping', False),
|
|
("[] is mapping", False),
|
|
("{} is mapping", True),
|
|
("mydict is mapping", True),
|
|
("none is iterable", False),
|
|
("false is iterable", False),
|
|
("42 is iterable", False),
|
|
('"foo" is iterable', True),
|
|
("[] is iterable", True),
|
|
("{} is iterable", True),
|
|
("range(5) is iterable", True),
|
|
("none is callable", False),
|
|
("false is callable", False),
|
|
("42 is callable", False),
|
|
('"foo" is callable', False),
|
|
("[] is callable", False),
|
|
("{} is callable", False),
|
|
("range is callable", True),
|
|
),
|
|
)
|
|
def test_types(self, env, op, expect):
|
|
t = env.from_string(f"{{{{ {op} }}}}")
|
|
assert t.render(mydict=MyDict(), complex=complex(1, 2)) == str(expect)
|
|
|
|
def test_upper(self, env):
|
|
tmpl = env.from_string('{{ "FOO" is upper }}|{{ "foo" is upper }}')
|
|
assert tmpl.render() == "True|False"
|
|
|
|
def test_equalto(self, env):
|
|
tmpl = env.from_string(
|
|
"{{ foo is eq 12 }}|"
|
|
"{{ foo is eq 0 }}|"
|
|
"{{ foo is eq (3 * 4) }}|"
|
|
'{{ bar is eq "baz" }}|'
|
|
'{{ bar is eq "zab" }}|'
|
|
'{{ bar is eq ("ba" + "z") }}|'
|
|
"{{ bar is eq bar }}|"
|
|
"{{ bar is eq foo }}"
|
|
)
|
|
assert (
|
|
tmpl.render(foo=12, bar="baz")
|
|
== "True|False|True|True|False|True|True|False"
|
|
)
|
|
|
|
@pytest.mark.parametrize(
|
|
"op,expect",
|
|
(
|
|
("eq 2", True),
|
|
("eq 3", False),
|
|
("ne 3", True),
|
|
("ne 2", False),
|
|
("lt 3", True),
|
|
("lt 2", False),
|
|
("le 2", True),
|
|
("le 1", False),
|
|
("gt 1", True),
|
|
("gt 2", False),
|
|
("ge 2", True),
|
|
("ge 3", False),
|
|
),
|
|
)
|
|
def test_compare_aliases(self, env, op, expect):
|
|
t = env.from_string(f"{{{{ 2 is {op} }}}}")
|
|
assert t.render() == str(expect)
|
|
|
|
def test_sameas(self, env):
|
|
tmpl = env.from_string("{{ foo is sameas false }}|{{ 0 is sameas false }}")
|
|
assert tmpl.render(foo=False) == "True|False"
|
|
|
|
def test_no_paren_for_arg1(self, env):
|
|
tmpl = env.from_string("{{ foo is sameas none }}")
|
|
assert tmpl.render(foo=None) == "True"
|
|
|
|
def test_escaped(self, env):
|
|
env = Environment(autoescape=True)
|
|
tmpl = env.from_string("{{ x is escaped }}|{{ y is escaped }}")
|
|
assert tmpl.render(x="foo", y=Markup("foo")) == "False|True"
|
|
|
|
def test_greaterthan(self, env):
|
|
tmpl = env.from_string("{{ 1 is greaterthan 0 }}|{{ 0 is greaterthan 1 }}")
|
|
assert tmpl.render() == "True|False"
|
|
|
|
def test_lessthan(self, env):
|
|
tmpl = env.from_string("{{ 0 is lessthan 1 }}|{{ 1 is lessthan 0 }}")
|
|
assert tmpl.render() == "True|False"
|
|
|
|
def test_multiple_tests(self):
|
|
items = []
|
|
|
|
def matching(x, y):
|
|
items.append((x, y))
|
|
return False
|
|
|
|
env = Environment()
|
|
env.tests["matching"] = matching
|
|
tmpl = env.from_string(
|
|
"{{ 'us-west-1' is matching '(us-east-1|ap-northeast-1)'"
|
|
" or 'stage' is matching '(dev|stage)' }}"
|
|
)
|
|
assert tmpl.render() == "False"
|
|
assert items == [
|
|
("us-west-1", "(us-east-1|ap-northeast-1)"),
|
|
("stage", "(dev|stage)"),
|
|
]
|
|
|
|
def test_in(self, env):
|
|
tmpl = env.from_string(
|
|
'{{ "o" is in "foo" }}|'
|
|
'{{ "foo" is in "foo" }}|'
|
|
'{{ "b" is in "foo" }}|'
|
|
"{{ 1 is in ((1, 2)) }}|"
|
|
"{{ 3 is in ((1, 2)) }}|"
|
|
"{{ 1 is in [1, 2] }}|"
|
|
"{{ 3 is in [1, 2] }}|"
|
|
'{{ "foo" is in {"foo": 1}}}|'
|
|
'{{ "baz" is in {"bar": 1}}}'
|
|
)
|
|
assert tmpl.render() == "True|True|False|True|False|True|False|True|False"
|