task-012 (#2)

Co-authored-by: Joe Carstairs <jcarstairs@scottlogic.com>
Reviewed-on: https://git.joeac.net/joeac/schist/pulls/2
Co-authored-by: Joe Carstairs <me@joeac.net>
Co-committed-by: Joe Carstairs <me@joeac.net>

1 files changed, 151 insertions, 0 deletions

diff --git a/schist_core/schist_queries/tests/pipes.rs b/schist_core/schist_queries/tests/pipes.rs
new file mode 100644
index 0000000..abd5a5e
--- /dev/null
+++ b/schist_core/schist_queries/tests/pipes.rs
@@ -0,0 +1,151 @@
+mod common;
+
+use common::test_context::TestContext;
+use diesel::{Connection, SqliteConnection};
+use schist_fakes::{
+    account::make_fake_account, bucket::make_fake_bucket, pipe::make_fake_pipe_builder,
+    transaction::make_fake_transaction_builder,
+};
+use schist_models::{account::Account, bucket::Bucket, transaction::Transaction};
+use schist_queries as queries;
+
+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_buckets(connection: &mut SqliteConnection) -> Vec<Bucket> {
+    let buckets = vec![make_fake_bucket(0), make_fake_bucket(1)];
+    let _ = queries::buckets::insert_buckets(&buckets, connection);
+    buckets
+}
+
+fn given_transactions(connection: &mut SqliteConnection) -> Vec<Transaction> {
+    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_pipes_then_returns_num_pipes() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    given_accounts(connection);
+    given_buckets(connection);
+    given_transactions(connection);
+    let pipes = [
+        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
+    ];
+
+    let num_pipes_inserted = queries::pipes::insert_pipes(&pipes, connection).unwrap();
+
+    assert_eq!(num_pipes_inserted, 2);
+}
+
+#[test]
+fn given_pipes_when_get_all_pipes_then_return_pipes() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    given_accounts(connection);
+    given_buckets(connection);
+    given_transactions(connection);
+    let pipes = [
+        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
+    ];
+    let _ = queries::pipes::insert_pipes(&pipes, connection);
+
+    let pipes_in_db = queries::pipes::get_all_pipes(connection).unwrap();
+
+    assert_eq!(pipes_in_db.len(), pipes.len());
+    for pipe in &pipes {
+        assert!(pipes_in_db.iter().any(|pipe_in_db| pipe_in_db.eq(&pipe)));
+    }
+    for pipe_in_db in pipes_in_db {
+        assert!(pipes.iter().any(|pipe| pipe.eq(&pipe_in_db)));
+    }
+}
+
+#[test]
+fn given_pipes_when_delete_all_pipes_then_return_num_of_pipes() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    given_accounts(connection);
+    given_buckets(connection);
+    given_transactions(connection);
+    let pipes = [
+        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
+    ];
+    let _ = queries::pipes::insert_pipes(&pipes, connection);
+
+    let num_pipes_deleted = queries::pipes::delete_all_pipes(connection).unwrap();
+
+    assert_eq!(num_pipes_deleted, pipes.len());
+}
+
+#[test]
+fn given_deleted_pipes_when_get_all_pipes_then_return_empty() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    given_accounts(connection);
+    given_buckets(connection);
+    given_transactions(connection);
+    let pipes = [
+        make_fake_pipe_builder(0).bucket_id(0).build().unwrap(),
+        make_fake_pipe_builder(1).bucket_id(0).build().unwrap(),
+    ];
+    let _ = queries::pipes::insert_pipes(&pipes, connection);
+    let _ = queries::pipes::delete_all_pipes(connection);
+
+    let pipes_returned = queries::pipes::get_all_pipes(connection).unwrap();
+
+    assert_eq!(pipes_returned.len(), 0);
+}
+
+#[test]
+fn given_pipes_when_sum_quantity_per_bucket_id_then_returns_sum_quantity_per_bucket_id() {
+    let context = TestContext::new();
+    let connection = &mut SqliteConnection::establish(&context.db_url).unwrap();
+    given_accounts(connection);
+    let buckets = given_buckets(connection);
+    given_transactions(connection);
+    let pipes = [
+        make_fake_pipe_builder(0)
+            .bucket_id(0)
+            .amount(1)
+            .build()
+            .unwrap(),
+        make_fake_pipe_builder(1)
+            .bucket_id(0)
+            .amount(2)
+            .build()
+            .unwrap(),
+        make_fake_pipe_builder(2)
+            .bucket_id(1)
+            .amount(4)
+            .build()
+            .unwrap(),
+    ];
+    let _ = queries::pipes::insert_pipes(&pipes, connection);
+
+    let sums = queries::pipes::sum_pipes_flow_per_bucket_id(connection);
+
+    assert!(sums.is_ok());
+    let mut sums = sums.unwrap();
+    sums.sort_by_key(|sum| sum.0);
+    assert_eq!(buckets.len(), sums.len());
+    assert_eq!(3, sums[0].1);
+    assert_eq!(4, sums[1].1);
+}