def test_ternary(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|ternary('yes', 'no') }}".encode("UTF-8")) f.seek(0) context = {"text": "kapitan == kapitan"} output = "yes" self.assertEqual(render_jinja2_file(f.name, context), output)
def jinja2_render_file(search_paths, name, ctx): """ Render jinja2 file name with context ctx. search_paths is used to find the file name as there is a limitation with jsonnet's native_callback approach: one can't access the current directory being evaluated """ ctx = json.loads(ctx) _full_path = "" for path in search_paths: _full_path = os.path.join(path, name) logger.debug("jinja2_render_file trying file %s", _full_path) if os.path.exists(_full_path): logger.debug("jinja2_render_file found file at %s", _full_path) try: return render_jinja2_file(_full_path, ctx, search_paths=search_paths) except Exception as e: raise CompileError( "Jsonnet jinja2 failed to render {}: {}".format( _full_path, e)) raise IOError( "jinja2 failed to render, could not find file: {}".format(_full_path))
def test_regex_replace(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|regex_replace(pattern='world', replacement='kapitan') }}".encode("UTF-8")) f.seek(0) context = {"text": "hello world"} output = "hello kapitan" self.assertEqual(render_jinja2_file(f.name, context), output)
def test_base64_decode(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|b64decode }}".encode("UTF-8")) f.seek(0) context = {"text": "dGhpcyBhbmQgdGhhdA=="} output = "this and that" self.assertEqual(render_jinja2_file(f.name, context), output)
def test_regex_findall(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|regex_findall('world.*') }}".encode("UTF-8")) f.seek(0) context = {"text": "hello world"} output = "['world']" self.assertEqual(render_jinja2_file(f.name, context), output)
def test_bool(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|bool }}".encode("UTF-8")) f.seek(0) context = {"text": "yes"} output = "True" self.assertEqual(render_jinja2_file(f.name, context), output)
def test_to_datetime(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|to_datetime }}".encode("UTF-8")) f.seek(0) context = {"text": "2019-03-07 13:37:00"} output = "2019-03-07 13:37:00" self.assertEqual(render_jinja2_file(f.name, context), output)
def test_regex_escape(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|regex_escape }}".encode("UTF-8")) f.seek(0) context = {"text": "+s[a-z].*"} output = "\\+s\\[a\\-z\\]\\.\\*" self.assertEqual(render_jinja2_file(f.name, context), output)
def test_reveal_maybe_tag_no_reveal_flag(self): """ creates ?{base64:some_value} and runs reveal_maybe jinja2 filters without --reveal flag """ with tempfile.NamedTemporaryFile() as f: f.write("{{ my_ref_tag_var|reveal_maybe }}".encode("UTF-8")) f.seek(0) # new argparse namespace with --reveal and --refs-path values namespace = namedtuple("Namespace", []) namespace.reveal = False namespace.refs_path = tempfile.mkdtemp() # reveal_maybe uses cached, so inject namespace cached.args["compile"] = namespace cached.ref_controller_obj = RefController( cached.args["compile"].refs_path) cached.revealer_obj = Revealer(cached.ref_controller_obj) ref_tag = "?{base64:some_value}" ref_value = b"sitar_rock!" cached.ref_controller_obj[ref_tag] = Base64Ref(ref_value) context = {"my_ref_tag_var": ref_tag} self.assertEqual(render_jinja2_file(f.name, context), "?{base64:some_value}")
def test_toml(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|toml }}".encode("UTF-8")) f.seek(0) context = {"text": {"foo": ["this", "that"]}} output = 'foo = [ "this", "that",]\n' self.assertEqual(render_jinja2_file(f.name, context), output)
def test_sha256(self): with tempfile.NamedTemporaryFile() as f: f.write("{{text|sha256}}".encode("UTF-8")) f.seek(0) context = {"text": "this and that"} digest = 'e863c1ac42619a2b429a08775a6acd89ff4c2c6b8dae12e3461a5fa63b2f92f5' self.assertEqual(render_jinja2_file(f.name, context), digest)
def test_yaml(self): with tempfile.NamedTemporaryFile() as f: f.write("{{text|yaml}}".encode("UTF-8")) f.seek(0) context = {"text": ["this", "that"]} yaml = '- this\n- that\n' self.assertEqual(render_jinja2_file(f.name, context), yaml)
def test_reveal_maybe_b64encode_tag(self): """ creates ?{base64:some_value} and runs reveal_maybe|b64encode jinja2 filters """ with tempfile.NamedTemporaryFile() as f: f.write( "{{ my_ref_tag_var|reveal_maybe|b64encode }}".encode("UTF-8")) f.seek(0) # new argparse namespace with --reveal and --refs-path values namespace = namedtuple('Namespace', []) namespace.reveal = True namespace.refs_path = tempfile.mkdtemp() # reveal_maybe uses cached, so inject namespace cached.args['compile'] = namespace cached.ref_controller_obj = RefController( cached.args['compile'].refs_path) cached.revealer_obj = Revealer(cached.ref_controller_obj) ref_tag = '?{base64:some_value}' ref_value = b'sitar_rock!' cached.ref_controller_obj[ref_tag] = Base64Ref(ref_value) context = {"my_ref_tag_var": ref_tag} ref_value_b64 = base64.b64encode(ref_value).decode() self.assertEqual(render_jinja2_file(f.name, context), ref_value_b64)
def test_fileglob(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|fileglob }}".encode("UTF-8")) f.seek(0) context = {"text": "./tests/*jinja2.py"} output = "['./tests/test_jinja2.py']" self.assertEqual(render_jinja2_file(f.name, context), output)
def test_shuffle(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|shuffle }}".encode("UTF-8")) f.seek(0) array = [1, 2, 3, 4, 5] context = {"text": array} self.assertNotEqual(render_jinja2_file(f.name, context), array)
def body(self): self.root.metadata.name = self.kwargs.name self.root.data["tunnel.sh"] = render_jinja2_file( "components/incognito/tunnel.sh.j2", { "rpc_port": self.kwargs.rpc_port, "node_port": self.kwargs.node_port, "public_ip": self.kwargs.public_ip })
def test_strftime(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ text|strftime }}".encode("UTF-8")) f.seek(0) format = "%a, %d %b %Y %H:%M" context = {"text": format} output = time.strftime(format) self.assertEqual(render_jinja2_file(f.name, context), output)
def test_inventory_context(self): with tempfile.NamedTemporaryFile() as f: f.write("{{inventory.parameters.cluster.name}}".encode("UTF-8")) cluster_name = "minikube" target_name = "minikube-es" inv = inventory(["examples/kubernetes"], target_name) context = {"inventory": inv} f.seek(0) self.assertEqual(render_jinja2_file(f.name, context), cluster_name)
def test_inventory_global_context(self): with tempfile.NamedTemporaryFile() as f: target_name = "minikube-es" f.write("{{inventory_global[\"%s\"].parameters.cluster.name}}".encode("UTF-8") % target_name.encode("UTF-8")) cluster_name = "minikube" inv_global = inventory("examples/kubernetes", None) context = {"inventory_global": inv_global} f.seek(0) self.assertEqual(render_jinja2_file(f.name, context), cluster_name)
def test_custom_filter_jinja2(self): with tempfile.NamedTemporaryFile() as f: f.write("{{ inventory.parameters.cluster.name | custom_jinja2_filter }}".encode("UTF-8")) cluster_name = "minikube" target_name = "minikube-es" inv = inventory(["examples/kubernetes"], target_name) context = {"inventory": inv} f.seek(0) actual_output = render_jinja2_file( f.name, context, "./examples/kubernetes/lib/custom_jinja2_filter.py" ) expected_output = base64_encode(cluster_name) self.assertEqual(actual_output, expected_output)
def jinja2_render_file(search_path, name, ctx): """ Render jinja2 file name with context ctx. search_path is used to find the file name as there is a limitation with jsonnet's native_callback approach: one can't access the current directory being evaluated """ ctx = json.loads(ctx) _full_path = os.path.join(search_path, name) logger.debug("jinja2_render_file trying file %s", _full_path) if os.path.exists(_full_path): logger.debug("jinja2_render_file found file at %s", _full_path) return render_jinja2_file(_full_path, ctx) # default IOError if we reach here raise IOError("Could not find file %s" % name)
def jinja2_render_file(search_path, name, ctx): """ Render jinja2 file name with context ctx. search_path is used to find the file name as there is a limitation with jsonnet's native_callback approach: one can't access the current directory being evaluated """ ctx = json.loads(ctx) _full_path = os.path.join(search_path, name) logger.debug("jinja2_render_file trying file %s", _full_path) try: if os.path.exists(_full_path): logger.debug("jinja2_render_file found file at %s", _full_path) return render_jinja2_file(_full_path, ctx) else: raise IOError("Could not find file %s" % name) except Exception as e: logger.error("Jsonnet jinja2 failed to render %s: %s", _full_path, str(e)) raise CompileError(e)
def test_reveal_maybe_no_tag(self): """ runs reveal_maybe jinja2 filter on data without ref tags """ with tempfile.NamedTemporaryFile() as f: f.write("{{ my_var|reveal_maybe }}".encode("UTF-8")) f.seek(0) # new argparse namespace with --reveal and --refs-path values namespace = namedtuple("Namespace", []) namespace.reveal = True namespace.refs_path = tempfile.mkdtemp() # reveal_maybe uses cached, so inject namespace cached.args["compile"] = namespace cached.ref_controller_obj = RefController(cached.args["compile"].refs_path) cached.revealer_obj = Revealer(cached.ref_controller_obj) var_value = "heavy_rock!" context = {"my_var": var_value} self.assertEqual(render_jinja2_file(f.name, context), var_value)
def j2(filename, ctx): return render_jinja2_file(filename, ctx, search_paths=search_paths)