Adding comparison operators in query for event traits
In EventFilter we have an optional parameter 'op' in traits_filter part. But up to date usage of this param has been implemented only in Hbase and Mongodb backends. However in API we can use only 'op'='eq'. This change improves usage of parameter 'op' in query for events in api, and adds possibility to use comparison in query with SQL backend. Some tests are also added to cover using of this new feature. Closes-bug: #1354009 Change-Id: I4824800eac7270bcfa10882a735e48d80bf32712
This commit is contained in:
Igor Degtiarov
parent
b8974633c0
commit
be88b00e90
@ -56,7 +56,6 @@ from ceilometer import sample
|
||||
from ceilometer import storage
|
||||
from ceilometer import utils
|
||||
|
||||
|
||||
LOG = log.getLogger(__name__)
|
||||
|
||||
|
||||
@ -79,7 +78,8 @@ cfg.CONF.register_opts(ALARM_API_OPTS, group='alarm')
|
||||
|
||||
state_kind = ["ok", "alarm", "insufficient data"]
|
||||
state_kind_enum = wtypes.Enum(str, *state_kind)
|
||||
operation_kind = wtypes.Enum(str, 'lt', 'le', 'eq', 'ne', 'ge', 'gt')
|
||||
operation_kind = ('lt', 'le', 'eq', 'ne', 'ge', 'gt')
|
||||
operation_kind_enum = wtypes.Enum(str, *operation_kind)
|
||||
|
||||
|
||||
class ClientSideError(wsme.exc.ClientSideError):
|
||||
@ -245,7 +245,7 @@ class Query(_Base):
|
||||
|
||||
# op = wsme.wsattr(operation_kind, default='eq')
|
||||
# this ^ doesn't seem to work.
|
||||
op = wsme.wsproperty(operation_kind, get_op, set_op)
|
||||
op = wsme.wsproperty(operation_kind_enum, get_op, set_op)
|
||||
"The comparison operator. Defaults to 'eq'."
|
||||
|
||||
value = wtypes.text
|
||||
@ -2321,16 +2321,17 @@ def _event_query_to_event_filter(q):
|
||||
traits_filter = []
|
||||
|
||||
for i in q:
|
||||
# FIXME(herndon): Support for operators other than
|
||||
# 'eq' will come later.
|
||||
if i.op != 'eq':
|
||||
error = _("operator %s not supported") % i.op
|
||||
if not i.op:
|
||||
i.op = 'eq'
|
||||
elif i.op not in operation_kind:
|
||||
error = _("operator {} is incorrect").format(i.op)
|
||||
raise ClientSideError(error)
|
||||
if i.field in evt_model_filter:
|
||||
evt_model_filter[i.field] = i.value
|
||||
else:
|
||||
traits_filter.append({"key": i.field,
|
||||
i.type: i._get_value_as_type()})
|
||||
i.type: i._get_value_as_type(),
|
||||
"op": i.op})
|
||||
return storage.EventFilter(traits_filter=traits_filter, **evt_model_filter)
|
||||
|
||||
|
||||
|
||||
@ -131,7 +131,6 @@ class MTable(object):
|
||||
r = {}
|
||||
for row in rows:
|
||||
data = rows[row]
|
||||
|
||||
if op == '=':
|
||||
if column in data and data[column] == value:
|
||||
r[row] = data
|
||||
@ -147,11 +146,9 @@ class MTable(object):
|
||||
elif op == '>=':
|
||||
if column in data and data[column] >= value:
|
||||
r[row] = data
|
||||
else:
|
||||
raise NotImplementedError("In-memory "
|
||||
"SingleColumnValueFilter "
|
||||
"doesn't support the %s operation "
|
||||
"yet" % op)
|
||||
elif op == '!=':
|
||||
if column in data and data[column] != value:
|
||||
r[row] = data
|
||||
return r
|
||||
|
||||
@staticmethod
|
||||
|
||||
@ -770,19 +770,14 @@ class Connection(base.Connection):
|
||||
# Build a sub query that joins Trait to TraitType
|
||||
# where the trait name matches
|
||||
trait_name = trait_filter.pop('key')
|
||||
op = trait_filter.pop('op', 'eq')
|
||||
conditions = [models.Trait.trait_type_id ==
|
||||
models.TraitType.id,
|
||||
models.TraitType.desc == trait_name]
|
||||
|
||||
for key, value in six.iteritems(trait_filter):
|
||||
if key == 'string':
|
||||
conditions.append(models.Trait.t_string == value)
|
||||
elif key == 'integer':
|
||||
conditions.append(models.Trait.t_int == value)
|
||||
elif key == 'datetime':
|
||||
conditions.append(models.Trait.t_datetime == value)
|
||||
elif key == 'float':
|
||||
conditions.append(models.Trait.t_float == value)
|
||||
sql_utils.trait_op_condition(conditions,
|
||||
key, value, op)
|
||||
|
||||
trait_query = (session.query(models.Trait.event_id).
|
||||
join(models.TraitType,
|
||||
|
||||
@ -122,3 +122,18 @@ class QueryTransformer(object):
|
||||
|
||||
def get_query(self):
|
||||
return self.query
|
||||
|
||||
|
||||
trait_models_dict = {'string': models.Trait.t_string,
|
||||
'integer': models.Trait.t_int,
|
||||
'datetime': models.Trait.t_datetime,
|
||||
'float': models.Trait.t_float}
|
||||
|
||||
|
||||
def trait_op_condition(conditions, trait_type, value, op='eq'):
|
||||
trait_model = trait_models_dict[trait_type]
|
||||
op_dict = {'eq': (trait_model == value), 'lt': (trait_model < value),
|
||||
'le': (trait_model <= value), 'gt': (trait_model > value),
|
||||
'ge': (trait_model >= value), 'ne': (trait_model != value)}
|
||||
conditions.append(op_dict[op])
|
||||
return conditions
|
||||
|
||||
@ -17,6 +17,7 @@
|
||||
import datetime
|
||||
|
||||
from oslo.utils import timeutils
|
||||
import webtest.app
|
||||
|
||||
from ceilometer.storage import models
|
||||
from ceilometer.tests.api import v2
|
||||
@ -50,13 +51,16 @@ class EventTestBase(v2.FunctionalTest,
|
||||
|
||||
# Message ID for test will be 'base'. So, message ID for the first
|
||||
# event will be '0', the second '100', and so on.
|
||||
# trait_time in first event will be equal to self.trait_time
|
||||
# (datetime.datetime(2013, 12, 31, 5, 0)), next will add 1 day, so
|
||||
# second will be (datetime.datetime(2014, 01, 01, 5, 0)) and so on.
|
||||
event_models.append(
|
||||
models.Event(message_id=str(base),
|
||||
event_type=event_type,
|
||||
generated=self.trait_time,
|
||||
traits=trait_models))
|
||||
base += 100
|
||||
|
||||
self.trait_time += datetime.timedelta(days=1)
|
||||
self.conn.record_events(event_models)
|
||||
|
||||
|
||||
@ -107,7 +111,8 @@ class TestTraitAPI(EventTestBase):
|
||||
data = self.get_json(path, headers=headers)
|
||||
self.assertEqual(1, len(data))
|
||||
self.assertEqual("trait_D", data[0]['name'])
|
||||
self.assertEqual(self.trait_time.isoformat(), data[0]['value'])
|
||||
self.assertEqual((self.trait_time - datetime.timedelta(days=3)).
|
||||
isoformat(), data[0]['value'])
|
||||
|
||||
def test_get_trait_data_for_non_existent_event(self):
|
||||
path = (self.PATH % "NO_SUCH_EVENT") + "/trait_A"
|
||||
@ -125,15 +130,17 @@ class TestTraitAPI(EventTestBase):
|
||||
class TestEventAPI(EventTestBase):
|
||||
|
||||
PATH = '/events'
|
||||
START_TRAIT_TIME = datetime.datetime(2013, 12, 31, 5, 0)
|
||||
|
||||
def test_get_events(self):
|
||||
data = self.get_json(self.PATH, headers=headers)
|
||||
self.assertEqual(3, len(data))
|
||||
# We expect to get native UTC generated time back
|
||||
expected_generated = timeutils.strtime(
|
||||
at=timeutils.normalize_time(self.trait_time),
|
||||
fmt=timeutils._ISO8601_TIME_FORMAT)
|
||||
trait_time = self.START_TRAIT_TIME
|
||||
for event in data:
|
||||
expected_generated = timeutils.strtime(
|
||||
at=timeutils.normalize_time(trait_time),
|
||||
fmt=timeutils._ISO8601_TIME_FORMAT)
|
||||
self.assertTrue(event['event_type'] in ['Foo', 'Bar', 'Zoo'])
|
||||
self.assertEqual(4, len(event['traits']))
|
||||
self.assertEqual(expected_generated, event['generated'])
|
||||
@ -141,6 +148,7 @@ class TestEventAPI(EventTestBase):
|
||||
'trait_C', 'trait_D']:
|
||||
self.assertTrue(trait_name in map(lambda x: x['name'],
|
||||
event['traits']))
|
||||
trait_time += datetime.timedelta(days=1)
|
||||
|
||||
def test_get_event_by_message_id(self):
|
||||
event = self.get_json(self.PATH + "/100", headers=headers)
|
||||
@ -155,10 +163,10 @@ class TestEventAPI(EventTestBase):
|
||||
'value': '100.123456'},
|
||||
{'name': 'trait_D',
|
||||
'type': 'datetime',
|
||||
'value': '2013-12-31T05:00:00'}]
|
||||
'value': '2014-01-01T05:00:00'}]
|
||||
self.assertEqual('100', event['message_id'])
|
||||
self.assertEqual('Bar', event['event_type'])
|
||||
self.assertEqual('2013-12-31T05:00:00', event['generated'])
|
||||
self.assertEqual('2014-01-01T05:00:00', event['generated'])
|
||||
self.assertEqual(expected_traits, event['traits'])
|
||||
|
||||
def test_get_event_by_message_id_no_such_id(self):
|
||||
@ -209,13 +217,13 @@ class TestEventAPI(EventTestBase):
|
||||
def test_get_events_filter_datetime_trait(self):
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_D',
|
||||
'value': self.trait_time.isoformat(),
|
||||
'value': '2014-01-01T05:00:00',
|
||||
'type': 'datetime'}])
|
||||
self.assertEqual(3, len(data))
|
||||
self.assertEqual(1, len(data))
|
||||
traits = filter(lambda x: x['name'] == 'trait_D', data[0]['traits'])
|
||||
self.assertEqual(1, len(traits))
|
||||
self.assertEqual('datetime', traits[0]['type'])
|
||||
self.assertEqual(self.trait_time.isoformat(), traits[0]['value'])
|
||||
self.assertEqual('2014-01-01T05:00:00', traits[0]['value'])
|
||||
|
||||
def test_get_events_multiple_filters(self):
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
@ -243,3 +251,163 @@ class TestEventAPI(EventTestBase):
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[])
|
||||
self.assertEqual(3, len(data))
|
||||
|
||||
def test_get_events_filter_op_string(self):
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_A',
|
||||
'value': 'my_Foo_text',
|
||||
'type': 'string',
|
||||
'op': 'eq'}])
|
||||
self.assertEqual(1, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_A',
|
||||
'value': 'my_Bar_text',
|
||||
'type': 'string',
|
||||
'op': 'lt'}])
|
||||
self.assertEqual(0, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_A',
|
||||
'value': 'my_Zoo_text',
|
||||
'type': 'string',
|
||||
'op': 'le'}])
|
||||
self.assertEqual(3, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_A',
|
||||
'value': 'my_Foo_text',
|
||||
'type': 'string',
|
||||
'op': 'ne'}])
|
||||
self.assertEqual(2, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_A',
|
||||
'value': 'my_Bar_text',
|
||||
'type': 'string',
|
||||
'op': 'gt'}])
|
||||
self.assertEqual(2, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_A',
|
||||
'value': 'my_Zoo_text',
|
||||
'type': 'string',
|
||||
'op': 'ge'}])
|
||||
self.assertEqual(1, len(data))
|
||||
|
||||
def test_get_events_filter_op_integer(self):
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_B',
|
||||
'value': '101',
|
||||
'type': 'integer',
|
||||
'op': 'eq'}])
|
||||
self.assertEqual(1, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_B',
|
||||
'value': '201',
|
||||
'type': 'integer',
|
||||
'op': 'lt'}])
|
||||
self.assertEqual(2, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_B',
|
||||
'value': '1',
|
||||
'type': 'integer',
|
||||
'op': 'le'}])
|
||||
self.assertEqual(1, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_B',
|
||||
'value': '101',
|
||||
'type': 'integer',
|
||||
'op': 'ne'}])
|
||||
self.assertEqual(2, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_B',
|
||||
'value': '201',
|
||||
'type': 'integer',
|
||||
'op': 'gt'}])
|
||||
self.assertEqual(0, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_B',
|
||||
'value': '1',
|
||||
'type': 'integer',
|
||||
'op': 'ge'}])
|
||||
self.assertEqual(3, len(data))
|
||||
|
||||
def test_get_events_filter_op_float(self):
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_C',
|
||||
'value': '100.123456',
|
||||
'type': 'float',
|
||||
'op': 'eq'}])
|
||||
self.assertEqual(1, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_C',
|
||||
'value': '200.123456',
|
||||
'type': 'float',
|
||||
'op': 'lt'}])
|
||||
self.assertEqual(2, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_C',
|
||||
'value': '0.123456',
|
||||
'type': 'float',
|
||||
'op': 'le'}])
|
||||
self.assertEqual(1, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_C',
|
||||
'value': '100.123456',
|
||||
'type': 'float',
|
||||
'op': 'ne'}])
|
||||
self.assertEqual(2, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_C',
|
||||
'value': '200.123456',
|
||||
'type': 'float',
|
||||
'op': 'gt'}])
|
||||
self.assertEqual(0, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_C',
|
||||
'value': '0.123456',
|
||||
'type': 'float',
|
||||
'op': 'ge'}])
|
||||
self.assertEqual(3, len(data))
|
||||
|
||||
def test_get_events_filter_op_datatime(self):
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_D',
|
||||
'value': '2014-01-01T05:00:00',
|
||||
'type': 'datetime',
|
||||
'op': 'eq'}])
|
||||
self.assertEqual(1, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_D',
|
||||
'value': '2014-01-02T05:00:00',
|
||||
'type': 'datetime',
|
||||
'op': 'lt'}])
|
||||
self.assertEqual(2, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_D',
|
||||
'value': '2013-12-31T05:00:00',
|
||||
'type': 'datetime',
|
||||
'op': 'le'}])
|
||||
self.assertEqual(1, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_D',
|
||||
'value': '2014-01-01T05:00:00',
|
||||
'type': 'datetime',
|
||||
'op': 'ne'}])
|
||||
self.assertEqual(2, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_D',
|
||||
'value': '2014-01-02T05:00:00',
|
||||
'type': 'datetime',
|
||||
'op': 'gt'}])
|
||||
self.assertEqual(0, len(data))
|
||||
data = self.get_json(self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_D',
|
||||
'value': '2013-12-31T05:00:00',
|
||||
'type': 'datetime',
|
||||
'op': 'ge'}])
|
||||
self.assertEqual(3, len(data))
|
||||
|
||||
def test_get_events_filter_wrong_op(self):
|
||||
self.assertRaises(webtest.app.AppError,
|
||||
self.get_json, self.PATH, headers=headers,
|
||||
q=[{'field': 'trait_B',
|
||||
'value': '1',
|
||||
'type': 'integer',
|
||||
'op': 'el'}])
|
||||
@ -2825,6 +2825,165 @@ class GetEventTest(EventTestBase):
|
||||
self.assertEqual(events[0].event_type, "Bar")
|
||||
self.assertEqual(4, len(events[0].traits))
|
||||
|
||||
def test_get_event_trait_filter_op_string(self):
|
||||
trait_filters = [{'key': 'trait_A', 'string': 'my_Foo_text',
|
||||
'op': 'eq'}]
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(2, len(events))
|
||||
self.assertEqual("Foo", events[0].event_type)
|
||||
self.assertEqual(4, len(events[0].traits))
|
||||
trait_filters[0].update({'key': 'trait_A', 'op': 'lt'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(2, len(events))
|
||||
self.assertEqual("Bar", events[0].event_type)
|
||||
trait_filters[0].update({'key': 'trait_A', 'op': 'le'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(4, len(events))
|
||||
self.assertEqual("Bar", events[1].event_type)
|
||||
trait_filters[0].update({'key': 'trait_A', 'op': 'ne'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(4, len(events))
|
||||
self.assertEqual("Zoo", events[3].event_type)
|
||||
trait_filters[0].update({'key': 'trait_A', 'op': 'gt'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(2, len(events))
|
||||
self.assertEqual("Zoo", events[0].event_type)
|
||||
trait_filters[0].update({'key': 'trait_A', 'op': 'ge'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(4, len(events))
|
||||
self.assertEqual("Foo", events[2].event_type)
|
||||
|
||||
def test_get_event_trait_filter_op_integer(self):
|
||||
trait_filters = [{'key': 'trait_B', 'integer': 101, 'op': 'eq'}]
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(1, len(events))
|
||||
self.assertEqual("Bar", events[0].event_type)
|
||||
self.assertEqual(4, len(events[0].traits))
|
||||
trait_filters[0].update({'key': 'trait_B', 'op': 'lt'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(1, len(events))
|
||||
self.assertEqual("Foo", events[0].event_type)
|
||||
trait_filters[0].update({'key': 'trait_B', 'op': 'le'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(2, len(events))
|
||||
self.assertEqual("Bar", events[1].event_type)
|
||||
trait_filters[0].update({'key': 'trait_B', 'op': 'ne'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(5, len(events))
|
||||
self.assertEqual("Zoo", events[4].event_type)
|
||||
trait_filters[0].update({'key': 'trait_B', 'op': 'gt'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(4, len(events))
|
||||
self.assertEqual("Zoo", events[0].event_type)
|
||||
trait_filters[0].update({'key': 'trait_B', 'op': 'ge'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(5, len(events))
|
||||
self.assertEqual("Foo", events[2].event_type)
|
||||
|
||||
def test_get_event_trait_filter_op_float(self):
|
||||
trait_filters = [{'key': 'trait_C', 'float': 300.123456, 'op': 'eq'}]
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(1, len(events))
|
||||
self.assertEqual("Foo", events[0].event_type)
|
||||
self.assertEqual(4, len(events[0].traits))
|
||||
trait_filters[0].update({'key': 'trait_C', 'op': 'lt'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(3, len(events))
|
||||
self.assertEqual("Zoo", events[2].event_type)
|
||||
trait_filters[0].update({'key': 'trait_C', 'op': 'le'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(4, len(events))
|
||||
self.assertEqual("Bar", events[1].event_type)
|
||||
trait_filters[0].update({'key': 'trait_C', 'op': 'ne'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(5, len(events))
|
||||
self.assertEqual("Zoo", events[2].event_type)
|
||||
trait_filters[0].update({'key': 'trait_C', 'op': 'gt'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(2, len(events))
|
||||
self.assertEqual("Bar", events[0].event_type)
|
||||
trait_filters[0].update({'key': 'trait_C', 'op': 'ge'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(3, len(events))
|
||||
self.assertEqual("Zoo", events[2].event_type)
|
||||
|
||||
def test_get_event_trait_filter_op_datetime(self):
|
||||
trait_filters = [{'key': 'trait_D',
|
||||
'datetime': self.start + datetime.timedelta(hours=2),
|
||||
'op': 'eq'}]
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(1, len(events))
|
||||
self.assertEqual("Zoo", events[0].event_type)
|
||||
self.assertEqual(4, len(events[0].traits))
|
||||
trait_filters[0].update({'key': 'trait_D', 'op': 'lt'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(2, len(events))
|
||||
trait_filters[0].update({'key': 'trait_D', 'op': 'le'})
|
||||
self.assertEqual("Bar", events[1].event_type)
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(3, len(events))
|
||||
self.assertEqual("Bar", events[1].event_type)
|
||||
trait_filters[0].update({'key': 'trait_D', 'op': 'ne'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(5, len(events))
|
||||
self.assertEqual("Foo", events[2].event_type)
|
||||
trait_filters[0].update({'key': 'trait_D', 'op': 'gt'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(3, len(events))
|
||||
self.assertEqual("Zoo", events[2].event_type)
|
||||
trait_filters[0].update({'key': 'trait_D', 'op': 'ge'})
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(4, len(events))
|
||||
self.assertEqual("Bar", events[2].event_type)
|
||||
|
||||
def test_get_event_multiple_trait_filter(self):
|
||||
trait_filters = [{'key': 'trait_B', 'integer': 1},
|
||||
{'key': 'trait_A', 'string': 'my_Foo_text'}]
|
||||
@ -2832,7 +2991,7 @@ class GetEventTest(EventTestBase):
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(1, len(events))
|
||||
self.assertEqual(events[0].event_type, "Foo")
|
||||
self.assertEqual("Foo", events[0].event_type)
|
||||
self.assertEqual(4, len(events[0].traits))
|
||||
|
||||
def test_get_event_multiple_trait_filter_expect_none(self):
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user