def _get_events_by_type(self, event_types):
"""Get events by type
:param event_types:
Type filter ('cloudify_event' and/or 'cloudify_log')
:type event_types: list(str)
"""
event_classes = tuple(
[self.TYPE_TO_MODEL[event_type] for event_type in event_types])
filters = {'type': event_types}
query = EventsV1._build_select_query(filters, self.DEFAULT_SORT,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id)
events = query.params(**self.DEFAULT_PAGINATION).all()
event_ids = [event.id for event in events]
count_query = EventsV1._build_count_query(filters,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id)
event_count = count_query.params(**self.DEFAULT_RANGE_FILTERS).scalar()
expected_events = [
event for event in self.events if isinstance(event, event_classes)
]
expected_event_ids = [event.id for event in expected_events]
self.assertListEqual(event_ids, expected_event_ids)
self.assertEqual(event_count, len(expected_events))
def test_filter_required(self):
"""Filter parameter is expected to be dictionary."""
params = deepcopy(self.DEFAULT_PARAMS)
params['filters'] = None
params['tenant_id'] = 1
with self.assertRaises(AssertionError):
EventsV1._build_select_query(**params)
def test_filter_by_level_and_type_cloudify_event(self):
"""Filter events by level and type cloudify_event."""
level = choice(self.LOG_LEVELS)
filters = {
'level': [level],
'type': ['cloudify_event']
}
query = EventsV1._build_select_query(
filters,
self.DEFAULT_SORT,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id
)
events = query.params(**self.DEFAULT_PAGINATION).all()
count_query = EventsV1._build_count_query(
filters,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id
)
event_count = count_query.params(**self.DEFAULT_RANGE_FILTERS).scalar()
# events don't have level, so query should return no results
expected_events = []
self.assertListEqual(events, expected_events)
self.assertEqual(event_count, len(expected_events))
def filter_by_message_helper(self, message_field):
"""Filter events by message field."""
word = self.fake.word()
filters = {
message_field: ['%{0}%'.format(word)],
'type': ['cloudify_event', 'cloudify_log']
}
query = EventsV1._build_select_query(
filters,
self.DEFAULT_SORT,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id
)
events = query.params(**self.DEFAULT_PAGINATION).all()
event_ids = [event.id for event in events]
count_query = EventsV1._build_count_query(
filters,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id
)
event_count = count_query.params(**self.DEFAULT_RANGE_FILTERS).scalar()
expected_events = [
event
for event in self.events
if word.lower() in event.message.lower()
]
expected_event_ids = [event.id for event in expected_events]
self.assertListEqual(event_ids, expected_event_ids)
self.assertEqual(event_count, len(expected_events))
def test_filter_by_event_type_and_type_cloudify_log(self):
"""Filter events by even_type and type cloudify_log."""
event_type = choice(self.EVENT_TYPES)
filters = {
'event_type': [event_type],
'type': ['cloudify_log']
}
query = EventsV1._build_select_query(
filters,
self.DEFAULT_SORT,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id
)
events = query.params(**self.DEFAULT_PAGINATION).all()
count_query = EventsV1._build_count_query(
filters,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id
)
event_count = count_query.params(**self.DEFAULT_RANGE_FILTERS).scalar()
# logs don't have event_type, so query should return no results
expected_events = []
self.assertListEqual(events, expected_events)
self.assertEqual(event_count, len(expected_events))
def test_filter_by_level(self):
"""Filter events by level."""
level = choice(self.LOG_LEVELS)
filters = {
'level': [level],
'type': ['cloudify_event', 'cloudify_log']
}
query = EventsV1._build_select_query(
filters,
self.DEFAULT_SORT,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id
)
events = query.params(**self.DEFAULT_PAGINATION).all()
event_ids = [event.id for event in events]
count_query = EventsV1._build_count_query(
filters,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id
)
event_count = count_query.params(**self.DEFAULT_RANGE_FILTERS).scalar()
expected_events = [
event
for event in self.events
if getattr(event, 'level', None) == level
]
expected_event_ids = [event.id for event in expected_events]
self.assertListEqual(event_ids, expected_event_ids)
self.assertEqual(event_count, len(expected_events))
def test_filter_by_execution(self):
"""Filter events by execution."""
execution = choice(self.executions)
filters = {
'execution_id': [execution.id],
'type': ['cloudify_event', 'cloudify_log']
}
query = EventsV1._build_select_query(
filters,
self.DEFAULT_SORT,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id
)
events = query.params(**self.DEFAULT_PAGINATION).all()
event_ids = [event.id for event in events]
count_query = EventsV1._build_count_query(
filters,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id
)
event_count = count_query.params(**self.DEFAULT_RANGE_FILTERS).scalar()
expected_events = [
event
for event in self.events
if event._execution_fk == execution._storage_id
]
expected_event_ids = [event.id for event in expected_events]
self.assertListEqual(event_ids, expected_event_ids)
self.assertEqual(event_count, len(expected_events))
def _sort_by_timestamp(self, field, direction):
"""Sort by a given field.
:param field: Field name (timestamp/@timestamp)
:type field: str
:param direction: Sorting direction (asc/desc)
:type direction: str
"""
sort = {field: direction}
query = EventsV1._build_select_query(self.DEFAULT_FILTERS, sort,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id)
events = query.params(**self.DEFAULT_PAGINATION).all()
event_timestamps = [event.timestamp for event in events]
count_query = EventsV1._build_count_query(self.DEFAULT_FILTERS,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id)
event_count = count_query.params(**self.DEFAULT_RANGE_FILTERS).scalar()
expected_events = sorted(
self.events,
key=lambda event: event.timestamp,
reverse=direction == 'desc',
)
expected_event_timestamps = [
event.timestamp for event in expected_events
]
self.assertListEqual(event_timestamps, expected_event_timestamps)
self.assertEqual(event_count, len(expected_events))
def _filter_by_timestamp_range(
self, field, include_from=True, include_to=True):
"""Filter by timestamp range.
:param field: Field name to use (timestamp/@timestamp)
:type field: str
:param include_from: Whether to include from field in range filter
:type include_from: bool
:param include_to: Whether to include from field in range filter
:type include_to: bool
"""
fake = Faker()
from_datetime, to_datetime = sorted(
[fake.date_time(), fake.date_time()])
range_filter = {}
if include_from:
range_filter['from'] = from_datetime
if include_to:
range_filter['to'] = to_datetime
range_filters = {field: range_filter}
query = EventsV1._build_select_query(
self.DEFAULT_FILTERS,
self.DEFAULT_SORT,
range_filters,
self.tenant.id
)
events = query.params(**self.DEFAULT_PAGINATION).all()
event_timestamps = [event.timestamp for event in events]
count_query = EventsV1._build_count_query(
self.DEFAULT_FILTERS,
range_filters,
self.tenant.id
)
event_count = count_query.params(**range_filters).scalar()
sorted_events = sorted(
self.events,
key=lambda event: event.timestamp,
)
from_timestamp = '{}Z'.format(from_datetime.isoformat()[:-3])
to_timestamp = '{}Z'.format(to_datetime.isoformat()[:-3])
expected_events = [
event
for event in sorted_events
if (
(not include_from or from_timestamp <= event.timestamp) and
(not include_to or event.timestamp <= to_timestamp)
)
]
expected_event_timestamps = [
event.timestamp for event in expected_events]
self.assertListEqual(event_timestamps, expected_event_timestamps)
self.assertEqual(event_count, len(expected_events))
def test_filter_by_unknown_range(self):
"""Filter by unknown field range."""
with self.assertRaises(BadParametersError):
EventsV1._build_select_query(self.DEFAULT_FILTERS,
self.DEFAULT_SORT,
{'unknown': {
'from': 'a',
'to': 'b'
}}, self.tenant.id)
def test_filter_by_unknown(self):
"""Filter events by an unknown field."""
filters = {
'unknown': ['<value>'],
'type': ['cloudify_event', 'cloudify_log']
}
with self.assertRaises(BadParametersError):
EventsV1._build_select_query(filters, self.DEFAULT_SORT,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id)
def test_filter_by_blueprint(self):
"""Filter events by blueprint."""
blueprint = choice(self.blueprints)
filters = {
'blueprint_id': [blueprint.id],
'type': ['cloudify_event', 'cloudify_log']
}
query, event_count = EventsV1._build_select_query(
filters, self.DEFAULT_SORT, self.DEFAULT_RANGE_FILTERS,
self.tenant.id)
events = query.params(**self.DEFAULT_PAGINATION).all()
event_ids = [event.id for event in events]
expected_deployment_ids = [
deployment._storage_id for deployment in self.deployments
if deployment._blueprint_fk == blueprint._storage_id
]
expected_executions_id = [
execution._storage_id for execution in self.executions
if execution._deployment_fk in expected_deployment_ids
]
expected_events = [
event for event in self.events
if event._execution_fk in expected_executions_id
]
expected_event_ids = [event.id for event in expected_events]
self.assertListEqual(event_ids, expected_event_ids)
self.assertEqual(event_count, len(expected_events))
def test_different_tenant(self):
"""A new tenant sees none of the events of other tenants"""
tenant = Tenant(name='other_tenant')
db.session.add(tenant)
db.session.commit()
query = EventsV1._build_select_query(
self.DEFAULT_FILTERS, self.DEFAULT_SORT,
self.DEFAULT_RANGE_FILTERS, tenant.id)
events = query.params(**self.DEFAULT_PAGINATION).all()
events_count = EventsV1._build_count_query(
self.DEFAULT_FILTERS, self.DEFAULT_RANGE_FILTERS,
tenant.id).scalar()
self.assertEqual(events, [])
self.assertEqual(events_count, 0)
def test_get_events_and_logs_implicit(self):
"""Get both events and logs implicitly without passing any filter."""
filters = {}
query = EventsV1._build_select_query(filters, self.DEFAULT_SORT,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id)
events = query.params(**self.DEFAULT_PAGINATION).all()
event_ids = [event.id for event in events]
count_query = EventsV1._build_count_query(filters,
self.DEFAULT_RANGE_FILTERS,
self.tenant.id)
event_count = count_query.params(**self.DEFAULT_RANGE_FILTERS).scalar()
expected_events = self.events
expected_event_ids = [event.id for event in expected_events]
self.assertListEqual(event_ids, expected_event_ids)
self.assertEqual(event_count, len(expected_events))
def test_map_log(self):
"""Map log as returned by SQL query to elasticsearch style output."""
sql_log = EventResult(
timestamp='2017-05-22T00:00Z',
reported_timestamp='2016-12-09T00:00Z',
deployment_id='<deployment_id>',
execution_id='<execution_id>',
workflow_id='<workflow_id>',
message='<message>',
message_code=None,
event_type=None,
operation='<operation>',
node_id='<node_id>',
node_instance_id='<node_instance_id>',
node_name='<node_name>',
level='<level>',
logger='<logger>',
type='cloudify_log',
)
expected_es_log = {
'context': {
'deployment_id': '<deployment_id>',
'execution_id': '<execution_id>',
'workflow_id': '<workflow_id>',
'operation': '<operation>',
'node_id': '<node_id>',
'node_name': '<node_name>',
},
'level': '<level>',
'timestamp': '2017-05-22T00:00Z',
'@timestamp': '2017-05-22T00:00Z',
'message': {
'text': '<message>'
},
'message_code': None,
'type': 'cloudify_log',
'logger': '<logger>',
}
es_log = EventsV1._map_event_to_dict(None, sql_log)
self.assertDictEqual(es_log, expected_es_log)
def test_filter_by_event_type(self):
"""Filter events by event_type."""
event_type = choice(self.EVENT_TYPES)
filters = {
'event_type': [event_type],
'type': ['cloudify_event', 'cloudify_log']
}
query, event_count = EventsV1._build_select_query(
filters, self.DEFAULT_SORT, self.DEFAULT_RANGE_FILTERS,
self.tenant.id)
events = query.params(**self.DEFAULT_PAGINATION).all()
event_ids = [event.id for event in events]
expected_events = [
event for event in self.events
if getattr(event, 'event_type', None) == event_type
]
expected_event_ids = [event.id for event in expected_events]
self.assertListEqual(event_ids, expected_event_ids)
self.assertEqual(event_count, len(expected_events))
def test_map_event(self):
"""Map event as returned by SQL query to elasticsearch style output."""
sql_event = EventResult(
timestamp='2016-12-09T00:00Z',
deployment_id='<deployment_id>',
execution_id='<execution_id>',
workflow_id='<workflow_id>',
message='<message>',
message_code=None,
event_type='<event_type>',
operation='<operation>',
node_id='<node_id>',
node_instance_id='<node_instance_id>',
node_name='<node_name>',
logger=None,
level=None,
type='cloudify_event',
)
expected_es_event = {
'context': {
'deployment_id': '<deployment_id>',
'execution_id': '<execution_id>',
'workflow_id': '<workflow_id>',
'operation': '<operation>',
'node_id': '<node_id>',
'node_name': '<node_name>',
},
'event_type': '<event_type>',
'timestamp': '2016-12-09T00:00Z',
'@timestamp': '2016-12-09T00:00Z',
'message': {
'arguments': None,
'text': '<message>',
},
'message_code': None,
'type': 'cloudify_event',
}
es_event = EventsV1._map_event_to_dict(None, sql_event)
self.assertDictEqual(es_event, expected_es_event)
def test_filter_required(self):
"""Filter parameter is expected to be dictionary."""
filters = None
with self.assertRaises(AssertionError):
EventsV1._build_select_query(filters, {}, {}, tenant_id=1)