コード例 #1
0
 def test_isc_clause_zone__clause_stmt_zone_standalone_dict_passing(self):
     assertParserResultDictTrue(
         clause_stmt_zone_standalone, 'zone red { auto-dnssec maintain; };',
         {'zone': {
             'auto_dnssec': 'maintain',
             'zone_name': 'red',
         }})
コード例 #2
0
 def test_isc_optviewzone_stmt_forwarders_passing(self):
     """ Clause options/view/zone; Statement forwarders; passing """
     test_string = [
         'forwarders { 1.1.1.1; };',
         'forwarders { 1.1.1.2 port 53; };',
         'forwarders { 1.1.1.3 port 54 dscp 6; };',
         'forwarders { 1.1.1.4 dscp 5; };',
         'forwarders { fe01::1; };',
         'forwarders { fe01::2 port 55; };',
         'forwarders { fe01::3 port 57 dscp 6; };',
         'forwarders { fe01::4 dscp 5; };',
         'forwarders port 53 { 1.1.1.1; };',
         'forwarders port 53  dscp 1 { 1.1.1.2 port 53; };',
         'forwarders dscp 2 { 1.1.1.3 port 54 dscp 6; };',
         'forwarders port 54 { fe01::1; };',
         'forwarders port 55 dscp 3 { fe01::2 port 55; };',
         'forwarders dscp 4 { fe01::3 port 57 dscp 6; };',
     ]
     result = optviewzone_stmt_forwarders.runTests(test_string, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(
         optviewzone_stmt_forwarders,
         'forwarders port 44  dscp 4 { 2.2.2.2 port 53; fe08::8 dscp 3; };',
         {'fowarders': [{'dscp_port': 4,
                         'fwdr2': [{'addr': '2.2.2.2', 'ip_port': '53'},
                                   {'addr': 'fe08::8',
                                    'dscp_port': 3}],
                         'ip_port': '44'}]}
     )
コード例 #3
0
 def test_isc_optviewzone_stmt_transfer_source_v6_passing(self):
     """ Clause options/view/zone; Statement transfer-source-v6; passing """
     test_string = [
         'transfer-source-v6 fe12::1;',
         'transfer-source-v6 fe12::2 port 53;',
         'transfer-source-v6 fe12::3 port *;',
         'transfer-source-v6 fe12::4 port 53 dscp 1;',
         'transfer-source-v6 fe12::5 port * dscp 1;',
         'transfer-source-v6 fe12::6 dscp 2;',
         'transfer-source-v6 *;',
         'transfer-source-v6 * port 53;',
         'transfer-source-v6 * port *;',
         'transfer-source-v6 * port 53 dscp 1;',
         'transfer-source-v6 * port * dscp 1;',
         'transfer-source-v6 * dscp 2;',
     ]
     result = optviewzone_stmt_transfer_source_v6.runTests(test_string, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(
         optviewzone_stmt_transfer_source_v6,
         'transfer-source-v6 fe12::5 port * dscp 1;',
         {'transfer_source_v6': {'addr': 'fe12::5',
                                 'dscp_port': 1,
                                 'ip_port_w': '*'}}
     )
コード例 #4
0
 def test_isc_optview_stmt_rate_limit_passing(self):
     """ Clause options/view; Statement rate-limit; passing """
     test_string = [
         'rate-limit { all-per-second 60; };',
         'rate-limit { errors-per-second 60; };',
         'rate-limit { exempt-clients { 4.4.4.4; }; };',
         'rate-limit { ipv4-prefix-length 8; };',
         'rate-limit { ipv6-prefix-length 8; };',
         'rate-limit { log-only yes; };',
         'rate-limit { max-table-size 1500; };',
         'rate-limit { min-table-size 1500; };',
         'rate-limit { nodata-per-second 5; };',
         'rate-limit { nxdomains-per-second 5; };',
         'rate-limit { qps-scale 5; };',
         'rate-limit { referrals-per-second 5; };',
         'rate-limit { responses-per-second 5; };',
         'rate-limit { slip 5; };',
         'rate-limit { window 5; };',
     ]
     result = optview_stmt_rate_limit.runTests(test_string, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(
         optview_stmt_rate_limit,
         'rate-limit { exempt-clients { 5.5.5.5; }; slip 5; window 6; responses-per-second 60; };',
         {'rate_limit': [{'addr': '5.5.5.5'},
                         {'slip': 5},
                         {'window': 6},
                         {'responses_per_second': 60}]}
     )
コード例 #5
0
 def test_isc_clause_stmt_masters_multielement_passing(self):
     """Masters clause, passing mode"""
     test_string = 'masters ns1 { 127.0.0.1; 192.168.1.1; 192.168.6.1; };'
     expected_result = {
         'masters': [{
             'master_id':
             'ns1',
             'master_list': [{
                 'addr': '127.0.0.1'
             }, {
                 'addr': '192.168.1.1'
             }, {
                 'addr': '192.168.6.1'
             }]
         }]
     }
     assertParserResultDictTrue(clause_stmt_masters_standalone, test_string,
                                expected_result)
     test_string = 'masters ns1 { another_bastion_hosts1; hidden_bastion2; };'
     expected_result = {
         'masters': [{
             'master_id':
             'ns1',
             'master_list': [{
                 'addr': 'another_bastion_hosts1'
             }, {
                 'addr': 'hidden_bastion2'
             }]
         }]
     }
     assertParserResultDictTrue(clause_stmt_masters_standalone, test_string,
                                expected_result)
コード例 #6
0
ファイル: test_utils.py プロジェクト: bopopescu/bind9_parser
 def test_isc_zone_name_dquoted_passing(self):
     """ ISC Utilities; Type Zone Name; Double-Quote; passing """
     test_data = ['"red_zone"']
     result = zone_name_dquotable.runTests(test_data, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(zone_name_dquotable, '"example.com."',
                                {'zone_name': '"example.com."'})
コード例 #7
0
 def test_isc_optview_stmt_query_source_v6_passing(self):
     """ Clause options/view; Statement YYYY; passing """
     test_string = [
         'query-source-v6;',  # INADDR_ANY (wildcard)
         'query-source-v6 address fe01::1;',
         'query-source-v6 address *;',
         'query-source-v6 address fe01::2 port 53;',
         'query-source-v6 address fe01::3 port *;',
         'query-source-v6 address * port 153;',
         'query-source-v6 address * port *;',
         'query-source-v6 port 253;',
         'query-source-v6 port *;',
     ]
     result = optview_stmt_query_source_v6.runTests(test_string, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(
         optview_stmt_query_source_v6,
         'query-source-v6 address * port 353;',
         {'query_source_v6': {'ip6_addr': '*', 'ip_port_w': '353'}}
     )
     assertParserResultDictTrue(
         optview_stmt_query_source_v6,
         'query-source-v6 address fe08::08 port *;',
         {'query_source_v6': {'ip6_addr': 'fe08::08', 'ip_port_w': '*'}}
     )
コード例 #8
0
 def test_isc_logging_chan_file_path_size_element_passing(self):
     """ Clause logging; Element File path size; passing mode """
     test_string = 'size 1M'
     expected_result = {'size_spec': [1, 'M']}
     assertParserResultDictTrue(logging_chan_file_path_size_element,
                                test_string,
                                expected_result)
     test_string = 'size 1024'
     expected_result = {'size_spec': [1024]}
     assertParserResultDictTrue(logging_chan_file_path_size_element,
                                test_string,
                                expected_result)
     test_string = 'size 100'
     expected_result = {'size_spec': [100]}
     assertParserResultDictTrue(logging_chan_file_path_size_element,
                                test_string,
                                expected_result)
     test_string = 'size 10G'
     expected_result = {'size_spec': [10, 'G']}
     assertParserResultDictTrue(logging_chan_file_path_size_element,
                                test_string,
                                expected_result)
     test_string = 'size 10g'
     expected_result = {'size_spec': [10, 'g']}
     assertParserResultDictTrue(logging_chan_file_path_size_element,
                                test_string,
                                expected_result)
コード例 #9
0
 def test_isc_optviewzone_stmt_alt_transfer_source_v6_passing(self):
     """ Clause options/view/zone; Statement alt-transfer-source-v6; passing """
     test_string = [
         'alt-transfer-source-v6 *;',
         'alt-transfer-source-v6 * port *;',
         'alt-transfer-source-v6 * port * dscp 7;',
         'alt-transfer-source-v6 * dscp 7;',
         'alt-transfer-source-v6 * port 53 dscp 7;',
         'alt-transfer-source-v6 * port 53;',
         'alt-transfer-source-v6 fe0f::e;',
         'alt-transfer-source-v6 fe0f::e port *;',
         'alt-transfer-source-v6 fe0f::e port * dscp 7;',
         'alt-transfer-source-v6 fe0f::e dscp 7;',
         'alt-transfer-source-v6 fe0f::e port 53 dscp 7;',
         'alt-transfer-source-v6 fe0f::e port 53;',
     ]
     result = optviewzone_stmt_alt_transfer_source_v6.runTests(
         test_string, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(optviewzone_stmt_alt_transfer_source_v6,
                                'alt-transfer-source-v6 fe0f::6 port 56;', {
                                    'alt_transfer_source_v6': {
                                        'ip6_addr': 'fe0f::6',
                                        'ip_port_w': 56
                                    }
                                })
コード例 #10
0
 def test_isc_logging_chan_method_option_series_passing(self):
     """ Clause logging; Series Method; passing mode """
     test_string = 'print-time 1; buffered 0; print-severity True;'
     expected_result = {'print_time': '1', 'buffered': '0', 'print_severity': 'True'}
     assertParserResultDictTrue(logging_chan_method_option_series,
                                test_string,
                                expected_result)
コード例 #11
0
 def test_isc_clause_logging_logging_stmt_category2_passing(self):
     test_string = 'category unmatched { null; };'
     expected_result = { 'category_group': [ { 'categories': ['null'],
                     'category_group_name': 'unmatched'}]}
     assertParserResultDictTrue(logging_stmt_category_set,
                                test_string,
                                expected_result)
コード例 #12
0
 def test_isc_logging_chan_file_method_passing(self):
     """ Clause logging; Element File Method; passing mode """
     test_string = 'file "unquoted-key_id";'
     expected_result = {'path_name': '"unquoted-key_id"'}
     assertParserResultDictTrue(logging_chan_file_method,
                                 test_string,
                                 expected_result)
     test_string = 'syslog syslog;'
     expected_result = {'facility': 'syslog'}
     assertParserResultDictTrue(logging_chan_file_method,
                                 test_string,
                                 expected_result)
     test_string = 'syslog daemon;'
     expected_result = {'facility': 'daemon'}
     assertParserResultDictTrue(logging_chan_file_method,
                                 test_string,
                                 expected_result)
     test_string = 'stderr;'
     expected_result = {'io': 'stderr'}
     assertParserResultDictTrue(logging_chan_file_method,
                                 test_string,
                                 expected_result)
     test_string = 'null;'
     expected_result = {'io': 'null'}
     assertParserResultDictTrue(logging_chan_file_method,
                                 test_string,
                                 expected_result)
コード例 #13
0
    def test_isc_logging_chan_file_path_element_passing(self):
        """ Clause logging; Element File path; passing mode """
        test_string = 'file "simple-relative-filename"'
        expected_result = {'path_name': '"simple-relative-filename"'}
        assertParserResultDictTrue(logging_chan_file_path_element,
                                   test_string,
                                   expected_result, 'did not detect missing semicolon')
        test_string = 'file "/tmp/unquoted-key_id"'
        expected_result = {'path_name': '"/tmp/unquoted-key_id"'}
        assertParserResultDictTrue(logging_chan_file_path_element,
                                   test_string,
                                   expected_result, 'did not detect missing semicolon')
        test_string = 'file "/tmp/spaced-out key_id"'
        expected_result = {'path_name': '"/tmp/spaced-out key_id"'}
        assertParserResultDictTrue(logging_chan_file_path_element,
                           test_string,
                           expected_result, 'did not detect missing semicolon')
#        test_string = 'file /tmp/"spaced dir"/spaced-outkey_id'   # TODO: Either get this working or go generic-string
#        expected_result = {'path_name': '/tmp/spaced dir/spaced-outkey_id'}
#        assertParserResultDictTrue(logging_chan_file_path_element,
#                                   test_string,
#                                   expected_result, 'did not detect missing semicolon')
        test_string = "file '/tmp/spaced-out key_id2'"
        expected_result = {'path_name': "'/tmp/spaced-out key_id2'"}
        assertParserResultDictTrue(logging_chan_file_path_element,
                                   test_string,
                                   expected_result, 'did not detect missing semicolon')
        test_string = 'file \'/dev/null\''
        expected_result = {'path_name': '\'/dev/null\''}
        assertParserResultDictTrue(logging_chan_file_path_element,
                                   test_string,
                                   expected_result, 'did not detect missing semicolon')
コード例 #14
0
 def test_isc_clause_zone__clause_zone_standalone_passing(self):
     test_data = [
         """ zone "home" IN { type master; file "/var/lib/bind/internal/master/db.home"; allow-update { none; }; };"""
     ]
     test_clause_stmt_zone = clause_stmt_zone_standalone.copy()
     test_clause_stmt_zone = test_clause_stmt_zone.setWhitespaceChars(' \t')
     test_clause_stmt_zone = test_clause_stmt_zone.ignore(
         pythonStyleComment)
     test_clause_stmt_zone = test_clause_stmt_zone.ignore(cppStyleComment)
     #        test_clause_stmt_zone.ignore(pythonStyleComment)
     #        test_clause_stmt_zone.ignore(cppStyleComment)
     result = clause_stmt_zone_standalone.runTests(test_data,
                                                   failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(
         clause_stmt_zone_standalone,
         'zone "home" IN { type master; file "/var/lib/bind/internal/master/db.home"; allow-update { none; }; };',
         {
             'zone': {
                 'allow_update': {
                     'aml': [{
                         'addr': 'none'
                     }]
                 },
                 'file': '"/var/lib/bind/internal/master/db.home"',
                 'type': 'master',
                 'zone_name': '"home"'
             }
         })
コード例 #15
0
 def test_isc_options_stmt_disable_algorithms_passing(self):
     assertParserResultDictTrue(options_stmt_disable_algorithms,
                                'disable-algorithms example.com { sha512; cbc32; };',
                                {
                                    'disable_algorithms': [
                                        {
                                            'algorithm_list': [
                                                'sha512',
                                                'cbc32'
                                            ],
                                            'domain_name': 'example.com'
                                        },
                                    ]
                                }
                                )
     assertParserResultDictTrue(options_multiple_stmt_disable_algorithms,
                                'disable-algorithms example.com { sha512; cbc32; }; disable-algorithms yahoo.com { cbc128; };',
                                {
                                    'disable_algorithms': [
                                        {
                                            'algorithm_list': [
                                                'sha512',
                                                'cbc32'
                                            ],
                                            'domain_name': 'example.com'
                                        },
                                        {
                                            'algorithm_list': [
                                                'cbc128'
                                            ],
                                            'domain_name': 'yahoo.com'
                                        }
                                    ]
                                }
                                )
コード例 #16
0
 def test_isc_options_stmt_blackhole_passing(self):
     """ Clause options; Statement blackhole; passing mode """
     assertParserResultDictTrue(
         options_stmt_blackhole,
         'blackhole { 127.0.0.1; { localhost; localnets; }; !{ any; }; { none; }; };',
         {
             'blackhole': {
                 'aml': [{
                     'addr': '127.0.0.1'
                 }, {
                     'aml': [{
                         'addr': 'localhost'
                     }, {
                         'addr': 'localnets'
                     }]
                 }, {
                     'aml': [{
                         'addr': 'any'
                     }],
                     'not': '!'
                 }, {
                     'aml': [{
                         'addr': 'none'
                     }]
                 }]
             }
         })
     assertParserResultDictTrue(
         options_stmt_blackhole, 'blackhole { 127.0.0.1; };',
         {'blackhole': {
             'aml': [{
                 'addr': '127.0.0.1'
             }]
         }})
コード例 #17
0
 def test_isc_options_stmt_listen_on3_passing(self):
     assertParserResultDictTrue(
         options_stmt_listen_on,
         'listen-on { ! 10.0.1.1; any;};',
         {'listen_on': [{'aml': [{'addr': '10.0.1.1', 'not': '!'},
                                 {'addr': 'any'}]}]}
     )
コード例 #18
0
 def test_isc_options_stmt_deny_answer_aliases_passing(self):
     assertParserResultDictTrue(
         options_stmt_deny_answer_aliases,
         'deny-answer-aliases { 128.0.0.1; };',
         {'deny_answer_aliases': [{
             'name': '128.0.0.1'
         }]})
コード例 #19
0
 def test_isc_optview_stmt_dual_stack_servers_passing(self):
     """ Clause options/view; Statement dual-stack-servers; passing """
     test_string = [
         'dual-stack-servers { 1.1.1.1; };',
         'dual-stack-servers { 2.2.2.2 port 563; };',
         'dual-stack-servers { fe0a::1; };',
         'dual-stack-servers { fe0a::2 port 771; };',
         'dual-stack-servers port 593 { 3.3.3.3; };',
         'dual-stack-servers port 593 { "bastion1.example.com" port 693; };',
         'dual-stack-servers port 593 { "bastion2.example.com" port 893; };',
         'dual-stack-servers port 593 { "bastion3.example.com" port 893; "bastion4.example.com" port 993; };',
     ]
     result = optview_stmt_dual_stack_servers.runTests(test_string, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(
         optview_stmt_dual_stack_servers,
         'dual-stack-servers port 593 { "dmz.example.com" port 893; "hidden-dns.example.com" port 993; };',
         {
             'dual_stack_servers': {
                 'addrs': [
                     {
                         'domain': '"dmz.example.com"',
                         'ip_port': '893'
                     },
                     {
                         'domain': '"hidden-dns.example.com"',
                         'ip_port': '993'
                     }
                 ],
                 'ip_port': '593'
             }
         }
     )
コード例 #20
0
 def test_isc_options_stmt_listen_on_passing(self):
     assertParserResultDictTrue(options_stmt_listen_on,
                                'listen-on port 553 { 127.0.0.1;};', {
                                    'listen_on': [
                                        {
                                            'aml': [{
                                                'addr': '127.0.0.1'
                                            }],
                                            'ip_port': 553
                                        },
                                    ]
                                })
     assertParserResultDictTrue(
         options_multiple_stmt_listen_on,
         'listen-on port 553 { 127.0.0.1;}; listen-on port 1553 { 192.168.1.1; };',
         {
             'listen_on': [{
                 'aml': [{
                     'addr': '127.0.0.1'
                 }],
                 'ip_port': 553
             }, {
                 'aml': [{
                     'addr': '192.168.1.1'
                 }],
                 'ip_port': 1553
             }]
         })
コード例 #21
0
 def test_isc_optview_stmt_query_source_passing(self):
     """ Clause options/view; Statement query-source; passing """
     test_string = [
         'query-source;',  # INADDR_ANY (wildcard)
         'query-source address 4.4.4.4;',
         'query-source address *;',
         'query-source address 5.5.5.5 port 53;',
         'query-source address 6.6.6.6 port *;',
         'query-source address * port 153;',
         'query-source address * port *;',
         'query-source port 253;',
         'query-source port *;',
     ]
     result = optview_stmt_query_source.runTests(test_string, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(
         optview_stmt_query_source,
         'query-source address * port 353;',
         {'query_source': {'ip4_addr': '*', 'ip_port_w': '353'}}
     )
     assertParserResultDictTrue(
         optview_stmt_query_source,
         'query-source address 7.7.7.7 port *;',
         {'query_source': {'ip4_addr': '7.7.7.7', 'ip_port_w': '*'}}
     )
コード例 #22
0
 def test_isc_options_stmt_prefetch_passing(self):
     assertParserResultDictTrue(
         options_stmt_prefetch, 'prefetch 55555 3600;',
         {'prefetch': {
             'expiry_ttl': 55555,
             'threshold_ttl': 3600
         }})
コード例 #23
0
 def test_isc_clause_stmt_dlz_multiple_passing(self):
     """ Clause dlz; Multiple Statments group; passing mode """
     assertParserResultDictTrue(
         clause_stmt_dlz_series,
         """dlz my_dlz_1 { database def; search yes; };
            dlz example { database "dlopen driver.so args"; search yes; };
            dlz other { database "dlopen driver.so args"; search no; };
            dlz their_mysql { database mysql; search 1; };""", {
             'dlz': [{
                 'db_args': 'def',
                 'dlz_name': 'my_dlz_1',
                 'search': 'yes'
             }, {
                 'db_args': '"dlopen driver.so args"',
                 'dlz_name': 'example',
                 'search': 'yes'
             }, {
                 'db_args': '"dlopen driver.so args"',
                 'dlz_name': 'other',
                 'search': 'no'
             }, {
                 'db_args': 'mysql',
                 'dlz_name': 'their_mysql',
                 'search': '1'
             }]
         })
コード例 #24
0
 def test_isc_options_stmt_deny_answer_addresses2_passing(self):
     assertParserResultDictTrue(
         options_stmt_deny_answer_addresses,
         'deny-answer-addresses { any; } except-from { "string"; };',
         {'deny_answer_addresses': {'aml': [{'addr': 'any'}],
                                    'name': '"string"'}}
     )
コード例 #25
0
 def test_isc_optviewzone_stmt_alt_transfer_source_passing(self):
     """ Clause options/view/zone; Statement alt-transfer-source; passing """
     test_string = [
         'alt-transfer-source *;',
         'alt-transfer-source * port *;',
         'alt-transfer-source * port * dscp 7;',
         'alt-transfer-source * dscp 7;',
         'alt-transfer-source * port 53 dscp 7;',
         'alt-transfer-source * port 53;',
         'alt-transfer-source 2.2.2.2;',
         'alt-transfer-source 2.2.2.2 port *;',
         'alt-transfer-source 2.2.2.2 port * dscp 7;',
         'alt-transfer-source 2.2.2.2 dscp 7;',
         'alt-transfer-source 2.2.2.2 port 53 dscp 7;',
         'alt-transfer-source 2.2.2.2 port 53;',
     ]
     result = optviewzone_stmt_alt_transfer_source.runTests(test_string, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(
         optviewzone_stmt_alt_transfer_source,
         'alt-transfer-source 2.3.4.5 port * dscp 7;',
         {'alt_transfer_source': {'dscp_port': 7,
                                  'ip4_addr': '2.3.4.5',
                                  'ip_port_w': '*'}}
     )
コード例 #26
0
 def test_isc_options_stmt_deny_answer_addresses5_passing(self):
     assertParserResultDictTrue(
         options_stmt_deny_answer_addresses,
         'deny-answer-addresses { 192.0.2.0/24; } except-from { "example.net"; };',
         {'deny_answer_addresses': {'aml': [{'addr': '192.0.2.0/24'}],
                                    'name': '"example.net"'}}
     )
コード例 #27
0
 def test_isc_optviewzone_stmt_notify_source_v6_passing(self):
     """ Clause options/view/zone; Statement notify-source-v6; passing """
     test_string = [
         'notify-source-v6 *;',
         'notify-source-v6 * port 53;',
         'notify-source-v6 * port *;',
         'notify-source-v6 * port 153 dscp 1;',
         'notify-source-v6 * port * dscp 1;',
         'notify-source-v6 * dscp 1;',
         'notify-source-v6 fe11::1;',
         'notify-source-v6 fe11::1 port *;',
         'notify-source-v6 fe11::1 port 253;',
         'notify-source-v6 fe11::1 port * dscp 2;',
         'notify-source-v6 fe11::1 port 353 dscp 2;',
         'notify-source-v6 fe11::1 dscp 3;',
     ]
     result = optviewzone_stmt_notify_source_v6.runTests(test_string, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(
         optviewzone_stmt_notify_source_v6,
         'notify-source-v6 fe11::123 port * dscp 5;',
         {'notify_source_v6': {'addr': 'fe11::123',
                               'dscp_port': 5,
                               'ip_port_w': '*'}}
     )
コード例 #28
0
    def test_isc_options_stmt_deny_answer_addresses6_passing(self):
        assertParserResultDictTrue(
            options_stmt_deny_answer_addresses,
            """
deny-answer-addresses {
    0.0.0.0; 
    10.0.0.0/8;
    172.16.0.0/12;
    192.168.0.0/16;
    169.254.0.0/16;
    ::/80;
    fe80::/10;
    64:ff9b::/96;
} except-from { "Your.Domain"; };""",
            {
                'deny_answer_addresses': {
                    'aml': [
                        {'addr': '0.0.0.0'},
                        {'addr': '10.0.0.0/8'},
                        {'addr': '172.16.0.0/12'},
                        {'addr': '192.168.0.0/16'},
                        {'addr': '169.254.0.0/16'},
                        {'addr': '::/80',
                         'ip6s_subnet': '80'},
                        {'addr': 'fe80::/10',
                         'ip6s_subnet': '10'},
                        {'addr': '64:ff9b::/96',
                         'ip6s_subnet': '96'}],
                    'name': '"Your.Domain"'}}
        )
コード例 #29
0
 def test_isc_optviewzone_stmt_transfer_source_passing(self):
     """ Clause options/view/zone; Statement transfer-source; passing """
     test_string = [
         'transfer-source 1.1.1.1;',
         'transfer-source 2.2.2.2 port 53;',
         'transfer-source 3.3.3.3 port *;',
         'transfer-source 4.4.4.4 port 53 dscp 1;',
         'transfer-source 5.5.5.5 port * dscp 1;',
         'transfer-source 6.6.6.6 dscp 2;',
         'transfer-source *;',
         'transfer-source * port 53;',
         'transfer-source * port *;',
         'transfer-source * port 53 dscp 1;',
         'transfer-source * port * dscp 1;',
         'transfer-source * dscp 2;',
     ]
     result = optviewzone_stmt_transfer_source.runTests(test_string, failureTests=False)
     self.assertTrue(result[0])
     assertParserResultDictTrue(
         optviewzone_stmt_transfer_source,
         'transfer-source 4.4.4.4 port 53 dscp 1;',
         {'transfer_source': {'addr': '4.4.4.4',
                              'dscp_port': 1,
                              'ip_port_w': '53'}}
     )
コード例 #30
0
 def test_isc_zone_stmt_masters_name_by_ipv4_passing(self):
     """ Clause zone; Name, masters; by IPv4; passing """
     assertParserResultDictTrue(zone_masters_set,
                                '4.4.4.4 key priv_dns_chan_key0;', {
                                    'ip4': '4.4.4.4',
                                    'key_id': 'priv_dns_chan_key0'
                                })