I should be working.

src/services/_transactions.rs

@@ -1,4 +1,4 @@
-use rusqlite::{ffi, params, Params, Transaction};
+use rusqlite::{ffi, params, Params, Savepoint, Transaction};
 
 use crate::db::accounts::{Account, get_account_by_id};
 use crate::db::cheques::SecurityEmitterCheque;
@@ -44,18 +44,20 @@ fn _add_cheque_to_cashed_cheques_log(tx: &TransactionHelper,
 fn cash_cheque(tx: &Transaction,
                cheque: &SecurityEmitterCheque,
                account_id: &AccountId) -> CustomResult<()> {
-
-    if !securities::is_owner(tx, &cheque.security_id, &cheque.drawer_user_id).map_err(Error::SqlError)? {
+    // let mut savepoint: Savepoint = tx.savepoint_with_name("bib").map_err(Error::SqlError)?;
+    if !securities::is_owner(&tx, &cheque.security_id, &cheque.drawer_user_id).map_err(Error::SqlError)? {
         return Err(Error::InvalidDrawer(format!("The drawer is the security owner: {:?}", cheque)));
     }
 
     // todo:
     //   1. payee is owner of the account.
+    //   2. drawer is owner of the account.
 
 
     let myx = TransactionHelper::new(tx);
     _add_securities_to_account(&myx, cheque, account_id)?;
     _add_cheque_to_cashed_cheques_log(&myx, cheque, account_id)?;
+    // savepoint.rollback().map_err(Error::SqlError)?;
     // create transaction log
     Ok(())
 }
@@ -64,9 +66,10 @@ fn cash_cheque(tx: &Transaction,
 #[cfg(test)]
 mod test_caching_cheques {
     use rusqlite::{Connection, params};
-    use crate::db::accounts::create_checking_account;
+    use crate::db::accounts::{create_checking_account, create_security_emitter_account};
 
     use crate::db::{accounts, test_utils};
+    use crate::db::cheques::{Drawer, Payee};
     use crate::db::external_id::{Id, SecurityId, UserId};
     use crate::db::users::User;
     use crate::migration;
@@ -79,34 +82,32 @@ mod test_caching_cheques {
         return conn;
     }
 
-    fn setup_basic() -> (Connection, UserId, SecurityId, UserId, AccountId) {
+    fn setup_basic() -> (Connection, Drawer, Payee, AccountId) {
         let mut conn = setup_conn();
         let tx = conn.transaction().unwrap();
         let (users, securities, accounts) = test_utils::setup_basic_environment(&tx).unwrap();
         let sec = securities.get(0).unwrap();
         let drawer = users.get(0).unwrap();
         let payee = users.get(1).unwrap();
+        let drawer_account = create_security_emitter_account(&tx, &sec.id(), &drawer.id()).unwrap();
         let payee_account = create_checking_account(&tx, &sec.id(), &payee.id()).unwrap();
 
         tx.commit().unwrap();
-        (conn, drawer.id(), sec.id(), payee.id(), payee_account.id())
+        let drawer: Drawer = (drawer.id(), drawer_account.id(), sec.id());
+        let payee: Payee = (payee.id(), sec.id());
+        (conn, drawer, payee, payee_account.id())
     }
 
 
     #[test]
     fn test_basic_happy_path() -> CustomResult<()> {
-        let (mut conn, drawer, sec, payee, payee_account) = setup_basic();
-        let tx = conn.transaction().unwrap();
+        let (mut conn, drawer, payee, payee_account) = setup_basic();
+        let mut tx = conn.transaction().unwrap();
 
         let cheque = SecurityEmitterCheque::new(
-            drawer,
-            sec,
-            payee,
-            1000,
-            99,
-        );
+            drawer, payee, 1000, 99);
 
-        cash_cheque(&tx, &cheque, &payee_account)?;
+        cash_cheque(&mut tx, &cheque, &payee_account)?;
         tx.commit().unwrap();
 
         let tx = conn.transaction().unwrap();
@@ -118,23 +119,22 @@ mod test_caching_cheques {
 
     #[test]
     fn test_double_spend() -> CustomResult<()> {
-        let (mut conn, drawer, sec, payee, payee_account) = setup_basic();
+        let (mut conn, drawer, payee, payee_account) = setup_basic();
         let amount: u32 = 1000;
-        let tx = conn.transaction().unwrap();
+        let mut tx = conn.transaction().unwrap();
 
         let cheque = SecurityEmitterCheque::new(
             drawer,
-            sec,
             payee,
             1000,
             99,
         );
 
-        cash_cheque(&tx, &cheque, &payee_account)?;
+        cash_cheque(&mut tx, &cheque, &payee_account)?;
         tx.commit().unwrap();
-        let tx = conn.transaction().unwrap();
+        let mut tx = conn.transaction().unwrap();
 
-        let ret = cash_cheque(&tx, &cheque, &payee_account);
+        let ret = cash_cheque(&mut tx, &cheque, &payee_account);
         match ret {
             Err(Error::DoubleSpendingError(_)) => Ok(()),
             _ => Err(Error::Testing("Expected double spending error here.".to_string()))
@@ -143,19 +143,19 @@ mod test_caching_cheques {
 
     #[test]
     fn test_invalid_drawer() -> CustomResult<()> {
-        let (mut conn, drawer, sec, payee, payee_account) = setup_basic();
+        let (mut conn, drawer, payee, payee_account) = setup_basic();
         let amount: u32 = 1000;
-        let tx = conn.transaction().unwrap();
-        let not_currency_owner = UserId::from_id(drawer.get_id() + 72623);
+        let mut tx = conn.transaction().unwrap();
+        let not_currency_owner_user_id = UserId::from_id(drawer.0.get_id() + 72623);
+        let not_currency_owner: Drawer = (not_currency_owner_user_id, drawer.1, drawer.2);
         let cheque = SecurityEmitterCheque::new(
             not_currency_owner,
-            sec,
             payee,
             1000,
             99,
         );
 
-        let ret = cash_cheque(&tx, &cheque, &payee_account);
+        let ret = cash_cheque(&mut tx, &cheque, &payee_account);
         match ret {
             Err(Error::InvalidDrawer(_)) => Ok(()),
             _ => Err(Error::Testing("Expected invalid drawer here.".to_string()))