fix(orders-accounting): show full order ID in overbid errors

orders-accounting/src/error.rs

@@ -19,43 +19,43 @@ use common::{chain::OrderId, primitives::Amount};
 pub enum Error {
     #[error("Base accounting error: `{0}`")]
     AccountingError(#[from] accounting::Error),
-    #[error("Order already exists: `{0}`")]
+    #[error("Order already exists: `{0:x}`")]
     OrderAlreadyExists(OrderId),
-    #[error("Data for order `{0}` not found")]
+    #[error("Data for order `{0:x}` not found")]
     OrderDataNotFound(OrderId),
-    #[error("Attempt to create an order with zero exchange value `{0}`")]
+    #[error("Attempt to create an order with zero exchange value `{0:x}`")]
     OrderWithZeroValue(OrderId),
-    #[error("Data for order `{0}` not found for undo")]
+    #[error("Data for order `{0:x}` not found for undo")]
     InvariantOrderDataNotFoundForUndo(OrderId),
-    #[error("Ask balance for order `{0}` changed for undo")]
+    #[error("Ask balance for order `{0:x}` changed for undo")]
     InvariantOrderAskBalanceChangedForUndo(OrderId),
-    #[error("Give balance for order `{0}` changed for undo")]
+    #[error("Give balance for order `{0:x}` changed for undo")]
     InvariantOrderGiveBalanceChangedForUndo(OrderId),
-    #[error("Data for order `{0}` still exist on conclude undo")]
+    #[error("Data for order `{0:x}` still exist on conclude undo")]
     InvariantOrderDataExistForConcludeUndo(OrderId),
-    #[error("Data for order `{0}` doesn't exist on freeze undo")]
+    #[error("Data for order `{0:x}` doesn't exist on freeze undo")]
     InvariantOrderDataNotExistForFreezeUndo(OrderId),
-    #[error("Ask balance for order `{0}` still exist on conclude undo")]
+    #[error("Ask balance for order `{0:x}` still exist on conclude undo")]
     InvariantOrderAskBalanceExistForConcludeUndo(OrderId),
-    #[error("Give balance for order `{0}` still exist on conclude undo")]
+    #[error("Give balance for order `{0:x}` still exist on conclude undo")]
     InvariantOrderGiveBalanceExistForConcludeUndo(OrderId),
-    #[error("Ask balance for non-existing order `{0}` is not zero")]
+    #[error("Ask balance for non-existing order `{0:x}` is not zero")]
     InvariantNonzeroAskBalanceForMissingOrder(OrderId),
-    #[error("Give balance for non-existing order `{0}` is not zero")]
+    #[error("Give balance for non-existing order `{0:x}` is not zero")]
     InvariantNonzeroGiveBalanceForMissingOrder(OrderId),
-    #[error("Order overflow: `{0}`")]
+    #[error("Order overflow: `{0:x}`")]
     OrderOverflow(OrderId),
-    #[error("Order `{0}` can provide `{1:?}` amount; but attempted to fill `{2:?}`")]
+    #[error("Order `{0:x}` can provide `{1:?}` amount; but attempted to fill `{2:?}`")]
     OrderOverbid(OrderId, Amount, Amount),
-    #[error("Order `{0}` provides amount `{1:?}` that is not enough to fill even a single atom")]
+    #[error("Order `{0:x}` provides amount `{1:?}` that is not enough to fill even a single atom")]
     OrderUnderbid(OrderId, Amount),
-    #[error("Attempt to conclude non-existing order data `{0}`")]
+    #[error("Attempt to conclude non-existing order data `{0:x}`")]
     AttemptedConcludeNonexistingOrderData(OrderId),
-    #[error("Attempt to freeze non-existing order data `{0}`")]
+    #[error("Attempt to freeze non-existing order data `{0:x}`")]
     AttemptedFreezeNonexistingOrderData(OrderId),
-    #[error("Attempt to freeze already frozen order `{0}`")]
+    #[error("Attempt to freeze already frozen order `{0:x}`")]
     AttemptedFreezeAlreadyFrozenOrder(OrderId),
-    #[error("Attempt to fill frozen order `{0}`")]
+    #[error("Attempt to fill frozen order `{0:x}`")]
     AttemptedFillFrozenOrder(OrderId),
     #[error("Unsupported token version")]
     UnsupportedTokenVersion,
@@ -75,3 +75,42 @@ impl From<std::convert::Infallible> for Error {
         match value {}
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use common::primitives::H256;
+
+    use super::*;
+
+    #[test]
+    fn order_errors_display_full_order_id() {
+        let order_id = OrderId::new(H256::repeat_byte(0xab));
+        let full_order_id = "abababababababababababababababababababababababababababababababab";
+
+        let errors = [
+            Error::OrderAlreadyExists(order_id),
+            Error::OrderDataNotFound(order_id),
+            Error::OrderWithZeroValue(order_id),
+            Error::InvariantOrderDataNotFoundForUndo(order_id),
+            Error::InvariantOrderAskBalanceChangedForUndo(order_id),
+            Error::InvariantOrderGiveBalanceChangedForUndo(order_id),
+            Error::InvariantOrderDataExistForConcludeUndo(order_id),
+            Error::InvariantOrderDataNotExistForFreezeUndo(order_id),
+            Error::InvariantOrderAskBalanceExistForConcludeUndo(order_id),
+            Error::InvariantOrderGiveBalanceExistForConcludeUndo(order_id),
+            Error::InvariantNonzeroAskBalanceForMissingOrder(order_id),
+            Error::InvariantNonzeroGiveBalanceForMissingOrder(order_id),
+            Error::OrderOverflow(order_id),
+            Error::OrderOverbid(order_id, Amount::from_atoms(1), Amount::from_atoms(2)),
+            Error::OrderUnderbid(order_id, Amount::from_atoms(1)),
+            Error::AttemptedConcludeNonexistingOrderData(order_id),
+            Error::AttemptedFreezeNonexistingOrderData(order_id),
+            Error::AttemptedFreezeAlreadyFrozenOrder(order_id),
+            Error::AttemptedFillFrozenOrder(order_id),
+        ];
+
+        for error in errors {
+            assert!(error.to_string().contains(full_order_id));
+        }
+    }
+}