From 8d714f760bd0349560d464583a151a04a19de1c9 Mon Sep 17 00:00:00 2001 From: Joe Carstairs Date: Wed, 13 Aug 2025 18:44:20 +0100 Subject: rename category -> bucket --- .../src/schist_state.rs | 10 +- .../src/transform_state/transform_budget_drips.rs | 10 +- .../src/transform_state/transform_categories.rs | 113 +++++++++++---------- .../transform_category_transfers.rs | 56 +++++----- .../src/transform_state/transform_state.rs | 10 +- .../src/transform_state/transform_transactions.rs | 10 +- .../tests/common/bucket_matchers.rs | 34 +++++++ .../tests/common/bucket_names.rs | 37 +++++++ .../tests/common/bucket_transfer_matchers.rs | 38 +++++++ .../tests/common/budget_drip_matchers.rs | 74 +++++++------- .../tests/common/category_matchers.rs | 34 ------- .../tests/common/category_names.rs | 37 ------- .../tests/common/category_transfer_matchers.rs | 38 ------- .../tests/common/mod.rs | 12 +-- .../common/transaction_categorisation_matchers.rs | 54 +++++----- .../tests/run.rs | 36 +++---- 16 files changed, 302 insertions(+), 301 deletions(-) create mode 100644 transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_matchers.rs create mode 100644 transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_names.rs create mode 100644 transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_transfer_matchers.rs delete mode 100644 transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_matchers.rs delete mode 100644 transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_names.rs delete mode 100644 transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_transfer_matchers.rs (limited to 'transformers') diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/schist_state.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/schist_state.rs index 370a0e8..a6c850e 100644 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/schist_state.rs +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/schist_state.rs @@ -1,28 +1,28 @@ use anyhow::Result; use diesel::SqliteConnection; use schist_models::{ - account::Account, account_transfer::AccountTransfer, budget_drip::BudgetDrip, category::Category, category_transfer::CategoryTransfer, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation + account::Account, account_transfer::AccountTransfer, budget_drip::BudgetDrip, bucket::Bucket, bucket_transfer::BucketTransfer, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation }; pub struct SchistState { pub first_transaction_date: DateUtc, pub accounts: Vec, pub account_transfers: Vec, - pub categories: Vec, + pub buckets: Vec, pub budget_drips: Vec, pub transactions: Vec, pub transaction_categorisations: Vec, - pub category_transfers: Vec, + pub bucket_transfers: Vec, } pub fn export_schist_state(schist_state: &SchistState, schist_connection: &mut SqliteConnection) -> Result<()> { schist_queries::clear::clear(schist_connection)?; schist_queries::accounts::insert_accounts(&schist_state.accounts, schist_connection)?; schist_queries::account_transfers::insert_account_transfers(&schist_state.account_transfers, schist_connection)?; - schist_queries::categories::insert_categories(&schist_state.categories, schist_connection)?; + schist_queries::buckets::insert_buckets(&schist_state.buckets, schist_connection)?; schist_queries::budget_drips::insert_budget_drips(&schist_state.budget_drips, schist_connection)?; schist_queries::transactions::insert_transactions(&schist_state.transactions, schist_connection)?; schist_queries::transaction_categorisations::insert_transaction_categorisations(&schist_state.transaction_categorisations, schist_connection)?; - schist_queries::category_transfers::insert_category_transfers(&schist_state.category_transfers, schist_connection)?; + schist_queries::bucket_transfers::insert_bucket_transfers(&schist_state.bucket_transfers, schist_connection)?; Ok(()) } diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_budget_drips.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_budget_drips.rs index 1163e56..01289a0 100644 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_budget_drips.rs +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_budget_drips.rs @@ -58,7 +58,7 @@ fn map_actualbudget_zero_budget_to_budget_drips( let budget_drips: Vec = days_in_month.iter().map(|&date| BudgetDrip { id: transform_budget_drip_id(&actualbudget_zero_budget, &date), - category_id: transform_id(&actualbudget_zero_budget.category_id), + bucket_id: transform_id(&actualbudget_zero_budget.category_id), date, quantity: if date == first_day_of_month { quantity + remainder_quantity @@ -277,28 +277,28 @@ mod test { let budget_drips_jan_category_0: Vec<&BudgetDrip> = budget_drips .iter() - .filter(|bd| bd.category_id == category_0_id && bd.date.month() == 1) + .filter(|bd| bd.bucket_id == category_0_id && bd.date.month() == 1) .collect(); assert_eq!(31, budget_drips_jan_category_0.len()); assert!(budget_drips_jan_category_0.iter().all(|bd| bd.quantity == 100)); let budget_drips_jan_category_1: Vec<&BudgetDrip> = budget_drips .iter() - .filter(|bd| bd.category_id == category_1_id && bd.date.month() == 1) + .filter(|bd| bd.bucket_id == category_1_id && bd.date.month() == 1) .collect(); assert_eq!(31, budget_drips_jan_category_1.len()); assert!(budget_drips_jan_category_1.iter().all(|bd| bd.quantity == 200)); let budget_drips_feb_category_0: Vec<&BudgetDrip> = budget_drips .iter() - .filter(|bd| bd.category_id == category_0_id && bd.date.month() == 2) + .filter(|bd| bd.bucket_id == category_0_id && bd.date.month() == 2) .collect(); assert_eq!(29, budget_drips_feb_category_0.len()); assert!(budget_drips_feb_category_0.iter().all(|bd| bd.quantity == 110)); let budget_drips_feb_category_1: Vec<&BudgetDrip> = budget_drips .iter() - .filter(|bd| bd.category_id == category_1_id && bd.date.month() == 2) + .filter(|bd| bd.bucket_id == category_1_id && bd.date.month() == 2) .collect(); assert_eq!(29, budget_drips_feb_category_1.len()); assert!(budget_drips_feb_category_1.iter().all(|bd| bd.quantity == 210)); diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_categories.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_categories.rs index 17ce194..2a21860 100644 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_categories.rs +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_categories.rs @@ -1,6 +1,6 @@ use actualbudget_models::{ActualbudgetCategory, ActualbudgetZeroBudget}; use itertools::Itertools; -use schist_models::{budget_period_unit::BudgetPeriodUnit, category::Category, date_utc::DateUtc}; +use schist_models::{budget_period_unit::BudgetPeriodUnit, bucket::Bucket, date_utc::DateUtc}; use super::transform_id; @@ -8,7 +8,7 @@ pub fn transform_categories( actualbudget_categories: &[ActualbudgetCategory], actualbudget_zero_budgets: &[ActualbudgetZeroBudget], before_first_activity: &DateUtc, -) -> Vec { +) -> Vec { let last_non_zero_month = actualbudget_zero_budgets .iter() .map(|zb| zb.month.clone()) @@ -28,7 +28,7 @@ pub fn transform_categories( actualbudget_zero_budgets }; - actualbudget_categories.iter().map(|actualbudget_category| Category { + actualbudget_categories.iter().map(|actualbudget_category| Bucket { id: transform_id(&actualbudget_category.id.clone()), name: actualbudget_category.name.clone(), balance: 0, @@ -36,6 +36,7 @@ pub fn transform_categories( budget_period: 1, budget_period_unit: BudgetPeriodUnit::Month, budget_quantity: get_budget_quantity(actualbudget_category, actualbudget_zero_budgets), + group: String::from("un-named group"), }).collect() } @@ -75,20 +76,20 @@ mod test { ]; let before_first_transaction = DateUtc::now(); - let categories = transform_categories( + let buckets = transform_categories( &actualbudget_categories, &actualbudget_zero_budgets, &before_first_transaction, ); - assert_eq!(1, categories.len()); - let category = categories.get(0).unwrap(); - assert_eq!("Food", category.name); - assert_eq!(0, category.balance); - assert_eq!(before_first_transaction, category.balance_date); - assert_eq!(1, category.budget_period); - assert_eq!(BudgetPeriodUnit::Month, category.budget_period_unit); - assert_eq!(100, category.budget_quantity); + assert_eq!(1, buckets.len()); + let bucket = buckets.get(0).unwrap(); + assert_eq!("Food", bucket.name); + assert_eq!(0, bucket.balance); + assert_eq!(before_first_transaction, bucket.balance_date); + assert_eq!(1, bucket.budget_period); + assert_eq!(BudgetPeriodUnit::Month, bucket.budget_period_unit); + assert_eq!(100, bucket.budget_quantity); } #[test] @@ -99,20 +100,20 @@ mod test { let actualbudget_zero_budgets = []; let before_first_transaction = DateUtc::now(); - let categories = transform_categories( + let buckets = transform_categories( &actualbudget_categories, &actualbudget_zero_budgets, &before_first_transaction, ); - assert_eq!(1, categories.len()); - let category = categories.get(0).unwrap(); - assert_eq!("Food", category.name); - assert_eq!(0, category.balance); - assert_eq!(before_first_transaction, category.balance_date); - assert_eq!(1, category.budget_period); - assert_eq!(BudgetPeriodUnit::Month, category.budget_period_unit); - assert_eq!(0, category.budget_quantity); + assert_eq!(1, buckets.len()); + let bucket = buckets.get(0).unwrap(); + assert_eq!("Food", bucket.name); + assert_eq!(0, bucket.balance); + assert_eq!(before_first_transaction, bucket.balance_date); + assert_eq!(1, bucket.budget_period); + assert_eq!(BudgetPeriodUnit::Month, bucket.budget_period_unit); + assert_eq!(0, bucket.budget_quantity); } #[test] @@ -130,20 +131,20 @@ mod test { ]; let before_first_transaction = DateUtc::now(); - let categories = transform_categories( + let buckets = transform_categories( &actualbudget_categories, &actualbudget_zero_budgets, &before_first_transaction, ); - assert_eq!(1, categories.len()); - let category = categories.get(0).unwrap(); - assert_eq!("Food", category.name); - assert_eq!(0, category.balance); - assert_eq!(before_first_transaction, category.balance_date); - assert_eq!(1, category.budget_period); - assert_eq!(BudgetPeriodUnit::Month, category.budget_period_unit); - assert_eq!(300, category.budget_quantity); + assert_eq!(1, buckets.len()); + let bucket = buckets.get(0).unwrap(); + assert_eq!("Food", bucket.name); + assert_eq!(0, bucket.balance); + assert_eq!(before_first_transaction, bucket.balance_date); + assert_eq!(1, bucket.budget_period); + assert_eq!(BudgetPeriodUnit::Month, bucket.budget_period_unit); + assert_eq!(300, bucket.budget_quantity); } #[test] @@ -169,36 +170,36 @@ mod test { ]; let before_first_transaction = DateUtc::now(); - let categories = transform_categories( + let buckets = transform_categories( &actualbudget_categories, &actualbudget_zero_budgets, &before_first_transaction, ); - assert_eq!(3, categories.len()); - - let category_0 = categories.iter().filter(|c| c.id == transform_id("0")).last().unwrap(); - assert_eq!("Food", category_0.name); - assert_eq!(0, category_0.balance); - assert_eq!(before_first_transaction, category_0.balance_date); - assert_eq!(1, category_0.budget_period); - assert_eq!(BudgetPeriodUnit::Month, category_0.budget_period_unit); - assert_eq!(300, category_0.budget_quantity); - - let category_1 = categories.iter().filter(|c| c.id == transform_id("1")).last().unwrap(); - assert_eq!("Clothes", category_1.name); - assert_eq!(0, category_1.balance); - assert_eq!(before_first_transaction, category_1.balance_date); - assert_eq!(1, category_1.budget_period); - assert_eq!(BudgetPeriodUnit::Month, category_1.budget_period_unit); - assert_eq!(310, category_1.budget_quantity); - - let category_2 = categories.iter().filter(|c| c.id == transform_id("2")).last().unwrap(); - assert_eq!("Rent", category_2.name); - assert_eq!(0, category_2.balance); - assert_eq!(before_first_transaction, category_2.balance_date); - assert_eq!(1, category_2.budget_period); - assert_eq!(BudgetPeriodUnit::Month, category_2.budget_period_unit); - assert_eq!(320, category_2.budget_quantity); + assert_eq!(3, buckets.len()); + + let bucket_0 = buckets.iter().filter(|c| c.id == transform_id("0")).last().unwrap(); + assert_eq!("Food", bucket_0.name); + assert_eq!(0, bucket_0.balance); + assert_eq!(before_first_transaction, bucket_0.balance_date); + assert_eq!(1, bucket_0.budget_period); + assert_eq!(BudgetPeriodUnit::Month, bucket_0.budget_period_unit); + assert_eq!(300, bucket_0.budget_quantity); + + let bucket_1 = buckets.iter().filter(|c| c.id == transform_id("1")).last().unwrap(); + assert_eq!("Clothes", bucket_1.name); + assert_eq!(0, bucket_1.balance); + assert_eq!(before_first_transaction, bucket_1.balance_date); + assert_eq!(1, bucket_1.budget_period); + assert_eq!(BudgetPeriodUnit::Month, bucket_1.budget_period_unit); + assert_eq!(310, bucket_1.budget_quantity); + + let bucket_2 = buckets.iter().filter(|c| c.id == transform_id("2")).last().unwrap(); + assert_eq!("Rent", bucket_2.name); + assert_eq!(0, bucket_2.balance); + assert_eq!(before_first_transaction, bucket_2.balance_date); + assert_eq!(1, bucket_2.budget_period); + assert_eq!(BudgetPeriodUnit::Month, bucket_2.budget_period_unit); + assert_eq!(320, bucket_2.budget_quantity); } } diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_category_transfers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_category_transfers.rs index 318e88c..11ed2e3 100644 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_category_transfers.rs +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_category_transfers.rs @@ -4,14 +4,14 @@ use actualbudget_models::{ }; use anyhow::{bail, Context, Result}; use itertools::Itertools; -use schist_models::category_transfer::CategoryTransfer; +use schist_models::bucket_transfer::BucketTransfer; use super::{is_category_transfer, transform_id}; pub fn transform_category_transfers( actualbudget_transactions: &[ActualbudgetTransaction], actualbudget_category_transfers_account: &Option, -) -> Result> { +) -> Result> { let actualbudget_category_transfers = actualbudget_transactions .iter() .filter(|transaction| @@ -32,7 +32,7 @@ pub fn transform_category_transfers( .map(|pct| transform_category_transfer(pct, &actualbudget_child_category_transfers)) .filter_ok(Option::is_some) .map_ok(Option::unwrap) - .collect::>>() + .collect::>>() .with_context(|| "failed to transform category transfers")? ) } @@ -40,7 +40,7 @@ pub fn transform_category_transfers( fn transform_category_transfer( actualbudget_parent_category_transfer: &ActualbudgetTransaction, actualbudget_child_category_transfers: &[ActualbudgetTransaction], -) -> Result> { +) -> Result> { transform_category_transfer_without_context( actualbudget_parent_category_transfer, actualbudget_child_category_transfers, @@ -50,7 +50,7 @@ fn transform_category_transfer( fn transform_category_transfer_without_context( actualbudget_parent_category_transfer: &ActualbudgetTransaction, actualbudget_child_category_transfers: &[ActualbudgetTransaction], -) -> Result> { +) -> Result> { let actualbudget_child_category_transfers = actualbudget_child_category_transfers .iter() .filter(|t| @@ -100,15 +100,15 @@ fn transform_category_transfer_without_context( bail!("actualbudget category transfer amounts did not sum to zero"); } - Ok(Some(CategoryTransfer { + Ok(Some(BucketTransfer { id: transform_id(&actualbudget_parent_category_transfer.id), description: actualbudget_parent_category_transfer .notes .clone() .unwrap_or_else(String::new), quantity: to_transfer.amount.try_into().unwrap(), - from_category_id, - to_category_id, + from_bucket_id: from_category_id, + to_bucket_id: to_category_id, })) } @@ -116,7 +116,7 @@ fn transform_category_transfer_without_context( mod test { use actualbudget_fakes::{actualbudget_account::make_fake_actualbudget_account, actualbudget_transaction::make_fake_actualbudget_transaction_builder}; use actualbudget_models::{ActualbudgetTransaction, ActualbudgetTransactionBuilder}; - use schist_models::category_transfer::CategoryTransfer; + use schist_models::bucket_transfer::BucketTransfer; use crate::transform_state::transform_id::transform_id; @@ -137,13 +137,13 @@ mod test { ); assert!(result.is_ok()); - let category_transfers = result.unwrap(); - assert_eq!(1, category_transfers.len()); - let category_transfer = category_transfers.get(0).unwrap(); - assert_eq!(100, category_transfer.quantity); - assert_eq!("I was a parent transaction", category_transfer.description); - assert_eq!(transform_id("0"), category_transfer.from_category_id); - assert_eq!(transform_id("1"), category_transfer.to_category_id); + let bucket_transfers = result.unwrap(); + assert_eq!(1, bucket_transfers.len()); + let bucket_transfer = bucket_transfers.get(0).unwrap(); + assert_eq!(100, bucket_transfer.quantity); + assert_eq!("I was a parent transaction", bucket_transfer.description); + assert_eq!(transform_id("0"), bucket_transfer.from_bucket_id); + assert_eq!(transform_id("1"), bucket_transfer.to_bucket_id); } #[test] @@ -166,26 +166,26 @@ mod test { ); assert!(result.is_ok()); - let category_transfers = result.unwrap(); - assert_eq!(2, category_transfers.len()); + let bucket_transfers = result.unwrap(); + assert_eq!(2, bucket_transfers.len()); - let category_transfer_0: Vec<&CategoryTransfer> = category_transfers + let bucket_transfer_0: Vec<&BucketTransfer> = bucket_transfers .iter() .filter(|ct| ct.quantity == 100) .collect(); - assert_eq!(1, category_transfer_0.len()); - let category_transfer_0 = category_transfer_0.get(0).unwrap(); - assert_eq!(transform_id("0"), category_transfer_0.from_category_id); - assert_eq!(transform_id("1"), category_transfer_0.to_category_id); + assert_eq!(1, bucket_transfer_0.len()); + let bucket_transfer_0 = bucket_transfer_0.get(0).unwrap(); + assert_eq!(transform_id("0"), bucket_transfer_0.from_bucket_id); + assert_eq!(transform_id("1"), bucket_transfer_0.to_bucket_id); - let category_transfer_1: Vec<&CategoryTransfer> = category_transfers + let bucket_transfer_1: Vec<&BucketTransfer> = bucket_transfers .iter() .filter(|ct| ct.quantity == 200) .collect(); - assert_eq!(1, category_transfer_1.len()); - let category_transfer_1 = category_transfer_1.get(0).unwrap(); - assert_eq!(transform_id("1"), category_transfer_1.from_category_id); - assert_eq!(transform_id("0"), category_transfer_1.to_category_id); + assert_eq!(1, bucket_transfer_1.len()); + let bucket_transfer_1 = bucket_transfer_1.get(0).unwrap(); + assert_eq!(transform_id("1"), bucket_transfer_1.from_bucket_id); + assert_eq!(transform_id("0"), bucket_transfer_1.to_bucket_id); } #[test] diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_state.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_state.rs index 7c64e35..575e624 100644 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_state.rs +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_state.rs @@ -1,5 +1,5 @@ use anyhow::{bail, Context, Result}; -use schist_models::{account::Account, category::Category, category_transfer::CategoryTransfer, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation}; +use schist_models::{account::Account, bucket::Bucket, bucket_transfer::BucketTransfer, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation}; use crate::{actualbudget_state::ActualbudgetState, schist_state::SchistState}; @@ -24,7 +24,7 @@ fn transform_state_without_context(actualbudget_state: ActualbudgetState) -> Res &first_activity_date, ); let budget_drips = transform_budget_drips(&actualbudget_state.actualbudget_zero_budgets)?; - let categories: Vec = transform_categories( + let buckets: Vec = transform_categories( &actualbudget_state.actualbudget_categories, &actualbudget_state.actualbudget_zero_budgets, &before_first_activity_date, @@ -35,7 +35,7 @@ fn transform_state_without_context(actualbudget_state: ActualbudgetState) -> Res &actualbudget_state.actualbudget_category_transfers_account, &actualbudget_state.actualbudget_payees, )?; - let category_transfers: Vec = transform_category_transfers( + let bucket_transfers: Vec = transform_category_transfers( &remaining_transactions, &actualbudget_state.actualbudget_category_transfers_account, )?; @@ -44,11 +44,11 @@ fn transform_state_without_context(actualbudget_state: ActualbudgetState) -> Res first_transaction_date: first_activity_date, accounts, account_transfers, - categories, + buckets, budget_drips, transactions, transaction_categorisations, - category_transfers, + bucket_transfers, }) } diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_transactions.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_transactions.rs index f7fb098..f24e8b6 100644 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_transactions.rs +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_transactions.rs @@ -75,7 +75,7 @@ fn transform_transactions_without_context( description: String::new(), quantity: atomic_actualbudget_transaction.amount.try_into().unwrap(), transaction_id, - category_id: transform_id(&actualbudget_category_id), + bucket_id: transform_id(&actualbudget_category_id), }); } @@ -113,7 +113,7 @@ fn transform_transactions_without_context( description: child_actualbudget_transaction.notes.clone().unwrap_or_else(String::new), quantity: child_actualbudget_transaction.amount.try_into().unwrap(), transaction_id, - category_id: transform_id(&actualbudget_category_id), + bucket_id: transform_id(&actualbudget_category_id), }); } } @@ -191,7 +191,7 @@ mod test { assert_eq!("", transaction_categorisation.description); assert_eq!(100, transaction_categorisation.quantity); assert_eq!(transaction.id, transaction_categorisation.transaction_id); - assert_eq!(transform_id("0"), transaction_categorisation.category_id); + assert_eq!(transform_id("0"), transaction_categorisation.bucket_id); } #[test] @@ -238,7 +238,7 @@ mod test { .last() .unwrap(); assert_eq!(transaction.id, transaction_categorisation_0.transaction_id); - assert_eq!(transform_id("0"), transaction_categorisation_0.category_id); + assert_eq!(transform_id("0"), transaction_categorisation_0.bucket_id); assert_eq!("notes A", transaction_categorisation_0.description); let transaction_categorisation_1 = transaction_categorisations @@ -247,7 +247,7 @@ mod test { .last() .unwrap(); assert_eq!(transaction.id, transaction_categorisation_1.transaction_id); - assert_eq!(transform_id("0"), transaction_categorisation_1.category_id); + assert_eq!(transform_id("0"), transaction_categorisation_1.bucket_id); assert_eq!("notes B", transaction_categorisation_1.description); } } diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_matchers.rs new file mode 100644 index 0000000..76189d3 --- /dev/null +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_matchers.rs @@ -0,0 +1,34 @@ +use schist_models::{budget_period_unit::BudgetPeriodUnit, bucket::Bucket}; + +use super::bucket_names::{BUCKET_NAMES, BUCKET_NAME_BILLS, BUCKET_NAME_BILLS_FLEXIBLE, BUCKET_NAME_FOOD, BUCKET_NAME_GENERAL, BUCKET_NAME_INCOME, BUCKET_NAME_SAVINGS, BUCKET_NAME_STARTING_BALANCES}; + +pub fn get_bucket_matchers( +) -> Vec bool>> { + BUCKET_NAMES + .iter() + .map(|bucket_name| -> Box bool> { + Box::new(|c| matches_bucket(c, bucket_name)) + }).collect() +} + +fn matches_bucket(bucket: &Bucket, bucket_name: &str,) -> bool { + bucket.name == bucket_name + && bucket.balance == 0 + && bucket.balance_date < "2024-08-01".parse().unwrap() + && bucket.budget_period == 1 + && bucket.budget_period_unit == BudgetPeriodUnit::Month + && bucket.budget_quantity == get_expected_budget_quantity(bucket_name) +} + +fn get_expected_budget_quantity(bucket_name: &str) -> i32 { + match bucket_name { + BUCKET_NAME_FOOD => 200_00, + BUCKET_NAME_GENERAL => 100_00, + BUCKET_NAME_BILLS => 125_00, + BUCKET_NAME_BILLS_FLEXIBLE => 25_00, + BUCKET_NAME_SAVINGS => 400_00, + BUCKET_NAME_STARTING_BALANCES => 0, + BUCKET_NAME_INCOME => 0, + _ => panic!("unexpected bucket name {}", bucket_name), + } +} diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_names.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_names.rs new file mode 100644 index 0000000..5f232a8 --- /dev/null +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_names.rs @@ -0,0 +1,37 @@ +pub const BUCKET_NAME_FOOD: &str = "Food"; +pub const BUCKET_NAME_GENERAL: &str = "General"; +pub const BUCKET_NAME_BILLS: &str = "Bills"; +pub const BUCKET_NAME_BILLS_FLEXIBLE: &str = "Bills (Flexible)"; +pub const BUCKET_NAME_SAVINGS: &str = "Savings"; +pub const BUCKET_NAME_STARTING_BALANCES: &str = "Starting Balances"; +pub const BUCKET_NAME_INCOME: &str = "Income"; + +pub const BUCKET_NAMES: &[&'static str] = &[ + BUCKET_NAME_FOOD, + BUCKET_NAME_GENERAL, + BUCKET_NAME_BILLS, + BUCKET_NAME_BILLS_FLEXIBLE, + BUCKET_NAME_SAVINGS, + BUCKET_NAME_STARTING_BALANCES, + BUCKET_NAME_INCOME, +]; + +pub struct BucketNamesDict { + pub food: &'static str, + pub general: &'static str, + pub bills: &'static str, + pub bills_flexible: &'static str, + pub savings: &'static str, + pub starting_balances: &'static str, + pub income: &'static str, +} + +pub const BUCKET_NAMES_DICT: BucketNamesDict = BucketNamesDict { + food: BUCKET_NAME_FOOD, + general: BUCKET_NAME_GENERAL, + bills: BUCKET_NAME_BILLS, + bills_flexible: BUCKET_NAME_BILLS_FLEXIBLE, + savings: BUCKET_NAME_SAVINGS, + starting_balances: BUCKET_NAME_STARTING_BALANCES, + income: BUCKET_NAME_INCOME, +}; diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_transfer_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_transfer_matchers.rs new file mode 100644 index 0000000..3b46d76 --- /dev/null +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_transfer_matchers.rs @@ -0,0 +1,38 @@ +use schist_models::{bucket::Bucket, bucket_transfer::BucketTransfer}; + +use super::bucket_names::{BUCKET_NAME_GENERAL, BUCKET_NAME_SAVINGS}; + +pub fn get_bucket_transfer_matchers( +) -> Vec bool>> { + vec![ + Box::new(|ct, c| matches_120_savings_to_general_23_oct_2024(ct, c)), + ] +} + +fn matches_120_savings_to_general_23_oct_2024( + bucket_transfer: &BucketTransfer, + buckets: &[Bucket], +) -> bool { + let savings_bucket = buckets + .iter() + .find(|c| c.name == BUCKET_NAME_SAVINGS) + .expect("failed to find savings bucket"); + + let general_bucket = buckets + .iter() + .find(|c| c.name == BUCKET_NAME_GENERAL) + .expect("failed to find general bucket"); + + match bucket_transfer { + BucketTransfer { + id: _id, + description, + quantity: 120_00, + from_bucket_id, + to_bucket_id, + } => *from_bucket_id == savings_bucket.id + && *to_bucket_id == general_bucket.id + && description.as_str() == "", + _ => false, + } +} diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/budget_drip_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/budget_drip_matchers.rs index 04be584..97f81a2 100644 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/budget_drip_matchers.rs +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/budget_drip_matchers.rs @@ -1,19 +1,19 @@ use std::sync::LazyLock; -use schist_models::{budget_drip::BudgetDrip, category::Category, date_utc::DateUtc}; +use schist_models::{budget_drip::BudgetDrip, bucket::Bucket, date_utc::DateUtc}; use schist_traits::dateable::Dateable; -use crate::common::category_names::{CATEGORY_NAME_BILLS, CATEGORY_NAME_BILLS_FLEXIBLE, CATEGORY_NAME_FOOD, CATEGORY_NAME_GENERAL, CATEGORY_NAME_SAVINGS}; +use crate::common::bucket_names::{BUCKET_NAME_BILLS, BUCKET_NAME_BILLS_FLEXIBLE, BUCKET_NAME_FOOD, BUCKET_NAME_GENERAL, BUCKET_NAME_SAVINGS}; pub fn get_num_expected_budget_drips() -> usize { let num_expected_dates = DATES.len(); - let num_expected_categories = 5; - num_expected_dates * num_expected_categories + let num_expected_buckets = 5; + num_expected_dates * num_expected_buckets } pub fn assert_budget_drip_matches( budget_drip: &BudgetDrip, - categories: &[Category], + buckets: &[Bucket], ) { assert!( DATES.iter().any(|date| *LazyLock::force(date) == budget_drip.date), @@ -21,55 +21,55 @@ pub fn assert_budget_drip_matches( budget_drip, ); - let category_name = categories + let bucket_name = buckets .iter() - .find(|c| c.id == budget_drip.category_id) + .find(|c| c.id == budget_drip.bucket_id) .map(|c| c.name.clone()) .expect(format!( - "budget drip {:?} had unexpected category ID. categories were: {:?}", + "budget drip {:?} had unexpected bucket ID. buckets were: {:?}", budget_drip, - categories, + buckets, ).as_str()); let expected_quantity = match ( - category_name.as_str(), + bucket_name.as_str(), budget_drip.date.month(), budget_drip.date.day(), ) { - (CATEGORY_NAME_FOOD, 8 | 10, 1) => 6_50, - (CATEGORY_NAME_FOOD, 8 | 10, _) => 6_45, - (CATEGORY_NAME_FOOD, 9 | 11, 1) => 6_86, - (CATEGORY_NAME_FOOD, 9 | 11, _) => 6_66, - (CATEGORY_NAME_FOOD, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip), + (BUCKET_NAME_FOOD, 8 | 10, 1) => 6_50, + (BUCKET_NAME_FOOD, 8 | 10, _) => 6_45, + (BUCKET_NAME_FOOD, 9 | 11, 1) => 6_86, + (BUCKET_NAME_FOOD, 9 | 11, _) => 6_66, + (BUCKET_NAME_FOOD, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip), - (CATEGORY_NAME_GENERAL, 8 | 10, 1) => 3_40, - (CATEGORY_NAME_GENERAL, 8 | 10, _) => 3_22, - (CATEGORY_NAME_GENERAL, 9 | 11, 1) => 3_43, - (CATEGORY_NAME_GENERAL, 9 | 11, _) => 3_33, - (CATEGORY_NAME_GENERAL, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip), + (BUCKET_NAME_GENERAL, 8 | 10, 1) => 3_40, + (BUCKET_NAME_GENERAL, 8 | 10, _) => 3_22, + (BUCKET_NAME_GENERAL, 9 | 11, 1) => 3_43, + (BUCKET_NAME_GENERAL, 9 | 11, _) => 3_33, + (BUCKET_NAME_GENERAL, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip), - (CATEGORY_NAME_BILLS, 8 | 10, 1) => 4_10, - (CATEGORY_NAME_BILLS, 8 | 10, _) => 4_03, - (CATEGORY_NAME_BILLS, 9 | 11, 1) => 4_36, - (CATEGORY_NAME_BILLS, 9 | 11, _) => 4_16, - (CATEGORY_NAME_BILLS, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip), + (BUCKET_NAME_BILLS, 8 | 10, 1) => 4_10, + (BUCKET_NAME_BILLS, 8 | 10, _) => 4_03, + (BUCKET_NAME_BILLS, 9 | 11, 1) => 4_36, + (BUCKET_NAME_BILLS, 9 | 11, _) => 4_16, + (BUCKET_NAME_BILLS, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip), - (CATEGORY_NAME_BILLS_FLEXIBLE, 8 | 10, 1) => 1_00, - (CATEGORY_NAME_BILLS_FLEXIBLE, 8 | 10, _) => 80, - (CATEGORY_NAME_BILLS_FLEXIBLE, 9 | 11, 1) => 93, - (CATEGORY_NAME_BILLS_FLEXIBLE, 9 | 11, _) => 83, - (CATEGORY_NAME_BILLS_FLEXIBLE, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip), + (BUCKET_NAME_BILLS_FLEXIBLE, 8 | 10, 1) => 1_00, + (BUCKET_NAME_BILLS_FLEXIBLE, 8 | 10, _) => 80, + (BUCKET_NAME_BILLS_FLEXIBLE, 9 | 11, 1) => 93, + (BUCKET_NAME_BILLS_FLEXIBLE, 9 | 11, _) => 83, + (BUCKET_NAME_BILLS_FLEXIBLE, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip), - (CATEGORY_NAME_SAVINGS, 8 | 10, 1) => 13_00, - (CATEGORY_NAME_SAVINGS, 8 | 10, _) => 12_90, - (CATEGORY_NAME_SAVINGS, 9 | 11, 1) => 13_43, - (CATEGORY_NAME_SAVINGS, 9 | 11, _) => 13_33, - (CATEGORY_NAME_SAVINGS, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip), + (BUCKET_NAME_SAVINGS, 8 | 10, 1) => 13_00, + (BUCKET_NAME_SAVINGS, 8 | 10, _) => 12_90, + (BUCKET_NAME_SAVINGS, 9 | 11, 1) => 13_43, + (BUCKET_NAME_SAVINGS, 9 | 11, _) => 13_33, + (BUCKET_NAME_SAVINGS, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip), (_, _, _) => panic!( - "budget drip {:?} had unexpected category name {}", + "budget drip {:?} had unexpected bucket name {}", budget_drip, - category_name, + bucket_name, ), }; diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_matchers.rs deleted file mode 100644 index 6660add..0000000 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_matchers.rs +++ /dev/null @@ -1,34 +0,0 @@ -use schist_models::{budget_period_unit::BudgetPeriodUnit, category::Category}; - -use super::category_names::{CATEGORY_NAMES, CATEGORY_NAME_BILLS, CATEGORY_NAME_BILLS_FLEXIBLE, CATEGORY_NAME_FOOD, CATEGORY_NAME_GENERAL, CATEGORY_NAME_INCOME, CATEGORY_NAME_SAVINGS, CATEGORY_NAME_STARTING_BALANCES}; - -pub fn get_category_matchers( -) -> Vec bool>> { - CATEGORY_NAMES - .iter() - .map(|category_name| -> Box bool> { - Box::new(|c| matches_category(c, category_name)) - }).collect() -} - -fn matches_category(category: &Category, category_name: &str,) -> bool { - category.name == category_name - && category.balance == 0 - && category.balance_date < "2024-08-01".parse().unwrap() - && category.budget_period == 1 - && category.budget_period_unit == BudgetPeriodUnit::Month - && category.budget_quantity == get_expected_budget_quantity(category_name) -} - -fn get_expected_budget_quantity(category_name: &str) -> i32 { - match category_name { - CATEGORY_NAME_FOOD => 200_00, - CATEGORY_NAME_GENERAL => 100_00, - CATEGORY_NAME_BILLS => 125_00, - CATEGORY_NAME_BILLS_FLEXIBLE => 25_00, - CATEGORY_NAME_SAVINGS => 400_00, - CATEGORY_NAME_STARTING_BALANCES => 0, - CATEGORY_NAME_INCOME => 0, - _ => panic!("unexpected category name {}", category_name), - } -} diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_names.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_names.rs deleted file mode 100644 index 601f294..0000000 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_names.rs +++ /dev/null @@ -1,37 +0,0 @@ -pub const CATEGORY_NAME_FOOD: &str = "Food"; -pub const CATEGORY_NAME_GENERAL: &str = "General"; -pub const CATEGORY_NAME_BILLS: &str = "Bills"; -pub const CATEGORY_NAME_BILLS_FLEXIBLE: &str = "Bills (Flexible)"; -pub const CATEGORY_NAME_SAVINGS: &str = "Savings"; -pub const CATEGORY_NAME_STARTING_BALANCES: &str = "Starting Balances"; -pub const CATEGORY_NAME_INCOME: &str = "Income"; - -pub const CATEGORY_NAMES: &[&'static str] = &[ - CATEGORY_NAME_FOOD, - CATEGORY_NAME_GENERAL, - CATEGORY_NAME_BILLS, - CATEGORY_NAME_BILLS_FLEXIBLE, - CATEGORY_NAME_SAVINGS, - CATEGORY_NAME_STARTING_BALANCES, - CATEGORY_NAME_INCOME, -]; - -pub struct CategoryNamesDict { - pub food: &'static str, - pub general: &'static str, - pub bills: &'static str, - pub bills_flexible: &'static str, - pub savings: &'static str, - pub starting_balances: &'static str, - pub income: &'static str, -} - -pub const CATEGORY_NAMES_DICT: CategoryNamesDict = CategoryNamesDict { - food: CATEGORY_NAME_FOOD, - general: CATEGORY_NAME_GENERAL, - bills: CATEGORY_NAME_BILLS, - bills_flexible: CATEGORY_NAME_BILLS_FLEXIBLE, - savings: CATEGORY_NAME_SAVINGS, - starting_balances: CATEGORY_NAME_STARTING_BALANCES, - income: CATEGORY_NAME_INCOME, -}; diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_transfer_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_transfer_matchers.rs deleted file mode 100644 index 6d11c8a..0000000 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_transfer_matchers.rs +++ /dev/null @@ -1,38 +0,0 @@ -use schist_models::{category::Category, category_transfer::CategoryTransfer}; - -use super::category_names::{CATEGORY_NAME_GENERAL, CATEGORY_NAME_SAVINGS}; - -pub fn get_category_transfer_matchers( -) -> Vec bool>> { - vec![ - Box::new(|ct, c| matches_120_savings_to_general_23_oct_2024(ct, c)), - ] -} - -fn matches_120_savings_to_general_23_oct_2024( - category_transfer: &CategoryTransfer, - categories: &[Category], -) -> bool { - let savings_category = categories - .iter() - .find(|c| c.name == CATEGORY_NAME_SAVINGS) - .expect("failed to find savings category"); - - let general_category = categories - .iter() - .find(|c| c.name == CATEGORY_NAME_GENERAL) - .expect("failed to find general category"); - - match category_transfer { - CategoryTransfer { - id: _id, - description, - quantity: 120_00, - from_category_id, - to_category_id, - } => *from_category_id == savings_category.id - && *to_category_id == general_category.id - && description.as_str() == "", - _ => false, - } -} diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/mod.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/mod.rs index c67f62e..62255b0 100644 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/mod.rs +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/mod.rs @@ -2,9 +2,9 @@ mod account_matchers; mod account_names; mod account_transfer_matchers; mod budget_drip_matchers; -mod category_matchers; -mod category_names; -mod category_transfer_matchers; +mod bucket_matchers; +mod bucket_names; +mod bucket_transfer_matchers; mod db_url; mod test_context; mod transaction_matchers; @@ -15,9 +15,9 @@ pub use account_names::ACCOUNT_NAMES_DICT; pub use account_transfer_matchers::get_account_transfer_matchers; pub use budget_drip_matchers::assert_budget_drip_matches; pub use budget_drip_matchers::get_num_expected_budget_drips; -pub use category_names::CATEGORY_NAMES_DICT; -pub use category_matchers::get_category_matchers; -pub use category_transfer_matchers::get_category_transfer_matchers; +pub use bucket_names::BUCKET_NAMES_DICT; +pub use bucket_matchers::get_bucket_matchers; +pub use bucket_transfer_matchers::get_bucket_transfer_matchers; pub use db_url::TEST_IN_DB_URL; pub use db_url::TEST_OUT_DB_URL; pub use test_context::TestContext; diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_categorisation_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_categorisation_matchers.rs index 04ce6a7..8082055 100644 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_categorisation_matchers.rs +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_categorisation_matchers.rs @@ -1,9 +1,9 @@ -use schist_models::{account::Account, category::Category, transaction::Transaction, transaction_categorisation::TransactionCategorisation}; +use schist_models::{account::Account, bucket::Bucket, transaction::Transaction, transaction_categorisation::TransactionCategorisation}; -use super::{category_names::{CATEGORY_NAME_FOOD, CATEGORY_NAME_INCOME, CATEGORY_NAME_STARTING_BALANCES}, matches_bank_account_initial_transaction, matches_cash_account_initial_transaction, matches_food_transaction, matches_income_transaction}; +use super::{bucket_names::{BUCKET_NAME_FOOD, BUCKET_NAME_INCOME, BUCKET_NAME_STARTING_BALANCES}, matches_bank_account_initial_transaction, matches_cash_account_initial_transaction, matches_food_transaction, matches_income_transaction}; pub fn get_transaction_categorisation_matchers( -) -> Vec bool>> { +) -> Vec bool>> { vec![ Box::new(|tc, t, c, a| matches_bank_account_initial_transaction_categorisation(tc, t, c, a)), Box::new(|tc, t, c, a| matches_cash_account_initial_transaction_categorisation(tc, t, c, a)), @@ -21,7 +21,7 @@ pub fn get_transaction_categorisation_matchers( fn matches_bank_account_initial_transaction_categorisation( transaction_categorisation: &TransactionCategorisation, transactions: &[Transaction], - categories: &[Category], + buckets: &[Bucket], accounts: &[Account], ) -> bool { let bank_account_initial_transaction = transactions @@ -29,10 +29,10 @@ fn matches_bank_account_initial_transaction_categorisation( .find(|t| matches_bank_account_initial_transaction(t, accounts)) .expect("failed to find bank account initial transaction"); - let starting_balance_category = categories + let starting_balance_bucket = buckets .iter() - .find(|c| c.name == CATEGORY_NAME_STARTING_BALANCES) - .expect("failed to find starting balance category"); + .find(|c| c.name == BUCKET_NAME_STARTING_BALANCES) + .expect("failed to find starting balance bucket"); match transaction_categorisation { TransactionCategorisation { @@ -40,10 +40,10 @@ fn matches_bank_account_initial_transaction_categorisation( description, quantity: 1200_00, transaction_id, - category_id, + bucket_id, } => description == "" && *transaction_id == bank_account_initial_transaction.id - && *category_id == starting_balance_category.id, + && *bucket_id == starting_balance_bucket.id, _ => false, } } @@ -51,7 +51,7 @@ fn matches_bank_account_initial_transaction_categorisation( fn matches_cash_account_initial_transaction_categorisation( transaction_categorisation: &TransactionCategorisation, transactions: &[Transaction], - categories: &[Category], + buckets: &[Bucket], accounts: &[Account], ) -> bool { let cash_account_initial_transaction = transactions @@ -59,10 +59,10 @@ fn matches_cash_account_initial_transaction_categorisation( .find(|t| matches_cash_account_initial_transaction(t, accounts)) .expect("failed to find cash account initial transaction"); - let starting_balance_category = categories + let starting_balance_bucket = buckets .iter() - .find(|c| c.name == CATEGORY_NAME_STARTING_BALANCES) - .expect("failed to find starting balance category"); + .find(|c| c.name == BUCKET_NAME_STARTING_BALANCES) + .expect("failed to find starting balance bucket"); match transaction_categorisation { TransactionCategorisation { @@ -70,10 +70,10 @@ fn matches_cash_account_initial_transaction_categorisation( description, quantity: 45_10, transaction_id, - category_id, + bucket_id, } => description == "" && *transaction_id == cash_account_initial_transaction.id - && *category_id == starting_balance_category.id, + && *bucket_id == starting_balance_bucket.id, _ => false, } } @@ -81,7 +81,7 @@ fn matches_cash_account_initial_transaction_categorisation( fn matches_income_transaction_categorisation( transaction_categorisation: &TransactionCategorisation, transactions: &[Transaction], - categories: &[Category], + buckets: &[Bucket], accounts: &[Account], month: &str, ) -> bool { @@ -90,10 +90,10 @@ fn matches_income_transaction_categorisation( .find(|t| matches_income_transaction(t, accounts, month)) .expect(format!("failed to find income transaction for month {}", month).as_str()); - let income_category = categories + let income_bucket = buckets .iter() - .find(|c| c.name == CATEGORY_NAME_INCOME) - .expect("failed to find income category"); + .find(|c| c.name == BUCKET_NAME_INCOME) + .expect("failed to find income bucket"); match transaction_categorisation { TransactionCategorisation { @@ -101,10 +101,10 @@ fn matches_income_transaction_categorisation( description, quantity: 846_46, transaction_id, - category_id, + bucket_id, } => description == "" && *transaction_id == income_transaction.id - && *category_id == income_category.id, + && *bucket_id == income_bucket.id, _ => false, } } @@ -112,7 +112,7 @@ fn matches_income_transaction_categorisation( fn matches_food_transaction_categorisation( transaction_categorisation: &TransactionCategorisation, transactions: &[Transaction], - categories: &[Category], + buckets: &[Bucket], accounts: &[Account], month: &str, ) -> bool { @@ -121,10 +121,10 @@ fn matches_food_transaction_categorisation( .find(|t| matches_food_transaction(t, accounts, month)) .expect(format!("failed to find food transaction for month {}", month).as_str()); - let food_category = categories + let food_bucket = buckets .iter() - .find(|c| c.name == CATEGORY_NAME_FOOD) - .expect("failed to find food category"); + .find(|c| c.name == BUCKET_NAME_FOOD) + .expect("failed to find food bucket"); match transaction_categorisation { TransactionCategorisation { @@ -132,10 +132,10 @@ fn matches_food_transaction_categorisation( description, quantity: -200_00, transaction_id, - category_id, + bucket_id, } => description == "" && *transaction_id == food_transaction.id - && *category_id == food_category.id, + && *bucket_id == food_bucket.id, _ => false, } } diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/run.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/run.rs index e882dc5..4c13d55 100644 --- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/run.rs +++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/run.rs @@ -1,9 +1,9 @@ pub mod common; use actualbudget_to_schist_transformer::run::run; -use common::{assert_budget_drip_matches, get_account_matchers, get_account_transfer_matchers, get_category_matchers, get_category_transfer_matchers, get_num_expected_budget_drips, get_transaction_categorisation_matchers, get_transaction_matchers, TestContext, TEST_IN_DB_URL, TEST_OUT_DB_URL}; +use common::{assert_budget_drip_matches, get_account_matchers, get_account_transfer_matchers, get_bucket_matchers, get_bucket_transfer_matchers, get_num_expected_budget_drips, get_transaction_categorisation_matchers, get_transaction_matchers, TestContext, TEST_IN_DB_URL, TEST_OUT_DB_URL}; use diesel::{Connection, SqliteConnection}; -use schist_queries::{account_transfers::get_all_account_transfers, accounts::get_all_accounts, budget_drips::get_all_budget_drips, categories::get_all_categories, category_transfers::get_all_category_transfers, transaction_categorisations::get_all_transaction_categorisations, transactions::get_all_transactions}; +use schist_queries::{account_transfers::get_all_account_transfers, accounts::get_all_accounts, budget_drips::get_all_budget_drips, buckets::get_all_buckets, bucket_transfers::get_all_bucket_transfers, transaction_categorisations::get_all_transaction_categorisations, transactions::get_all_transactions}; #[test] fn given_test_database_when_run_then_exports_expected_schist_state() { @@ -13,8 +13,8 @@ fn given_test_database_when_run_then_exports_expected_schist_state() { let accounts = get_all_accounts(connection).unwrap(); let account_transfers = get_all_account_transfers(connection).unwrap(); let budget_drips = get_all_budget_drips(connection).unwrap(); - let categories = get_all_categories(connection).unwrap(); - let category_transfers = get_all_category_transfers(connection).unwrap(); + let buckets = get_all_buckets(connection).unwrap(); + let bucket_transfers = get_all_bucket_transfers(connection).unwrap(); let transactions = get_all_transactions(connection).unwrap(); let transaction_categorisations = get_all_transaction_categorisations(connection).unwrap(); @@ -40,26 +40,26 @@ fn given_test_database_when_run_then_exports_expected_schist_state() { assert_eq!(get_num_expected_budget_drips(), budget_drips.len()); for budget_drip in budget_drips { - assert_budget_drip_matches(&budget_drip, &categories); + assert_budget_drip_matches(&budget_drip, &buckets); } - let category_matchers = get_category_matchers(); - assert_eq!(category_matchers.len(), categories.len()); - for category in categories.clone() { + let bucket_matchers = get_bucket_matchers(); + assert_eq!(bucket_matchers.len(), buckets.len()); + for bucket in buckets.clone() { assert!( - category_matchers.iter().any(|m| m(&category)), - "no match found for category {:?}", - category, + bucket_matchers.iter().any(|m| m(&bucket)), + "no match found for bucket {:?}", + bucket, ); } - let category_transfer_matchers = get_category_transfer_matchers(); - assert_eq!(category_transfer_matchers.len(), category_transfers.len()); - for category_transfer in category_transfers { + let bucket_transfer_matchers = get_bucket_transfer_matchers(); + assert_eq!(bucket_transfer_matchers.len(), bucket_transfers.len()); + for bucket_transfer in bucket_transfers { assert!( - category_transfer_matchers.iter().any(|m| m(&category_transfer, &categories)), - "no match found for category_transfer {:?}", - category_transfer, + bucket_transfer_matchers.iter().any(|m| m(&bucket_transfer, &buckets)), + "no match found for bucket_transfer {:?}", + bucket_transfer, ); } @@ -80,7 +80,7 @@ fn given_test_database_when_run_then_exports_expected_schist_state() { transaction_categorisation_matchers.iter().any(|m| m( &transaction_categorisation, &transactions, - &categories, + &buckets, &accounts, )), "no match found for transaction_categorisation {:?}", -- cgit v1.2.3