Add tests

utxo/src/ledger.rs

@@ -486,12 +486,14 @@ where
         &self.config.status
     }
 
-    /// TODO
+    /// Locks the transaction and returns a token that can be used to unlock it.
+    ///
+    /// Locked transactions cannot be updated without the TokenPayload or until it expires.
     pub async fn lock_transaction(
         &self,
         transaction_id: TxId,
         owner: String,
-    ) -> Result<TokenPayload, Error> {
+    ) -> Result<(Transaction, TokenPayload), Error> {
         let filter = Filter {
             ids: vec![transaction_id.clone()],
             limit: 1,
@@ -506,8 +508,7 @@ where
             .pop()
             .ok_or(Error::TxNotFound)?
             .lock_transaction(owner, &self.config.token_manager)?;
-        self.store(new_revision).await?;
-        Ok(secret)
+        Ok((self.store(new_revision).await?, secret))
     }
 
     /// Updates a transaction and updates their tags to this given set

utxo/src/storage/mod.rs

@@ -374,9 +374,81 @@ pub mod test {
             $crate::storage_unit_test!(find_transactions_by_status);
             $crate::storage_unit_test!(not_spendable_new_payments_not_spendable);
             $crate::storage_unit_test!(subscribe_realtime);
+            $crate::storage_unit_test!(transaction_locking);
         };
     }
 
+    pub async fn transaction_locking<T>(storage: T)
+    where
+        T: Storage + Send + Sync,
+    {
+        let config = Config {
+            storage,
+            token_manager: Default::default(),
+            status: StatusManager::default(),
+        };
+
+        let ledger = Ledger::new(config);
+
+        let asset: Asset = "USD/2".parse().expect("valid asset");
+        let deposit = Transaction::new_external_deposit(
+            "test reference".to_owned(),
+            "pending".into(),
+            vec![],
+            vec![(
+                "alice".parse().expect("account"),
+                asset.from_human("100.99").expect("valid amount"),
+            )],
+        )
+        .expect("valid tx");
+
+        let deposit = ledger.store(deposit).await.expect("valid insert");
+
+        let (deposit, update_token) = ledger
+            .lock_transaction(deposit.id, "tester".to_owned())
+            .await
+            .expect("valid locking");
+
+        assert_eq!(
+            "Invalid update token: Missing update token".to_owned(),
+            ledger
+                .change_status(
+                    deposit.revision_id.clone(),
+                    "processing".into(),
+                    "some text".to_owned(),
+                    None,
+                )
+                .await
+                .unwrap_err()
+                .to_string()
+        );
+
+        assert_eq!(
+            "Invalid update token: Invalid signature".to_owned(),
+            ledger
+                .change_status(
+                    deposit.revision_id.clone(),
+                    "processing".into(),
+                    "some text".to_owned(),
+                    Some(Default::default()),
+                )
+                .await
+                .unwrap_err()
+                .to_string()
+        );
+        let new_deposit = ledger
+            .change_status(
+                deposit.revision_id.clone(),
+                "processing".into(),
+                "some text".to_owned(),
+                Some(update_token),
+            )
+            .await
+            .expect("successful update");
+        assert!(new_deposit.revision.locked.is_none());
+        assert!(new_deposit.revision.update_token.is_some());
+    }
+
     pub async fn transaction_does_not_update_stale_revision<T>(storage: T)
     where
         T: Storage + Send + Sync,

utxo/src/transaction/mod.rs

@@ -201,7 +201,10 @@ impl Transaction {
         })
     }
 
-    /// TODO:
+    /// Locks a transaction for updates
+    ///
+    /// The transaction cannot be updated without the secret, which is returned in the tuple, or
+    /// until the lock expires.
     pub fn lock_transaction(
         self,
         owner: String,