def test_prepare_sql_stmt_unregistered(self): """ Given a function that generates SQL has not been registered with the PreparedStatementController When prepare_sql_stmt is called for that function Then a StatementNotRegistered error will be raised """ psc = PreparedStatementController() with self.assertRaises(StatementNotRegistered): psc.prepare_sql_stmt("unregistered_sql", force=False)
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_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_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, {})