remove event_* prefixes
we don't need this. Change-Id: Ia2008bb8de5335776b58b8e5e5f69f7ec88d30b9
This commit is contained in:
parent
41f345f552
commit
97742e644d
|
@ -140,12 +140,12 @@ function cleanup_panko {
|
|||
# Set configuration for storage backend.
|
||||
function _panko_configure_storage_backend {
|
||||
if [ "$PANKO_BACKEND" = 'mysql' ] || [ "$PANKO_BACKEND" = 'postgresql' ] ; then
|
||||
iniset $PANKO_CONF database event_connection $(database_connection_url panko)
|
||||
iniset $PANKO_CONF database connection $(database_connection_url panko)
|
||||
elif [ "$PANKO_BACKEND" = 'es' ] ; then
|
||||
iniset $PANKO_CONF database event_connection es://localhost:9200
|
||||
iniset $PANKO_CONF database connection es://localhost:9200
|
||||
${TOP_DIR}/pkg/elasticsearch.sh start
|
||||
elif [ "$PANKO_BACKEND" = 'mongodb' ] ; then
|
||||
iniset $PANKO_CONF database event_connection mongodb://localhost:27017/panko
|
||||
iniset $PANKO_CONF database connection mongodb://localhost:27017/panko
|
||||
else
|
||||
die $LINENO "Unable to configure unknown PANKO_BACKEND $PANKO_BACKEND"
|
||||
fi
|
||||
|
|
|
@ -64,10 +64,8 @@ class CapabilitiesController(rest.RestController):
|
|||
"""
|
||||
# variation in API capabilities is effectively determined by
|
||||
# the lack of strict feature parity across storage drivers
|
||||
event_conn = pecan.request.event_storage_conn
|
||||
driver_capabilities = {'events':
|
||||
event_conn.get_capabilities()['events']}
|
||||
event_driver_perf = event_conn.get_storage_capabilities()
|
||||
conn = pecan.request.conn
|
||||
driver_capabilities = {'events': conn.get_capabilities()['events']}
|
||||
driver_perf = conn.get_storage_capabilities()
|
||||
return Capabilities(api=_flatten_capabilities(driver_capabilities),
|
||||
event_storage=_flatten_capabilities(
|
||||
event_driver_perf))
|
||||
event_storage=_flatten_capabilities(driver_perf))
|
||||
|
|
|
@ -233,8 +233,7 @@ class TraitsController(rest.RestController):
|
|||
"""
|
||||
LOG.debug("Getting traits for %s", event_type)
|
||||
return [Trait._convert_storage_trait(t)
|
||||
for t in pecan.request.event_storage_conn
|
||||
.get_traits(event_type, trait_name)]
|
||||
for t in pecan.request.conn.get_traits(event_type, trait_name)]
|
||||
|
||||
@v2_utils.requires_admin
|
||||
@wsme_pecan.wsexpose([TraitDescription], wtypes.text)
|
||||
|
@ -246,8 +245,7 @@ class TraitsController(rest.RestController):
|
|||
get_trait_name = event_models.Trait.get_name_by_type
|
||||
return [TraitDescription(name=t['name'],
|
||||
type=get_trait_name(t['data_type']))
|
||||
for t in pecan.request.event_storage_conn
|
||||
.get_trait_types(event_type)]
|
||||
for t in pecan.request.conn.get_trait_types(event_type)]
|
||||
|
||||
|
||||
class EventTypesController(rest.RestController):
|
||||
|
@ -268,7 +266,7 @@ class EventTypesController(rest.RestController):
|
|||
@wsme_pecan.wsexpose([six.text_type])
|
||||
def get_all(self):
|
||||
"""Get all event types."""
|
||||
return list(pecan.request.event_storage_conn.get_event_types())
|
||||
return list(pecan.request.conn.get_event_types())
|
||||
|
||||
|
||||
class EventsController(rest.RestController):
|
||||
|
@ -296,8 +294,7 @@ class EventsController(rest.RestController):
|
|||
traits=event.traits,
|
||||
raw=event.raw)
|
||||
for event in
|
||||
pecan.request.event_storage_conn.get_events(event_filter,
|
||||
pagination)]
|
||||
pecan.request.conn.get_events(event_filter, pagination)]
|
||||
|
||||
@v2_utils.requires_context
|
||||
@wsme_pecan.wsexpose(Event, wtypes.text)
|
||||
|
@ -314,7 +311,7 @@ class EventsController(rest.RestController):
|
|||
admin_proj=admin_proj,
|
||||
message_id=message_id)
|
||||
events = [event for event
|
||||
in pecan.request.event_storage_conn.get_events(event_filter)]
|
||||
in pecan.request.conn.get_events(event_filter)]
|
||||
if not events:
|
||||
raise base.EntityNotFound(_("Event"), message_id)
|
||||
|
||||
|
|
|
@ -35,11 +35,11 @@ class ConfigHook(hooks.PecanHook):
|
|||
class DBHook(hooks.PecanHook):
|
||||
|
||||
def __init__(self, conf):
|
||||
self.event_storage_connection = storage.get_connection_from_config(
|
||||
self.connection = storage.get_connection_from_config(
|
||||
conf)
|
||||
|
||||
def before(self, state):
|
||||
state.request.event_storage_conn = self.event_storage_connection
|
||||
state.request.conn = self.connection
|
||||
|
||||
|
||||
class TranslationHook(hooks.PecanHook):
|
||||
|
|
|
@ -34,9 +34,8 @@ def expirer():
|
|||
|
||||
if conf.database.event_time_to_live > 0:
|
||||
LOG.debug("Clearing expired event data")
|
||||
event_conn = storage.get_connection_from_config(conf)
|
||||
event_conn.clear_expired_event_data(
|
||||
conf.database.event_time_to_live)
|
||||
conn = storage.get_connection_from_config(conf)
|
||||
conn.clear_expired_data(conf.database.event_time_to_live)
|
||||
else:
|
||||
LOG.info(_LI("Nothing to clean, database event time to live "
|
||||
"is disabled"))
|
||||
|
|
|
@ -41,7 +41,7 @@ class DatabaseDispatcher(object):
|
|||
# NOTE(jd) The `conf' arg is the Ceilometer conf, but we don't really
|
||||
# need it here.
|
||||
conf = service.prepare_service([])
|
||||
self.event_conn = storage.get_connection_from_config(conf)
|
||||
self.conn = storage.get_connection_from_config(conf)
|
||||
|
||||
def record_events(self, events):
|
||||
if not isinstance(events, list):
|
||||
|
@ -65,4 +65,4 @@ class DatabaseDispatcher(object):
|
|||
except Exception:
|
||||
LOG.exception(_LE("Error processing event and it will be "
|
||||
"dropped: %s"), ev)
|
||||
self.event_conn.record_events(event_list)
|
||||
self.conn.record_events(event_list)
|
||||
|
|
|
@ -34,8 +34,9 @@ OPTS = [
|
|||
"in the database for (<= 0 means forever).")),
|
||||
cfg.StrOpt('event_connection',
|
||||
secret=True,
|
||||
help='The connection string used to connect to the event '
|
||||
'database. (if unset, connection is used)'),
|
||||
deprecated_for_removal=True,
|
||||
help='The connection string used to connect '
|
||||
'to the event database - rather use ${database.connection}'),
|
||||
]
|
||||
|
||||
|
||||
|
|
|
@ -122,7 +122,7 @@ class Connection(object):
|
|||
return cls.STORAGE_CAPABILITIES
|
||||
|
||||
@staticmethod
|
||||
def clear_expired_event_data(ttl):
|
||||
def clear_expired_data(ttl):
|
||||
"""Clear expired data from the backend storage system.
|
||||
|
||||
Clearing occurs according to the time-to-live.
|
||||
|
|
|
@ -23,7 +23,7 @@ class Connection(base.Connection):
|
|||
"""Log event data."""
|
||||
|
||||
@staticmethod
|
||||
def clear_expired_event_data(ttl):
|
||||
def clear_expired_data(ttl):
|
||||
"""Clear expired data from the backend storage system.
|
||||
|
||||
Clearing occurs according to the time-to-live.
|
||||
|
|
|
@ -96,7 +96,7 @@ class Connection(pymongo_base.Connection):
|
|||
# Connection will be reopened automatically if needed
|
||||
self.conn.close()
|
||||
|
||||
def clear_expired_event_data(self, ttl):
|
||||
def clear_expired_data(self, ttl):
|
||||
"""Clear expired data from the backend storage system.
|
||||
|
||||
Clearing occurs according to the time-to-live.
|
||||
|
|
|
@ -435,7 +435,7 @@ class Connection(base.Connection):
|
|||
dtype=dtype,
|
||||
value=v)
|
||||
|
||||
def clear_expired_event_data(self, ttl):
|
||||
def clear_expired_data(self, ttl):
|
||||
"""Clear expired data from the backend storage system.
|
||||
|
||||
Clearing occurs according to the time-to-live.
|
||||
|
|
|
@ -49,8 +49,7 @@ class MongoDbManager(fixtures.Fixture):
|
|||
action='ignore',
|
||||
message='.*you must provide a username and password.*')
|
||||
try:
|
||||
self.event_connection = storage.get_connection(
|
||||
self.url, self.conf)
|
||||
self.connection = storage.get_connection(self.url, self.conf)
|
||||
except storage.StorageBadVersion as e:
|
||||
raise testcase.TestSkipped(six.text_type(e))
|
||||
|
||||
|
@ -77,7 +76,7 @@ class SQLManager(fixtures.Fixture):
|
|||
|
||||
def setUp(self):
|
||||
super(SQLManager, self).setUp()
|
||||
self.event_connection = storage.get_connection(self.url, self.conf)
|
||||
self.connection = storage.get_connection(self.url, self.conf)
|
||||
|
||||
|
||||
class PgSQLManager(SQLManager):
|
||||
|
@ -101,13 +100,13 @@ class ElasticSearchManager(fixtures.Fixture):
|
|||
|
||||
def setUp(self):
|
||||
super(ElasticSearchManager, self).setUp()
|
||||
self.event_connection = storage.get_connection(
|
||||
self.connection = storage.get_connection(
|
||||
self.url, self.conf)
|
||||
# prefix each test with unique index name
|
||||
inx_uuid = uuidutils.generate_uuid(dashed=False)
|
||||
self.event_connection.index_name = 'events_%s' % inx_uuid
|
||||
self.connection.index_name = 'events_%s' % inx_uuid
|
||||
# force index on write so data is queryable right away
|
||||
self.event_connection._refresh_on_write = True
|
||||
self.connection._refresh_on_write = True
|
||||
|
||||
|
||||
class HBaseManager(fixtures.Fixture):
|
||||
|
@ -117,7 +116,7 @@ class HBaseManager(fixtures.Fixture):
|
|||
|
||||
def setUp(self):
|
||||
super(HBaseManager, self).setUp()
|
||||
self.event_connection = storage.get_connection(
|
||||
self.connection = storage.get_connection(
|
||||
self.url, self.conf)
|
||||
# Unique prefix for each test to keep data is distinguished because
|
||||
# all test data is stored in one table
|
||||
|
@ -156,7 +155,7 @@ class SQLiteManager(fixtures.Fixture):
|
|||
|
||||
def setUp(self):
|
||||
super(SQLiteManager, self).setUp()
|
||||
self.event_connection = storage.get_connection(
|
||||
self.connection = storage.get_connection(
|
||||
self.url, self.conf)
|
||||
|
||||
|
||||
|
@ -200,19 +199,19 @@ class TestBase(test_base.BaseTestCase):
|
|||
|
||||
self.useFixture(self.db_manager)
|
||||
|
||||
self.event_conn = self.db_manager.event_connection
|
||||
self.event_conn.upgrade()
|
||||
self.conn = self.db_manager.connection
|
||||
self.conn.upgrade()
|
||||
|
||||
self.useFixture(mockpatch.Patch('panko.storage.get_connection',
|
||||
side_effect=self._get_connection))
|
||||
|
||||
def tearDown(self):
|
||||
self.event_conn.clear()
|
||||
self.event_conn = None
|
||||
self.conn.clear()
|
||||
self.conn = None
|
||||
super(TestBase, self).tearDown()
|
||||
|
||||
def _get_connection(self, url, conf):
|
||||
return self.event_conn
|
||||
return self.conn
|
||||
|
||||
|
||||
def run_with(*drivers):
|
||||
|
|
|
@ -92,7 +92,7 @@ class TestBaseApiEventRBAC(v2.FunctionalTest):
|
|||
self.message_id = uuidutils.generate_uuid()
|
||||
ev = models.Event(self.message_id, 'event_type',
|
||||
datetime.datetime.now(), traits, {})
|
||||
self.event_conn.record_events([ev])
|
||||
self.conn.record_events([ev])
|
||||
|
||||
def test_get_events_without_project(self):
|
||||
headers_no_proj = {"X-Roles": "admin", "X-User-Id": "user-good"}
|
||||
|
|
|
@ -67,7 +67,7 @@ class EventTestBase(v2.FunctionalTest):
|
|||
raw={'status': {'nested': 'started'}}))
|
||||
base += 100
|
||||
self.trait_time += datetime.timedelta(days=1)
|
||||
self.event_conn.record_events(event_models)
|
||||
self.conn.record_events(event_models)
|
||||
|
||||
|
||||
class TestEventTypeAPI(EventTestBase):
|
||||
|
@ -566,7 +566,7 @@ class AclRestrictedEventTestBase(v2.FunctionalTest):
|
|||
models.Trait.TEXT_TYPE,
|
||||
self.user_id)],
|
||||
raw={}))
|
||||
self.event_conn.record_events(event_models)
|
||||
self.conn.record_events(event_models)
|
||||
|
||||
def test_non_admin_access(self):
|
||||
a_headers = {"X-Roles": "member",
|
||||
|
@ -682,7 +682,7 @@ class EventRestrictionTestBase(v2.FunctionalTest):
|
|||
traits=trait_models,
|
||||
raw={'status': {'nested': 'started'}}))
|
||||
self.trait_time += datetime.timedelta(seconds=1)
|
||||
self.event_conn.record_events(event_models)
|
||||
self.conn.record_events(event_models)
|
||||
|
||||
|
||||
class TestEventRestriction(EventRestrictionTestBase):
|
||||
|
|
|
@ -84,7 +84,6 @@ class ConfigFixture(fixture.GabbiFixture):
|
|||
db_url = urlparse.urlunparse(parsed_url)
|
||||
|
||||
conf.set_override('connection', db_url, group='database')
|
||||
conf.set_override('event_connection', '', group='database')
|
||||
|
||||
if (parsed_url[0].startswith("mysql")
|
||||
or parsed_url[0].startswith("postgresql")):
|
||||
|
|
|
@ -31,31 +31,31 @@ class IndexTest(tests_db.TestBase):
|
|||
|
||||
def test_event_ttl_index_absent(self):
|
||||
# create a fake index and check it is deleted
|
||||
self.event_conn.clear_expired_event_data(-1)
|
||||
self.conn.clear_expired_data(-1)
|
||||
self.assertNotIn("event_ttl",
|
||||
self.event_conn.db.event.index_information())
|
||||
self.conn.db.event.index_information())
|
||||
|
||||
self.event_conn.clear_expired_event_data(456789)
|
||||
self.conn.clear_expired_data(456789)
|
||||
self.assertEqual(456789,
|
||||
self.event_conn.db.event.index_information()
|
||||
self.conn.db.event.index_information()
|
||||
["event_ttl"]['expireAfterSeconds'])
|
||||
|
||||
def test_event_ttl_index_present(self):
|
||||
self.event_conn.clear_expired_event_data(456789)
|
||||
self.conn.clear_expired_data(456789)
|
||||
self.assertEqual(456789,
|
||||
self.event_conn.db.event.index_information()
|
||||
self.conn.db.event.index_information()
|
||||
["event_ttl"]['expireAfterSeconds'])
|
||||
|
||||
self.event_conn.clear_expired_event_data(-1)
|
||||
self.conn.clear_expired_data(-1)
|
||||
self.assertNotIn("event_ttl",
|
||||
self.event_conn.db.event.index_information())
|
||||
self.conn.db.event.index_information())
|
||||
|
||||
|
||||
class CapabilitiesTest(test_base.BaseTestCase):
|
||||
# Check the returned capabilities list, which is specific to each DB
|
||||
# driver
|
||||
|
||||
def test_event_capabilities(self):
|
||||
def test_capabilities(self):
|
||||
expected_capabilities = {
|
||||
'events': {'query': {'simple': True}},
|
||||
}
|
||||
|
|
|
@ -44,16 +44,16 @@ class EventTypeTest(tests_db.TestBase):
|
|||
# Not applicable to other drivers.
|
||||
|
||||
def test_event_type_exists(self):
|
||||
et1 = self.event_conn._get_or_create_event_type("foo")
|
||||
et1 = self.conn._get_or_create_event_type("foo")
|
||||
self.assertTrue(et1.id >= 0)
|
||||
et2 = self.event_conn._get_or_create_event_type("foo")
|
||||
et2 = self.conn._get_or_create_event_type("foo")
|
||||
self.assertEqual(et2.id, et1.id)
|
||||
self.assertEqual(et2.desc, et1.desc)
|
||||
|
||||
def test_event_type_unique(self):
|
||||
et1 = self.event_conn._get_or_create_event_type("foo")
|
||||
et1 = self.conn._get_or_create_event_type("foo")
|
||||
self.assertTrue(et1.id >= 0)
|
||||
et2 = self.event_conn._get_or_create_event_type("blah")
|
||||
et2 = self.conn._get_or_create_event_type("blah")
|
||||
self.assertNotEqual(et1.id, et2.id)
|
||||
self.assertNotEqual(et1.desc, et2.desc)
|
||||
# Test the method __repr__ returns a string
|
||||
|
@ -65,8 +65,8 @@ class EventTest(tests_db.TestBase):
|
|||
def _verify_data(self, trait, trait_table):
|
||||
now = datetime.datetime.utcnow()
|
||||
ev = models.Event('1', 'name', now, [trait], {})
|
||||
self.event_conn.record_events([ev])
|
||||
session = self.event_conn._engine_facade.get_session()
|
||||
self.conn.record_events([ev])
|
||||
session = self.conn._engine_facade.get_session()
|
||||
t_tables = [sql_models.TraitText, sql_models.TraitFloat,
|
||||
sql_models.TraitInt, sql_models.TraitDatetime]
|
||||
for table in t_tables:
|
||||
|
@ -102,7 +102,7 @@ class CapabilitiesTest(test_base.BaseTestCase):
|
|||
# Check the returned capabilities list, which is specific to each DB
|
||||
# driver
|
||||
|
||||
def test_event_capabilities(self):
|
||||
def test_capabilities(self):
|
||||
expected_capabilities = {
|
||||
'events': {'query': {'simple': True}},
|
||||
}
|
||||
|
|
|
@ -59,25 +59,25 @@ class EventTestBase(tests_db.TestBase):
|
|||
now = now + datetime.timedelta(hours=1)
|
||||
self.end = now
|
||||
|
||||
self.event_conn.record_events(self.models)
|
||||
self.conn.record_events(self.models)
|
||||
|
||||
|
||||
@tests_db.run_with('sqlite', 'mysql', 'pgsql')
|
||||
class EventTTLTest(EventTestBase):
|
||||
|
||||
@mock.patch.object(timeutils, 'utcnow')
|
||||
def test_clear_expired_event_data(self, mock_utcnow):
|
||||
def test_clear_expired_data(self, mock_utcnow):
|
||||
mock_utcnow.return_value = datetime.datetime(2013, 12, 31, 10, 0)
|
||||
self.event_conn.clear_expired_event_data(3600)
|
||||
self.conn.clear_expired_data(3600)
|
||||
|
||||
events = list(self.event_conn.get_events(storage.EventFilter()))
|
||||
events = list(self.conn.get_events(storage.EventFilter()))
|
||||
self.assertEqual(2, len(events))
|
||||
event_types = list(self.event_conn.get_event_types())
|
||||
event_types = list(self.conn.get_event_types())
|
||||
self.assertEqual(['Bar', 'Zoo'], event_types)
|
||||
for event_type in event_types:
|
||||
trait_types = list(self.event_conn.get_trait_types(event_type))
|
||||
trait_types = list(self.conn.get_trait_types(event_type))
|
||||
self.assertEqual(4, len(trait_types))
|
||||
traits = list(self.event_conn.get_traits(event_type))
|
||||
traits = list(self.conn.get_traits(event_type))
|
||||
self.assertEqual(4, len(traits))
|
||||
|
||||
|
||||
|
@ -88,8 +88,8 @@ class EventTest(EventTestBase):
|
|||
m = [models.Event("1", "Foo", now, None, {}),
|
||||
models.Event("1", "Zoo", now, [], {})]
|
||||
with mock.patch('%s.LOG' %
|
||||
self.event_conn.record_events.__module__) as log:
|
||||
self.event_conn.record_events(m)
|
||||
self.conn.record_events.__module__) as log:
|
||||
self.conn.record_events(m)
|
||||
self.assertEqual(1, log.info.call_count)
|
||||
|
||||
def test_bad_event(self):
|
||||
|
@ -98,8 +98,8 @@ class EventTest(EventTestBase):
|
|||
del(broken_event.__dict__['raw'])
|
||||
m = [broken_event, broken_event]
|
||||
with mock.patch('%s.LOG' %
|
||||
self.event_conn.record_events.__module__) as log:
|
||||
self.assertRaises(AttributeError, self.event_conn.record_events, m)
|
||||
self.conn.record_events.__module__) as log:
|
||||
self.assertRaises(AttributeError, self.conn.record_events, m)
|
||||
# ensure that record_events does not break on first error but
|
||||
# delays exception and tries to record each event.
|
||||
self.assertEqual(2, log.exception.call_count)
|
||||
|
@ -109,7 +109,7 @@ class GetEventTest(EventTestBase):
|
|||
|
||||
def test_generated_is_datetime(self):
|
||||
event_filter = storage.EventFilter(self.start, self.end)
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(6, len(events))
|
||||
for i, event in enumerate(events):
|
||||
self.assertIsInstance(event.generated, datetime.datetime)
|
||||
|
@ -123,7 +123,7 @@ class GetEventTest(EventTestBase):
|
|||
|
||||
def test_simple_get(self):
|
||||
event_filter = storage.EventFilter(self.start, self.end)
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(6, len(events))
|
||||
start_time = None
|
||||
for i, type in enumerate(['Foo', 'Bar', 'Zoo']):
|
||||
|
@ -152,7 +152,7 @@ class GetEventTest(EventTestBase):
|
|||
}
|
||||
|
||||
event_filter = storage.EventFilter(self.start, self.end, "Bar")
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(2, len(events))
|
||||
self.assertEqual("Bar", events[0].event_type)
|
||||
self.assertEqual("Bar", events[1].event_type)
|
||||
|
@ -174,7 +174,7 @@ class GetEventTest(EventTestBase):
|
|||
trait_filters = [{'key': 'trait_B', 'integer': 101}]
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
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))
|
||||
|
@ -184,38 +184,38 @@ class GetEventTest(EventTestBase):
|
|||
'op': 'eq'}]
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(4, len(events))
|
||||
self.assertEqual("Foo", events[2].event_type)
|
||||
|
||||
|
@ -223,38 +223,38 @@ class GetEventTest(EventTestBase):
|
|||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(5, len(events))
|
||||
self.assertEqual("Foo", events[2].event_type)
|
||||
|
||||
|
@ -262,38 +262,38 @@ class GetEventTest(EventTestBase):
|
|||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(3, len(events))
|
||||
self.assertEqual("Zoo", events[2].event_type)
|
||||
|
||||
|
@ -303,38 +303,38 @@ class GetEventTest(EventTestBase):
|
|||
'op': 'eq'}]
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
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.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(4, len(events))
|
||||
self.assertEqual("Bar", events[2].event_type)
|
||||
|
||||
|
@ -344,7 +344,7 @@ class GetEventTest(EventTestBase):
|
|||
{'key': 'trait_C', 'float': 0.123456}]
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
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))
|
||||
|
@ -354,12 +354,12 @@ class GetEventTest(EventTestBase):
|
|||
{'key': 'trait_A', 'string': 'my_Zoo_text'}]
|
||||
event_filter = storage.EventFilter(self.start, self.end,
|
||||
traits_filter=trait_filters)
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(0, len(events))
|
||||
|
||||
def test_get_event_types(self):
|
||||
event_types = [e for e in
|
||||
self.event_conn.get_event_types()]
|
||||
self.conn.get_event_types()]
|
||||
|
||||
self.assertEqual(3, len(event_types))
|
||||
self.assertIn("Bar", event_types)
|
||||
|
@ -368,7 +368,7 @@ class GetEventTest(EventTestBase):
|
|||
|
||||
def test_get_trait_types(self):
|
||||
trait_types = [tt for tt in
|
||||
self.event_conn.get_trait_types("Foo")]
|
||||
self.conn.get_trait_types("Foo")]
|
||||
self.assertEqual(4, len(trait_types))
|
||||
trait_type_names = map(lambda x: x['name'], trait_types)
|
||||
self.assertIn("trait_A", trait_type_names)
|
||||
|
@ -378,11 +378,11 @@ class GetEventTest(EventTestBase):
|
|||
|
||||
def test_get_trait_types_unknown_event(self):
|
||||
trait_types = [tt for tt in
|
||||
self.event_conn.get_trait_types("Moo")]
|
||||
self.conn.get_trait_types("Moo")]
|
||||
self.assertEqual(0, len(trait_types))
|
||||
|
||||
def test_get_traits(self):
|
||||
traits = self.event_conn.get_traits("Bar")
|
||||
traits = self.conn.get_traits("Bar")
|
||||
# format results in a way that makes them easier to work with
|
||||
trait_dict = {}
|
||||
for trait in traits:
|
||||
|
@ -399,7 +399,7 @@ class GetEventTest(EventTestBase):
|
|||
trait_dict["trait_D"])
|
||||
|
||||
def test_get_all_traits(self):
|
||||
traits = self.event_conn.get_traits("Foo")
|
||||
traits = self.conn.get_traits("Foo")
|
||||
traits = sorted([t for t in traits], key=operator.attrgetter('dtype'))
|
||||
self.assertEqual(8, len(traits))
|
||||
trait = traits[0]
|
||||
|
@ -409,10 +409,10 @@ class GetEventTest(EventTestBase):
|
|||
def test_simple_get_event_no_traits(self):
|
||||
new_events = [models.Event("id_notraits", "NoTraits",
|
||||
self.start, [], {})]
|
||||
self.event_conn.record_events(new_events)
|
||||
self.conn.record_events(new_events)
|
||||
event_filter = storage.EventFilter(
|
||||
self.start, self.end, "NoTraits")
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(1, len(events))
|
||||
self.assertEqual("id_notraits", events[0].message_id)
|
||||
self.assertEqual("NoTraits", events[0].event_type)
|
||||
|
@ -420,23 +420,23 @@ class GetEventTest(EventTestBase):
|
|||
|
||||
def test_simple_get_no_filters(self):
|
||||
event_filter = storage.EventFilter(None, None, None)
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(6, len(events))
|
||||
|
||||
def test_get_by_message_id(self):
|
||||
new_events = [models.Event("id_testid", "MessageIDTest",
|
||||
self.start, [], {})]
|
||||
|
||||
self.event_conn.record_events(new_events)
|
||||
self.conn.record_events(new_events)
|
||||
event_filter = storage.EventFilter(message_id="id_testid")
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertEqual(1, len(events))
|
||||
event = events[0]
|
||||
self.assertEqual("id_testid", event.message_id)
|
||||
|
||||
def test_simple_get_raw(self):
|
||||
event_filter = storage.EventFilter()
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
self.assertTrue(events)
|
||||
self.assertEqual({'status': {'nested': 'started'}}, events[0].raw)
|
||||
|
||||
|
@ -447,9 +447,9 @@ class GetEventTest(EventTestBase):
|
|||
models.Trait('int', models.Trait.INT_TYPE, 0),
|
||||
models.Trait('float', models.Trait.FLOAT_TYPE, 0.0)],
|
||||
{})]
|
||||
self.event_conn.record_events(new_events)
|
||||
self.conn.record_events(new_events)
|
||||
event_filter = storage.EventFilter(message_id="id_testid")
|
||||
events = [event for event in self.event_conn.get_events(event_filter)]
|
||||
events = [event for event in self.conn.get_events(event_filter)]
|
||||
options = [(models.Trait.TEXT_TYPE, ''),
|
||||
(models.Trait.INT_TYPE, 0.0),
|
||||
(models.Trait.FLOAT_TYPE, 0.0)]
|
||||
|
|
|
@ -33,11 +33,11 @@ class TestDispatcherDB(base.BaseTestCase):
|
|||
f.return_value = self.CONF
|
||||
self.dispatcher = database.DatabaseDispatcher(None)
|
||||
|
||||
def test_event_conn(self):
|
||||
def test_conn(self):
|
||||
event = models.Event(uuidutils.generate_uuid(), 'test',
|
||||
datetime.datetime(2012, 7, 2, 13, 53, 40),
|
||||
[], {}).serialize()
|
||||
with mock.patch.object(self.dispatcher.event_conn,
|
||||
with mock.patch.object(self.dispatcher.conn,
|
||||
'record_events') as record_events:
|
||||
self.dispatcher.record_events(event)
|
||||
self.assertEqual(1, len(record_events.call_args_list[0][0][0]))
|
||||
|
|
Loading…
Reference in New Issue