summaryrefslogtreecommitdiff
path: root/schist_core/schist_queries
diff options
context:
space:
mode:
Diffstat (limited to 'schist_core/schist_queries')
-rw-r--r--schist_core/schist_queries/src/bucket_transactions.rs65
-rw-r--r--schist_core/schist_queries/src/bucket_transfers.rs82
-rw-r--r--schist_core/schist_queries/src/clear.rs6
-rw-r--r--schist_core/schist_queries/src/lib.rs2
-rw-r--r--schist_core/schist_queries/tests/bucket_transactions.rs160
-rw-r--r--schist_core/schist_queries/tests/buckets.rs83
-rw-r--r--schist_core/schist_queries/tests/category_transfers.rs201
7 files changed, 313 insertions, 286 deletions
diff --git a/schist_core/schist_queries/src/bucket_transactions.rs b/schist_core/schist_queries/src/bucket_transactions.rs
new file mode 100644
index 0000000..da06341
--- /dev/null
+++ b/schist_core/schist_queries/src/bucket_transactions.rs
@@ -0,0 +1,65 @@
+use anyhow::{Context, Result};
+use diesel::{dsl::sum, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+use schist_models::BucketTransaction;
+use schist_schema::schema::bucket_transactions::{
+ self as bucket_transactions_schema, dsl::bucket_transactions as bucket_transactions_table,
+};
+
+pub fn delete_all_bucket_transactions(connection: &mut SqliteConnection) -> Result<usize> {
+ let num_rows_deleted = diesel::delete(bucket_transactions_table)
+ .execute(connection)
+ .with_context(|| "failed to delete all bucket transactions")?;
+ Ok(num_rows_deleted)
+}
+
+pub fn get_all_bucket_transactions(
+ connection: &mut SqliteConnection,
+) -> Result<Vec<BucketTransaction>> {
+ let all_bucket_transactions = bucket_transactions_table
+ .select(BucketTransaction::as_select())
+ .load(connection)
+ .with_context(|| "failed to get all bucket transactions")?;
+ Ok(all_bucket_transactions)
+}
+
+pub fn insert_bucket_transactions(
+ bucket_transactions: &[BucketTransaction],
+ connection: &mut SqliteConnection,
+) -> Result<usize> {
+ let num_rows_inserted = diesel::insert_into(bucket_transactions_table)
+ .values(bucket_transactions)
+ .execute(connection)
+ .with_context(|| insert_err_msg(&bucket_transactions))?;
+ Ok(num_rows_inserted)
+}
+
+fn insert_err_msg(bucket_transactions: &[BucketTransaction]) -> String {
+ format!(
+ "failed to insert bucket transactions: [{}]",
+ bucket_transactions
+ .iter()
+ .map(|ct| ct.id.to_string())
+ .collect::<Vec<String>>()
+ .join(", ")
+ )
+}
+
+pub fn sum_bucket_transaction_amount_per_bucket_id(
+ connection: &mut SqliteConnection,
+) -> Result<Vec<(i32, i64)>> {
+ let sum = bucket_transactions_table
+ .group_by(bucket_transactions_schema::bucket_id)
+ .select((
+ bucket_transactions_schema::bucket_id,
+ sum(bucket_transactions_schema::amount),
+ ))
+ .load::<(i32, Option<i64>)>(connection)
+ .map(|result| {
+ result
+ .iter()
+ .map(|sum| (sum.0, sum.1.unwrap_or(0)))
+ .collect()
+ })
+ .with_context(|| "failed to sum bucket transaction amount per bucket ID")?;
+ Ok(sum)
+}
diff --git a/schist_core/schist_queries/src/bucket_transfers.rs b/schist_core/schist_queries/src/bucket_transfers.rs
deleted file mode 100644
index 652c8e0..0000000
--- a/schist_core/schist_queries/src/bucket_transfers.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-use anyhow::{Context, Result};
-use diesel::{dsl::sum, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
-use schist_models::BucketTransfer;
-use schist_schema::schema::bucket_transfers::{
- self as bucket_transfers_schema, dsl::bucket_transfers as bucket_transfers_table,
-};
-
-pub fn delete_all_bucket_transfers(connection: &mut SqliteConnection) -> Result<usize> {
- let num_rows_deleted = diesel::delete(bucket_transfers_table)
- .execute(connection)
- .with_context(|| "failed to delete all bucket transfers")?;
- Ok(num_rows_deleted)
-}
-
-pub fn get_all_bucket_transfers(connection: &mut SqliteConnection) -> Result<Vec<BucketTransfer>> {
- let all_bucket_transfers = bucket_transfers_table
- .select(BucketTransfer::as_select())
- .load(connection)
- .with_context(|| "failed to get all bucket transfers")?;
- Ok(all_bucket_transfers)
-}
-
-pub fn insert_bucket_transfers(
- bucket_transfers: &[BucketTransfer],
- connection: &mut SqliteConnection,
-) -> Result<usize> {
- let num_rows_inserted = diesel::insert_into(bucket_transfers_table)
- .values(bucket_transfers)
- .execute(connection)
- .with_context(|| insert_err_msg(&bucket_transfers))?;
- Ok(num_rows_inserted)
-}
-
-fn insert_err_msg(bucket_transfers: &[BucketTransfer]) -> String {
- format!(
- "failed to insert bucket transfers: [{}]",
- bucket_transfers
- .iter()
- .map(|ct| ct.id.to_string())
- .collect::<Vec<String>>()
- .join(", ")
- )
-}
-
-pub fn sum_bucket_transfer_quantity_per_from_bucket_id(
- connection: &mut SqliteConnection,
-) -> Result<Vec<(i32, i64)>> {
- let sum = bucket_transfers_table
- .group_by(bucket_transfers_schema::from_bucket_id)
- .select((
- bucket_transfers_schema::from_bucket_id,
- sum(bucket_transfers_schema::amount),
- ))
- .load::<(i32, Option<i64>)>(connection)
- .map(|result| {
- result
- .iter()
- .map(|sum| (sum.0, sum.1.unwrap_or(0)))
- .collect()
- })
- .with_context(|| "failed to sum bucket transfer quantity per from bucket ID")?;
- Ok(sum)
-}
-
-pub fn sum_bucket_transfer_quantity_per_to_bucket_id(
- connection: &mut SqliteConnection,
-) -> Result<Vec<(i32, i64)>> {
- let sum = bucket_transfers_table
- .group_by(bucket_transfers_schema::to_bucket_id)
- .select((
- bucket_transfers_schema::to_bucket_id,
- sum(bucket_transfers_schema::amount),
- ))
- .load::<(i32, Option<i64>)>(connection)
- .map(|vec| {
- vec.iter()
- .map(|(id, sum)| (*id, sum.unwrap_or(0)))
- .collect()
- })
- .with_context(|| "failed to sum bucket transfer quantity per to bucket ID")?;
- Ok(sum)
-}
diff --git a/schist_core/schist_queries/src/clear.rs b/schist_core/schist_queries/src/clear.rs
index a5a82f3..845e109 100644
--- a/schist_core/schist_queries/src/clear.rs
+++ b/schist_core/schist_queries/src/clear.rs
@@ -2,7 +2,9 @@ use anyhow::Result;
use diesel::SqliteConnection;
use crate::{
- account_transfers::delete_all_account_transfers, accounts::delete_all_accounts, bucket_transfers::delete_all_bucket_transfers, buckets::delete_all_buckets, drips::delete_all_drips, pipes::delete_all_pipes, transactions::delete_all_transactions
+ account_transfers::delete_all_account_transfers, accounts::delete_all_accounts,
+ bucket_transactions::delete_all_bucket_transactions, buckets::delete_all_buckets,
+ drips::delete_all_drips, pipes::delete_all_pipes, transactions::delete_all_transactions,
};
pub fn clear(connection: &mut SqliteConnection) -> Result<()> {
@@ -11,7 +13,7 @@ pub fn clear(connection: &mut SqliteConnection) -> Result<()> {
delete_all_pipes(connection)?;
delete_all_transactions(connection)?;
delete_all_accounts(connection)?;
- delete_all_bucket_transfers(connection)?;
+ delete_all_bucket_transactions(connection)?;
delete_all_buckets(connection)?;
Ok(())
}
diff --git a/schist_core/schist_queries/src/lib.rs b/schist_core/schist_queries/src/lib.rs
index ccd558d..ee74d6b 100644
--- a/schist_core/schist_queries/src/lib.rs
+++ b/schist_core/schist_queries/src/lib.rs
@@ -1,6 +1,6 @@
pub mod account_transfers;
pub mod accounts;
-pub mod bucket_transfers;
+pub mod bucket_transactions;
pub mod buckets;
pub mod clear;
pub mod drips;
diff --git a/schist_core/schist_queries/tests/bucket_transactions.rs b/schist_core/schist_queries/tests/bucket_transactions.rs
new file mode 100644
index 0000000..9c877af
--- /dev/null
+++ b/schist_core/schist_queries/tests/bucket_transactions.rs
@@ -0,0 +1,160 @@
+mod common;
+
+use common::test_context::TestContext;
+use diesel::{Connection, SqliteConnection};
+use schist_fakes::{
+ bucket::make_fake_bucket, bucket_transaction::make_fake_bucket_transaction_builder,
+};
+use schist_queries as queries;
+
+#[test]
+fn when_insert_bucket_transactions_then_returns_num_bucket_transactions() {
+ let context = TestContext::new();
+ let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+ let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+ let bucket_transactions = [
+ make_fake_bucket_transaction_builder(0)
+ .bucket_id(0)
+ .build()
+ .unwrap(),
+ make_fake_bucket_transaction_builder(1)
+ .bucket_id(1)
+ .build()
+ .unwrap(),
+ ];
+ let _ = queries::buckets::insert_buckets(&buckets, connection);
+
+ let num_bucket_transactions_inserted =
+ queries::bucket_transactions::insert_bucket_transactions(&bucket_transactions, connection)
+ .unwrap();
+
+ assert_eq!(num_bucket_transactions_inserted, 2);
+}
+
+#[test]
+fn given_bucket_transactions_when_get_all_bucket_transactions_then_return_bucket_transactions() {
+ let context = TestContext::new();
+ let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+ let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+ let bucket_transactions = [
+ make_fake_bucket_transaction_builder(0)
+ .bucket_id(0)
+ .build()
+ .unwrap(),
+ make_fake_bucket_transaction_builder(1)
+ .bucket_id(1)
+ .build()
+ .unwrap(),
+ ];
+ let _ = queries::buckets::insert_buckets(&buckets, connection);
+ let _ =
+ queries::bucket_transactions::insert_bucket_transactions(&bucket_transactions, connection)
+ .unwrap();
+
+ let bucket_transactions_in_db =
+ queries::bucket_transactions::get_all_bucket_transactions(connection).unwrap();
+
+ assert_eq!(bucket_transactions_in_db.len(), bucket_transactions.len());
+ for bucket_transaction in &bucket_transactions {
+ assert!(bucket_transactions_in_db
+ .iter()
+ .any(|bucket_transaction_in_db| bucket_transaction_in_db.eq(&bucket_transaction)));
+ }
+ for bucket_transaction_in_db in bucket_transactions_in_db {
+ assert!(bucket_transactions
+ .iter()
+ .any(|bucket_transaction| bucket_transaction.eq(&bucket_transaction_in_db)));
+ }
+}
+
+#[test]
+fn given_bucket_transactions_when_delete_all_bucket_transactions_then_return_num_of_bucket_transactions(
+) {
+ let context = TestContext::new();
+ let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+ let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+ let bucket_transactions = [
+ make_fake_bucket_transaction_builder(0)
+ .bucket_id(0)
+ .build()
+ .unwrap(),
+ make_fake_bucket_transaction_builder(1)
+ .bucket_id(1)
+ .build()
+ .unwrap(),
+ ];
+ let _ = queries::buckets::insert_buckets(&buckets, connection);
+ let _ =
+ queries::bucket_transactions::insert_bucket_transactions(&bucket_transactions, connection)
+ .unwrap();
+
+ let num_bucket_transactions_deleted =
+ queries::bucket_transactions::delete_all_bucket_transactions(connection).unwrap();
+
+ assert_eq!(num_bucket_transactions_deleted, bucket_transactions.len());
+}
+
+#[test]
+fn given_deleted_bucket_transactions_when_get_all_bucket_transactions_then_return_empty() {
+ let context = TestContext::new();
+ let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+ let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+ let bucket_transactions = [
+ make_fake_bucket_transaction_builder(0)
+ .bucket_id(0)
+ .build()
+ .unwrap(),
+ make_fake_bucket_transaction_builder(1)
+ .bucket_id(1)
+ .build()
+ .unwrap(),
+ ];
+ let _ = queries::buckets::insert_buckets(&buckets, connection);
+ let _ =
+ queries::bucket_transactions::insert_bucket_transactions(&bucket_transactions, connection)
+ .unwrap();
+ let _ = queries::bucket_transactions::delete_all_bucket_transactions(connection).unwrap();
+
+ let bucket_transactions_returned =
+ queries::bucket_transactions::get_all_bucket_transactions(connection).unwrap();
+
+ assert_eq!(bucket_transactions_returned.len(), 0);
+}
+
+#[test]
+fn given_bucket_transactions_when_sum_quantity_per_bucket_id_then_returns_sum_per_bucket_id() {
+ let context = TestContext::new();
+ let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+ let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+ let bucket_transactions = [
+ make_fake_bucket_transaction_builder(0)
+ .bucket_id(0)
+ .amount(1)
+ .build()
+ .unwrap(),
+ make_fake_bucket_transaction_builder(1)
+ .bucket_id(0)
+ .amount(2)
+ .build()
+ .unwrap(),
+ make_fake_bucket_transaction_builder(2)
+ .bucket_id(1)
+ .amount(4)
+ .build()
+ .unwrap(),
+ ];
+ let _ = queries::buckets::insert_buckets(&buckets, connection);
+ let _ =
+ queries::bucket_transactions::insert_bucket_transactions(&bucket_transactions, connection)
+ .unwrap();
+
+ let sums =
+ queries::bucket_transactions::sum_bucket_transaction_amount_per_bucket_id(connection);
+
+ assert!(sums.is_ok());
+ let mut sums = sums.unwrap();
+ sums.sort_by_key(|sum| sum.0);
+ assert_eq!(buckets.len(), sums.len());
+ assert_eq!(3, sums[0].1);
+ assert_eq!(4, sums[1].1);
+}
diff --git a/schist_core/schist_queries/tests/buckets.rs b/schist_core/schist_queries/tests/buckets.rs
new file mode 100644
index 0000000..72dd4c7
--- /dev/null
+++ b/schist_core/schist_queries/tests/buckets.rs
@@ -0,0 +1,83 @@
+mod common;
+
+use common::test_context::TestContext;
+use diesel::{Connection, SqliteConnection};
+use schist_fakes::bucket::make_fake_bucket;
+use schist_models::Bucket;
+use schist_queries as queries;
+
+fn given_buckets(connection: &mut SqliteConnection) -> Vec<Bucket> {
+ let buckets = vec![make_fake_bucket(0), make_fake_bucket(1)];
+ let _ = queries::buckets::insert_buckets(&buckets, connection).unwrap();
+ buckets
+}
+
+#[test]
+fn when_insert_buckets_then_returns_num_buckets() {
+ let context = TestContext::new();
+ let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+ let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
+
+ let num_buckets_inserted = queries::buckets::insert_buckets(&buckets, connection).unwrap();
+
+ assert_eq!(num_buckets_inserted, 2);
+}
+
+#[test]
+fn given_buckets_when_get_all_buckets_then_return_buckets() {
+ let context = TestContext::new();
+ let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+ let buckets = given_buckets(connection);
+
+ let buckets_in_db = queries::buckets::get_all_buckets(connection).unwrap();
+
+ assert_eq!(buckets_in_db.len(), buckets.len());
+ for bucket in &buckets {
+ assert!(buckets_in_db
+ .iter()
+ .any(|bucket_in_db| bucket_in_db.eq(&bucket)));
+ }
+ for bucket_in_db in buckets_in_db {
+ assert!(buckets.iter().any(|bucket| bucket.eq(&bucket_in_db)));
+ }
+}
+
+#[test]
+fn given_buckets_when_delete_all_buckets_then_return_num_of_buckets() {
+ let context = TestContext::new();
+ let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+ let buckets = given_buckets(connection);
+
+ let num_buckets_deleted = queries::buckets::delete_all_buckets(connection).unwrap();
+
+ assert_eq!(num_buckets_deleted, buckets.len());
+}
+
+#[test]
+fn given_deleted_buckets_when_get_all_buckets_then_return_empty() {
+ let context = TestContext::new();
+ let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+ given_buckets(connection);
+ let _ = queries::buckets::delete_all_buckets(connection).unwrap();
+
+ let buckets_returned = queries::buckets::get_all_buckets(connection).unwrap();
+
+ assert_eq!(buckets_returned.len(), 0);
+}
+
+#[test]
+fn given_buckets_when_get_all_ids_then_return_all_ids() {
+ let context = TestContext::new();
+ let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+ let buckets = given_buckets(connection);
+
+ let ids = queries::buckets::get_all_bucket_ids(connection).unwrap();
+
+ assert_eq!(buckets.len(), ids.len());
+ for bucket in &buckets {
+ assert!(ids.iter().any(|id| bucket.id == *id));
+ }
+ for id in ids {
+ assert!(buckets.iter().any(|bucket| bucket.id == id));
+ }
+}
diff --git a/schist_core/schist_queries/tests/category_transfers.rs b/schist_core/schist_queries/tests/category_transfers.rs
deleted file mode 100644
index f7c75a7..0000000
--- a/schist_core/schist_queries/tests/category_transfers.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-mod common;
-
-use common::test_context::TestContext;
-use diesel::{Connection, SqliteConnection};
-use schist_fakes::{bucket::make_fake_bucket, bucket_transfer::make_fake_bucket_transfer_builder};
-use schist_queries as queries;
-
-#[test]
-fn when_insert_bucket_transfers_then_returns_num_bucket_transfers() {
- let context = TestContext::new();
- let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
- let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
- let bucket_transfers = [
- make_fake_bucket_transfer_builder(0)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .build()
- .unwrap(),
- make_fake_bucket_transfer_builder(1)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .build()
- .unwrap(),
- ];
- let _ = queries::buckets::insert_buckets(&buckets, connection);
-
- let num_bucket_transfers_inserted =
- queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
-
- assert_eq!(num_bucket_transfers_inserted, 2);
-}
-
-#[test]
-fn given_bucket_transfers_when_get_all_bucket_transfers_then_return_bucket_transfers() {
- let context = TestContext::new();
- let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
- let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
- let bucket_transfers = [
- make_fake_bucket_transfer_builder(0)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .build()
- .unwrap(),
- make_fake_bucket_transfer_builder(1)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .build()
- .unwrap(),
- ];
- let _ = queries::buckets::insert_buckets(&buckets, connection);
- let _ =
- queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
-
- let bucket_transfers_in_db =
- queries::bucket_transfers::get_all_bucket_transfers(connection).unwrap();
-
- assert_eq!(bucket_transfers_in_db.len(), bucket_transfers.len());
- for bucket_transfer in &bucket_transfers {
- assert!(bucket_transfers_in_db
- .iter()
- .any(|bucket_transfer_in_db| bucket_transfer_in_db.eq(&bucket_transfer)));
- }
- for bucket_transfer_in_db in bucket_transfers_in_db {
- assert!(bucket_transfers
- .iter()
- .any(|bucket_transfer| bucket_transfer.eq(&bucket_transfer_in_db)));
- }
-}
-
-#[test]
-fn given_bucket_transfers_when_delete_all_bucket_transfers_then_return_num_of_bucket_transfers() {
- let context = TestContext::new();
- let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
- let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
- let bucket_transfers = [
- make_fake_bucket_transfer_builder(0)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .build()
- .unwrap(),
- make_fake_bucket_transfer_builder(1)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .build()
- .unwrap(),
- ];
- let _ = queries::buckets::insert_buckets(&buckets, connection);
- let _ =
- queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
-
- let num_bucket_transfers_deleted =
- queries::bucket_transfers::delete_all_bucket_transfers(connection).unwrap();
-
- assert_eq!(num_bucket_transfers_deleted, bucket_transfers.len());
-}
-
-#[test]
-fn given_deleted_bucket_transfers_when_get_all_bucket_transfers_then_return_empty() {
- let context = TestContext::new();
- let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
- let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
- let bucket_transfers = [
- make_fake_bucket_transfer_builder(0)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .build()
- .unwrap(),
- make_fake_bucket_transfer_builder(1)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .build()
- .unwrap(),
- ];
- let _ = queries::buckets::insert_buckets(&buckets, connection);
- let _ =
- queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
- let _ = queries::bucket_transfers::delete_all_bucket_transfers(connection).unwrap();
-
- let bucket_transfers_returned =
- queries::bucket_transfers::get_all_bucket_transfers(connection).unwrap();
-
- assert_eq!(bucket_transfers_returned.len(), 0);
-}
-
-#[test]
-fn given_bucket_transfers_when_sum_quantity_per_from_bucket_id_then_returns_sum_per_from_bucket_id()
-{
- let context = TestContext::new();
- let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
- let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
- let bucket_transfers = [
- make_fake_bucket_transfer_builder(0)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .amount(1)
- .build()
- .unwrap(),
- make_fake_bucket_transfer_builder(1)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .amount(2)
- .build()
- .unwrap(),
- make_fake_bucket_transfer_builder(2)
- .from_bucket_id(1)
- .to_bucket_id(0)
- .amount(4)
- .build()
- .unwrap(),
- ];
- let _ = queries::buckets::insert_buckets(&buckets, connection);
- let _ =
- queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
-
- let sums =
- queries::bucket_transfers::sum_bucket_transfer_quantity_per_from_bucket_id(connection);
-
- assert!(sums.is_ok());
- let mut sums = sums.unwrap();
- sums.sort_by_key(|sum| sum.0);
- assert_eq!(buckets.len(), sums.len());
- assert_eq!(3, sums[0].1);
- assert_eq!(4, sums[1].1);
-}
-
-#[test]
-fn given_bucket_transfers_when_sum_quantity_per_to_bucket_id_then_returns_sum_per_to_bucket_id() {
- let context = TestContext::new();
- let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
- let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
- let bucket_transfers = [
- make_fake_bucket_transfer_builder(0)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .amount(1)
- .build()
- .unwrap(),
- make_fake_bucket_transfer_builder(1)
- .from_bucket_id(0)
- .to_bucket_id(1)
- .amount(2)
- .build()
- .unwrap(),
- make_fake_bucket_transfer_builder(2)
- .from_bucket_id(1)
- .to_bucket_id(0)
- .amount(4)
- .build()
- .unwrap(),
- ];
- let _ = queries::buckets::insert_buckets(&buckets, connection);
- let _ =
- queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
-
- let sums = queries::bucket_transfers::sum_bucket_transfer_quantity_per_to_bucket_id(connection);
-
- assert!(sums.is_ok());
- let mut sums = sums.unwrap();
- sums.sort_by_key(|sum| sum.0);
- assert_eq!([(0, 4), (1, 3)], sums.as_slice());
-}
generated by cgit v1.2.3 (git 2.25.1) at 2026-09-08 16:44:23 +0000