diff options
Diffstat (limited to 'backend')
38 files changed, 822 insertions, 48 deletions
diff --git a/backend/core/Cargo.lock b/backend/core/Cargo.lock index a889422..649a043 100644 --- a/backend/core/Cargo.lock +++ b/backend/core/Cargo.lock @@ -35,8 +35,10 @@ version = "0.1.0" dependencies = [ "anyhow", "chrono", + "derive_builder", "diesel", "diesel_migrations", + "libsqlite3-sys", "serde", ] @@ -127,6 +129,37 @@ dependencies = [ ] [[package]] +name = "derive_builder" +version = "0.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947" +dependencies = [ + "derive_builder_macro", +] + +[[package]] +name = "derive_builder_core" +version = "0.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8" +dependencies = [ + "darling", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "derive_builder_macro" +version = "0.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c" +dependencies = [ + "derive_builder_core", + "syn", +] + +[[package]] name = "diesel" version = "2.2.4" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -280,6 +313,7 @@ version = "0.30.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149" dependencies = [ + "cc", "pkg-config", "vcpkg", ] diff --git a/backend/core/Cargo.toml b/backend/core/Cargo.toml index bf87568..406e5e5 100644 --- a/backend/core/Cargo.toml +++ b/backend/core/Cargo.toml @@ -6,6 +6,10 @@ edition = "2021" [dependencies] anyhow = { version = "1.0.0" } chrono = { version = "0.4.38", features = ["serde"] } +derive_builder = { version = "0.20.2" } diesel = { version = "2.2.0", features = ["sqlite"] } diesel_migrations = "2.2.0" serde = { version = "1.0.209", features = ["derive"] } + +[dev-dependencies] +libsqlite3-sys = { version = "0.30.1", features = ["bundled"] } diff --git a/backend/core/src/models/account.rs b/backend/core/src/models/account.rs index c10bd5f..fcd5270 100644 --- a/backend/core/src/models/account.rs +++ b/backend/core/src/models/account.rs @@ -1,7 +1,7 @@ use diesel::prelude::*; use serde::{Deserialize, Serialize}; -use super::date_time_utc::DateTimeUtc; +use crate::models::date_time_utc::DateTimeUtc; #[derive( Insertable, Queryable, Identifiable, Selectable, Debug, PartialEq, Clone, Serialize, Deserialize, diff --git a/backend/core/src/models/budget.rs b/backend/core/src/models/budget.rs index cc18f2e..08a1c72 100644 --- a/backend/core/src/models/budget.rs +++ b/backend/core/src/models/budget.rs @@ -32,7 +32,7 @@ mod test { let budget_update = BudgetUpdate { id: 0, category_id: 1, - date: DateTimeUtc::new(Utc::now()), + date: DateTimeUtc::new(&Utc::now()), new_budget: quantity, new_period: period, }; diff --git a/backend/core/src/models/budget_update.rs b/backend/core/src/models/budget_update.rs index 8600419..3500d8e 100644 --- a/backend/core/src/models/budget_update.rs +++ b/backend/core/src/models/budget_update.rs @@ -1,3 +1,4 @@ +use derive_builder::Builder; use diesel::prelude::*; use serde::Serialize; @@ -5,7 +6,7 @@ use crate::models::category::Category; use super::date_time_utc::DateTimeUtc; -#[derive(Clone, Serialize, Queryable, Identifiable, Selectable, Associations, Debug, PartialEq, Insertable)] +#[derive(Builder, Clone, Serialize, Queryable, Identifiable, Selectable, Associations, Debug, PartialEq, Insertable)] #[diesel(table_name = crate::schema::budget_updates)] #[diesel(belongs_to(Category))] pub struct BudgetUpdate { diff --git a/backend/core/src/models/category.rs b/backend/core/src/models/category.rs index 595cff6..55c7b97 100644 --- a/backend/core/src/models/category.rs +++ b/backend/core/src/models/category.rs @@ -1,7 +1,8 @@ +use derive_builder::Builder; use diesel::prelude::*; use serde::{Deserialize, Serialize}; -#[derive(Queryable, Identifiable, Selectable, Debug, PartialEq, Serialize, Deserialize, Insertable)] +#[derive(Builder, Queryable, Identifiable, Selectable, Debug, PartialEq, Serialize, Deserialize, Insertable)] #[diesel(table_name = crate::schema::categories)] pub struct Category { pub id: i32, diff --git a/backend/core/src/models/category_transfer.rs b/backend/core/src/models/category_transfer.rs index a048a07..7b36054 100644 --- a/backend/core/src/models/category_transfer.rs +++ b/backend/core/src/models/category_transfer.rs @@ -1,6 +1,7 @@ +use derive_builder::Builder; use diesel::prelude::*; -#[derive(Queryable, Identifiable, Selectable, Debug, PartialEq, Insertable)] +#[derive(Builder, Queryable, Identifiable, Selectable, Debug, PartialEq, Insertable)] #[diesel(table_name = crate::schema::category_transfers)] pub struct CategoryTransfer { pub id: i32, diff --git a/backend/core/src/models/date_time_utc.rs b/backend/core/src/models/date_time_utc.rs index 52c0cc6..d59d8f4 100644 --- a/backend/core/src/models/date_time_utc.rs +++ b/backend/core/src/models/date_time_utc.rs @@ -1,4 +1,4 @@ -use anyhow::Result; +use anyhow::{Error, Result}; use chrono::{DateTime, Datelike, Utc}; use diesel::{ backend::Backend, @@ -17,40 +17,88 @@ use serde::{Deserialize, Serialize}; PartialOrd, Serialize, Deserialize, - Copy, Clone, Debug, AsExpression, FromSqlRow, )] #[diesel(sql_type=Text)] -pub struct DateTimeUtc(DateTime<Utc>); +pub struct DateTimeUtc { + chrono_datetime_utc: DateTime<Utc>, +} impl DateTimeUtc { pub fn day_diff(&self, other: &DateTimeUtc) -> u32 { - self.0 + self.chrono_datetime_utc .num_days_from_ce() - .abs_diff(other.0.num_days_from_ce()) + .abs_diff(other.chrono_datetime_utc.num_days_from_ce()) } - pub fn to_day_str(&self) -> String { - self.0 - .to_rfc3339() - .split_at_checked(10) - .map(|(day_str, _)| String::from(day_str)) - .unwrap_or_else(|| String::from("")) + pub fn new(chrono_datetime_utc: &DateTime<Utc>) -> Self { + Self { + chrono_datetime_utc: chrono_datetime_utc.clone(), + } } - pub fn new(date_time_utc: DateTime<Utc>) -> Self { - Self(date_time_utc) + pub fn now() -> Self { + Self::new(&Utc::now()) } + /// Constructs DateTimeUtc from a day string, YYYY-MM-DD, in UTC + /// Example: "2024-10-24" -> Midnight 24 Oct 2024 UTC + pub fn from_day_str(day_str: &str) -> Result<Self> { + if !Self::is_day_str(day_str) { + Err(Error::msg(format!("{} is not a day string in YYYY-MM-DD format", day_str))) + } else { + let mut date_str = String::from(day_str); + date_str.push_str("T00:00:00.000Z"); + Ok(Self::from_date_str(&date_str)?) + } + } + + /// Constructs DateTimeUtc from a date string in ISO format, in UTC + /// Example: "2024-10-24T10:30:00.000" -> 10.30am 24 Oct 2024 UTC pub fn from_date_str(date_time_utc: &str) -> Result<Self> { - Ok(Self(date_time_utc.parse::<DateTime<Utc>>()?)) + let chrono_datetime_utc = date_time_utc.parse::<DateTime<Utc>>()?; + Ok(Self { + chrono_datetime_utc, + }) } - pub fn now() -> Self { - Self(Utc::now()) + /// Converts to a day string, YYYY-MM-DD, in UTC + /// Example: 10.30am 24 Oct 2024 UTC -> "2024-10-24" + pub fn to_day_str(&self) -> String { + let date_str = self.to_date_str(); + let day_str = date_str + .split_at_checked(10) + .unwrap() + .0; + String::from(day_str) + } + + /// Converts to a date string in ISO format, in UTC + /// Example: 10.30am 24 Oct 2024 UTC -> "2024-10-24T10:30:00.000Z" + pub fn to_date_str(&self) -> String { + self.chrono_datetime_utc.to_rfc3339() + } + + + fn is_day_str(str: &str) -> bool { + if str.len() != 10 { + return false; + } + for (ix, ch) in str.chars().enumerate() { + if ix == 4 || ix == 7 { + if ch != '-' { + return false; + } + } else { + if ch < '0' || ch > '9' { + return false; + } + } + } + return true; } } @@ -59,16 +107,15 @@ impl ToSql<Text, Sqlite> for DateTimeUtc { &'b self, out: &mut diesel::serialize::Output<'b, '_, Sqlite>, ) -> serialize::Result { - out.set_value(self.to_day_str()); - Ok(diesel::serialize::IsNull::No) + out.set_value(self.to_date_str()); + Ok(serialize::IsNull::No) } } impl FromSql<Text, Sqlite> for DateTimeUtc { fn from_sql(bytes: <Sqlite as Backend>::RawValue<'_>) -> deserialize::Result<DateTimeUtc> { - let str: String = FromSql::<Text, Sqlite>::from_sql(bytes)?; - let date_time = str.as_str().parse::<DateTime<Utc>>()?; - Ok(DateTimeUtc(date_time)) + let str = <String as FromSql<Text, Sqlite>>::from_sql(bytes)?; + Ok(Self::from_date_str(&str)?) } } @@ -80,9 +127,9 @@ mod test { #[test] fn given_midnight_when_day_diff_next_midnight_less_1s_then_return_0() { - let start = DateTimeUtc::new(Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap().to_utc()); + let start = DateTimeUtc::new(&Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap().to_utc()); let end = DateTimeUtc::new( - Utc.with_ymd_and_hms(2000, 1, 1, 23, 59, 59) + &Utc.with_ymd_and_hms(2000, 1, 1, 23, 59, 59) .unwrap() .to_utc(), ); @@ -96,8 +143,8 @@ mod test { #[test] fn given_midnight_when_day_diff_next_midnight_then_return_1() { - let start = DateTimeUtc::new(Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap().to_utc()); - let end = DateTimeUtc::new(Utc.with_ymd_and_hms(2000, 1, 2, 0, 0, 0).unwrap().to_utc()); + let start = DateTimeUtc::new(&Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap().to_utc()); + let end = DateTimeUtc::new(&Utc.with_ymd_and_hms(2000, 1, 2, 0, 0, 0).unwrap().to_utc()); let day_diff = start.day_diff(&end); let neg_day_diff = end.day_diff(&start); @@ -109,11 +156,11 @@ mod test { #[test] fn given_midnight_less_1s_when_day_diff_midnight_then_return_1() { let start = DateTimeUtc::new( - Utc.with_ymd_and_hms(2000, 1, 1, 23, 59, 59) + &Utc.with_ymd_and_hms(2000, 1, 1, 23, 59, 59) .unwrap() .to_utc(), ); - let end = DateTimeUtc::new(Utc.with_ymd_and_hms(2000, 1, 2, 0, 0, 0).unwrap().to_utc()); + let end = DateTimeUtc::new(&Utc.with_ymd_and_hms(2000, 1, 2, 0, 0, 0).unwrap().to_utc()); let day_diff = start.day_diff(&end); let neg_day_diff = end.day_diff(&start); @@ -125,12 +172,11 @@ mod test { #[test] fn given_23_nov_1970_when_to_day_str_then_return_iso_day_str() { let date_time_utc = DateTimeUtc::new( - Utc.with_ymd_and_hms(1970, 11, 23, 0, 0, 0) + &Utc.with_ymd_and_hms(1970, 11, 23, 0, 0, 0) .unwrap() .to_utc(), ); - let day_str = date_time_utc.to_day_str(); - assert_eq!(day_str, "1970-11-23"); + assert_eq!(date_time_utc.to_day_str(), "1970-11-23"); } } diff --git a/backend/core/src/models/transaction.rs b/backend/core/src/models/transaction.rs index 5f85689..edfabce 100644 --- a/backend/core/src/models/transaction.rs +++ b/backend/core/src/models/transaction.rs @@ -1,10 +1,11 @@ +use derive_builder::Builder; use diesel::prelude::*; use crate::models::account::Account; use super::date_time_utc::DateTimeUtc; -#[derive(Queryable, Identifiable, Selectable, Insertable, Associations, Debug, PartialEq)] +#[derive(Builder, Queryable, Identifiable, Selectable, Insertable, Associations, Debug, PartialEq)] #[diesel(table_name = crate::schema::transactions)] #[diesel(belongs_to(Account))] pub struct Transaction { diff --git a/backend/core/src/models/transaction_categorisation.rs b/backend/core/src/models/transaction_categorisation.rs index 45591a5..c6ac6ea 100644 --- a/backend/core/src/models/transaction_categorisation.rs +++ b/backend/core/src/models/transaction_categorisation.rs @@ -1,6 +1,7 @@ +use derive_builder::Builder; use diesel::prelude::*; -#[derive(Queryable, Identifiable, Selectable, Insertable, Debug, PartialEq)] +#[derive(Builder, Queryable, Identifiable, Selectable, Insertable, Debug, PartialEq)] #[diesel(table_name = crate::schema::transaction_categorisations)] pub struct TransactionCategorisation { pub id: i32, diff --git a/backend/core/src/queries/category_transfers/get_all.rs b/backend/core/src/queries/category_transfers/get_all.rs new file mode 100644 index 0000000..73d7e10 --- /dev/null +++ b/backend/core/src/queries/category_transfers/get_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use crate::{models::category_transfer::CategoryTransfer, schema::category_transfers::dsl::category_transfers as category_transfers_table}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +pub fn get_all_category_transfers(connection: &mut SqliteConnection) -> Result<Vec<CategoryTransfer>> { + let all_category_transfers = category_transfers_table + .select(CategoryTransfer::as_select()) + .load(connection) + .with_context(|| "failed to get all category transfers")?; + Ok(all_category_transfers) +} diff --git a/backend/core/src/queries/category_transfers/mod.rs b/backend/core/src/queries/category_transfers/mod.rs index 68f32f4..eed7946 100644 --- a/backend/core/src/queries/category_transfers/mod.rs +++ b/backend/core/src/queries/category_transfers/mod.rs @@ -1,9 +1,11 @@ mod delete_all; +mod get_all; mod insert; mod sum_quantity_per_from_category_id; mod sum_quantity_per_to_category_id; pub use delete_all::delete_all_category_transfers; +pub use get_all::get_all_category_transfers; pub use insert::insert_category_transfers; pub use sum_quantity_per_from_category_id::sum_category_transfer_quantity_per_from_category_id; pub use sum_quantity_per_to_category_id::sum_category_transfer_quantity_per_to_category_id; diff --git a/backend/core/src/queries/clear.rs b/backend/core/src/queries/clear.rs index dbe0f84..e704634 100644 --- a/backend/core/src/queries/clear.rs +++ b/backend/core/src/queries/clear.rs @@ -1,3 +1,4 @@ +use anyhow::Result; use crate::queries::{ accounts::delete_all_accounts, budget_updates::delete_all_budget_updates, @@ -6,9 +7,9 @@ use crate::queries::{ transactions::delete_all_transactions, transaction_categorisations::delete_all_transaction_categorisations, }; -use diesel::{result::Error, SqliteConnection}; +use diesel::SqliteConnection; -pub fn clear(connection: &mut SqliteConnection) -> Result<(), Error> { +pub fn clear(connection: &mut SqliteConnection) -> Result<()> { delete_all_accounts(connection)?; delete_all_budget_updates(connection)?; delete_all_categories(connection)?; diff --git a/backend/core/src/queries/transaction_categorisations/get_all.rs b/backend/core/src/queries/transaction_categorisations/get_all.rs new file mode 100644 index 0000000..0cacfe6 --- /dev/null +++ b/backend/core/src/queries/transaction_categorisations/get_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use crate::{models::transaction_categorisation::TransactionCategorisation, schema::transaction_categorisations::dsl::transaction_categorisations as transaction_categorisations_table}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +pub fn get_all_transaction_categorisations(connection: &mut SqliteConnection) -> Result<Vec<TransactionCategorisation>> { + let all_transaction_categorisations = transaction_categorisations_table + .select(TransactionCategorisation::as_select()) + .load(connection) + .with_context(|| "failed to get all transaction categorisations")?; + Ok(all_transaction_categorisations) +} diff --git a/backend/core/src/queries/transaction_categorisations/mod.rs b/backend/core/src/queries/transaction_categorisations/mod.rs index 3664fa6..d383791 100644 --- a/backend/core/src/queries/transaction_categorisations/mod.rs +++ b/backend/core/src/queries/transaction_categorisations/mod.rs @@ -1,7 +1,9 @@ mod delete_all; +mod get_all; mod insert; mod sum_quantity_per_category_id; pub use delete_all::delete_all_transaction_categorisations; +pub use get_all::get_all_transaction_categorisations; pub use insert::insert_transaction_categorisations; pub use sum_quantity_per_category_id::sum_transaction_categorisation_quantity_per_category_id; diff --git a/backend/core/src/queries/transactions/get_all.rs b/backend/core/src/queries/transactions/get_all.rs new file mode 100644 index 0000000..afb87f4 --- /dev/null +++ b/backend/core/src/queries/transactions/get_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use crate::{models::transaction::Transaction, schema::transactions::dsl::transactions as transactions_table}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +pub fn get_all_transactions(connection: &mut SqliteConnection) -> Result<Vec<Transaction>> { + let all_transactions = transactions_table + .select(Transaction::as_select()) + .load(connection) + .with_context(|| "failed to get all category transfers")?; + Ok(all_transactions) +} diff --git a/backend/core/src/queries/transactions/mod.rs b/backend/core/src/queries/transactions/mod.rs index 40855f3..983e9af 100644 --- a/backend/core/src/queries/transactions/mod.rs +++ b/backend/core/src/queries/transactions/mod.rs @@ -1,5 +1,7 @@ mod delete_all; +mod get_all; mod insert; pub use delete_all::delete_all_transactions; +pub use get_all::get_all_transactions; pub use insert::insert_transactions; diff --git a/backend/core/src/utils/calculate_budgets_accrual.rs b/backend/core/src/utils/calculate_budgets_accrual.rs index bbc197c..22061ee 100644 --- a/backend/core/src/utils/calculate_budgets_accrual.rs +++ b/backend/core/src/utils/calculate_budgets_accrual.rs @@ -9,7 +9,7 @@ pub fn calculate_budgets_accrual(category: &Category, budget_updates: &[BudgetUp .iter() .filter(|bu| bu.category_id == category.id) .collect::<Vec<&BudgetUpdate>>(); - budget_updates.sort_by_key(|bu| bu.date); + budget_updates.sort_by_key(|bu| bu.date.clone()); budget_updates.reverse(); let mut budgets_accrual = 0.0_f64; @@ -22,7 +22,7 @@ pub fn calculate_budgets_accrual(category: &Category, budget_updates: &[BudgetUp } let budget_per_day = budget_update.new_budget as f64 / budget_update.new_period as f64; budgets_accrual += days_on_this_budget as f64 * budget_per_day; - calculated_back_to_date = budget_update.date; + calculated_back_to_date = budget_update.date.clone(); } budgets_accrual.floor() as i64 @@ -78,7 +78,7 @@ mod test { let budget_updates = [BudgetUpdate { id: 0, category_id: 0, - date: DateTimeUtc::new(Utc::now().checked_sub_days(Days::new(120)).unwrap()), + date: DateTimeUtc::new(&Utc::now().checked_sub_days(Days::new(120)).unwrap()), new_budget: 100, new_period: 1, }]; @@ -98,14 +98,14 @@ mod test { BudgetUpdate { id: 0, category_id: 0, - date: DateTimeUtc::new(Utc::now().checked_sub_days(Days::new(60)).unwrap()), + date: DateTimeUtc::new(&Utc::now().checked_sub_days(Days::new(60)).unwrap()), new_budget: 200, new_period: 1, }, BudgetUpdate { id: 0, category_id: 0, - date: DateTimeUtc::new(Utc::now().checked_sub_days(Days::new(120)).unwrap()), + date: DateTimeUtc::new(&Utc::now().checked_sub_days(Days::new(120)).unwrap()), new_budget: 100, new_period: 1, }, @@ -127,7 +127,7 @@ mod test { id: 0, category_id: 0, date: DateTimeUtc::new( - Utc::now() + &Utc::now() .checked_sub_days(Days::new(120)) .unwrap() .with_hour(13) @@ -140,7 +140,7 @@ mod test { id: 0, category_id: 0, date: DateTimeUtc::new( - Utc::now() + &Utc::now() .checked_sub_days(Days::new(120)) .unwrap() .with_hour(12) diff --git a/backend/core/src/utils/calculate_category_balance.rs b/backend/core/src/utils/calculate_category_balance.rs index 5eca05b..e461cee 100644 --- a/backend/core/src/utils/calculate_category_balance.rs +++ b/backend/core/src/utils/calculate_category_balance.rs @@ -51,7 +51,7 @@ mod test { let budget_updates = [BudgetUpdate { id: 0, category_id: 1, - date: DateTimeUtc::new(Utc::now().checked_sub_days(Days::new(120)).unwrap()), + date: DateTimeUtc::new(&Utc::now().checked_sub_days(Days::new(120)).unwrap()), new_budget: 77, new_period: 1, }]; @@ -123,7 +123,7 @@ mod test { let budget_updates = [BudgetUpdate { id: 0, category_id: 0, - date: DateTimeUtc::new(Utc::now().checked_sub_days(Days::new(120)).unwrap()), + date: DateTimeUtc::new(&Utc::now().checked_sub_days(Days::new(120)).unwrap()), new_budget: 77, new_period: 1, }]; diff --git a/backend/core/tests/common/fakes/account.rs b/backend/core/tests/common/fakes/account.rs new file mode 100644 index 0000000..e915aed --- /dev/null +++ b/backend/core/tests/common/fakes/account.rs @@ -0,0 +1,10 @@ +use budgeting_app_core::models::{account::Account, date_time_utc::DateTimeUtc}; + +pub fn make_fake_account(id: i32) -> Account { + Account { + id, + name: String::from("Joe Bloggs"), + opening_balance: 0, + opening_date: DateTimeUtc::now(), + } +} diff --git a/backend/core/tests/common/fakes/budget_update.rs b/backend/core/tests/common/fakes/budget_update.rs new file mode 100644 index 0000000..e7ee9b9 --- /dev/null +++ b/backend/core/tests/common/fakes/budget_update.rs @@ -0,0 +1,16 @@ +use budgeting_app_core::models::{budget_update::{BudgetUpdate, BudgetUpdateBuilder}, date_time_utc::DateTimeUtc}; + +pub fn make_fake_budget_update(id: i32) -> BudgetUpdate { + make_fake_budget_update_builder(id).build().unwrap() +} + +pub fn make_fake_budget_update_builder(id: i32) -> BudgetUpdateBuilder { + let mut builder = BudgetUpdateBuilder::default(); + builder + .id(id) + .category_id(0) + .date(DateTimeUtc::now()) + .new_budget(0) + .new_period(0); + builder +} diff --git a/backend/core/tests/common/fakes/category.rs b/backend/core/tests/common/fakes/category.rs new file mode 100644 index 0000000..27a027e --- /dev/null +++ b/backend/core/tests/common/fakes/category.rs @@ -0,0 +1,13 @@ +use budgeting_app_core::models::category::{Category, CategoryBuilder}; + +pub fn make_fake_category(id: i32) -> Category { + make_fake_category_builder(id).build().unwrap() +} + +pub fn make_fake_category_builder(id: i32) -> CategoryBuilder { + let mut builder = CategoryBuilder::default(); + builder + .id(id) + .name(String::from("Fake category")); + builder +} diff --git a/backend/core/tests/common/fakes/category_transfer.rs b/backend/core/tests/common/fakes/category_transfer.rs new file mode 100644 index 0000000..66496f3 --- /dev/null +++ b/backend/core/tests/common/fakes/category_transfer.rs @@ -0,0 +1,16 @@ +use budgeting_app_core::models::category_transfer::{CategoryTransfer, CategoryTransferBuilder}; + +pub fn make_fake_category_transfer(id: i32) -> CategoryTransfer { + make_fake_category_transfer_builder(id).build().unwrap() +} + +pub fn make_fake_category_transfer_builder(id: i32) -> CategoryTransferBuilder { + let mut builder = CategoryTransferBuilder::default(); + builder + .id(id) + .description(String::from("Fake category transfer")) + .quantity(0) + .from_category_id(0) + .to_category_id(1); + builder +} diff --git a/backend/core/tests/common/fakes/mod.rs b/backend/core/tests/common/fakes/mod.rs new file mode 100644 index 0000000..68f5209 --- /dev/null +++ b/backend/core/tests/common/fakes/mod.rs @@ -0,0 +1,6 @@ +pub mod account; +pub mod budget_update; +pub mod category; +pub mod category_transfer; +pub mod transaction; +pub mod transaction_categorisation; diff --git a/backend/core/tests/common/fakes/transaction.rs b/backend/core/tests/common/fakes/transaction.rs new file mode 100644 index 0000000..d113ce5 --- /dev/null +++ b/backend/core/tests/common/fakes/transaction.rs @@ -0,0 +1,17 @@ +use budgeting_app_core::models::{date_time_utc::DateTimeUtc, transaction::{Transaction, TransactionBuilder}}; + +pub fn make_fake_transaction(id: i32) -> Transaction { + make_fake_transaction_builder(id).build().unwrap() +} + +pub fn make_fake_transaction_builder(id: i32) -> TransactionBuilder { + let mut builder = TransactionBuilder::default(); + builder + .id(id) + .description(String::from("Fake category transfer")) + .payee(String::from("Fake payee")) + .quantity(0) + .date(DateTimeUtc::now()) + .account_id(0); + builder +} diff --git a/backend/core/tests/common/fakes/transaction_categorisation.rs b/backend/core/tests/common/fakes/transaction_categorisation.rs new file mode 100644 index 0000000..9ddd684 --- /dev/null +++ b/backend/core/tests/common/fakes/transaction_categorisation.rs @@ -0,0 +1,16 @@ +use budgeting_app_core::models::transaction_categorisation::{TransactionCategorisation, TransactionCategorisationBuilder}; + +pub fn make_fake_transaction_categorisation(id: i32) -> TransactionCategorisation { + make_fake_transaction_categorisation_builder(id).build().unwrap() +} + +pub fn make_fake_transaction_categorisation_builder(id: i32) -> TransactionCategorisationBuilder { + let mut builder = TransactionCategorisationBuilder::default(); + builder + .id(id) + .description(String::from("Fake category transfer")) + .quantity(0) + .transaction_id(0) + .category_id(0); + builder +} diff --git a/backend/core/tests/common/mod.rs b/backend/core/tests/common/mod.rs new file mode 100644 index 0000000..6681d3d --- /dev/null +++ b/backend/core/tests/common/mod.rs @@ -0,0 +1,2 @@ +pub mod fakes; +pub mod test_context; diff --git a/backend/core/tests/common/test_context.rs b/backend/core/tests/common/test_context.rs new file mode 100644 index 0000000..f6142b0 --- /dev/null +++ b/backend/core/tests/common/test_context.rs @@ -0,0 +1,43 @@ +use std::sync::atomic::{AtomicU64, Ordering}; + +use budgeting_app_core::{queries::clear::clear, MIGRATIONS}; +use diesel::{Connection, SqliteConnection}; +use diesel_migrations::MigrationHarness; + +pub struct TestContext { + pub db_url: String, +} + +static ID_COUNTER: AtomicU64 = AtomicU64::new(0); + +impl TestContext { + pub fn new() -> Self { + let db_url = Self::next_id() + ".sqlite"; + + let connection = &mut SqliteConnection + ::establish(&db_url) + .expect("failed to connect to database"); + + connection + .run_pending_migrations(MIGRATIONS) + .expect("failed to run migrations"); + + clear(connection) + .expect("failed to clear database"); + + Self { + db_url, + } + } + + fn next_id() -> String { + ID_COUNTER.fetch_add(1, Ordering::Relaxed).to_string() + } +} + +impl Drop for TestContext { + fn drop(&mut self) { + std::fs::remove_file(&self.db_url) + .expect(format!("failed to delete database {}", self.db_url).as_str()); + } +} diff --git a/backend/core/tests/main.rs b/backend/core/tests/main.rs new file mode 100644 index 0000000..27409b6 --- /dev/null +++ b/backend/core/tests/main.rs @@ -0,0 +1,4 @@ +pub mod common; + +mod models; +mod queries; diff --git a/backend/core/tests/models/date_time_utc.rs b/backend/core/tests/models/date_time_utc.rs new file mode 100644 index 0000000..1f86968 --- /dev/null +++ b/backend/core/tests/models/date_time_utc.rs @@ -0,0 +1,59 @@ +use anyhow::Result; +use budgeting_app_core::models::date_time_utc::DateTimeUtc; +use diesel::{sql_query, Connection, ExpressionMethods, QueryDsl, RunQueryDsl, Selectable, SelectableHelper, SqliteConnection}; +use diesel::prelude::{Insertable, Queryable}; + +use crate::common::test_context::TestContext; + +diesel::table! { + date_time_utc_test (id) { + id -> Integer, + date_time_utc -> Text, + } +} + +#[derive(Insertable, Queryable, Selectable, Clone)] +#[diesel(table_name = date_time_utc_test)] +pub struct DateTimeUtcTest { + pub id: i32, + pub date_time_utc: DateTimeUtc, +} + +fn new_test_context() -> Result<TestContext> { + let test_context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&test_context.db_url)?; + let query = "CREATE TABLE date_time_utc_test(id INTEGER PRIMARY KEY, date_time_utc TEXT);"; + sql_query(query).execute(connection)?; + Ok(test_context) +} + +fn insert_date_time_utc(id: i32, date_time_utc: &DateTimeUtc, connection: &mut SqliteConnection) -> Result<usize> { + let model = DateTimeUtcTest { + id, + date_time_utc: date_time_utc.clone(), + }; + let num_rows_inserted = diesel::insert_into(date_time_utc_test::dsl::date_time_utc_test) + .values(&[model]) + .execute(connection)?; + Ok(num_rows_inserted) +} + +fn get_date_time_utc(id: i32, connection: &mut SqliteConnection) -> Result<DateTimeUtcTest> { + let date_time_utc: Vec<DateTimeUtcTest> = date_time_utc_test::dsl::date_time_utc_test + .select(DateTimeUtcTest::as_select()) + .filter(date_time_utc_test::id.eq(id)) + .load(connection)?; + Ok(date_time_utc[0].clone()) +} + +#[test] +fn when_insert_date_time_utc_and_select_then_returns_original_value() -> Result<()> { + let date_time_utc = DateTimeUtc::now(); + let test_context = new_test_context()?; + let connection = &mut SqliteConnection::establish(&test_context.db_url)?; + let num_rows_inserted = insert_date_time_utc(0, &date_time_utc, connection)?; + assert_eq!(num_rows_inserted, 1); + let date_time_utc_returned = get_date_time_utc(0, connection)?; + assert_eq!(date_time_utc_returned.date_time_utc.to_date_str(), date_time_utc.to_date_str()); + Ok(()) +} diff --git a/backend/core/tests/models/mod.rs b/backend/core/tests/models/mod.rs new file mode 100644 index 0000000..5837dcd --- /dev/null +++ b/backend/core/tests/models/mod.rs @@ -0,0 +1 @@ +mod date_time_utc; diff --git a/backend/core/tests/queries/account.rs b/backend/core/tests/queries/account.rs new file mode 100644 index 0000000..4fd9e99 --- /dev/null +++ b/backend/core/tests/queries/account.rs @@ -0,0 +1,58 @@ +use budgeting_app_core::queries; +use diesel::{Connection, SqliteConnection}; + +use crate::common::{fakes::account::make_fake_account, test_context::TestContext}; + +#[test] +fn when_insert_accounts_then_returns_num_accounts() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let accounts = [make_fake_account(0), make_fake_account(1)]; + + let num_accounts_inserted = queries::accounts::insert_accounts(&accounts, connection).unwrap(); + + assert_eq!(num_accounts_inserted, 2); +} + +#[test] +fn given_accounts_when_get_all_accounts_then_return_accounts() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let accounts = [make_fake_account(0), make_fake_account(1)]; + let _ = queries::accounts::insert_accounts(&accounts, connection).unwrap(); + + let accounts_in_db = queries::accounts::get_all_accounts(connection).unwrap(); + + assert_eq!(accounts_in_db.len(), accounts.len()); + for account in &accounts { + assert!(accounts_in_db.iter().any(|account_in_db| account_in_db.eq(&account))); + } + for account_in_db in accounts_in_db { + assert!(accounts.iter().any(|account| account.eq(&account_in_db))); + } +} + +#[test] +fn given_accounts_when_delete_all_accounts_then_return_num_of_accounts() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let accounts = [make_fake_account(0), make_fake_account(1)]; + let _ = queries::accounts::insert_accounts(&accounts, connection).unwrap(); + + let num_accounts_deleted = queries::accounts::delete_all_accounts(connection).unwrap(); + + assert_eq!(num_accounts_deleted, accounts.len()); +} + +#[test] +fn given_deleted_accounts_when_get_all_accounts_then_return_empty() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let accounts = [make_fake_account(0), make_fake_account(1)]; + let _ = queries::accounts::insert_accounts(&accounts, connection).unwrap(); + let _ = queries::accounts::delete_all_accounts(connection).unwrap(); + + let accounts_returned = queries::accounts::get_all_accounts(connection).unwrap(); + + assert_eq!(accounts_returned.len(), 0); +} diff --git a/backend/core/tests/queries/budget_updates.rs b/backend/core/tests/queries/budget_updates.rs new file mode 100644 index 0000000..147d06f --- /dev/null +++ b/backend/core/tests/queries/budget_updates.rs @@ -0,0 +1,78 @@ +use budgeting_app_core::queries; +use diesel::{Connection, SqliteConnection}; + +use crate::common::{fakes::{budget_update::make_fake_budget_update_builder, category::make_fake_category}, test_context::TestContext}; + +#[test] +fn when_insert_budget_updates_then_returns_num_budget_updates() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0)]; + let budget_updates = [ + make_fake_budget_update_builder(0).category_id(0).build().unwrap(), + make_fake_budget_update_builder(1).category_id(0).build().unwrap(), + ]; + let _ = queries::categories::insert_categories(&categories, connection); + + let num_budget_updates_inserted = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap(); + + assert_eq!(num_budget_updates_inserted, 2); +} + +#[test] +fn given_budget_updates_when_get_all_budget_updates_then_return_budget_updates() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0)]; + let budget_updates = [ + make_fake_budget_update_builder(0).category_id(0).build().unwrap(), + make_fake_budget_update_builder(1).category_id(0).build().unwrap(), + ]; + let _ = queries::categories::insert_categories(&categories, connection); + let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap(); + + let budget_updates_in_db = queries::budget_updates::get_all_budget_updates(connection).unwrap(); + + assert_eq!(budget_updates_in_db.len(), budget_updates.len()); + for budget_update in &budget_updates { + assert!(budget_updates_in_db.iter().any(|budget_update_in_db| budget_update_in_db.eq(&budget_update))); + } + for budget_update_in_db in budget_updates_in_db { + assert!(budget_updates.iter().any(|budget_update| budget_update.eq(&budget_update_in_db))); + } +} + +#[test] +fn given_budget_updates_when_delete_all_budget_updates_then_return_num_of_budget_updates() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0)]; + let budget_updates = [ + make_fake_budget_update_builder(0).category_id(0).build().unwrap(), + make_fake_budget_update_builder(1).category_id(0).build().unwrap(), + ]; + let _ = queries::categories::insert_categories(&categories, connection); + let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap(); + + let num_budget_updates_deleted = queries::budget_updates::delete_all_budget_updates(connection).unwrap(); + + assert_eq!(num_budget_updates_deleted, budget_updates.len()); +} + +#[test] +fn given_deleted_budget_updates_when_get_all_budget_updates_then_return_empty() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0)]; + let budget_updates = [ + make_fake_budget_update_builder(0).category_id(0).build().unwrap(), + make_fake_budget_update_builder(1).category_id(0).build().unwrap(), + ]; + let _ = queries::categories::insert_categories(&categories, connection); + let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap(); + let _ = queries::budget_updates::delete_all_budget_updates(connection).unwrap(); + + let budget_updates_returned = queries::budget_updates::get_all_budget_updates(connection).unwrap(); + + assert_eq!(budget_updates_returned.len(), 0); +} diff --git a/backend/core/tests/queries/categories.rs b/backend/core/tests/queries/categories.rs new file mode 100644 index 0000000..917536e --- /dev/null +++ b/backend/core/tests/queries/categories.rs @@ -0,0 +1,58 @@ +use budgeting_app_core::queries; +use diesel::{Connection, SqliteConnection}; + +use crate::common::{fakes::category::make_fake_category, test_context::TestContext}; + +#[test] +fn when_insert_categories_then_returns_num_categories() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0), make_fake_category(1)]; + + let num_categories_inserted = queries::categories::insert_categories(&categories, connection).unwrap(); + + assert_eq!(num_categories_inserted, 2); +} + +#[test] +fn given_categories_when_get_all_categories_then_return_categories() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0), make_fake_category(1)]; + let _ = queries::categories::insert_categories(&categories, connection).unwrap(); + + let categories_in_db = queries::categories::get_all_categories(connection).unwrap(); + + assert_eq!(categories_in_db.len(), categories.len()); + for category in &categories { + assert!(categories_in_db.iter().any(|category_in_db| category_in_db.eq(&category))); + } + for category_in_db in categories_in_db { + assert!(categories.iter().any(|category| category.eq(&category_in_db))); + } +} + +#[test] +fn given_categories_when_delete_all_categories_then_return_num_of_categories() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0), make_fake_category(1)]; + let _ = queries::categories::insert_categories(&categories, connection).unwrap(); + + let num_categories_deleted = queries::categories::delete_all_categories(connection).unwrap(); + + assert_eq!(num_categories_deleted, categories.len()); +} + +#[test] +fn given_deleted_categories_when_get_all_categories_then_return_empty() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0), make_fake_category(1)]; + let _ = queries::categories::insert_categories(&categories, connection).unwrap(); + let _ = queries::categories::delete_all_categories(connection).unwrap(); + + let categories_returned = queries::categories::get_all_categories(connection).unwrap(); + + assert_eq!(categories_returned.len(), 0); +} diff --git a/backend/core/tests/queries/category_transfers.rs b/backend/core/tests/queries/category_transfers.rs new file mode 100644 index 0000000..d329d9c --- /dev/null +++ b/backend/core/tests/queries/category_transfers.rs @@ -0,0 +1,78 @@ +use budgeting_app_core::queries; +use diesel::{Connection, SqliteConnection}; + +use crate::common::{fakes::{category::make_fake_category, category_transfer::make_fake_category_transfer_builder}, test_context::TestContext}; + +#[test] +fn when_insert_category_transfers_then_returns_num_category_transfers() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0), make_fake_category(1)]; + let category_transfers = [ + make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(), + make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(), + ]; + let _ = queries::categories::insert_categories(&categories, connection); + + let num_category_transfers_inserted = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap(); + + assert_eq!(num_category_transfers_inserted, 2); +} + +#[test] +fn given_category_transfers_when_get_all_category_transfers_then_return_category_transfers() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0), make_fake_category(1)]; + let category_transfers = [ + make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(), + make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(), + ]; + let _ = queries::categories::insert_categories(&categories, connection); + let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap(); + + let category_transfers_in_db = queries::category_transfers::get_all_category_transfers(connection).unwrap(); + + assert_eq!(category_transfers_in_db.len(), category_transfers.len()); + for category_transfer in &category_transfers { + assert!(category_transfers_in_db.iter().any(|category_transfer_in_db| category_transfer_in_db.eq(&category_transfer))); + } + for category_transfer_in_db in category_transfers_in_db { + assert!(category_transfers.iter().any(|category_transfer| category_transfer.eq(&category_transfer_in_db))); + } +} + +#[test] +fn given_category_transfers_when_delete_all_category_transfers_then_return_num_of_category_transfers() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0), make_fake_category(1)]; + let category_transfers = [ + make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(), + make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(), + ]; + let _ = queries::categories::insert_categories(&categories, connection); + let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap(); + + let num_category_transfers_deleted = queries::category_transfers::delete_all_category_transfers(connection).unwrap(); + + assert_eq!(num_category_transfers_deleted, category_transfers.len()); +} + +#[test] +fn given_deleted_category_transfers_when_get_all_category_transfers_then_return_empty() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = [make_fake_category(0), make_fake_category(1)]; + let category_transfers = [ + make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(), + make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(), + ]; + let _ = queries::categories::insert_categories(&categories, connection); + let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap(); + let _ = queries::category_transfers::delete_all_category_transfers(connection).unwrap(); + + let category_transfers_returned = queries::category_transfers::get_all_category_transfers(connection).unwrap(); + + assert_eq!(category_transfers_returned.len(), 0); +} diff --git a/backend/core/tests/queries/mod.rs b/backend/core/tests/queries/mod.rs new file mode 100644 index 0000000..e421934 --- /dev/null +++ b/backend/core/tests/queries/mod.rs @@ -0,0 +1,6 @@ +mod account; +mod budget_updates; +mod categories; +mod category_transfers; +mod transaction_categorisations; +mod transactions; diff --git a/backend/core/tests/queries/transaction_categorisations.rs b/backend/core/tests/queries/transaction_categorisations.rs new file mode 100644 index 0000000..3c2171d --- /dev/null +++ b/backend/core/tests/queries/transaction_categorisations.rs @@ -0,0 +1,86 @@ +use budgeting_app_core::queries; +use diesel::{Connection, SqliteConnection}; + +use crate::common::{fakes::{account::make_fake_account, category::make_fake_category, transaction::make_fake_transaction_builder, transaction_categorisation::make_fake_transaction_categorisation_builder}, test_context::TestContext}; + +fn insert_prerequisite_data(connection: &mut SqliteConnection) { + let accounts = [make_fake_account(0)]; + let categories = [make_fake_category(0)]; + let transactions = [ + make_fake_transaction_builder(0).account_id(0).build().unwrap(), + make_fake_transaction_builder(1).account_id(0).build().unwrap(), + ]; + let _ = queries::accounts::insert_accounts(&accounts, connection); + let _ = queries::categories::insert_categories(&categories, connection); + let _ = queries::transactions::insert_transactions(&transactions, connection); +} + +#[test] +fn when_insert_transaction_categorisations_then_returns_num_transaction_categorisations() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + insert_prerequisite_data(connection); + let transaction_categorisations = [ + make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(), + make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(), + ]; + + let num_transaction_categorisations_inserted = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection).unwrap(); + + assert_eq!(num_transaction_categorisations_inserted, 2); +} + +#[test] +fn given_transaction_categorisations_when_get_all_transaction_categorisations_then_return_transaction_categorisations() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + insert_prerequisite_data(connection); + let transaction_categorisations = [ + make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(), + make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(), + ]; + let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection); + + let transaction_categorisations_in_db = queries::transaction_categorisations::get_all_transaction_categorisations(connection).unwrap(); + + assert_eq!(transaction_categorisations_in_db.len(), transaction_categorisations.len()); + for transaction_categorisation in &transaction_categorisations { + assert!(transaction_categorisations_in_db.iter().any(|transaction_categorisation_in_db| transaction_categorisation_in_db.eq(&transaction_categorisation))); + } + for transaction_categorisation_in_db in transaction_categorisations_in_db { + assert!(transaction_categorisations.iter().any(|transaction_categorisation| transaction_categorisation.eq(&transaction_categorisation_in_db))); + } +} + +#[test] +fn given_transaction_categorisations_when_delete_all_transaction_categorisations_then_return_num_of_transaction_categorisations() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + insert_prerequisite_data(connection); + let transaction_categorisations = [ + make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(), + make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(), + ]; + let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection); + + let num_transaction_categorisations_deleted = queries::transaction_categorisations::delete_all_transaction_categorisations(connection).unwrap(); + + assert_eq!(num_transaction_categorisations_deleted, transaction_categorisations.len()); +} + +#[test] +fn given_deleted_transaction_categorisations_when_get_all_transaction_categorisations_then_return_empty() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + insert_prerequisite_data(connection); + let transaction_categorisations = [ + make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(), + make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(), + ]; + let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection); + let _ = queries::transaction_categorisations::delete_all_transaction_categorisations(connection); + + let transaction_categorisations_returned = queries::transaction_categorisations::get_all_transaction_categorisations(connection).unwrap(); + + assert_eq!(transaction_categorisations_returned.len(), 0); +} diff --git a/backend/core/tests/queries/transactions.rs b/backend/core/tests/queries/transactions.rs new file mode 100644 index 0000000..406f5a8 --- /dev/null +++ b/backend/core/tests/queries/transactions.rs @@ -0,0 +1,78 @@ +use budgeting_app_core::queries; +use diesel::{Connection, SqliteConnection}; + +use crate::common::{fakes::{account::make_fake_account, transaction::make_fake_transaction_builder}, test_context::TestContext}; + +#[test] +fn when_insert_transactions_then_returns_num_transactions() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let accounts = [make_fake_account(0)]; + let transactions = [ + make_fake_transaction_builder(0).account_id(0).build().unwrap(), + make_fake_transaction_builder(1).account_id(0).build().unwrap(), + ]; + let _ = queries::accounts::insert_accounts(&accounts, connection); + + let num_transactions_inserted = queries::transactions::insert_transactions(&transactions, connection).unwrap(); + + assert_eq!(num_transactions_inserted, 2); +} + +#[test] +fn given_transactions_when_get_all_transactions_then_return_transactions() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let accounts = [make_fake_account(0)]; + let transactions = [ + make_fake_transaction_builder(0).account_id(0).build().unwrap(), + make_fake_transaction_builder(1).account_id(0).build().unwrap(), + ]; + let _ = queries::accounts::insert_accounts(&accounts, connection); + let _ = queries::transactions::insert_transactions(&transactions, connection).unwrap(); + + let transactions_in_db = queries::transactions::get_all_transactions(connection).unwrap(); + + assert_eq!(transactions_in_db.len(), transactions.len()); + for transaction in &transactions { + assert!(transactions_in_db.iter().any(|transaction_in_db| transaction_in_db.eq(&transaction))); + } + for transaction_in_db in transactions_in_db { + assert!(transactions.iter().any(|transaction| transaction.eq(&transaction_in_db))); + } +} + +#[test] +fn given_transactions_when_delete_all_transactions_then_return_num_of_transactions() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let accounts = [make_fake_account(0)]; + let transactions = [ + make_fake_transaction_builder(0).account_id(0).build().unwrap(), + make_fake_transaction_builder(1).account_id(0).build().unwrap(), + ]; + let _ = queries::accounts::insert_accounts(&accounts, connection); + let _ = queries::transactions::insert_transactions(&transactions, connection).unwrap(); + + let num_transactions_deleted = queries::transactions::delete_all_transactions(connection).unwrap(); + + assert_eq!(num_transactions_deleted, transactions.len()); +} + +#[test] +fn given_deleted_transactions_when_get_all_transactions_then_return_empty() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let accounts = [make_fake_account(0)]; + let transactions = [ + make_fake_transaction_builder(0).account_id(0).build().unwrap(), + make_fake_transaction_builder(1).account_id(0).build().unwrap(), + ]; + let _ = queries::accounts::insert_accounts(&accounts, connection); + let _ = queries::transactions::insert_transactions(&transactions, connection).unwrap(); + let _ = queries::transactions::delete_all_transactions(connection).unwrap(); + + let transactions_returned = queries::transactions::get_all_transactions(connection).unwrap(); + + assert_eq!(transactions_returned.len(), 0); +} |