rename category -> bucket

4 files changed, 150 insertions, 150 deletions

diff --git a/schist_core/schist_queries/tests/budget_drips.rs b/schist_core/schist_queries/tests/budget_drips.rs
index ac33885..7c5bd4d 100644
--- a/schist_core/schist_queries/tests/budget_drips.rs
+++ b/schist_core/schist_queries/tests/budget_drips.rs
@@ -2,29 +2,29 @@ mod common;
 
 use common::test_context::TestContext;
 use diesel::{Connection, SqliteConnection};
-use schist_fakes::{budget_drip::make_fake_budget_drip_builder, category::make_fake_category};
-use schist_models::{category::Category, date_utc::DateUtc};
+use schist_fakes::{budget_drip::make_fake_budget_drip_builder, bucket::make_fake_bucket};
+use schist_models::{bucket::Bucket, date_utc::DateUtc};
 use schist_queries as queries;
 
-fn given_categories(connection: &mut SqliteConnection) -> Vec<Category> {
-    let categories = vec![make_fake_category(0), make_fake_category(1)];
-    let _ = queries::categories::insert_categories(&categories, connection);
-    categories
+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);
+    buckets
 }
 
 #[test]
 fn when_insert_budget_drips_then_returns_num_budget_drips() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
     let budget_drips = [
         make_fake_budget_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
         make_fake_budget_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
     ];
 
@@ -34,14 +34,14 @@ fn when_insert_budget_drips_then_returns_num_budget_drips() {
 }
 
 #[test]
-fn given_budget_drip_when_insert_budget_drip_same_category_and_same_date_then_return_err() {
+fn given_budget_drip_when_insert_budget_drip_same_bucket_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 _buckets = given_buckets(connection);
 
     let budget_drips_1 = [
         make_fake_budget_drip_builder(0)
-            .category_id(0)
+            .bucket_id(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .build().unwrap()
     ];
@@ -49,7 +49,7 @@ fn given_budget_drip_when_insert_budget_drip_same_category_and_same_date_then_re
 
     let budget_drips_2 = [
         make_fake_budget_drip_builder(1)
-            .category_id(0)
+            .bucket_id(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .build().unwrap()
     ];
@@ -59,14 +59,14 @@ fn given_budget_drip_when_insert_budget_drip_same_category_and_same_date_then_re
 }
 
 #[test]
-fn given_budget_drip_when_insert_budget_drip_different_category_and_same_date_then_return_num_budget_drips_inserted() {
+fn given_budget_drip_when_insert_budget_drip_different_bucket_and_same_date_then_return_num_budget_drips_inserted() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
 
     let budget_drips_1 = [
         make_fake_budget_drip_builder(0)
-            .category_id(0)
+            .bucket_id(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .build().unwrap()
     ];
@@ -74,7 +74,7 @@ fn given_budget_drip_when_insert_budget_drip_different_category_and_same_date_th
 
     let budget_drips_2 = [
         make_fake_budget_drip_builder(1)
-            .category_id(1)
+            .bucket_id(1)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .build().unwrap()
     ];
@@ -85,14 +85,14 @@ fn given_budget_drip_when_insert_budget_drip_different_category_and_same_date_th
 }
 
 #[test]
-fn given_budget_drip_when_insert_budget_drip_same_category_and_different_date_then_return_num_budget_drips_inserted() {
+fn given_budget_drip_when_insert_budget_drip_same_bucket_and_different_date_then_return_num_budget_drips_inserted() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
 
     let budget_drips_1 = [
         make_fake_budget_drip_builder(0)
-            .category_id(0)
+            .bucket_id(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
             .build().unwrap()
     ];
@@ -100,7 +100,7 @@ fn given_budget_drip_when_insert_budget_drip_same_category_and_different_date_th
 
     let budget_drips_2 = [
         make_fake_budget_drip_builder(1)
-            .category_id(0)
+            .bucket_id(0)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
             .build().unwrap()
     ];
@@ -114,15 +114,15 @@ fn given_budget_drip_when_insert_budget_drip_same_category_and_different_date_th
 fn given_budget_drips_when_get_all_budget_drips_then_return_budget_drips() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
     let budget_drips = [
         make_fake_budget_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
         make_fake_budget_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
     ];
     let _ = queries::budget_drips::insert_budget_drips(&budget_drips, connection).unwrap();
@@ -144,15 +144,15 @@ fn given_budget_drips_when_get_all_budget_drips_then_return_budget_drips() {
 fn given_budget_drips_when_delete_all_budget_drips_then_return_num_of_budget_drips() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
     let budget_drips = [
         make_fake_budget_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
         make_fake_budget_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
     ];
     let _ = queries::budget_drips::insert_budget_drips(&budget_drips, connection).unwrap();
@@ -166,15 +166,15 @@ fn given_budget_drips_when_delete_all_budget_drips_then_return_num_of_budget_dri
 fn given_deleted_budget_drips_when_get_all_budget_drips_then_return_empty() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let _categories = given_categories(connection);
+    let _buckets = given_buckets(connection);
     let budget_drips = [
         make_fake_budget_drip_builder(0)
             .date(DateUtc::from_ymd(2020, 12, 25).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
         make_fake_budget_drip_builder(1)
             .date(DateUtc::from_ymd(2020, 12, 26).unwrap())
-            .category_id(0)
+            .bucket_id(0)
             .build().unwrap(),
     ];
     let _ = queries::budget_drips::insert_budget_drips(&budget_drips, connection).unwrap();
diff --git a/schist_core/schist_queries/tests/categories.rs b/schist_core/schist_queries/tests/categories.rs
index 915e853..5ef6552 100644
--- a/schist_core/schist_queries/tests/categories.rs
+++ b/schist_core/schist_queries/tests/categories.rs
@@ -2,80 +2,80 @@ mod common;
 
 use common::test_context::TestContext;
 use diesel::{Connection, SqliteConnection};
-use schist_fakes::category::make_fake_category;
-use schist_models::category::Category;
+use schist_fakes::bucket::make_fake_bucket;
+use schist_models::bucket::Bucket;
 use schist_queries as queries;
 
-fn given_categories(connection: &mut SqliteConnection) -> Vec<Category> {
-    let categories = vec![make_fake_category(0), make_fake_category(1)];
-    let _ = queries::categories::insert_categories(&categories, connection).unwrap();
-    categories
+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_categories_then_returns_num_categories() {
+fn when_insert_buckets_then_returns_num_buckets() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = [make_fake_category(0), make_fake_category(1)];
+    let buckets = [make_fake_bucket(0), make_fake_bucket(1)];
 
-    let num_categories_inserted = queries::categories::insert_categories(&categories, connection).unwrap();
+    let num_buckets_inserted = queries::buckets::insert_buckets(&buckets, connection).unwrap();
 
-    assert_eq!(num_categories_inserted, 2);
+    assert_eq!(num_buckets_inserted, 2);
 }
 
 #[test]
-fn given_categories_when_get_all_categories_then_return_categories() {
+fn given_buckets_when_get_all_buckets_then_return_buckets() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
-    let categories = given_categories(connection);
+    let buckets = given_buckets(connection);
 
-    let categories_in_db = queries::categories::get_all_categories(connection).unwrap();
+    let buckets_in_db = queries::buckets::get_all_buckets(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)));
+    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 category_in_db in categories_in_db {
-        assert!(categories.iter().any(|category| category.eq(&category_in_db)));
+    for bucket_in_db in buckets_in_db {
+        assert!(buckets.iter().any(|bucket| bucket.eq(&bucket_in_db)));
     }
 }
 
 #[test]
-fn given_categories_when_delete_all_categories_then_return_num_of_categories() {
+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 categories = given_categories(connection);
+    let buckets = given_buckets(connection);
 
-    let num_categories_deleted = queries::categories::delete_all_categories(connection).unwrap();
+    let num_buckets_deleted = queries::buckets::delete_all_buckets(connection).unwrap();
 
-    assert_eq!(num_categories_deleted, categories.len());
+    assert_eq!(num_buckets_deleted, buckets.len());
 }
 
 #[test]
-fn given_deleted_categories_when_get_all_categories_then_return_empty() {
+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_categories(connection);
-    let _ = queries::categories::delete_all_categories(connection).unwrap();
+    given_buckets(connection);
+    let _ = queries::buckets::delete_all_buckets(connection).unwrap();
 
-    let categories_returned = queries::categories::get_all_categories(connection).unwrap();
+    let buckets_returned = queries::buckets::get_all_buckets(connection).unwrap();
 
-    assert_eq!(categories_returned.len(), 0);
+    assert_eq!(buckets_returned.len(), 0);
 }
 
 #[test]
-fn given_categories_when_get_all_ids_then_return_all_ids() {
+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 categories = given_categories(connection);
+    let buckets = given_buckets(connection);
 
-    let ids = queries::categories::get_all_category_ids(connection).unwrap();
+    let ids = queries::buckets::get_all_bucket_ids(connection).unwrap();
 
-    assert_eq!(categories.len(), ids.len());
-    for category in &categories {
-        assert!(ids.iter().any(|id| category.id == *id));
+    assert_eq!(buckets.len(), ids.len());
+    for bucket in &buckets {
+        assert!(ids.iter().any(|id| bucket.id == *id));
     }
     for id in ids {
-        assert!(categories.iter().any(|category| category.id == id));
+        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
index f37a668..e913dcb 100644
--- a/schist_core/schist_queries/tests/category_transfers.rs
+++ b/schist_core/schist_queries/tests/category_transfers.rs
@@ -2,125 +2,125 @@ mod common;
 
 use common::test_context::TestContext;
 use diesel::{Connection, SqliteConnection};
-use schist_fakes::{category::make_fake_category, category_transfer::make_fake_category_transfer_builder};
+use schist_fakes::{bucket::make_fake_bucket, bucket_transfer::make_fake_bucket_transfer_builder};
 use schist_queries as queries;
 
 #[test]
-fn when_insert_category_transfers_then_returns_num_category_transfers() {
+fn when_insert_bucket_transfers_then_returns_num_bucket_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 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::categories::insert_categories(&categories, connection);
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
 
-    let num_category_transfers_inserted = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+    let num_bucket_transfers_inserted = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    assert_eq!(num_category_transfers_inserted, 2);
+    assert_eq!(num_bucket_transfers_inserted, 2);
 }
 
 #[test]
-fn given_category_transfers_when_get_all_category_transfers_then_return_category_transfers() {
+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 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 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::categories::insert_categories(&categories, connection);
-    let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
+    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let category_transfers_in_db = queries::category_transfers::get_all_category_transfers(connection).unwrap();
+    let bucket_transfers_in_db = queries::bucket_transfers::get_all_bucket_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)));
+    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 category_transfer_in_db in category_transfers_in_db {
-        assert!(category_transfers.iter().any(|category_transfer| category_transfer.eq(&category_transfer_in_db)));
+    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_category_transfers_when_delete_all_category_transfers_then_return_num_of_category_transfers() {
+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 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 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::categories::insert_categories(&categories, connection);
-    let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
+    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let num_category_transfers_deleted = queries::category_transfers::delete_all_category_transfers(connection).unwrap();
+    let num_bucket_transfers_deleted = queries::bucket_transfers::delete_all_bucket_transfers(connection).unwrap();
 
-    assert_eq!(num_category_transfers_deleted, category_transfers.len());
+    assert_eq!(num_bucket_transfers_deleted, bucket_transfers.len());
 }
 
 #[test]
-fn given_deleted_category_transfers_when_get_all_category_transfers_then_return_empty() {
+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 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 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::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 _ = 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 category_transfers_returned = queries::category_transfers::get_all_category_transfers(connection).unwrap();
+    let bucket_transfers_returned = queries::bucket_transfers::get_all_bucket_transfers(connection).unwrap();
 
-    assert_eq!(category_transfers_returned.len(), 0);
+    assert_eq!(bucket_transfers_returned.len(), 0);
 }
 
 #[test]
-fn given_category_transfers_when_sum_quantity_per_from_category_id_then_returns_sum_per_from_category_id() {
+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 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 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).quantity(1).build().unwrap(),
+        make_fake_bucket_transfer_builder(1).from_bucket_id(0).to_bucket_id(1).quantity(2).build().unwrap(),
+        make_fake_bucket_transfer_builder(2).from_bucket_id(1).to_bucket_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 _ = queries::buckets::insert_buckets(&buckets, connection);
+    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let sums = queries::category_transfers::sum_category_transfer_quantity_per_from_category_id(connection);
+    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!(categories.len(), sums.len());
+    assert_eq!(buckets.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() {
+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 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 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).quantity(1).build().unwrap(),
+        make_fake_bucket_transfer_builder(1).from_bucket_id(0).to_bucket_id(1).quantity(2).build().unwrap(),
+        make_fake_bucket_transfer_builder(2).from_bucket_id(1).to_bucket_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 _ = queries::buckets::insert_buckets(&buckets, connection);
+    let _ = queries::bucket_transfers::insert_bucket_transfers(&bucket_transfers, connection).unwrap();
 
-    let sums = queries::category_transfers::sum_category_transfer_quantity_per_to_category_id(connection);
+    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!(categories.len(), sums.len());
+    assert_eq!(buckets.len(), sums.len());
     assert_eq!(4, sums[0].1);
     assert_eq!(3, sums[1].1);
 }
diff --git a/schist_core/schist_queries/tests/transaction_categorisations.rs b/schist_core/schist_queries/tests/transaction_categorisations.rs
index 13864b4..bb88896 100644
--- a/schist_core/schist_queries/tests/transaction_categorisations.rs
+++ b/schist_core/schist_queries/tests/transaction_categorisations.rs
@@ -2,8 +2,8 @@ mod common;
 
 use common::test_context::TestContext;
 use diesel::{Connection, SqliteConnection};
-use schist_fakes::{account::make_fake_account, category::make_fake_category, transaction::make_fake_transaction_builder, transaction_categorisation::make_fake_transaction_categorisation_builder};
-use schist_models::{account::Account, category::Category, transaction::Transaction};
+use schist_fakes::{account::make_fake_account, bucket::make_fake_bucket, transaction::make_fake_transaction_builder, transaction_categorisation::make_fake_transaction_categorisation_builder};
+use schist_models::{account::Account, bucket::Bucket, transaction::Transaction};
 use schist_queries as queries;
 
 fn given_accounts(connection: &mut SqliteConnection) -> Vec<Account> {
@@ -12,10 +12,10 @@ fn given_accounts(connection: &mut SqliteConnection) -> Vec<Account> {
     accounts
 }
 
-fn given_categories(connection: &mut SqliteConnection) -> Vec<Category> {
-    let categories = vec![make_fake_category(0), make_fake_category(1)];
-    let _ = queries::categories::insert_categories(&categories, connection);
-    categories
+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);
+    buckets
 }
 
 fn given_transactions(connection: &mut SqliteConnection) -> Vec<Transaction> {
@@ -32,11 +32,11 @@ fn when_insert_transaction_categorisations_then_returns_num_transaction_categori
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     given_accounts(connection);
-    given_categories(connection);
+    given_buckets(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(),
+        make_fake_transaction_categorisation_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).bucket_id(0).build().unwrap(),
     ];
 
     let num_transaction_categorisations_inserted = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection).unwrap();
@@ -49,11 +49,11 @@ fn given_transaction_categorisations_when_get_all_transaction_categorisations_th
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     given_accounts(connection);
-    given_categories(connection);
+    given_buckets(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(),
+        make_fake_transaction_categorisation_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).bucket_id(0).build().unwrap(),
     ];
     let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection);
 
@@ -73,11 +73,11 @@ fn given_transaction_categorisations_when_delete_all_transaction_categorisations
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     given_accounts(connection);
-    given_categories(connection);
+    given_buckets(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(),
+        make_fake_transaction_categorisation_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).bucket_id(0).build().unwrap(),
     ];
     let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection);
 
@@ -91,11 +91,11 @@ fn given_deleted_transaction_categorisations_when_get_all_transaction_categorisa
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     given_accounts(connection);
-    given_categories(connection);
+    given_buckets(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(),
+        make_fake_transaction_categorisation_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).bucket_id(0).build().unwrap(),
     ];
     let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection);
     let _ = queries::transaction_categorisations::delete_all_transaction_categorisations(connection);
@@ -106,25 +106,25 @@ fn given_deleted_transaction_categorisations_when_get_all_transaction_categorisa
 }
 
 #[test]
-fn given_transaction_categorisations_when_sum_quantity_per_category_id_then_returns_sum_quantity_per_category_id() {
+fn given_transaction_categorisations_when_sum_quantity_per_bucket_id_then_returns_sum_quantity_per_bucket_id() {
     let context = TestContext::new();
     let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
     given_accounts(connection);
-    let categories = given_categories(connection);
+    let buckets = given_buckets(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(),
+        make_fake_transaction_categorisation_builder(0).bucket_id(0).quantity(1).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).bucket_id(0).quantity(2).build().unwrap(),
+        make_fake_transaction_categorisation_builder(2).bucket_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);
+    let sums = queries::transaction_categorisations::sum_transaction_categorisation_quantity_per_bucket_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!(buckets.len(), sums.len());
     assert_eq!(3, sums[0].1);
     assert_eq!(4, sums[1].1);
 }