Add tests

utxo/Cargo.toml

@@ -32,7 +32,13 @@ sqlx = { version = "0.7.1", features = [
     "sqlite",
     "chrono",
 ] }
+cucumber = "0.21.0"
+
+[[test]]
+name = "ledger"
+harness = false
+
 
 [features]
-default = []
+default = ["sqlite"]
 sqlite = ["sqlx", "futures"]

utxo/src/lib.rs

@@ -42,6 +42,8 @@ mod worker;
 
 #[cfg(test)]
 pub use self::storage::test as storage_test;
+#[cfg(test)]
+use cucumber as _;
 
 pub use self::{
     amount::{Amount, AnyAmount, HumanAmount},

utxo/src/status.rs

@@ -128,7 +128,12 @@ impl Default for StatusManager {
                 let mut map = HashMap::new();
                 map.insert(
                     pending.clone(),
-                    vec![processing.clone(), settled.clone(), cancelled.clone()],
+                    vec![
+                        processing.clone(),
+                        settled.clone(),
+                        cancelled.clone(),
+                        failed.clone(),
+                    ],
                 );
                 map.insert(processing.clone(), vec![settled, failed]);
                 map

utxo/src/storage/sqlite/mod.rs

@@ -17,6 +17,7 @@ pub use batch::Batch;
 pub use sqlx::sqlite::{SqliteConnectOptions, SqliteJournalMode, SqlitePoolOptions};
 
 /// SQLite storage layer for Verax
+#[derive(Debug)]
 pub struct SQLite {
     db: sqlx::SqlitePool,
 }

utxo/tests/ledger.rs

@@ -0,0 +1,112 @@
+use cucumber::{given, then, when, World};
+use std::sync::Arc;
+use verax::{storage::SQLite, Asset};
+
+#[derive(Debug, World)]
+pub struct LedgerWorld {
+    ledger: Arc<verax::Ledger<SQLite>>,
+    revisions: Vec<verax::RevId>,
+}
+
+impl Default for LedgerWorld {
+    fn default() -> Self {
+        futures::executor::block_on(async move {
+            let settings = "sqlite://:memory:"
+                .parse::<verax::storage::sqlite::SqliteConnectOptions>()
+                .expect("valid settings")
+                .journal_mode(verax::storage::sqlite::SqliteJournalMode::Wal)
+                .create_if_missing(true);
+
+            let pool = verax::storage::sqlite::SqlitePoolOptions::new()
+                .connect_with(settings)
+                .await
+                .expect("pool");
+
+            let db = SQLite::new(pool);
+            db.setup().await.expect("setup");
+
+            Self {
+                ledger: verax::Ledger::new(db.into()),
+                revisions: vec![],
+            }
+        })
+    }
+}
+
+#[given(expr = "a {word} deposit of {word} {word} for {word}")]
+async fn deposit_funds(
+    world: &mut LedgerWorld,
+    status: String,
+    amount: String,
+    asset: String,
+    account: String,
+) {
+    let asset = asset.parse::<Asset>().expect("valid asset");
+
+    world.revisions.push(
+        world
+            .ledger
+            .deposit(
+                &account.parse().expect("valid account"),
+                asset.from_human(&amount).expect("valid amount"),
+                status.parse().expect("valid status"),
+                vec![],
+                "Initial deposit".to_owned(),
+            )
+            .await
+            .expect("deposit")
+            .revision_id,
+    );
+}
+
+#[when(expr = "update last transaction set status to {word}")]
+async fn update_status_from_last_tx(world: &mut LedgerWorld, new_status: String) {
+    let revision = world.revisions.pop().expect("has last revision");
+    let status = new_status.parse().expect("valid status");
+
+    world.revisions.push(
+        world
+            .ledger
+            .change_status(revision, status, "update status".to_owned())
+            .await
+            .expect("update status")
+            .revision_id,
+    );
+}
+
+#[then(expr = "{word} has no balance")]
+async fn check_balance_empty(world: &mut LedgerWorld, account: String) {
+    let balance = world
+        .ledger
+        .get_balance(&account.parse().expect("valid account"))
+        .await
+        .expect("balance")
+        .into_iter()
+        .filter(|b| b.cents() != 0)
+        .collect::<Vec<_>>();
+
+    assert_eq!(0, balance.len())
+}
+
+#[then(expr = "{word} has balance of {word} {word}")]
+async fn check_balance(world: &mut LedgerWorld, account: String, amount: String, asset: String) {
+    let asset = asset.parse::<Asset>().expect("valid asset");
+    let amount = asset.from_human(&amount).expect("valid amount");
+
+    let balances = world
+        .ledger
+        .get_balance(&account.parse().expect("valid account"))
+        .await
+        .expect("balance")
+        .into_iter()
+        .filter(|b| b.asset() == &asset)
+        .collect::<Vec<_>>();
+
+    assert_eq!(1, balances.len(), "{} is found", asset);
+    assert_eq!(balances.get(0), Some(&amount));
+}
+
+#[tokio::main]
+async fn main() {
+    LedgerWorld::run("tests/simple.feature").await;
+}

utxo/tests/simple.feature

@@ -0,0 +1,29 @@
+Feature: Deposits
+
+  Scenario: User has deposit funds and it does not show in balances
+    Given a pending deposit of 10000 USD/2 for account1
+    Then account1 has no balance
+
+  Scenario: User deposit funds and it confirms
+    Given a pending deposit of 10000 USD/2 for account1
+    When update last transaction set status to settled
+    Then account1 has balance of 10000 USD/2
+
+  Scenario: User deposit funds and it fails
+    Given a pending deposit of 10000 USD/2 for account1
+    When update last transaction set status to failed
+    Then account1 has no balance
+
+  Scenario: User deposit funds and it confirms, then it reverts
+    Given a pending deposit of 10000 USD/2 for account1
+    When update last transaction set status to settled
+    Then account1 has balance of 10000 USD/2
+    Given a settled deposit of -10000 USD/2 for account1
+    Then account1 has no balance
+
+  Scenario: Negative deposit affects balance
+    Given a pending deposit of 1000 USD/2 for account1
+    When update last transaction set status to settled
+    Then account1 has balance of 1000 USD/2
+    Given a settled deposit of -10000 USD/2 for account1
+    Then account1 has balance of -9000 USD/2