def test_isc_logging_chan_method_option_series_failing(self): """ Clause logging; Series Method; failing mode """ test_string = 'print-time 2; buffered -1; print-severity True;' expected_result = {'print_time': '1', 'buffered': '0', 'print_severity': 'True'} assertParserResultDictFalse(logging_chan_method_option_series, test_string, expected_result)
def test_isc_logging_chan_print_severity_element_failing(self): """ Clause logging; Element Channel Print Severity; failing mode """ test_string = 'print-severity severe;' expected_result = {'print_severity': 'severe'} assertParserResultDictFalse(logging_chan_print_severity_element, test_string, expected_result)
def test_isc_logging_chan_file_method_failing(self): """ Clause logging; Element File Method; failing mode """ test_string = 'stdin;' expected_result = {} assertParserResultDictFalse(logging_chan_file_method, test_string, expected_result, 'did not detect missing semicolon') test_string ='stdout;' expected_result = {} assertParserResultDictFalse(logging_chan_file_method, test_string, expected_result, 'did not detect missing semicolon') test_string ='zero;' expected_result = {} assertParserResultDictFalse(logging_chan_file_method, test_string, expected_result, 'did not detect missing semicolon') test_string ='file nutz;file-with-semicolon.type;' expected_result = {} assertParserResultDictFalse(logging_chan_file_method, test_string, expected_result, 'did not detect missing semicolon') test_string = 'syslog warning;' expected_result = {'io': 'null'} assertParserResultDictFalse(logging_chan_file_method, test_string, expected_result, 'did not detect missing semicolon')
def test_isc_masters_element_series_failing(self): """Masters clause, Master Element series, purposely failing mode""" test_string = 'netspeed 150000000' expected_result = { 'master_list': [ {'addr': 'master_recon_border_gateway', 'key_id': '"My_Secret_Company_Key"'} ] } assertParserResultDictFalse(masters_element_series, test_string, expected_result)
def test_isc_clause_options_version_passing(self): # assertParserResultDictTrue(options_stmt_version, 'version 1.0.15;', {'version_string': '1.0.15'}) assertParserResultDictTrue(options_stmt_version, 'version "1.0.15";', {'version_string': '"1.0.15"'}) assertParserResultDictTrue(options_stmt_version, "version '1.0.15';", {'version_string': '\'1.0.15\''}) # Multiline test print("\nMulti-line tests:") assertParserResultDictFalse(options_stmt_version, "version = '1.0.15';", {})
def test_isc_clause_logging_logging_stmt_category_failing(self): """ Clause logging; Statement Category; failing mode """ test_string = 'category k l { b; c; d; };' expected_result = { 'category_group': { 'categories': ['b', 'c', 'd'], 'category_group_name': 'k'}} assertParserResultDictFalse(logging_stmt_category_set, test_string, expected_result)
def test_isc_logging_clause_stmt_failing(self): """ Clause logging; Statement Logging; failing mode """ test_string = 'logging { channel cb { files "/tmp/x" size 30M; severity info; print-time yes;}; };' expected_result = {} assertParserResultDictFalse(clause_stmt_logging_standalone, test_string, expected_result) test_string = 'logging { channel trucker { file "/tmp/x" size 30M; print__ime yes; severity info;}; };' expected_result = {} assertParserResultDictFalse(clause_stmt_logging_standalone, test_string, expected_result)
def test_isc_logging_stmt_channel_failing(self): """ Clause logging; Statement Channel; failing mode """ test_string = 'channel bl eep { file "/tmp/x" size 38M; severity warning;};' expected_result = { 'channel': { 'channel_name': 'bl', 'channel_name2': 'eep', 'path_name': '"/tmp/x"', 'severity': 'warning', 'size_spec': [38, 'M']}} assertParserResultDictFalse(logging_stmt_channel_set, test_string, expected_result)
def test_isc_zone_statements_series_multiple_masters_passing(self): """ Clause zone; Statement, multiple masters; passing """ # Only one masters statement is allowed in zone clause, so get the last one assertParserResultDictFalse( zone_statements_series, 'masters dmz_masters port 7552 dscp 5 { yellow_masters key priv_dns_chan_key5; }; ' + 'masters bastion_hosts port 1024 dscp 6 { fe08::1 port 77; };', {'masters': [{'dscp_port': 6, 'ip_port': 1025, 'master_id': 'bastion_hosts', 'master_list': [{'addr': 'fe08::1', 'ip_port': 77}]}]} )
def test_isc_masters_name_failing(self): """ Clause masters; Series Master Name; failing mode """ test_data = [ 'route,net;', 'bad host', 'no such;', ] expected_result = {'master_id': '2.2.2.2'} assertParserResultDictFalse(master_id, 'route.net;', expected_result) assertParserResultDictFalse(master_id, 'bad host', expected_result) assertParserResultDictFalse(master_id, 'no such;', expected_result)
def test_isc_logging_chan_print_time_element_failing(self): """ Clause logging; Element Channel Print Time; failing mode """ test_string = 'print-time off;' expected_result = {'print_time': 'off'} assertParserResultDictFalse(logging_chan_print_time_element, test_string, expected_result) test_string = 'print-time zero;' expected_result = {'print_time': 'zero'} assertParserResultDictFalse(logging_chan_print_time_element, test_string, expected_result) test_string = 'print-time none;' expected_result = {'print_time': 'none'} assertParserResultDictFalse(logging_chan_print_time_element, test_string, expected_result) test_string = 'print-time iso8601-est;' expected_result = {'print_time': 'iso8601-est'} assertParserResultDictFalse(logging_chan_print_time_element, test_string, expected_result)
def test_isc_logging_chan_file_path_size_element_failing(self): """ Clause logging; Element File path size; failing mode """ test_string = 'size 15x' expected_result = {'size_spec': [15, 'x']} assertParserResultDictFalse(logging_chan_file_path_size_element, test_string, expected_result, '"x" is not a valid size legend') test_string = 'size 32kilo' expected_result = {'size_spec': [32, ' kilo']} assertParserResultDictFalse(logging_chan_file_path_size_element, test_string, expected_result, '"kilo" is not a valid size legend') test_string = 'size 65mega' expected_result = {'size_spec': [65, 'mega']} assertParserResultDictFalse(logging_chan_file_path_size_element, test_string, expected_result, '"mega" s not a valid size legend') test_string = 'size 128 mega' expected_result = {'size_spec': [128, 'mega']} assertParserResultDictFalse(logging_chan_file_path_size_element, test_string, expected_result, '"mega" is not a valid size legend')
def test_isc_logging_chan_method_element_failing(self): """ Clause logging; Element Channel Method; failing mode """ test_string = 'files /tmp/x size 30M; severity ludicrous; print-time yes;}; };' expected_result = {'files': 'local0'} assertParserResultDictFalse(logging_chan_method_element, test_string, expected_result) test_string = 'syslog hacked;' expected_result = {'facility': 'hacked'} assertParserResultDictFalse(logging_chan_method_element, test_string, expected_result) test_string = 'syslog warning;' expected_result = {'facility': 'warning'} assertParserResultDictFalse(logging_chan_method_element, test_string, expected_result)
def test_isc_logging_chan_severity_element_failing(self): """ Clause logging; Element Channel Severity; failing mode """ test_data = [ ] test_string = 'severity warn;' expected_result = {'severity': ['warn']} assertParserResultDictFalse(logging_chan_syslog_severity_element, test_string, expected_result) test_string = 'severity debug high;' expected_result = {'severity': {'debug': ['high']}} assertParserResultDictFalse(logging_chan_syslog_severity_element, test_string, expected_result) test_string = 'severity dire_emergency;' expected_result = {'severity': ['dire_emergency']} assertParserResultDictFalse(logging_chan_syslog_severity_element, test_string, expected_result) test_string = 'severity debug on;' expected_result = {'severity': {'debug': ['on']}} assertParserResultDictFalse(logging_chan_syslog_severity_element, test_string, expected_result)
def test_isc_logging_chan_file_path_element_failing(self): """ Clause logging; Element File path; failing mode """ test_string = 'file "/control_r\rsubdir/unquoted-key_id"' expected_result = {'path_name': '"/control_r\rsubdir/unquoted-key_id"'} assertParserResultDictFalse(logging_chan_file_path_element, test_string, expected_result, 'did not detect missing semicolon') test_string = 'file /control_b\bsubdir/unquoted-key_id' expected_result = {'path_name': '/control_b\bsubdir/unquoted-key_id'} assertParserResultDictFalse(logging_chan_file_path_element, test_string, expected_result, 'did not detect missing semicolon') test_string = 'file /gappy subdir/unquoted-key_id' expected_result = {'path_name': '/gappy subdir/unquoted-key_id'} assertParserResultDictFalse(logging_chan_file_path_element, test_string, expected_result, 'did not detect missing semicolon')
def test_isc_logging_chan_file_path_version_element_failing(self): """ Clause logging; Element File path version; failing mode """ test_string = 'version A;' expected_result = {} assertParserResultDictFalse(logging_chan_file_path_version_element, test_string, expected_result, 'Alpha characters are not valid file versions') test_string = 'version limited;' expected_result = {} assertParserResultDictFalse(logging_chan_file_path_version_element, test_string, expected_result, 'literal "limited" is not a valid value') test_string = 'version not-limited' expected_result = {} assertParserResultDictFalse(logging_chan_file_path_version_element, test_string, expected_result, 'did not detect missing semicolon')
def test_isc_logging_chan_print_category_element_failing(self): """ Clause logging; Element Channel Print Category; failing mode """ test_data = [ ] test_string = 'print_category yes;' # underscore used instead of an hyphen expected_result = {'print_category': 'False'} assertParserResultDictFalse(logging_chan_print_category_element, test_string, expected_result) test_string = 'print category yes;' # missing hyphen expected_result = {'print_category': 'False'} assertParserResultDictFalse(logging_chan_print_category_element, test_string, expected_result) test_string = 'print-categories yes' # plural form used instead of singular expected_result = {'print_category': 'False'} assertParserResultDictFalse(logging_chan_print_category_element, test_string, expected_result)
def test_isc_master_name_failing(self): """Masters clause, Master Name type, purposely failing mode""" test_string = 'netspeed 150000000' expected_result = {'master_id': 'netspeed'} assertParserResultDictFalse(master_id, test_string, expected_result)
def test_isc_optzone_stmt_statements_set_failing(self): assertParserResultDictFalse(optzone_statements_set, 'notify-to-soa wrong;', {'notify_to_soa': 'wrong'})
def test_isc_clause_stmt_managed_keys_failing(self): """ Clause managed-keys; purposely failing mode""" test_string = 'managed-keys { . initial-key 257 3 3 "AAAAAAAAA+BBBBBBBBBBBBB/CCXCCCCCCCCCCCCC";};' expected_result = {} assertParserResultDictFalse(clause_stmt_managed_keys_series, test_string, expected_result)
def test_isc_inet_port_high_failing(self): """INET clause; ip_port element; highest value; failing mode""" assertParserResultDictFalse(ip_port, '65536', {'ip_port': '65536'})
def test_isc_inet_port_low_failing(self): """INET clause; ip_port element; lowest value; failing mode""" assertParserResultDictFalse(ip_port, '0', {'ip_port': '0'})
def test_isc_inet_port_element_wildcard_high_failing(self): """INET clause; port element; wildcard; failing""" assertParserResultDictFalse(inet_ip_port_keyword_and_wildcard_element, 'port x', {'ip_port_w': '*'})
def test_isc_inet_port_element_high_failing(self): """INET clause; port element; high failing""" assertParserResultDictFalse(inet_ip_port_keyword_and_number_element, 'port 65536', {'ip_port': '65536'})
def test_isc_inet_port_element_low_failing(self): """INET clause; port element; low; failing""" assertParserResultDictFalse(inet_ip_port_keyword_and_number_element, 'port 0', {'ip_port': '0'})