too much fucking refactoring.

src/db/_securities.rs

@@ -2,6 +2,7 @@ use rusqlite::{params, Connection, Result, Row, ToSql, Transaction};
 use serde::Serialize;
 
 use crate::db::_external_id::{Id, SecurityId};
+use crate::util::{CustomResult, Error};
 
 
 #[derive(Debug, Serialize, PartialEq)]
@@ -61,32 +62,33 @@ pub struct NewSecurity {
     pub name: String,
 }
 
-pub fn create_security(tx: &Transaction, sec: &NewSecurity) -> Result<Security> {
+pub fn create_security(tx: &Transaction, sec: &NewSecurity) -> CustomResult<Security> {
     let q = "INSERT INTO
                      securities(name, symbol, security_type)
                    VALUES(?1, ?2, ?3)";
     let params = (&sec.name, &sec.symbol, &sec.security_type);
-    tx.execute(q, params)?;
+    tx.execute(q, params).map_err(Error::SqlError)?;
     let new_sec_id = tx.last_insert_rowid() as i32;
 
     return get_security_by_id(tx, new_sec_id);
 }
 
-pub fn get_security_by_id(tx: &Transaction, id: i32) -> Result<Security> {
+pub fn get_security_by_id(tx: &Transaction, id: i32) -> CustomResult<Security> {
     let q = "SELECT id AS sec_id, security_type AS sec_security_type, symbol AS sec_symbol
                   FROM securities
                   WHERE id = ?1";
-    tx.query_row(q, params![id], Security::from_row)
+    tx.query_row(q, params![id], Security::from_row).map_err(Error::SqlError)
 }
 
-pub fn list_securities(conn: &Connection) -> Result<Vec<Security>> {
+pub fn list_securities(conn: &Connection) -> CustomResult<Vec<Security>> {
     let q = "SELECT id AS sec_id, security_type AS sec_security_type, symbol AS sec_symbol
                   FROM securities
                   ORDER BY id ASC";
-    let mut stmt = conn.prepare(q)?;
+    let mut stmt = conn.prepare(q).map_err(Error::SqlError)?;
 
     let ret: Vec<Security> = stmt
-        .query_map([], Security::from_row)?
+        .query_map([], Security::from_row)
+        .map_err(Error::SqlError)?
         .filter(Result::is_ok)
         .map(Result::unwrap)
         .collect();
@@ -130,25 +132,26 @@ mod test_securities {
     }
 
     #[test]
-    fn test_create_security() -> Result<(), rusqlite::Error> {
+    fn test_create_security() -> CustomResult<()> {
         let (mut conn, _users) = setup();
         let new_sec = mock_currency_1();
-        let tx = conn.transaction()?;
+        let tx = conn.transaction().unwrap();
         let sec = create_security(&tx, &new_sec)?;
         assert_eq!(sec.symbol, new_sec.symbol);
 
-        tx.commit()
+        tx.commit().unwrap();
+        Ok(())
     }
 
     #[test]
-    fn test_list_security() -> Result<(), rusqlite::Error> {
+    fn test_list_security() -> CustomResult<()> {
         let (mut conn, _users) = setup();
         assert_eq!(0, list_securities(&conn)?.len());
 
         let sec = mock_currency_1();
-        let tx = conn.transaction()?;
+        let tx = conn.transaction().unwrap();
         create_security(&tx, &sec)?;
-        tx.commit()?;
+        tx.commit().unwrap();
         let ret = list_securities(&conn)?;
         let expt = Security {
             id: 1,
@@ -164,9 +167,9 @@ mod test_securities {
             security_type: SecurityType::Bond,
             symbol: "B".to_string(),
         };
-        let tx = conn.transaction()?;
+        let tx = conn.transaction().unwrap();
         create_security(&tx, &sec)?;
-        tx.commit()?;
+        tx.commit().unwrap();
         let ret = list_securities(&conn)?;
         assert_eq!(2, ret.len());
         assert_eq!(&expt, ret.get(1).unwrap());