Merge pull request algorandfoundation#6 from algorandfoundation/tests/use_testing_frameworks

test(algo_models_ffi): use bun test runner and pytest

Author: joe-p

.gitignore

@@ -1,7 +1,4 @@
 /target
-
 .vscode/
-!/.vscode/settings.recommended.json
-
 .zed/
-!/.zed/settings.recommended.json
+.venv/

crates/algo_models/src/lib.rs

@@ -22,6 +22,9 @@ pub enum MsgPackError {
 
     #[error("Unknown transaction type")]
     UnknownTransactionType,
+
+    #[error("Invalid input: {0}")]
+    InputError(String),
 }
 
 pub trait AlgorandMsgpack: Serialize + for<'de> Deserialize<'de> {
@@ -49,7 +52,13 @@ pub trait AlgorandMsgpack: Serialize + for<'de> Deserialize<'de> {
 
     /// Decode the bytes into Self. "TX" prefix is ignored if present
     fn decode(bytes: &[u8]) -> Result<Self, MsgPackError> {
-        if bytes[0] == b'T' && bytes[1] == b'X' {
+        if bytes.is_empty() {
+            return Err(MsgPackError::InputError(
+                "attempted to decode 0 bytes".to_string(),
+            ));
+        }
+
+        if bytes.len() > 2 && bytes[0] == b'T' && bytes[1] == b'X' {
             let without_prefix = bytes[2..].to_vec();
             Ok(rmp_serde::from_slice(&without_prefix)?)
         } else {

crates/algo_models_ffi/src/lib.rs

@@ -38,6 +38,7 @@ impl From<algo_models::MsgPackError> for MsgPackError {
             algo_models::MsgPackError::UnknownTransactionType => {
                 MsgPackError::DecodingError(e.to_string())
             }
+            algo_models::MsgPackError::InputError(e) => MsgPackError::DecodingError(e.to_string()),
         }
     }
 }
@@ -373,9 +374,12 @@ impl From<algo_models::TransactionType> for TransactionType {
 /// Get the transaction type from the encoded transaction.
 /// This is particularly useful when decoding a transaction that has a unknow type
 pub fn get_encoded_transaction_type(bytes: &[u8]) -> Result<TransactionType, MsgPackError> {
-    let header: TransactionHeader =
-        rmp_serde::from_slice(bytes).map_err(|w| MsgPackError::DecodingError(w.to_string()))?;
-    Ok(header.transaction_type)
+    let decoded = algo_models::Transaction::decode(bytes)?;
+
+    match decoded {
+        algo_models::Transaction::Payment(_) => Ok(TransactionType::Payment),
+        algo_models::Transaction::AssetTransfer(_) => Ok(TransactionType::AssetTransfer),
+    }
 }
 
 #[cfg_attr(feature = "ffi_wasm", wasm_bindgen(js_name = "encodePayment"))]
@@ -416,3 +420,38 @@ pub fn attach_signature(encoded_tx: &[u8], signature: &[u8]) -> Result<Vec<u8>,
     };
     Ok(signed_tx.encode()?)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_encoded_transaction_type() {
+        // Create a minimal payment transaction
+        let tx = PayTransactionFields {
+            header: TransactionHeader {
+                transaction_type: TransactionType::Payment,
+                sender: ByteBuf::from(vec![0; 32]), // 32-byte dummy public key
+                fee: 1000,
+                first_valid: 1000,
+                last_valid: 2000,
+                genesis_hash: None,
+                genesis_id: None,
+                note: None,
+                rekey_to: None,
+                lease: None,
+                group: None,
+            },
+            receiver: ByteBuf::from(vec![1; 32]), // 32-byte dummy receiver
+            amount: 1000000,
+            close_remainder_to: None,
+        };
+
+        // Encode the transaction
+        let encoded = encode_payment(tx).unwrap();
+
+        // Test the get_encoded_transaction_type function
+        let tx_type = get_encoded_transaction_type(&encoded).unwrap();
+        assert_eq!(tx_type, TransactionType::Payment);
+    }
+}

crates/algo_models_ffi/tests/generate_test_data.py

@@ -0,0 +1,63 @@
+# This script is used to generate test_data.json, which is then used in the language binding tests
+# This script should only be ran when the data is updated (i.e. a new transaction type is added)
+
+from algosdk import account, transaction, encoding, constants
+from algosdk.v2client.algod import AlgodClient
+import base64
+import json
+
+[sender_sk, sender_addr] = account.generate_account()
+[_, receiver_addr] = account.generate_account()
+
+
+algod = AlgodClient("", "https://testnet-api.4160.nodely.dev")
+sp = algod.suggested_params()
+
+
+def get_bytes_for_signing(tx: transaction.Transaction):
+    return list(constants.txid_prefix + base64.b64decode(encoding.msgpack_encode(pay)))
+
+
+def addr_bytes(addr):
+    return list(encoding.decode_address(addr))
+
+
+def b64_bytes(data):
+    return list(base64.b64decode(data))
+
+
+pay = transaction.PaymentTxn(
+    sender=sender_addr,
+    receiver=receiver_addr,
+    amt=1000,
+    close_remainder_to=None,
+    note=None,
+    lease=None,
+    rekey_to=None,
+    sp=sp,
+)
+
+stxn = pay.sign(sender_sk)
+
+data = {
+    "privKey": list(base64.b64decode(sender_sk))[0:32],
+    "fields": {
+        "header": {
+            "sender": addr_bytes(pay.sender),
+            "fee": pay.fee,
+            "transactionType": "Payment",
+            "firstValid": pay.first_valid_round,
+            "lastValid": pay.last_valid_round,
+            "genesisHash": b64_bytes(pay.genesis_hash),
+            "genesisId": pay.genesis_id,
+        },
+        "receiver": addr_bytes(pay.receiver),
+        "amount": pay.amt,
+    },
+    "expectedBytesForSigning": get_bytes_for_signing(pay),
+    "expectedSignedTxn": b64_bytes(encoding.msgpack_encode(stxn)),
+}
+
+
+with open("./test_data.json", "w") as f:
+    json.dump(data, f, indent=2)

crates/algo_models_ffi/tests/js/bun.lockb

@@ -0,0 +1,94 @@
+import { expect, test, describe } from "bun:test";
+import * as ed from "@noble/ed25519";
+import init, {
+  type PayTransactionFields,
+  encodePayment,
+  attachSignature,
+  decodePayment,
+  getEncodedTransactionType,
+} from "./pkg/algo_models_ffi";
+import path from "path";
+
+describe("algo_models WASM", async () => {
+  await init();
+
+  const jsonString = await Bun.file(
+    path.join(__dirname, "../test_data.json")
+  ).text();
+
+  const testData = JSON.parse(jsonString, (_, value) => {
+    if (Array.isArray(value) && value.every((n) => typeof n === "number")) {
+      return new Uint8Array(value);
+    }
+
+    if (
+      typeof value === "number" &&
+      ["fee", "amount", "firstValid", "lastValid"].includes(_)
+    ) {
+      return BigInt(value);
+    }
+
+    return value;
+  });
+
+  const privKey = testData.privKey;
+
+  describe("payment", () => {
+    const fields: PayTransactionFields = testData.fields;
+    const expectedSignedTxn = testData.expectedSignedTxn;
+    const expectedBytesForSigning = testData.expectedBytesForSigning;
+
+    test("encode", () => {
+      expect(encodePayment(fields)).toEqual(expectedBytesForSigning);
+    });
+
+    test("encode with signature", async () => {
+      const sig = await ed.signAsync(expectedBytesForSigning, privKey);
+      const signedTx = attachSignature(expectedBytesForSigning, sig);
+      expect(signedTx).toEqual(expectedSignedTxn);
+    });
+
+    test("decode (with TX prefix)", () => {
+      expect(decodePayment(expectedBytesForSigning)).toEqual(fields);
+    });
+
+    test("decode (without TX prefix)", () => {
+      expect(decodePayment(expectedBytesForSigning.slice(2))).toEqual(fields);
+    });
+
+    test("getEncodedTransactionType", () => {
+      expect(getEncodedTransactionType(expectedBytesForSigning)).toBe(
+        "Payment"
+      );
+    });
+
+    // TODO: Decide if this is the behavior we want or if there should be input validation on encode
+    test("encode/decode with extra field", () => {
+      const extraField = { ...fields, foo: "bar" };
+      const encoded = encodePayment(extraField);
+      expect(decodePayment(encoded)).not.toContainKey("foo");
+    });
+
+    test("DecodingError: 0 bytes", () => {
+      expect(() => decodePayment(new Uint8Array(0))).toThrow(
+        "DecodingError: attempted to decode 0 bytes"
+      );
+    });
+
+    test("DecodingError: malformed bytes", () => {
+      const badBytes = expectedBytesForSigning.slice();
+      badBytes[13] = 37;
+      expect(() => decodePayment(badBytes)).toThrow(
+        "DecodingError: Error ocurred during decoding: missing field `fee`"
+      );
+    });
+
+    test("Error: invalid type", () => {
+      const badFields = { ...fields, header: { fee: "foo" } };
+      // @ts-expect-error known bad type for testing purposes
+      expect(() => encodePayment(badFields)).toThrow(
+        'Error: invalid type: string "foo", expected u64'
+      );
+    });
+  });
+});

crates/algo_models_ffi/tests/js/index.test.ts

@@ -13,5 +13,8 @@
     "@algorandfoundation/algo-models": "^0.0.2",
     "@noble/ed25519": "^2.1.0",
     "algo-msgpack-with-bigint": "^2.1.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.14"
   }
 }

crates/algo_models_ffi/tests/js/index.ts

@@ -42,7 +42,7 @@
     // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
     // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
     // "noUncheckedSideEffectImports": true,             /* Check side effect imports. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    "resolveJsonModule": true,                        /* Enable importing .json files. */
     // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
     // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */