def test_prepare_sql_stmt_force(self): """ Given a SQL statement has already been prepared in the database When prepare_sql_stmt is called for the same function And force is False Then a StatementAlreadyPreparedException error will be raised --- Given a SQL statement has already been prepared in the database When prepare_sql_stmt is called for the same function And force is True Then the existing statement will be deallocated And the statement will be re-prepared """ psc = PreparedStatementController() psc.register_sql("gen_sql", lambda: None) with patch.object(PreparedStatement, "prepare", return_value=None): psc.prepare_sql_stmt("gen_sql", force=False) self.assertTrue("gen_sql" in psc.prepared_statements) with self.assertRaises(StatementAlreadyPreparedException): psc.prepare_sql_stmt("gen_sql", force=False) with patch.object(PreparedStatement, "prepare", return_value=None) as mock_prepare: with patch.object(PreparedStatement, "deallocate", return_value=None) as mock_deallocate: psc.prepare_sql_stmt("gen_sql", force=True) mock_deallocate.assert_called_once() mock_prepare.assert_called_once()
def test_register_sql(self): """ Given a function that returns an SQL string When register_sql is called with that function as one of the arguments Then that function should be added to the sql_generating_functions dict """ def gen_sql(): pass psc = PreparedStatementController() psc.register_sql("gen_sql", gen_sql) self.assertTrue("gen_sql" in psc.sql_generating_functions) self.assertFalse("gen_sql" in psc.qs_generating_functions) self.assertTrue(psc.sql_generating_functions["gen_sql"] is gen_sql)
def test_execute_prepared_stmt(self): """ Given a statement has been prepared in the database When execute() is called for that statement Then then the execute method of the PreparedStatement object will be called """ psc = PreparedStatementController() psc.register_sql("gen_sql", lambda: None) with patch.object(PreparedStatement, "prepare", return_value=None): psc.prepare_sql_stmt("gen_sql", force=False) self.assertTrue("gen_sql" in psc.prepared_statements) with patch.object(PreparedStatement, "execute", return_value=None) as mock_execute: psc.execute("gen_sql") mock_execute.assert_called_once()
def test_prepare_sql_stmt(self): """ Given a function that generates SQL has been registered with the PreparedStatementController When prepare_sql_stmt is called Then a PreparedStatement object should be created And the PreparedStatement should be added to the prepared_statements dict And the prepare method of the PreparedStatement will be called """ psc = PreparedStatementController() psc.register_sql("gen_sql", lambda: None) with patch.object(PreparedStatement, "prepare", return_value=None) as mock_prepare: psc.prepare_sql_stmt("gen_sql", force=False) self.assertTrue("gen_sql" in psc.prepared_statements) self.assertTrue( isinstance(psc.prepared_statements["gen_sql"], PreparedStatement)) mock_prepare.assert_called_once()
def test_prepare_all(self): """ Given a set of sql and qs generating functions that have been registered with the PreparedStatementController When prepare_all() is called Then prepare_sql_stmt and prepare_qs_stmt should be called for each registered function as appropriate """ psc = PreparedStatementController() psc.register_sql("gen_sql1", lambda: None) psc.register_sql("gen_sql2", lambda: None) psc.register_sql("gen_sql3", lambda: None) psc.register_qs("gen_qs1", lambda: Species.prepare.all()) psc.register_qs("gen_qs2", lambda: Species.prepare.all()) with patch.object(PreparedORMStatement, "prepare", return_value=None) as mock_orm_prepare: with patch.object(PreparedStatement, "prepare", return_value=None) as mock_sql_prepare: psc.prepare_all() self.assertEqual(mock_sql_prepare.call_count, 3) self.assertEqual(mock_orm_prepare.call_count, 2)
def test_deallocate_all(self): """ Given there are prepared statements When deallocate_all() is called Then the deallocate method will be called on every PreparedStatement object And the prepared_statements dict will be empty """ psc = PreparedStatementController() psc.register_sql("gen_sql", lambda: None) psc.register_sql("gen_sql2", lambda: None) psc.register_sql("gen_sql3", lambda: None) with patch.object(PreparedStatement, "prepare", return_value=None): psc.prepare_sql_stmt("gen_sql", force=False) psc.prepare_sql_stmt("gen_sql2", force=False) psc.prepare_sql_stmt("gen_sql3", force=False) with patch.object(PreparedStatement, "deallocate", return_value=None) as mock_deallocate: psc.deallocate_all() self.assertEqual(mock_deallocate.call_count, 3) self.assertEqual(psc.prepared_statements, {})