ergo-lib-python: add unit tests

Author: sethdusek

bindings/ergo-lib-python/src/chain/address.rs

@@ -17,48 +17,12 @@ impl From<NetworkPrefix> for address::NetworkPrefix {
     }
 }
 
-/**
- * An address is a short string corresponding to some script used to protect a box. Unlike (string-encoded) binary
- * representation of a script, an address has some useful characteristics:
- *
- * - Integrity of an address could be checked., as it is incorporating a checksum.
- * - A prefix of address is showing network and an address type.
- * - An address is using an encoding (namely, Base58) which is avoiding similarly l0Oking characters, friendly to
- * double-clicking and line-breaking in emails.
- *
- *
- *
- * An address is encoding network type, address type, checksum, and enough information to watch for a particular scripts.
- *
- * Possible network types are:
- * Mainnet - 0x00
- * Testnet - 0x10
- *
- * For an address type, we form content bytes as follows:
- *
- * P2PK - serialized (compressed) public key
- * P2SH - first 192 bits of the Blake2b256 hash of serialized script bytes
- * P2S  - serialized script
- *
- * Address examples for testnet:
- *
- * 3   - P2PK (3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN)
- * ?   - P2SH (rbcrmKEYduUvADj9Ts3dSVSG27h54pgrq5fPuwB)
- * ?   - P2S (Ms7smJwLGbUAjuWQ)
- *
- * for mainnet:
- *
- * 9  - P2PK (9fRAWhdxEsTcdb8PhGNrZfwqa65zfkuYHAMmkQLcic1gdLSV5vA)
- * ?  - P2SH (8UApt8czfFVuTgQmMwtsRBZ4nfWquNiSwCWUjMg)
- * ?  - P2S (4MQyML64GnzMxZgm, BxKBaHkvrTvLZrDcZjcsxsF7aSsrN73ijeFZXtbj4CXZHHcvBtqSxQ)
- */
 #[pyclass(eq, frozen)]
 #[derive(From, Into, Clone, PartialEq, Eq)]
 pub(crate) struct Address(pub(crate) address::Address);
 
 #[pymethods]
 impl Address {
-    /// Build a new address from a str, ErgoTree or bytes
     #[new]
     #[pyo3(signature = (arg, network_prefix=None))]
     fn new(arg: &Bound<'_, PyAny>, network_prefix: Option<NetworkPrefix>) -> PyResult<Self> {
@@ -90,15 +54,12 @@ impl Address {
     fn p2pk(_: &Bound<'_, PyType>, prove_dlog: ProveDlog) -> Address {
         address::Address::P2Pk(prove_dlog.into()).into()
     }
-    /// Re-create the address from ErgoTree that was built from the address
-    /// This is the inverse of Address.ergo_tree()
     #[classmethod]
     fn recreate_from_ergo_tree(_: &Bound<'_, PyType>, tree: &ErgoTree) -> PyResult<Self> {
         address::Address::recreate_from_ergo_tree(&tree.0)
             .map(Self)
             .map_err(to_value_error)
     }
-    /// Create an ErgoTree script from the address
     pub(crate) fn ergo_tree(&self) -> PyResult<ErgoTree> {
         self.0.script().map(Into::into).map_err(to_value_error)
     }

bindings/ergo-lib-python/tests/address_tests.py

@@ -0,0 +1,12 @@
+import unittest
+from ergo_lib_python.chain import Address, NetworkPrefix
+
+class AddressTests(unittest.TestCase):
+    def test_from_str(self):
+        testnet_address_str = "3WvsT2Gm4EpsM9Pg18PdY6XyhNNMqXDsvJTbbf6ihLvAmSb7u5RN"
+        testnet_address = Address(testnet_address_str)
+        self.assertEqual(testnet_address.to_str(NetworkPrefix.Testnet), testnet_address_str)
+        with self.assertRaises(ValueError):
+            Address(testnet_address_str, network_prefix=NetworkPrefix.Mainnet)
+        tree = testnet_address.ergo_tree()
+        self.assertEqual(Address.recreate_from_ergo_tree(tree), testnet_address)

bindings/ergo-lib-python/tests/constant_tests.py

@@ -0,0 +1,57 @@
+import unittest
+from ergo_lib_python.chain import Constant, SType, ErgoBox
+
+class TestConstant(unittest.TestCase):
+    def test_i32(self):
+        c = Constant.from_i32(999)
+        self.assertEqual(c.tpe, SType.SInt())
+        encoded = bytes(c)
+        decoded = Constant.from_bytes(encoded)
+        self.assertEqual(c, decoded)
+        with self.assertRaises(OverflowError):
+            Constant.from_i32(2 ** 31)
+        with self.assertRaises(OverflowError):
+            Constant.from_i32(-(2 ** 31) - 1)
+
+    def test_i64(self):
+        c = Constant.from_i64(999)
+        self.assertEqual(c.tpe, SType.SLong())
+        encoded: bytes = bytes(c)
+        decoded = Constant.from_bytes(encoded)
+        self.assertEqual(c, decoded)
+        with self.assertRaises(OverflowError):
+            Constant.from_i64(2 ** 63)
+        with self.assertRaises(OverflowError):
+            Constant.from_i32(-(2 ** 63) - 1)
+    def test_bytes(self):
+        b = bytes([1, 1, 2, 255])
+        c = Constant(b)
+        self.assertEqual(c.tpe, SType.SColl(SType.SByte()))
+        encoded = bytes(c)
+        decoded = Constant.from_bytes(encoded)
+        self.assertEqual(c, decoded)
+    def test_tuple(self):
+        box = ErgoBox.from_json("""
+                    {
+                      "boxId": "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e",
+                      "value": 67500000000,
+                      "ergoTree": "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301",
+                      "assets": [],
+                      "creationHeight": 284761,
+                      "additionalRegisters": {},
+                      "transactionId": "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9",
+                      "index": 1
+                    }
+                """)
+        c = Constant((Constant.from_i32(1), Constant(box), Constant(bytes([1, 2]))))
+        self.assertEqual(c.value, (Constant.from_i32(1), Constant(box), Constant(bytes([1, 2]))))
+        self.assertEqual(c.tpe, SType.STuple((SType.SInt(), SType.SBox(), SType.SColl(SType.SByte()))))
+        #test that pattern matching works
+        match c.tpe:
+            case SType.STuple((SType.SInt(), SType.SBox(), SType.SColl(SType.SByte()))):
+                ...
+            case _:
+                assert False
+        encoded = bytes(c)
+        decoded = Constant.from_bytes(encoded)
+        self.assertEqual(c, decoded)

bindings/ergo-lib-python/tests/ergobox_tests.py

@@ -0,0 +1,24 @@
+import unittest
+from ergo_lib_python.chain import BoxId, ErgoBox
+import json
+
+class ErgoBoxTests(unittest.TestCase):
+    def test_json(self):
+        box_json = """
+            {
+              "boxId": "e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e",
+              "value": 67500000000,
+              "ergoTree": "100204a00b08cd021dde34603426402615658f1d970cfa7c7bd92ac81a8b16eeebff264d59ce4604ea02d192a39a8cc7a70173007301",
+              "assets": [],
+              "creationHeight": 284761,
+              "additionalRegisters": {},
+              "transactionId": "9148408c04c2e38a6402a7950d6157730fa7d49e9ab3b9cadec481d7769918e9",
+              "index": 1
+            }
+        """
+        box = ErgoBox.from_json(box_json)
+        # test equivalence between from_json(str) and from_json(dict)
+        self.assertEqual(box, ErgoBox.from_json(json.loads(box_json)))
+        self.assertEqual(box.box_id, BoxId("e56847ed19b3dc6b72828fcfb992fdf7310828cf291221269b7ffc72fd66706e"))
+        self.assertEqual(box.creation_height, 284761)
+        self.assertEqual(box.value, 67500000000)

bindings/ergo-lib-python/tests/token_tests.py

@@ -0,0 +1,12 @@
+import unittest
+import base64
+from ergo_lib_python.chain import TokenId, BoxId
+
+class TokenTests(unittest.TestCase):
+    id_str = "19475d9a78377ff0f36e9826cec439727bea522f6ffa3bda32e20d2f8b3103ac"
+    def test_from_str(self):
+        id = TokenId(self.id_str)
+        self.assertEqual(bytes(id), base64.b16decode(self.id_str, casefold=True))
+    def test_from_box_id(self):
+        box_id = BoxId(self.id_str)
+        self.assertEqual(bytes(box_id), bytes(TokenId.from_box_id(box_id)))