class TestBackendSqlite(TestBackend):
def setUp(self):
self.filename = get_temporary_filename()
self.backend = SqliteBackend(self.filename)
self.backend.setup()
def tearDown(self):
os.remove(self.filename)
def test_setup(self):
""" Test that setup() creates a new table with the correct columns. """
expected_columns = [
(u"uuid", u"", 1),
(u"timestamp", u"FLOAT", 0),
(u"session", u"PICKLE", 0)
]
# Verify that setup created the correct tables
c = self.backend.conn.cursor()
c.execute("PRAGMA table_info(sessions);")
actual_columns = [
(name, type, pk)
for (cid, name, type, notnull, dflt_value, pk) in c.fetchall()]
self.assertEqual(expected_columns, actual_columns)
def test_duplicate_setup(self):
""" Test that running setup() twice (duplicate tables) won't fail. """
self.backend.setup()
def test_add_session(self):
""" Test that adding a session inserts it into the database. """
mock_session = create_mock_session()
self.backend.add(mock_session)
query = "SELECT uuid, timestamp, session FROM sessions WHERE uuid = ?;"
params = (mock_session.uuid,)
c = self.backend.conn.cursor()
c.execute(query, params)
actual_uuid, actual_timestamp, actual_session = c.fetchone()
# Assure the meta columns are equal
self.assertEquals(mock_session.uuid, actual_uuid)
self.assertEquals(SPECIFIC_DATE_EPOCH, actual_timestamp)
# Also insure that the session we put in is intact!
self.assertSessionsEqual(mock_session, actual_session)
def test_delete(self):
""" Test that removing an added session removes it from the DB. """
mock_session = create_mock_session()
self.backend.add(mock_session)
self.backend.delete(mock_session.uuid)
query = "SELECT * FROM sessions WHERE uuid = ?;"
params = (mock_session.uuid,)
# Verify that no rows are matched
c = self.backend.conn.cursor()
c.execute(query, params)
self.assertEquals(c.fetchone(), None)
def test_delete_all(self):
""" Test that deleting all session removes them all from the DB """
# Add a few new session profiles
for i in range(1, 5):
self.backend.add(create_mock_session())
# TODO Check to make sure rows were added?
# Then delete them all.
self.backend.delete_all()
query = "SELECT * FROM sessions;"
# Verify that no rows are matched
c = self.backend.conn.cursor()
c.execute(query)
self.assertEquals(c.fetchone(), None)
def test_get(self):
""" Test that a session can be received using get(). """
mock_session = create_mock_session()
self.backend.add(mock_session)
actual_session = self.backend.get(mock_session.uuid)
self.assertSessionsEqual(mock_session, actual_session)
def test_get_no_results(self):
""" Test that when no sessions are available, get returns None """
actual_session = self.backend.get("not a real uuid")
self.assertEqual(None, actual_session)
def test_get_all(self):
""" Test that all sessions are retrieved when using get_all() """
expected_sessions = {}
for i in range(1, 5):
mock_session = create_mock_session()
self.backend.add(mock_session)
expected_sessions[mock_session.uuid] = mock_session
actual_sessions = self.backend.get_all()
for (actual_uuid, actual_session) in actual_sessions.items():
expected_session = expected_sessions.get(actual_uuid)
self.assertTrue(expected_session != None,
"UUID `%s' not found in results." % actual_uuid)
self.assertSessionsEqual(actual_session, expected_session)
def test_get_all_no_results(self):
""" Test that an empty dict is returned when no sessions exist. """
actual_sessions = self.backend.get_all()
self.assertFalse(len(actual_sessions))
def setUp(self):
self.filename = get_temporary_filename()
self.backend = SqliteBackend(self.filename)
self.backend.setup()
