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 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_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_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_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_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 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)
