renames categories -> buckets, refactors category_transfers -> bucket_transactions

3 files changed, 243 insertions, 201 deletions

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());
-}