def setUp(self): """ Create an engine for a SQLlite in-memory DB, and create a :class:`ContextManagedSession` to test on """ TestCaseWithAppContext.setUp(self) self.engine = create_engine('sqlite:///') self.base_session = ContextManagedSession(bind=self.engine)
def setUp(self): TestTokens.setUp(self) self.session = mock.MagicMock(spec=ContextManagedSession()) self.token = mock.MagicMock() self.endpoint.make_400_error_response = mock.MagicMock() self.error_message = 'This is an error'
Contains integration tests for :mod:`auth`, performing authentication without stubbing out any functionality. """ import json from base64 import b64encode from uuid import uuid4 import omicron_server.auth as auth from omicron_server.database import ContextManagedSession from omicron_server.models import User from omicron_server.config import default_config as conf from tests.integration import TestCaseWithDatabase from omicron_server import app from copy import deepcopy __author__ = 'Michal Kononenko' database_session = ContextManagedSession(bind=conf.DATABASE_ENGINE) class TestAuth(TestCaseWithDatabase): """ Base class for testing :mod:`auth` """ @classmethod def setUpClass(cls): """ Set up the test database, and put the server into a request context requiring authentication. """ TestCaseWithDatabase.setUpClass() cls.username = '******' cls.password = '******'
class TestContextManagedSession(TestCaseWithAppContext): """ Base test case for :class:`database.sessions.ContextManagedSession` """ def setUp(self): """ Create an engine for a SQLlite in-memory DB, and create a :class:`ContextManagedSession` to test on """ TestCaseWithAppContext.setUp(self) self.engine = create_engine('sqlite:///') self.base_session = ContextManagedSession(bind=self.engine) def test_context_managed_session_enter(self): """ Test that entering a :class:`ContextManagedSession` creates a new object of the same type as :class:`ContextManagedSession`, that the namespaces of the new session is equal to the master session, but that they are different objects, (i.e. reside at different memory addresses) """ with self.base_session() as session: self.assertNotEqual(self.base_session, session) self.assertEqual(self.base_session.__dict__, session.__dict__) self.assertIsInstance(session, self.base_session.__class__) def test_exit_no_error(self): """ Tests that upon exiting the context manager, :meth:`sqlalchemy.orm.Session.commit` is called. """ commit = mock.MagicMock() rollback = mock.MagicMock() with self.base_session() as session: session.commit = commit session.rollback = rollback self.assertFalse(rollback.called) self.assertEqual(commit.call_args, mock.call()) def test_exit_with_error(self): """ Tests that if an exception is thrown inside the context manager, the rollback method is called, and the exception is re-thrown """ error_to_raise = Exception('test_error') commit = mock.MagicMock() rollback = mock.MagicMock() with self.assertRaises(error_to_raise.__class__): with self.base_session() as session: session.commit = commit session.rollback = rollback raise Exception('test_error') self.assertFalse(commit.called) self.assertEqual(rollback.call_args, mock.call()) def test_exit_commit_error(self): """ Tests that :meth:`sqlalchemy.orm.Session.rollback` is called if there is an error on execution of :meth:`sqlalchemy.orm.Session.commit`. """ error_to_raise = Exception('test_error') commit = mock.MagicMock(side_effect=error_to_raise) rollback = mock.MagicMock() with self.assertRaises(error_to_raise.__class__): with self.base_session() as session: session.commit = commit session.rollback = rollback self.assertTrue(commit.called) self.assertTrue(rollback.called) def test_repr(self): """ Tests :meth:`database.sessions.ContextManagedSession.__repr__` """ repr_string = '%s(bind=%s, expire_on_commit=%s)' % \ (self.base_session.__class__.__name__, self.base_session.bind, self.base_session.expire_on_commit) self.assertEqual(repr_string, self.base_session.__repr__()) def test_decorator_callable(self): """ Tests that :class:`database.sessions.ContextManagedSession` is able to decorate a function. """ @self.base_session() def _test_decorator(created_session): return created_session session = _test_decorator() self.assertIsInstance(session, ContextManagedSession) self.assertNotEqual(session, self.base_session) def test_context_manager(self): """ Test that the session is able to work as a context manager """ with self.base_session() as session: pass self.assertIsInstance(session, ContextManagedSession) self.assertNotEqual(session, self.base_session)