Add tests

utxo/Cargo.toml

@@ -33,7 +33,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

@@ -43,6 +43,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

@@ -38,7 +38,7 @@ pub enum InternalStatus {
 }
 
 /// Status error object
-#[derive(Debug, Serialize, thiserror::Error)]
+#[derive(Debug, Serialize, thiserror::Error, Clone)]
 pub enum Error {
     #[error("Unknown status: {0}")]
     UnknownStatus(String),
@@ -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/deposit.feature

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

utxo/tests/ledger.rs

@@ -0,0 +1,247 @@
+use cucumber::{given, then, when, World};
+use futures::future::BoxFuture;
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
+use tokio::{fs, io};
+use verax::{storage::SQLite, AccountId, Amount, Asset, RevId};
+
+#[derive(Debug, Clone)]
+pub enum Variable {
+    RevId(RevId),
+    RevIdResult(Result<RevId, String>),
+}
+
+impl From<RevId> for Variable {
+    fn from(rev_id: RevId) -> Self {
+        Variable::RevId(rev_id)
+    }
+}
+
+impl From<Result<RevId, verax::Error>> for Variable {
+    fn from(rev_id: Result<RevId, verax::Error>) -> Self {
+        Variable::RevIdResult(rev_id.map_err(|e| e.to_string()))
+    }
+}
+
+#[derive(Debug, World)]
+pub struct LedgerWorld {
+    ledger: Arc<verax::Ledger<SQLite>>,
+    variables: HashMap<String, Variable>,
+    spend: Option<Vec<(AccountId, Amount)>>,
+    receive: Option<Vec<(AccountId, Amount)>>,
+}
+
+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()),
+                variables: HashMap::new(),
+                spend: None,
+                receive: None,
+            }
+        })
+    }
+}
+impl LedgerWorld {
+    pub fn get(&self, name: &str) -> &Variable {
+        self.variables.get(name).as_ref().expect("variable")
+    }
+}
+
+#[given("a new transaction")]
+fn new_transaction(world: &mut LedgerWorld) {
+    world.spend = Some(vec![]);
+    world.receive = Some(vec![]);
+}
+
+#[given(expr = "spend {word} {word} from {word}")]
+fn spend(world: &mut LedgerWorld, amount: String, asset: String, account: String) {
+    let asset = asset.parse::<Asset>().expect("valid asset");
+    let amount = asset.from_human(&amount).expect("valid amount");
+
+    world
+        .spend
+        .as_mut()
+        .expect("has spend")
+        .push((account.parse().expect("valid account"), amount));
+}
+
+#[given(expr = "receive {word} {word} in {word}")]
+fn receive(world: &mut LedgerWorld, amount: String, asset: String, account: String) {
+    let asset = asset.parse::<Asset>().expect("valid asset");
+    let amount = asset.from_human(&amount).expect("valid amount");
+
+    world
+        .receive
+        .as_mut()
+        .expect("has receive")
+        .push((account.parse().expect("valid account"), amount));
+}
+
+#[when(expr = "commit transaction {word} it fails")]
+async fn commit_transaction_and_expect_to_fail(world: &mut LedgerWorld, status: String) {
+    let status = status.parse::<verax::Status>().expect("valid status");
+
+    let spend = world.spend.take().expect("has spend");
+    let receive = world.receive.take().expect("has receive");
+
+    assert!(world
+        .ledger
+        .new_transaction("Transaction".to_owned(), status, spend, receive)
+        .await
+        .is_err());
+}
+
+#[when(expr = "commit transaction {word} as {word}")]
+async fn commit_transaction(world: &mut LedgerWorld, name: String, status: String) {
+    let status = status.parse::<verax::Status>().expect("valid status");
+
+    let spend = world.spend.take().expect("has spend");
+    let receive = world.receive.take().expect("has receive");
+
+    world.variables.insert(
+        name,
+        world
+            .ledger
+            .new_transaction("Transaction".to_owned(), status, spend, receive)
+            .await
+            .map(|x| x.revision_id)
+            .into(),
+    );
+}
+
+#[given(expr = "a {word} deposit {word} of {word} {word} for {word}")]
+async fn deposit_funds(
+    world: &mut LedgerWorld,
+    status: String,
+    name: String,
+    amount: String,
+    asset: String,
+    account: String,
+) {
+    let asset = asset.parse::<Asset>().expect("valid asset");
+
+    world.variables.insert(
+        name,
+        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
+            .map(|x| x.revision_id)
+            .into(),
+    );
+}
+
+#[given(expr = "update {word} set status to {word}")]
+async fn update_status_from_last_tx(world: &mut LedgerWorld, tx: String, new_status: String) {
+    let revision = match world.get(&tx) {
+        Variable::RevId(rev_id) => rev_id.clone(),
+        Variable::RevIdResult(Ok(rev_id)) => rev_id.clone(),
+        _ => panic!("{} is not a RevId", tx),
+    };
+    let status = new_status.parse().expect("valid status");
+
+    world.variables.insert(
+        tx,
+        world
+            .ledger
+            .change_status(revision, status, "update status".to_owned())
+            .await
+            .map(|x| x.revision_id)
+            .into(),
+    );
+}
+
+#[then(expr = "{word} has failed")]
+fn has_failed(world: &mut LedgerWorld, tx: String) {
+    assert!(matches!(
+        world.get(&tx).clone(),
+        Variable::RevIdResult(Err(_))
+    ));
+}
+
+#[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));
+}
+
+fn find_features<'a, A: AsRef<Path> + Send + Sync>(
+    dir_path: &'a A,
+) -> BoxFuture<'a, io::Result<Vec<PathBuf>>> {
+    Box::pin(async move {
+        let mut entries = fs::read_dir(dir_path).await?;
+        let mut paths = vec![];
+
+        while let Ok(Some(entry)) = entries.next_entry().await {
+            let path = entry.path();
+
+            if path.is_dir() {
+                paths.extend(find_features(&path).await?);
+            } else if let Some(extension) = path.extension() {
+                if extension == "feature" {
+                    paths.push(path);
+                }
+            }
+        }
+
+        Ok(paths)
+    })
+}
+
+#[tokio::main]
+async fn main() {
+    for file in find_features(&".").await.expect("files") {
+        LedgerWorld::run(file).await;
+    }
+}

utxo/tests/transaction.feature

@@ -0,0 +1,25 @@
+Feature: Transactions
+
+  Scenario: User deposit funds and it confirms, then performs a transaction
+    Given a pending deposit @tx1 of 10000 USD/2 for @account1
+    And update @tx1 set status to settled
+    Then @account1 has balance of 10000 USD/2
+    Given a new transaction
+    And spend 1000 USD/2 from @account1
+    And receive 1000 USD/2 in @account2
+    When commit transaction @tx2 as settled
+    Then @account1 has balance of 9000 USD/2
+    Then @account2 has balance of 1000 USD/2
+
+  Scenario: User deposit funds and transfer to other accounts
+    Given a pending deposit @tx1 of 10000 USD/2 for @account1
+    And update @tx1 set status to settled
+    Then @account1 has balance of 10000 USD/2
+    Given a new transaction
+    And spend 1000 USD/2 from @account1
+    And receive 999 USD/2 in @account2
+    And receive 1 USD/2 in @account3
+    When commit transaction @tx2 as settled
+    Then @account1 has balance of 9000 USD/2
+    Then @account2 has balance of 999 USD/2
+    Then @account3 has balance of 1 USD/2