def test_file_contents(self):
test_path = '/path/to/some/foo.bar.json'
test_value = 'foooooooo'
conf = Configuration()
self.assertEqual(conf._get_file_contents(None), None)
self.assertEqual(conf._get_file_contents(''), None)
def test_basic(self):
with mock.patch.object(Configuration, '_get_file_contents') as mock_get_contents:
mock_get_contents.return_value = '{"a": "first file"}'
conf = Configuration('/tmp/file1.json')
mock_get_contents.return_value = 'a: "second file"'
conf.load_source('/tmp/yaml.yaml')
self.assertEqual(conf.get('a'), 'second file')
def __init__(self):
self.settings = Configuration('config.yaml', Configuration.Arg('config'))
print(' == Watchtower == ')
print('\tStorage:', self.settings.get('storage.type'))
self._load_storage(
self.settings.get('storage.type', self.DEFAULT_STORAGE),
self.settings.get('storage.options', {}),
)
self.alerts = self._parse_alerts(self.settings.get('alerts', {}))
print('\tAlerts:')
for alert_name, alert in self.alerts.items():
print('\t\t{}: {}'.format(
alert.__class__.__name__,
alert.name
))
self.checks = self._parse_checks(self.settings.get('checks', []))
print('\tChecks:')
for check in self.checks:
print('\t\t{}: {}'.format(
check.__class__.__name__,
check.name
))
def test_parse_contents(self):
conf = Configuration()
JSON_TEST = ('{"key1": "value1"}', {'key1': 'value1'})
YAML_TEST = ('key1: value1', {'key1': 'value1'})
INI_TEST = ('[Section]\nkey1 = value1', {'Section': {'key1': 'value1'}, 'defaults': {}})
json_value, _ = conf._parse_contents(JSON_TEST[0], 'json')
self.assertEqual(json_value, JSON_TEST[1])
yaml_value, _ = conf._parse_contents(YAML_TEST[0], 'yaml')
self.assertEqual(yaml_value, YAML_TEST[1])
ini_value, _ = conf._parse_contents(INI_TEST[0], 'ini')
self.assertEqual(ini_value, INI_TEST[1])
# Make sure it doesn't support invalid extensions ;)
with self.assertRaises(ValueError):
conf._parse_contents('foobar', 'xml')
# Make sure a parse error returns None
with mock.patch('json.loads') as m:
m.side_effect = ValueError
value, message = conf._parse_contents(JSON_TEST[0], 'json')
self.assertEqual(value, None)
def test_destination(self):
test_structure = {'a': 1, 'b': 2}
conf = Configuration()
conf.load_source(test_structure, destination='sub')
self.assertEqual(
list(conf.extractor.sources),
[{'sub': test_structure}]
)
conf = Configuration()
conf.load_source(test_structure)
self.assertEqual(list(conf.extractor.sources), [test_structure])
def test_load_source(self):
conf = Configuration()
test_file_type = 'json'
test_contents = 'test contents'
test_parsed = {'foo': 'bar'}
conf._get_file_type = mock.Mock(return_value=test_file_type)
conf._get_file_contents = mock.Mock(return_value=test_contents)
conf._parse_contents = mock.Mock(return_value=(test_parsed, None))
conf.load_source(self.test_origin)
self.assertEqual(len(conf.sources), 1)
built_source = conf.sources[0]
self.assertEqual(built_source['origin'], self.test_origin)
self.assertEqual(built_source['location'], self.test_origin)
self.assertEqual(built_source['type'], test_file_type)
self.assertEqual(built_source['contents'], test_contents)
self.assertEqual(built_source['data'], test_parsed)
from quickconfig import Configuration
from core import Reactor, Receiver, Sender
def parse_receivers():
return []
def parse_senders():
return []
def main(config):
receivers = parse_receivers(config('receivers'))
senders = parse_senders(config('senders'))
reactor = Reactor()
reactor.run()
if __name__ == '__main__':
config = Configuration('config.yaml', Configuration.Arg('config'))
main(config)
class Watchtower():
DEFAULT_STORAGE = 'watchtower.storage.memory.MemoryStorage'
def __init__(self):
self.settings = Configuration('config.yaml', Configuration.Arg('config'))
print(' == Watchtower == ')
print('\tStorage:', self.settings.get('storage.type'))
self._load_storage(
self.settings.get('storage.type', self.DEFAULT_STORAGE),
self.settings.get('storage.options', {}),
)
self.alerts = self._parse_alerts(self.settings.get('alerts', {}))
print('\tAlerts:')
for alert_name, alert in self.alerts.items():
print('\t\t{}: {}'.format(
alert.__class__.__name__,
alert.name
))
self.checks = self._parse_checks(self.settings.get('checks', []))
print('\tChecks:')
for check in self.checks:
print('\t\t{}: {}'.format(
check.__class__.__name__,
check.name
))
def _parse_checks(self, checks_config):
checks = []
for check_info in checks_config:
name = check_info['name']
title = check_info.get('title', None)
# Parse Alert
alerts = []
alert_names = check_info["alerts"]
for alert_name in alert_names:
alert = self.alerts.get(alert_name, None)
if alert is None:
continue
else:
alerts.append(alert)
# Make Alert of Type
type_path = check_info['type']
type_class = import_class(type_path)
options = check_info.get('options', {})
checks.append(type_class(name, title, options, alerts))
return checks
def _parse_alerts(self, alerts_config):
alerts = {}
for name, alert_info in alerts_config.items():
type_path = alert_info['type']
type_class = import_class(type_path)
options = alert_info.get('options', {})
issue_options = alert_info.get('issues', {})
alerts[name] = type_class(name, options, issue_options)
return alerts
def _load_storage(self, path, settings):
StorageClass = import_class(path)
self.storage = StorageClass(**settings)
return self.storage
def test_invalid_config_file(self):
conf = Configuration(silent_on_missing=False, silent_on_invalid=False)
conf._get_file_contents = mock.Mock(return_value='{invalid,,,:json')
with self.assertRaises(InvalidConfigError):
conf.load_source(self.test_origin)
def test_config_file_exists(self):
conf = Configuration(silent_on_missing=True, silent_on_invalid=True)
conf._get_file_contents = mock.Mock(return_value=None)
conf.load_source(self.test_origin)
self.assertEqual(len(conf.sources), 1)
def test_missing_config_file(self):
conf = Configuration(silent_on_missing=False, silent_on_invalid=False)
conf._get_file_contents = mock.Mock(return_value=None)
with self.assertRaises(MissingConfigFileError):
conf.load_source(self.test_origin)
def test_file_type(self):
test_path = '/path/to/some/foo.bar.json'
conf = Configuration()
t = conf._get_file_type(test_path)
self.assertEqual(t, 'json')
