chore: better tests (#13)

* fix tests

* more tests

* hardening

* more tests

* more tests

* more

* remove noise

* cleanup

* more tests

* integration tests

* tests

Author: tac0turtle

bin/evd/src/genesis_config.rs

@@ -76,3 +76,139 @@ impl AccountConfig {
             .map_err(|e| format!("invalid eth address '{}': {}", self.eth_address, e))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::PathBuf;
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    static TEMP_FILE_COUNTER: AtomicU64 = AtomicU64::new(0);
+
+    fn temp_genesis_file(contents: &str) -> PathBuf {
+        let mut path = std::env::temp_dir();
+        let id = TEMP_FILE_COUNTER.fetch_add(1, Ordering::Relaxed);
+        path.push(format!("evd-genesis-{}-{id}.json", std::process::id()));
+        std::fs::write(&path, contents).unwrap();
+        path
+    }
+
+    #[test]
+    fn load_fails_for_missing_file() {
+        let path = "/definitely/not/present/evd-genesis.json";
+        let err = EvdGenesisConfig::load(path)
+            .err()
+            .expect("missing file must fail");
+        assert!(err.contains("failed to read genesis file"));
+    }
+
+    #[test]
+    fn load_fails_for_empty_accounts() {
+        let path = temp_genesis_file(
+            r#"{
+                "token": {
+                    "name": "Evolve",
+                    "symbol": "EV",
+                    "decimals": 6,
+                    "icon_url": "https://example.com/icon.png",
+                    "description": "token"
+                },
+                "minter_id": 100,
+                "accounts": []
+            }"#,
+        );
+
+        let err = EvdGenesisConfig::load(path.to_str().unwrap())
+            .err()
+            .expect("empty accounts fail");
+        assert!(err.contains("at least one account"));
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn load_fails_for_invalid_account_address() {
+        let path = temp_genesis_file(
+            r#"{
+                "token": {
+                    "name": "Evolve",
+                    "symbol": "EV",
+                    "decimals": 6,
+                    "icon_url": "https://example.com/icon.png",
+                    "description": "token"
+                },
+                "minter_id": 100,
+                "accounts": [
+                    { "eth_address": "not-an-address", "balance": 1 }
+                ]
+            }"#,
+        );
+
+        let err = EvdGenesisConfig::load(path.to_str().unwrap())
+            .err()
+            .expect("invalid address must fail");
+        assert!(err.contains("account[0]"));
+        assert!(err.contains("invalid eth address"));
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn load_succeeds_for_valid_config() {
+        let path = temp_genesis_file(
+            r#"{
+                "token": {
+                    "name": "Evolve",
+                    "symbol": "EV",
+                    "decimals": 6,
+                    "icon_url": "https://example.com/icon.png",
+                    "description": "token"
+                },
+                "minter_id": 100,
+                "accounts": [
+                    {
+                        "eth_address": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
+                        "balance": 1000
+                    }
+                ]
+            }"#,
+        );
+
+        let cfg = EvdGenesisConfig::load(path.to_str().unwrap()).expect("valid config should load");
+        assert_eq!(cfg.minter_id, 100);
+        assert_eq!(cfg.accounts.len(), 1);
+        assert_eq!(cfg.accounts[0].balance, 1000);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn parse_address_rejects_invalid_and_accepts_valid() {
+        let bad = AccountConfig {
+            eth_address: "bad-address".to_string(),
+            balance: 1,
+        };
+        assert!(bad.parse_address().is_err());
+
+        let good = AccountConfig {
+            eth_address: "0x0000000000000000000000000000000000000001".to_string(),
+            balance: 1,
+        };
+        assert!(good.parse_address().is_ok());
+    }
+
+    #[test]
+    fn token_to_metadata_maps_all_fields() {
+        let token = TokenConfig {
+            name: "Evolve".to_string(),
+            symbol: "EV".to_string(),
+            decimals: 6,
+            icon_url: "https://example.com/token.png".to_string(),
+            description: "Sample token".to_string(),
+        };
+        let metadata = token.to_metadata();
+
+        assert_eq!(metadata.name, "Evolve");
+        assert_eq!(metadata.symbol, "EV");
+        assert_eq!(metadata.decimals, 6);
+        assert_eq!(metadata.icon_url, "https://example.com/token.png");
+        assert_eq!(metadata.description, "Sample token");
+    }
+}

bin/txload/src/main.rs

@@ -525,3 +525,127 @@ async fn run_loadtest(config: LoadtestConfig) -> Result<(), String> {
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fixed_key() -> SigningKey {
+        parse_signing_key("0x1111111111111111111111111111111111111111111111111111111111111111")
+            .expect("fixed key should parse")
+    }
+
+    #[test]
+    fn parse_signing_key_accepts_prefixed_and_unprefixed_hex() {
+        let with_prefix =
+            parse_signing_key("0x1111111111111111111111111111111111111111111111111111111111111111")
+                .expect("with-prefix key should parse");
+        let without_prefix =
+            parse_signing_key("1111111111111111111111111111111111111111111111111111111111111111")
+                .expect("without-prefix key should parse");
+
+        assert_eq!(
+            wallet_address(&with_prefix),
+            wallet_address(&without_prefix)
+        );
+    }
+
+    #[test]
+    fn parse_signing_key_rejects_wrong_length() {
+        let err = parse_signing_key("0x1234").expect_err("short key must fail");
+        assert!(err.contains("private key must be 32 bytes"));
+    }
+
+    #[test]
+    fn parse_hex_u64_handles_common_cases() {
+        assert_eq!(parse_hex_u64("0x0").unwrap(), 0);
+        assert_eq!(parse_hex_u64("0Xff").unwrap(), 255);
+        assert_eq!(parse_hex_u64("a").unwrap(), 10);
+        assert_eq!(parse_hex_u64("").unwrap(), 0);
+        assert!(parse_hex_u64("0xzz").is_err());
+    }
+
+    #[test]
+    fn build_transfer_calldata_has_selector_and_borsh_args() {
+        let recipient = AccountId::new(42);
+        let amount = 999_u128;
+
+        let calldata = build_transfer_calldata(recipient, amount).unwrap();
+        assert!(calldata.len() > 4);
+        assert_eq!(&calldata[0..4], &transfer_selector());
+
+        let decoded: (AccountId, u128) = borsh::from_slice(&calldata[4..]).unwrap();
+        assert_eq!(decoded.0, recipient);
+        assert_eq!(decoded.1, amount);
+    }
+
+    #[test]
+    fn create_signed_tx_is_type_2_and_deterministic() {
+        let key = fixed_key();
+        let params = TxBuildParams {
+            chain_id: 1,
+            to: wallet_address(&key),
+            gas_limit: 21_000,
+            max_priority_fee_per_gas: 1_000_000_000,
+            max_fee_per_gas: 2_000_000_000,
+        };
+        let input = vec![1, 2, 3, 4];
+
+        let tx1 = create_signed_tx(&key, 7, input.clone(), params);
+        let tx2 = create_signed_tx(&key, 7, input, params);
+
+        assert!(!tx1.is_empty());
+        assert_eq!(tx1[0], 0x02);
+        assert_eq!(tx1, tx2);
+    }
+
+    #[tokio::test]
+    async fn run_loadtest_validates_config_before_network() {
+        let key = fixed_key();
+        let token_account = wallet_address(&key);
+
+        let base = LoadtestConfig {
+            rpc_url: "http://127.0.0.1:8545".to_string(),
+            chain_id: 1,
+            token_account,
+            funder_key: key,
+            workers: 2,
+            target_tps: 1,
+            duration_secs: 1,
+            fanout_amount: 1,
+            tx_amount: 1,
+            gas_limit: 21_000,
+            max_priority_fee_per_gas: 1,
+            max_fee_per_gas: 1,
+            funding_settle_secs: 0,
+            request_timeout_ms: 100,
+        };
+
+        let err_workers = run_loadtest(LoadtestConfig { workers: 1, ..base })
+            .await
+            .expect_err("workers < 2 should fail");
+        assert!(err_workers.contains("workers must be >= 2"));
+
+        let key2 = fixed_key();
+        let token2 = wallet_address(&key2);
+        let err_tps = run_loadtest(LoadtestConfig {
+            rpc_url: "http://127.0.0.1:8545".to_string(),
+            chain_id: 1,
+            token_account: token2,
+            funder_key: key2,
+            workers: 2,
+            target_tps: 0,
+            duration_secs: 1,
+            fanout_amount: 1,
+            tx_amount: 1,
+            gas_limit: 21_000,
+            max_priority_fee_per_gas: 1,
+            max_fee_per_gas: 1,
+            funding_settle_secs: 0,
+            request_timeout_ms: 100,
+        })
+        .await
+        .expect_err("target_tps == 0 should fail");
+        assert!(err_tps.contains("target_tps must be > 0"));
+    }
+}