Integration tests for basic CRD queries

38 files changed, 822 insertions, 48 deletions

diff --git a/backend/core/Cargo.lock b/backend/core/Cargo.lock
index a889422..649a043 100644
--- a/backend/core/Cargo.lock
+++ b/backend/core/Cargo.lock
@@ -35,8 +35,10 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "chrono",
+ "derive_builder",
  "diesel",
  "diesel_migrations",
+ "libsqlite3-sys",
  "serde",
 ]
 
@@ -127,6 +129,37 @@ dependencies = [
 ]
 
 [[package]]
+name = "derive_builder"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "507dfb09ea8b7fa618fcf76e953f4f5e192547945816d5358edffe39f6f94947"
+dependencies = [
+ "derive_builder_macro",
+]
+
+[[package]]
+name = "derive_builder_core"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d5bcf7b024d6835cfb3d473887cd966994907effbe9227e8c8219824d06c4e8"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "derive_builder_macro"
+version = "0.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab63b0e2bf4d5928aff72e83a7dace85d7bba5fe12dcc3c5a572d78caffd3f3c"
+dependencies = [
+ "derive_builder_core",
+ "syn",
+]
+
+[[package]]
 name = "diesel"
 version = "2.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -280,6 +313,7 @@ version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149"
 dependencies = [
+ "cc",
  "pkg-config",
  "vcpkg",
 ]
diff --git a/backend/core/Cargo.toml b/backend/core/Cargo.toml
index bf87568..406e5e5 100644
--- a/backend/core/Cargo.toml
+++ b/backend/core/Cargo.toml
@@ -6,6 +6,10 @@ edition = "2021"
 [dependencies]
 anyhow = { version = "1.0.0" }
 chrono = { version = "0.4.38", features = ["serde"] }
+derive_builder = { version = "0.20.2" }
 diesel = { version = "2.2.0", features = ["sqlite"] }
 diesel_migrations = "2.2.0"
 serde = { version = "1.0.209",  features = ["derive"] }
+
+[dev-dependencies]
+libsqlite3-sys = { version = "0.30.1", features = ["bundled"] }
diff --git a/backend/core/src/models/account.rs b/backend/core/src/models/account.rs
index c10bd5f..fcd5270 100644
--- a/backend/core/src/models/account.rs
+++ b/backend/core/src/models/account.rs
@@ -1,7 +1,7 @@
 use diesel::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use super::date_time_utc::DateTimeUtc;
+use crate::models::date_time_utc::DateTimeUtc;
 
 #[derive(
     Insertable, Queryable, Identifiable, Selectable, Debug, PartialEq, Clone, Serialize, Deserialize,
diff --git a/backend/core/src/models/budget.rs b/backend/core/src/models/budget.rs
index cc18f2e..08a1c72 100644
--- a/backend/core/src/models/budget.rs
+++ b/backend/core/src/models/budget.rs
@@ -32,7 +32,7 @@ mod test {
         let budget_update = BudgetUpdate {
             id: 0,
             category_id: 1,
-            date: DateTimeUtc::new(Utc::now()),
+            date: DateTimeUtc::new(&Utc::now()),
             new_budget: quantity,
             new_period: period,
         };
diff --git a/backend/core/src/models/budget_update.rs b/backend/core/src/models/budget_update.rs
index 8600419..3500d8e 100644
--- a/backend/core/src/models/budget_update.rs
+++ b/backend/core/src/models/budget_update.rs
@@ -1,3 +1,4 @@
+use derive_builder::Builder;
 use diesel::prelude::*;
 use serde::Serialize;
 
@@ -5,7 +6,7 @@ use crate::models::category::Category;
 
 use super::date_time_utc::DateTimeUtc;
 
-#[derive(Clone, Serialize, Queryable, Identifiable, Selectable, Associations, Debug, PartialEq, Insertable)]
+#[derive(Builder, Clone, Serialize, Queryable, Identifiable, Selectable, Associations, Debug, PartialEq, Insertable)]
 #[diesel(table_name = crate::schema::budget_updates)]
 #[diesel(belongs_to(Category))]
 pub struct BudgetUpdate {
diff --git a/backend/core/src/models/category.rs b/backend/core/src/models/category.rs
index 595cff6..55c7b97 100644
--- a/backend/core/src/models/category.rs
+++ b/backend/core/src/models/category.rs
@@ -1,7 +1,8 @@
+use derive_builder::Builder;
 use diesel::prelude::*;
 use serde::{Deserialize, Serialize};
 
-#[derive(Queryable, Identifiable, Selectable, Debug, PartialEq, Serialize, Deserialize, Insertable)]
+#[derive(Builder, Queryable, Identifiable, Selectable, Debug, PartialEq, Serialize, Deserialize, Insertable)]
 #[diesel(table_name = crate::schema::categories)]
 pub struct Category {
     pub id: i32,
diff --git a/backend/core/src/models/category_transfer.rs b/backend/core/src/models/category_transfer.rs
index a048a07..7b36054 100644
--- a/backend/core/src/models/category_transfer.rs
+++ b/backend/core/src/models/category_transfer.rs
@@ -1,6 +1,7 @@
+use derive_builder::Builder;
 use diesel::prelude::*;
 
-#[derive(Queryable, Identifiable, Selectable, Debug, PartialEq, Insertable)]
+#[derive(Builder, Queryable, Identifiable, Selectable, Debug, PartialEq, Insertable)]
 #[diesel(table_name = crate::schema::category_transfers)]
 pub struct CategoryTransfer {
     pub id: i32,
diff --git a/backend/core/src/models/date_time_utc.rs b/backend/core/src/models/date_time_utc.rs
index 52c0cc6..d59d8f4 100644
--- a/backend/core/src/models/date_time_utc.rs
+++ b/backend/core/src/models/date_time_utc.rs
@@ -1,4 +1,4 @@
-use anyhow::Result;
+use anyhow::{Error, Result};
 use chrono::{DateTime, Datelike, Utc};
 use diesel::{
     backend::Backend,
@@ -17,40 +17,88 @@ use serde::{Deserialize, Serialize};
     PartialOrd,
     Serialize,
     Deserialize,
-    Copy,
     Clone,
     Debug,
     AsExpression,
     FromSqlRow,
 )]
 #[diesel(sql_type=Text)]
-pub struct DateTimeUtc(DateTime<Utc>);
+pub struct DateTimeUtc {
+    chrono_datetime_utc: DateTime<Utc>,
+}
 
 impl DateTimeUtc {
     pub fn day_diff(&self, other: &DateTimeUtc) -> u32 {
-        self.0
+        self.chrono_datetime_utc
             .num_days_from_ce()
-            .abs_diff(other.0.num_days_from_ce())
+            .abs_diff(other.chrono_datetime_utc.num_days_from_ce())
     }
 
-    pub fn to_day_str(&self) -> String {
-        self.0
-            .to_rfc3339()
-            .split_at_checked(10)
-            .map(|(day_str, _)| String::from(day_str))
-            .unwrap_or_else(|| String::from(""))
+    pub fn new(chrono_datetime_utc: &DateTime<Utc>) -> Self {
+        Self {
+            chrono_datetime_utc: chrono_datetime_utc.clone(),
+        }
     }
 
-    pub fn new(date_time_utc: DateTime<Utc>) -> Self {
-        Self(date_time_utc)
+    pub fn now() -> Self {
+        Self::new(&Utc::now())
     }
 
+    /// Constructs DateTimeUtc from a day string, YYYY-MM-DD, in UTC
+    /// Example: "2024-10-24" -> Midnight 24 Oct 2024 UTC
+    pub fn from_day_str(day_str: &str) -> Result<Self> {
+        if !Self::is_day_str(day_str) {
+            Err(Error::msg(format!("{} is not a day string in YYYY-MM-DD format", day_str)))
+        } else {
+            let mut date_str = String::from(day_str);
+            date_str.push_str("T00:00:00.000Z");
+            Ok(Self::from_date_str(&date_str)?)
+        }
+    }
+
+    /// Constructs DateTimeUtc from a date string in ISO format, in UTC
+    /// Example: "2024-10-24T10:30:00.000" -> 10.30am 24 Oct 2024 UTC
     pub fn from_date_str(date_time_utc: &str) -> Result<Self> {
-        Ok(Self(date_time_utc.parse::<DateTime<Utc>>()?))
+        let chrono_datetime_utc = date_time_utc.parse::<DateTime<Utc>>()?;
+        Ok(Self {
+            chrono_datetime_utc,
+        })
     }
 
-    pub fn now() -> Self {
-        Self(Utc::now())
+    /// Converts to a day string, YYYY-MM-DD, in UTC
+    /// Example: 10.30am 24 Oct 2024 UTC -> "2024-10-24"
+    pub fn to_day_str(&self) -> String {
+        let date_str = self.to_date_str();
+        let day_str = date_str
+            .split_at_checked(10)
+            .unwrap()
+            .0;
+        String::from(day_str)
+    }
+
+    /// Converts to a date string in ISO format, in UTC
+    /// Example: 10.30am 24 Oct 2024 UTC -> "2024-10-24T10:30:00.000Z"
+    pub fn to_date_str(&self) -> String {
+        self.chrono_datetime_utc.to_rfc3339()
+    }
+
+
+    fn is_day_str(str: &str) -> bool {
+        if str.len() != 10 {
+            return false;
+        }
+        for (ix, ch) in str.chars().enumerate() {
+            if ix == 4 || ix == 7 {
+                if ch != '-' {
+                    return false;
+                }
+            } else {
+                if ch < '0' || ch > '9' {
+                    return false;
+                }
+            }
+        }
+        return true;
     }
 }
 
@@ -59,16 +107,15 @@ impl ToSql<Text, Sqlite> for DateTimeUtc {
         &'b self,
         out: &mut diesel::serialize::Output<'b, '_, Sqlite>,
     ) -> serialize::Result {
-        out.set_value(self.to_day_str());
-        Ok(diesel::serialize::IsNull::No)
+        out.set_value(self.to_date_str());
+        Ok(serialize::IsNull::No)
     }
 }
 
 impl FromSql<Text, Sqlite> for DateTimeUtc {
     fn from_sql(bytes: <Sqlite as Backend>::RawValue<'_>) -> deserialize::Result<DateTimeUtc> {
-        let str: String = FromSql::<Text, Sqlite>::from_sql(bytes)?;
-        let date_time = str.as_str().parse::<DateTime<Utc>>()?;
-        Ok(DateTimeUtc(date_time))
+        let str = <String as FromSql<Text, Sqlite>>::from_sql(bytes)?;
+        Ok(Self::from_date_str(&str)?)
     }
 }
 
@@ -80,9 +127,9 @@ mod test {
 
     #[test]
     fn given_midnight_when_day_diff_next_midnight_less_1s_then_return_0() {
-        let start = DateTimeUtc::new(Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap().to_utc());
+        let start = DateTimeUtc::new(&Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap().to_utc());
         let end = DateTimeUtc::new(
-            Utc.with_ymd_and_hms(2000, 1, 1, 23, 59, 59)
+            &Utc.with_ymd_and_hms(2000, 1, 1, 23, 59, 59)
                 .unwrap()
                 .to_utc(),
         );
@@ -96,8 +143,8 @@ mod test {
 
     #[test]
     fn given_midnight_when_day_diff_next_midnight_then_return_1() {
-        let start = DateTimeUtc::new(Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap().to_utc());
-        let end = DateTimeUtc::new(Utc.with_ymd_and_hms(2000, 1, 2, 0, 0, 0).unwrap().to_utc());
+        let start = DateTimeUtc::new(&Utc.with_ymd_and_hms(2000, 1, 1, 0, 0, 0).unwrap().to_utc());
+        let end = DateTimeUtc::new(&Utc.with_ymd_and_hms(2000, 1, 2, 0, 0, 0).unwrap().to_utc());
 
         let day_diff = start.day_diff(&end);
         let neg_day_diff = end.day_diff(&start);
@@ -109,11 +156,11 @@ mod test {
     #[test]
     fn given_midnight_less_1s_when_day_diff_midnight_then_return_1() {
         let start = DateTimeUtc::new(
-            Utc.with_ymd_and_hms(2000, 1, 1, 23, 59, 59)
+            &Utc.with_ymd_and_hms(2000, 1, 1, 23, 59, 59)
                 .unwrap()
                 .to_utc(),
         );
-        let end = DateTimeUtc::new(Utc.with_ymd_and_hms(2000, 1, 2, 0, 0, 0).unwrap().to_utc());
+        let end = DateTimeUtc::new(&Utc.with_ymd_and_hms(2000, 1, 2, 0, 0, 0).unwrap().to_utc());
 
         let day_diff = start.day_diff(&end);
         let neg_day_diff = end.day_diff(&start);
@@ -125,12 +172,11 @@ mod test {
     #[test]
     fn given_23_nov_1970_when_to_day_str_then_return_iso_day_str() {
         let date_time_utc = DateTimeUtc::new(
-            Utc.with_ymd_and_hms(1970, 11, 23, 0, 0, 0)
+            &Utc.with_ymd_and_hms(1970, 11, 23, 0, 0, 0)
                 .unwrap()
                 .to_utc(),
         );
-        let day_str = date_time_utc.to_day_str();
 
-        assert_eq!(day_str, "1970-11-23");
+        assert_eq!(date_time_utc.to_day_str(), "1970-11-23");
     }
 }
diff --git a/backend/core/src/models/transaction.rs b/backend/core/src/models/transaction.rs
index 5f85689..edfabce 100644
--- a/backend/core/src/models/transaction.rs
+++ b/backend/core/src/models/transaction.rs
@@ -1,10 +1,11 @@
+use derive_builder::Builder;
 use diesel::prelude::*;
 
 use crate::models::account::Account;
 
 use super::date_time_utc::DateTimeUtc;
 
-#[derive(Queryable, Identifiable, Selectable, Insertable, Associations, Debug, PartialEq)]
+#[derive(Builder, Queryable, Identifiable, Selectable, Insertable, Associations, Debug, PartialEq)]
 #[diesel(table_name = crate::schema::transactions)]
 #[diesel(belongs_to(Account))]
 pub struct Transaction {
diff --git a/backend/core/src/models/transaction_categorisation.rs b/backend/core/src/models/transaction_categorisation.rs
index 45591a5..c6ac6ea 100644
--- a/backend/core/src/models/transaction_categorisation.rs
+++ b/backend/core/src/models/transaction_categorisation.rs
@@ -1,6 +1,7 @@
+use derive_builder::Builder;
 use diesel::prelude::*;
 
-#[derive(Queryable, Identifiable, Selectable, Insertable, Debug, PartialEq)]
+#[derive(Builder, Queryable, Identifiable, Selectable, Insertable, Debug, PartialEq)]
 #[diesel(table_name = crate::schema::transaction_categorisations)]
 pub struct TransactionCategorisation {
     pub id: i32,
diff --git a/backend/core/src/queries/category_transfers/get_all.rs b/backend/core/src/queries/category_transfers/get_all.rs
new file mode 100644
index 0000000..73d7e10
--- /dev/null
+++ b/backend/core/src/queries/category_transfers/get_all.rs
@@ -0,0 +1,11 @@
+use anyhow::{Context, Result};
+use crate::{models::category_transfer::CategoryTransfer, schema::category_transfers::dsl::category_transfers as category_transfers_table};
+use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+
+pub fn get_all_category_transfers(connection: &mut SqliteConnection) -> Result<Vec<CategoryTransfer>> {
+    let all_category_transfers = category_transfers_table
+        .select(CategoryTransfer::as_select())
+        .load(connection)
+        .with_context(|| "failed to get all category transfers")?;
+    Ok(all_category_transfers)
+}
diff --git a/backend/core/src/queries/category_transfers/mod.rs b/backend/core/src/queries/category_transfers/mod.rs
index 68f32f4..eed7946 100644
--- a/backend/core/src/queries/category_transfers/mod.rs
+++ b/backend/core/src/queries/category_transfers/mod.rs
@@ -1,9 +1,11 @@
 mod delete_all;
+mod get_all;
 mod insert;
 mod sum_quantity_per_from_category_id;
 mod sum_quantity_per_to_category_id;
 
 pub use delete_all::delete_all_category_transfers;
+pub use get_all::get_all_category_transfers;
 pub use insert::insert_category_transfers;
 pub use sum_quantity_per_from_category_id::sum_category_transfer_quantity_per_from_category_id;
 pub use sum_quantity_per_to_category_id::sum_category_transfer_quantity_per_to_category_id;
diff --git a/backend/core/src/queries/clear.rs b/backend/core/src/queries/clear.rs
index dbe0f84..e704634 100644
--- a/backend/core/src/queries/clear.rs
+++ b/backend/core/src/queries/clear.rs
@@ -1,3 +1,4 @@
+use anyhow::Result;
 use crate::queries::{
     accounts::delete_all_accounts,
     budget_updates::delete_all_budget_updates,
@@ -6,9 +7,9 @@ use crate::queries::{
     transactions::delete_all_transactions,
     transaction_categorisations::delete_all_transaction_categorisations,
 };
-use diesel::{result::Error, SqliteConnection};
+use diesel::SqliteConnection;
 
-pub fn clear(connection: &mut SqliteConnection) -> Result<(), Error> {
+pub fn clear(connection: &mut SqliteConnection) -> Result<()> {
     delete_all_accounts(connection)?;
     delete_all_budget_updates(connection)?;
     delete_all_categories(connection)?;
diff --git a/backend/core/src/queries/transaction_categorisations/get_all.rs b/backend/core/src/queries/transaction_categorisations/get_all.rs
new file mode 100644
index 0000000..0cacfe6
--- /dev/null
+++ b/backend/core/src/queries/transaction_categorisations/get_all.rs
@@ -0,0 +1,11 @@
+use anyhow::{Context, Result};
+use crate::{models::transaction_categorisation::TransactionCategorisation, schema::transaction_categorisations::dsl::transaction_categorisations as transaction_categorisations_table};
+use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+
+pub fn get_all_transaction_categorisations(connection: &mut SqliteConnection) -> Result<Vec<TransactionCategorisation>> {
+    let all_transaction_categorisations = transaction_categorisations_table
+        .select(TransactionCategorisation::as_select())
+        .load(connection)
+        .with_context(|| "failed to get all transaction categorisations")?;
+    Ok(all_transaction_categorisations)
+}
diff --git a/backend/core/src/queries/transaction_categorisations/mod.rs b/backend/core/src/queries/transaction_categorisations/mod.rs
index 3664fa6..d383791 100644
--- a/backend/core/src/queries/transaction_categorisations/mod.rs
+++ b/backend/core/src/queries/transaction_categorisations/mod.rs
@@ -1,7 +1,9 @@
 mod delete_all;
+mod get_all;
 mod insert;
 mod sum_quantity_per_category_id;
 
 pub use delete_all::delete_all_transaction_categorisations;
+pub use get_all::get_all_transaction_categorisations;
 pub use insert::insert_transaction_categorisations;
 pub use sum_quantity_per_category_id::sum_transaction_categorisation_quantity_per_category_id;
diff --git a/backend/core/src/queries/transactions/get_all.rs b/backend/core/src/queries/transactions/get_all.rs
new file mode 100644
index 0000000..afb87f4
--- /dev/null
+++ b/backend/core/src/queries/transactions/get_all.rs
@@ -0,0 +1,11 @@
+use anyhow::{Context, Result};
+use crate::{models::transaction::Transaction, schema::transactions::dsl::transactions as transactions_table};
+use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection};
+
+pub fn get_all_transactions(connection: &mut SqliteConnection) -> Result<Vec<Transaction>> {
+    let all_transactions = transactions_table
+        .select(Transaction::as_select())
+        .load(connection)
+        .with_context(|| "failed to get all category transfers")?;
+    Ok(all_transactions)
+}
diff --git a/backend/core/src/queries/transactions/mod.rs b/backend/core/src/queries/transactions/mod.rs
index 40855f3..983e9af 100644
--- a/backend/core/src/queries/transactions/mod.rs
+++ b/backend/core/src/queries/transactions/mod.rs
@@ -1,5 +1,7 @@
 mod delete_all;
+mod get_all;
 mod insert;
 
 pub use delete_all::delete_all_transactions;
+pub use get_all::get_all_transactions;
 pub use insert::insert_transactions;
diff --git a/backend/core/src/utils/calculate_budgets_accrual.rs b/backend/core/src/utils/calculate_budgets_accrual.rs
index bbc197c..22061ee 100644
--- a/backend/core/src/utils/calculate_budgets_accrual.rs
+++ b/backend/core/src/utils/calculate_budgets_accrual.rs
@@ -9,7 +9,7 @@ pub fn calculate_budgets_accrual(category: &Category, budget_updates: &[BudgetUp
         .iter()
         .filter(|bu| bu.category_id == category.id)
         .collect::<Vec<&BudgetUpdate>>();
-    budget_updates.sort_by_key(|bu| bu.date);
+    budget_updates.sort_by_key(|bu| bu.date.clone());
     budget_updates.reverse();
 
     let mut budgets_accrual = 0.0_f64;
@@ -22,7 +22,7 @@ pub fn calculate_budgets_accrual(category: &Category, budget_updates: &[BudgetUp
         }
         let budget_per_day = budget_update.new_budget as f64 / budget_update.new_period as f64;
         budgets_accrual += days_on_this_budget as f64 * budget_per_day;
-        calculated_back_to_date = budget_update.date;
+        calculated_back_to_date = budget_update.date.clone();
     }
 
     budgets_accrual.floor() as i64
@@ -78,7 +78,7 @@ mod test {
         let budget_updates = [BudgetUpdate {
             id: 0,
             category_id: 0,
-            date: DateTimeUtc::new(Utc::now().checked_sub_days(Days::new(120)).unwrap()),
+            date: DateTimeUtc::new(&Utc::now().checked_sub_days(Days::new(120)).unwrap()),
             new_budget: 100,
             new_period: 1,
         }];
@@ -98,14 +98,14 @@ mod test {
             BudgetUpdate {
                 id: 0,
                 category_id: 0,
-                date: DateTimeUtc::new(Utc::now().checked_sub_days(Days::new(60)).unwrap()),
+                date: DateTimeUtc::new(&Utc::now().checked_sub_days(Days::new(60)).unwrap()),
                 new_budget: 200,
                 new_period: 1,
             },
             BudgetUpdate {
                 id: 0,
                 category_id: 0,
-                date: DateTimeUtc::new(Utc::now().checked_sub_days(Days::new(120)).unwrap()),
+                date: DateTimeUtc::new(&Utc::now().checked_sub_days(Days::new(120)).unwrap()),
                 new_budget: 100,
                 new_period: 1,
             },
@@ -127,7 +127,7 @@ mod test {
                 id: 0,
                 category_id: 0,
                 date: DateTimeUtc::new(
-                    Utc::now()
+                    &Utc::now()
                         .checked_sub_days(Days::new(120))
                         .unwrap()
                         .with_hour(13)
@@ -140,7 +140,7 @@ mod test {
                 id: 0,
                 category_id: 0,
                 date: DateTimeUtc::new(
-                    Utc::now()
+                    &Utc::now()
                         .checked_sub_days(Days::new(120))
                         .unwrap()
                         .with_hour(12)
diff --git a/backend/core/src/utils/calculate_category_balance.rs b/backend/core/src/utils/calculate_category_balance.rs
index 5eca05b..e461cee 100644
--- a/backend/core/src/utils/calculate_category_balance.rs
+++ b/backend/core/src/utils/calculate_category_balance.rs
@@ -51,7 +51,7 @@ mod test {
         let budget_updates = [BudgetUpdate {
             id: 0,
             category_id: 1,
-            date: DateTimeUtc::new(Utc::now().checked_sub_days(Days::new(120)).unwrap()),
+            date: DateTimeUtc::new(&Utc::now().checked_sub_days(Days::new(120)).unwrap()),
             new_budget: 77,
             new_period: 1,
         }];
@@ -123,7 +123,7 @@ mod test {
         let budget_updates = [BudgetUpdate {
             id: 0,
             category_id: 0,
-            date: DateTimeUtc::new(Utc::now().checked_sub_days(Days::new(120)).unwrap()),
+            date: DateTimeUtc::new(&Utc::now().checked_sub_days(Days::new(120)).unwrap()),
             new_budget: 77,
             new_period: 1,
         }];
diff --git a/backend/core/tests/common/fakes/account.rs b/backend/core/tests/common/fakes/account.rs
new file mode 100644
index 0000000..e915aed
--- /dev/null
+++ b/backend/core/tests/common/fakes/account.rs
@@ -0,0 +1,10 @@
+use budgeting_app_core::models::{account::Account, date_time_utc::DateTimeUtc};
+
+pub fn make_fake_account(id: i32) -> Account {
+    Account {
+        id,
+        name: String::from("Joe Bloggs"),
+        opening_balance: 0,
+        opening_date: DateTimeUtc::now(),
+    }
+}
diff --git a/backend/core/tests/common/fakes/budget_update.rs b/backend/core/tests/common/fakes/budget_update.rs
new file mode 100644
index 0000000..e7ee9b9
--- /dev/null
+++ b/backend/core/tests/common/fakes/budget_update.rs
@@ -0,0 +1,16 @@
+use budgeting_app_core::models::{budget_update::{BudgetUpdate, BudgetUpdateBuilder}, date_time_utc::DateTimeUtc};
+
+pub fn make_fake_budget_update(id: i32) -> BudgetUpdate {
+    make_fake_budget_update_builder(id).build().unwrap()
+}
+
+pub fn make_fake_budget_update_builder(id: i32) ->  BudgetUpdateBuilder {
+    let mut builder = BudgetUpdateBuilder::default();
+    builder
+        .id(id)
+        .category_id(0)
+        .date(DateTimeUtc::now())
+        .new_budget(0)
+        .new_period(0);
+    builder
+}
diff --git a/backend/core/tests/common/fakes/category.rs b/backend/core/tests/common/fakes/category.rs
new file mode 100644
index 0000000..27a027e
--- /dev/null
+++ b/backend/core/tests/common/fakes/category.rs
@@ -0,0 +1,13 @@
+use budgeting_app_core::models::category::{Category, CategoryBuilder};
+
+pub fn make_fake_category(id: i32) -> Category {
+    make_fake_category_builder(id).build().unwrap()
+}
+
+pub fn make_fake_category_builder(id: i32) ->  CategoryBuilder {
+    let mut builder = CategoryBuilder::default();
+    builder
+        .id(id)
+        .name(String::from("Fake category"));
+    builder
+}
diff --git a/backend/core/tests/common/fakes/category_transfer.rs b/backend/core/tests/common/fakes/category_transfer.rs
new file mode 100644
index 0000000..66496f3
--- /dev/null
+++ b/backend/core/tests/common/fakes/category_transfer.rs
@@ -0,0 +1,16 @@
+use budgeting_app_core::models::category_transfer::{CategoryTransfer, CategoryTransferBuilder};
+
+pub fn make_fake_category_transfer(id: i32) -> CategoryTransfer {
+    make_fake_category_transfer_builder(id).build().unwrap()
+}
+
+pub fn make_fake_category_transfer_builder(id: i32) ->  CategoryTransferBuilder {
+    let mut builder = CategoryTransferBuilder::default();
+    builder
+        .id(id)
+        .description(String::from("Fake category transfer"))
+        .quantity(0)
+        .from_category_id(0)
+        .to_category_id(1);
+    builder
+}
diff --git a/backend/core/tests/common/fakes/mod.rs b/backend/core/tests/common/fakes/mod.rs
new file mode 100644
index 0000000..68f5209
--- /dev/null
+++ b/backend/core/tests/common/fakes/mod.rs
@@ -0,0 +1,6 @@
+pub mod account;
+pub mod budget_update;
+pub mod category;
+pub mod category_transfer;
+pub mod transaction;
+pub mod transaction_categorisation;
diff --git a/backend/core/tests/common/fakes/transaction.rs b/backend/core/tests/common/fakes/transaction.rs
new file mode 100644
index 0000000..d113ce5
--- /dev/null
+++ b/backend/core/tests/common/fakes/transaction.rs
@@ -0,0 +1,17 @@
+use budgeting_app_core::models::{date_time_utc::DateTimeUtc, transaction::{Transaction, TransactionBuilder}};
+
+pub fn make_fake_transaction(id: i32) -> Transaction {
+    make_fake_transaction_builder(id).build().unwrap()
+}
+
+pub fn make_fake_transaction_builder(id: i32) ->  TransactionBuilder {
+    let mut builder = TransactionBuilder::default();
+    builder
+        .id(id)
+        .description(String::from("Fake category transfer"))
+        .payee(String::from("Fake payee"))
+        .quantity(0)
+        .date(DateTimeUtc::now())
+        .account_id(0);
+    builder
+}
diff --git a/backend/core/tests/common/fakes/transaction_categorisation.rs b/backend/core/tests/common/fakes/transaction_categorisation.rs
new file mode 100644
index 0000000..9ddd684
--- /dev/null
+++ b/backend/core/tests/common/fakes/transaction_categorisation.rs
@@ -0,0 +1,16 @@
+use budgeting_app_core::models::transaction_categorisation::{TransactionCategorisation, TransactionCategorisationBuilder};
+
+pub fn make_fake_transaction_categorisation(id: i32) -> TransactionCategorisation {
+    make_fake_transaction_categorisation_builder(id).build().unwrap()
+}
+
+pub fn make_fake_transaction_categorisation_builder(id: i32) ->  TransactionCategorisationBuilder {
+    let mut builder = TransactionCategorisationBuilder::default();
+    builder
+        .id(id)
+        .description(String::from("Fake category transfer"))
+        .quantity(0)
+        .transaction_id(0)
+        .category_id(0);
+    builder
+}
diff --git a/backend/core/tests/common/mod.rs b/backend/core/tests/common/mod.rs
new file mode 100644
index 0000000..6681d3d
--- /dev/null
+++ b/backend/core/tests/common/mod.rs
@@ -0,0 +1,2 @@
+pub mod fakes;
+pub mod test_context;
diff --git a/backend/core/tests/common/test_context.rs b/backend/core/tests/common/test_context.rs
new file mode 100644
index 0000000..f6142b0
--- /dev/null
+++ b/backend/core/tests/common/test_context.rs
@@ -0,0 +1,43 @@
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use budgeting_app_core::{queries::clear::clear, MIGRATIONS};
+use diesel::{Connection, SqliteConnection};
+use diesel_migrations::MigrationHarness;
+
+pub struct TestContext {
+    pub db_url: String,
+}
+
+static ID_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+impl TestContext {
+    pub fn new() -> Self {
+        let db_url = Self::next_id() + ".sqlite";
+
+        let connection = &mut SqliteConnection
+            ::establish(&db_url)
+            .expect("failed to connect to database");
+
+        connection
+            .run_pending_migrations(MIGRATIONS)
+            .expect("failed to run migrations");
+
+        clear(connection)
+            .expect("failed to clear database");
+
+        Self {
+            db_url,
+        }
+    }
+
+    fn next_id() -> String {
+        ID_COUNTER.fetch_add(1, Ordering::Relaxed).to_string()
+    }
+}
+
+impl Drop for TestContext {
+    fn drop(&mut self) {
+        std::fs::remove_file(&self.db_url)
+            .expect(format!("failed to delete database {}", self.db_url).as_str());
+    }
+}
diff --git a/backend/core/tests/main.rs b/backend/core/tests/main.rs
new file mode 100644
index 0000000..27409b6
--- /dev/null
+++ b/backend/core/tests/main.rs
@@ -0,0 +1,4 @@
+pub mod common;
+
+mod models;
+mod queries;
diff --git a/backend/core/tests/models/date_time_utc.rs b/backend/core/tests/models/date_time_utc.rs
new file mode 100644
index 0000000..1f86968
--- /dev/null
+++ b/backend/core/tests/models/date_time_utc.rs
@@ -0,0 +1,59 @@
+use anyhow::Result;
+use budgeting_app_core::models::date_time_utc::DateTimeUtc;
+use diesel::{sql_query, Connection, ExpressionMethods, QueryDsl, RunQueryDsl, Selectable, SelectableHelper, SqliteConnection};
+use diesel::prelude::{Insertable, Queryable};
+
+use crate::common::test_context::TestContext;
+
+diesel::table! {
+    date_time_utc_test (id) {
+        id -> Integer,
+        date_time_utc -> Text,
+    }
+}
+
+#[derive(Insertable, Queryable, Selectable, Clone)]
+#[diesel(table_name = date_time_utc_test)]
+pub struct DateTimeUtcTest {
+    pub id: i32,
+    pub date_time_utc: DateTimeUtc,
+}
+
+fn new_test_context() -> Result<TestContext> {
+    let test_context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&test_context.db_url)?;
+    let query = "CREATE TABLE date_time_utc_test(id INTEGER PRIMARY KEY, date_time_utc TEXT);";
+    sql_query(query).execute(connection)?;
+    Ok(test_context)
+}
+
+fn insert_date_time_utc(id: i32, date_time_utc: &DateTimeUtc, connection: &mut SqliteConnection) -> Result<usize> {
+    let model = DateTimeUtcTest {
+        id,
+        date_time_utc: date_time_utc.clone(),
+    };
+    let num_rows_inserted = diesel::insert_into(date_time_utc_test::dsl::date_time_utc_test)
+        .values(&[model])
+        .execute(connection)?;
+    Ok(num_rows_inserted)
+}
+
+fn get_date_time_utc(id: i32, connection: &mut SqliteConnection) -> Result<DateTimeUtcTest> {
+    let date_time_utc: Vec<DateTimeUtcTest> = date_time_utc_test::dsl::date_time_utc_test
+        .select(DateTimeUtcTest::as_select())
+        .filter(date_time_utc_test::id.eq(id))
+        .load(connection)?;
+    Ok(date_time_utc[0].clone())
+}
+
+#[test]
+fn when_insert_date_time_utc_and_select_then_returns_original_value() -> Result<()> {
+    let date_time_utc = DateTimeUtc::now();
+    let test_context = new_test_context()?;
+    let connection = &mut SqliteConnection::establish(&test_context.db_url)?;
+    let num_rows_inserted = insert_date_time_utc(0, &date_time_utc, connection)?;
+    assert_eq!(num_rows_inserted, 1);
+    let date_time_utc_returned = get_date_time_utc(0, connection)?;
+    assert_eq!(date_time_utc_returned.date_time_utc.to_date_str(), date_time_utc.to_date_str());
+    Ok(())
+}
diff --git a/backend/core/tests/models/mod.rs b/backend/core/tests/models/mod.rs
new file mode 100644
index 0000000..5837dcd
--- /dev/null
+++ b/backend/core/tests/models/mod.rs
@@ -0,0 +1 @@
+mod date_time_utc;
diff --git a/backend/core/tests/queries/account.rs b/backend/core/tests/queries/account.rs
new file mode 100644
index 0000000..4fd9e99
--- /dev/null
+++ b/backend/core/tests/queries/account.rs
@@ -0,0 +1,58 @@
+use budgeting_app_core::queries;
+use diesel::{Connection, SqliteConnection};
+
+use crate::common::{fakes::account::make_fake_account, test_context::TestContext};
+
+#[test]
+fn when_insert_accounts_then_returns_num_accounts() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let accounts = [make_fake_account(0), make_fake_account(1)];
+
+    let num_accounts_inserted = queries::accounts::insert_accounts(&accounts, connection).unwrap();
+
+    assert_eq!(num_accounts_inserted, 2);
+}
+
+#[test]
+fn given_accounts_when_get_all_accounts_then_return_accounts() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let accounts = [make_fake_account(0), make_fake_account(1)];
+    let _ = queries::accounts::insert_accounts(&accounts, connection).unwrap();
+
+    let accounts_in_db = queries::accounts::get_all_accounts(connection).unwrap();
+
+    assert_eq!(accounts_in_db.len(), accounts.len());
+    for account in &accounts {
+        assert!(accounts_in_db.iter().any(|account_in_db| account_in_db.eq(&account)));
+    }
+    for account_in_db in accounts_in_db {
+        assert!(accounts.iter().any(|account| account.eq(&account_in_db)));
+    }
+}
+
+#[test]
+fn given_accounts_when_delete_all_accounts_then_return_num_of_accounts() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let accounts = [make_fake_account(0), make_fake_account(1)];
+    let _ = queries::accounts::insert_accounts(&accounts, connection).unwrap();
+
+    let num_accounts_deleted = queries::accounts::delete_all_accounts(connection).unwrap();
+
+    assert_eq!(num_accounts_deleted, accounts.len());
+}
+
+#[test]
+fn given_deleted_accounts_when_get_all_accounts_then_return_empty() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let accounts = [make_fake_account(0), make_fake_account(1)];
+    let _ = queries::accounts::insert_accounts(&accounts, connection).unwrap();
+    let _ = queries::accounts::delete_all_accounts(connection).unwrap();
+
+    let accounts_returned = queries::accounts::get_all_accounts(connection).unwrap();
+
+    assert_eq!(accounts_returned.len(), 0);
+}
diff --git a/backend/core/tests/queries/budget_updates.rs b/backend/core/tests/queries/budget_updates.rs
new file mode 100644
index 0000000..147d06f
--- /dev/null
+++ b/backend/core/tests/queries/budget_updates.rs
@@ -0,0 +1,78 @@
+use budgeting_app_core::queries;
+use diesel::{Connection, SqliteConnection};
+
+use crate::common::{fakes::{budget_update::make_fake_budget_update_builder, category::make_fake_category}, test_context::TestContext};
+
+#[test]
+fn when_insert_budget_updates_then_returns_num_budget_updates() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0)];
+    let budget_updates = [
+        make_fake_budget_update_builder(0).category_id(0).build().unwrap(),
+        make_fake_budget_update_builder(1).category_id(0).build().unwrap(),
+    ];
+    let _ = queries::categories::insert_categories(&categories, connection);
+
+    let num_budget_updates_inserted = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap();
+
+    assert_eq!(num_budget_updates_inserted, 2);
+}
+
+#[test]
+fn given_budget_updates_when_get_all_budget_updates_then_return_budget_updates() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0)];
+    let budget_updates = [
+        make_fake_budget_update_builder(0).category_id(0).build().unwrap(),
+        make_fake_budget_update_builder(1).category_id(0).build().unwrap(),
+    ];
+    let _ = queries::categories::insert_categories(&categories, connection);
+    let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap();
+
+    let budget_updates_in_db = queries::budget_updates::get_all_budget_updates(connection).unwrap();
+
+    assert_eq!(budget_updates_in_db.len(), budget_updates.len());
+    for budget_update in &budget_updates {
+        assert!(budget_updates_in_db.iter().any(|budget_update_in_db| budget_update_in_db.eq(&budget_update)));
+    }
+    for budget_update_in_db in budget_updates_in_db {
+        assert!(budget_updates.iter().any(|budget_update| budget_update.eq(&budget_update_in_db)));
+    }
+}
+
+#[test]
+fn given_budget_updates_when_delete_all_budget_updates_then_return_num_of_budget_updates() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0)];
+    let budget_updates = [
+        make_fake_budget_update_builder(0).category_id(0).build().unwrap(),
+        make_fake_budget_update_builder(1).category_id(0).build().unwrap(),
+    ];
+    let _ = queries::categories::insert_categories(&categories, connection);
+    let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap();
+
+    let num_budget_updates_deleted = queries::budget_updates::delete_all_budget_updates(connection).unwrap();
+
+    assert_eq!(num_budget_updates_deleted, budget_updates.len());
+}
+
+#[test]
+fn given_deleted_budget_updates_when_get_all_budget_updates_then_return_empty() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0)];
+    let budget_updates = [
+        make_fake_budget_update_builder(0).category_id(0).build().unwrap(),
+        make_fake_budget_update_builder(1).category_id(0).build().unwrap(),
+    ];
+    let _ = queries::categories::insert_categories(&categories, connection);
+    let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap();
+    let _ = queries::budget_updates::delete_all_budget_updates(connection).unwrap();
+
+    let budget_updates_returned = queries::budget_updates::get_all_budget_updates(connection).unwrap();
+
+    assert_eq!(budget_updates_returned.len(), 0);
+}
diff --git a/backend/core/tests/queries/categories.rs b/backend/core/tests/queries/categories.rs
new file mode 100644
index 0000000..917536e
--- /dev/null
+++ b/backend/core/tests/queries/categories.rs
@@ -0,0 +1,58 @@
+use budgeting_app_core::queries;
+use diesel::{Connection, SqliteConnection};
+
+use crate::common::{fakes::category::make_fake_category, test_context::TestContext};
+
+#[test]
+fn when_insert_categories_then_returns_num_categories() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0), make_fake_category(1)];
+
+    let num_categories_inserted = queries::categories::insert_categories(&categories, connection).unwrap();
+
+    assert_eq!(num_categories_inserted, 2);
+}
+
+#[test]
+fn given_categories_when_get_all_categories_then_return_categories() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0), make_fake_category(1)];
+    let _ = queries::categories::insert_categories(&categories, connection).unwrap();
+
+    let categories_in_db = queries::categories::get_all_categories(connection).unwrap();
+
+    assert_eq!(categories_in_db.len(), categories.len());
+    for category in &categories {
+        assert!(categories_in_db.iter().any(|category_in_db| category_in_db.eq(&category)));
+    }
+    for category_in_db in categories_in_db {
+        assert!(categories.iter().any(|category| category.eq(&category_in_db)));
+    }
+}
+
+#[test]
+fn given_categories_when_delete_all_categories_then_return_num_of_categories() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0), make_fake_category(1)];
+    let _ = queries::categories::insert_categories(&categories, connection).unwrap();
+
+    let num_categories_deleted = queries::categories::delete_all_categories(connection).unwrap();
+
+    assert_eq!(num_categories_deleted, categories.len());
+}
+
+#[test]
+fn given_deleted_categories_when_get_all_categories_then_return_empty() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0), make_fake_category(1)];
+    let _ = queries::categories::insert_categories(&categories, connection).unwrap();
+    let _ = queries::categories::delete_all_categories(connection).unwrap();
+
+    let categories_returned = queries::categories::get_all_categories(connection).unwrap();
+
+    assert_eq!(categories_returned.len(), 0);
+}
diff --git a/backend/core/tests/queries/category_transfers.rs b/backend/core/tests/queries/category_transfers.rs
new file mode 100644
index 0000000..d329d9c
--- /dev/null
+++ b/backend/core/tests/queries/category_transfers.rs
@@ -0,0 +1,78 @@
+use budgeting_app_core::queries;
+use diesel::{Connection, SqliteConnection};
+
+use crate::common::{fakes::{category::make_fake_category, category_transfer::make_fake_category_transfer_builder}, test_context::TestContext};
+
+#[test]
+fn when_insert_category_transfers_then_returns_num_category_transfers() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0), make_fake_category(1)];
+    let category_transfers = [
+        make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(),
+        make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(),
+    ];
+    let _ = queries::categories::insert_categories(&categories, connection);
+
+    let num_category_transfers_inserted = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+
+    assert_eq!(num_category_transfers_inserted, 2);
+}
+
+#[test]
+fn given_category_transfers_when_get_all_category_transfers_then_return_category_transfers() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0), make_fake_category(1)];
+    let category_transfers = [
+        make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(),
+        make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(),
+    ];
+    let _ = queries::categories::insert_categories(&categories, connection);
+    let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+
+    let category_transfers_in_db = queries::category_transfers::get_all_category_transfers(connection).unwrap();
+
+    assert_eq!(category_transfers_in_db.len(), category_transfers.len());
+    for category_transfer in &category_transfers {
+        assert!(category_transfers_in_db.iter().any(|category_transfer_in_db| category_transfer_in_db.eq(&category_transfer)));
+    }
+    for category_transfer_in_db in category_transfers_in_db {
+        assert!(category_transfers.iter().any(|category_transfer| category_transfer.eq(&category_transfer_in_db)));
+    }
+}
+
+#[test]
+fn given_category_transfers_when_delete_all_category_transfers_then_return_num_of_category_transfers() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0), make_fake_category(1)];
+    let category_transfers = [
+        make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(),
+        make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(),
+    ];
+    let _ = queries::categories::insert_categories(&categories, connection);
+    let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+
+    let num_category_transfers_deleted = queries::category_transfers::delete_all_category_transfers(connection).unwrap();
+
+    assert_eq!(num_category_transfers_deleted, category_transfers.len());
+}
+
+#[test]
+fn given_deleted_category_transfers_when_get_all_category_transfers_then_return_empty() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let categories = [make_fake_category(0), make_fake_category(1)];
+    let category_transfers = [
+        make_fake_category_transfer_builder(0).from_category_id(0).to_category_id(1).build().unwrap(),
+        make_fake_category_transfer_builder(1).from_category_id(0).to_category_id(1).build().unwrap(),
+    ];
+    let _ = queries::categories::insert_categories(&categories, connection);
+    let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap();
+    let _ = queries::category_transfers::delete_all_category_transfers(connection).unwrap();
+
+    let category_transfers_returned = queries::category_transfers::get_all_category_transfers(connection).unwrap();
+
+    assert_eq!(category_transfers_returned.len(), 0);
+}
diff --git a/backend/core/tests/queries/mod.rs b/backend/core/tests/queries/mod.rs
new file mode 100644
index 0000000..e421934
--- /dev/null
+++ b/backend/core/tests/queries/mod.rs
@@ -0,0 +1,6 @@
+mod account;
+mod budget_updates;
+mod categories;
+mod category_transfers;
+mod transaction_categorisations;
+mod transactions;
diff --git a/backend/core/tests/queries/transaction_categorisations.rs b/backend/core/tests/queries/transaction_categorisations.rs
new file mode 100644
index 0000000..3c2171d
--- /dev/null
+++ b/backend/core/tests/queries/transaction_categorisations.rs
@@ -0,0 +1,86 @@
+use budgeting_app_core::queries;
+use diesel::{Connection, SqliteConnection};
+
+use crate::common::{fakes::{account::make_fake_account, category::make_fake_category, transaction::make_fake_transaction_builder, transaction_categorisation::make_fake_transaction_categorisation_builder}, test_context::TestContext};
+
+fn insert_prerequisite_data(connection: &mut SqliteConnection) {
+    let accounts = [make_fake_account(0)];
+    let categories = [make_fake_category(0)];
+    let transactions = [
+        make_fake_transaction_builder(0).account_id(0).build().unwrap(),
+        make_fake_transaction_builder(1).account_id(0).build().unwrap(),
+    ];
+    let _ = queries::accounts::insert_accounts(&accounts, connection);
+    let _ = queries::categories::insert_categories(&categories, connection);
+    let _ = queries::transactions::insert_transactions(&transactions, connection);
+}
+
+#[test]
+fn when_insert_transaction_categorisations_then_returns_num_transaction_categorisations() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    insert_prerequisite_data(connection);
+    let transaction_categorisations = [
+        make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(),
+    ];
+
+    let num_transaction_categorisations_inserted = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection).unwrap();
+
+    assert_eq!(num_transaction_categorisations_inserted, 2);
+}
+
+#[test]
+fn given_transaction_categorisations_when_get_all_transaction_categorisations_then_return_transaction_categorisations() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    insert_prerequisite_data(connection);
+    let transaction_categorisations = [
+        make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(),
+    ];
+    let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection);
+
+    let transaction_categorisations_in_db = queries::transaction_categorisations::get_all_transaction_categorisations(connection).unwrap();
+
+    assert_eq!(transaction_categorisations_in_db.len(), transaction_categorisations.len());
+    for transaction_categorisation in &transaction_categorisations {
+        assert!(transaction_categorisations_in_db.iter().any(|transaction_categorisation_in_db| transaction_categorisation_in_db.eq(&transaction_categorisation)));
+    }
+    for transaction_categorisation_in_db in transaction_categorisations_in_db {
+        assert!(transaction_categorisations.iter().any(|transaction_categorisation| transaction_categorisation.eq(&transaction_categorisation_in_db)));
+    }
+}
+
+#[test]
+fn given_transaction_categorisations_when_delete_all_transaction_categorisations_then_return_num_of_transaction_categorisations() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    insert_prerequisite_data(connection);
+    let transaction_categorisations = [
+        make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(),
+    ];
+    let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection);
+
+    let num_transaction_categorisations_deleted = queries::transaction_categorisations::delete_all_transaction_categorisations(connection).unwrap();
+
+    assert_eq!(num_transaction_categorisations_deleted, transaction_categorisations.len());
+}
+
+#[test]
+fn given_deleted_transaction_categorisations_when_get_all_transaction_categorisations_then_return_empty() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    insert_prerequisite_data(connection);
+    let transaction_categorisations = [
+        make_fake_transaction_categorisation_builder(0).category_id(0).build().unwrap(),
+        make_fake_transaction_categorisation_builder(1).category_id(0).build().unwrap(),
+    ];
+    let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection);
+    let _ = queries::transaction_categorisations::delete_all_transaction_categorisations(connection);
+
+    let transaction_categorisations_returned = queries::transaction_categorisations::get_all_transaction_categorisations(connection).unwrap();
+
+    assert_eq!(transaction_categorisations_returned.len(), 0);
+}
diff --git a/backend/core/tests/queries/transactions.rs b/backend/core/tests/queries/transactions.rs
new file mode 100644
index 0000000..406f5a8
--- /dev/null
+++ b/backend/core/tests/queries/transactions.rs
@@ -0,0 +1,78 @@
+use budgeting_app_core::queries;
+use diesel::{Connection, SqliteConnection};
+
+use crate::common::{fakes::{account::make_fake_account, transaction::make_fake_transaction_builder}, test_context::TestContext};
+
+#[test]
+fn when_insert_transactions_then_returns_num_transactions() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let accounts = [make_fake_account(0)];
+    let transactions = [
+        make_fake_transaction_builder(0).account_id(0).build().unwrap(),
+        make_fake_transaction_builder(1).account_id(0).build().unwrap(),
+    ];
+    let _ = queries::accounts::insert_accounts(&accounts, connection);
+
+    let num_transactions_inserted = queries::transactions::insert_transactions(&transactions, connection).unwrap();
+
+    assert_eq!(num_transactions_inserted, 2);
+}
+
+#[test]
+fn given_transactions_when_get_all_transactions_then_return_transactions() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let accounts = [make_fake_account(0)];
+    let transactions = [
+        make_fake_transaction_builder(0).account_id(0).build().unwrap(),
+        make_fake_transaction_builder(1).account_id(0).build().unwrap(),
+    ];
+    let _ = queries::accounts::insert_accounts(&accounts, connection);
+    let _ = queries::transactions::insert_transactions(&transactions, connection).unwrap();
+
+    let transactions_in_db = queries::transactions::get_all_transactions(connection).unwrap();
+
+    assert_eq!(transactions_in_db.len(), transactions.len());
+    for transaction in &transactions {
+        assert!(transactions_in_db.iter().any(|transaction_in_db| transaction_in_db.eq(&transaction)));
+    }
+    for transaction_in_db in transactions_in_db {
+        assert!(transactions.iter().any(|transaction| transaction.eq(&transaction_in_db)));
+    }
+}
+
+#[test]
+fn given_transactions_when_delete_all_transactions_then_return_num_of_transactions() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let accounts = [make_fake_account(0)];
+    let transactions = [
+        make_fake_transaction_builder(0).account_id(0).build().unwrap(),
+        make_fake_transaction_builder(1).account_id(0).build().unwrap(),
+    ];
+    let _ = queries::accounts::insert_accounts(&accounts, connection);
+    let _ = queries::transactions::insert_transactions(&transactions, connection).unwrap();
+
+    let num_transactions_deleted = queries::transactions::delete_all_transactions(connection).unwrap();
+
+    assert_eq!(num_transactions_deleted, transactions.len());
+}
+
+#[test]
+fn given_deleted_transactions_when_get_all_transactions_then_return_empty() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    let accounts = [make_fake_account(0)];
+    let transactions = [
+        make_fake_transaction_builder(0).account_id(0).build().unwrap(),
+        make_fake_transaction_builder(1).account_id(0).build().unwrap(),
+    ];
+    let _ = queries::accounts::insert_accounts(&accounts, connection);
+    let _ = queries::transactions::insert_transactions(&transactions, connection).unwrap();
+    let _ = queries::transactions::delete_all_transactions(connection).unwrap();
+
+    let transactions_returned = queries::transactions::get_all_transactions(connection).unwrap();
+
+    assert_eq!(transactions_returned.len(), 0);
+}