From 10f071447594f2bdcec84a461df9ad648f71f44b Mon Sep 17 00:00:00 2001 From: Joe Carstairs Date: Sun, 17 Nov 2024 09:29:32 +0000 Subject: Renames app to 'schist' --- rust/core/tests/queries/account.rs | 58 ---- rust/core/tests/queries/budget_updates.rs | 354 --------------------- rust/core/tests/queries/categories.rs | 218 ------------- rust/core/tests/queries/category_transfers.rs | 124 -------- rust/core/tests/queries/mod.rs | 6 - .../tests/queries/transaction_categorisations.rs | 127 -------- rust/core/tests/queries/transactions.rs | 78 ----- 7 files changed, 965 deletions(-) delete mode 100644 rust/core/tests/queries/account.rs delete mode 100644 rust/core/tests/queries/budget_updates.rs delete mode 100644 rust/core/tests/queries/categories.rs delete mode 100644 rust/core/tests/queries/category_transfers.rs delete mode 100644 rust/core/tests/queries/mod.rs delete mode 100644 rust/core/tests/queries/transaction_categorisations.rs delete mode 100644 rust/core/tests/queries/transactions.rs (limited to 'rust/core/tests/queries') diff --git a/rust/core/tests/queries/account.rs b/rust/core/tests/queries/account.rs deleted file mode 100644 index 4fd9e99..0000000 --- a/rust/core/tests/queries/account.rs +++ /dev/null @@ -1,58 +0,0 @@ -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/rust/core/tests/queries/budget_updates.rs b/rust/core/tests/queries/budget_updates.rs deleted file mode 100644 index 6641b25..0000000 --- a/rust/core/tests/queries/budget_updates.rs +++ /dev/null @@ -1,354 +0,0 @@ -use budgeting_app_core::{models::{category::Category, date_utc::DateUtc}, queries, traits::nowlike::Nowlike}; -use diesel::{Connection, SqliteConnection}; - -use crate::common::{fakes::{budget_update::make_fake_budget_update_builder, category::make_fake_category}, test_context::TestContext}; - -fn given_categories(connection: &mut SqliteConnection) -> Vec { - let categories = vec![make_fake_category(0), make_fake_category(1)]; - let _ = queries::categories::insert_categories(&categories, connection); - categories -} - -#[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 = given_categories(connection); - let budget_updates = [ - make_fake_budget_update_builder(0) - .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) - .category_id(0) - .build().unwrap(), - make_fake_budget_update_builder(1) - .date(DateUtc::from_ymd(2020, 12, 26).unwrap()) - .category_id(0) - .build().unwrap(), - ]; - - 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_update_when_insert_budget_update_same_category_and_same_date_then_return_err() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let _categories = given_categories(connection); - - let budget_updates_1 = [ - make_fake_budget_update_builder(0) - .category_id(0) - .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) - .build().unwrap() - ]; - let _ = queries::budget_updates::insert_budget_updates(&budget_updates_1, connection); - - let budget_updates_2 = [ - make_fake_budget_update_builder(1) - .category_id(0) - .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) - .build().unwrap() - ]; - let result = queries::budget_updates::insert_budget_updates(&budget_updates_2, connection); - - assert!(result.is_err()); -} - -#[test] -fn given_budget_update_when_insert_budget_update_different_category_and_same_date_then_return_num_budget_updates_inserted() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let _categories = given_categories(connection); - - let budget_updates_1 = [ - make_fake_budget_update_builder(0) - .category_id(0) - .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) - .build().unwrap() - ]; - let _ = queries::budget_updates::insert_budget_updates(&budget_updates_1, connection); - - let budget_updates_2 = [ - make_fake_budget_update_builder(1) - .category_id(1) - .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) - .build().unwrap() - ]; - let result = queries::budget_updates::insert_budget_updates(&budget_updates_2, connection); - - assert!(result.is_ok()); - assert_eq!(result.unwrap(), 1); -} - -#[test] -fn given_budget_update_when_insert_budget_update_same_category_and_different_date_then_return_num_budget_updates_inserted() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let _categories = given_categories(connection); - - let budget_updates_1 = [ - make_fake_budget_update_builder(0) - .category_id(0) - .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) - .build().unwrap() - ]; - let _ = queries::budget_updates::insert_budget_updates(&budget_updates_1, connection); - - let budget_updates_2 = [ - make_fake_budget_update_builder(1) - .category_id(0) - .date(DateUtc::from_ymd(2020, 12, 26).unwrap()) - .build().unwrap() - ]; - let result = queries::budget_updates::insert_budget_updates(&budget_updates_2, connection); - - assert!(result.is_ok()); - assert_eq!(result.unwrap(), 1); -} - -#[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 = given_categories(connection); - let budget_updates = [ - make_fake_budget_update_builder(0) - .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) - .category_id(0) - .build().unwrap(), - make_fake_budget_update_builder(1) - .date(DateUtc::from_ymd(2020, 12, 26).unwrap()) - .category_id(0) - .build().unwrap(), - ]; - 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()); - assert_eq!(budget_updates_in_db[0], budget_updates[0]); - assert_eq!(budget_updates_in_db[1], budget_updates[1]); - 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 = given_categories(connection); - let budget_updates = [ - make_fake_budget_update_builder(0) - .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) - .category_id(0) - .build().unwrap(), - make_fake_budget_update_builder(1) - .date(DateUtc::from_ymd(2020, 12, 26).unwrap()) - .category_id(0) - .build().unwrap(), - ]; - 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 = given_categories(connection); - let budget_updates = [ - make_fake_budget_update_builder(0) - .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) - .category_id(0) - .build().unwrap(), - make_fake_budget_update_builder(1) - .date(DateUtc::from_ymd(2020, 12, 26).unwrap()) - .category_id(0) - .build().unwrap(), - ]; - 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); -} - -#[test] -fn given_no_categories_when_get_first_with_date_and_category_id_then_return_none() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - - let first_with_date_and_category_id = - queries::budget_updates::get_first_budget_update_with_date_and_category_id( - &DateUtc::now(), - 0, - connection, - ).unwrap(); - - assert!(first_with_date_and_category_id.is_none()); -} - -#[test] -fn given_no_budget_updates_when_get_first_with_date_and_category_id_then_return_none() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let _categories = given_categories(connection); - - let first_with_date_and_category_id = - queries::budget_updates::get_first_budget_update_with_date_and_category_id( - &DateUtc::now(), - 0, - connection, - ).unwrap(); - - assert!(first_with_date_and_category_id.is_none()); -} - -#[test] -fn given_budget_update_when_get_first_with_date_then_return_budget_update() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let _categories = given_categories(connection); - let date: DateUtc = "2024-10-28".parse().unwrap(); - let budget_update = make_fake_budget_update_builder(0).date(date.clone()).build().unwrap(); - let _ = queries::budget_updates::insert_budget_updates(&[budget_update.clone()], connection).unwrap(); - - let first_with_date_and_category_id = - queries::budget_updates::get_first_budget_update_with_date_and_category_id( - &date, - 0, - connection, - ).unwrap(); - - assert!(first_with_date_and_category_id.is_some()); - assert_eq!(first_with_date_and_category_id.unwrap(), budget_update); -} - -#[test] -fn given_budget_update_when_get_first_with_date_and_different_category_id_then_return_none() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let _categories = given_categories(connection); - let date: DateUtc = "2024-10-28".parse().unwrap(); - let different_date: DateUtc = "2024-10-29".parse().unwrap(); - let budget_update = make_fake_budget_update_builder(0).date(date.clone()).build().unwrap(); - let _ = queries::budget_updates::insert_budget_updates(&[budget_update.clone()], connection).unwrap(); - - let first_with_date_and_category_id = - queries::budget_updates::get_first_budget_update_with_date_and_category_id( - &different_date, - 2, - connection - ).unwrap(); - - assert!(first_with_date_and_category_id.is_none()); -} - -#[test] -fn given_budget_update_when_get_first_with_different_date_and_category_id_then_return_none() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let _categories = given_categories(connection); - let date: DateUtc = "2024-10-28".parse().unwrap(); - let different_date: DateUtc = "2024-10-29".parse().unwrap(); - let budget_update = make_fake_budget_update_builder(0).date(date.clone()).build().unwrap(); - let _ = queries::budget_updates::insert_budget_updates(&[budget_update.clone()], connection).unwrap(); - - let first_with_date_and_category_id = - queries::budget_updates::get_first_budget_update_with_date_and_category_id( - &different_date, - 0, - connection - ).unwrap(); - - assert!(first_with_date_and_category_id.is_none()); -} - -#[test] -fn given_many_budget_updates_when_get_first_with_date_and_category_id_then_return_any_with_date() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let _categories = given_categories(connection); - let budget_updates = [ - make_fake_budget_update_builder(0).date("2024-12-25".parse().unwrap()).category_id(0).build().unwrap(), - make_fake_budget_update_builder(1).date("2024-12-25".parse().unwrap()).category_id(1).build().unwrap(), - make_fake_budget_update_builder(2).date("2020-12-26".parse().unwrap()).category_id(0).build().unwrap(), - make_fake_budget_update_builder(3).date("2020-12-26".parse().unwrap()).category_id(1).build().unwrap(), - make_fake_budget_update_builder(4).date("2020-12-27".parse().unwrap()).category_id(0).build().unwrap(), - make_fake_budget_update_builder(5).date("2020-12-27".parse().unwrap()).category_id(1).build().unwrap(), - ]; - let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap(); - - let first_with_date_and_category_id = - queries::budget_updates::get_first_budget_update_with_date_and_category_id( - &"2024-12-25".parse().unwrap(), - 0, - connection, - ).unwrap(); - - assert!(first_with_date_and_category_id.is_some()); - assert_eq!(first_with_date_and_category_id.unwrap(), budget_updates[0]); -} - -#[test] -fn given_many_budget_updates_when_get_most_recent_with_category_id_then_return_correct_date() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let _categories = given_categories(connection); - let budget_updates = [ - make_fake_budget_update_builder(0) - .category_id(0) - .date("2024-12-25".parse().unwrap()) - .build().unwrap(), - make_fake_budget_update_builder(1) - .category_id(0) - .date("2020-12-26".parse().unwrap()) - .build().unwrap(), - make_fake_budget_update_builder(2) - .category_id(1) - .date("2020-12-27".parse().unwrap()) - .build().unwrap(), - ]; - let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap(); - - let most_recent_with_category = queries::budget_updates::get_most_recent_budget_update_date_with_category_id( - 0, connection, - ); - - assert!(most_recent_with_category.is_ok()); - let most_recent_with_category = most_recent_with_category.unwrap(); - assert!(most_recent_with_category .is_some()); - let most_recent_with_category = most_recent_with_category.unwrap(); - assert_eq!(most_recent_with_category, budget_updates[1].date); -} - -#[test] -fn given_budget_update_when_get_most_recent_with_different_category_id_then_return_none() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let _categories = given_categories(connection); - let budget_updates = [ - make_fake_budget_update_builder(0) - .category_id(1) - .date("2020-12-27".parse().unwrap()) - .build().unwrap(), - ]; - let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap(); - - let most_recent_with_category = queries::budget_updates::get_most_recent_budget_update_date_with_category_id( - 0, connection, - ); - - assert!(most_recent_with_category.is_ok()); - let most_recent_with_category = most_recent_with_category.unwrap(); - assert!(most_recent_with_category .is_none()); -} diff --git a/rust/core/tests/queries/categories.rs b/rust/core/tests/queries/categories.rs deleted file mode 100644 index 4ab3f68..0000000 --- a/rust/core/tests/queries/categories.rs +++ /dev/null @@ -1,218 +0,0 @@ -use budgeting_app_core::{models::{account::Account, budget::Budget, budget_update::BudgetUpdate, category::Category, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation}, queries}; -use chrono::{Days, Utc}; -use diesel::{Connection, SqliteConnection}; - -use crate::common::{fakes::{account::make_fake_account, budget_update::make_fake_budget_update_builder, category::make_fake_category, transaction::make_fake_transaction_builder, transaction_categorisation::make_fake_transaction_categorisation_builder}, test_context::TestContext}; - -fn given_categories(connection: &mut SqliteConnection) -> Vec { - let categories = vec![make_fake_category(0), make_fake_category(1)]; - let _ = queries::categories::insert_categories(&categories, connection).unwrap(); - categories -} - -fn given_transactions(connection: &mut SqliteConnection) -> Vec { - let transactions = vec![ - make_fake_transaction_builder(0).quantity(1).build().unwrap(), - make_fake_transaction_builder(1).quantity(2).build().unwrap(), - make_fake_transaction_builder(2).quantity(4).build().unwrap(), - make_fake_transaction_builder(3).quantity(8).build().unwrap(), - ]; - let _ = queries::transactions::insert_transactions(&transactions, connection).unwrap(); - transactions -} - -fn given_accounts(connection: &mut SqliteConnection) -> Vec { - let accounts = vec![ - make_fake_account(0), - ]; - let _ = queries::accounts::insert_accounts(&accounts, connection); - accounts -} - -fn given_transaction_categorisations(connection: &mut SqliteConnection) -> Vec { - let transaction_categorisations = vec![ - make_fake_transaction_categorisation_builder(0).quantity(1).transaction_id(0).category_id(0).build().unwrap(), - make_fake_transaction_categorisation_builder(1).quantity(1).transaction_id(1).category_id(0).build().unwrap(), - make_fake_transaction_categorisation_builder(2).quantity(1).transaction_id(1).category_id(0).build().unwrap(), - make_fake_transaction_categorisation_builder(3).quantity(4).transaction_id(2).category_id(1).build().unwrap(), - make_fake_transaction_categorisation_builder(4).quantity(3).transaction_id(3).category_id(1).build().unwrap(), - make_fake_transaction_categorisation_builder(5).quantity(5).transaction_id(3).category_id(1).build().unwrap(), - ]; - let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection).unwrap(); - transaction_categorisations -} - -fn given_budget_updates(connection: &mut SqliteConnection) -> Vec { - let now = Utc::now(); - let twenty_days_ago = DateUtc::from(now.checked_sub_days(Days::new(20)).unwrap()); - let ten_days_ago = DateUtc::from(now.checked_sub_days(Days::new(10)).unwrap()); - let budget_updates = vec![ - make_fake_budget_update_builder(0).category_id(0).date(twenty_days_ago.clone()).new_budget(100).new_period(1).build().unwrap(), - make_fake_budget_update_builder(1).category_id(0).date(ten_days_ago.clone()).new_budget(50).new_period(2).build().unwrap(), - make_fake_budget_update_builder(2).category_id(1).date(twenty_days_ago.clone()).new_budget(90).new_period(4).build().unwrap(), - make_fake_budget_update_builder(3).category_id(1).date(ten_days_ago.clone()).new_budget(40).new_period(8).build().unwrap(), - ]; - let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection); - budget_updates -} - -#[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 = given_categories(connection); - - 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 = given_categories(connection); - - 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(); - given_categories(connection); - let _ = queries::categories::delete_all_categories(connection).unwrap(); - - let categories_returned = queries::categories::get_all_categories(connection).unwrap(); - - assert_eq!(categories_returned.len(), 0); -} - -#[test] -fn given_categories_and_no_transactions_when_get_all_balances_then_return_all_zero() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - given_categories(connection); - - let balances = queries::categories::get_all_category_balances(connection); - - assert!(balances.is_ok()); - let mut balances = balances.unwrap(); - balances.sort_by(|b1, b2| b1.category_id.cmp(&b2.category_id)); - assert_eq!(balances.len(), 2); - for balance in balances { - assert_eq!(0, balance.balance); - } -} - -#[test] -fn given_categories_and_transaction_categorisations_when_get_all_balances_then_return_balances() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let categories = given_categories(connection); - let _accounts = given_accounts(connection); - let _transactions = given_transactions(connection); - let transaction_categorisations = given_transaction_categorisations(connection); - - let balances = queries::categories::get_all_category_balances(connection); - - assert!(balances.is_ok()); - let mut balances = balances.unwrap(); - balances.sort_by(|b1, b2| b1.category_id.cmp(&b2.category_id)); - assert_eq!(balances.len(), categories.len()); - for category in categories { - let balance = balances.iter().find(|b| b.category_id == category.id).unwrap(); - let expected_balance: i32 = transaction_categorisations - .iter() - .filter(|t| t.category_id == category.id) - .map(|t| t.quantity) - .sum(); - assert_eq!(expected_balance, balance.balance); - } -} - -#[test] -fn given_categories_when_get_all_ids_then_return_all_ids() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let categories = given_categories(connection); - - let ids = queries::categories::get_all_category_ids(connection).unwrap(); - - assert_eq!(categories.len(), ids.len()); - for category in &categories { - assert!(ids.iter().any(|id| category.id == *id)); - } - for id in ids { - assert!(categories.iter().any(|category| category.id == id)); - } -} - -#[test] -fn given_categories_and_no_budget_updates_when_get_most_recent_budget_per_category_id_then_return_none() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let categories = given_categories(connection); - - let most_recent_budget_per_category_id = queries::categories::get_most_recent_category_budget_per_category_id(connection); - - assert!(most_recent_budget_per_category_id.is_ok()); - let most_recent_budget_per_category_id = most_recent_budget_per_category_id.unwrap(); - assert_eq!(categories.len(), most_recent_budget_per_category_id.len()); - for category in categories { - let most_recent_budget = most_recent_budget_per_category_id.iter().find(|b| b.category_id == category.id); - assert!(most_recent_budget.is_some()); - let most_recent_budget = most_recent_budget.unwrap(); - assert!(most_recent_budget.budget.is_none()); - } -} - -#[test] -fn given_categories_and_budget_updates_when_get_most_recent_budget_per_category_id_then_return_most_recent_budget() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - let categories = given_categories(connection); - let budget_updates = given_budget_updates(connection); - - let most_recent_budget_per_category_id = queries::categories::get_most_recent_category_budget_per_category_id(connection); - - assert!(most_recent_budget_per_category_id.is_ok()); - let most_recent_budget_per_category_id = most_recent_budget_per_category_id.unwrap(); - assert_eq!(categories.len(), most_recent_budget_per_category_id.len()); - for category in categories { - let most_recent_budget_update = budget_updates - .iter() - .filter(|bu| bu.category_id == category.id) - .max_by_key(|bu| bu.date.clone()) - .unwrap(); - - let most_recent_budget = most_recent_budget_per_category_id.iter().find(|b| b.category_id == category.id); - assert!(most_recent_budget.is_some()); - let most_recent_budget = most_recent_budget.unwrap(); - assert!(most_recent_budget.budget.is_some()); - let most_recent_budget = most_recent_budget.budget.unwrap(); - assert_eq!(most_recent_budget, Budget { - quantity: most_recent_budget_update.new_budget, - period: most_recent_budget_update.new_period, - }); - } -} diff --git a/rust/core/tests/queries/category_transfers.rs b/rust/core/tests/queries/category_transfers.rs deleted file mode 100644 index 0df144f..0000000 --- a/rust/core/tests/queries/category_transfers.rs +++ /dev/null @@ -1,124 +0,0 @@ -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); -} - -#[test] -fn given_category_transfers_when_sum_quantity_per_from_category_id_then_returns_sum_per_from_category_id() { - 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).quantity(1).build().unwrap(), - make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).quantity(2).build().unwrap(), - make_fake_category_transfer_builder(2).from_category_id(1).to_category_id(0).quantity(4).build().unwrap(), - ]; - let _ = queries::categories::insert_categories(&categories, connection); - let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap(); - - let sums = queries::category_transfers::sum_category_transfer_quantity_per_from_category_id(connection); - - assert!(sums.is_ok()); - let mut sums = sums.unwrap(); - sums.sort_by_key(|sum| sum.0); - assert_eq!(categories.len(), sums.len()); - assert_eq!(3, sums[0].1); - assert_eq!(4, sums[1].1); -} - -#[test] -fn given_category_transfers_when_sum_quantity_per_to_category_id_then_returns_sum_per_to_category_id() { - 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).quantity(1).build().unwrap(), - make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).quantity(2).build().unwrap(), - make_fake_category_transfer_builder(2).from_category_id(1).to_category_id(0).quantity(4).build().unwrap(), - ]; - let _ = queries::categories::insert_categories(&categories, connection); - let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap(); - - let sums = queries::category_transfers::sum_category_transfer_quantity_per_to_category_id(connection); - - assert!(sums.is_ok()); - let mut sums = sums.unwrap(); - sums.sort_by_key(|sum| sum.0); - assert_eq!(categories.len(), sums.len()); - assert_eq!(4, sums[0].1); - assert_eq!(3, sums[1].1); -} diff --git a/rust/core/tests/queries/mod.rs b/rust/core/tests/queries/mod.rs deleted file mode 100644 index e421934..0000000 --- a/rust/core/tests/queries/mod.rs +++ /dev/null @@ -1,6 +0,0 @@ -mod account; -mod budget_updates; -mod categories; -mod category_transfers; -mod transaction_categorisations; -mod transactions; diff --git a/rust/core/tests/queries/transaction_categorisations.rs b/rust/core/tests/queries/transaction_categorisations.rs deleted file mode 100644 index 123ee6e..0000000 --- a/rust/core/tests/queries/transaction_categorisations.rs +++ /dev/null @@ -1,127 +0,0 @@ -use budgeting_app_core::{models::{account::Account, category::Category, transaction::Transaction}, 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 given_accounts(connection: &mut SqliteConnection) -> Vec { - let accounts = vec![make_fake_account(0)]; - let _ = queries::accounts::insert_accounts(&accounts, connection); - accounts -} - -fn given_categories(connection: &mut SqliteConnection) -> Vec { - let categories = vec![make_fake_category(0), make_fake_category(1)]; - let _ = queries::categories::insert_categories(&categories, connection); - categories -} - -fn given_transactions(connection: &mut SqliteConnection) -> Vec { - let transactions = vec![ - make_fake_transaction_builder(0).account_id(0).build().unwrap(), - make_fake_transaction_builder(1).account_id(0).build().unwrap(), - ]; - let _ = queries::transactions::insert_transactions(&transactions, connection); - transactions -} - -#[test] -fn when_insert_transaction_categorisations_then_returns_num_transaction_categorisations() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - given_accounts(connection); - given_categories(connection); - given_transactions(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(); - given_accounts(connection); - given_categories(connection); - given_transactions(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(); - given_accounts(connection); - given_categories(connection); - given_transactions(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(); - given_accounts(connection); - given_categories(connection); - given_transactions(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); -} - -#[test] -fn given_transaction_categorisations_when_sum_quantity_per_category_id_then_returns_sum_quantity_per_category_id() { - let context = TestContext::new(); - let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); - given_accounts(connection); - let categories = given_categories(connection); - given_transactions(connection); - let transaction_categorisations = [ - make_fake_transaction_categorisation_builder(0).category_id(0).quantity(1).build().unwrap(), - make_fake_transaction_categorisation_builder(1).category_id(0).quantity(2).build().unwrap(), - make_fake_transaction_categorisation_builder(2).category_id(1).quantity(4).build().unwrap(), - ]; - let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection); - - let sums = queries::transaction_categorisations::sum_transaction_categorisation_quantity_per_category_id(connection); - - assert!(sums.is_ok()); - let mut sums = sums.unwrap(); - sums.sort_by_key(|sum| sum.0); - assert_eq!(categories.len(), sums.len()); - assert_eq!(3, sums[0].1); - assert_eq!(4, sums[1].1); -} diff --git a/rust/core/tests/queries/transactions.rs b/rust/core/tests/queries/transactions.rs deleted file mode 100644 index 406f5a8..0000000 --- a/rust/core/tests/queries/transactions.rs +++ /dev/null @@ -1,78 +0,0 @@ -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); -} -- cgit v1.2.3