From: Aleš Mrázek Date: Wed, 25 Oct 2023 13:51:02 +0000 (+0200) Subject: tests: datamodel: templates: WIP X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=refs%2Fenvironments%2Fdocs-develop-data-jboivx%2Fdeployments%2F2843;p=thirdparty%2Fknot-resolver.git tests: datamodel: templates: WIP --- diff --git a/manager/tests/unit/datamodel/templates/test_cache_macros.py b/manager/tests/unit/datamodel/templates/test_cache_macros.py new file mode 100644 index 000000000..690d1fee9 --- /dev/null +++ b/manager/tests/unit/datamodel/templates/test_cache_macros.py @@ -0,0 +1,88 @@ +import pytest + +from knot_resolver_manager.datamodel.cache_schema import PredictionSchema, PrefillSchema +from knot_resolver_manager.datamodel.config_schema import template_from_str + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + [ + PrefillSchema( + { + "origin": ".", + "url": "https://www.internic.net/domain/root.zone", + } + ) + ], + """prefill.config({ + ['.'] = { + url = 'https://www.internic.net/domain/root.zone', + interval = 86400, + } +})""", + ), + ( + [ + PrefillSchema( + { + "origin": ".", + "url": "https://www.internic.net/domain/root.zone", + "refresh-interval": "12h", + "ca-file": "/etc/pki/tls/certs/ca-bundle.crt", + } + ) + ], + """prefill.config({ + ['.'] = { + url = 'https://www.internic.net/domain/root.zone', + interval = 43200, + ca_file = '/etc/pki/tls/certs/ca-bundle.crt', + } +})""", + ), + ], +) +def test_prefill_config(val, lua): + tmpl = template_from_str( + "{% from 'macros/cache_macros.lua.j2' import prefill_config %}" "{{ prefill_config(config) }}" + ) + assert tmpl.render(config=val, negation=False).replace(" ", "") == lua.replace(" ", "") + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + PredictionSchema(), + """predict.config({ + window = 15, + period = 24, +})""", + ), + ( + PredictionSchema( + { + "window": "60m", + } + ), + """predict.config({ + window = 60, + period = 24, +})""", + ), + ( + PredictionSchema({"window": "60m", "period": 48}), + """predict.config({ + window = 60, + period = 48, +})""", + ), + ], +) +def test_predict_config(val, lua): + tmpl = template_from_str( + "{% from 'macros/cache_macros.lua.j2' import predict_config %}" "{{ predict_config(config) }}" + ) + assert tmpl.render(config=val, negation=False) == lua diff --git a/manager/tests/unit/datamodel/templates/test_common_macros.py b/manager/tests/unit/datamodel/templates/test_common_macros.py index b2f363b25..3c9d09c04 100644 --- a/manager/tests/unit/datamodel/templates/test_common_macros.py +++ b/manager/tests/unit/datamodel/templates/test_common_macros.py @@ -1,90 +1,103 @@ +import pytest + from knot_resolver_manager.datamodel.config_schema import template_from_str from knot_resolver_manager.datamodel.forward_schema import ForwardServerSchema -def test_boolean(): - tmpl_str = """{% from 'macros/common_macros.lua.j2' import boolean %} -{{ boolean(x) }}""" - - tmpl = template_from_str(tmpl_str) - assert tmpl.render(x=True) == "true" - assert tmpl.render(x=False) == "false" - - -def test_boolean_neg(): - tmpl_str = """{% from 'macros/common_macros.lua.j2' import boolean %} -{{ boolean(x,true) }}""" - - tmpl = template_from_str(tmpl_str) - assert tmpl.render(x=True) == "false" - assert tmpl.render(x=False) == "true" - +@pytest.mark.parametrize( + "val", + ["string", 55, 5.5, True, None], +) +def test_quotes(val): + tmpl = template_from_str("{% from 'macros/common_macros.lua.j2' import quotes %}{{ quotes(string) }}") + assert tmpl.render(string=val) == f"'{val}'" -def test_string_table(): - s = "any string" - t = [s, "other string"] - tmpl_str = """{% from 'macros/common_macros.lua.j2' import string_table %} -{{ string_table(x) }}""" - tmpl = template_from_str(tmpl_str) - assert tmpl.render(x=s) == f"'{s}'" - assert tmpl.render(x=t) == f"{{'{s}','{t[1]}',}}" +@pytest.mark.parametrize( + "val,lua", + [(True, "true"), (False, "false"), (1, "true"), (0, "false")], +) +def test_boolean(val, lua): + tmpl = template_from_str("{% from 'macros/common_macros.lua.j2' import boolean %}{{ boolean(bool, negation) }}") + assert tmpl.render(bool=val, negation=False) == lua + assert tmpl.render(bool=not bool(val), negation=True) == lua -def test_str2ip_table(): - s = "2001:DB8::d0c" - t = [s, "192.0.2.1"] - tmpl_str = """{% from 'macros/common_macros.lua.j2' import str2ip_table %} -{{ str2ip_table(x) }}""" +# MODULES - tmpl = template_from_str(tmpl_str) - assert tmpl.render(x=s) == f"kres.str2ip('{s}')" - assert tmpl.render(x=t) == f"{{kres.str2ip('{s}'),kres.str2ip('{t[1]}'),}}" - - -def test_qtype_table(): - s = "AAAA" - t = [s, "TXT"] - tmpl_str = """{% from 'macros/common_macros.lua.j2' import qtype_table %} -{{ qtype_table(x) }}""" - - tmpl = template_from_str(tmpl_str) - assert tmpl.render(x=s) == f"kres.type.{s}" - assert tmpl.render(x=t) == f"{{kres.type.{s},kres.type.{t[1]},}}" +@pytest.mark.parametrize( + "val", + ["module_name_to_load"], +) +def test_modules_load(val): + tmpl = template_from_str( + "{% from 'macros/common_macros.lua.j2' import modules_load %}{{ modules_load(module_name) }}" + ) + assert tmpl.render(module_name=val) == f"modules.load('{val}')" -def test_servers_table(): - s = "2001:DB8::d0c" - t = [s, "192.0.2.1"] - tmpl_str = """{% from 'macros/common_macros.lua.j2' import servers_table %} -{{ servers_table(x) }}""" - tmpl = template_from_str(tmpl_str) - assert tmpl.render(x=s) == f"'{s}'" - assert tmpl.render(x=t) == f"{{'{s}','{t[1]}',}}" - assert tmpl.render(x=[{"address": s}, {"address": t[1]}]) == f"{{'{s}','{t[1]}',}}" +@pytest.mark.parametrize( + "val", + ["module_name_to_unload"], +) +def test_modules_unload(val): + tmpl = template_from_str( + "{% from 'macros/common_macros.lua.j2' import modules_unload %}{{ modules_unload(module_name) }}" + ) + assert tmpl.render(module_name=val) == f"modules.unload('{val}')" -def test_tls_servers_table(): - d = ForwardServerSchema( - # the ca-file is a dummy, because it's existence is checked - {"address": ["2001:DB8::d0c"], "hostname": "res.example.com", "ca-file": "/etc/passwd"} +@pytest.mark.parametrize("val,name", [(True, "module_name_to_load"), (False, "module_name_to_unload")]) +def test_module_loader(val, name): + tmpl = template_from_str( + "{% from 'macros/common_macros.lua.j2' import module_loader %}{{ module_loader(bool, module_name) }}" + ) + lua = tmpl.render(bool=val, module_name=name) + if val is True: + assert lua == f"modules.load('{name}')" + elif val is False: + assert lua == f"modules.load('{name}')\nmodules.unload('{name}')" + + +# TABLES + + +@pytest.mark.parametrize( + "val,lua", + [ + ("string", "'string'"), + (["s1", "s2", "s3"], "{'s1','s2','s3',}"), + ], +) +def test_table_or_string(val, lua): + tmpl = template_from_str( + "{% from 'macros/common_macros.lua.j2' import table_or_string %}{{ table_or_string(val) }}" ) - t = [ - d, - ForwardServerSchema( - { - "address": "192.0.2.1", - "pin-sha256": "OTJmODU3ZDMyOWMwOWNlNTU4Y2M0YWNjMjI5NWE2NWJlMzY4MzRmMzY3NGU3NDAwNTI1YjMxZTMxYTgzMzQwMQ==", - } - ), - ] - tmpl_str = """{% from 'macros/common_macros.lua.j2' import tls_servers_table %} -{{ tls_servers_table(x) }}""" - - tmpl = template_from_str(tmpl_str) - assert tmpl.render(x=[d.address, t[1].address]) == f"{{'{d.address}','{t[1].address}',}}" - assert ( - tmpl.render(x=t) - == f"{{{{'{d.address}',hostname='{d.hostname}',ca_file='{d.ca_file}',}},{{'{t[1].address}',pin_sha256={{'{t[1].pin_sha256}',}}}},}}" + assert tmpl.render(val=val) == lua + + +@pytest.mark.parametrize( + "val,lua", + [ + ("2001:DB8::d0c", "kres.str2ip('2001:DB8::d0c')"), + (["2001:DB8::d0c", "192.0.2.1"], "{kres.str2ip('2001:DB8::d0c'),kres.str2ip('192.0.2.1'),}"), + ], +) +def test_table_or_str2ip(val, lua): + tmpl = template_from_str( + "{% from 'macros/common_macros.lua.j2' import table_or_str2ip %}{{ table_or_str2ip(val) }}" ) + assert tmpl.render(val=val) == lua + + +@pytest.mark.parametrize( + "val,lua", + [ + ("AAAA", "kres.type.AAAA"), + (["AAAA", "TXT"], "{kres.type.AAAA,kres.type.TXT,}"), + ], +) +def test_table_or_qtype(val, lua): + tmpl = template_from_str("{% from 'macros/common_macros.lua.j2' import table_or_qtype %}{{ table_or_qtype(val) }}") + assert tmpl.render(val=val) == lua diff --git a/manager/tests/unit/datamodel/templates/test_dns64_macros.py b/manager/tests/unit/datamodel/templates/test_dns64_macros.py new file mode 100644 index 000000000..e9f53bd71 --- /dev/null +++ b/manager/tests/unit/datamodel/templates/test_dns64_macros.py @@ -0,0 +1,36 @@ +import pytest + +from knot_resolver_manager.datamodel.config_schema import template_from_str +from knot_resolver_manager.datamodel.dns64_schema import Dns64Schema + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + Dns64Schema({"prefix": "64:ff9b::/96"}), + """dns64.config({ + prefix = '64:ff9b::', +})""", + ), + ( + Dns64Schema({"prefix": "64:ff9b::/96", "rev-ttl": "5s", "exclude-subnets": ["2001:db8:888::/48"]}), + """dns64.config({ + prefix = '64:ff9b::', + rev_ttl = 5, + exclude_subnets = {'2001:db8:888::/48',}, +})""", + ), + ( + Dns64Schema({"prefix": "64:ff9b::/96", "rev-ttl": "1m", "exclude-subnets": ["2001:db8:888::/48", "::/0"]}), + """dns64.config({ + prefix = '64:ff9b::', + rev_ttl = 60, + exclude_subnets = {'2001:db8:888::/48','::/0',}, +})""", + ), + ], +) +def test_dns64_config(val, lua): + tmpl = template_from_str("{% from 'macros/dns64_macros.lua.j2' import dns64_config %}{{ dns64_config(config) }}") + assert tmpl.render(config=val) == lua diff --git a/manager/tests/unit/datamodel/templates/test_dnssec_macros copy.py b/manager/tests/unit/datamodel/templates/test_dnssec_macros copy.py new file mode 100644 index 000000000..41c81cd16 --- /dev/null +++ b/manager/tests/unit/datamodel/templates/test_dnssec_macros copy.py @@ -0,0 +1,58 @@ +import pytest + +from knot_resolver_manager.datamodel.config_schema import template_from_str +from knot_resolver_manager.datamodel.dnssec_schema import TrustAnchorFileSchema + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + [". 3600 IN DS 19036 8 2 49AAC11...", ". 3600 IN DS 19036 8 2 49AAC11..."], + """trust_anchors.add('. 3600 IN DS 19036 8 2 49AAC11...') +trust_anchors.add('. 3600 IN DS 19036 8 2 49AAC11...')\n""", + ) + ], +) +def test_trust_anchors(val, lua): + tmpl = template_from_str("{% from 'macros/dnssec_macros.lua.j2' import trust_anchors %}" "{{ trust_anchors(tas) }}") + assert tmpl.render(tas=val) == lua + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + ["bad.boy", "example.com"], + """trust_anchors.set_insecure({ + 'bad.boy', + 'example.com', +})""", + ) + ], +) +def test_negative_trust_anchors(val, lua): + tmpl = template_from_str( + "{% from 'macros/dnssec_macros.lua.j2' import negative_trust_anchors %}" "{{ negative_trust_anchors(ntas) }}" + ) + assert tmpl.render(ntas=val) == lua + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + [ + TrustAnchorFileSchema({"file": "/path/to/tafile", "read-only": True}), + TrustAnchorFileSchema({"file": "/path/to/another/tafile"}), + ], + """trust_anchors.add_file('/path/to/tafile', readonly = true) +trust_anchors.add_file('/path/to/another/tafile', readonly = false)\n""", + ) + ], +) +def test_trust_anchors_files(val, lua): + tmpl = template_from_str( + "{% from 'macros/dnssec_macros.lua.j2' import trust_anchors_files %}" "{{ trust_anchors_files(tafs) }}" + ) + assert tmpl.render(tafs=val) == lua diff --git a/manager/tests/unit/datamodel/templates/test_dnssec_macros.py b/manager/tests/unit/datamodel/templates/test_dnssec_macros.py new file mode 100644 index 000000000..41c81cd16 --- /dev/null +++ b/manager/tests/unit/datamodel/templates/test_dnssec_macros.py @@ -0,0 +1,58 @@ +import pytest + +from knot_resolver_manager.datamodel.config_schema import template_from_str +from knot_resolver_manager.datamodel.dnssec_schema import TrustAnchorFileSchema + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + [". 3600 IN DS 19036 8 2 49AAC11...", ". 3600 IN DS 19036 8 2 49AAC11..."], + """trust_anchors.add('. 3600 IN DS 19036 8 2 49AAC11...') +trust_anchors.add('. 3600 IN DS 19036 8 2 49AAC11...')\n""", + ) + ], +) +def test_trust_anchors(val, lua): + tmpl = template_from_str("{% from 'macros/dnssec_macros.lua.j2' import trust_anchors %}" "{{ trust_anchors(tas) }}") + assert tmpl.render(tas=val) == lua + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + ["bad.boy", "example.com"], + """trust_anchors.set_insecure({ + 'bad.boy', + 'example.com', +})""", + ) + ], +) +def test_negative_trust_anchors(val, lua): + tmpl = template_from_str( + "{% from 'macros/dnssec_macros.lua.j2' import negative_trust_anchors %}" "{{ negative_trust_anchors(ntas) }}" + ) + assert tmpl.render(ntas=val) == lua + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + [ + TrustAnchorFileSchema({"file": "/path/to/tafile", "read-only": True}), + TrustAnchorFileSchema({"file": "/path/to/another/tafile"}), + ], + """trust_anchors.add_file('/path/to/tafile', readonly = true) +trust_anchors.add_file('/path/to/another/tafile', readonly = false)\n""", + ) + ], +) +def test_trust_anchors_files(val, lua): + tmpl = template_from_str( + "{% from 'macros/dnssec_macros.lua.j2' import trust_anchors_files %}" "{{ trust_anchors_files(tafs) }}" + ) + assert tmpl.render(tafs=val) == lua diff --git a/manager/tests/unit/datamodel/templates/test_forward_macros.py b/manager/tests/unit/datamodel/templates/test_forward_macros.py index 4e8a5bce9..180776857 100644 --- a/manager/tests/unit/datamodel/templates/test_forward_macros.py +++ b/manager/tests/unit/datamodel/templates/test_forward_macros.py @@ -1,27 +1,210 @@ +import pytest + from knot_resolver_manager.datamodel.config_schema import template_from_str -from knot_resolver_manager.datamodel.forward_schema import ForwardSchema -from knot_resolver_manager.datamodel.types import IPAddressOptionalPort +from knot_resolver_manager.datamodel.forward_schema import ForwardOptionsSchema, ForwardSchema, ForwardServerSchema + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + ForwardOptionsSchema(), + """{ + dnssec = true, + auth = false +}""", + ), + ( + ForwardOptionsSchema({"dnssec": False, "authoritative": True}), + """{ + dnssec = false, + auth = true +}""", + ), + ], +) +def test_forward_options(val, lua): + tmpl = template_from_str( + "{% from 'macros/forward_macros.lua.j2' import forward_options %}" "{{ forward_options(options) }}" + ) + assert tmpl.render(options=val) == lua + + +@pytest.mark.parametrize( + "val,lua", + [ + ( + ( + "2001:148f:fffe::1", + "tls", + "odvr.nic.cz", + "/path/to/ca-file.crt", + ), + """{ + '2001:148f:fffe::1', + tls = true, + hostname = 'odvr.nic.cz', + ca_file = '/path/to/ca-file.crt', +}""", + ), + ( + ( + "2001:148f:fffe::1", + None, + None, + None, + ), + """{ + '2001:148f:fffe::1', + tls = false, +}""", + ), + ], +) +def test_forward_server_config(val, lua): + tmpl = template_from_str( + "{% from 'macros/forward_macros.lua.j2' import forward_server_config %}" + "{{ forward_server_config(address, transport, hostname, pin_sha256, ca_file) }}" + ) + assert tmpl.render(address=val[0], transport=val[1], hostname=val[2], pin_sha256=None, ca_file=val[3]) == lua + + +@pytest.mark.parametrize( + "val,lua", + [ + ("185.43.135.1", "{ '185.43.135.1' },"), + ( + ForwardServerSchema( + { + "address": "2001:148f:fffe::1", + "transport": "tls", + "hostname": "odvr.nic.cz", + "ca-file": "/path/to/ca-file.crt", + } + ), + """{ + '2001:148f:fffe::1', + tls = true, + hostname = 'odvr.nic.cz', + ca_file = '/path/to/ca-file.crt', +}, +""", + ), + ( + ForwardServerSchema( + { + "address": ["2001:148f:fffe::1", "185.43.135.1"], + "transport": "tls", + "hostname": "odvr.nic.cz", + "ca-file": "/path/to/ca-file.crt", + } + ), + """{ + '2001:148f:fffe::1', + tls = true, + hostname = 'odvr.nic.cz', + ca_file = '/path/to/ca-file.crt', +}, +{ + '185.43.135.1', + tls = true, + hostname = 'odvr.nic.cz', + ca_file = '/path/to/ca-file.crt', +}, +""", + ), + ], +) +def test_forward_server(val, lua): + tmpl = template_from_str( + "{% from 'macros/forward_macros.lua.j2' import forward_server %}" "{{ forward_server(server) }}" + ) + assert tmpl.render(server=val) == lua def test_policy_rule_forward_add(): - tmpl_str = """{% from 'macros/forward_macros.lua.j2' import policy_rule_forward_add %} -{{ policy_rule_forward_add(rule.subtree[0],rule.options,rule.servers) }}""" - - rule = ForwardSchema( - { - "subtree": ".", - "servers": [{"address": ["2001:148f:fffe::1", "185.43.135.1"], "hostname": "odvr.nic.cz"}], - "options": { - "authoritative": False, - "dnssec": True, - }, - } + tmpl = template_from_str( + "{% from 'macros/forward_macros.lua.j2' import policy_rule_forward_add %}" + "{{ policy_rule_forward_add(subtree, options, servers) }}" ) - result = "policy.rule_forward_add('.',{dnssec=true,auth=false},{{'2001:148f:fffe::1',tls=false,hostname='odvr.nic.cz',},{'185.43.135.1',tls=false,hostname='odvr.nic.cz',},})" - tmpl = template_from_str(tmpl_str) - assert tmpl.render(rule=rule) == result + lua = """policy.rule_forward_add( + 'subtree', + options, + servers +)""" + + assert tmpl.render(subtree="subtree", options="options", servers="servers") == lua + + +# @pytest.mark.parametrize( +# "val,lua", +# [ +# ( +# ForwardSchema( +# { +# "subtree": ".", +# "servers": [ +# { +# "address": ["2001:148f:fffe::1", "185.43.135.1"], +# "transport": "tls", +# "hostname": "odvr.nic.cz", +# } +# ], +# "options": { +# "authoritative": False, +# "dnssec": True, +# }, +# } +# ), +# """policy.rule_forward_add( +# '.', +# { +# dnssec = true, +# auth = false, +# }, +# { +# { +# '2001:148f:fffe::1', +# tls = true, +# hostname = 'odvr.nic.cz', +# }, +# { +# '185.43.135.1', +# tls = true, +# hostname = 'odvr.nic.cz', +# }, +# }, +# )""", +# ), +# ( +# ForwardSchema( +# { +# "subtree": ".", +# "servers": ["2001:148f:fffe::1", "185.43.135.1"], +# "options": { +# "authoritative": False, +# "dnssec": True, +# }, +# } +# ), +# """policy.rule_forward_add( +# '.', +# { +# dnssec = true, +# auth = false, +# }, +# { +# '2001:148f:fffe::1', +# '185.43.135.1', +# }, +# )""", +# ), +# ], +# ) +# def test_policy_rule_forward_add(val, lua): +# tmpl_str = """{% from 'macros/forward_macros.lua.j2' import forward %} +# {{ forward(fwd) }}""" - rule.servers = [IPAddressOptionalPort("2001:148f:fffe::1"), IPAddressOptionalPort("185.43.135.1")] - result = "policy.rule_forward_add('.',{dnssec=true,auth=false},{{'2001:148f:fffe::1'},{'185.43.135.1'},})" - assert tmpl.render(rule=rule) == result +# tmpl = template_from_str(tmpl_str) +# assert tmpl.render(fwd=val) == lua diff --git a/manager/tests/unit/datamodel/templates/test_network_macros.py b/manager/tests/unit/datamodel/templates/test_network_macros.py index ad193d982..cc42e92cd 100644 --- a/manager/tests/unit/datamodel/templates/test_network_macros.py +++ b/manager/tests/unit/datamodel/templates/test_network_macros.py @@ -1,35 +1,91 @@ +import pytest + from knot_resolver_manager.datamodel.config_schema import template_from_str from knot_resolver_manager.datamodel.network_schema import ListenSchema -def test_network_listen(): - tmpl_str = """{% from 'macros/network_macros.lua.j2' import network_listen %} -{{ network_listen(listen) }}""" - tmpl = template_from_str(tmpl_str) - - soc = ListenSchema({"unix-socket": "/tmp/kresd-socket", "kind": "dot"}) - assert tmpl.render(listen=soc) == "net.listen('/tmp/kresd-socket',nil,{kind='tls',freebind=false})\n" - soc_list = ListenSchema({"unix-socket": [soc.unix_socket.to_std()[0], "/tmp/kresd-socket2"], "kind": "dot"}) - assert ( - tmpl.render(listen=soc_list) - == "net.listen('/tmp/kresd-socket',nil,{kind='tls',freebind=false})\n" - + "net.listen('/tmp/kresd-socket2',nil,{kind='tls',freebind=false})\n" +@pytest.mark.parametrize( + "val,lua", + [ + ("2001:DB8::d0c", "'2001:DB8::d0c'"), + (["2001:DB8::d0c", "192.0.2.1"], "{'2001:DB8::d0c','192.0.2.1',}"), + ], +) +def test_table_or_server(val, lua): + tmpl = template_from_str( + "{% from 'macros/network_macros.lua.j2' import table_or_server %}" "{{ table_or_server(val) }}" ) + assert tmpl.render(val=val) == lua - ip = ListenSchema({"interface": "::1@55", "freebind": True}) - assert tmpl.render(listen=ip) == "net.listen('::1',55,{kind='dns',freebind=true})\n" - ip_list = ListenSchema({"interface": [ip.interface.to_std()[0], "127.0.0.1@5353"]}) - assert ( - tmpl.render(listen=ip_list) - == "net.listen('::1',55,{kind='dns',freebind=false})\n" - + "net.listen('127.0.0.1',5353,{kind='dns',freebind=false})\n" - ) - intrfc = ListenSchema({"interface": "eth0", "kind": "doh2"}) - assert tmpl.render(listen=intrfc) == "net.listen(net.eth0,443,{kind='doh2',freebind=false})\n" - intrfc_list = ListenSchema({"interface": [intrfc.interface.to_std()[0], "lo"], "port": 5555, "kind": "doh2"}) - assert ( - tmpl.render(listen=intrfc_list) - == "net.listen(net.eth0,5555,{kind='doh2',freebind=false})\n" - + "net.listen(net.lo,5555,{kind='doh2',freebind=false})\n" - ) +@pytest.mark.parametrize( + "val,lua", + [ + ( + ListenSchema({"unix-socket": "/tmp/kresd-socket", "kind": "dot"}), + """net.listen('/tmp/kresd-socket', nil, { + kind = 'tls', + freebind = false, +}) +""", + ), + ( + ListenSchema({"unix-socket": ["/tmp/kresd-socket", "/tmp/kresd-socket2"], "kind": "dot"}), + """net.listen('/tmp/kresd-socket', nil, { + kind = 'tls', + freebind = false, +}) +net.listen('/tmp/kresd-socket2', nil, { + kind = 'tls', + freebind = false, +}) +""", + ), + ( + ListenSchema({"interface": "::1@55", "freebind": True}), + """net.listen('::1', 55, { + kind = 'dns', + freebind = true, +}) +""", + ), + ( + ListenSchema({"interface": ["::1@55", "127.0.0.1@5353"]}), + """net.listen('::1', 55, { + kind = 'dns', + freebind = false, +}) +net.listen('127.0.0.1', 5353, { + kind = 'dns', + freebind = false, +}) +""", + ), + ( + ListenSchema({"interface": "eth0", "kind": "doh2"}), + """net.listen(net.eth0, 443, { + kind = 'doh2', + freebind = false, +}) +""", + ), + ( + ListenSchema({"interface": ["eth0", "lo"], "port": 5555, "kind": "doh2"}), + """net.listen(net.eth0, 5555, { + kind = 'doh2', + freebind = false, +}) +net.listen(net.lo, 5555, { + kind = 'doh2', + freebind = false, +}) +""", + ), + ], +) +def test_network_listen(val, lua): + tmpl_str = """{% from 'macros/network_macros.lua.j2' import network_listen %} +{{ network_listen(listen) }}""" + + tmpl = template_from_str(tmpl_str) + assert tmpl.render(listen=val) == lua diff --git a/manager/tests/unit/datamodel/templates/test_view_macros.py b/manager/tests/unit/datamodel/templates/test_view_macros.py index fbc62f49c..230a8885a 100644 --- a/manager/tests/unit/datamodel/templates/test_view_macros.py +++ b/manager/tests/unit/datamodel/templates/test_view_macros.py @@ -1,4 +1,4 @@ -from typing import Any +from typing import Any, List import pytest @@ -6,38 +6,52 @@ from knot_resolver_manager.datamodel.config_schema import template_from_str from knot_resolver_manager.datamodel.view_schema import ViewOptionsSchema, ViewSchema -def test_view_flags(): - tmpl_str = """{% from 'macros/view_macros.lua.j2' import view_flags %} -{{ view_flags(options) }}""" +@pytest.mark.parametrize( + "val,lua", + [ + (None, "0"), + ( + ["udp53", "tcp53", "dot", "doh", "doq"], + "0 + 2^C.KR_PROTO_UDP53 + 2^C.KR_PROTO_TCP53 + 2^C.KR_PROTO_DOT + 2^C.KR_PROTO_DOH + 2^C.KR_PROTO_DOQ", + ), + ], +) +def test_view_protocols(val, lua): + tmpl_str = """{% from 'macros/view_macros.lua.j2' import view_protocols %} +{{ view_protocols(protocols) }}""" tmpl = template_from_str(tmpl_str) - options = ViewOptionsSchema({"dns64": False, "minimize": False}) - assert tmpl.render(options=options) == '"NO_MINIMIZE","DNS64_DISABLE",' - assert tmpl.render(options=ViewOptionsSchema()) == "" + assert tmpl.render(protocols=val) == lua -def test_view_answer(): +@pytest.mark.parametrize( + "val,lua", + [ + (ViewOptionsSchema({"dns64": False, "minimize": False}), '"NO_MINIMIZE",\n"DNS64_DISABLE",\n'), + (ViewOptionsSchema({"minimize": False}), '"NO_MINIMIZE",\n'), + (ViewOptionsSchema({"dns64": False}), '"DNS64_DISABLE",\n'), + (ViewOptionsSchema(), ""), + ], +) +def test_view_options(val, lua): tmpl_str = """{% from 'macros/view_macros.lua.j2' import view_options_flags %} {{ view_options_flags(options) }}""" tmpl = template_from_str(tmpl_str) - options = ViewOptionsSchema({"dns64": False, "minimize": False}) - assert tmpl.render(options=options) == "policy.FLAGS({'NO_MINIMIZE','DNS64_DISABLE',})" - assert tmpl.render(options=ViewOptionsSchema()) == "policy.FLAGS({})" + assert tmpl.render(options=val) == lua @pytest.mark.parametrize( - "val,res", + "val,lua", [ ("allow", "policy.TAGS_ASSIGN({})"), ("refused", "'policy.REFUSE'"), ("noanswer", "'policy.NO_ANSWER'"), ], ) -def test_view_answer(val: Any, res: Any): +def test_view_answer(val, lua): tmpl_str = """{% from 'macros/view_macros.lua.j2' import view_answer %} {{ view_answer(view.answer) }}""" tmpl = template_from_str(tmpl_str) - view = ViewSchema({"subnets": ["10.0.0.0/8"], "answer": val}) - assert tmpl.render(view=view) == res + assert tmpl.render(view=ViewSchema({"subnets": ["10.0.0.0/8"], "answer": val})) == lua