going somewhere.

src/db/_accounts.rs

@@ -11,8 +11,8 @@ pub struct Account {
 }
 
 impl Account {
-    pub fn from_row(row: &Row) -> Result<Account>{
-        return Ok(Account{
+    pub fn from_row(row: &Row) -> Result<Account> {
+        return Ok(Account {
             id: row.get("acc_id")?,
             amount: row.get("acc_amount")?,
             timestamp: row.get("acc_timestamp")?,
@@ -41,7 +41,7 @@ pub fn list_accounts<'a>(conn: &Connection) -> Result<Vec<Account>> {
     return Ok(ret);
 }
 
-pub fn get_account_by_id(tx: &Transaction, id: u32) -> Result<Account>{
+pub fn get_account_by_id(tx: &Transaction, id: u32) -> Result<Account> {
     let q = "SELECT acc.id AS acc_id,
                           acc.amount AS acc_amount,
                           UNIXEPOCH(acc.timestamp) AS acc_timestamp,
@@ -55,7 +55,7 @@ pub fn get_account_by_id(tx: &Transaction, id: u32) -> Result<Account>{
     return tx.query_row(q, params![id], Account::from_row);
 }
 
-pub fn create_account(tx: &Transaction, sec: &Security, user: &User) -> Result<Account>{
+pub fn create_account(tx: &Transaction, sec: &Security, user: &User) -> Result<Account> {
     let q = "INSERT INTO accounts(security, owner, amount, timestamp)
                    VALUES (?1, ?2, 0, CURRENT_TIMESTAMP)";
     tx.execute(q, (sec.id, user.id))?;
@@ -64,38 +64,27 @@ pub fn create_account(tx: &Transaction, sec: &Security, user: &User) -> Result<A
 
 #[cfg(test)]
 mod test {
-    use rusqlite::{Connection};
-    use crate::db::_users;
+    use rusqlite::Connection;
+
+    use crate::db::_test_utils::{setup_users_and_securities};
     use crate::db::_securities;
+    use crate::db::_users;
     use crate::migration;
 
     use super::*;
 
-    fn setup_users(tx: &Transaction) -> Result<Vec<User>> {
-        let user_1 = _users::create_user(tx, &"bernard".to_string(), &"123".to_string())?;
-        let user_2 = _users::create_user(tx, &"sam".to_string(), &"abc".to_string())?;
-        return Ok(vec![user_1, user_2]);
-    }
-
-    fn setup_securities(tx: &Transaction) -> Result<Vec<Security>> {
-        let sec_1 = _securities::create_security(tx, &_securities::test_util::mock_currency_1())?;
-        let sec_2 = _securities::create_security(tx, &_securities::test_util::mock_currency_2())?;
-        return Ok(vec![sec_1, sec_2]);
-    }
-
     fn setup() -> (Connection, Vec<User>, Vec<Security>) {
         let mut conn = Connection::open_in_memory().unwrap();
         migration::apply_migrations(&mut conn).unwrap();
 
         let tx = conn.transaction().unwrap();
-        let users = setup_users(&tx).unwrap();
-        let securities = setup_securities(&tx).unwrap();
+        let (users, securities) = setup_users_and_securities(&tx).unwrap();
 
         tx.commit().unwrap();
         return (conn, users, securities);
     }
 
-    fn create_all_accounts(tx: & Transaction, users: & Vec<User>, secs: & Vec<Security>) -> Result<()>{
+    fn create_all_accounts(tx: &Transaction, users: &Vec<User>, secs: &Vec<Security>) -> Result<()> {
         for sec in secs.iter() {
             for user in users.iter() {
                 create_account(&tx, sec, user)?;
@@ -105,12 +94,12 @@ mod test {
     }
 
     #[test]
-    fn test_happy_path() -> Result<()>{
+    fn test_happy_path() -> Result<()> {
         let (mut conn, users, secs) = setup();
         let tx = conn.transaction()?;
-        create_all_accounts(& tx, &users, &secs)?;
+        create_all_accounts(&tx, &users, &secs)?;
         tx.commit()?;
-        let accs = list_accounts(& conn)?;
+        let accs = list_accounts(&conn)?;
         assert_eq!(4, accs.len());
         assert_eq!(1, accs.get(0).unwrap().id);
         assert_eq!(4, accs.get(3).unwrap().id);
@@ -118,10 +107,10 @@ mod test {
     }
 
     #[test]
-    fn test_happy_path_no_commit() -> Result<()>{
+    fn test_happy_path_no_commit() -> Result<()> {
         let (mut conn, users, secs) = setup();
-        create_all_accounts(& conn.transaction()?, &users, &secs)?;
-        let accs = list_accounts(& conn)?;
+        create_all_accounts(&conn.transaction()?, &users, &secs)?;
+        let accs = list_accounts(&conn)?;
         assert_eq!(0, accs.len());
         return Ok(());
     }