def test_extract_envelope_none(self):
"""ParserBase - Extract Envelope, None"""
record = {'key': 'value'}
parser = ParserBase(None)
envelope = parser._extract_envelope(record)
assert_equal(envelope, None)
def test_extract_envelope(self):
"""ParserBase - Extract Envelope"""
options = {'configuration': {'envelope_keys': ['env_key_01']}}
record = {'env_key_01': 'foo', 'non_env_key': 'bar'}
parser = ParserBase(options)
envelope = parser._extract_envelope(record)
assert_equal(envelope, {'env_key_01': 'foo'})
def test_json_path_records(self):
"""ParserBase - JSON Path Records"""
expected_records = [{'foo': 'bar'}, {'bar': 'baz'}]
record = {'key': [{'value': expected_records}]}
options = {'configuration': {'json_path': 'key[].value[]'}}
parser = ParserBase(options)
records = parser._json_path_records(record)
assert_equal(records, expected_records)
def test_parse(self):
"""ParserBase - Parse, Invalid Schema"""
options = {
'schema': {
'key': 'string'
},
'configuration': {
'optional_top_level_keys': ['non_key']
}
}
assert_equal(ParserBase(options).parse(None), False)
def test_validate_schema_invalid(self):
"""ParserBase - Validate Schema, Invalid"""
options = {
'schema': {
'timestamp': 'string',
'host': 'string',
'application': 'string',
'message': 'string'
},
'configuration': {
'optional_top_level_keys': ['date']
}
}
parser = ParserBase(options)
assert_equal(parser._validate_schema(), False)
def setup(self):
"""Setup before each method"""
# pylint: disable=abstract-class-instantiated,attribute-defined-outside-init
options = {
'schema': {
'timestamp': 'string',
'host': 'string'
},
'configuration': {
'optional_top_level_keys': ['host'],
'log_patterns': {
'host': ['foo*']
},
'json_path': 'logEvents[].message',
'envelope_keys': {
'env_key_01': 'string'
},
'optional_envelope_keys': ['env_key_01']
}
}
self._parser = ParserBase(options)
def test_validate_schema_all(self):
"""ParserBase - Validate Schema, All Options"""
options = {
'schema': {
'timestamp': 'string',
'host': 'string',
'application': 'string',
'message': 'string'
},
'configuration': {
'envelope_keys': {
'env_key_01': 'string',
'env_key_02': 'string'
},
'optional_envelope_keys': ['env_key_01'],
'optional_top_level_keys': ['host']
}
}
parser = ParserBase(options)
assert_equal(parser._validate_schema(), True)
def test_add_parse_result_invalid(self):
"""ParserBase - Add Parse Result, Valid"""
parser = ParserBase(None)
record = {'key': 'value'}
parser._add_parse_result(record, False, None)
assert_equal(parser._invalid_parses, [record])
def test_invalid_parses_property(self):
"""ParserBase - Invalid Parses Property"""
item = 'foobar'
parser = ParserBase(None)
parser._invalid_parses.append(item)
assert_equal(parser.invalid_parses, [item])
def test_parses_property(self):
"""ParserBase - Parses Property"""
item = 'foobar'
parser = ParserBase(None)
parser._valid_parses.append(item)
assert_equal(parser.parsed_records, [item])
def test_valid_property_false(self):
"""ParserBase - Valid Property"""
parser = ParserBase(None)
assert_equal(parser.valid, False)
def test_valid_property(self):
"""ParserBase - Valid Property"""
parser = ParserBase(None)
parser._valid_parses.append('foobar')
assert_equal(parser.valid, True)
def test_log_schema_type_property(self):
"""ParserBase - Log Schema Type Property"""
log_type = 'foobar'
parser = ParserBase(None, log_type)
assert_equal(parser.log_schema_type, log_type)