Lines
51.72 %
Functions
23.08 %
Branches
100 %
pub mod user {
use crate::db::DBError;
use crate::error::ServerError;
use crate::user::User;
use finance::{
account::{Account, AccountBuilder},
tag::Tag,
};
use sqlx::types::Uuid;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
impl User {
pub async fn add_account(&self, script: &[u8]) -> Result<Account, ServerError> {
let a = AccountBuilder::new().id(Uuid::new_v4()).build()?;
let mut tags = self.get_account_tags(&a).await?;
let tagdb: Arc<Mutex<HashMap<String, String>>> = Arc::new(Mutex::new(HashMap::new()));
{
let mut tagdb_lock = tagdb.lock().map_err(|err| {
log::error!("{}", t!("Mutex error: %{err}", err = err : {:?}));
ServerError::Lock
})?;
for t in &tags {
tagdb_lock.insert(t.tag_name.clone(), t.tag_value.clone());
}
let account = if script.is_empty() {
a
} else {
// TODO: Implement account hook similar to commodity
// Update the tags with the new values from `tagdb`
let tagdb_lock = tagdb.lock().map_err(|err| {
for t in &mut tags {
if let Some(value) = tagdb_lock.get(&t.tag_name) {
t.tag_value = value.to_owned();
// Call `update_account_tags` to apply the updates to the database
self.update_account_tags(&account, &tags).await?;
Ok(account)
pub async fn create_account(
&self,
name: &str,
parent: Option<Uuid>,
) -> Result<Account, ServerError> {
use sqlx::Connection;
// Every account must carry a `name` tag: the UI relies on it.
// Reject a blank name before anything is written.
if name.trim().is_empty() {
return Err(ServerError::Creation);
let a = Account {
id: Uuid::new_v4(),
parent,
let mut conn = self.get_connection().await.map_err(|err| {
log::error!("{}", t!("Database error: %{err}", err = err : {:?}));
ServerError::DB(err)
// The account row and its name tag are written in one transaction,
// so a failure while tagging cannot leave a nameless account behind.
let mut tx = conn.begin().await.map_err(|err| {
ServerError::DB(DBError::Sqlx(err))
a.commit(&mut *tx).await?;
sqlx::query_file!(
"sql/set/accounts/tag.sql",
&a.id,
"name",
name,
None::<String>
)
.execute(&mut *tx)
.await
.map_err(|err| {
tx.commit().await.map_err(|err| {
Ok(a)
pub async fn update_account_tags(
a: &Account,
tags: &[Tag],
) -> Result<(), ServerError> {
for tag in tags {
self.set_account_tag(a, tag).await?;
Ok(())
pub async fn set_account_tag(&self, a: &Account, t: &Tag) -> Result<(), ServerError> {
if t.tag_name.trim().is_empty() || t.tag_value.trim().is_empty() {
&t.tag_name,
&t.tag_value,
t.description
.execute(&mut *conn)
pub async fn get_account_tags(&self, a: &Account) -> Result<Vec<Tag>, ServerError> {
let tags = sqlx::query_file_as!(Tag, "sql/select/accounts/tags.sql", &a.id)
.fetch_all(&mut *conn)
log::error!("Database error: {err:?}");
Ok(tags)
pub async fn list_transaction_ids_by_account(
account_id: Uuid,
) -> Result<Vec<Uuid>, ServerError> {
let rows = sqlx::query_file!("sql/select/transactions/by_account_all.sql", &account_id)
Ok(rows.into_iter().map(|r| r.id).collect())
pub async fn get_account_tag(&self, a: &Account, tag: &String) -> Result<Tag, ServerError> {
let tag = sqlx::query_file_as!(Tag, "sql/select/accounts/tag.sql", &a.id, tag)
.fetch_one(&mut *conn)
Ok(tag)
#[cfg(test)]
mod account_tests {
use super::*;
use crate::db::DB_POOL;
#[cfg(feature = "testlog")]
use env_logger;
use finance::commodity::Commodity;
use log;
use sqlx::PgPool;
use supp_macro::local_db_sqlx_test;
use tokio::sync::OnceCell;
/// Context for keeping environment intact
static CONTEXT: OnceCell<()> = OnceCell::const_new();
static COMMODITY: OnceCell<Commodity> = OnceCell::const_new();
static USER: OnceCell<User> = OnceCell::const_new();
async fn setup() {
CONTEXT
.get_or_init(|| async {
let _ = env_logger::builder()
.is_test(true)
.filter_level(log::LevelFilter::Trace)
.try_init();
})
.await;
COMMODITY
.get_or_init(|| async { Commodity { id: Uuid::new_v4() } })
USER.get_or_init(|| async { User { id: Uuid::new_v4() } })
// #[local_db_sqlx_test]
// async fn test_add_account(pool: PgPool) -> Result<(), anyhow::Error> {
// let mut conn = pool.acquire().await.unwrap();
// USER.get()
// .unwrap()
// .commit()
// .await
// .expect("Failed to commit user to database");
// COMMODITY.get().unwrap().commit(&mut *conn).await?;
// let account = Account {
// id: Uuid::new_v4(),
// commodity_id: COMMODITY.get().unwrap().id,
// parent: None,
// };
// account.commit(&mut *conn).await?;
// let script = vec![];
// let user = USER.get().unwrap();
// let acc = user.add_account(&script).await?;
// assert!(!acc.commodity_id.is_nil());
// }
#[local_db_sqlx_test]
async fn test_create_account(pool: PgPool) -> Result<(), anyhow::Error> {
USER.get()
.unwrap()
.commit()
.expect("Failed to commit user to database");
let mut conn = pool.acquire().await.unwrap();
COMMODITY.get().unwrap().commit(&mut *conn).await?;
let user = USER.get().unwrap();
let a = user.create_account("Test Account", None).await?;
let tag = user.get_account_tag(&a, &"name".to_string()).await?;
assert_eq!(tag.tag_value, "Test Account");
async fn test_create_account_blank_name(pool: PgPool) -> Result<(), anyhow::Error> {
for name in ["", " "] {
assert!(
matches!(
user.create_account(name, None).await,
Err(ServerError::Creation)
),
"blank name {name:?} must be rejected"
);
// A rejected creation must not leave a nameless account behind.
let mut conn = user.get_connection().await?;
let count: i64 = sqlx::query_scalar("SELECT count(*) FROM accounts")
.await?;
assert_eq!(count, 0);
async fn test_set_account_name_to_same_value(pool: PgPool) -> Result<(), anyhow::Error> {
let a = user.create_account("Same Name", None).await?;
// Re-setting the current value (e.g. saving a rename unchanged)
// must keep the tag rather than detach it.
user.set_account_tag(
&a,
&Tag::builder()
.id(Uuid::new_v4())
.tag_name("name")
.tag_value("Same Name")
.build()?,
let tags = user.get_account_tags(&a).await?;
assert_eq!(tags.len(), 1);
assert_eq!(tags[0].tag_name, "name");
assert_eq!(tags[0].tag_value, "Same Name");
async fn test_account_tag(pool: PgPool) -> Result<(), anyhow::Error> {
let account = Account {
parent: None,
account.commit(&mut *conn).await?;
&account,
.tag_name("test")
.tag_value("testval")
let tags = user.get_account_tags(&account).await?;
assert_eq!(tags[0].tag_name, "test");
assert_eq!(tags[0].tag_value, "testval");
.tag_value("testval2")
assert_eq!(tags[0].tag_value, "testval2");
async fn test_get_account_tags(pool: PgPool) -> Result<(), anyhow::Error> {
.tag_name("test1")
.tag_value("value1")
.tag_name("test2")
.tag_value("value2")
let mut newtags = user.get_account_tags(&account).await?;
assert_eq!(newtags.len(), 2);
newtags[0].tag_value = "newvalue1".to_string();
user.update_account_tags(&account, &newtags).await?;
let updated_tags = user.get_account_tags(&account).await?;
assert_eq!(updated_tags[0].tag_value, "newvalue1");