def test_version_match(self):
        env = jinja_utils.get_jinja_environment()

        template = '{{version | version_match(">0.10.0")}}'
        actual = env.from_string(template).render({"version": "0.10.1"})
        expected = "True"
        assert actual == expected
        actual = env.from_string(template).render({"version": "0.1.1"})
        expected = "False"
        assert actual == expected

        template = '{{version | version_match("<0.10.0")}}'
        actual = env.from_string(template).render({"version": "0.1.0"})
        expected = "True"
        assert actual == expected
        actual = env.from_string(template).render({"version": "1.1.0"})
        expected = "False"
        assert actual == expected

        template = '{{version | version_match("==0.10.0")}}'
        actual = env.from_string(template).render({"version": "0.10.0"})
        expected = "True"
        assert actual == expected
        actual = env.from_string(template).render({"version": "0.10.1"})
        expected = "False"
        assert actual == expected
Beispiel #2
0
    def test_filters_regex_substring(self):
        env = jinja_utils.get_jinja_environment()

        # Normal (match)
        template = r'{{input_str | regex_substring("([0-9]{3} \w+ (?:Ave|St|Dr))")}}'
        actual = env.from_string(template).render(
            {"input_str": "My address is 123 Somewhere Ave. See you soon!"})
        expected = "123 Somewhere Ave"
        assert actual == expected

        # Selecting second match explicitly
        template = r'{{input_str | regex_substring("([0-9]{3} \w+ (?:Ave|St|Dr))", 1)}}'
        actual = env.from_string(template).render({
            "input_str":
            "Your address is 567 Elsewhere Dr. My address is 123 Somewhere Ave."
        })
        expected = "123 Somewhere Ave"
        assert actual == expected

        # Selecting second match explicitly, but doesn't exist
        template = r'{{input_str | regex_substring("([0-9]{3} \w+ (?:Ave|St|Dr))", 1)}}'
        with pytest.raises(IndexError):
            actual = env.from_string(template).render(
                {"input_str": "Your address is 567 Elsewhere Dr."})

        # No match
        template = r'{{input_str | regex_substring("([0-3]{3} \w+ (?:Ave|St|Dr))")}}'
        with pytest.raises(IndexError):
            actual = env.from_string(template).render({
                "input_str":
                "My address is 986 Somewhere Ave. See you soon!"
            })
    def test_version_strip_patch(self):
        env = jinja_utils.get_jinja_environment()

        template = "{{version | version_strip_patch}}"
        actual = env.from_string(template).render({"version": "0.10.1"})
        expected = "0.10"
        assert actual == expected
Beispiel #4
0
    def test_filters_regex_replace(self):
        env = jinja_utils.get_jinja_environment()

        template = '{{k1 | regex_replace("x", "y")}}'
        actual = env.from_string(template).render({"k1": "xyz"})
        expected = "yyz"
        assert actual == expected

        template = '{{k1 | regex_replace("(blue|white|red)", "color")}}'
        actual = env.from_string(template).render(
            {"k1": "blue socks and red shoes"})
        expected = "color socks and color shoes"
        assert actual == expected
Beispiel #5
0
    def test_basename(self):
        env = jinja_utils.get_jinja_environment()

        template = "{{k1 | basename}}"
        actual = env.from_string(template).render(
            {"k1": "/some/path/to/file.txt"})
        assert actual == "file.txt"

        actual = env.from_string(template).render({"k1": "/some/path/to/dir"})
        assert actual == "dir"

        actual = env.from_string(template).render({"k1": "/some/path/to/dir/"})
        assert actual == ""
Beispiel #6
0
    def test_filters_regex_match(self):
        env = jinja_utils.get_jinja_environment()

        template = '{{k1 | regex_match("x")}}'
        actual = env.from_string(template).render({"k1": "xyz"})
        expected = "True"
        assert actual == expected

        template = '{{k1 | regex_match("y")}}'
        actual = env.from_string(template).render({"k1": "xyz"})
        expected = "False"
        assert actual == expected

        template = '{{k1 | regex_match("^v(\\d+\\.)?(\\d+\\.)?(\\*|\\d+)$")}}'
        actual = env.from_string(template).render({"k1": "v0.10.1"})
        expected = "True"
        assert actual == expected
    def test_jsonpath_query_static(self):
        env = jinja_utils.get_jinja_environment()
        obj = {
            "people": [
                {"first": "James", "last": "d"},
                {"first": "Jacob", "last": "e"},
                {"first": "Jayden", "last": "f"},
                {"missing": "different"},
            ],
            "foo": {"bar": "baz"},
        }

        template = '{{ obj | jsonpath_query("people[*].first") }}'
        actual_str = env.from_string(template).render({"obj": obj})
        actual = eval(actual_str)
        expected = ["James", "Jacob", "Jayden"]
        assert actual == expected
    def test_version_compare(self):
        env = jinja_utils.get_jinja_environment()

        template = '{{version | version_compare("0.10.0")}}'
        actual = env.from_string(template).render({"version": "0.9.0"})
        expected = "-1"
        assert actual == expected

        template = '{{version | version_compare("0.10.0")}}'
        actual = env.from_string(template).render({"version": "0.10.1"})
        expected = "1"
        assert actual == expected

        template = '{{version | version_compare("0.10.0")}}'
        actual = env.from_string(template).render({"version": "0.10.0"})
        expected = "0"
        assert actual == expected
    def test_version_less_than(self):
        env = jinja_utils.get_jinja_environment()

        template = '{{version | version_less_than("0.10.0")}}'
        actual = env.from_string(template).render({"version": "0.9.0"})
        expected = "True"
        assert actual == expected

        template = '{{version | version_less_than("0.10.0")}}'
        actual = env.from_string(template).render({"version": "0.10.1"})
        expected = "False"
        assert actual == expected

        template = '{{version | version_less_than("0.10.0")}}'
        actual = env.from_string(template).render({"version": "0.10.0"})
        expected = "False"
        assert actual == expected
    def test_jsonpath_query_no_results(self):
        env = jinja_utils.get_jinja_environment()
        obj = {
            "people": [
                {"first": "James", "last": "d"},
                {"first": "Jacob", "last": "e"},
                {"first": "Jayden", "last": "f"},
                {"missing": "different"},
            ],
            "foo": {"bar": "baz"},
        }
        query = "query_returns_no_results"

        template = "{{ obj | jsonpath_query(query) }}"
        actual_str = env.from_string(template).render({"obj": obj, "query": query})
        actual = eval(actual_str)
        expected = None
        assert actual == expected
Beispiel #11
0
 def test_doublequotes(self):
     env = jinja_utils.get_jinja_environment()
     template = "{{ test_str | json_escape }}"
     actual = env.from_string(template).render({"test_str": 'foo """ bar'})
     expected = 'foo \\"\\"\\" bar'
     assert actual == expected
Beispiel #12
0
 def test_tab(self):
     env = jinja_utils.get_jinja_environment()
     template = "{{ test_str | json_escape }}"
     actual = env.from_string(template).render({"test_str": "foo \t bar"})
     expected = "foo \\t bar"
     assert actual == expected