def test_happy_case_insert_more_than_one_event(self): """Insert more than one event on database using batch_write""" another_event = next(self.event_generator) events_batch = [(TEST_SCHEMA_SCID, [another_event, self.event])] eventlogging.store_sql_events(self.meta, events_batch) table = self.meta.tables['TestSchema_123'] # is the table on the db and does it have the right data? s = sqlalchemy.sql.select([table]) results = self.engine.execute(s) # the number of records in table must be the list size rows = results.fetchall() self.assertEqual(len(rows), 2)
def test_happy_case_insert_more_than_one_event(self): """Insert more than one event on database using batch_write""" another_event = next(self.event_generator) event_list = [another_event, self.event] eventlogging.store_sql_events( self.meta, TEST_SCHEMA_SCID, event_list) table = self.meta.tables['TestSchema_123'] # is the table on the db and does it have the right data? s = sqlalchemy.sql.select([table]) results = self.engine.execute(s) # the number of records in table must be the list size rows = results.fetchall() self.assertEqual(len(rows), 2)
def test_insert_events_with_different_set_of_optional_fields(self): """Events belonging to the same schema with a different set of optional fields are inserted correctly""" another_event = next(self.event_generator) # ensure both events get inserted? event_list = [another_event, self.event] eventlogging.store_sql_events(self.meta, TEST_SCHEMA_SCID, event_list) table = self.meta.tables['TestSchema_123'] # is the table on the db and does it have the right data? s = sqlalchemy.sql.select([table]) results = self.engine.execute(s) # the number of records in table must be the list size rows = results.fetchall() self.assertEqual(len(rows), 2)
def test_lazy_table_creation(self): """If an attempt is made to store an event for which no table exists, the schema is automatically retrieved and a suitable table generated.""" events_batch = [(TEST_SCHEMA_SCID, [self.event])] eventlogging.store_sql_events(self.meta, events_batch) self.assertIn('TestSchema_123', self.meta.tables) table = self.meta.tables['TestSchema_123'] # is the table on the db and does it have the right data? s = sqlalchemy.sql.select([table]) results = self.engine.execute(s) row = results.fetchone() # see columns with print table.c self.assertEqual(row['clientIp'], self.event['clientIp'])
def test_insert_events_with_different_set_of_optional_fields(self): """Events belonging to the same schema with a different set of optional fields are inserted correctly""" another_event = next(self.event_generator) # ensure both events get inserted? events_batch = [(TEST_SCHEMA_SCID, [another_event, self.event])] eventlogging.store_sql_events(self.meta, events_batch) table = self.meta.tables['TestSchema_123'] # is the table on the db and does it have the right data? s = sqlalchemy.sql.select([table]) results = self.engine.execute(s) # the number of records in table must be the list size rows = results.fetchall() self.assertEqual(len(rows), 2)
def test_lazy_table_creation_with_meta(self): """If an attempt is made to store an event with meta (not encapsulated) for which no table exists, the schema is automatically retrieved and a suitable table generated.""" eventlogging.store_sql_events( self.meta, TEST_META_SCHEMA_SCID, [self.event_with_meta]) table_name = TABLE_NAME_FORMAT % TEST_META_SCHEMA_SCID self.assertIn(table_name, self.meta.tables) table = self.meta.tables[table_name] # is the table on the db and does it have the right data? s = sqlalchemy.sql.select([table]) results = self.engine.execute(s) row = results.fetchone() # see columns with print table.c self.assertEqual(row['meta_id'], self.event_with_meta.id())
def test_lazy_table_creation_with_meta(self): """If an attempt is made to store an event with meta (not encapsulated) for which no table exists, the schema is automatically retrieved and a suitable table generated.""" eventlogging.store_sql_events(self.meta, TEST_META_SCHEMA_SCID, [self.event_with_meta]) table_name = event_to_table_name(self.event_with_meta) self.assertIn(table_name, self.meta.tables) table = self.meta.tables[table_name] # is the table on the db and does it have the right data? s = sqlalchemy.sql.select([table]) results = self.engine.execute(s) row = results.fetchone() # see columns with print table.c self.assertEqual(row['meta_id'], self.event_with_meta.id())
def test_insertion_of_multiple_events_with_a_duplicate(self): """"If an insert with multiple events includes a duplicate and replace=True we have to insert the other items. """ # insert event eventlogging.jrm.store_sql_events( self.meta, TEST_SCHEMA_SCID, [self.event]) # now try to insert list of events in which this event is included another_event = next(self.event_generator) event_list = [another_event, self.event] eventlogging.store_sql_events( self.meta, TEST_SCHEMA_SCID, event_list, replace=True) # we should still have to insert the other record though table = self.meta.tables['TestSchema_123'] s = sqlalchemy.sql.select([table]) results = self.engine.execute(s) rows = results.fetchall() self.assertEqual(len(rows), 2)
def test_insertion_of_multiple_events_with_a_duplicate(self): """"If an insert with multiple events includes a duplicate and replace=True we have to insert the other items. """ # insert event events_batch = [(TEST_SCHEMA_SCID, [self.event])] eventlogging.jrm.store_sql_events(self.meta, events_batch) # now try to insert list of events in which this event is included another_event = next(self.event_generator) event_list = [another_event, self.event] events_batch = [(TEST_SCHEMA_SCID, event_list)] eventlogging.store_sql_events(self.meta, events_batch, replace=True) # we should still have to insert the other record though table = self.meta.tables['TestSchema_123'] s = sqlalchemy.sql.select([table]) results = self.engine.execute(s) rows = results.fetchall() self.assertEqual(len(rows), 2)
def test_reflection(self): """Tables which exist in the database but not in the MetaData cache are correctly reflected.""" eventlogging.store_sql_events( self.meta, TEST_SCHEMA_SCID, [self.event]) # Tell Python to forget everything it knows about this database # by purging ``MetaData``. The actual data in the database is # not altered by this operation. del self.meta self.meta = sqlalchemy.MetaData(bind=self.engine) # Although ``TestSchema_123`` exists in the database, SQLAlchemy # is not yet aware of its existence: self.assertNotIn('TestSchema_123', self.meta.tables) # The ``checkfirst`` arg to :func:`sqlalchemy.Table.create` # will ensure that we don't attempt to CREATE TABLE on the # already-existing table: eventlogging.store_sql_events( self.meta, TEST_SCHEMA_SCID, [self.event], True) self.assertIn('TestSchema_123', self.meta.tables)
def test_reflection(self): """Tables which exist in the database but not in the MetaData cache are correctly reflected.""" events_batch = [(TEST_SCHEMA_SCID, [self.event])] eventlogging.store_sql_events(self.meta, events_batch) # Tell Python to forget everything it knows about this database # by purging ``MetaData``. The actual data in the database is # not altered by this operation. del self.meta self.meta = sqlalchemy.MetaData(bind=self.engine) # Although ``TestSchema_123`` exists in the database, SQLAlchemy # is not yet aware of its existence: self.assertNotIn('TestSchema_123', self.meta.tables) # The ``checkfirst`` arg to :func:`sqlalchemy.Table.create` # will ensure that we don't attempt to CREATE TABLE on the # already-existing table: events_batch = [(TEST_SCHEMA_SCID, [self.event])] eventlogging.store_sql_events(self.meta, events_batch, True) self.assertIn('TestSchema_123', self.meta.tables)
def test_event_list_is_empty(self): """An empty event queue is handled well No exception is raised""" event_list = [] eventlogging.store_sql_events(self.meta, TEST_SCHEMA_SCID, event_list)
def test_event_queue_is_empty(self): """An empty event queue is handled well No exception is raised""" event_list = [] eventlogging.store_sql_events(self.meta, event_list)