class TestAlchemyHandler(unittest.TestCase):
def setUp(self):
self.alchemist = AlchemyHandler()
def test_constructor_1(self):
self.assertEqual(self.alchemist._database, None)
self.assertEqual(self.alchemist._username, None)
self.assertEqual(self.alchemist._password, None)
def test_constructor_2(self):
self.assertEqual(self.alchemist._engine, None)
self.assertEqual(self.alchemist.metadata, None)
self.assertEqual(self.alchemist.graph, None)
self.assertEqual(self.alchemist.session, None)
def test_constructor_3(self):
self.assertFalse(self.alchemist.connected)
self.assertFalse(self.alchemist.has_database)
self.assertFalse(self.alchemist.has_credentials)
def test_database_1(self):
self.alchemist.database = "Test"
self.assertTrue(self.alchemist.has_database)
self.assertFalse(self.alchemist.connected_database)
def test_username_1(self):
self.alchemist.username = "******"
self.assertFalse(self.alchemist.has_credentials)
self.assertFalse(self.alchemist.connected)
def test_username_2(self):
self.alchemist.password = "******"
self.alchemist.username = "******"
self.assertTrue(self.alchemist.has_credentials)
self.assertFalse(self.alchemist.connected)
def test_password_1(self):
self.alchemist.password ="******"
self.assertFalse(self.alchemist.has_credentials)
self.assertFalse(self.alchemist.connected)
def test_password_2(self):
self.alchemist.username = "******"
self.alchemist.password = "******"
self.assertTrue(self.alchemist.has_credentials)
self.assertFalse(self.alchemist.connected)
def test_engine_1(self):
self.alchemist.connected = True
self.alchemist.engine = None
self.assertFalse(self.alchemist.connected)
def test_engine_2(self):
with self.assertRaises(TypeError):
self.alchemist.engine = "Test"
@patch("pdm_utils.classes.alchemyhandler.input")
def test_ask_database_1(self, Input):
self.alchemist.ask_database()
Input.assert_called()
@patch("pdm_utils.classes.alchemyhandler.input")
def test_ask_database_2(self, Input):
self.alchemist.has_database = False
self.alchemist.connected = True
self.alchemist.ask_database()
self.assertTrue(self.alchemist.has_database)
self.assertFalse(self.alchemist.connected)
@patch("pdm_utils.classes.alchemyhandler.getpass")
def test_ask_credentials_1(self, GetPass):
self.alchemist.ask_credentials()
GetPass.assert_called()
@patch("pdm_utils.classes.alchemyhandler.getpass")
def test_ask_credentials_2(self, GetPass):
self.alchemist.has_credentials = False
self.alchemist.connected = True
self.alchemist.ask_credentials()
self.assertTrue(self.alchemist.has_credentials)
self.assertFalse(self.alchemist.connected)
def test_validate_database_1(self):
MockEngine = Mock()
MockProxy = Mock()
MockEngine.execute.return_value = MockProxy
MockProxy.fetchall.return_value = [("test_db",),
("Actinobacteriophage",)]
self.alchemist.database = "test_db"
self.alchemist._engine = MockEngine
self.alchemist.validate_database()
MockEngine.execute.assert_called_with("SHOW DATABASES")
MockProxy.fetchall.assert_called()
def test_validate_database_2(self):
with self.assertRaises(IndexError):
self.alchemist.validate_database()
def test_validate_database_3(self):
MockEngine = Mock()
MockProxy = Mock()
MockEngine.execute.return_value = MockProxy
MockProxy.fetchall.return_value = []
self.alchemist.database = "test db"
self.alchemist._engine = MockEngine
with self.assertRaises(ValueError):
self.alchemist.validate_database()
MockEngine.execute.assert_called_with("SHOW DATABASES")
MockProxy.fetchall.assert_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.sqlalchemy.create_engine")
def test_build_engine_1(self, CreateEngine, AskCredentials):
self.alchemist.engine = None
self.alchemist.connected = True
self.alchemist.build_engine()
CreateEngine.assert_not_called()
AskCredentials.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.sqlalchemy.create_engine")
def test_build_engine_2(self, CreateEngine, AskCredentials):
self.alchemist.username = "******"
self.alchemist.password = "******"
self.alchemist.has_credentials = False
self.alchemist.build_engine()
AskCredentials.assert_called()
login_string = "mysql+pymysql://user:pass@localhost/"
CreateEngine.assert_called_with(login_string)
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.validate_database")
@patch("pdm_utils.classes.alchemyhandler.sqlalchemy.create_engine")
def test_build_engine_3(self, CreateEngine, ValidateDatabase):
self.alchemist.username = "******"
self.alchemist.password = "******"
self.alchemist.database = "database"
self.alchemist.build_engine()
login_string = "mysql+pymysql://user:pass@localhost/"
db_login_string = "mysql+pymysql://user:pass@localhost/database"
CreateEngine.assert_any_call(login_string)
CreateEngine.assert_any_call(db_login_string)
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.sqlalchemy.create_engine")
def test_build_engine_4(self, CreateEngine, AskCredentials):
self.alchemist.has_credentials = True
self.alchemist.connected = False
self.alchemist.metadata = "Test"
self.alchemist.graph = "Test"
self.alchemist.build_engine()
self.alchemist.connected = True
self.assertEqual(self.alchemist.metadata, None)
self.assertEqual(self.alchemist.graph, None)
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
def test_connect_1(self, BuildEngine, AskDatabase, AskCredentials):
self.alchemist.has_credentials = True
self.alchemist.connect()
BuildEngine.assert_called()
AskDatabase.assert_not_called()
AskCredentials.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
def test_connect_2(self, BuildEngine, AskDatabase, AskCredentials):
self.alchemist.connect(ask_database=True)
BuildEngine.assert_called()
AskDatabase.assert_called()
AskCredentials.assert_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
def test_connect_3(self, BuildEngine, AskDatabase, AskCredentials):
self.alchemist.connected = False
BuildEngine.side_effect = OperationalError("", "", "")
with self.assertRaises(ValueError):
self.alchemist.connect()
BuildEngine.assert_called()
AskDatabase.assert_not_called()
AskCredentials.assert_called()
def mock_build_engine(self, mock_engine):
self.alchemist._engine = mock_engine
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
def test_execute_1(self, BuildEngine):
MockEngine = Mock()
MockProxy = Mock()
MockEngine.execute.return_value = MockProxy
MockProxy.fetchall.return_value = []
self.alchemist._engine = MockEngine
self.alchemist.execute("Executable")
MockEngine.execute.assert_called_with("Executable")
MockProxy.fetchall.assert_called()
BuildEngine.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
def test_scalar_1(self, BuildEngine):
MockEngine = Mock()
MockProxy = Mock()
MockEngine.execute.return_value = MockProxy
MockProxy.scalar.return_value = "Scalar"
self.alchemist._engine = MockEngine
self.alchemist.scalar("Executable")
MockEngine.execute.assert_called_with("Executable")
MockProxy.scalar.assert_called()
BuildEngine.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.MetaData")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
def test_build_metadata_1(self, AskDatabase, BuildEngine, MetaData):
self.alchemist.has_database = False
self.alchemist.connected = False
self.alchemist.build_metadata()
AskDatabase.assert_called()
BuildEngine.assert_called()
MetaData.assert_called()
@patch("pdm_utils.classes.alchemyhandler.MetaData")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
def test_build_metadata_2(self, AskDatabase, BuildEngine, MetaData):
self.alchemist.has_database = True
self.alchemist.connected = True
self.alchemist.build_metadata()
AskDatabase.assert_not_called()
BuildEngine.assert_not_called()
MetaData.assert_called()
@patch("pdm_utils.classes.alchemyhandler.parsing.translate_table")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_translate_table_1(self, BuildMetadata, TranslateTable):
self.alchemist.metadata = "Metadata"
self.alchemist.translate_table("Test")
TranslateTable.assert_called_with("Metadata", "Test")
BuildMetadata.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.parsing.translate_table")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_translate_table_2(self, BuildMetadata, TranslateTable):
self.alchemist.metadata = None
self.alchemist.translate_table("Test")
TranslateTable.assert_called_with(None, "Test")
BuildMetadata.assert_called()
@patch("pdm_utils.classes.alchemyhandler.parsing.translate_column")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_translate_column_1(self, BuildMetadata, TranslateColumn):
self.alchemist.metadata = "Metadata"
self.alchemist.translate_column("Test")
TranslateColumn.assert_called_with("Metadata", "Test")
BuildMetadata.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.parsing.translate_column")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_translate_column_2(self, BuildMetadata, TranslateColumn):
self.alchemist.metadata = None
self.alchemist.translate_column("Test")
TranslateColumn.assert_called_with(None, "Test")
BuildMetadata.assert_called()
@patch("pdm_utils.classes.alchemyhandler.querying.get_table")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_get_table_1(self, BuildMetadata, GetTable):
self.alchemist.metadata = "Metadata"
self.alchemist.get_table("Test")
GetTable.assert_called_with("Metadata", "Test")
BuildMetadata.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.querying.get_table")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_get_table_2(self, BuildMetadata, GetTable):
self.alchemist.metadata = None
self.alchemist.get_table("Test")
GetTable.assert_called_with(None, "Test")
BuildMetadata.assert_called()
@patch("pdm_utils.classes.alchemyhandler.querying.get_column")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_get_column_1(self, BuildMetadata, GetColumn):
self.alchemist.metadata = "Metadata"
self.alchemist.get_column("Test")
GetColumn.assert_called_with("Metadata", "Test")
BuildMetadata.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.querying.get_column")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_get_column_2(self, BuildMetadata, GetColumn):
self.alchemist.metadata = None
self.alchemist.get_column("Test")
GetColumn.assert_called_with(None, "Test")
BuildMetadata.assert_called()
@patch("pdm_utils.classes.alchemyhandler.querying.build_graph")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_build_graph_1(self, BuildMetadata, BuildGraph):
BuildGraph.return_value = "Graph"
self.alchemist.metadata = "Metadata"
self.alchemist.build_graph()
BuildMetadata.assert_not_called()
BuildGraph.assert_called_with("Metadata")
self.assertEqual(self.alchemist.graph, "Graph")
@patch("pdm_utils.classes.alchemyhandler.querying.build_graph")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_build_graph_2(self, BuildMetadata, BuildGraph):
BuildGraph.return_value = "Graph"
self.alchemist.metadata = None
self.alchemist.build_graph()
BuildMetadata.assert_called()
BuildGraph.assert_called_with(None)
self.assertEqual(self.alchemist.graph, "Graph")
@patch("pdm_utils.classes.alchemyhandler.cartography.get_map")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_get_map_1(self, BuildMetadata, GetMap):
self.alchemist.metadata = "Metadata"
self.alchemist.get_map("Test")
BuildMetadata.assert_not_called()
GetMap.assert_called_with("Metadata", "Test")
@patch("pdm_utils.classes.alchemyhandler.cartography.get_map")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_get_map_2(self, BuildMetadata, GetMap):
self.alchemist.metadata = None
self.alchemist.get_map("Test")
BuildMetadata.assert_called()
GetMap.assert_called_with(None, "Test")
class TestAlchemyHandler(unittest.TestCase):
def setUp(self):
self.alchemist = AlchemyHandler()
def test_constructor_1(self):
"""Verify AlchemyHandler credentials are initialized as None.
"""
self.assertEqual(self.alchemist._database, None)
self.assertEqual(self.alchemist._username, None)
self.assertEqual(self.alchemist._password, None)
def test_constructor_2(self):
"""Verify AlchemyHandler data objects are initialized as None.
"""
self.assertEqual(self.alchemist._engine, None)
self.assertEqual(self.alchemist._metadata, None)
self.assertEqual(self.alchemist._graph, None)
self.assertEqual(self.alchemist._session, None)
def test_constructor_3(self):
"""Verify AlchemyHandler data booleans are initialized as False.
"""
self.assertFalse(self.alchemist.connected)
self.assertFalse(self.alchemist.has_database)
self.assertFalse(self.alchemist.has_credentials)
def test_database_1(self):
"""Verify database property sets has_database.
"""
self.alchemist.database = "Test"
self.assertTrue(self.alchemist.has_database)
self.assertFalse(self.alchemist.connected_database)
def test_username_1(self):
"""Verify username property conserves has_credentials and connected.
"""
self.alchemist.username = "******"
self.assertFalse(self.alchemist.has_credentials)
self.assertFalse(self.alchemist.connected)
def test_username_2(self):
"""Verify username property sets has_credentials with valid password.
"""
self.alchemist.password = "******"
self.alchemist.username = "******"
self.assertTrue(self.alchemist.has_credentials)
self.assertFalse(self.alchemist.connected)
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.clear")
def test_username_3(self, clear_mock):
"""Verify changing usrename property calls clear().
"""
self.alchemist.username = "******"
clear_mock.assert_called()
def test_password_1(self):
"""Verify password property conserves has_credentials and connected.
"""
self.alchemist.password = "******"
self.assertFalse(self.alchemist.has_credentials)
self.assertFalse(self.alchemist.connected)
def test_password_2(self):
"""Verify password property sets has_credentials with valid username.
"""
self.alchemist.username = "******"
self.alchemist.password = "******"
self.assertTrue(self.alchemist.has_credentials)
self.assertFalse(self.alchemist.connected)
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.clear")
def test_password_3(self, clear_mock):
"""Verify changing password property calls clear().
"""
self.alchemist.password = "******"
clear_mock.assert_called()
def test_construct_engine_string_1(self):
"""Verify construct_engine_string generates an expected URI.
"""
URI = self.alchemist.construct_engine_string(username="******",
password="******")
self.assertEqual(URI, "mysql+pymysql://pdm_user:pdm_pass@localhost/")
def test_construct_engine_string_2(self):
"""Verify construct_engine_string accepts use of different drivers.
"""
URI = self.alchemist.construct_engine_string(driver="mysqlconnector",
username="******",
password="******")
self.assertEqual(URI,
"mysql+mysqlconnector://pdm_user:pdm_pass@localhost/")
def test_engine_1(self):
"""Verify engine property sets connected.
"""
self.alchemist.connected = True
self.alchemist.engine = None
self.assertFalse(self.alchemist.connected)
def test_engine_2(self):
"""Verify engine property raises TypeError on bad engine input.
"""
with self.assertRaises(TypeError):
self.alchemist.engine = "Test"
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
def test_engine_3(self, build_engine_mock):
"""Verify engine property calls build_engine() selectively.
"""
mock_engine = Mock()
build_engine_mock.return_value = mock_engine
self.alchemist._engine = "Test"
self.assertEqual(self.alchemist.engine, "Test")
build_engine_mock.assert_not_called()
self.alchemist._engine = None
self.alchemist.engine
build_engine_mock.assert_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler"
".extract_engine_credentials")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.get_mysql_dbs")
def test_engine_4(self, get_mysql_dbs_mock,
extract_engine_credentials_mock):
"""Verify call structure of engine property setter.
"""
mock_engine = Mock(spec=Engine)
self.alchemist.engine = mock_engine
get_mysql_dbs_mock.assert_called()
extract_engine_credentials_mock.assert_called_with(mock_engine)
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_metadata_1(self, build_metadata_mock):
"""Verify metadata property calls build_metadata() selectively.
"""
self.alchemist._metadata = "Test"
self.alchemist.metadata
build_metadata_mock.assert_not_called()
self.alchemist._metadata = None
self.alchemist.metadata
build_metadata_mock.assert_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_graph")
def test_graph_1(self, build_graph_mock):
"""Verify graph property calls build_graph() selectively.
"""
self.alchemist._graph = "Test"
self.alchemist.graph
build_graph_mock.assert_not_called()
self.alchemist._graph = None
self.alchemist.graph
build_graph_mock.assert_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_session")
def test_session_1(self, build_session_mock):
"""Verify session property calls build_session() selectively.
"""
self.alchemist._session = "Test"
self.alchemist.session
build_session_mock.assert_not_called()
self.alchemist._session = None
self.alchemist.session
build_session_mock.assert_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_mapper")
def test_mapper_1(self, build_mapper_mock):
"""Verify mapper property calls build_mapper() selectively.
"""
self.alchemist._mapper = "Test"
self.alchemist.mapper
build_mapper_mock.assert_not_called()
self.alchemist._mapper = None
self.alchemist.mapper
build_mapper_mock.assert_called()
@patch("pdm_utils.classes.alchemyhandler.input")
def test_ask_database_1(self, Input):
"""Verify ask_database() calls input().
"""
self.alchemist.ask_database()
Input.assert_called()
@patch("pdm_utils.classes.alchemyhandler.input")
def test_ask_database_2(self, Input):
"""Verify ask_database() sets has_database.
"""
self.alchemist.has_database = False
self.alchemist.connected = True
self.alchemist.ask_database()
self.assertTrue(self.alchemist.has_database)
self.assertFalse(self.alchemist.connected)
@patch("pdm_utils.classes.alchemyhandler.getpass")
def test_ask_credentials_1(self, GetPass):
"""Verify ask_credentials() calls getpass().
"""
self.alchemist.ask_credentials()
GetPass.assert_called()
@patch("pdm_utils.classes.alchemyhandler.getpass")
def test_ask_credentials_2(self, GetPass):
"""Verify ask_credentials() sets has_credentials.
"""
self.alchemist.has_credentials = False
self.alchemist.connected = True
self.alchemist.ask_credentials()
self.assertTrue(self.alchemist.has_credentials)
self.assertFalse(self.alchemist.connected)
def test_validate_database_1(self):
"""Verify function structure of validate_database().
"""
mock_engine = Mock()
mock_proxy = Mock()
mock_engine.execute.return_value = mock_proxy
mock_proxy.fetchall.return_value = [("pdm_test_db",),
("Actinobacteriophage",)]
self.alchemist.connected = True
self.alchemist.database = "pdm_test_db"
self.alchemist._engine = mock_engine
self.alchemist.validate_database()
mock_engine.execute.assert_called_once()
mock_proxy.fetchall.assert_called()
def test_validate_database_2(self):
"""Verify validate_database() raises IndexError without database.
"""
self.alchemist.connected = True
with self.assertRaises(AttributeError):
self.alchemist.validate_database()
def test_validate_database_3(self):
"""Verify validate_database() raises ValueError from bad database input.
"""
mock_engine = Mock()
mock_proxy = Mock()
mock_engine.execute.return_value = mock_proxy
mock_proxy.fetchall.return_value = []
self.alchemist.connected = True
self.alchemist.database = "test db"
self.alchemist._engine = mock_engine
with self.assertRaises(MySQLDatabaseError):
self.alchemist.validate_database()
mock_engine.execute.assert_called_once()
mock_proxy.fetchall.assert_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.sqlalchemy.create_engine")
def test_build_engine_1(self, create_engine_mock, ask_credentials_mock):
"""Verify build_engine() returns if connected already.
"""
self.alchemist.engine = None
self.alchemist.connected = True
self.alchemist.build_engine()
create_engine_mock.assert_not_called()
ask_credentials_mock.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.sqlalchemy.create_engine")
def test_build_engine_2(self, create_engine_mock, ask_credentials_mock):
"""Verify build_engine() raises attribute error without credentials.
"""
self.alchemist.username = "******"
self.alchemist.password = "******"
self.alchemist.has_credentials = False
with self.assertRaises(AttributeError):
self.alchemist.build_engine()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.validate_database")
@patch("pdm_utils.classes.alchemyhandler.sqlalchemy.create_engine")
def test_build_engine_3(self, create_engine_mock, validate_database_mock):
"""Verify build_engine() calls create_engine() with db engine string.
"""
self.alchemist.username = "******"
self.alchemist.password = "******"
self.alchemist.database = "database"
self.alchemist.build_engine()
login_string = "mysql+pymysql://user:pass@localhost/"
db_login_string = "mysql+pymysql://user:pass@localhost/database"
create_engine_mock.assert_any_call(login_string, echo=False)
create_engine_mock.assert_any_call(db_login_string, echo=False)
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.sqlalchemy.create_engine")
def test_build_engine_4(self, create_engine_mock, ask_credentials_mock):
"""Verify build_engine() sets has_credentials.
"""
self.alchemist.has_credentials = True
self.alchemist.connected = False
self.alchemist._metadata = "Test"
self.alchemist._graph = "Test"
self.alchemist.build_engine()
self.alchemist.connected = True
self.assertEqual(self.alchemist._metadata, None)
self.assertEqual(self.alchemist._graph, None)
@patch("pdm_utils.classes.alchemyhandler.sqlalchemy.create_engine")
def test_build_engine_5(self, create_engine_mock):
"""Verify AlchemyHandler echo property controls create_engine()
parameters.
"""
self.alchemist.username = "******"
self.alchemist.password = "******"
self.alchemist.build_engine()
login_string = "mysql+pymysql://user:pass@localhost/"
create_engine_mock.assert_any_call(login_string, echo=False)
self.alchemist.echo = True
self.alchemist.connected = False
self.alchemist.build_engine()
create_engine_mock.assert_any_call(login_string, echo=True)
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
def test_connect_1(self, build_engine_mock, ask_database_mock,
AskCredentials):
"""Verify connect() returns if build_engine() does not complain.
"""
self.alchemist.has_credentials = True
self.alchemist.connected = True
self.alchemist.connect()
build_engine_mock.assert_called()
ask_database_mock.assert_not_called()
AskCredentials.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
def test_connect_2(self, build_engine_mock, ask_database_mock,
AskCredentials):
"""Verify connect() AlchemyHandler properties control function calls.
"""
self.alchemist.connected = True
self.alchemist.connected_database = True
self.alchemist.has_credentials = True
self.alchemist.connect(ask_database=True)
build_engine_mock.assert_called()
ask_database_mock.assert_not_called()
AskCredentials.assert_not_called()
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler."
"ask_credentials")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
def test_connect_3(self, build_engine_mock, ask_database_mock,
AskCredentials):
"""Verify connect() depends on build_engine() to raise ValueError.
"""
self.alchemist.connected = False
build_engine_mock.side_effect = OperationalError("", "", "")
with self.assertRaises(SQLCredentialsError):
self.alchemist.connect()
build_engine_mock.assert_called()
ask_database_mock.assert_not_called()
AskCredentials.assert_called()
def build_engine_side_effect(self, mock_engine):
"""Helper function for side effect usage.
"""
self.alchemist._engine = mock_engine
@patch("pdm_utils.classes.alchemyhandler.MetaData")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
def test_build_metadata_1(self, ask_database_mock, build_engine_mock,
metadata_mock):
"""Verify build_metadata() relies on AlchemyHandler properties.
"""
self.alchemist.has_database = False
self.alchemist.connected = False
self.alchemist.build_metadata()
ask_database_mock.assert_called()
build_engine_mock.assert_called()
metadata_mock.assert_called()
@patch("pdm_utils.classes.alchemyhandler.MetaData")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
def test_build_metadata_2(self, ask_database_mock, build_engine_mock,
metadata_mock):
"""Verify build_metadata() calls ask_database() and build_engine().
"""
self.alchemist.has_database = True
self.alchemist.connected = True
self.alchemist.connected_database = True
self.alchemist.build_metadata()
ask_database_mock.assert_not_called()
build_engine_mock.assert_not_called()
metadata_mock.assert_called()
@patch("pdm_utils.classes.alchemyhandler.querying.build_graph")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_build_graph_1(self, build_metadata_mock, build_graph_mock):
"""Verify build_graph() calls querying.build_graph().
"""
build_graph_mock.return_value = "Graph"
self.alchemist._metadata = "Metadata"
self.alchemist.build_graph()
build_metadata_mock.assert_not_called()
build_graph_mock.assert_called_with("Metadata")
self.assertEqual(self.alchemist._graph, "Graph")
@patch("pdm_utils.classes.alchemyhandler.querying.build_graph")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_build_graph_2(self, build_metadata_mock, build_graph_mock):
"""Verify build_graph() calls build_metadata().
"""
build_graph_mock.return_value = "Graph"
self.alchemist._metadata = None
self.alchemist.build_graph()
build_metadata_mock.assert_called()
build_graph_mock.assert_called_with(None)
self.assertEqual(self.alchemist._graph, "Graph")
@patch("pdm_utils.classes.alchemyhandler.sessionmaker")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
def test_build_session_1(self, ask_database_mock, build_engine_mock,
sessionmaker_mock):
"""Verify build_session() relies on AlchemyHandler properties.
"""
self.alchemist.has_database = False
self.alchemist.connected = False
self.alchemist.build_session()
ask_database_mock.assert_called()
build_engine_mock.assert_called()
sessionmaker_mock.assert_called()
@patch("pdm_utils.classes.alchemyhandler.sessionmaker")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_engine")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.ask_database")
def test_build_session_2(self, ask_database_mock, build_engine_mock,
sessionmaker_mock):
"""Verify build_session() calls ask_database() and build_engine().
"""
self.alchemist.has_database = True
self.alchemist.connected = True
self.alchemist.build_session()
ask_database_mock.assert_not_called()
build_engine_mock.assert_not_called()
sessionmaker_mock.assert_called()
@patch("pdm_utils.classes.alchemyhandler.automap_base")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_build_mapper_1(self, build_metadata_mock, automap_base_mock):
"""Verify build_mapper() calls automap_base().
"""
base_mock = Mock()
automap_base_mock.return_value = base_mock
self.alchemist._metadata = "Metadata"
self.alchemist.build_mapper()
build_metadata_mock.assert_not_called()
automap_base_mock.assert_called_with(metadata="Metadata")
self.assertEqual(self.alchemist._mapper, base_mock)
@patch("pdm_utils.classes.alchemyhandler.automap_base")
@patch("pdm_utils.classes.alchemyhandler.AlchemyHandler.build_metadata")
def test_build_mapper_2(self, build_metadata_mock, automap_base_mock):
"""Verify build_mapper() calls build_metadata().
"""
base_mock = Mock()
automap_base_mock.return_value = base_mock
self.alchemist._metadata = None
self.alchemist.build_mapper()
build_metadata_mock.assert_called()
automap_base_mock.assert_called_with(metadata=None)
self.assertEqual(self.alchemist._mapper, base_mock)