def test_timestamp_column_index_creation(self): """The ``timestamp`` column is indexed by default.""" table_name = event_to_table_name(self.event) t = eventlogging.jrm.declare_table(self.meta, TEST_SCHEMA_SCID, table_name) cols = {column.name for index in t.indexes for column in index.columns} self.assertIn('timestamp', cols)
def test_uuid_v1_type_index_creation(self): """A ``uuid v1 pattern`` column is indexed by default.""" table_name = event_to_table_name(self.event_with_meta) t = eventlogging.jrm.declare_table(self.meta, TEST_META_SCHEMA_SCID, table_name, should_encapsulate=False) cols = {column.name for index in t.indexes for column in index.columns} self.assertIn('meta_id', cols)
def test_column_names(self): """Generated tables contain columns for each relevant field.""" table_name = event_to_table_name(self.event) t = eventlogging.jrm.declare_table(self.meta, TEST_SCHEMA_SCID, table_name) # The columns we expect to see are.. cols = set(eventlogging.utils.flatten(self.event)) # all properties cols -= set(eventlogging.jrm.NO_DB_PROPERTIES) # unless excluded cols |= {'id', 'uuid'} # plus id, uuid self.assertSetEqual(set(t.columns.keys()), cols)
def test_meta_id_unique_index_creation(self): """A field named ``id`` (e.g. meta.id) should have a unique index.""" table_name = event_to_table_name(self.event_with_meta) t = eventlogging.jrm.declare_table(self.meta, TEST_META_SCHEMA_SCID, table_name, should_encapsulate=False) cols = { column.name for index in t.indexes for column in index.columns if index.unique } self.assertIn('meta_id', cols)
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_name = event_to_table_name(self.event) 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) # the number of records in table must be the list size rows = results.fetchall() self.assertEqual(len(rows), 2)
def test_encoding(self): """Timestamps, unicode strings, and arrays are correctly encoded.""" eventlogging.jrm.store_sql_events(self.meta, TEST_SCHEMA_SCID, [self.event]) table_name = event_to_table_name(self.event) table = eventlogging.jrm.get_table(self.meta, TEST_SCHEMA_SCID, table_name) row = table.select().execute().fetchone() self.assertEqual(row['event_value'], '☆ 彡') self.assertEqual(row['event_list'], ['a', '☆ 彡']) self.assertEqual(row['uuid'], 'babb66f34a0a5de3be0c6513088be33e') self.assertEqual(row['timestamp'], datetime.datetime(2013, 1, 21, 18, 10, 34))
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_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_name = event_to_table_name(self.event) 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) # the number of records in table must be the list size 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 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_name = event_to_table_name(self.event) table = self.meta.tables[table_name] 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) table_name = event_to_table_name(self.event) # Although ``TestSchema_123`` exists in the database, SQLAlchemy # is not yet aware of its existence: self.assertNotIn(table_name, 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(table_name, self.meta.tables)