diff options
Diffstat (limited to 'rust/schist_core')
80 files changed, 3677 insertions, 0 deletions
diff --git a/rust/schist_core/Cargo.lock b/rust/schist_core/Cargo.lock new file mode 100644 index 0000000..9253dc6 --- /dev/null +++ b/rust/schist_core/Cargo.lock @@ -0,0 +1,669 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "android-tzdata" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0" + +[[package]] +name = "android_system_properties" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311" +dependencies = [ + "libc", +] + +[[package]] +name = "anyhow" +version = "1.0.90" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37bf3594c4c988a53154954629820791dde498571819ae4ca50ca811e060cc95" + +[[package]] +name = "autocfg" +version = "1.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26" + +[[package]] +name = "schist_core" +version = "0.1.0" +dependencies = [ + "anyhow", + "chrono", + "derive_builder", + "diesel", + "diesel_migrations", + "libsqlite3-sys", + "serde", +] + +[[package]] +name = "bumpalo" +version = "3.16.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c" + +[[package]] +name = "cc" +version = "1.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b16803a61b81d9eabb7eae2588776c4c1e584b738ede45fdbb4c972cec1e9945" +dependencies = [ + "shlex", +] + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "chrono" +version = "0.4.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a21f936df1771bf62b77f047b726c4625ff2e8aa607c01ec06e5a05bd8463401" +dependencies = [ + "android-tzdata", + "iana-time-zone", + "js-sys", + "num-traits", + "serde", + "wasm-bindgen", + "windows-targets", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "darling" +version = "0.20.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6f63b86c8a8826a49b8c21f08a2d07338eec8d900540f8630dc76284be802989" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.20.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "95133861a8032aaea082871032f5815eb9e98cef03fa916ab4500513994df9e5" +dependencies = [ + "fnv", + "ident_case", + "proc-macro2", + "quote", + "strsim", + "syn", +] + +[[package]] +name = "darling_macro" +version = "0.20.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d336a2a514f6ccccaa3e09b02d41d35330c07ddf03a62165fcec10bb561c7806" +dependencies = [ + "darling_core", + "quote", + "syn", +] + +[[package]] +name = "deranged" +version = "0.3.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4" +dependencies = [ + "powerfmt", +] + +[[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" +checksum = "158fe8e2e68695bd615d7e4f3227c0727b151330d3e253b525086c348d055d5e" +dependencies = [ + "diesel_derives", + "libsqlite3-sys", + "time", +] + +[[package]] +name = "diesel_derives" +version = "2.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7f2c3de51e2ba6bf2a648285696137aaf0f5f487bcbea93972fe8a364e131a4" +dependencies = [ + "diesel_table_macro_syntax", + "dsl_auto_type", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "diesel_migrations" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a73ce704bad4231f001bff3314d91dce4aba0770cee8b233991859abc15c1f6" +dependencies = [ + "diesel", + "migrations_internals", + "migrations_macros", +] + +[[package]] +name = "diesel_table_macro_syntax" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "209c735641a413bc68c4923a9d6ad4bcb3ca306b794edaa7eb0b3228a99ffb25" +dependencies = [ + "syn", +] + +[[package]] +name = "dsl_auto_type" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5d9abe6314103864cc2d8901b7ae224e0ab1a103a0a416661b4097b0779b607" +dependencies = [ + "darling", + "either", + "heck", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "either" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0" + +[[package]] +name = "equivalent" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "hashbrown" +version = "0.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e087f84d4f86bf4b218b927129862374b72199ae7d8657835f1e89000eea4fb" + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "iana-time-zone" +version = "0.1.61" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "235e081f3925a06703c2d0117ea8b91f042756fd6e7a6e5d901e8ca1a996b220" +dependencies = [ + "android_system_properties", + "core-foundation-sys", + "iana-time-zone-haiku", + "js-sys", + "wasm-bindgen", + "windows-core", +] + +[[package]] +name = "iana-time-zone-haiku" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f" +dependencies = [ + "cc", +] + +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + +[[package]] +name = "indexmap" +version = "2.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "itoa" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b" + +[[package]] +name = "js-sys" +version = "0.3.72" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6a88f1bda2bd75b0452a14784937d796722fdebfe50df998aeb3f0b7603019a9" +dependencies = [ + "wasm-bindgen", +] + +[[package]] +name = "libc" +version = "0.2.159" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "561d97a539a36e26a9a5fad1ea11a3039a67714694aaa379433e580854bc3dc5" + +[[package]] +name = "libsqlite3-sys" +version = "0.30.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2e99fb7a497b1e3339bc746195567ed8d3e24945ecd636e3619d20b9de9e9149" +dependencies = [ + "cc", + "pkg-config", + "vcpkg", +] + +[[package]] +name = "log" +version = "0.4.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24" + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "migrations_internals" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd01039851e82f8799046eabbb354056283fb265c8ec0996af940f4e85a380ff" +dependencies = [ + "serde", + "toml", +] + +[[package]] +name = "migrations_macros" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ffb161cc72176cb37aa47f1fc520d3ef02263d67d661f44f05d05a079e1237fd" +dependencies = [ + "migrations_internals", + "proc-macro2", + "quote", +] + +[[package]] +name = "num-conv" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9" + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", +] + +[[package]] +name = "once_cell" +version = "1.20.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1261fe7e33c73b354eab43b1273a57c8f967d0391e80353e51f764ac02cf6775" + +[[package]] +name = "pkg-config" +version = "0.3.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "953ec861398dccce10c670dfeaf3ec4911ca479e9c02154b3a215178c5f566f2" + +[[package]] +name = "powerfmt" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" + +[[package]] +name = "proc-macro2" +version = "1.0.87" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b3e4daa0dcf6feba26f985457cdf104d4b4256fc5a09547140f3631bb076b19a" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "serde" +version = "1.0.210" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.210" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_spanned" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1" +dependencies = [ + "serde", +] + +[[package]] +name = "shlex" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "syn" +version = "2.0.79" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "89132cd0bf050864e1d38dc3bbc07a0eb8e7530af26344d3d2bbbef83499f590" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "time" +version = "0.3.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885" +dependencies = [ + "deranged", + "itoa", + "num-conv", + "powerfmt", + "serde", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" + +[[package]] +name = "time-macros" +version = "0.2.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf" +dependencies = [ + "num-conv", + "time-core", +] + +[[package]] +name = "toml" +version = "0.8.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e" +dependencies = [ + "serde", + "serde_spanned", + "toml_datetime", + "toml_edit", +] + +[[package]] +name = "toml_datetime" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41" +dependencies = [ + "serde", +] + +[[package]] +name = "toml_edit" +version = "0.22.22" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5" +dependencies = [ + "indexmap", + "serde", + "serde_spanned", + "toml_datetime", + "winnow", +] + +[[package]] +name = "unicode-ident" +version = "1.0.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe" + +[[package]] +name = "vcpkg" +version = "0.2.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426" + +[[package]] +name = "wasm-bindgen" +version = "0.2.95" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "128d1e363af62632b8eb57219c8fd7877144af57558fb2ef0368d0087bddeb2e" +dependencies = [ + "cfg-if", + "once_cell", + "wasm-bindgen-macro", +] + +[[package]] +name = "wasm-bindgen-backend" +version = "0.2.95" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb6dd4d3ca0ddffd1dd1c9c04f94b868c37ff5fac97c30b97cff2d74fce3a358" +dependencies = [ + "bumpalo", + "log", + "once_cell", + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.95" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e79384be7f8f5a9dd5d7167216f022090cf1f9ec128e6e6a482a2cb5c5422c56" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.95" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26c6ab57572f7a24a4985830b120de1594465e5d500f24afe89e16b4e833ef68" +dependencies = [ + "proc-macro2", + "quote", + "syn", + "wasm-bindgen-backend", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.95" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65fc09f10666a9f147042251e0dda9c18f166ff7de300607007e96bdebc1068d" + +[[package]] +name = "windows-core" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winnow" +version = "0.6.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b" +dependencies = [ + "memchr", +] diff --git a/rust/schist_core/Cargo.toml b/rust/schist_core/Cargo.toml new file mode 100644 index 0000000..ba49014 --- /dev/null +++ b/rust/schist_core/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "schist_core" +version = "0.1.0" +edition = "2021" + +[dependencies] +anyhow = { workspace = true } +chrono = { workspace = true, features = ["serde"] } +derive_builder = { workspace = true } +diesel = { workspace = true, features = ["sqlite"] } +diesel_migrations = { workspace = true } +serde = { workspace = true, features = ["derive"] } + +[dev-dependencies] +libsqlite3-sys = { workspace = true, features = ["bundled"] } diff --git a/rust/schist_core/migrations/2024-08-31-084439_initial_setup/down.sql b/rust/schist_core/migrations/2024-08-31-084439_initial_setup/down.sql new file mode 100644 index 0000000..8cf4b1e --- /dev/null +++ b/rust/schist_core/migrations/2024-08-31-084439_initial_setup/down.sql @@ -0,0 +1,6 @@ +DROP TABLE accounts; +DROP TABLE budget_updates; +DROP TABLE categories; +DROP TABLE transaction_categorisations; +DROP TABLE category_transfers; +DROP TABLE transactions; diff --git a/rust/schist_core/migrations/2024-08-31-084439_initial_setup/up.sql b/rust/schist_core/migrations/2024-08-31-084439_initial_setup/up.sql new file mode 100644 index 0000000..9038b54 --- /dev/null +++ b/rust/schist_core/migrations/2024-08-31-084439_initial_setup/up.sql @@ -0,0 +1,71 @@ +PRAGMA foreign_keys = ON; + +CREATE TABLE accounts( + id INTEGER NOT NULL PRIMARY KEY, + name TEXT NOT NULL, + opening_balance INTEGER NOT NULL, + opening_date TEXT NOT NULL +); + +CREATE TABLE budget_updates( + id INTEGER NOT NULL PRIMARY KEY, + category_id INTEGER NOT NULL, + date TEXT NOT NULL, + new_budget INTEGER NOT NULL, + new_period INTEGER NOT NULL, + UNIQUE (category_id, date), + FOREIGN KEY (category_id) + REFERENCES categories (id) + ON UPDATE CASCADE + ON DELETE RESTRICT +); + +CREATE TABLE categories( + id INTEGER NOT NULL PRIMARY KEY, + name TEXT NOT NULL +); + +CREATE TABLE category_transfers( + id INTEGER NOT NULL PRIMARY KEY, + description TEXT NOT NULL, + quantity INTEGER NOT NULL, + from_category_id INTEGER NOT NULL, + to_category_id INTEGER NOT NULL, + FOREIGN KEY (from_category_id) + REFERENCES categories (id) + ON UPDATE CASCADE + ON DELETE RESTRICT, + FOREIGN KEY (to_category_id) + REFERENCES categories (id) + ON UPDATE CASCADE + ON DELETE RESTRICT +); + +CREATE TABLE transactions( + id INTEGER NOT NULL PRIMARY KEY, + description TEXT NOT NULL, + payee TEXT NOT NULL, + quantity INTEGER NOT NULL, + date TEXT NOT NULL, + account_id INTEGER NOT NULL, + FOREIGN KEY (account_id) + REFERENCES accounts (id) + ON UPDATE CASCADE + ON DELETE RESTRICT +); + +CREATE TABLE transaction_categorisations( + id INTEGER NOT NULL PRIMARY KEY, + description TEXT NOT NULL, + quantity INTEGER NOT NULL, + transaction_id INTEGER NOT NULL, + category_id INTEGER NOT NULL, + FOREIGN KEY (transaction_id) + REFERENCES transactions (id) + ON UPDATE CASCADE + ON DELETE RESTRICT, + FOREIGN KEY (category_id) + REFERENCES categories (id) + ON UPDATE CASCADE + ON DELETE RESTRICT +); diff --git a/rust/schist_core/src/lib.rs b/rust/schist_core/src/lib.rs new file mode 100644 index 0000000..fd56999 --- /dev/null +++ b/rust/schist_core/src/lib.rs @@ -0,0 +1,10 @@ +use diesel_migrations::{embed_migrations, EmbeddedMigrations}; + +pub mod models; +pub mod queries; +pub mod schema; +pub mod traits; + +mod utils; + +pub const MIGRATIONS: EmbeddedMigrations = embed_migrations!("migrations"); diff --git a/rust/schist_core/src/models/account.rs b/rust/schist_core/src/models/account.rs new file mode 100644 index 0000000..2df43e1 --- /dev/null +++ b/rust/schist_core/src/models/account.rs @@ -0,0 +1,15 @@ +use diesel::prelude::*; +use serde::{Deserialize, Serialize}; + +use crate::models::datetime_utc::DatetimeUtc; + +#[derive( + Insertable, Queryable, Identifiable, Selectable, Debug, PartialEq, Clone, Serialize, Deserialize, +)] +#[diesel(table_name = crate::schema::accounts)] +pub struct Account { + pub id: i32, + pub name: String, + pub opening_balance: i32, + pub opening_date: DatetimeUtc, +} diff --git a/rust/schist_core/src/models/budget.rs b/rust/schist_core/src/models/budget.rs new file mode 100644 index 0000000..e6fb4c9 --- /dev/null +++ b/rust/schist_core/src/models/budget.rs @@ -0,0 +1,42 @@ +use serde::Serialize; + +use super::budget_update::BudgetUpdate; + +#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize)] +pub struct Budget { + pub quantity: i32, + pub period: i32, +} + +impl From<&BudgetUpdate> for Budget { + fn from(budget_update: &BudgetUpdate) -> Self { + Self { + quantity: budget_update.new_budget, + period: budget_update.new_period, + } + } +} + +#[cfg(test)] +mod test { + use crate::{models::date_utc::DateUtc, traits::nowlike::Nowlike}; + + use super::*; + + #[test] + fn when_from_budget_update_then_returns_budget() { + let quantity = 2; + let period = 3; + let budget_update = BudgetUpdate { + id: 0, + category_id: 1, + date: DateUtc::now(), + new_budget: quantity, + new_period: period, + }; + + let budget = Budget::from(&budget_update); + + assert_eq!(budget, Budget { quantity, period }); + } +} diff --git a/rust/schist_core/src/models/budget_update.rs b/rust/schist_core/src/models/budget_update.rs new file mode 100644 index 0000000..c7221b1 --- /dev/null +++ b/rust/schist_core/src/models/budget_update.rs @@ -0,0 +1,16 @@ +use derive_builder::Builder; +use diesel::prelude::*; +use serde::Serialize; + +use crate::models::{category::Category, date_utc::DateUtc}; + +#[derive(Builder, Clone, Serialize, Queryable, Identifiable, Selectable, Associations, Debug, PartialEq, Eq, Insertable)] +#[diesel(table_name = crate::schema::budget_updates)] +#[diesel(belongs_to(Category))] +pub struct BudgetUpdate { + pub id: i32, + pub category_id: i32, + pub date: DateUtc, + pub new_budget: i32, + pub new_period: i32, +} diff --git a/rust/schist_core/src/models/category.rs b/rust/schist_core/src/models/category.rs new file mode 100644 index 0000000..55c7b97 --- /dev/null +++ b/rust/schist_core/src/models/category.rs @@ -0,0 +1,10 @@ +use derive_builder::Builder; +use diesel::prelude::*; +use serde::{Deserialize, Serialize}; + +#[derive(Builder, Queryable, Identifiable, Selectable, Debug, PartialEq, Serialize, Deserialize, Insertable)] +#[diesel(table_name = crate::schema::categories)] +pub struct Category { + pub id: i32, + pub name: String, +} diff --git a/rust/schist_core/src/models/category_balance.rs b/rust/schist_core/src/models/category_balance.rs new file mode 100644 index 0000000..796b40b --- /dev/null +++ b/rust/schist_core/src/models/category_balance.rs @@ -0,0 +1,7 @@ +use serde::Serialize; + +#[derive(Serialize)] +pub struct CategoryBalance { + pub category_id: i32, + pub balance: i32, +} diff --git a/rust/schist_core/src/models/category_budget.rs b/rust/schist_core/src/models/category_budget.rs new file mode 100644 index 0000000..9796261 --- /dev/null +++ b/rust/schist_core/src/models/category_budget.rs @@ -0,0 +1,9 @@ +use serde::Serialize; + +use super::budget::Budget; + +#[derive(Serialize)] +pub struct CategoryBudget { + pub category_id: i32, + pub budget: Option<Budget>, +} diff --git a/rust/schist_core/src/models/category_transfer.rs b/rust/schist_core/src/models/category_transfer.rs new file mode 100644 index 0000000..7b36054 --- /dev/null +++ b/rust/schist_core/src/models/category_transfer.rs @@ -0,0 +1,12 @@ +use derive_builder::Builder; +use diesel::prelude::*; + +#[derive(Builder, Queryable, Identifiable, Selectable, Debug, PartialEq, Insertable)] +#[diesel(table_name = crate::schema::category_transfers)] +pub struct CategoryTransfer { + pub id: i32, + pub description: String, + pub quantity: i32, + pub from_category_id: i32, + pub to_category_id: i32, +} diff --git a/rust/schist_core/src/models/date_utc.rs b/rust/schist_core/src/models/date_utc.rs new file mode 100644 index 0000000..55d9e3f --- /dev/null +++ b/rust/schist_core/src/models/date_utc.rs @@ -0,0 +1,309 @@ +use std::{borrow::Borrow, fmt, str::FromStr}; + +use anyhow::{Context, Error, Result}; +use chrono::{DateTime, Datelike, NaiveDate, NaiveTime, Utc}; +use diesel::{ + backend::Backend, + deserialize::{self, FromSql, FromSqlRow}, + expression::AsExpression, + serialize::{self, ToSql}, + sql_types::Text, + sqlite::Sqlite, +}; +use serde::{Deserialize, Serialize}; + +use crate::traits::{dateable::Dateable, nowlike::Nowlike}; + +use super::datetime_utc::DatetimeUtc; + +#[derive( + Eq, + PartialEq, + Ord, + PartialOrd, + Serialize, + Deserialize, + Clone, + Debug, + AsExpression, + FromSqlRow, +)] +#[diesel(sql_type=Text)] +pub struct DateUtc { + chrono_datetime_utc: DateTime<Utc>, +} + +impl DateUtc { + pub fn from_ymd(year: i32, month: u32, day: u32) -> Result<Self> { + Ok(Self { + chrono_datetime_utc: NaiveDate::from_ymd_opt(year, month, day) + .with_context(|| format!("failed to construct date from ymd {:04}-{:02}-{:02}", year, month, day))? + .and_hms_opt(0, 0, 0).unwrap() + .and_utc() + }) + } + + pub fn with_hms(&mut self, hour: u32, min: u32, sec: u32) -> Result<DatetimeUtc> { + DatetimeUtc::from_ymd_and_hms( + self.year(), self.month(), self.day(), hour, min, sec, + ) + } + + pub fn day_diff(&self, other: &DateUtc) -> u32 { + self.chrono_datetime_utc + .num_days_from_ce() + .abs_diff(other.chrono_datetime_utc.num_days_from_ce()) + } + + 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; + } +} + +impl Nowlike for DateUtc { + fn now() -> Self { + let now = Utc::now(); + Self::from_ymd( + now.year(), + now.month(), + now.day(), + ).unwrap() + } +} + +impl Dateable for DateUtc { + fn year(&self) -> i32 { + self.chrono_datetime_utc.year() + } + + fn month(&self) -> u32 { + self.chrono_datetime_utc.month() + } + + fn day(&self) -> u32 { + self.chrono_datetime_utc.day() + } +} + +impl From<DatetimeUtc> for DateUtc { + fn from(datetime_utc: DatetimeUtc) -> Self { + Self { + chrono_datetime_utc: datetime_utc + .borrow() + .to_string() + .parse::<DateTime<Utc>>().unwrap() + .with_time(NaiveTime::from_hms_opt(0, 0, 0).unwrap()).unwrap(), + } + } +} + +impl<T> From<T> for DateUtc where T: Borrow<DateTime<Utc>> { + fn from(chrono_datetime_utc: T) -> Self { + Self { + chrono_datetime_utc: chrono_datetime_utc + .borrow() + .with_time(NaiveTime::from_hms_opt(0, 0, 0).unwrap()).unwrap(), + } + } +} + +impl fmt::Display for DateUtc { + /// Converts to a day string, YYYY-MM-DD, in UTC + /// Example: 10.30am 24 Oct 2024 UTC -> "2024-10-24" + fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { + let date_str = self.chrono_datetime_utc.to_rfc3339(); + let day_str = date_str + .split_at_checked(10) + .unwrap() + .0; + write!(f, "{}", day_str) + } +} + +impl FromStr for DateUtc { + type Err = anyhow::Error; + + /// Constructs DatetimeUtc from a day string, YYYY-MM-DD, in UTC + /// Example: "2024-10-24" -> Midnight 24 Oct 2024 UTC + fn from_str(date_str: &str) -> Result<Self> { + if !Self::is_day_str(&date_str) { + Err(Error::msg(format!("{} is not a day string in YYYY-MM-DD format", date_str))) + } else { + let mut datetime_str = String::from(date_str); + datetime_str.push_str("T00:00:00.000Z"); + Ok(Self { + chrono_datetime_utc: datetime_str.parse()?, + }) + } + } +} + +impl ToSql<Text, Sqlite> for DateUtc { + fn to_sql<'b>( + &'b self, + out: &mut diesel::serialize::Output<'b, '_, Sqlite>, + ) -> serialize::Result { + out.set_value(self.to_string()); + Ok(serialize::IsNull::No) + } +} + +impl FromSql<Text, Sqlite> for DateUtc { + fn from_sql(bytes: <Sqlite as Backend>::RawValue<'_>) -> deserialize::Result<DateUtc> { + let str = <String as FromSql<Text, Sqlite>>::from_sql(bytes)?; + Ok(str.parse()?) + } +} + +#[cfg(test)] +mod test { + use crate::traits::timeable::Timeable; + + use super::*; + + #[test] + fn when_from_ymd_then_ymd_are_as_expected() { + let date_utc = DateUtc::from_ymd(1970, 11, 23); + + assert!(date_utc.is_ok()); + let date_utc = date_utc.unwrap(); + assert_eq!(date_utc.year(), 1970); + assert_eq!(date_utc.month(), 11); + assert_eq!(date_utc.day(), 23); + } + + #[test] + fn when_from_ymd_then_to_string_as_expected() { + let date_utc = DateUtc::from_ymd(1970, 11, 23); + + assert!(date_utc.is_ok()); + assert_eq!(date_utc.unwrap().to_string(), "1970-11-23"); + } + + #[test] + fn when_from_invalid_ymd_then_err() { + let date_utc_1 = DateUtc::from_ymd(1970, 0, 23); + let date_utc_2 = DateUtc::from_ymd(1970, 13, 23); + let date_utc_3 = DateUtc::from_ymd(1970, 11, 0); + let date_utc_4 = DateUtc::from_ymd(1970, 11, 31); + let date_utc_5 = DateUtc::from_ymd(1971, 2, 29); + + assert!(date_utc_1.is_err()); + assert_eq!(date_utc_1.unwrap_err().to_string(), "failed to construct date from ymd 1970-00-23"); + assert!(date_utc_2.is_err()); + assert_eq!(date_utc_2.unwrap_err().to_string(), "failed to construct date from ymd 1970-13-23"); + assert!(date_utc_3.is_err()); + assert_eq!(date_utc_3.unwrap_err().to_string(), "failed to construct date from ymd 1970-11-00"); + assert!(date_utc_4.is_err()); + assert_eq!(date_utc_4.unwrap_err().to_string(), "failed to construct date from ymd 1970-11-31"); + assert!(date_utc_5.is_err()); + assert_eq!(date_utc_5.unwrap_err().to_string(), "failed to construct date from ymd 1971-02-29"); + } + + #[test] + fn when_from_string_then_ymd_are_as_expected() { + let date_utc: Result<DateUtc> = "1970-11-23".parse(); + + assert!(date_utc.is_ok()); + let date_utc = date_utc.unwrap(); + assert_eq!(date_utc.year(), 1970); + assert_eq!(date_utc.month(), 11); + assert_eq!(date_utc.day(), 23); + } + + #[test] + fn when_from_string_then_to_string_as_expected() { + let date_utc: Result<DateUtc> = "1970-11-23".parse(); + + assert!(date_utc.is_ok()); + assert_eq!(date_utc.unwrap().to_string(), "1970-11-23"); + } + + #[test] + fn when_from_invalid_string_then_err() { + let date_utc_1: Result<DateUtc> = "1970-00-23".parse(); + let date_utc_2: Result<DateUtc> = "1970-13-23".parse(); + let date_utc_3: Result<DateUtc> = "1970-11-0".parse(); + let date_utc_4: Result<DateUtc> = "1970-11-31".parse(); + let date_utc_5: Result<DateUtc> = "1971-02-29".parse(); + + assert!(date_utc_1.is_err()); + assert!(date_utc_2.is_err()); + assert!(date_utc_3.is_err()); + assert!(date_utc_4.is_err()); + assert!(date_utc_5.is_err()); + } + + #[test] + fn with_with_hms_then_ymd_hms_are_as_expected() { + let datetime_utc = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(12, 55, 16); + + assert!(datetime_utc.is_ok()); + let datetime_utc = datetime_utc.unwrap(); + assert_eq!(datetime_utc.year(), 1970); + assert_eq!(datetime_utc.month(), 11); + assert_eq!(datetime_utc.day(), 23); + assert_eq!(datetime_utc.hour(), 12); + assert_eq!(datetime_utc.minute(), 55); + assert_eq!(datetime_utc.second(), 16); + } + + #[test] + fn when_with_invalid_hms_then_err() { + let datetime_utc_1 = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(25, 0, 0); + let datetime_utc_2 = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(0, 61, 0); + let datetime_utc_3 = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(0, 0, 61); + + assert!(datetime_utc_1.is_err()); + assert!(datetime_utc_2.is_err()); + assert!(datetime_utc_3.is_err()); + } + + #[test] + fn when_from_datetime_utc_at_different_times_on_same_day_then_eq() { + let datetime_utc1 = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(0, 0, 0).unwrap(); + let datetime_utc2 = DateUtc::from_ymd(1970, 11, 23).unwrap().with_hms(23, 59, 59).unwrap(); + let date_utc1 = DateUtc::from(datetime_utc1); + let date_utc2 = DateUtc::from(datetime_utc2); + + assert_eq!(date_utc1, date_utc2); + } + + #[test] + fn given_today_when_day_diff_today_then_return_0() { + let start = DateUtc::from_ymd(2000, 1, 1).unwrap(); + let end = DateUtc::from_ymd(2000, 1, 1).unwrap(); + + let day_diff = start.day_diff(&end); + let neg_day_diff = end.day_diff(&start); + + assert_eq!(day_diff, 0); + assert_eq!(day_diff, neg_day_diff); + } + + #[test] + fn given_today_when_day_diff_tomorrow_then_return_1() { + let start = DateUtc::from_ymd(2000, 1, 1).unwrap(); + let end = DateUtc::from_ymd(2000, 1, 2).unwrap(); + + let day_diff = start.day_diff(&end); + let neg_day_diff = end.day_diff(&start); + + assert_eq!(day_diff, 1); + assert_eq!(day_diff, neg_day_diff); + } +} diff --git a/rust/schist_core/src/models/datetime_utc.rs b/rust/schist_core/src/models/datetime_utc.rs new file mode 100644 index 0000000..98d1d6c --- /dev/null +++ b/rust/schist_core/src/models/datetime_utc.rs @@ -0,0 +1,223 @@ +use std::{fmt::Display, str::FromStr}; + +use anyhow::{Context, Result}; +use chrono::{DateTime, Datelike as ChronoDatelike, NaiveDate, Timelike as ChronoTimelike, Utc}; +use diesel::{ + backend::Backend, + deserialize::{self, FromSql, FromSqlRow}, + expression::AsExpression, + serialize::{self, ToSql}, + sql_types::Text, + sqlite::Sqlite, +}; +use serde::{Deserialize, Serialize}; + +use crate::traits::{dateable::Dateable, nowlike::Nowlike, timeable::Timeable}; + +#[derive( + PartialEq, + Eq, + PartialOrd, + Ord, + Serialize, + Deserialize, + Clone, + Debug, + AsExpression, + FromSqlRow, +)] +#[diesel(sql_type=Text)] +pub struct DatetimeUtc { + chrono_datetime_utc: DateTime<Utc>, +} + +impl DatetimeUtc { + pub fn from_ymd_and_hms(year: i32, month: u32, day: u32, hour: u32, min: u32, sec: u32) -> Result<Self> { + Ok(Self { chrono_datetime_utc: NaiveDate + ::from_ymd_opt(year, month, day) + .with_context(|| format!("failed to construct datetime from ymd {:04}-{:02}-{:02}", year, month, day))? + .and_hms_opt(hour, min, sec) + .with_context(|| format!("failed to construct datetime from hms {:02}:{:02}:{:02}", hour, min, sec))? + .and_utc() + }) + } +} + +impl FromStr for DatetimeUtc { + type Err = anyhow::Error; + + /// Constructs DatetimeUtc from a date string in ISO format, in UTC + /// Example: "2024-10-24T10:30:00.000" -> 10.30am 24 Oct 2024 UTC + fn from_str(datetime_str: &str) -> Result<Self> { + let chrono_datetime_utc = datetime_str.parse::<DateTime<Utc>>()?; + Ok(Self { + chrono_datetime_utc, + }) + } +} + +impl Display for DatetimeUtc { + /// Converts to a date string in ISO format, in UTC + /// Example: 10.30am 24 Oct 2024 UTC -> "2024-10-24T10:30:00.000Z" + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + write!(f, "{}", self.chrono_datetime_utc.to_rfc3339_opts(chrono::SecondsFormat::Millis, true)) + } +} + +impl Nowlike for DatetimeUtc { + fn now() -> Self { + let now = Utc::now(); + Self::from_ymd_and_hms( + now.year(), + now.month(), + now.day(), + now.hour(), + now.minute(), + now.second(), + ).unwrap() + } +} + +impl Dateable for DatetimeUtc { + fn year(&self) -> i32 { + self.chrono_datetime_utc.year() + } + + fn month(&self) -> u32 { + self.chrono_datetime_utc.month() + } + + fn day(&self) -> u32 { + self.chrono_datetime_utc.day() + } +} + +impl Timeable for DatetimeUtc { + fn hour(&self) -> u32 { + self.chrono_datetime_utc.hour() + } + + fn minute(&self) -> u32 { + self.chrono_datetime_utc.minute() + } + + fn second(&self) -> u32 { + self.chrono_datetime_utc.second() + } +} + +impl ToSql<Text, Sqlite> for DatetimeUtc { + fn to_sql<'b>( + &'b self, + out: &mut diesel::serialize::Output<'b, '_, Sqlite>, + ) -> serialize::Result { + out.set_value::<String>(self.to_string()); + Ok(serialize::IsNull::No) + } +} + +impl FromSql<Text, Sqlite> for DatetimeUtc { + fn from_sql(bytes: <Sqlite as Backend>::RawValue<'_>) -> deserialize::Result<DatetimeUtc> { + let str = <String as FromSql<Text, Sqlite>>::from_sql(bytes)?; + Ok(str.parse()?) + } +} + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn when_from_ymd_and_hms_then_ymd_and_hms_are_as_expected() { + let datetime_utc = DatetimeUtc::from_ymd_and_hms(1970, 11, 23, 12, 55, 16); + + assert!(datetime_utc.is_ok()); + let date_utc = datetime_utc.unwrap(); + assert_eq!(date_utc.year(), 1970); + assert_eq!(date_utc.month(), 11); + assert_eq!(date_utc.day(), 23); + assert_eq!(date_utc.hour(), 12); + assert_eq!(date_utc.minute(), 55); + assert_eq!(date_utc.second(), 16); + } + + #[test] + fn when_from_ymd_and_hms_then_to_string_as_expected() { + let date_utc = DatetimeUtc::from_ymd_and_hms(1970, 11, 23, 12, 55, 16); + + assert!(date_utc.is_ok()); + assert_eq!(date_utc.unwrap().to_string(), "1970-11-23T12:55:16.000Z") + } + + #[test] + fn when_with_invalid_ymd_and_hms_then_err() { + let datetime_utc_1 = DatetimeUtc::from_ymd_and_hms(1970, 0, 23, 12, 55, 16); + let datetime_utc_2 = DatetimeUtc::from_ymd_and_hms(1970, 13, 23, 12, 55, 16); + let datetime_utc_3 = DatetimeUtc::from_ymd_and_hms(1970, 11, 0, 12, 55, 16); + let datetime_utc_4 = DatetimeUtc::from_ymd_and_hms(1970, 11, 31, 12, 55, 16); + let datetime_utc_5 = DatetimeUtc::from_ymd_and_hms(1971, 2, 29, 12, 55, 16); + let datetime_utc_6 = DatetimeUtc::from_ymd_and_hms(1970, 11, 23, 25, 0, 0); + let datetime_utc_7 = DatetimeUtc::from_ymd_and_hms(1970, 11, 23, 0, 61, 0); + let datetime_utc_8 = DatetimeUtc::from_ymd_and_hms(1970, 11, 23, 0, 0, 61); + + assert!(datetime_utc_1.is_err()); + assert_eq!(datetime_utc_1.unwrap_err().to_string(), "failed to construct datetime from ymd 1970-00-23"); + assert!(datetime_utc_2.is_err()); + assert_eq!(datetime_utc_2.unwrap_err().to_string(), "failed to construct datetime from ymd 1970-13-23"); + assert!(datetime_utc_3.is_err()); + assert_eq!(datetime_utc_3.unwrap_err().to_string(), "failed to construct datetime from ymd 1970-11-00"); + assert!(datetime_utc_4.is_err()); + assert_eq!(datetime_utc_4.unwrap_err().to_string(), "failed to construct datetime from ymd 1970-11-31"); + assert!(datetime_utc_5.is_err()); + assert_eq!(datetime_utc_5.unwrap_err().to_string(), "failed to construct datetime from ymd 1971-02-29"); + assert!(datetime_utc_6.is_err()); + assert_eq!(datetime_utc_6.unwrap_err().to_string(), "failed to construct datetime from hms 25:00:00"); + assert!(datetime_utc_7.is_err()); + assert_eq!(datetime_utc_7.unwrap_err().to_string(), "failed to construct datetime from hms 00:61:00"); + assert!(datetime_utc_8.is_err()); + assert_eq!(datetime_utc_8.unwrap_err().to_string(), "failed to construct datetime from hms 00:00:61"); + } + + #[test] + fn when_from_string_then_ymd_and_hms_are_as_expected() { + let date_utc: Result<DatetimeUtc> = "1970-11-23T12:55:16.000Z".parse(); + + assert!(date_utc.is_ok()); + let datetime_utc = date_utc.unwrap(); + assert_eq!(datetime_utc.year(), 1970); + assert_eq!(datetime_utc.month(), 11); + assert_eq!(datetime_utc.day(), 23); + assert_eq!(datetime_utc.hour(), 12); + assert_eq!(datetime_utc.minute(), 55); + assert_eq!(datetime_utc.second(), 16); + } + + #[test] + fn when_from_string_then_to_string_as_expected() { + let datetime_utc: Result<DatetimeUtc> = "1970-11-23T12:55:16.000Z".parse(); + + assert!(datetime_utc.is_ok()); + assert_eq!(datetime_utc.unwrap().to_string(), "1970-11-23T12:55:16.000Z") + } + + #[test] + fn when_from_invalid_string_then_err() { + let datetime_utc_1: Result<DatetimeUtc> = "1970-00-23T00:00:00.000Z".parse(); + let datetime_utc_2: Result<DatetimeUtc> = "1970-13-23T00:00:00.000Z".parse(); + let datetime_utc_3: Result<DatetimeUtc> = "1970-11-0T00:00:00.000Z".parse(); + let datetime_utc_4: Result<DatetimeUtc> = "1970-11-31T00:00:00.000Z".parse(); + let datetime_utc_5: Result<DatetimeUtc> = "1971-02-29T00:00:00.000Z".parse(); + let datetime_utc_6: Result<DatetimeUtc> = "1970-11-23T25:00:00.000Z".parse(); + let datetime_utc_7: Result<DatetimeUtc> = "1970-11-23T00:61:00.000Z".parse(); + let datetime_utc_8: Result<DatetimeUtc> = "1970-11-23T00:00:61.000Z".parse(); + + assert!(datetime_utc_1.is_err()); + assert!(datetime_utc_2.is_err()); + assert!(datetime_utc_3.is_err()); + assert!(datetime_utc_4.is_err()); + assert!(datetime_utc_5.is_err()); + assert!(datetime_utc_6.is_err()); + assert!(datetime_utc_7.is_err()); + assert!(datetime_utc_8.is_err()); + } +} diff --git a/rust/schist_core/src/models/mod.rs b/rust/schist_core/src/models/mod.rs new file mode 100644 index 0000000..2eb7ac2 --- /dev/null +++ b/rust/schist_core/src/models/mod.rs @@ -0,0 +1,11 @@ +pub mod account; +pub mod budget; +pub mod budget_update; +pub mod category; +pub mod category_balance; +pub mod category_budget; +pub mod category_transfer; +pub mod date_utc; +pub mod datetime_utc; +pub mod transaction; +pub mod transaction_categorisation; diff --git a/rust/schist_core/src/models/transaction.rs b/rust/schist_core/src/models/transaction.rs new file mode 100644 index 0000000..18a4c0e --- /dev/null +++ b/rust/schist_core/src/models/transaction.rs @@ -0,0 +1,18 @@ +use derive_builder::Builder; +use diesel::prelude::*; + +use crate::models::account::Account; + +use super::datetime_utc::DatetimeUtc; + +#[derive(Builder, Queryable, Identifiable, Selectable, Insertable, Associations, Debug, PartialEq)] +#[diesel(table_name = crate::schema::transactions)] +#[diesel(belongs_to(Account))] +pub struct Transaction { + pub id: i32, + pub description: String, + pub payee: String, + pub quantity: i32, + pub date: DatetimeUtc, + pub account_id: i32, +} diff --git a/rust/schist_core/src/models/transaction_categorisation.rs b/rust/schist_core/src/models/transaction_categorisation.rs new file mode 100644 index 0000000..c6ac6ea --- /dev/null +++ b/rust/schist_core/src/models/transaction_categorisation.rs @@ -0,0 +1,12 @@ +use derive_builder::Builder; +use diesel::prelude::*; + +#[derive(Builder, Queryable, Identifiable, Selectable, Insertable, Debug, PartialEq)] +#[diesel(table_name = crate::schema::transaction_categorisations)] +pub struct TransactionCategorisation { + pub id: i32, + pub description: String, + pub quantity: i32, + pub transaction_id: i32, + pub category_id: i32, +} diff --git a/rust/schist_core/src/queries/accounts/delete_all.rs b/rust/schist_core/src/queries/accounts/delete_all.rs new file mode 100644 index 0000000..84d7bf6 --- /dev/null +++ b/rust/schist_core/src/queries/accounts/delete_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use diesel::{RunQueryDsl, SqliteConnection}; + +use crate::schema::accounts::dsl::accounts; + +pub fn delete_all_accounts(connection: &mut SqliteConnection) -> Result<usize> { + let num_rows_deleted = diesel::delete(accounts) + .execute(connection) + .with_context(|| "failed to delete all accounts")?; + Ok(num_rows_deleted) +} diff --git a/rust/schist_core/src/queries/accounts/get_all.rs b/rust/schist_core/src/queries/accounts/get_all.rs new file mode 100644 index 0000000..ab53729 --- /dev/null +++ b/rust/schist_core/src/queries/accounts/get_all.rs @@ -0,0 +1,10 @@ +use anyhow::{Context, Result}; +use crate::{models::account::Account, schema::accounts::dsl::accounts}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +pub fn get_all_accounts(connection: &mut SqliteConnection) -> Result<Vec<Account>> { + let all_accounts = accounts.select(Account::as_select()) + .load(connection) + .with_context(|| "failed to get all accounts")?; + Ok(all_accounts) +} diff --git a/rust/schist_core/src/queries/accounts/insert.rs b/rust/schist_core/src/queries/accounts/insert.rs new file mode 100644 index 0000000..7020b68 --- /dev/null +++ b/rust/schist_core/src/queries/accounts/insert.rs @@ -0,0 +1,28 @@ +use anyhow::{Context, Result}; +use crate::{ + models::account::Account, + schema::accounts::dsl::accounts as accounts_table, +}; +use diesel::prelude::*; + +pub fn insert_accounts( + accounts: &[Account], + connection: &mut SqliteConnection, +) -> Result<usize> { + let num_accounts_inserted = diesel::insert_into(accounts_table) + .values(accounts) + .execute(connection) + .with_context(|| err_msg(accounts))?; + Ok(num_accounts_inserted) +} + +fn err_msg(accounts: &[Account]) -> String { + format!( + "failed to insert accounts: [{}]", + accounts + .iter() + .map(|a| format!("\"{}\": \"{}\"", a.id, a.name)) + .collect::<Vec<String>>() + .join(", ") + ) +} diff --git a/rust/schist_core/src/queries/accounts/mod.rs b/rust/schist_core/src/queries/accounts/mod.rs new file mode 100644 index 0000000..222b180 --- /dev/null +++ b/rust/schist_core/src/queries/accounts/mod.rs @@ -0,0 +1,7 @@ +mod delete_all; +mod get_all; +mod insert; + +pub use delete_all::delete_all_accounts; +pub use get_all::get_all_accounts; +pub use insert::insert_accounts; diff --git a/rust/schist_core/src/queries/budget_updates/delete_all.rs b/rust/schist_core/src/queries/budget_updates/delete_all.rs new file mode 100644 index 0000000..b7ad082 --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/delete_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use diesel::{RunQueryDsl, SqliteConnection}; + +use crate::schema::budget_updates::dsl::budget_updates; + +pub fn delete_all_budget_updates(connection: &mut SqliteConnection) -> Result<usize> { + let num_rows_deleted = diesel::delete(budget_updates) + .execute(connection) + .with_context(|| "failed to delete all budget updates")?; + Ok(num_rows_deleted) +} diff --git a/rust/schist_core/src/queries/budget_updates/get_all.rs b/rust/schist_core/src/queries/budget_updates/get_all.rs new file mode 100644 index 0000000..9c9310b --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/get_all.rs @@ -0,0 +1,16 @@ +use anyhow::{Context, Result}; +use crate::{ + models::budget_update::BudgetUpdate, + schema::budget_updates::dsl::budget_updates as budget_updates_table, +}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +pub fn get_all_budget_updates( + connection: &mut SqliteConnection, +) -> Result<Vec<BudgetUpdate>> { + let all_budget_updates = budget_updates_table + .select(BudgetUpdate::as_select()) + .load::<BudgetUpdate>(connection) + .with_context(|| "failed to get all budget updates")?; + Ok(all_budget_updates) +} diff --git a/rust/schist_core/src/queries/budget_updates/get_first_with_date_and_category_id.rs b/rust/schist_core/src/queries/budget_updates/get_first_with_date_and_category_id.rs new file mode 100644 index 0000000..2d8f97c --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/get_first_with_date_and_category_id.rs @@ -0,0 +1,25 @@ +use anyhow::{Context, Result}; +use crate::{ + models::{budget_update::BudgetUpdate, date_utc::DateUtc}, + schema::budget_updates::{ + self as budget_updates_schema, dsl::budget_updates as budget_updates_table, + }, +}; +use diesel::{ + ExpressionMethods, OptionalExtension, QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection +}; + +pub fn get_first_budget_update_with_date_and_category_id( + date: &DateUtc, + category_id: i32, + connection: &mut SqliteConnection, +) -> Result<Option<BudgetUpdate>> { + let first_budget_update = budget_updates_table + .select(BudgetUpdate::as_select()) + .filter(budget_updates_schema::date.eq(date.to_string())) + .filter(budget_updates_schema::category_id.eq(category_id)) + .first(connection) + .optional() + .with_context(|| format!("failed to get first budget update with date {}", date.to_string()))?; + Ok(first_budget_update) +} diff --git a/rust/schist_core/src/queries/budget_updates/get_most_recent_with_category_id.rs b/rust/schist_core/src/queries/budget_updates/get_most_recent_with_category_id.rs new file mode 100644 index 0000000..41ef5ec --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/get_most_recent_with_category_id.rs @@ -0,0 +1,21 @@ +use anyhow::{Context, Result}; +use crate::{ + models::date_utc::DateUtc, + schema::budget_updates::{ + self as budget_updates_schema, dsl::budget_updates as budget_updates_table, + }, traits::nowlike::Nowlike, +}; +use diesel::{dsl::max, ExpressionMethods, QueryDsl, RunQueryDsl, SqliteConnection}; + +pub fn get_most_recent_budget_update_date_with_category_id( + category_id: i32, + connection: &mut SqliteConnection, +) -> Result<Option<DateUtc>> { + let most_recent_date = budget_updates_table + .select(max(budget_updates_schema::date)) + .filter(budget_updates_schema::category_id.eq(category_id)) + .filter(budget_updates_schema::date.le(DateUtc::now())) + .first(connection) + .with_context(|| format!("failed to get most recent budget update date with category ID {}", category_id))?; + Ok(most_recent_date) +} diff --git a/rust/schist_core/src/queries/budget_updates/insert.rs b/rust/schist_core/src/queries/budget_updates/insert.rs new file mode 100644 index 0000000..e8ae271 --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/insert.rs @@ -0,0 +1,28 @@ +use anyhow::{Context, Result}; +use crate::{ + models::budget_update::BudgetUpdate, + schema::budget_updates::dsl::budget_updates as budget_updates_table, +}; +use diesel::prelude::*; + +pub fn insert_budget_updates( + budget_updates: &[BudgetUpdate], + connection: &mut SqliteConnection, +) -> Result<usize> { + let num_rows_inserted = diesel::insert_into(budget_updates_table) + .values(budget_updates) + .execute(connection) + .with_context(|| err_msg(budget_updates))?; + Ok(num_rows_inserted) +} + +fn err_msg(budget_updates: &[BudgetUpdate]) -> String { + format!( + "failed to insert budget updates: [{}]", + budget_updates + .iter() + .map(|a| a.id.to_string()) + .collect::<Vec<String>>() + .join(", ") + ) +} diff --git a/rust/schist_core/src/queries/budget_updates/mod.rs b/rust/schist_core/src/queries/budget_updates/mod.rs new file mode 100644 index 0000000..6fc7de0 --- /dev/null +++ b/rust/schist_core/src/queries/budget_updates/mod.rs @@ -0,0 +1,11 @@ +mod delete_all; +mod get_all; +mod get_first_with_date_and_category_id; +mod get_most_recent_with_category_id; +mod insert; + +pub use delete_all::delete_all_budget_updates; +pub use get_all::get_all_budget_updates; +pub use get_first_with_date_and_category_id::get_first_budget_update_with_date_and_category_id; +pub use get_most_recent_with_category_id::get_most_recent_budget_update_date_with_category_id; +pub use insert::insert_budget_updates; diff --git a/rust/schist_core/src/queries/categories/delete_all.rs b/rust/schist_core/src/queries/categories/delete_all.rs new file mode 100644 index 0000000..1fd2581 --- /dev/null +++ b/rust/schist_core/src/queries/categories/delete_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use diesel::{RunQueryDsl, SqliteConnection}; + +use crate::schema::categories::dsl::categories; + +pub fn delete_all_categories(connection: &mut SqliteConnection) -> Result<usize> { + let num_rows_deleted = diesel::delete(categories) + .execute(connection) + .with_context(|| "failed to delete all categories")?; + Ok(num_rows_deleted) +} diff --git a/rust/schist_core/src/queries/categories/get_all.rs b/rust/schist_core/src/queries/categories/get_all.rs new file mode 100644 index 0000000..431ed9c --- /dev/null +++ b/rust/schist_core/src/queries/categories/get_all.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use crate::{models::category::Category, schema::categories::dsl::categories as categories_table}; +use diesel::{QueryDsl, RunQueryDsl, SelectableHelper, SqliteConnection}; + +pub fn get_all_categories(connection: &mut SqliteConnection) -> Result<Vec<Category>> { + let all_categories = categories_table + .select(Category::as_select()) + .load(connection) + .with_context(|| "failed to get all categories")?; + Ok(all_categories) +} diff --git a/rust/schist_core/src/queries/categories/get_all_balances.rs b/rust/schist_core/src/queries/categories/get_all_balances.rs new file mode 100644 index 0000000..c9a0102 --- /dev/null +++ b/rust/schist_core/src/queries/categories/get_all_balances.rs @@ -0,0 +1,47 @@ +use anyhow::{Context, Result}; +use crate::{models::category_balance::CategoryBalance, queries::{ + budget_updates::get_all_budget_updates, + categories::get_all_categories, + category_transfers::{ + sum_category_transfer_quantity_per_from_category_id, + sum_category_transfer_quantity_per_to_category_id, + }, + transaction_categorisations::sum_transaction_categorisation_quantity_per_category_id, + }, utils::calculate_category_balance}; +use diesel::SqliteConnection; + +pub fn get_all_category_balances( + connection: &mut SqliteConnection, +) -> Result<Vec<CategoryBalance>> { + get_all_category_balances_without_context(connection) + .with_context(|| "failed to get all category balances") +} + +fn get_all_category_balances_without_context( + connection: &mut SqliteConnection, +) -> Result<Vec<CategoryBalance>> { + let categories = get_all_categories(connection)?; + let transaction_sums = sum_transaction_categorisation_quantity_per_category_id(connection)?; + let category_transfer_from_sums = + sum_category_transfer_quantity_per_from_category_id(connection)?; + let category_transfer_to_sums = sum_category_transfer_quantity_per_to_category_id(connection)?; + let budget_updates = get_all_budget_updates(connection)?; + + let mut balances = Vec::<CategoryBalance>::new(); + for category in categories { + let balance = calculate_category_balance( + &category, + &transaction_sums, + &category_transfer_from_sums, + &category_transfer_to_sums, + &budget_updates, + )?; + + balances.push(CategoryBalance { + category_id: category.id, + balance: balance.try_into().unwrap(), + }) + } + + Ok(balances) +} diff --git a/rust/schist_core/src/queries/categories/get_all_ids.rs b/rust/schist_core/src/queries/categories/get_all_ids.rs new file mode 100644 index 0000000..8505e71 --- /dev/null +++ b/rust/schist_core/src/queries/categories/get_all_ids.rs @@ -0,0 +1,11 @@ +use anyhow::{Context, Result}; +use crate::schema::categories::{self as categories_schema, dsl::categories as categories_table}; +use diesel::{QueryDsl, RunQueryDsl, SqliteConnection}; + +pub fn get_all_category_ids(connection: &mut SqliteConnection) -> Result<Vec<i32>> { + let all_category_ids = categories_table + .select(categories_schema::id) + .load(connection) + .with_context(|| "failed to get all category IDs")?; + Ok(all_category_ids) +} diff --git a/rust/schist_core/src/queries/categories/get_most_recent_budget_per_category_id.rs b/rust/schist_core/src/queries/categories/get_most_recent_budget_per_category_id.rs new file mode 100644 index 0000000..9f2e4f6 --- /dev/null +++ b/rust/schist_core/src/queries/categories/get_most_recent_budget_per_category_id.rs @@ -0,0 +1,52 @@ +use anyhow::{Context, Result}; +use crate::{models::{budget::Budget, category_budget::CategoryBudget}, queries::{ + budget_updates::{ + get_first_budget_update_with_date_and_category_id, get_most_recent_budget_update_date_with_category_id, + }, + categories::get_all_category_ids, +}}; +use diesel::SqliteConnection; + +pub fn get_most_recent_category_budget_per_category_id( + connection: &mut SqliteConnection, +) -> Result<Vec<CategoryBudget>> { + get_most_recent_category_budget_per_category_id_without_context(connection) + .with_context(|| "failed to get most recent category budget per category ID") +} + +fn get_most_recent_category_budget_per_category_id_without_context( + connection: &mut SqliteConnection, +) -> Result<Vec<CategoryBudget>> { + let category_ids: Vec<i32> = get_all_category_ids(connection)?; + + let mut budgets = Vec::<CategoryBudget>::new(); + for category_id in category_ids { + let most_recent_budget_update_date = + get_most_recent_budget_update_date_with_category_id(category_id, connection)?; + + if most_recent_budget_update_date.is_none() { + budgets.push(CategoryBudget { + category_id, + budget: Option::None, + }); + continue; + } + let most_recent_budget_update_date = most_recent_budget_update_date.unwrap(); + + let most_recent_budget_update = get_first_budget_update_with_date_and_category_id( + &most_recent_budget_update_date, + category_id, + connection, + )?; + // The fact we found the date by getting the most recent budget update + // date guarantees that the Option is Some + let most_recent_budget_update = most_recent_budget_update.unwrap(); + + budgets.push(CategoryBudget { + category_id, + budget: Some(Budget::from(&most_recent_budget_update)), + }); + } + + Ok(budgets) +} diff --git a/rust/schist_core/src/queries/categories/insert.rs b/rust/schist_core/src/queries/categories/insert.rs new file mode 100644 index 0000000..bccba72 --- /dev/null +++ b/rust/schist_core/src/queries/categories/insert.rs @@ -0,0 +1,28 @@ +use anyhow::{Context, Result}; +use crate::{ + models::category::Category, + schema::categories::dsl::categories as categories_table, +}; +use diesel::prelude::*; + +pub fn insert_categories( + categories: &[Category], + connection: &mut SqliteConnection, +) -> Result<usize> { + let num_categories_inserted = diesel::insert_into(categories_table) + .values(categories) + .execute(connection) + .with_context(|| err_msg(categories))?; + Ok(num_categories_inserted) +} + +fn err_msg(categories: &[Category]) -> String { + format!( + "failed to insert categories: [{}]", + categories + .iter() + .map(|a| format!("\"{}\": \"{}\"", a.id, a.name)) + .collect::<Vec<String>>() + .join(", ") + ) +} diff --git a/rust/schist_core/src/queries/categories/mod.rs b/rust/schist_core/src/queries/categories/mod.rs new file mode 100644 index 0000000..edeeebf --- /dev/null +++ b/rust/schist_core/src/queries/categories/mod.rs @@ -0,0 +1,13 @@ +mod delete_all; +mod get_all; +mod get_all_balances; +mod get_all_ids; +mod get_most_recent_budget_per_category_id; +mod insert; + +pub use delete_all::delete_all_categories; +pub use get_all::get_all_categories; +pub use get_all_balances::get_all_category_balances; +pub use get_all_ids::get_all_category_ids; +pub use get_most_recent_budget_per_category_id::get_most_recent_category_budget_per_category_id; +pub use insert::insert_categories; diff --git a/rust/schist_core/src/queries/category_transfers/delete_all.rs b/rust/schist_core/src/queries/category_transfers/delete_all.rs new file mode 100644 index 0000000..406b80b --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/delete_all.rs @@ -0,0 +1,7 @@ +use diesel::{result::Error, RunQueryDsl, SqliteConnection}; + +use crate::schema::category_transfers::dsl::category_transfers; + +pub fn delete_all_category_transfers(connection: &mut SqliteConnection) -> Result<usize, Error> { + diesel::delete(category_transfers).execute(connection) +} diff --git a/rust/schist_core/src/queries/category_transfers/get_all.rs b/rust/schist_core/src/queries/category_transfers/get_all.rs new file mode 100644 index 0000000..73d7e10 --- /dev/null +++ b/rust/schist_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/rust/schist_core/src/queries/category_transfers/insert.rs b/rust/schist_core/src/queries/category_transfers/insert.rs new file mode 100644 index 0000000..e1db167 --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/insert.rs @@ -0,0 +1,15 @@ +use crate::{ + models::category_transfer::CategoryTransfer, + schema::category_transfers::dsl::category_transfers as category_transfers_table, +}; +use diesel::prelude::*; +use diesel::result::Error; + +pub fn insert_category_transfers( + category_transfers: &[CategoryTransfer], + connection: &mut SqliteConnection, +) -> Result<usize, Error> { + diesel::insert_into(category_transfers_table) + .values(category_transfers) + .execute(connection) +} diff --git a/rust/schist_core/src/queries/category_transfers/mod.rs b/rust/schist_core/src/queries/category_transfers/mod.rs new file mode 100644 index 0000000..eed7946 --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/mod.rs @@ -0,0 +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/rust/schist_core/src/queries/category_transfers/sum_quantity_per_from_category_id.rs b/rust/schist_core/src/queries/category_transfers/sum_quantity_per_from_category_id.rs new file mode 100644 index 0000000..a9c2a8c --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/sum_quantity_per_from_category_id.rs @@ -0,0 +1,18 @@ +use crate::schema::category_transfers::{ + self as category_transfers_schema, + dsl::category_transfers as category_transfers_table, +}; +use diesel::{dsl::sum, result::Error, QueryDsl, RunQueryDsl, SqliteConnection}; + +pub fn sum_category_transfer_quantity_per_from_category_id( + connection: &mut SqliteConnection, +) -> Result<Vec<(i32, i64)>, Error> { + category_transfers_table + .group_by(category_transfers_schema::from_category_id) + .select(( + category_transfers_schema::from_category_id, + sum(category_transfers_schema::quantity), + )) + .load::<(i32, Option<i64>)>(connection) + .map(|result| result.iter().map(|sum| (sum.0, sum.1.unwrap_or(0))).collect()) +} diff --git a/rust/schist_core/src/queries/category_transfers/sum_quantity_per_to_category_id.rs b/rust/schist_core/src/queries/category_transfers/sum_quantity_per_to_category_id.rs new file mode 100644 index 0000000..f041477 --- /dev/null +++ b/rust/schist_core/src/queries/category_transfers/sum_quantity_per_to_category_id.rs @@ -0,0 +1,18 @@ +use crate::schema::category_transfers::{ + self as category_transfers_schema, + dsl::category_transfers as category_transfers_table, +}; +use diesel::{dsl::sum, result::Error, QueryDsl, RunQueryDsl, SqliteConnection}; + +pub fn sum_category_transfer_quantity_per_to_category_id( + connection: &mut SqliteConnection, +) -> Result<Vec<(i32, i64)>, Error> { + category_transfers_table + .group_by(category_transfers_schema::to_category_id) + .select(( + category_transfers_schema::to_category_id, + sum(category_transfers_schema::quantity), + )) + .load::<(i32, Option<i64>)>(connection) + .map(|vec| vec.iter().map(|(id, sum)| (*id, sum.unwrap_or(0))).collect()) +} diff --git a/rust/schist_core/src/queries/clear.rs b/rust/schist_core/src/queries/clear.rs new file mode 100644 index 0000000..e704634 --- /dev/null +++ b/rust/schist_core/src/queries/clear.rs @@ -0,0 +1,20 @@ +use anyhow::Result; +use crate::queries::{ + accounts::delete_all_accounts, + budget_updates::delete_all_budget_updates, + categories::delete_all_categories, + category_transfers::delete_all_category_transfers, + transactions::delete_all_transactions, + transaction_categorisations::delete_all_transaction_categorisations, +}; +use diesel::SqliteConnection; + +pub fn clear(connection: &mut SqliteConnection) -> Result<()> { + delete_all_accounts(connection)?; + delete_all_budget_updates(connection)?; + delete_all_categories(connection)?; + delete_all_category_transfers(connection)?; + delete_all_transactions(connection)?; + delete_all_transaction_categorisations(connection)?; + Ok(()) +} diff --git a/rust/schist_core/src/queries/mod.rs b/rust/schist_core/src/queries/mod.rs new file mode 100644 index 0000000..f0852ce --- /dev/null +++ b/rust/schist_core/src/queries/mod.rs @@ -0,0 +1,7 @@ +pub mod accounts; +pub mod budget_updates; +pub mod categories; +pub mod category_transfers; +pub mod clear; +pub mod transactions; +pub mod transaction_categorisations; diff --git a/rust/schist_core/src/queries/transaction_categorisations/delete_all.rs b/rust/schist_core/src/queries/transaction_categorisations/delete_all.rs new file mode 100644 index 0000000..e80a0ca --- /dev/null +++ b/rust/schist_core/src/queries/transaction_categorisations/delete_all.rs @@ -0,0 +1,7 @@ +use diesel::{result::Error, RunQueryDsl, SqliteConnection}; + +use crate::schema::transaction_categorisations::dsl::transaction_categorisations; + +pub fn delete_all_transaction_categorisations(connection: &mut SqliteConnection) -> Result<usize, Error> { + diesel::delete(transaction_categorisations).execute(connection) +} diff --git a/rust/schist_core/src/queries/transaction_categorisations/get_all.rs b/rust/schist_core/src/queries/transaction_categorisations/get_all.rs new file mode 100644 index 0000000..0cacfe6 --- /dev/null +++ b/rust/schist_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/rust/schist_core/src/queries/transaction_categorisations/insert.rs b/rust/schist_core/src/queries/transaction_categorisations/insert.rs new file mode 100644 index 0000000..3da1c33 --- /dev/null +++ b/rust/schist_core/src/queries/transaction_categorisations/insert.rs @@ -0,0 +1,15 @@ +use crate::{ + models::transaction_categorisation::TransactionCategorisation, + schema::transaction_categorisations::dsl::transaction_categorisations as transaction_categorisations_table, +}; +use diesel::prelude::*; +use diesel::result::Error; + +pub fn insert_transaction_categorisations( + transaction_categorisations: &[TransactionCategorisation], + connection: &mut SqliteConnection, +) -> Result<usize, Error> { + diesel::insert_into(transaction_categorisations_table) + .values(transaction_categorisations) + .execute(connection) +} diff --git a/rust/schist_core/src/queries/transaction_categorisations/mod.rs b/rust/schist_core/src/queries/transaction_categorisations/mod.rs new file mode 100644 index 0000000..d383791 --- /dev/null +++ b/rust/schist_core/src/queries/transaction_categorisations/mod.rs @@ -0,0 +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/rust/schist_core/src/queries/transaction_categorisations/sum_quantity_per_category_id.rs b/rust/schist_core/src/queries/transaction_categorisations/sum_quantity_per_category_id.rs new file mode 100644 index 0000000..61f3492 --- /dev/null +++ b/rust/schist_core/src/queries/transaction_categorisations/sum_quantity_per_category_id.rs @@ -0,0 +1,18 @@ +use crate::schema::transaction_categorisations::{ + self as transaction_categorisations_schema, + dsl::transaction_categorisations as transaction_categorisations_table, +}; +use diesel::{dsl::sum, result::Error, QueryDsl, RunQueryDsl, SqliteConnection}; + +pub fn sum_transaction_categorisation_quantity_per_category_id( + connection: &mut SqliteConnection, +) -> Result<Vec<(i32, i64)>, Error> { + transaction_categorisations_table + .group_by(transaction_categorisations_schema::category_id) + .select(( + transaction_categorisations_schema::category_id, + sum(transaction_categorisations_schema::quantity), + )) + .load::<(i32, Option<i64>)>(connection) + .map(|vec| vec.iter().map(|(category_id, sum)| (*category_id, sum.unwrap_or(0))).collect()) +} diff --git a/rust/schist_core/src/queries/transactions/delete_all.rs b/rust/schist_core/src/queries/transactions/delete_all.rs new file mode 100644 index 0000000..43b7976 --- /dev/null +++ b/rust/schist_core/src/queries/transactions/delete_all.rs @@ -0,0 +1,7 @@ +use diesel::{result::Error, RunQueryDsl, SqliteConnection}; + +use crate::schema::transactions::dsl::transactions; + +pub fn delete_all_transactions(connection: &mut SqliteConnection) -> Result<usize, Error> { + diesel::delete(transactions).execute(connection) +} diff --git a/rust/schist_core/src/queries/transactions/get_all.rs b/rust/schist_core/src/queries/transactions/get_all.rs new file mode 100644 index 0000000..afb87f4 --- /dev/null +++ b/rust/schist_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/rust/schist_core/src/queries/transactions/insert.rs b/rust/schist_core/src/queries/transactions/insert.rs new file mode 100644 index 0000000..32f3dc2 --- /dev/null +++ b/rust/schist_core/src/queries/transactions/insert.rs @@ -0,0 +1,15 @@ +use crate::{ + models::transaction::Transaction, + schema::transactions::dsl::transactions as transactions_table, +}; +use diesel::prelude::*; +use diesel::result::Error; + +pub fn insert_transactions( + transactions: &[Transaction], + connection: &mut SqliteConnection, +) -> Result<usize, Error> { + diesel::insert_into(transactions_table) + .values(transactions) + .execute(connection) +} diff --git a/rust/schist_core/src/queries/transactions/mod.rs b/rust/schist_core/src/queries/transactions/mod.rs new file mode 100644 index 0000000..983e9af --- /dev/null +++ b/rust/schist_core/src/queries/transactions/mod.rs @@ -0,0 +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/rust/schist_core/src/schema.rs b/rust/schist_core/src/schema.rs new file mode 100644 index 0000000..372f8f3 --- /dev/null +++ b/rust/schist_core/src/schema.rs @@ -0,0 +1,72 @@ +// @generated automatically by Diesel CLI. + +diesel::table! { + accounts (id) { + id -> Integer, + name -> Text, + opening_balance -> Integer, + opening_date -> Text, + } +} + +diesel::table! { + budget_updates (id) { + id -> Integer, + category_id -> Integer, + date -> Text, + new_budget -> Integer, + new_period -> Integer, + } +} + +diesel::table! { + categories (id) { + id -> Integer, + name -> Text, + } +} + +diesel::table! { + category_transfers (id) { + id -> Integer, + description -> Text, + quantity -> Integer, + from_category_id -> Integer, + to_category_id -> Integer, + } +} + +diesel::table! { + transaction_categorisations (id) { + id -> Integer, + description -> Text, + quantity -> Integer, + transaction_id -> Integer, + category_id -> Integer, + } +} + +diesel::table! { + transactions (id) { + id -> Integer, + description -> Text, + payee -> Text, + quantity -> Integer, + date -> Text, + account_id -> Integer, + } +} + +diesel::joinable!(budget_updates -> categories (category_id)); +diesel::joinable!(transaction_categorisations -> categories (category_id)); +diesel::joinable!(transaction_categorisations -> transactions (transaction_id)); +diesel::joinable!(transactions -> accounts (account_id)); + +diesel::allow_tables_to_appear_in_same_query!( + accounts, + budget_updates, + categories, + category_transfers, + transaction_categorisations, + transactions, +); diff --git a/rust/schist_core/src/traits/dateable.rs b/rust/schist_core/src/traits/dateable.rs new file mode 100644 index 0000000..05f2d74 --- /dev/null +++ b/rust/schist_core/src/traits/dateable.rs @@ -0,0 +1,5 @@ +pub trait Dateable { + fn year(&self) -> i32; + fn month(&self) -> u32; + fn day(&self) -> u32; +} diff --git a/rust/schist_core/src/traits/mod.rs b/rust/schist_core/src/traits/mod.rs new file mode 100644 index 0000000..ab5caca --- /dev/null +++ b/rust/schist_core/src/traits/mod.rs @@ -0,0 +1,3 @@ +pub mod dateable; +pub mod nowlike; +pub mod timeable; diff --git a/rust/schist_core/src/traits/nowlike.rs b/rust/schist_core/src/traits/nowlike.rs new file mode 100644 index 0000000..bae2309 --- /dev/null +++ b/rust/schist_core/src/traits/nowlike.rs @@ -0,0 +1,3 @@ +pub trait Nowlike { + fn now() -> Self; +} diff --git a/rust/schist_core/src/traits/timeable.rs b/rust/schist_core/src/traits/timeable.rs new file mode 100644 index 0000000..f6f9244 --- /dev/null +++ b/rust/schist_core/src/traits/timeable.rs @@ -0,0 +1,5 @@ +pub trait Timeable { + fn hour(&self) -> u32; + fn minute(&self) -> u32; + fn second(&self) -> u32; +} diff --git a/rust/schist_core/src/utils/calculate_budgets_accrual.rs b/rust/schist_core/src/utils/calculate_budgets_accrual.rs new file mode 100644 index 0000000..56171ca --- /dev/null +++ b/rust/schist_core/src/utils/calculate_budgets_accrual.rs @@ -0,0 +1,155 @@ +use anyhow::Result; +use crate::{models::{ + budget_update::BudgetUpdate, category::Category, date_utc::DateUtc +}, traits::nowlike::Nowlike}; + +pub fn calculate_budgets_accrual(category: &Category, budget_updates: &[BudgetUpdate]) -> Result<i64> { + let mut budget_updates = budget_updates + .iter() + .filter(|bu| bu.category_id == category.id) + .collect::<Vec<&BudgetUpdate>>(); + budget_updates.sort_by_key(|bu| bu.date.clone()); + budget_updates.reverse(); + + let mut budgets_accrual = 0.0_f64; + let mut calculated_back_to_date = DateUtc::now(); + + for budget_update in budget_updates { + let days_on_this_budget = calculated_back_to_date.day_diff(&budget_update.date); + if days_on_this_budget == 0_u32 { + return Err(anyhow::Error::msg(format!( + "failed to calculate budgets accrual since two budget updates had the same date ({})", + budget_update.date, + ))); + } + 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.clone(); + } + + Ok(budgets_accrual.floor() as i64) +} + +#[cfg(test)] +mod test { + use chrono::{Days, Utc}; + + use crate::{ + models::{budget_update::BudgetUpdate, category::Category, date_utc::DateUtc}, traits::nowlike::Nowlike, utils::calculate_budgets_accrual + }; + + #[test] + fn when_no_budget_updates_then_return_zero() { + let category = Category { + id: 0, + name: String::from("Groceries"), + }; + let budget_updates = []; + + let result = calculate_budgets_accrual(&category, &budget_updates); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_one_budget_update_for_another_category_then_return_zero() { + let category = Category { + id: 0, + name: String::from("Groceries"), + }; + let budget_updates = [BudgetUpdate { + id: 0, + category_id: 1, + date: DateUtc::now(), + new_budget: 100, + new_period: 1, + }]; + + let result = calculate_budgets_accrual(&category, &budget_updates); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_one_budget_update_then_return_quantity_times_days_in_past() { + let category = Category { + id: 0, + name: String::from("Groceries"), + }; + let budget_updates = [BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from(Utc::now().checked_sub_days(Days::new(120)).unwrap()), + new_budget: 100, + new_period: 1, + }]; + + let result = calculate_budgets_accrual(&category, &budget_updates); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 12_000); + } + + #[test] + fn when_two_budget_updates_then_calculates_as_expected() { + let category = Category { + id: 0, + name: String::from("Groceries"), + }; + let budget_updates = [ + BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from(&Utc::now().checked_sub_days(Days::new(60)).unwrap()), + new_budget: 200, + new_period: 1, + }, + BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from(&Utc::now().checked_sub_days(Days::new(120)).unwrap()), + new_budget: 100, + new_period: 1, + }, + ]; + + let result = calculate_budgets_accrual(&category, &budget_updates); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 18_000); + } + + #[test] + fn when_two_budget_updates_on_same_day_then_returns_err() { + let category = Category { + id: 0, + name: String::from("Groceries"), + }; + let budget_updates = [ + BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from_ymd(2020, 12, 25).unwrap(), + new_budget: 200, + new_period: 1, + }, + BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from_ymd(2020, 12, 25).unwrap(), + new_budget: 100, + new_period: 1, + }, + ]; + let mut budget_updates_reversed = budget_updates.clone(); + budget_updates_reversed.reverse(); + + let result_leftways = calculate_budgets_accrual(&category, &budget_updates); + let result_rightways = calculate_budgets_accrual(&category, &budget_updates_reversed); + + assert!(result_leftways.is_err()); + assert!(result_rightways.is_err()); + } +} diff --git a/rust/schist_core/src/utils/calculate_category_balance.rs b/rust/schist_core/src/utils/calculate_category_balance.rs new file mode 100644 index 0000000..61b94a8 --- /dev/null +++ b/rust/schist_core/src/utils/calculate_category_balance.rs @@ -0,0 +1,153 @@ +use anyhow::Result; +use crate::{ + models::{budget_update::BudgetUpdate, category::Category}, + utils::{calculate_budgets_accrual, find_by_id_or}, +}; + +pub fn calculate_category_balance( + category: &Category, + transaction_sums: &[(i32, i64)], + category_transfer_from_sums: &[(i32, i64)], + category_transfer_to_sums: &[(i32, i64)], + budget_updates: &[BudgetUpdate], +) -> Result<i64> { + let transaction_sum = find_by_id_or(transaction_sums, category.id, 0); + let category_transfer_from_sum = find_by_id_or(category_transfer_from_sums, category.id, 0); + let category_transfer_to_sum = find_by_id_or(category_transfer_to_sums, category.id, 0); + let budget_accruals_sum = calculate_budgets_accrual(category, budget_updates)?; + + Ok( + transaction_sum + + budget_accruals_sum + + category_transfer_to_sum + - category_transfer_from_sum + ) +} + +#[cfg(test)] +mod test { + use chrono::{Days, Utc}; + + use crate::{ + models::{budget_update::BudgetUpdate, category::Category, date_utc::DateUtc}, + utils::calculate_category_balance + }; + + #[test] + fn when_no_data_then_returns_zero() { + let category = Category { + id: 0, + name: String::new(), + }; + + let result = calculate_category_balance(&category, &[], &[], &[], &[]); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_data_only_for_another_category_then_returns_zero() { + let category = Category { + id: 0, + name: String::new(), + }; + let transaction_sums = [(1, 100)]; + let category_transfer_from_sums = [(1, 91)]; + let category_transfer_to_sums = [(2, 79)]; + let budget_updates = [BudgetUpdate { + id: 0, + category_id: 1, + date: DateUtc::from(Utc::now().checked_sub_days(Days::new(120)).unwrap()), + new_budget: 77, + new_period: 1, + }]; + + let result = calculate_category_balance( + &category, + &transaction_sums, + &category_transfer_from_sums, + &category_transfer_to_sums, + &budget_updates, + ); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_transaction_sum_is_zero_then_returns_zero() { + let category = Category { + id: 0, + name: String::new(), + }; + let transaction_sums = [(0, 0)]; + let category_transfer_from_sums = []; + let category_transfer_to_sums = []; + let budget_updates = []; + + let result = calculate_category_balance( + &category, + &transaction_sums, + &category_transfer_from_sums, + &category_transfer_to_sums, + &budget_updates, + ); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_category_transfers_are_zero_then_returns_zero() { + let category = Category { + id: 0, + name: String::new(), + }; + let transaction_sums = []; + let category_transfer_from_sums = [(0, 0)]; + let category_transfer_to_sums = [(0, 0)]; + let budget_updates = []; + + let result = calculate_category_balance( + &category, + &transaction_sums, + &category_transfer_from_sums, + &category_transfer_to_sums, + &budget_updates, + ); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 0_i64); + } + + #[test] + fn when_some_data_then_calculates_as_expected() { + let category = Category { + id: 0, + name: String::new(), + }; + let transaction_sums = [(0, 100)]; + let category_transfer_from_sums = [(0, 91)]; + let category_transfer_to_sums = [(0, 79)]; + let budget_updates = [BudgetUpdate { + id: 0, + category_id: 0, + date: DateUtc::from(&Utc::now().checked_sub_days(Days::new(120)).unwrap()), + new_budget: 77, + new_period: 1, + }]; + + let result = calculate_category_balance( + &category, + &transaction_sums, + &category_transfer_from_sums, + &category_transfer_to_sums, + &budget_updates, + ); + + let expected_result = 100 + (-91) + 79 + 77 * 120; + assert!(result.is_ok()); + assert_eq!(result.unwrap(), expected_result); + } +} diff --git a/rust/schist_core/src/utils/find_by_id_or.rs b/rust/schist_core/src/utils/find_by_id_or.rs new file mode 100644 index 0000000..8335e5c --- /dev/null +++ b/rust/schist_core/src/utils/find_by_id_or.rs @@ -0,0 +1,41 @@ +pub fn find_by_id_or<Id: PartialEq, Val: Copy>( + arr: &[(Id, Val)], + id: Id, + default: Val, +) -> Val { + arr.iter() + .find(|(elem_id, _)| *elem_id == id) + .map_or(default, |row| row.1) +} + +#[cfg(test)] +mod test { + use super::find_by_id_or; + + #[test] + fn when_no_elements_then_return_default() { + let arr = []; + + let result = find_by_id_or(&arr, 1, 42); + + assert_eq!(result, 42); + } + + #[test] + fn when_id_not_in_elements_then_return_default() { + let arr = [(0, 100), (2, 200)]; + + let result = find_by_id_or(&arr, 1, 42); + + assert_eq!(result, 42); + } + + #[test] + fn when_id_in_elements_then_return_value() { + let arr = [(1, 67)]; + + let result = find_by_id_or(&arr, 1, 42); + + assert_eq!(result, 67); + } +} diff --git a/rust/schist_core/src/utils/mod.rs b/rust/schist_core/src/utils/mod.rs new file mode 100644 index 0000000..84a27af --- /dev/null +++ b/rust/schist_core/src/utils/mod.rs @@ -0,0 +1,7 @@ +mod calculate_budgets_accrual; +mod calculate_category_balance; +mod find_by_id_or; + +pub use calculate_budgets_accrual::calculate_budgets_accrual; +pub use calculate_category_balance::calculate_category_balance; +pub use find_by_id_or::find_by_id_or; diff --git a/rust/schist_core/tests/common/fakes/account.rs b/rust/schist_core/tests/common/fakes/account.rs new file mode 100644 index 0000000..0a1f8fe --- /dev/null +++ b/rust/schist_core/tests/common/fakes/account.rs @@ -0,0 +1,10 @@ +use schist_core::{models::{account::Account, datetime_utc::DatetimeUtc}, traits::nowlike::Nowlike}; + +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/rust/schist_core/tests/common/fakes/budget_update.rs b/rust/schist_core/tests/common/fakes/budget_update.rs new file mode 100644 index 0000000..a690288 --- /dev/null +++ b/rust/schist_core/tests/common/fakes/budget_update.rs @@ -0,0 +1,16 @@ +use schist_core::{models::{budget_update::{BudgetUpdate, BudgetUpdateBuilder}, date_utc::DateUtc}, traits::nowlike::Nowlike}; + +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(DateUtc::now()) + .new_budget(0) + .new_period(0); + builder +} diff --git a/rust/schist_core/tests/common/fakes/category.rs b/rust/schist_core/tests/common/fakes/category.rs new file mode 100644 index 0000000..6f0e357 --- /dev/null +++ b/rust/schist_core/tests/common/fakes/category.rs @@ -0,0 +1,13 @@ +use schist_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/rust/schist_core/tests/common/fakes/category_transfer.rs b/rust/schist_core/tests/common/fakes/category_transfer.rs new file mode 100644 index 0000000..3c66d6f --- /dev/null +++ b/rust/schist_core/tests/common/fakes/category_transfer.rs @@ -0,0 +1,16 @@ +use schist_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/rust/schist_core/tests/common/fakes/mod.rs b/rust/schist_core/tests/common/fakes/mod.rs new file mode 100644 index 0000000..68f5209 --- /dev/null +++ b/rust/schist_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/rust/schist_core/tests/common/fakes/transaction.rs b/rust/schist_core/tests/common/fakes/transaction.rs new file mode 100644 index 0000000..308b121 --- /dev/null +++ b/rust/schist_core/tests/common/fakes/transaction.rs @@ -0,0 +1,17 @@ +use schist_core::{models::{datetime_utc::DatetimeUtc, transaction::{Transaction, TransactionBuilder}}, traits::nowlike::Nowlike}; + +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/rust/schist_core/tests/common/fakes/transaction_categorisation.rs b/rust/schist_core/tests/common/fakes/transaction_categorisation.rs new file mode 100644 index 0000000..dee34c1 --- /dev/null +++ b/rust/schist_core/tests/common/fakes/transaction_categorisation.rs @@ -0,0 +1,16 @@ +use schist_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/rust/schist_core/tests/common/mod.rs b/rust/schist_core/tests/common/mod.rs new file mode 100644 index 0000000..6681d3d --- /dev/null +++ b/rust/schist_core/tests/common/mod.rs @@ -0,0 +1,2 @@ +pub mod fakes; +pub mod test_context; diff --git a/rust/schist_core/tests/common/test_context.rs b/rust/schist_core/tests/common/test_context.rs new file mode 100644 index 0000000..5dcaebc --- /dev/null +++ b/rust/schist_core/tests/common/test_context.rs @@ -0,0 +1,43 @@ +use std::sync::atomic::{AtomicU64, Ordering}; + +use schist_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/rust/schist_core/tests/main.rs b/rust/schist_core/tests/main.rs new file mode 100644 index 0000000..27409b6 --- /dev/null +++ b/rust/schist_core/tests/main.rs @@ -0,0 +1,4 @@ +pub mod common; + +mod models; +mod queries; diff --git a/rust/schist_core/tests/models/date_utc.rs b/rust/schist_core/tests/models/date_utc.rs new file mode 100644 index 0000000..d379a05 --- /dev/null +++ b/rust/schist_core/tests/models/date_utc.rs @@ -0,0 +1,60 @@ +use anyhow::Result; +use schist_core::models::date_utc::DateUtc; +use schist_core::traits::nowlike::Nowlike; +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_utc_test (id) { + id -> Integer, + date_utc -> Text, + } +} + +#[derive(Insertable, Queryable, Selectable, Clone)] +#[diesel(table_name = date_utc_test)] +pub struct DateUtcTest { + pub id: i32, + pub date_utc: DateUtc, +} + +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_utc_test(id INTEGER PRIMARY KEY, date_utc TEXT);"; + sql_query(query).execute(connection)?; + Ok(test_context) +} + +fn insert_date_utc(id: i32, date_utc: &DateUtc, connection: &mut SqliteConnection) -> Result<usize> { + let model = DateUtcTest { + id, + date_utc: date_utc.clone(), + }; + let num_rows_inserted = diesel::insert_into(date_utc_test::dsl::date_utc_test) + .values(&[model]) + .execute(connection)?; + Ok(num_rows_inserted) +} + +fn get_date_utc(id: i32, connection: &mut SqliteConnection) -> Result<DateUtcTest> { + let date_utc: Vec<DateUtcTest> = date_utc_test::dsl::date_utc_test + .select(DateUtcTest::as_select()) + .filter(date_utc_test::id.eq(id)) + .load(connection)?; + Ok(date_utc[0].clone()) +} + +#[test] +fn when_insert_date_utc_and_select_then_returns_original_value() -> Result<()> { + let date_utc = DateUtc::now(); + let test_context = new_test_context()?; + let connection = &mut SqliteConnection::establish(&test_context.db_url)?; + let num_rows_inserted = insert_date_utc(0, &date_utc, connection)?; + assert_eq!(num_rows_inserted, 1); + let date_utc_returned = get_date_utc(0, connection)?; + assert_eq!(date_utc_returned.date_utc, date_utc); + Ok(()) +} diff --git a/rust/schist_core/tests/models/datetime_utc.rs b/rust/schist_core/tests/models/datetime_utc.rs new file mode 100644 index 0000000..5bb51c0 --- /dev/null +++ b/rust/schist_core/tests/models/datetime_utc.rs @@ -0,0 +1,60 @@ +use anyhow::Result; +use schist_core::models::datetime_utc::DatetimeUtc; +use schist_core::traits::nowlike::Nowlike; +use diesel::{sql_query, Connection, ExpressionMethods, QueryDsl, RunQueryDsl, Selectable, SelectableHelper, SqliteConnection}; +use diesel::prelude::{Insertable, Queryable}; + +use crate::common::test_context::TestContext; + +diesel::table! { + datetime_utc_test (id) { + id -> Integer, + datetime_utc -> Text, + } +} + +#[derive(Insertable, Queryable, Selectable, Clone)] +#[diesel(table_name = datetime_utc_test)] +pub struct DatetimeUtcTest { + pub id: i32, + pub datetime_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 datetime_utc_test(id INTEGER PRIMARY KEY, datetime_utc TEXT);"; + sql_query(query).execute(connection)?; + Ok(test_context) +} + +fn insert_datetime_utc(id: i32, datetime_utc: &DatetimeUtc, connection: &mut SqliteConnection) -> Result<usize> { + let model = DatetimeUtcTest { + id, + datetime_utc: datetime_utc.clone(), + }; + let num_rows_inserted = diesel::insert_into(datetime_utc_test::dsl::datetime_utc_test) + .values(&[model]) + .execute(connection)?; + Ok(num_rows_inserted) +} + +fn get_datetime_utc(id: i32, connection: &mut SqliteConnection) -> Result<DatetimeUtcTest> { + let datetime_utc: Vec<DatetimeUtcTest> = datetime_utc_test::dsl::datetime_utc_test + .select(DatetimeUtcTest::as_select()) + .filter(datetime_utc_test::id.eq(id)) + .load(connection)?; + Ok(datetime_utc[0].clone()) +} + +#[test] +fn when_insert_datetime_utc_and_select_then_returns_original_value() -> Result<()> { + let datetime_utc = DatetimeUtc::now(); + let test_context = new_test_context()?; + let connection = &mut SqliteConnection::establish(&test_context.db_url)?; + let num_rows_inserted = insert_datetime_utc(0, &datetime_utc, connection)?; + assert_eq!(num_rows_inserted, 1); + let datetime_utc_returned = get_datetime_utc(0, connection)?; + assert_eq!(datetime_utc_returned.datetime_utc, datetime_utc); + Ok(()) +} diff --git a/rust/schist_core/tests/models/mod.rs b/rust/schist_core/tests/models/mod.rs new file mode 100644 index 0000000..d0d0e4a --- /dev/null +++ b/rust/schist_core/tests/models/mod.rs @@ -0,0 +1,2 @@ +mod date_utc; +mod datetime_utc; diff --git a/rust/schist_core/tests/queries/account.rs b/rust/schist_core/tests/queries/account.rs new file mode 100644 index 0000000..ce4269d --- /dev/null +++ b/rust/schist_core/tests/queries/account.rs @@ -0,0 +1,58 @@ +use schist_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/rust/schist_core/tests/queries/budget_updates.rs b/rust/schist_core/tests/queries/budget_updates.rs new file mode 100644 index 0000000..b9d60e2 --- /dev/null +++ b/rust/schist_core/tests/queries/budget_updates.rs @@ -0,0 +1,354 @@ +use schist_core::{models::{category::Category, date_utc::DateUtc}, queries, traits::nowlike::Nowlike}; +use diesel::{Connection, SqliteConnection}; + +use crate::common::{fakes::{budget_update::make_fake_budget_update_builder, category::make_fake_category}, test_context::TestContext}; + +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 +} + +#[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 = given_categories(connection); + let budget_updates = [ + make_fake_budget_update_builder(0) + .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) + .category_id(0) + .build().unwrap(), + make_fake_budget_update_builder(1) + .date(DateUtc::from_ymd(2020, 12, 26).unwrap()) + .category_id(0) + .build().unwrap(), + ]; + + 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_update_when_insert_budget_update_same_category_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 budget_updates_1 = [ + make_fake_budget_update_builder(0) + .category_id(0) + .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) + .build().unwrap() + ]; + let _ = queries::budget_updates::insert_budget_updates(&budget_updates_1, connection); + + let budget_updates_2 = [ + make_fake_budget_update_builder(1) + .category_id(0) + .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) + .build().unwrap() + ]; + let result = queries::budget_updates::insert_budget_updates(&budget_updates_2, connection); + + assert!(result.is_err()); +} + +#[test] +fn given_budget_update_when_insert_budget_update_different_category_and_same_date_then_return_num_budget_updates_inserted() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let _categories = given_categories(connection); + + let budget_updates_1 = [ + make_fake_budget_update_builder(0) + .category_id(0) + .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) + .build().unwrap() + ]; + let _ = queries::budget_updates::insert_budget_updates(&budget_updates_1, connection); + + let budget_updates_2 = [ + make_fake_budget_update_builder(1) + .category_id(1) + .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) + .build().unwrap() + ]; + let result = queries::budget_updates::insert_budget_updates(&budget_updates_2, connection); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 1); +} + +#[test] +fn given_budget_update_when_insert_budget_update_same_category_and_different_date_then_return_num_budget_updates_inserted() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let _categories = given_categories(connection); + + let budget_updates_1 = [ + make_fake_budget_update_builder(0) + .category_id(0) + .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) + .build().unwrap() + ]; + let _ = queries::budget_updates::insert_budget_updates(&budget_updates_1, connection); + + let budget_updates_2 = [ + make_fake_budget_update_builder(1) + .category_id(0) + .date(DateUtc::from_ymd(2020, 12, 26).unwrap()) + .build().unwrap() + ]; + let result = queries::budget_updates::insert_budget_updates(&budget_updates_2, connection); + + assert!(result.is_ok()); + assert_eq!(result.unwrap(), 1); +} + +#[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 = given_categories(connection); + let budget_updates = [ + make_fake_budget_update_builder(0) + .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) + .category_id(0) + .build().unwrap(), + make_fake_budget_update_builder(1) + .date(DateUtc::from_ymd(2020, 12, 26).unwrap()) + .category_id(0) + .build().unwrap(), + ]; + 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()); + assert_eq!(budget_updates_in_db[0], budget_updates[0]); + assert_eq!(budget_updates_in_db[1], budget_updates[1]); + 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 = given_categories(connection); + let budget_updates = [ + make_fake_budget_update_builder(0) + .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) + .category_id(0) + .build().unwrap(), + make_fake_budget_update_builder(1) + .date(DateUtc::from_ymd(2020, 12, 26).unwrap()) + .category_id(0) + .build().unwrap(), + ]; + 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 = given_categories(connection); + let budget_updates = [ + make_fake_budget_update_builder(0) + .date(DateUtc::from_ymd(2020, 12, 25).unwrap()) + .category_id(0) + .build().unwrap(), + make_fake_budget_update_builder(1) + .date(DateUtc::from_ymd(2020, 12, 26).unwrap()) + .category_id(0) + .build().unwrap(), + ]; + 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); +} + +#[test] +fn given_no_categories_when_get_first_with_date_and_category_id_then_return_none() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + + let first_with_date_and_category_id = + queries::budget_updates::get_first_budget_update_with_date_and_category_id( + &DateUtc::now(), + 0, + connection, + ).unwrap(); + + assert!(first_with_date_and_category_id.is_none()); +} + +#[test] +fn given_no_budget_updates_when_get_first_with_date_and_category_id_then_return_none() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let _categories = given_categories(connection); + + let first_with_date_and_category_id = + queries::budget_updates::get_first_budget_update_with_date_and_category_id( + &DateUtc::now(), + 0, + connection, + ).unwrap(); + + assert!(first_with_date_and_category_id.is_none()); +} + +#[test] +fn given_budget_update_when_get_first_with_date_then_return_budget_update() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let _categories = given_categories(connection); + let date: DateUtc = "2024-10-28".parse().unwrap(); + let budget_update = make_fake_budget_update_builder(0).date(date.clone()).build().unwrap(); + let _ = queries::budget_updates::insert_budget_updates(&[budget_update.clone()], connection).unwrap(); + + let first_with_date_and_category_id = + queries::budget_updates::get_first_budget_update_with_date_and_category_id( + &date, + 0, + connection, + ).unwrap(); + + assert!(first_with_date_and_category_id.is_some()); + assert_eq!(first_with_date_and_category_id.unwrap(), budget_update); +} + +#[test] +fn given_budget_update_when_get_first_with_date_and_different_category_id_then_return_none() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let _categories = given_categories(connection); + let date: DateUtc = "2024-10-28".parse().unwrap(); + let different_date: DateUtc = "2024-10-29".parse().unwrap(); + let budget_update = make_fake_budget_update_builder(0).date(date.clone()).build().unwrap(); + let _ = queries::budget_updates::insert_budget_updates(&[budget_update.clone()], connection).unwrap(); + + let first_with_date_and_category_id = + queries::budget_updates::get_first_budget_update_with_date_and_category_id( + &different_date, + 2, + connection + ).unwrap(); + + assert!(first_with_date_and_category_id.is_none()); +} + +#[test] +fn given_budget_update_when_get_first_with_different_date_and_category_id_then_return_none() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let _categories = given_categories(connection); + let date: DateUtc = "2024-10-28".parse().unwrap(); + let different_date: DateUtc = "2024-10-29".parse().unwrap(); + let budget_update = make_fake_budget_update_builder(0).date(date.clone()).build().unwrap(); + let _ = queries::budget_updates::insert_budget_updates(&[budget_update.clone()], connection).unwrap(); + + let first_with_date_and_category_id = + queries::budget_updates::get_first_budget_update_with_date_and_category_id( + &different_date, + 0, + connection + ).unwrap(); + + assert!(first_with_date_and_category_id.is_none()); +} + +#[test] +fn given_many_budget_updates_when_get_first_with_date_and_category_id_then_return_any_with_date() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let _categories = given_categories(connection); + let budget_updates = [ + make_fake_budget_update_builder(0).date("2024-12-25".parse().unwrap()).category_id(0).build().unwrap(), + make_fake_budget_update_builder(1).date("2024-12-25".parse().unwrap()).category_id(1).build().unwrap(), + make_fake_budget_update_builder(2).date("2020-12-26".parse().unwrap()).category_id(0).build().unwrap(), + make_fake_budget_update_builder(3).date("2020-12-26".parse().unwrap()).category_id(1).build().unwrap(), + make_fake_budget_update_builder(4).date("2020-12-27".parse().unwrap()).category_id(0).build().unwrap(), + make_fake_budget_update_builder(5).date("2020-12-27".parse().unwrap()).category_id(1).build().unwrap(), + ]; + let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap(); + + let first_with_date_and_category_id = + queries::budget_updates::get_first_budget_update_with_date_and_category_id( + &"2024-12-25".parse().unwrap(), + 0, + connection, + ).unwrap(); + + assert!(first_with_date_and_category_id.is_some()); + assert_eq!(first_with_date_and_category_id.unwrap(), budget_updates[0]); +} + +#[test] +fn given_many_budget_updates_when_get_most_recent_with_category_id_then_return_correct_date() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let _categories = given_categories(connection); + let budget_updates = [ + make_fake_budget_update_builder(0) + .category_id(0) + .date("2024-12-25".parse().unwrap()) + .build().unwrap(), + make_fake_budget_update_builder(1) + .category_id(0) + .date("2020-12-26".parse().unwrap()) + .build().unwrap(), + make_fake_budget_update_builder(2) + .category_id(1) + .date("2020-12-27".parse().unwrap()) + .build().unwrap(), + ]; + let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap(); + + let most_recent_with_category = queries::budget_updates::get_most_recent_budget_update_date_with_category_id( + 0, connection, + ); + + assert!(most_recent_with_category.is_ok()); + let most_recent_with_category = most_recent_with_category.unwrap(); + assert!(most_recent_with_category .is_some()); + let most_recent_with_category = most_recent_with_category.unwrap(); + assert_eq!(most_recent_with_category, budget_updates[1].date); +} + +#[test] +fn given_budget_update_when_get_most_recent_with_different_category_id_then_return_none() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let _categories = given_categories(connection); + let budget_updates = [ + make_fake_budget_update_builder(0) + .category_id(1) + .date("2020-12-27".parse().unwrap()) + .build().unwrap(), + ]; + let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection).unwrap(); + + let most_recent_with_category = queries::budget_updates::get_most_recent_budget_update_date_with_category_id( + 0, connection, + ); + + assert!(most_recent_with_category.is_ok()); + let most_recent_with_category = most_recent_with_category.unwrap(); + assert!(most_recent_with_category .is_none()); +} diff --git a/rust/schist_core/tests/queries/categories.rs b/rust/schist_core/tests/queries/categories.rs new file mode 100644 index 0000000..51bd8eb --- /dev/null +++ b/rust/schist_core/tests/queries/categories.rs @@ -0,0 +1,218 @@ +use schist_core::{models::{account::Account, budget::Budget, budget_update::BudgetUpdate, category::Category, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation}, queries}; +use chrono::{Days, Utc}; +use diesel::{Connection, SqliteConnection}; + +use crate::common::{fakes::{account::make_fake_account, budget_update::make_fake_budget_update_builder, category::make_fake_category, transaction::make_fake_transaction_builder, transaction_categorisation::make_fake_transaction_categorisation_builder}, test_context::TestContext}; + +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_transactions(connection: &mut SqliteConnection) -> Vec<Transaction> { + let transactions = vec![ + make_fake_transaction_builder(0).quantity(1).build().unwrap(), + make_fake_transaction_builder(1).quantity(2).build().unwrap(), + make_fake_transaction_builder(2).quantity(4).build().unwrap(), + make_fake_transaction_builder(3).quantity(8).build().unwrap(), + ]; + let _ = queries::transactions::insert_transactions(&transactions, connection).unwrap(); + transactions +} + +fn given_accounts(connection: &mut SqliteConnection) -> Vec<Account> { + let accounts = vec![ + make_fake_account(0), + ]; + let _ = queries::accounts::insert_accounts(&accounts, connection); + accounts +} + +fn given_transaction_categorisations(connection: &mut SqliteConnection) -> Vec<TransactionCategorisation> { + let transaction_categorisations = vec![ + make_fake_transaction_categorisation_builder(0).quantity(1).transaction_id(0).category_id(0).build().unwrap(), + make_fake_transaction_categorisation_builder(1).quantity(1).transaction_id(1).category_id(0).build().unwrap(), + make_fake_transaction_categorisation_builder(2).quantity(1).transaction_id(1).category_id(0).build().unwrap(), + make_fake_transaction_categorisation_builder(3).quantity(4).transaction_id(2).category_id(1).build().unwrap(), + make_fake_transaction_categorisation_builder(4).quantity(3).transaction_id(3).category_id(1).build().unwrap(), + make_fake_transaction_categorisation_builder(5).quantity(5).transaction_id(3).category_id(1).build().unwrap(), + ]; + let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection).unwrap(); + transaction_categorisations +} + +fn given_budget_updates(connection: &mut SqliteConnection) -> Vec<BudgetUpdate> { + let now = Utc::now(); + let twenty_days_ago = DateUtc::from(now.checked_sub_days(Days::new(20)).unwrap()); + let ten_days_ago = DateUtc::from(now.checked_sub_days(Days::new(10)).unwrap()); + let budget_updates = vec![ + make_fake_budget_update_builder(0).category_id(0).date(twenty_days_ago.clone()).new_budget(100).new_period(1).build().unwrap(), + make_fake_budget_update_builder(1).category_id(0).date(ten_days_ago.clone()).new_budget(50).new_period(2).build().unwrap(), + make_fake_budget_update_builder(2).category_id(1).date(twenty_days_ago.clone()).new_budget(90).new_period(4).build().unwrap(), + make_fake_budget_update_builder(3).category_id(1).date(ten_days_ago.clone()).new_budget(40).new_period(8).build().unwrap(), + ]; + let _ = queries::budget_updates::insert_budget_updates(&budget_updates, connection); + budget_updates +} + +#[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 = given_categories(connection); + + 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 = given_categories(connection); + + 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(); + given_categories(connection); + let _ = queries::categories::delete_all_categories(connection).unwrap(); + + let categories_returned = queries::categories::get_all_categories(connection).unwrap(); + + assert_eq!(categories_returned.len(), 0); +} + +#[test] +fn given_categories_and_no_transactions_when_get_all_balances_then_return_all_zero() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + given_categories(connection); + + let balances = queries::categories::get_all_category_balances(connection); + + assert!(balances.is_ok()); + let mut balances = balances.unwrap(); + balances.sort_by(|b1, b2| b1.category_id.cmp(&b2.category_id)); + assert_eq!(balances.len(), 2); + for balance in balances { + assert_eq!(0, balance.balance); + } +} + +#[test] +fn given_categories_and_transaction_categorisations_when_get_all_balances_then_return_balances() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = given_categories(connection); + let _accounts = given_accounts(connection); + let _transactions = given_transactions(connection); + let transaction_categorisations = given_transaction_categorisations(connection); + + let balances = queries::categories::get_all_category_balances(connection); + + assert!(balances.is_ok()); + let mut balances = balances.unwrap(); + balances.sort_by(|b1, b2| b1.category_id.cmp(&b2.category_id)); + assert_eq!(balances.len(), categories.len()); + for category in categories { + let balance = balances.iter().find(|b| b.category_id == category.id).unwrap(); + let expected_balance: i32 = transaction_categorisations + .iter() + .filter(|t| t.category_id == category.id) + .map(|t| t.quantity) + .sum(); + assert_eq!(expected_balance, balance.balance); + } +} + +#[test] +fn given_categories_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 ids = queries::categories::get_all_category_ids(connection).unwrap(); + + assert_eq!(categories.len(), ids.len()); + for category in &categories { + assert!(ids.iter().any(|id| category.id == *id)); + } + for id in ids { + assert!(categories.iter().any(|category| category.id == id)); + } +} + +#[test] +fn given_categories_and_no_budget_updates_when_get_most_recent_budget_per_category_id_then_return_none() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = given_categories(connection); + + let most_recent_budget_per_category_id = queries::categories::get_most_recent_category_budget_per_category_id(connection); + + assert!(most_recent_budget_per_category_id.is_ok()); + let most_recent_budget_per_category_id = most_recent_budget_per_category_id.unwrap(); + assert_eq!(categories.len(), most_recent_budget_per_category_id.len()); + for category in categories { + let most_recent_budget = most_recent_budget_per_category_id.iter().find(|b| b.category_id == category.id); + assert!(most_recent_budget.is_some()); + let most_recent_budget = most_recent_budget.unwrap(); + assert!(most_recent_budget.budget.is_none()); + } +} + +#[test] +fn given_categories_and_budget_updates_when_get_most_recent_budget_per_category_id_then_return_most_recent_budget() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + let categories = given_categories(connection); + let budget_updates = given_budget_updates(connection); + + let most_recent_budget_per_category_id = queries::categories::get_most_recent_category_budget_per_category_id(connection); + + assert!(most_recent_budget_per_category_id.is_ok()); + let most_recent_budget_per_category_id = most_recent_budget_per_category_id.unwrap(); + assert_eq!(categories.len(), most_recent_budget_per_category_id.len()); + for category in categories { + let most_recent_budget_update = budget_updates + .iter() + .filter(|bu| bu.category_id == category.id) + .max_by_key(|bu| bu.date.clone()) + .unwrap(); + + let most_recent_budget = most_recent_budget_per_category_id.iter().find(|b| b.category_id == category.id); + assert!(most_recent_budget.is_some()); + let most_recent_budget = most_recent_budget.unwrap(); + assert!(most_recent_budget.budget.is_some()); + let most_recent_budget = most_recent_budget.budget.unwrap(); + assert_eq!(most_recent_budget, Budget { + quantity: most_recent_budget_update.new_budget, + period: most_recent_budget_update.new_period, + }); + } +} diff --git a/rust/schist_core/tests/queries/category_transfers.rs b/rust/schist_core/tests/queries/category_transfers.rs new file mode 100644 index 0000000..c68d4dc --- /dev/null +++ b/rust/schist_core/tests/queries/category_transfers.rs @@ -0,0 +1,124 @@ +use schist_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); +} + +#[test] +fn given_category_transfers_when_sum_quantity_per_from_category_id_then_returns_sum_per_from_category_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 _ = queries::categories::insert_categories(&categories, connection); + let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap(); + + let sums = queries::category_transfers::sum_category_transfer_quantity_per_from_category_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!(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() { + 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 _ = queries::categories::insert_categories(&categories, connection); + let _ = queries::category_transfers::insert_category_transfers(&category_transfers, connection).unwrap(); + + let sums = queries::category_transfers::sum_category_transfer_quantity_per_to_category_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!(4, sums[0].1); + assert_eq!(3, sums[1].1); +} diff --git a/rust/schist_core/tests/queries/mod.rs b/rust/schist_core/tests/queries/mod.rs new file mode 100644 index 0000000..e421934 --- /dev/null +++ b/rust/schist_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/rust/schist_core/tests/queries/transaction_categorisations.rs b/rust/schist_core/tests/queries/transaction_categorisations.rs new file mode 100644 index 0000000..a4bbf83 --- /dev/null +++ b/rust/schist_core/tests/queries/transaction_categorisations.rs @@ -0,0 +1,127 @@ +use schist_core::{models::{account::Account, category::Category, transaction::Transaction}, 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 given_accounts(connection: &mut SqliteConnection) -> Vec<Account> { + let accounts = vec![make_fake_account(0)]; + let _ = queries::accounts::insert_accounts(&accounts, connection); + 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_transactions(connection: &mut SqliteConnection) -> Vec<Transaction> { + let transactions = vec![ + make_fake_transaction_builder(0).account_id(0).build().unwrap(), + make_fake_transaction_builder(1).account_id(0).build().unwrap(), + ]; + let _ = queries::transactions::insert_transactions(&transactions, connection); + transactions +} + +#[test] +fn when_insert_transaction_categorisations_then_returns_num_transaction_categorisations() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + given_accounts(connection); + given_categories(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(), + ]; + + 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(); + given_accounts(connection); + given_categories(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(), + ]; + 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(); + given_accounts(connection); + given_categories(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(), + ]; + 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(); + given_accounts(connection); + given_categories(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(), + ]; + 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); +} + +#[test] +fn given_transaction_categorisations_when_sum_quantity_per_category_id_then_returns_sum_quantity_per_category_id() { + let context = TestContext::new(); + let connection = &mut SqliteConnection::establish(&context.db_url).unwrap(); + given_accounts(connection); + let categories = given_categories(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(), + ]; + let _ = queries::transaction_categorisations::insert_transaction_categorisations(&transaction_categorisations, connection); + + let sums = queries::transaction_categorisations::sum_transaction_categorisation_quantity_per_category_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!(3, sums[0].1); + assert_eq!(4, sums[1].1); +} diff --git a/rust/schist_core/tests/queries/transactions.rs b/rust/schist_core/tests/queries/transactions.rs new file mode 100644 index 0000000..4e284bc --- /dev/null +++ b/rust/schist_core/tests/queries/transactions.rs @@ -0,0 +1,78 @@ +use schist_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); +} |