def test_load_EventDefinition_missing_group(self):
"""
Loading an EventDefinition with a reference to a non-existent group
will raise UtilsError.
"""
event_id = manufacture.getUniqueString()
group_1 = manufacture.getUniqueString()
message = manufacture.getUniqueString()
content = '''
{
"groups" : {},
"events" : {
"%s": {
"message": "%s",
"groups": ["%s"],
"description": "",
"version_removed": "",
"version_added": "",
"details": "",
"data": ""
}
}
}
''' % (event_id, message, group_1)
config = manufacture.makeEventsDefinition(
content=content, load=False)
with self.assertRaises(UtilsError):
config.load()
def test_init(self):
"""
Check EventDefinition initialization.
"""
event_id = manufacture.getUniqueString() + 'greater_than_5'
description = manufacture.getUniqueString()
message = manufacture.getUniqueString()
version_added = manufacture.getUniqueString()
version_removed = manufacture.getUniqueString()
groups = [
manufacture.makeEventGroupDefinition(),
manufacture.makeEventGroupDefinition(),
]
event_definition = EventDefinition(
id=event_id,
message=message,
description=description,
groups=groups,
version_added=version_added,
version_removed=version_removed,
)
self.assertProvides(IEventDefinition, event_definition)
self.assertEqual(event_id, event_definition.id)
self.assertEqual(message, event_definition.message)
self.assertEqual(groups, event_definition.groups)
self.assertEqual(description, event_definition.description)
self.assertEqual(version_added, event_definition.version_added)
self.assertEqual(version_removed, event_definition.version_removed)
self.assertEqual(
[groups[0].name, groups[1].name], event_definition.group_names)
def test_init_values(self):
"""
Check set values.
"""
certificate = manufacture.getUniqueString()
credentials = SSLCertificateCredentials(
username=manufacture.getUniqueString(),
certificate=certificate,
)
self.assertEqual(certificate, credentials.certificate)
def test_init(self):
"""
Check EventGroupDefinition initialization.
"""
name = manufacture.getUniqueString()
description = manufacture.getUniqueString()
event_group = EventGroupDefinition(
name=name, description=description)
self.assertProvides(IEventGroupDefinition, event_group)
self.assertEqual(name, event_group.name)
self.assertEqual(description, event_group.description)
def test_emit_message_from_definition_with_data(self):
"""
When data is provided the message will be interpolated based on
data and event_definition.
"""
handler = EventsHandler()
content = '''
{
"groups" : {
"group": { "description": "something"}
},
"events" : {
"100": {
"message": "100 %(data)s some message",
"groups": ["group"],
"description": "",
"version_removed": "",
"version_added": "",
"details": "",
"data": ""
}
}
}
'''
definitions = manufacture.makeEventsDefinition(content=content)
log_configuration_section = manufacture.makeLogConfigurationSection()
handler.configure(
definitions=definitions,
log_configuration_section=log_configuration_section)
data_string = manufacture.getUniqueString()
handler.emit('100', data={'data': data_string})
self.assertLog(100, regex="100 " + data_string + " some m")
def test_addFile_normal(self):
"""
System test for adding a normal non-rotate file handler.
"""
file_path, self.test_segments = manufacture.fs.makePathInTemp()
self.config.file = file_path
self.logger._configuration = self.config
log_id = manufacture.getUniqueInteger()
log_message = manufacture.getUniqueString()
result = self.logger._addFile()
self.assertIsInstance(FileHandler, result)
self.assertEqual('File %s' % (self.config.file), result.name)
# Add two log entries and close the logger.
self.logger.log(log_id, log_message)
self.logger.log(log_id + 1, log_message)
self.logger.removeAllHandlers()
# Check that file exists and it has the right content.
self.assertTrue(manufacture.fs.exists(self.test_segments))
log_content = manufacture.fs.getFileLines(self.test_segments)
self.assertEqual(2, len(log_content))
self.assertStartsWith(str(log_id), log_content[0])
self.assertEndsWith(log_message, log_content[0])
self.assertStartsWith(str(log_id + 1), log_content[1])
def test_removeHandler_success(self):
"""
It removes and closes the handler, sending a notification.
Handler is not called on further log events.
"""
log_handler = InMemoryHandler()
log_entry_id = manufacture.getUniqueInteger()
log_entry = manufacture.getUniqueString()
self.logger.addHandler(log_handler)
callback = self.Mock()
self.logger.subscribe('remove-handler', callback)
self.assertIsNotEmpty(self.logger.getHandlers())
self.logger.removeHandler(log_handler)
# No entry is recorded by the handler.
self.logger.log(log_entry_id, log_entry)
self.assertIsEmpty(log_handler.history)
# No handlers are there.
self.assertIsEmpty(self.logger.getHandlers())
self.assertEqual(1, callback.call_count)
signal = callback.call_args[0][0]
self.assertEqual(log_handler.name, signal.name)
def test_kind_name(self):
"""
If type name is request, a NotImplementedError is raises.
"""
credentials = CredentialsBase(username=manufacture.getUniqueString())
with self.assertRaises(NotImplementedError):
credentials.kind_name
def test_init(self):
"""
Check hanlder initialization.
"""
source_name = manufacture.getUniqueString()
handler = WindowsEventLogHandler(source_name)
self.assertEqual(source_name, handler.appname)
def test_init_values(self):
"""
Test initialization with values.
We use any kind of values.
"""
username = manufacture.getUniqueString()
password = manufacture.getUniqueString()
peer = manufacture.getUniqueString()
credentials = PasswordCredentials(
username=username,
password=password,
peer=peer,
)
self.assertEqual(username, credentials.username)
self.assertEqual(password, credentials.password)
self.assertEqual(peer, credentials.peer)
def test_init_default(self):
"""
Check default values.
"""
credentials = SSLCertificateCredentials(
username=manufacture.getUniqueString())
self.assertIsNone(credentials.certificate)
self.assertEqual(u'ssl certificate', credentials.kind_name)
def test_init_default(self):
"""
Check default valuse.
"""
credentials = PasswordCredentials(
username=manufacture.getUniqueString())
self.assertIsNone(credentials.password)
self.assertEqual(u'password', credentials.kind_name)
def test_init_password_not_unicode(self):
"""
AssertionError is raised if password is not unicode.
"""
with self.assertRaises(AssertionError):
PasswordCredentials(
username=manufacture.getUniqueString(),
password='******')
def test_init_default(self):
"""
By default values for credentialsBase.
"""
username = manufacture.getUniqueString()
credentials = CredentialsBase(username=username)
self.assertEqual(username, credentials.username)
self.assertIsNone(credentials.peer)
def test_init_values(self):
"""
Check set values.
"""
key_data = manufacture.getUniqueString()
key_algorithm = manufacture.getUniqueString()
key_signature = manufacture.getUniqueString()
key_signed_data = manufacture.getUniqueString()
credentials = SSHKeyCredentials(
username=manufacture.getUniqueString(),
key_data=key_data,
key_signature=key_signature,
key_algorithm=key_algorithm,
key_signed_data=key_signed_data,
)
self.assertEqual(key_data, credentials.key_data)
self.assertEqual(key_algorithm, credentials.key_algorithm)
self.assertEqual(key_signature, credentials.key_signature)
self.assertEqual(key_signed_data, credentials.key_signed_data)
def test_init_default(self):
"""
Check default values.
"""
credentials = SSHKeyCredentials(
username=manufacture.getUniqueString())
self.assertIsNone(credentials.key_data)
self.assertIsNone(credentials.key_algorithm)
self.assertIsNone(credentials.key_signature)
self.assertIsNone(credentials.key_signed_data)
self.assertEqual(u'ssh key', credentials.kind_name)
def test_getMessageID_no_id(self):
"""
1 is returned if log_entry/record does not have an id.
"""
source_name = manufacture.getUniqueString()
handler = WindowsEventLogHandler(source_name)
record = self.Bunch()
result = handler.getMessageID(record)
self.assertEqual(1, result)
def test_getMessageID_no_integer(self):
"""
1 is returned if log_entry/record does not have a valid integer ID.
"""
source_name = manufacture.getUniqueString()
handler = WindowsEventLogHandler(source_name)
record = LogEntry('no_int', 'don-t care')
result = handler.getMessageID(record)
self.assertEqual(1, result)
def test_emit_with_int_id(self):
"""
When event id is an integer, it will be converted to string.
"""
handler = EventsHandler()
message = u'Some message ' + manufacture.getUniqueString()
with patch.object(handler, 'emitEvent') as patched:
handler.emit(100, message=message)
event = patched.call_args[0][0]
self.assertEqual(u'100', event.id)
def test_getValueOrNone_value(self):
"""
getValueOrNone will return the actual value.
"""
value = manufacture.getUniqueString()
content = '{ "some": "%s"}' % (value)
json_file = manufacture.makeJSONFile(content=content)
self.assertEqual(
value,
json_file.getValueOrNone(json_file.data, 'some'),
)
def test_emit_without_configuration(self):
"""
If handler is not configured, all events will be logged using only
data from the event.
Event definitions and other configurations is not used.
"""
handler = EventsHandler()
message = u'Some message ' + manufacture.getUniqueString()
handler.emit('100', message=message)
self.assertLog(100, regex=u'Some ')
def test_emit_with_string_id(self):
"""
Events can be emitted with string ids and are converted to unicode.
"""
handler = EventsHandler()
message = u'Some message ' + manufacture.getUniqueString()
with patch.object(handler, 'emitEvent') as patched:
handler.emit(u'100', message=message)
event = patched.call_args[0][0]
self.assertEqual(u'100', event.id)
def test_load_EventDefinition_good(self):
"""
An EventDefinition with a message and groups will load just fine.
"""
event_id = manufacture.getUniqueString()
group_1 = manufacture.getUniqueString()
group_2 = manufacture.getUniqueString()
message = manufacture.getUniqueString()
content = '''
{
"groups" : {
"%s": { "description": ""},
"%s": { "description": ""}
},
"events" : {
"%s": {
"message": "%s",
"groups": ["%s", "%s"],
"description": "",
"version_removed": "",
"version_added": "",
"details": "",
"data": ""
}
}
}
''' % (group_1, group_2, event_id, message, group_1, group_2)
config = manufacture.makeEventsDefinition(
content=content, load=False)
config.load()
event_definition = config.getEventDefinition(id=event_id)
self.assertEqual(event_id, event_definition.id)
self.assertEqual(message, event_definition.message)
self.assertEqual(2, len(event_definition.groups))
self.assertIsNone(event_definition.version_added)
self.assertIsNone(event_definition.version_removed)
self.assertIsNone(event_definition.description)
def test_load_bad_config_file(self):
"""
Trying to configure from a bad formated configuration file
will raise UtilsError.
"""
content = manufacture.getUniqueString()
definitions = manufacture.makeEventsDefinition(
content=content, load=False)
with self.assertRaises(UtilsError) as context:
definitions.load()
self.assertExceptionID(u'1028', context.exception)
def test_init(self):
"""
Check Event initialization.
"""
event_id = manufacture.getUniqueString()
message = manufacture.getUniqueString()
data = {
'attr1': 'value1',
'attr2': 'value2',
'peer': manufacture.makeIPv4Address(),
'avatar': manufacture.makeFilesystemApplicationAvatar()}
event = Event(
id=event_id,
message=message,
data=data,
)
self.assertProvides(IEvent, event)
self.assertEqual(event_id, event.id)
self.assertEqual(message, event.message)
self.assertEqual(data, event.data)
def test_load_file_good_format(self):
"""
The parsed data will be available for read/write if it is valid.
"""
string_value = manufacture.getUniqueString()
content = '{ "some-good": 1, "utf8": "%s"}' % (string_value)
json_file = JSONFile(file=StringIO(content))
json_file.load()
self.assertNotEqual({}, json_file.data)
self.assertContains(u'some-good', json_file.data)
self.assertEqual(1, json_file.data['some-good'])
self.assertEqual(string_value, json_file.data['utf8'])
def test_load_EventGroup_good(self):
"""
An EventGroup with just a complex or simple description will load
just fine.
"""
name_1 = manufacture.getUniqueString()
name_2 = manufacture.getUniqueString()
description = manufacture.getUniqueString()
content = '''
{
"groups" : {
"%s": { "description": "%s"},
"%s": { "description": ""}
},
"events" : {}
}
''' % (name_1, description, name_2)
definitions = manufacture.makeEventsDefinition(content=content)
group = definitions.getEventGroupDefinition(name=name_1)
self.assertEqual(name_1, group.name)
self.assertEqual(description, group.description)
group = definitions.getEventGroupDefinition(name=name_2)
self.assertEqual(name_2, group.name)
def test_getAllEventGroupDefinitions_good(self):
"""
An getAllEventGroupDefinitions with return a dictionary with all
defined EventGroups.
"""
name_1 = manufacture.getUniqueString()
name_2 = manufacture.getUniqueString()
description = manufacture.getUniqueString()
content = '''
{
"groups" : {
"%s": { "description": "%s"},
"%s": { "description": ""}
},
"events" : {}
}
''' % (name_1, description, name_2)
config = manufacture.makeEventsDefinition(content=content)
result = config.getAllEventGroupDefinitions()
self.assertEqual(2, len(result))
self.assertTrue(name_1 in result)
self.assertTrue(name_2 in result)
def test_getSession_no_session(self):
"""
None is returned if the request does not contain session
information or the information is not valid.
"""
session = json_rpc._get_session(self.request)
self.assertIsNone(session)
request = manufacture.makeTwistedWebRequest()
request.setRequestHeader(
'authorization', manufacture.getUniqueString())
session = json_rpc._get_session(request)
self.assertIsNone(session)
def test_getMessageID_valid(self):
"""
The event id is returned if log_entry/record has a valid id.
"""
source_name = manufacture.getUniqueString()
handler = WindowsEventLogHandler(source_name)
record = self.Bunch(message_id='2')
result = handler.getMessageID(record)
self.assertEqual(2, result)
# Let's try with an int.
record = self.Bunch(message_id=3)
result = handler.getMessageID(record)
self.assertEqual(3, result)
