package com.ruoyi.system.rental; import static com.ruoyi.system.rental.RentalValues.*; import static org.junit.Assert.*; import com.fasterxml.jackson.databind.ObjectMapper; import org.h2.jdbcx.JdbcDataSource; import org.junit.Before; import org.junit.Test; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.datasource.DataSourceTransactionManager; import org.springframework.transaction.support.TransactionTemplate; import java.math.BigDecimal; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Paths; import java.util.*; import java.util.concurrent.*; /** 隔离事务测试:使用真实仓储SQL及行锁,不连接项目MySQL、Redis或TRON。 */ public class RentalBusinessTest { private RentalStore store; private RentalFunds funds; private RentalOrders orders; private RentalReviews reviews; private RentalTasks tasks; private RentalIdentity identity; private TransactionTemplate tx; private long payer; private long supplier; private long app; private long product; private long wallet; private long node; private boolean proofAvailable = true; private long verifiedResourceQuantity = 78000; private long verificationBlockAgeSeconds = 5; private boolean receiverActivated; private boolean activationRpcFailed; private int activationChecks; private long supplierBalanceSun = 10000000L; private static final String ADDRESS = "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf"; private static final String OWNER = "TR7NHqjeKQxGTCi8q8ZY4pL8otgjLj6t"; private final ObjectMapper json = new ObjectMapper(); /** 待验证地址仅本人可删除,验证后或状态变化后必须保留。 */ @Test public void pendingWalletDeletionChecksOwnershipAndVerification() { long pending = store.insert("wallet", map("node_id", node, "network", "NILE", "address", "pending-delete", "status", "PENDING")); expectFailure(() -> tx.execute(status -> { rentalDeletion().deletePendingWallet(pending, 10); return null; })); store.update("wallet", pending, map("ownership_verified_at", now())); expectFailure(() -> tx.execute(status -> { rentalDeletion().deletePendingWallet(pending, 20); return null; })); store.update("wallet", pending, map("ownership_verified_at", null, "status", "PAUSED")); expectFailure(() -> tx.execute(status -> { rentalDeletion().deletePendingWallet(pending, 20); return null; })); store.update("wallet", pending, map("status", "PENDING")); tx.execute(status -> { rentalDeletion().deletePendingWallet(pending, 20); return null; }); assertNull(store.one("SELECT id FROM rent_wallet WHERE id=?", pending)); assertEquals(1, store.rows("SELECT id FROM rent_event WHERE object_type='WALLET' AND object_id=? AND action='DELETE'", pending).size()); } /** 同一节点新增必须串行校验;两个并发请求只能成功绑定一个地址。 */ @Test public void concurrentWalletRegistrationAllowsOnlyOne() throws Exception { long freshNode = tx.execute(status -> rentalDeletion().create("node", map("name", "single-wallet"), 20)); ExecutorService pool = Executors.newFixedThreadPool(2); CountDownLatch start = new CountDownLatch(1); try { List> results = new ArrayList<>(); for (String address : Arrays.asList(ADDRESS, "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb")) { results.add(pool.submit(() -> { start.await(); try { tx.execute(status -> rentalDeletion().create("wallet", map("node_id", freshNode, "network", "MAINNET", "address", address), 20)); return true; } catch (IllegalArgumentException expected) { return false; } })); } start.countDown(); int successes = 0; for (Future result : results) { if (result.get(15, TimeUnit.SECONDS)) successes++; } assertEquals(1, successes); assertEquals(1, store.rows("SELECT id FROM rent_wallet WHERE node_id=?", freshNode).size()); } finally { pool.shutdownNow(); } } /** 换绑重置旧地址认证及资源策略,拒绝在线、越权、错误网络、重复地址及历史业务关联。 */ @Test public void walletRebindResetsProofAndRejectsUnsafeChanges() { Map request = map("network", "NILE", "address", ADDRESS); expectFailure(() -> tx.execute(status -> { rentalDeletion().rebindWallet(wallet, request, 20); return null; })); store.update("node", node, map("connection_status", "OFFLINE")); expectFailure(() -> tx.execute(status -> { rentalDeletion().rebindWallet(wallet, request, 10); return null; })); expectFailure(() -> tx.execute(status -> { rentalDeletion().rebindWallet(wallet, map("network", "MAINNET", "address", ADDRESS), 20); return null; })); expectFailure(() -> tx.execute(status -> { rentalDeletion().rebindWallet(wallet, map("network", "NILE", "address", OWNER), 20); return null; })); store.update("wallet", wallet, map("energy_reserved_sun", 1)); expectFailure(() -> tx.execute(status -> { rentalDeletion().rebindWallet(wallet, request, 20); return null; })); store.update("wallet", wallet, map("energy_reserved_sun", 0, "ownership_challenge", "old-challenge")); tx.execute(status -> { rentalDeletion().rebindWallet(wallet, request, 20); return null; }); Map updated = store.get("wallet", wallet, false); assertEquals(ADDRESS, text(updated, "address")); assertEquals("PENDING", text(updated, "status")); assertNull(updated.get("ownership_verified_at")); assertNull(updated.get("ownership_challenge")); assertNull(updated.get("snapshot_at")); assertEquals(0, number(updated, "energy_enabled")); assertEquals(0, number(updated, "energy_delegatable_sun")); store.update("wallet", wallet, map("status", "ACTIVE", "ownership_verified_at", now())); Map order = tx.execute(status -> orders.create(app, 10, map("network", "NILE", "package_id", product, "resource_type", "ENERGY", "merchant_order_no", "rebind-history", "receiver_address", ADDRESS))); store.update("order", number(order, "id"), map("wallet_id", wallet)); expectFailure(() -> tx.execute(status -> { rentalDeletion().rebindWallet(wallet, map("network", "NILE", "address", OWNER), 20); return null; })); assertEquals(ADDRESS, text(store.get("wallet", wallet, false), "address")); } /** 出租策略保留 SUN 整数精度,不能越权或写入负数/小数。 */ @Test public void walletPolicyIsOwnedAndUsesExactSun() { Map policy = map("energy_enabled", 1, "bandwidth_enabled", 0, "energy_retain_sun", "9007199254740993", "bandwidth_retain_sun", "0"); expectFailure(() -> tx.execute(status -> { rentalDeletion().policy(wallet, policy, 10); return null; })); tx.execute(status -> { rentalDeletion().policy(wallet, policy, 20); return null; }); assertEquals(9007199254740993L, number(store.get("wallet", wallet, false), "energy_retain_sun")); policy.put("bandwidth_retain_sun", "-1"); expectFailure(() -> tx.execute(status -> { rentalDeletion().policy(wallet, policy, 20); return null; })); } /** 在线和恢复连接时拒绝轮换且保留原凭证,离线后允许正常轮换。 */ @Test public void nodeCredentialRotationRequiresOffline() { Map original = store.one( "SELECT id FROM rent_credential WHERE owner_type='NODE' AND owner_id=? AND status='ACTIVE'", node); for (String connection : Arrays.asList("ONLINE", "SYNCING")) { store.update("node", node, map("connection_status", connection)); expectFailure(() -> tx.execute(status -> identity.issue("NODE", node, 20))); assertEquals("ACTIVE", text(store.get("credential", number(original, "id"), false), "status")); assertEquals(1, store.rows("SELECT id FROM rent_credential WHERE owner_type='NODE' AND owner_id=?", node).size()); } store.update("node", node, map("connection_status", "OFFLINE")); Map issued = tx.execute(status -> identity.issue("NODE", node, 20)); assertEquals("ACTIVE", text(store.get("credential", number(issued, "id"), false), "status")); assertEquals("VERIFY_ONLY", text(store.get("credential", number(original, "id"), false), "status")); } /** 真实查询验证应用隔离、节点凭证隔离与 Secret 不外泄。 */ @Test public void appDetailIsOwnedAndNeverReturnsSecrets() { com.ruoyi.common.core.domain.entity.SysUser user = new com.ruoyi.common.core.domain.entity.SysUser(); user.setUserId(10L); com.ruoyi.common.core.domain.model.LoginUser login = new com.ruoyi.common.core.domain.model.LoginUser(user, Collections.emptySet()); org.springframework.security.core.context.SecurityContextHolder.getContext().setAuthentication( new org.springframework.security.authentication.UsernamePasswordAuthenticationToken( login, null, Collections.emptyList())); try { tx.execute(status -> identity.issue("APP", app, 10)); store.update("node", node, map("connection_status", "OFFLINE")); tx.execute(status -> identity.issue("NODE", node, 20)); RentalController controller = new RentalController( store, null, identity, orders, funds, reviews, tasks, null, null); expectFailure(() -> controller.nodeDetail(node)); long ownNode = tx.execute(status -> rentalDeletion().create("node", map("name", "owned-detail"), 10)); long ownWallet = tx.execute(status -> rentalDeletion().create("wallet", map("node_id", ownNode, "network", "MAINNET", "address", ADDRESS), 10)); store.update("wallet", ownWallet, map("ownership_challenge", "hidden-challenge", "ownership_signature", "hidden-signature")); Map detail = (Map) controller.nodeDetail(ownNode).get("data"); List> wallets = (List>) detail.get("wallets"); assertEquals(1, wallets.size()); assertEquals(ownWallet, number(wallets.get(0), "id")); assertFalse(wallets.get(0).containsKey("ownership_challenge")); assertFalse(wallets.get(0).containsKey("ownership_signature")); Map result = (Map) controller.appDetail(app).get("data"); Map appDetail = (Map) result.get("app"); assertEquals(time(store.get("app", app, false).get("created_at")).toEpochMilli(), ((Number) appDetail.get("created_at")).longValue()); List> credentials = (List>) result.get("credentials"); assertEquals(1, credentials.size()); assertTrue(credentials.get(0).containsKey("api_key")); assertFalse(credentials.get(0).containsKey("api_secret")); long foreign = store.insert("app", map("user_id", 20, "name", "foreign", "status", "ACTIVE")); expectFailure(() -> controller.appDetail(foreign)); expectFailure(() -> controller.appDetail(Long.MAX_VALUE)); } finally { org.springframework.security.core.context.SecurityContextHolder.clearContext(); } } /** 订单或任意历史凭证均阻止物理删除,无依赖空应用可删除且写审计。 */ @Test public void appDeletionRejectsEveryOrderAndCredentialState() { try { long empty = store.insert("app", map("user_id", 10, "name", "empty", "status", "ACTIVE")); tx.execute(status -> { rentalDeletion().deleteApp(empty, 10L); return null; }); assertNull(store.one("SELECT id FROM rent_app WHERE id=?", empty)); assertEquals(1, store.rows("SELECT id FROM rent_event WHERE object_type='APP' AND object_id=? AND action='DELETE'", empty).size()); long withCredential = store.insert("app", map("user_id", 10, "name", "credential", "status", "ACTIVE")); tx.execute(status -> identity.issue("APP", withCredential, 10)); for (String credentialStatus : Arrays.asList("ACTIVE", "VERIFY_ONLY", "REVOKED")) { store.execute("UPDATE rent_credential SET status=? WHERE owner_type='APP' AND owner_id=?", credentialStatus, withCredential); expectFailure(() -> tx.execute(status -> { rentalDeletion().deleteApp(withCredential, 10L); return null; })); } long withOrder = store.insert("app", map("user_id", 10, "name", "order", "status", "ACTIVE")); Map order = tx.execute(status -> orders.create(withOrder, 10, map("package_id", product, "merchant_order_no", "delete-test", "receiver_address", ADDRESS))); tx.execute(status -> { orders.cancel(number(order, "id"), 10); return null; }); expectFailure(() -> tx.execute(status -> { rentalDeletion().deleteApp(withOrder, 10L); return null; })); long foreign = store.insert("app", map("user_id", 20, "name", "foreign", "status", "ACTIVE")); expectFailure(() -> tx.execute(status -> { rentalDeletion().deleteApp(foreign, 10L); return null; })); } catch (Exception ex) { throw new AssertionError(ex); } } /** 签发响应可用,未使用凭证可删除;有历史或近期调用时拒绝且不影响节点凭证。 */ @Test public void unusedAppCredentialCanBeDeletedButHistoryIsProtected() { Map issued = tx.execute(status -> identity.issue("APP", app, 10)); assertFalse(text(issued, "api_secret").isEmpty()); assertEquals(text(issued, "api_secret"), identity.secret(store.get("credential", number(issued, "id"), false))); long credentialId = number(issued, "id"); expectFailure(() -> tx.execute(status -> identity.deleteAppCredential(credentialId, 20))); assertEquals(Integer.valueOf(1), tx.execute(status -> identity.deleteAppCredential(credentialId, 10))); assertNull(store.one("SELECT id FROM rent_credential WHERE id=?", credentialId)); tx.execute(status -> { rentalDeletion().deleteApp(app, 10L); return null; }); assertNull(store.one("SELECT id FROM rent_app WHERE id=?", app)); long recentApp = store.insert("app", map("user_id", 10, "name", "recent", "status", "ACTIVE")); Map recent = tx.execute(status -> identity.issue("APP", recentApp, 10)); long recentId = number(recent, "id"); store.insert("nonce", map("api_key", text(recent, "api_key"), "scope", "APP", "nonce", "test-nonce", "expires_at", after(180))); expectFailure(() -> tx.execute(status -> identity.deleteAppCredential(recentId, 10))); store.execute("UPDATE rent_nonce SET expires_at=? WHERE api_key=?", after(-1), text(recent, "api_key")); assertEquals(Integer.valueOf(1), tx.execute(status -> identity.deleteAppCredential(recentId, 10))); long historicalApp = store.insert("app", map("user_id", 10, "name", "history", "status", "ACTIVE")); Map historical = tx.execute(status -> identity.issue("APP", historicalApp, 10)); Map order = tx.execute(status -> orders.create(historicalApp, 10, map("package_id", product, "merchant_order_no", "credential-delete", "receiver_address", ADDRESS))); tx.execute(status -> { orders.cancel(number(order, "id"), 10); return null; }); expectFailure(() -> tx.execute(status -> identity.deleteAppCredential(number(historical, "id"), 10))); store.update("node", node, map("connection_status", "OFFLINE")); Map nodeKey = tx.execute(status -> identity.issue("NODE", node, 20)); expectFailure(() -> tx.execute(status -> identity.deleteAppCredential(number(nodeKey, "id"), 20))); } /** 用户默认套餐选择及授权隔离,不受客户端user_id影响。 */ @Test public void userBindingsControlAutomaticAndExplicitOrders() throws Exception { store.execute("CREATE TABLE sys_user(user_id BIGINT PRIMARY KEY,user_name VARCHAR(64),nick_name VARCHAR(64),status CHAR(1),del_flag CHAR(1))"); store.execute("INSERT INTO sys_user VALUES(10,'buyer','buyer','0','0')"); RentalPackageBindings bindings = new RentalPackageBindings(store); Map request = map("merchant_order_no", "AUTO-1", "receiver_address", ADDRESS, "user_id", 20); Map original = tx.execute(status -> orders.create(app, 10, request)); assertEquals(product, number(original, "package_id")); Map snapshot = json.readValue(text(original, "package_snapshot"), Map.class); assertEquals(10L, ((Number) snapshot.get("binding_user_id")).longValue()); assertEquals(1, new RentalQueries(store).list("package", 10L, 1).size()); assertTrue(new RentalQueries(store).list("package", 20L, 1).isEmpty()); Map alternate = new LinkedHashMap<>(store.get("package", product, false)); alternate.remove("id"); alternate.put("package_code", "ALT-TEST"); long alternativeId = store.insert("package", alternate); expectFailure(() -> tx.execute(status -> orders.create(app, 10, map("package_id", alternativeId, "merchant_order_no", "NOT-BOUND", "receiver_address", ADDRESS)))); tx.execute(status -> { bindings.bind(10, alternativeId, true, true, 99); return null; }); Map next = tx.execute(status -> orders.create(app, 10, map("merchant_order_no", "AUTO-2", "receiver_address", ADDRESS))); assertEquals(alternativeId, number(next, "package_id")); assertEquals(number(original, "id"), number(tx.execute(status -> orders.create(app, 10, request)), "id")); assertEquals(1, store.rows("SELECT id FROM rent_user_package WHERE user_id=10 AND default_slot=1").size()); assertEquals(1, store.rows("SELECT id FROM rent_user_package WHERE user_id=10 AND status='ACTIVE'").size()); expectFailure(() -> tx.execute(status -> orders.create(app, 10, map("package_id", product, "merchant_order_no", "OLD-PACKAGE", "receiver_address", ADDRESS)))); tx.execute(status -> { bindings.bind(10, alternativeId, false, false, 99); return null; }); expectFailure(() -> tx.execute(status -> orders.create(app, 10, map("merchant_order_no", "NO-DEFAULT", "receiver_address", ADDRESS)))); expectFailure(() -> tx.execute(status -> orders.create(app, 10, map("package_id", alternativeId, "merchant_order_no", "DISABLED", "receiver_address", ADDRESS)))); expectFailure(() -> tx.execute(status -> { bindings.bind(999, product, true, true, 99); return null; })); assertEquals(number(next, "id"), number(tx.execute(status -> orders.create(app, 10, map("merchant_order_no", "AUTO-2", "receiver_address", ADDRESS))), "id")); } /** 四个分类独立共存、精确选取和幂等重试;同分类替换不影响其他三类。 */ @Test public void networkAndResourceBindingsAreIndependent() throws Exception { store.execute("CREATE TABLE sys_user(user_id BIGINT PRIMARY KEY,status CHAR(1),del_flag CHAR(1))"); store.execute("INSERT INTO sys_user VALUES(10,'0','0')"); RentalPackageBindings bindings = new RentalPackageBindings(store); Map retry = map("merchant_order_no", "SCOPE-ORIGINAL", "receiver_address", ADDRESS); Map original = tx.execute(status -> orders.create(app, 10, retry)); long bandwidth = scopedProduct("NILE", "BANDWIDTH", "SCOPE-NB"); long mainEnergy = scopedProduct("MAINNET", "ENERGY", "SCOPE-ME"); long mainBandwidth = scopedProduct("MAINNET", "BANDWIDTH", "SCOPE-MB"); for (long id : new long[] {bandwidth, mainEnergy, mainBandwidth}) { tx.execute(status -> { bindings.bind(10, id, true, true, 99); return null; }); } assertEquals(4, store.rows("SELECT id FROM rent_user_package WHERE user_id=10 AND default_slot=1").size()); RentalDashboard dashboard = new RentalDashboard(store); assertEquals(2, ((List) dashboard.overview(10, "account", "NILE", 7).get("packages")).size()); assertEquals(2, ((List) dashboard.overview(10, "account", "MAINNET", 7).get("packages")).size()); assertTrue(((List) dashboard.overview(20, "account", "NILE", 7).get("packages")).isEmpty()); assertEquals(mainEnergy, number(RentalPackageBindings.resolve(store, 10, map("network", "MAINNET", "resource_type", "ENERGY"), false), "id")); assertEquals(bandwidth, number(RentalPackageBindings.resolve(store, 10, map("package_id", bandwidth, "network", "NILE", "resource_type", "BANDWIDTH"), false), "id")); expectFailure(() -> RentalPackageBindings.resolve(store, 10, map(), false)); expectFailure(() -> RentalPackageBindings.resolve(store, 10, map("network", "NILE"), false)); expectFailure(() -> RentalPackageBindings.resolve(store, 10, map("package_id", product, "network", "MAINNET"), false)); expectFailure(() -> RentalPackageBindings.resolve(store, 20, map("package_id", product), false)); expectFailure(() -> tx.execute(status -> orders.create(app, 10, map("merchant_order_no", "AMBIGUOUS", "receiver_address", ADDRESS)))); Map scoped = tx.execute(status -> orders.create(app, 10, map("network", "NILE", "resource_type", "BANDWIDTH", "merchant_order_no", "SCOPED", "receiver_address", ADDRESS))); assertEquals(bandwidth, number(scoped, "package_id")); long replacement = scopedProduct("NILE", "ENERGY", "SCOPE-NEW"); tx.execute(status -> { bindings.bind(10, replacement, true, true, 99); return null; }); assertEquals(4, store.rows("SELECT id FROM rent_user_package WHERE user_id=10 AND default_slot=1").size()); assertEquals(number(original, "id"), number(tx.execute(status -> orders.create(app, 10, retry)), "id")); expectFailure(() -> tx.execute(status -> orders.create(app, 10, map("merchant_order_no", "SCOPE-ORIGINAL", "receiver_address", ADDRESS, "network", "MAINNET")))); tx.execute(status -> { bindings.bind(10, replacement, false, false, 99); return null; }); expectFailure(() -> RentalPackageBindings.resolve(store, 10, map("network", "NILE", "resource_type", "ENERGY"), false)); assertEquals(bandwidth, number(RentalPackageBindings.resolve(store, 10, map("network", "NILE"), false), "id")); } /** 签名API按分类筛选,报价与实际下单使用完全相同的选择规则。 */ @Test @SuppressWarnings("unchecked") public void scopedMerchantPackagesQuoteAndCreateAgree() throws Exception { long bandwidth = scopedProduct("NILE", "BANDWIDTH", "API-BANDWIDTH"); store.insert("user_package", map("user_id", 10, "package_id", bandwidth, "network", "NILE", "resource_type", "BANDWIDTH", "status", "ACTIVE", "default_slot", 1, "created_by", 99)); Map credential = tx.execute(status -> identity.issue("APP", app, 10)); String key = text(credential, "api_key"), secret = text(credential, "api_secret"); RentalApiController api = new RentalApiController(identity, store, orders, json); List> products = (List>) api.execute("packages", signedRequest("/api/rental/v1/packages", "{\"network\":\"NILE\"}", key, secret, "API")).get("data"); assertEquals(2, products.size()); List> filtered = (List>) api.execute("packages", signedRequest("/api/rental/v1/packages", "{\"network\":\"NILE\",\"resource_type\":\"BANDWIDTH\"}", key, secret, "API")).get("data"); assertEquals(1, filtered.size()); assertEquals(bandwidth, number(filtered.get(0), "id")); Map request = map("network", "NILE", "resource_type", "BANDWIDTH", "receiver_address", ADDRESS, "merchant_order_no", "API-SCOPE"); Map quote = (Map) api.execute("quote", signedRequest("/api/rental/v1/quote", json.writeValueAsString(request), key, secret, "API")).get("data"); assertEquals(bandwidth, number(quote, "package_id")); assertEquals("BANDWIDTH", text(quote, "resource_type")); request.put("expected_amount", quote.get("amount")); Map order = tx.execute(status -> orders.create(app, 10, request)); assertEquals(bandwidth, number(order, "package_id")); assertEquals(amount(quote, "amount"), amount(order, "sale_amount")); request.remove("resource_type"); expectFailure(() -> { try { api.execute("quote", signedRequest("/api/rental/v1/quote", json.writeValueAsString(request), key, secret, "API")); } catch (Exception ex) { throw new IllegalArgumentException(ex); } }); } /** 对外请求禁止套餐ID,分类均必填;更换绑定后原单仍按历史快照幂等。 */ @Test public void resourceOnlyEntryRejectsPackageIdsAndRequiresBothSelectors() throws Exception { Map credential = tx.execute(status -> identity.issue("APP", app, 10)); String key = text(credential, "api_key"), secret = text(credential, "api_secret"); RentalApiController api = new RentalApiController(identity, store, orders, json); Map valid = map("network", "NILE", "resource_type", "ENERGY", "receiver_address", ADDRESS, "merchant_order_no", "RESOURCE-ONLY"); List> invalidRequests = new ArrayList<>(); for (String missing : Arrays.asList("network", "resource_type")) { Map invalid = new LinkedHashMap<>(valid); invalid.remove(missing); invalidRequests.add(invalid); } for (Object id : Arrays.asList(product, "", "99999")) { Map invalid = new LinkedHashMap<>(valid); invalid.put("package_id", id); invalidRequests.add(invalid); } Map unknown = new LinkedHashMap<>(valid); unknown.put("resource_type", "BANDWIDTH"); invalidRequests.add(unknown); for (Map invalid : invalidRequests) { expectFailure(() -> tx.execute(status -> orders.createByResource(app, 10, invalid))); for (String operation : Arrays.asList("quote", "create")) { expectFailure(() -> { try { tx.execute(status -> { try { return api.execute(operation, signedRequest("/api/rental/v1/" + operation, json.writeValueAsString(invalid), key, secret, "API")); } catch (Exception ex) { throw new IllegalArgumentException(ex); } }); } catch (Exception ex) { throw new IllegalArgumentException(ex); } }); } } assertEquals(0, store.rows("SELECT id FROM rent_order").size()); assertEquals(money("100"), amount(store.get("account", payer, false), "available_amount")); Map original = tx.execute(status -> orders.createByResource(app, 10, valid)); store.execute("CREATE TABLE sys_user(user_id BIGINT PRIMARY KEY,status CHAR(1),del_flag CHAR(1))"); store.execute("INSERT INTO sys_user VALUES(10,'0','0')"); long replacement = scopedProduct("NILE", "ENERGY", "REPLACED-RESOURCE-ONLY"); tx.execute(status -> { new RentalPackageBindings(store).bind(10, replacement, true, true, 99); return null; }); Map retried = tx.execute(status -> orders.createByResource(app, 10, valid)); assertEquals(number(original, "id"), number(retried, "id")); assertEquals(product, number(retried, "package_id")); assertEquals(money("90"), amount(store.get("account", payer, false), "available_amount")); Map changed = new LinkedHashMap<>(valid); changed.put("network", "MAINNET"); expectFailure(() -> tx.execute(status -> orders.createByResource(app, 10, changed))); changed.put("network", "NILE"); changed.put("resource_type", "BANDWIDTH"); expectFailure(() -> tx.execute(status -> orders.createByResource(app, 10, changed))); } /** 数据库分类唯一键为并发与绕过服务写入提供最后一道保护。 */ @Test public void scopedBindingUniquenessAndConcurrentReplacement() throws Exception { store.execute("CREATE TABLE sys_user(user_id BIGINT PRIMARY KEY,status CHAR(1),del_flag CHAR(1))"); store.execute("INSERT INTO sys_user VALUES(10,'0','0')"); long first = scopedProduct("NILE", "ENERGY", "CONCURRENT-1"); long second = scopedProduct("NILE", "ENERGY", "CONCURRENT-2"); try { store.insert("user_package", map("user_id", 10, "package_id", first, "network", "NILE", "resource_type", "ENERGY", "status", "ACTIVE", "default_slot", 1, "created_by", 99)); fail("same scope must be unique"); } catch (org.springframework.dao.DuplicateKeyException expected) { /* 唯一键按预期拒绝。 */ } RentalPackageBindings bindings = new RentalPackageBindings(store); ExecutorService executor = Executors.newFixedThreadPool(2); CountDownLatch start = new CountDownLatch(1); try { List> futures = new ArrayList<>(); for (long id : new long[] {first, second}) { futures.add(executor.submit(() -> { try { start.await(); } catch (InterruptedException ex) { Thread.currentThread().interrupt(); throw new IllegalStateException(ex); } tx.execute(status -> { bindings.bind(10, id, true, true, 99); return null; }); })); } start.countDown(); for (Future future : futures) { future.get(15, TimeUnit.SECONDS); } assertEquals(1, store.rows("SELECT id FROM rent_user_package WHERE user_id=10 AND default_slot=1").size()); } finally { executor.shutdownNow(); } } private long scopedProduct(String network, String resourceType, String code) { Map copy = new LinkedHashMap<>(store.get("package", product, false)); copy.remove("id"); copy.put("network", network); copy.put("resource_type", resourceType); copy.put("package_code", code); return store.insert("package", copy); } /** 直接验证交付脚本中的三套餐INSERT及重复执行,不连接真实MySQL。 */ @Test public void seedScriptCreatesThreeValidPackagesIdempotently() throws Exception { String script = new String(Files.readAllBytes(Paths.get("../sql/rent_seed_three_packages.sql")), StandardCharsets.UTF_8); int start = script.indexOf("INSERT INTO rent_package("); String insert = script.substring(start, script.indexOf(';', start)) .replace("JSON_OBJECT('refund','MANUAL_REVIEW','delegate_lock',FALSE)", "'{\"refund\":\"MANUAL_REVIEW\",\"delegate_lock\":false}'") .replace("UTC_TIMESTAMP(3)", "CURRENT_TIMESTAMP"); store.execute(insert); store.execute(insert); List> products = store.rows("SELECT * FROM rent_package WHERE package_code LIKE 'DEMO_%'"); assertEquals(3, products.size()); for (Map seeded : products) { RentalOrders.validatePackage(seeded); assertEquals("NILE", text(seeded, "network")); } } private RentalProvisioning rentalDeletion() { return new RentalProvisioning(store, orders); } @Before public void setup() throws Exception { JdbcDataSource source = new JdbcDataSource(); source.setURL( "jdbc:h2:mem:" + UUID.randomUUID() + ";MODE=MySQL;DATABASE_TO_UPPER=false;DB_CLOSE_DELAY=-1;LOCK_TIMEOUT=10000"); JdbcTemplate jdbc = new JdbcTemplate(source); store = new RentalStore(jdbc); // 仅替换H2不支持的存储/字符集/JSON声明,保留16表字段、唯一键及事务SQL。 String ddl = new String( Files.readAllBytes(Paths.get("../sql/rent_init.sql")), StandardCharsets.UTF_8) .replaceAll("(?m)^--.*$", "") .replaceAll("CHARACTER SET ascii COLLATE ascii_bin", "") .replaceAll("(?i)\\bJSON\\b", "LONGTEXT") .replaceAll( "ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4" + " COLLATE=utf8mb4_bin", ""); for (String sql : ddl.split(";")) { if (!sql.trim().isEmpty()) { jdbc.execute(sql); } } tx = new TransactionTemplate(new DataSourceTransactionManager(source)); funds = new RentalFunds(store); orders = new RentalOrders(store, funds, json); RentalOnchain onchain = new RentalOnchain(); org.springframework.core.env.StandardEnvironment environment = new org.springframework.core.env.StandardEnvironment(); environment.getPropertySources().addFirst(new org.springframework.core.env.MapPropertySource("onchain-test", map( "rental.address-onchain.enabled", "true", "rental.address-onchain.nile.trx-price-usdt", "0.1234567", "rental.address-onchain.nile.service-fee-usdt", "0.05", "rental.address-onchain.nile.fee-limit-sun", "3000000", "rental.address-onchain.nile.platform-fee-percent", "20"))); java.lang.reflect.Field envField = RentalOnchain.class.getDeclaredField("environment"); envField.setAccessible(true); envField.set(onchain, environment); java.lang.reflect.Field activationField = RentalOnchain.class.getDeclaredField("chain"); activationField.setAccessible(true); activationField.set(onchain, new RentalChain(json) { @Override public com.fasterxml.jackson.databind.JsonNode call(String network, String path, Map body) { assertEquals("/wallet/getaccount", path); assertEquals("NILE", network); activationChecks++; if (activationRpcFailed) { throw new IllegalStateException("controlled RPC failure"); } return json.valueToTree(receiverActivated ? map("address", ADDRESS, "balance", 0) : map()); } }); java.lang.reflect.Field onchainField = RentalOrders.class.getDeclaredField("onchain"); onchainField.setAccessible(true); onchainField.set(orders, onchain); reviews = new RentalReviews(store, funds, orders); RentalCrypto crypto = new RentalCrypto(); java.lang.reflect.Field field = RentalCrypto.class.getDeclaredField("masterKey"); field.setAccessible(true); field.set(crypto, Base64.getEncoder().encodeToString(new byte[32])); identity = new RentalIdentity(store, crypto); payer = number(funds.account(10, "NILE"), "id"); supplier = number(funds.account(20, "NILE"), "id"); tx.execute( status -> { funds.post( payer, "TOPUP:NILE:fixture:0", "TOPUP", money("100"), ZERO, ZERO, ZERO, null, null, null, 99, "fixture", "隔离测试充值"); return null; }); app = store.insert("app", map("user_id", 10, "name", "test", "status", "ACTIVE")); node = store.insert( "node", map( "user_id", 20, "node_no", "NODE-TEST", "name", "test", "agent_version", "1", "status", "ACTIVE", "created_by", 20, "connection_status", "ONLINE", "heartbeat_expires_at", after(60))); // 先离线签发,再模拟 Agent 上线,遵循实际节点生命周期。 store.update("node", node, map("connection_status", "OFFLINE")); identity.issue("NODE", node, 20); store.update("node", node, map("connection_status", "ONLINE")); product = store.insert( "package", map( "package_code", "E", "revision", 1, "name", "energy", "network", "NILE", "resource_type", "ENERGY", "resource_quantity", 65000, "redundancy_percent", "20", "duration_seconds", 3600, "sale_amount", money("10"), "supplier_amount", money("8"), "supplier_fee_percent", "5", "fee_limit_sun", 1000000, "delegate_lock", 0, "rules", "{}", "status", "ACTIVE")); store.insert("user_package", map("user_id", 10, "package_id", product, "network", "NILE", "resource_type", "ENERGY", "status", "ACTIVE", "default_slot", 1, "created_by", 99)); wallet = store.insert( "wallet", map( "node_id", node, "network", "NILE", "address", OWNER, "status", "ACTIVE", "ownership_verified_at", now(), "energy_enabled", 1, "bandwidth_enabled", 1, "energy_delegatable_sun", 9000000000L, "bandwidth_delegatable_sun", 9000000000L, "total_energy_limit", 60000000, "total_energy_weight", 1000000, "total_bandwidth_limit", 1500000, "total_bandwidth_weight", 1000000, "snapshot_block_height", 100, "snapshot_at", now(), "snapshot_expires_at", after(60))); RentalChain chain = new RentalChain(json) { @Override public com.fasterxml.jackson.databind.JsonNode call(String network, String path, Map body) { return json.valueToTree(map("balance", supplierBalanceSun)); } @Override public long relation( String network, String owner, String receiver, String type) { return 0; } @Override public Map snapshot(String network, String address) { return map( "snapshot_block_height", 200, "energy_delegatable_sun", 9000000000L, "bandwidth_delegatable_sun", 9000000000L, "total_energy_limit", 60000000, "total_energy_weight", 1000000, "total_bandwidth_limit", 1500000, "total_bandwidth_weight", 1000000, "energy_available", 100000, "bandwidth_available", 10000, "snapshot_at", now(), "snapshot_expires_at", after(60)); } @Override public Map verify( Map task, String tx, String owner, String receiver) { return map( "status", "CONFIRMED", "block_height", 101, "block_time", now().minusSeconds(verificationBlockAgeSeconds), "after_sun", "DELEGATE".equals(text(task, "task_type")) ? task.get("delegate_sun") : 0, "verified_total_limit", 60000000, "verified_total_weight", 1000000, "verified_resource_quantity", verifiedResourceQuantity, "delivery_proven", proofAvailable); } }; tasks = new RentalTasks( store, chain, identity, orders, funds, new DataSourceTransactionManager(source)); } @Test public void onchainFreezesExactlyOnceAndDoesNotRequirePackage() { store.execute("DELETE FROM rent_user_package WHERE user_id=10"); Map request = onchainRequest("onchain-idempotent"); Map order = tx.execute(status -> orders.create(app, 10, request)); assertNull(order.get("package_id")); assertEquals(1000000L, number(order, "transfer_sun")); assertEquals(money("0.173457"), amount(order, "sale_amount")); assertEquals(money("0.010000"), amount(order, "supplier_fee_amount")); assertEquals(money("0.163457"), amount(order, "supplier_net_amount")); assertEquals(money("99.826543"), amount(store.get("account", payer, false), "available_amount")); // 修改当前配置不重算已下单分账,也不会阻碍同商户单号的幂等恢复。 try { java.lang.reflect.Field onchainField = RentalOrders.class.getDeclaredField("onchain"); onchainField.setAccessible(true); java.lang.reflect.Field envField = RentalOnchain.class.getDeclaredField("environment"); envField.setAccessible(true); org.springframework.core.env.StandardEnvironment env = (org.springframework.core.env.StandardEnvironment) envField.get(onchainField.get(orders)); env.getPropertySources().addFirst(new org.springframework.core.env.MapPropertySource("changed", map("rental.address-onchain.nile.platform-fee-percent", "80"))); } catch (ReflectiveOperationException ex) { throw new AssertionError(ex); } assertEquals(number(order, "id"), number(tx.execute(status -> orders.create(app, 10, request)), "id")); assertEquals(money("0.010000"), amount(tx.execute(status -> orders.create(app, 10, request)), "supplier_fee_amount")); assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='HOLD'").size()); request.put("receiver_address", OWNER); expectFailure(() -> tx.execute(status -> orders.create(app, 10, request))); } @Test public void onchainDispatchDoesNotRequireStakeSnapshotAndStillVerifiesTransfer() { store.update("node", node, map("transfer_enabled", 1)); store.update("wallet", wallet, map("snapshot_block_height", null, "snapshot_at", null, "snapshot_expires_at", null, "energy_enabled", 0, "bandwidth_enabled", 0)); long id = number(tx.execute(status -> orders.create(app, 10, onchainRequest("onchain-no-snapshot"))), "id"); tasks.dispatch(id); tasks.dispatch(id); Map task = store.one("SELECT * FROM rent_task WHERE order_id=?", id); assertNotNull(task); assertEquals("TRANSFER_TRX", text(task, "task_type")); assertEquals(0L, number(task, "conversion_block_height")); assertEquals(1, store.rows("SELECT id FROM rent_task WHERE order_id=?", id).size()); tasks.report(node, map("task_no", task.get("task_no"), "event_id", "no-snapshot-built", "state", "BUILT", "tx_id", String.join("", Collections.nCopies(64, "d")))); tasks.verify(number(task, "id")); assertEquals("SUCCESS", text(store.get("order", id, false), "status")); assertEquals("CHARGED", text(store.get("order", id, false), "fund_status")); } @Test public void onchainAcceptsExpiredSnapshotButResourceRentalStillWaits() { store.update("node", node, map("transfer_enabled", 1)); store.update("wallet", wallet, map("snapshot_expires_at", after(-60))); long rentalId = number(create("resource-expired-snapshot"), "id"); tasks.dispatch(rentalId); assertNull(store.one("SELECT id FROM rent_task WHERE order_id=?", rentalId)); long transferId = number(tx.execute(status -> orders.create(app, 10, onchainRequest("onchain-expired-snapshot"))), "id"); tasks.dispatch(transferId); assertNotNull(store.one("SELECT id FROM rent_task WHERE order_id=?", transferId)); } @Test public void onchainWithoutSnapshotStillRequiresVerifiedOnlineAuthorizedWalletAndBalance() { store.update("node", node, map("transfer_enabled", 1)); store.update("wallet", wallet, map("snapshot_expires_at", null)); long id = number(tx.execute(status -> orders.create(app, 10, onchainRequest("onchain-guards"))), "id"); store.update("wallet", wallet, map("ownership_verified_at", null)); tasks.dispatch(id); assertNull(store.one("SELECT id FROM rent_task WHERE order_id=?", id)); store.update("wallet", wallet, map("ownership_verified_at", now(), "network", "MAINNET")); tasks.dispatch(id); assertNull(store.one("SELECT id FROM rent_task WHERE order_id=?", id)); store.update("wallet", wallet, map("network", "NILE")); store.update("node", node, map("connection_status", "OFFLINE")); tasks.dispatch(id); assertNull(store.one("SELECT id FROM rent_task WHERE order_id=?", id)); store.update("node", node, map("connection_status", "ONLINE", "heartbeat_expires_at", after(-60))); tasks.dispatch(id); assertNull(store.one("SELECT id FROM rent_task WHERE order_id=?", id)); store.update("node", node, map("heartbeat_expires_at", after(300), "transfer_enabled", 0)); tasks.dispatch(id); assertNull(store.one("SELECT id FROM rent_task WHERE order_id=?", id)); store.update("node", node, map("transfer_enabled", 1)); supplierBalanceSun = 3999999L; tasks.dispatch(id); assertNull(store.one("SELECT id FROM rent_task WHERE order_id=?", id)); assertEquals("HELD", text(store.get("order", id, false), "fund_status")); supplierBalanceSun = 4000000L; tasks.dispatch(id); assertNotNull(store.one("SELECT id FROM rent_task WHERE order_id=?", id)); } @Test public void onchainRequiresCapableNodeAndChargesOnlyAfterIndependentProof() { Map order = tx.execute(status -> orders.create(app, 10, onchainRequest("onchain-success"))); long orderId = number(order, "id"); tasks.dispatch(orderId); assertNull(store.one("SELECT id FROM rent_task WHERE order_id=?", orderId)); store.execute("UPDATE rent_node SET transfer_enabled=1 WHERE id=?", node); tasks.dispatch(orderId); Map task = store.one("SELECT * FROM rent_task WHERE order_id=?", orderId); assertEquals("TRANSFER_TRX", text(task, "task_type")); assertEquals(0, number(store.get("wallet", wallet, false), "energy_reserved_sun")); tasks.report(node, map("task_no", task.get("task_no"), "event_id", "onchain-built", "state", "BUILT", "tx_id", String.join("", Collections.nCopies(64, "c")))); expectFailure(() -> tasks.report(node, map("task_no", task.get("task_no"), "event_id", "invalid-reject", "state", "REJECTED"))); assertEquals("HELD", text(store.get("order", orderId, false), "fund_status")); tasks.verify(number(task, "id")); tasks.verify(number(task, "id")); Map completed = store.get("order", orderId, false); assertEquals("SUCCESS", text(completed, "status")); assertEquals("NOT_REQUIRED", text(completed, "reclaim_status")); assertEquals("CHARGED", text(completed, "fund_status")); assertEquals(String.join("", Collections.nCopies(64, "c")), orders.confirmedTransferId(completed)); assertEquals(money("0.163457"), amount(store.get("account", supplier, false), "supplier_pending_amount")); assertEquals(money("0.010000"), amount(store.one("SELECT SUM(delta_platform_fee) AS fee FROM rent_ledger WHERE order_id=?", orderId), "fee")); assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE order_id=? AND event_type='SUPPLIER_FEE'", orderId).size()); assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='CHARGE'").size()); long settlement = tx.execute(status -> reviews.settlement(Collections.singletonList(orderId), 99)); assertEquals(money("0.163457"), amount(store.get("settlement", settlement, false), "amount")); } @Test public void onchainUnknownDoesNotReleaseOrRedispatchAndDefiniteRejectCanRelease() { store.execute("UPDATE rent_node SET transfer_enabled=1 WHERE id=?", node); Map order = tx.execute(status -> orders.create(app, 10, onchainRequest("onchain-unknown"))); long orderId = number(order, "id"); tasks.dispatch(orderId); Map task = store.one("SELECT * FROM rent_task WHERE order_id=?", orderId); tasks.report(node, map("task_no", task.get("task_no"), "event_id", "unknown", "state", "UNKNOWN")); store.execute("UPDATE rent_order SET dispatch_deadline=? WHERE id=?", now().minusSeconds(60), orderId); tasks.dispatch(orderId); assertEquals("HELD", text(store.get("order", orderId, false), "fund_status")); assertEquals(1, store.rows("SELECT id FROM rent_task WHERE order_id=?", orderId).size()); tasks.report(node, map("task_no", task.get("task_no"), "event_id", "rejected", "state", "REJECTED")); assertEquals("RELEASED", text(store.get("order", orderId, false), "fund_status")); assertEquals(money("100"), amount(store.get("account", payer, false), "available_amount")); assertEquals(0, store.rows("SELECT id FROM rent_ledger WHERE order_id=? AND event_type='SUPPLIER_FEE'", orderId).size()); } @Test public void onchainRejectsActivatedOrUnknownWithoutOrderOrFrozenFunds() { BigDecimal before = amount(store.get("account", payer, false), "available_amount"); for (boolean active : new boolean[] {true, false}) { receiverActivated = active; activationRpcFailed = !active; try { tx.execute(status -> orders.create(app, 10, onchainRequest("activation-reject"))); fail("已激活或状态未知不允许创建"); } catch (IllegalArgumentException | IllegalStateException expected) { /* 保持余额且无新订单 */ } assertEquals(before, amount(store.get("account", payer, false), "available_amount")); assertEquals(ZERO, amount(store.get("account", payer, false), "frozen_amount")); assertTrue(store.rows("SELECT id FROM rent_order WHERE merchant_order_no='activation-reject'").isEmpty()); } } @Test public void onchainIdempotentRetryStillWorksAfterReceiverActivated() { Map request = onchainRequest("activation-idempotent"); Map original = tx.execute(status -> orders.create(app, 10, request)); receiverActivated = true; Map retry = tx.execute(status -> orders.create(app, 10, request)); assertEquals(number(original, "id"), number(retry, "id")); assertEquals(1, activationChecks); } private Map onchainRequest(String merchant) { return map("order_type", "ADDRESS_ONCHAIN", "network", "NILE", "merchant_order_no", merchant, "receiver_address", ADDRESS, "expected_amount", "0.173457"); } @Test public void extendedDurationHoldsQuotedFundsAndRetryDoesNotChargeAgain() { Map request = map("package_id", product, "merchant_order_no", "LONG-RENT", "receiver_address", ADDRESS, "duration_seconds", 7200, "expected_amount", "20.000000"); Map order = tx.execute(status -> orders.create(app, 10, request)); assertEquals(7200, number(order, "duration_seconds")); assertEquals(money("20"), amount(order, "sale_amount")); assertEquals(money("16"), amount(order, "supplier_amount")); assertEquals(money("80"), amount(store.get("account", payer, false), "available_amount")); assertEquals(number(order, "id"), number(tx.execute(status -> orders.create(app, 10, request)), "id")); assertEquals(money("20"), amount(store.get("account", payer, false), "frozen_amount")); request.put("duration_seconds", 3600); expectFailure(() -> tx.execute(status -> orders.create(app, 10, request))); request.put("merchant_order_no", "PRICE-CHANGED"); expectFailure(() -> tx.execute(status -> orders.create(app, 10, request))); assertEquals(money("80"), amount(store.get("account", payer, false), "available_amount")); } @Test public void callbackDemoPersistsBeforeAckDeduplicatesAndRecoversAsyncInbox() throws Exception { store.execute("CREATE TABLE rent_callback_demo_inbox(event_no VARCHAR(64) PRIMARY KEY," + "order_no VARCHAR(64),event_type VARCHAR(64),body_hash VARCHAR(64)," + "processed INT,created_at TIMESTAMP)"); RentalCallbackDemoController controller = new RentalCallbackDemoController(store, json, tx.getTransactionManager()); for (String fieldName : Arrays.asList("apiKey", "apiSecret")) { java.lang.reflect.Field field = RentalCallbackDemoController.class.getDeclaredField(fieldName); field.setAccessible(true); field.set(controller, fieldName.equals("apiKey") ? "RKdemo" : "test-secret"); } String body = "{\"event_no\":\"WH-DEMO\",\"order_no\":\"RO-DEMO\",\"event_type\":\"DELIVERED\"}"; assertEquals("ok", controller.async(demoRequest("async", body, "test-secret")).getBody()); assertEquals(0, number(store.one("SELECT * FROM rent_callback_demo_inbox"), "processed")); // 模拟进程重启后由持久化扫描恢复,无需内存队列。 controller.consume(); assertEquals(1, number(store.one("SELECT * FROM rent_callback_demo_inbox"), "processed")); assertEquals("ok", controller.async(demoRequest("async", body, "test-secret")).getBody()); assertEquals(1, store.rows("SELECT * FROM rent_callback_demo_inbox").size()); assertEquals(400, controller.sync(demoRequest("sync", body, "wrong-secret")).getStatusCodeValue()); String second = body.replace("WH-DEMO", "WH-SYNC"); assertEquals("ok", controller.sync(demoRequest("sync", second, "test-secret")).getBody()); assertEquals(1, number(store.one("SELECT * FROM rent_callback_demo_inbox WHERE event_no='WH-SYNC'"), "processed")); assertEquals(503, controller.sync(demoRequest("sync", body.replace("DELIVERED", "CANCELLED"), "test-secret")).getStatusCodeValue()); } @Test @SuppressWarnings("unchecked") public void signedMerchantQuoteAndCreateWorkWithoutBackendLogin() throws Exception { Map credential = tx.execute(status -> identity.issue("APP", app, 10)); String key = text(credential, "api_key"), secret = text(credential, "api_secret"); RentalApiController controller = new RentalApiController(identity, store, orders, json); Map data = map("network", "NILE", "resource_type", "ENERGY", "merchant_order_no", "API-RENT", "duration_seconds", 7200, "receiver_address", ADDRESS); Map quote = (Map) controller.execute("quote", signedRequest("/api/rental/v1/quote", json.writeValueAsString(data), key, secret, "API")).get("data"); assertEquals("20.000000", quote.get("amount")); assertEquals(money("100"), amount(store.get("account", payer, false), "available_amount")); data.put("expected_amount", quote.get("amount")); String body = json.writeValueAsString(data); Map result = (Map) tx.execute(status -> { try { return controller.execute("create", signedRequest("/api/rental/v1/create", body, key, secret, "API")); } catch (Exception exception) { throw new IllegalArgumentException(exception); } }).get("data"); assertEquals(7200, number(result, "duration_seconds")); assertEquals(money("20"), amount(result, "amount")); assertEquals(money("80"), amount(store.get("account", payer, false), "available_amount")); } /** 独立接口沿用真实APP验签与账务事务,拒绝跨订单类型调用。 */ @Test @SuppressWarnings("unchecked") public void independentOnchainApiAuthenticatesActualPathAndIsolatesTypes() throws Exception { Map credential = tx.execute(status -> identity.issue("APP", app, 10)); String key = text(credential, "api_key"), secret = text(credential, "api_secret"); RentalApiController controller = new RentalApiController(identity, store, orders, json); java.lang.reflect.Field field = RentalApiController.class.getDeclaredField("onchain"); field.setAccessible(true); java.lang.reflect.Field serviceField = RentalOrders.class.getDeclaredField("onchain"); serviceField.setAccessible(true); field.set(controller, serviceField.get(orders)); String prefix = "/api/rental/v1/address-onchain/"; Map data = onchainRequest("API-ONCHAIN"); data.remove("order_type"); String body = json.writeValueAsString(data); Map quote = (Map) controller.executeOnchain("quote", signedRequest(prefix + "quote", body, key, secret, "API")).get("data"); assertEquals("0.173457", quote.get("amount")); assertFalse(quote.containsKey("supplier_fee_amount")); javax.servlet.http.HttpServletRequest oldSignature = signedRequest( "/api/rental/v1/quote", body, key, secret, "API"); javax.servlet.http.HttpServletRequest newPathWithOldSignature = (javax.servlet.http.HttpServletRequest) java.lang.reflect.Proxy.newProxyInstance( getClass().getClassLoader(), new Class[] {javax.servlet.http.HttpServletRequest.class}, (proxy, method, args) -> "getRequestURI".equals(method.getName()) ? prefix + "quote" : method.invoke(oldSignature, args)); try { controller.executeOnchain("quote", newPathWithOldSignature); fail("新路由不能复用旧路径签名"); } catch (IllegalArgumentException expected) { /* HMAC包含实际完整URI */ } Map created = (Map) tx.execute(status -> { try { return controller.executeOnchain("create", signedRequest(prefix + "create", body, key, secret, "API")); } catch (Exception ex) { throw new IllegalArgumentException(ex); } }).get("data"); assertEquals("ADDRESS_ONCHAIN", text(created, "order_type")); String queryBody = json.writeValueAsString(map("merchant_order_no", "API-ONCHAIN")); Map queried = (Map) controller.executeOnchain("query", signedRequest(prefix + "query", queryBody, key, secret, "API")).get("data"); assertEquals(text(created, "order_no"), text(queried, "order_no")); try { controller.execute("query", signedRequest("/api/rental/v1/query", queryBody, key, secret, "API")); fail("资源接口不能查询地址上链订单"); } catch (IllegalArgumentException expected) { /* 类型隔离 */ } data.put("order_type", "ADDRESS_ONCHAIN"); try { controller.execute("create", signedRequest("/api/rental/v1/create", json.writeValueAsString(data), key, secret, "API")); fail("旧资源接口不得创建地址上链订单"); } catch (IllegalArgumentException expected) { /* 不保留混用入口 */ } data.put("order_type", "RESOURCE_RENTAL"); try { controller.executeOnchain("create", signedRequest(prefix + "create", json.writeValueAsString(data), key, secret, "API")); fail("地址上链接口不得创建资源订单"); } catch (IllegalArgumentException expected) { /* 类型不允许覆盖 */ } } /** 经过生产可重复读过滤器再验签,防止格式化JSON的LF/CRLF被全局过滤器删除。 */ @Test public void formattedPackagesRequestSurvivesRepeatableFilterAndAuthenticates() throws Exception { Map credential = tx.execute(status -> identity.issue("APP", app, 10)); RentalApiController api = new RentalApiController(identity, store, orders, json); for (String body : new String[] {"{\n \"network\": \"NILE\"\n}", " \r\n{\r\n \"network\": \"NILE\",\r\n \"note\": \"中文调试\"\r\n}\r\n "}) { javax.servlet.http.HttpServletRequest signed = signedRequest("/api/rental/v1/packages", body, text(credential, "api_key"), text(credential, "api_secret"), "API"); javax.servlet.http.HttpServletRequest input = new javax.servlet.http.HttpServletRequestWrapper(signed) { @Override public String getContentType() { return "application/json;charset=UTF-8"; } }; javax.servlet.ServletResponse response = (javax.servlet.ServletResponse) java.lang.reflect.Proxy.newProxyInstance( getClass().getClassLoader(), new Class[] {javax.servlet.ServletResponse.class}, (proxy, method, args) -> null); new com.ruoyi.common.filter.RepeatableFilter().doFilter(input, response, (filtered, ignored) -> { try { javax.servlet.http.HttpServletRequest actual = (javax.servlet.http.HttpServletRequest) filtered; assertTrue(actual instanceof com.ruoyi.common.filter.RepeatedlyRequestWrapper); javax.servlet.ServletInputStream stream = actual.getInputStream(); assertFalse(stream.isFinished()); assertArrayEquals(body.getBytes(StandardCharsets.UTF_8), org.apache.commons.io.IOUtils.toByteArray(stream)); assertTrue(stream.isFinished()); assertEquals(0, stream.available()); assertEquals(body, org.apache.commons.io.IOUtils.toString(actual.getReader())); assertEquals(200, api.execute("packages", actual).get("code")); } catch (Exception ex) { throw new javax.servlet.ServletException(ex); } }); } } /** Servlet代理保留原始字节,无需启动真实HTTP端口。 */ private javax.servlet.http.HttpServletRequest demoRequest(String operation, String body, String secret) { return signedRequest("/api/rental/v1/demo/callback/" + operation, body, "RKdemo", secret, "WEBHOOK"); } private javax.servlet.http.HttpServletRequest signedRequest(String path, String body, String key, String secret, String scope) { String nonce = RentalCrypto.random(); long timestamp = System.currentTimeMillis(); Map headers = map("X-Rent-Key", key, "X-Rent-Timestamp", Long.toString(timestamp), "X-Rent-Nonce", nonce, "X-Rent-Signature", RentalCrypto.sign(secret, scope, key, timestamp, nonce, "POST", path, body)); return (javax.servlet.http.HttpServletRequest) java.lang.reflect.Proxy.newProxyInstance( getClass().getClassLoader(), new Class[] {javax.servlet.http.HttpServletRequest.class}, (proxy, method, args) -> { if ("getHeader".equals(method.getName())) { return headers.get(args[0]); } if ("getRequestURI".equals(method.getName())) { return path; } if ("getInputStream".equals(method.getName())) { // 模拟生产RepeatedlyRequestWrapper:每次调用返回从头开始的新流。 // 若控制器在读取循环里反复获取流,小请求也会不断累加并触发大小限制。 java.io.ByteArrayInputStream input = new java.io.ByteArrayInputStream( body.getBytes(StandardCharsets.UTF_8)); return new javax.servlet.ServletInputStream() { @Override public int read() { return input.read(); } @Override public boolean isFinished() { return input.available() == 0; } @Override public boolean isReady() { return true; } @Override public void setReadListener(javax.servlet.ReadListener listener) { } }; } return null; }); } @Test @SuppressWarnings("unchecked") public void dashboardSeparatesBuyerSupplierAndActualLedgerMoney() { Map order = create("DASHBOARD-CHARGE"); store.update("order", number(order, "id"), map("supplier_user_id", 20, "supplier_account_id", supplier, "status", "SUCCESS", "service_expires_at", after(3600))); tx.execute(status -> { funds.charge(store.get("order", number(order, "id"), true)); return null; }); RentalDashboard dashboard = new RentalDashboard(store); Map buyer = dashboard.overview(10, "account", "NILE", 7); Map seller = dashboard.overview(20, "supplier", "NILE", 7); Map bought = (Map) buyer.get("orders"); Map sold = (Map) seller.get("orders"); assertEquals(1, number(bought, "total")); assertEquals(1, number(sold, "success")); assertEquals("10.000000", text(bought, "amount")); assertEquals("7.600000", text(sold, "amount")); assertEquals(1, number((Map) buyer.get("monitoring"), "active_leases")); assertEquals(0, number((Map) dashboard.overview(10, "supplier", "NILE", 7).get("orders"), "total")); assertEquals(0, number((Map) dashboard.overview(20, "account", "NILE", 7).get("orders"), "total")); assertEquals(0, number((Map) dashboard.overview(10, "account", "MAINNET", 7).get("orders"), "total")); assertFalse(((Map) buyer.get("balance")).containsKey("pending")); assertEquals(7, ((List) buyer.get("trend")).size()); Map today = (Map) ((List) buyer.get("trend")).get(6); assertEquals("10.000000", text(today, "amount")); assertEquals(1, number(today, "total")); } @Test @SuppressWarnings("unchecked") public void dashboardUsesHeartbeatLeaseAndFreshNonnegativeResourceSnapshots() { RentalDashboard dashboard = new RentalDashboard(store); store.update("node", node, map("heartbeat_expires_at", after(-1), "heartbeat_at", now())); store.update("wallet", wallet, map("snapshot_expires_at", after(300), "snapshot_block_height", 100, "snapshot_min_block_height", 99, "energy_available", 500, "bandwidth_available", 200, "bandwidth_enabled", 1)); Map result = dashboard.overview(20, "supplier", "NILE", 14); assertEquals(1, number((Map) result.get("nodes"), "total")); assertEquals(0, number((Map) result.get("nodes"), "online")); assertEquals(Boolean.FALSE, ((Map) ((List) result.get("node_status")).get(0)).get("online")); assertEquals(500, number((Map) result.get("wallets"), "energy")); assertEquals(200, number((Map) result.get("wallets"), "bandwidth")); store.update("wallet", wallet, map("snapshot_expires_at", after(-1))); assertEquals(0, number((Map) dashboard.overview(20, "supplier", "NILE", 14).get("wallets"), "energy")); store.update("wallet", wallet, map("snapshot_expires_at", after(300), "energy_available", -10, "bandwidth_available", -5)); Map nonnegative = (Map) dashboard.overview(20, "supplier", "NILE", 14).get("wallets"); assertEquals(0, number(nonnegative, "energy")); assertEquals(0, number(nonnegative, "bandwidth")); assertEquals(0, number((Map) dashboard.overview(10, "supplier", "NILE", 14).get("nodes"), "total")); } @Test @SuppressWarnings("unchecked") public void dashboardAggregatesBeyondPageLimitAndEmptyReadsDoNotOpenAccounts() { Map original = create("DASHBOARD-MANY"); Map copy = new LinkedHashMap<>(original); copy.remove("id"); for (int index = 0; index < 55; index++) { copy.put("order_no", "DASH-" + index); copy.put("merchant_order_no", "DASH-" + index); store.insert("order", copy); } RentalDashboard dashboard = new RentalDashboard(store); Map result = dashboard.overview(10, "account", "NILE", 30); assertEquals(56, number((Map) result.get("orders"), "total")); assertEquals("0.000000", text((Map) result.get("orders"), "amount")); assertEquals(6, ((List) result.get("recent_orders")).size()); assertEquals(30, ((List) result.get("trend")).size()); Map empty = dashboard.overview(999, "account", "MAINNET", 7); assertEquals("NOT_OPEN", text((Map) empty.get("balance"), "status")); assertEquals(0, store.rows("SELECT id FROM rent_account WHERE user_id=999").size()); expectFailure(() -> dashboard.overview(10, "admin", "NILE", 7)); expectFailure(() -> dashboard.overview(10, "account", "OTHER", 7)); expectFailure(() -> dashboard.overview(10, "account", "NILE", 365)); } @Test @SuppressWarnings("unchecked") public void dashboardKeepsCurrentAlertsOutsideRangeAndAllowsNegativeNetSpending() { Map order = create("DASHBOARD-HISTORY"); long orderId = number(order, "id"); store.update("order", orderId, map("supplier_user_id", 20, "supplier_account_id", supplier, "status", "SUCCESS", "service_expires_at", after(-100), "reclaim_status", "MANUAL_REVIEW")); tx.execute(status -> { funds.charge(store.get("order", orderId, true)); return null; }); // 早期扣款不进入本期消费;当前退款仍应进入本期,形成负净消费。 store.execute("UPDATE rent_ledger SET created_at=? WHERE event_type='CHARGE'", now().minusDays(40)); store.update("order", orderId, map("created_at", now().minusDays(40))); tx.execute(status -> { funds.post(payer, "DASH-REFUND", "REFUND", money("2"), ZERO, ZERO, ZERO, orderId, null, null, 99, "fixture", "看板退款口径测试"); return null; }); orders.webhook(store.get("order", orderId, false), "SUCCESS", "DASH-WEBHOOK"); store.execute("UPDATE rent_webhook SET status='DEAD' WHERE order_id=?", orderId); RentalDashboard dashboard = new RentalDashboard(store); Map result = dashboard.overview(10, "account", "NILE", 7); assertEquals(0, number((Map) result.get("orders"), "total")); assertEquals("-2.000000", text((Map) result.get("orders"), "amount")); assertEquals(1, number((Map) result.get("monitoring"), "manual")); assertEquals(1, number((Map) result.get("monitoring"), "reclaim_pending")); assertEquals(1, number((Map) ((List) result.get("webhooks")).get(0), "total")); assertTrue(((List) dashboard.overview(20, "account", "NILE", 7).get("webhooks")).isEmpty()); assertTrue(((List) dashboard.overview(10, "account", "MAINNET", 7).get("webhooks")).isEmpty()); } private Map create(String number) { return tx.execute( status -> orders.create( app, 10, map( "package_id", product, "merchant_order_no", number, "receiver_address", ADDRESS))); } @Test public void orderAndTaskEventsArePublishedOnlyAfterCommit() throws Exception { List events = new ArrayList<>(); org.springframework.context.ApplicationEventPublisher publisher = event -> events.add((RentalDeliveryEvents) event); injectPublisher(orders, publisher); injectPublisher(tasks, publisher); long orderId = tx.execute(status -> { long id = number(create("AFTER-COMMIT"), "id"); assertTrue(events.isEmpty()); return id; }); assertEquals(1, events.size()); assertTrue(events.get(0).order); assertEquals(orderId, events.get(0).id); tx.execute(status -> { tasks.dispatch(orderId); assertEquals(1, events.size()); return null; }); assertEquals(2, events.size()); assertFalse(events.get(1).order); assertEquals(node, events.get(1).id); } @Test public void rolledBackOrderDoesNotScheduleDelivery() throws Exception { List events = new ArrayList<>(); injectPublisher(orders, events::add); tx.execute(status -> { create("ROLLBACK-DELIVERY"); status.setRollbackOnly(); return null; }); assertTrue(events.isEmpty()); assertNull(store.one("SELECT id FROM rent_order WHERE merchant_order_no='ROLLBACK-DELIVERY'")); } @Test public void committedOrderDispatchesOnIndependentDeliveryWorker() throws Exception { org.springframework.beans.factory.support.DefaultListableBeanFactory factory = new org.springframework.beans.factory.support.DefaultListableBeanFactory(); RentalSocket socket = new RentalSocket(store, identity, tasks, json); factory.registerSingleton("tasks", tasks); factory.registerSingleton("socket", socket); RentalDeliveryDispatcher dispatcher = new RentalDeliveryDispatcher( factory.getBeanProvider(RentalTasks.class), factory.getBeanProvider(RentalSocket.class)); dispatcher.start(); CountDownLatch taskCommitted = new CountDownLatch(1); java.util.concurrent.atomic.AtomicReference dispatchThread = new java.util.concurrent.atomic.AtomicReference<>(); injectPublisher(orders, event -> dispatcher.receive((RentalDeliveryEvents) event)); injectPublisher(tasks, event -> { dispatchThread.set(Thread.currentThread().getName()); taskCommitted.countDown(); }); try { long id = number(create("IMMEDIATE-DISPATCH"), "id"); assertTrue(taskCommitted.await(5, TimeUnit.SECONDS)); assertTrue(dispatchThread.get().startsWith("rental-delivery-")); assertNotNull(store.one("SELECT id FROM rent_task WHERE order_id=?", id)); } finally { dispatcher.close(); } } private void injectPublisher(Object target, org.springframework.context.ApplicationEventPublisher publisher) throws Exception { java.lang.reflect.Field field = target.getClass().getDeclaredField("deliveryEvents"); field.setAccessible(true); field.set(target, publisher); } @Test public void historyCleanupReadsRealBusinessSchemaAndKeepsFunds() throws Exception { String ddl = new String(Files.readAllBytes(Paths.get("../sql/rent_history_init.sql")), StandardCharsets.UTF_8) .replaceAll("(?m)^--.*$", "") .replace("ENGINE=InnoDB ROW_FORMAT=DYNAMIC DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin", ""); for (String statement : ddl.split(";")) { if (!statement.trim().isEmpty()) { store.execute(statement); } } // 此测试的完整业务DDL来自setup;清理器只能读业务状态,不能改动账户/流水。 store.execute("CREATE ALIAS IF NOT EXISTS UTC_TIMESTAMP FOR \"com.ruoyi.system.rental.RentalHistoryTest.utcTimestamp\""); Map oldAccount = new LinkedHashMap<>(store.get("account", payer, false)); Map order = create("CLEANUP-PRESERVE-FUNDS"); Map heldAccount = new LinkedHashMap<>(store.get("account", payer, false)); store.execute("INSERT INTO rent_history_cursor (network,scanned_height,scanned_block_id,updated_at)" + " VALUES ('NILE',30000,?,?)", String.format("%064x", 30000), now()); store.execute("INSERT INTO rent_history_block (network,block_height,block_id,parent_id,block_time," + "events_complete,created_at) VALUES ('NILE',100,?,?,?,1,?)", String.format("%064x", 100), String.format("%064x", 99), System.currentTimeMillis() - 45L * 86400000, now().minusDays(45)); java.nio.file.Path directory = Files.createTempDirectory("rental-history-cleanup-business-"); RentalHistoryCleaner cleaner = new RentalHistoryCleaner(store, json, new RentalHistoryArchive(json), tx.getTransactionManager()); java.lang.reflect.Field archiveDirectory = RentalHistoryCleaner.class.getDeclaredField("archiveDirectory"); archiveDirectory.setAccessible(true); archiveDirectory.set(cleaner, directory.toString()); assertEquals(1, cleaner.clean("NILE")); assertEquals(heldAccount, store.get("account", payer, false)); assertEquals("HELD", text(store.get("order", number(order, "id"), false), "fund_status")); assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE order_id=?", order.get("id")).size()); assertTrue(amount(oldAccount, "available_amount").compareTo(amount(heldAccount, "available_amount")) > 0); // 只删除本测试创建的临时归档文件,不访问部署归档目录。 for (java.io.File file : directory.toFile().listFiles()) { Files.delete(file.toPath()); } Files.delete(directory); } private void expectFailure(Runnable action) { try { action.run(); fail("应拒绝非法操作"); } catch (IllegalArgumentException | org.springframework.dao.DataAccessException expected) { /* 预期拒绝。 */ } } @Test public void precisionAndOverflow() { assertEquals(78000, target(65000, new BigDecimal("20"))); assertEquals(1300000000L, principal(78000, 60000000, 1000000)); assertEquals(78000, quantity(1300000000L, 60000000, 1000000)); expectFailure(() -> target(1, ZERO)); try { principal(Long.MAX_VALUE, 1, Long.MAX_VALUE); fail(); } catch (ArithmeticException expected) { /* 不允许溢出。 */ } } @Test public void sharedHmacVectorAndDomainIsolation() { String signature = RentalCrypto.sign( "test-secret", "API", "test-key", 1700000000123L, "abcdefghijklmnop", "POST", "/api/rental/v1/create", "{\"amount\":\"1.000000\"}"); assertEquals("47241a34f0813881384317eafbfc068dc9f7c6061a8fe269cb815e7820d48430", signature); assertFalse( RentalCrypto.equal( signature, RentalCrypto.sign( "test-secret", "NODE", "test-key", 1700000000123L, "abcdefghijklmnop", "POST", "/api/rental/v1/create", "{\"amount\":\"1.000000\"}"))); } @Test public void credentialNonceReplayRejectedAndSecretEncrypted() { Map issued = identity.issue("APP", app, 10); String key = text(issued, "api_key"), secret = text(issued, "api_secret"), nonce = RentalCrypto.random(); long timestamp = System.currentTimeMillis(); String signature = RentalCrypto.sign( secret, "API", key, timestamp, nonce, "POST", "/api/rental/v1/query", "{}"); identity.authenticate( key, "APP", "API", timestamp, nonce, "POST", "/api/rental/v1/query", "{}", signature); expectFailure( () -> identity.authenticate( key, "APP", "API", timestamp, nonce, "POST", "/api/rental/v1/query", "{}", signature)); assertFalse( text(store.get("credential", number(issued, "id"), false), "api_secret") .contains(secret)); } @Test public void mysqlJsonNormalizationDoesNotBreakTaskSignature() throws Exception { long id = number(create("CANONICAL"), "id"); tasks.dispatch(id); Map task = store.one("SELECT * FROM rent_task WHERE order_id=?", id); Map intent = json.readValue(text(task, "intent"), Map.class); String mysqlStyle = json.writerWithDefaultPrettyPrinter().writeValueAsString(new HashMap<>(intent)); String canonical = json.writeValueAsString(new TreeMap<>(json.readValue(mysqlStyle, Map.class))); Map credential = store.get("credential", number(task, "credential_id"), false); assertEquals( text(task, "signature"), RentalCrypto.sign( identity.secret(credential), "TASK", text(credential, "api_key"), time(task.get("signed_at")).toEpochMilli(), text(task, "nonce"), "PUSH", "/node/v1/task", canonical)); } @Test public void socketAuthenticationSyncAndOldCloseFenced() throws Exception { RentalSocket socket = new RentalSocket(store, identity, tasks, json); StubSocket first = new StubSocket(); authenticate(socket, first); Map firstAuth = json.readValue( text(json.readValue(first.messages.get(1), Map.class), "body"), Map.class); Map authPayload = (Map) firstAuth.get("payload"); assertEquals(Long.toString(node), text(authPayload, "node_id")); assertEquals("NILE", text(authPayload, "network")); List> verifiedWallets = (List>) authPayload.get("verified_wallets"); assertEquals(1, verifiedWallets.size()); assertEquals(OWNER, text(verifiedWallets.get(0), "address")); assertEquals("NILE", text(verifiedWallets.get(0), "network")); Map credential = store.one( "SELECT * FROM rent_credential WHERE owner_type='NODE' AND owner_id=? AND" + " status='ACTIVE'", node); Map sync = map( "type", "SYNC_STATE", "direction", "CLIENT", "session_id", firstAuth.get("session_id"), "session_epoch", firstAuth.get("session_epoch"), "sequence", "1", "message_id", "sync1", "payload", map("events", Collections.emptyList())); socket.handleTextMessage(first, envelope(credential, sync)); assertEquals("ONLINE", text(store.get("node", node, false), "connection_status")); // 独立推送周期无需等待heartbeat;连续短周期调用不能提前重投同一任务。 long deliveryOrder = number(create("DELIVERY-CADENCE"), "id"); tasks.dispatch(deliveryOrder); RentalWorkers workers = new RentalWorkers(store, tasks, socket, identity); workers.validateDeliveryIntervals(); ExecutorService competingPushes = Executors.newFixedThreadPool(2); try { Future immediate = competingPushes.submit(() -> socket.push(node)); Future periodic = competingPushes.submit(workers::pushTasks); immediate.get(5, TimeUnit.SECONDS); periodic.get(5, TimeUnit.SECONDS); } finally { competingPushes.shutdownNow(); } Map delivered = store.one("SELECT * FROM rent_task WHERE order_id=?", deliveryOrder); assertNotNull(delivered); assertEquals(1, number(delivered, "delivery_count")); boolean taskFrameFound = false; for (String message : first.messages) { Map envelope = json.readValue(message, Map.class); if (!envelope.containsKey("body")) { continue; // 首个CHALLENGE不是签名业务帧。 } Map frame = json.readValue(text(envelope, "body"), Map.class); assertFalse("快速推送扫描不应立即发送额外心跳", "PING".equals(text(frame, "type"))); if ("TASK_PUSH".equals(text(frame, "type"))) { taskFrameFound = true; } } assertTrue(taskFrameFound); workers.pushTasks(); assertEquals(1, number(store.get("task", number(delivered, "id"), false), "delivery_count")); StubSocket second = new StubSocket(); authenticate(socket, second); socket.afterConnectionClosed(first, org.springframework.web.socket.CloseStatus.NORMAL); assertEquals("SYNCING", text(store.get("node", node, false), "connection_status")); assertEquals(2, number(store.get("node", node, false), "session_epoch")); assertFalse(first.isOpen()); } @Test public void socketReplayCannotRefreshHeartbeat() throws Exception { RentalSocket socket = new RentalSocket(store, identity, tasks, json); StubSocket session = new StubSocket(); authenticate(socket, session); Map auth = json.readValue( text(json.readValue(session.messages.get(1), Map.class), "body"), Map.class); Map credential = store.one( "SELECT * FROM rent_credential WHERE owner_type='NODE' AND owner_id=? AND" + " status='ACTIVE'", node); org.springframework.web.socket.TextMessage frame = envelope( credential, map( "type", "PING", "direction", "CLIENT", "session_id", auth.get("session_id"), "session_epoch", auth.get("session_epoch"), "sequence", "1", "message_id", "ping1", "payload", map())); socket.handleTextMessage(session, frame); assertTrue(session.isOpen()); socket.handleTextMessage(session, frame); assertFalse(session.isOpen()); } /** 未认证钱包和其他节点的钱包不得进入当前节点的签名认证响应。 */ @Test public void socketAuthDoesNotAdvertiseUnverifiedOrOtherNodesWallets() throws Exception { store.update("wallet", wallet, map("ownership_verified_at", null)); long anotherNode = store.insert("node", map("user_id", 20, "node_no", "OTHER-WALLET-NODE", "status", "ACTIVE")); store.insert("wallet", map("node_id", anotherNode, "network", "NILE", "address", ADDRESS, "status", "ACTIVE", "ownership_verified_at", now())); StubSocket session = new StubSocket(); authenticate(new RentalSocket(store, identity, tasks, json), session); Map response = json.readValue(text(json.readValue(session.messages.get(1), Map.class), "body"), Map.class); Map payload = (Map) response.get("payload"); assertTrue(((List) payload.get("verified_wallets")).isEmpty()); } private void authenticate(RentalSocket socket, StubSocket session) throws Exception { socket.afterConnectionEstablished(session); Map challenge = json.readValue(session.messages.get(0), Map.class); Map credential = store.one( "SELECT * FROM rent_credential WHERE owner_type='NODE' AND owner_id=? AND" + " status='ACTIVE'", node); socket.handleTextMessage( session, envelope( credential, map( "type", "AUTH", "node_no", "NODE-TEST", "challenge", challenge.get("challenge")))); assertTrue(session.isOpen()); } private org.springframework.web.socket.TextMessage envelope( Map credential, Map frame) throws Exception { long timestamp = System.currentTimeMillis(); String nonce = RentalCrypto.random(), key = text(credential, "api_key"), body = json.writeValueAsString(frame); return new org.springframework.web.socket.TextMessage( json.writeValueAsString( map( "api_key", key, "timestamp", timestamp, "nonce", nonce, "body", body, "signature", RentalCrypto.sign( identity.secret(credential), "NODE", key, timestamp, nonce, "FRAME", "/node/v1/socket", body)))); } private static class StubSocket implements org.springframework.web.socket.WebSocketSession { private final String id = UUID.randomUUID().toString(); private boolean open = true; private final List messages = new ArrayList<>(); @Override public String getId() { return id; } @Override public java.net.URI getUri() { return java.net.URI.create("wss://test/node/v1/socket"); } @Override public org.springframework.http.HttpHeaders getHandshakeHeaders() { return new org.springframework.http.HttpHeaders(); } @Override public Map getAttributes() { return Collections.emptyMap(); } @Override public java.security.Principal getPrincipal() { return null; } @Override public java.net.InetSocketAddress getLocalAddress() { return null; } @Override public java.net.InetSocketAddress getRemoteAddress() { return null; } @Override public String getAcceptedProtocol() { return null; } @Override public void setTextMessageSizeLimit(int limit) {} @Override public int getTextMessageSizeLimit() { return 65536; } @Override public void setBinaryMessageSizeLimit(int limit) {} @Override public int getBinaryMessageSizeLimit() { return 0; } @Override public List getExtensions() { return Collections.emptyList(); } @Override public void sendMessage(org.springframework.web.socket.WebSocketMessage message) { messages.add(message.getPayload().toString()); } @Override public boolean isOpen() { return open; } @Override public void close() { open = false; } @Override public void close(org.springframework.web.socket.CloseStatus status) { open = false; } } @Test public void orderIdempotenceAndHold() { long id = number(create("ONE"), "id"); assertEquals(id, number(create("ONE"), "id")); assertEquals(money("90"), amount(store.get("account", payer, false), "available_amount")); assertEquals(1, store.rows("SELECT id FROM rent_ledger WHERE event_type='HOLD'").size()); expectFailure( () -> tx.execute( status -> orders.create( app, 10, map( "package_id", product, "merchant_order_no", "ONE", "receiver_address", OWNER)))); } @Test public void crossUserCannotReuseTopupEvidence() { expectFailure( () -> tx.execute( status -> { funds.post( supplier, "TOPUP:NILE:fixture:0", "TOPUP", money("100"), ZERO, ZERO, ZERO, null, null, null, 99, "fixture", "duplicate"); return null; })); assertEquals(ZERO, amount(store.get("account", supplier, false), "available_amount")); } @Test public void insufficientBalanceRollsBackOrder() { store.update("package", product, map("sale_amount", money("101"))); expectFailure(() -> create("NO-MONEY")); assertTrue(store.rows("SELECT id FROM rent_order").isEmpty()); } @Test public void cancelIsIdempotentAndDispatchedCannotCancel() { long id = number(create("CANCEL"), "id"); tx.execute( status -> { orders.cancel(id, 10); orders.cancel(id, 10); return null; }); assertEquals(money("100"), amount(store.get("account", payer, false), "available_amount")); long other = number(create("DISPATCH"), "id"); tasks.dispatch(other); expectFailure( () -> tx.execute( status -> { orders.cancel(other, 10); return null; })); } @Test public void unknownKeepsFundsAndAllSlots() { long id = number(create("UNKNOWN"), "id"); tasks.dispatch(id); Map task = store.one("SELECT * FROM rent_task WHERE order_id=?", id); tasks.report( node, map("task_no", task.get("task_no"), "event_id", "u1", "state", "UNKNOWN")); task = store.get("task", number(task, "id"), false); assertEquals("UNKNOWN", text(task, "status")); assertEquals(1, number(task, "wallet_execution_slot")); assertEquals("HELD", text(task, "reservation_status")); assertEquals("HELD", text(store.get("order", id, false), "fund_status")); } @Test public void confirmedTransactionChargesOnceAndInvalidatesSnapshot() { long id = number(create("SUCCESS"), "id"); tasks.dispatch(id); Map task = store.one("SELECT * FROM rent_task WHERE order_id=?", id); Map event = map( "task_no", task.get("task_no"), "event_id", "b1", "state", "BUILT", "tx_id", String.join("", Collections.nCopies(64, "a"))); tasks.report(node, event); tasks.report(node, event); tasks.verify(number(task, "id")); tasks.verify(number(task, "id")); assertEquals("SUCCESS", text(store.get("order", id, false), "status")); assertEquals( money("7.6"), amount(store.get("account", supplier, false), "supplier_pending_amount")); Map current = store.get("wallet", wallet, false); assertNull(current.get("snapshot_expires_at")); assertEquals(101, number(current, "snapshot_min_block_height")); assertEquals(1, number(store.get("order", id, false), "relation_slot")); } @Test public void rejectedRetryKeepsHold() { long id = number(create("REJECT"), "id"); tasks.dispatch(id); Map task = store.one("SELECT * FROM rent_task WHERE order_id=?", id); tasks.report( node, map("task_no", task.get("task_no"), "event_id", "r1", "state", "REJECTED")); assertEquals("WAITING", text(store.get("order", id, false), "status")); assertEquals("HELD", text(store.get("order", id, false), "fund_status")); assertEquals(0, number(store.get("wallet", wallet, false), "energy_reserved_sun")); } @Test public void concurrentOrdersNeverOverspend() throws Exception { ExecutorService executor = Executors.newFixedThreadPool(2); CountDownLatch start = new CountDownLatch(1); store.update("package", product, map("sale_amount", money("80"))); List> results = new ArrayList<>(); for (String no : Arrays.asList("RACE-A", "RACE-B")) { results.add( executor.submit( () -> { start.await(); try { create(no); return true; } catch (Exception ex) { return false; } })); } start.countDown(); int success = 0; for (Future result : results) { if (result.get(15, TimeUnit.SECONDS)) { success++; } } executor.shutdownNow(); assertEquals(1, success); assertEquals(money("20"), amount(store.get("account", payer, false), "available_amount")); } @Test public void sameRelationQueuesAndDifferentResourceUsesSeparatePool() { long first = number(create("RELATION-A"), "id"), second = number(create("RELATION-B"), "id"); tasks.dispatch(first); tasks.dispatch(second); assertEquals("WAITING", text(store.get("order", second, false), "status")); long bandwidth = store.insert( "package", map( "package_code", "B", "revision", 1, "name", "bandwidth", "network", "NILE", "resource_type", "BANDWIDTH", "resource_quantity", 1000, "redundancy_percent", "20", "duration_seconds", 3600, "sale_amount", money("10"), "supplier_amount", money("8"), "supplier_fee_percent", "5", "fee_limit_sun", 1000000, "delegate_lock", 0, "rules", "{}", "status", "ACTIVE")); store.execute("UPDATE rent_user_package SET status='DISABLED',default_slot=NULL WHERE user_id=10"); store.insert("user_package", map("user_id", 10, "package_id", bandwidth, "network", "NILE", "resource_type", "BANDWIDTH", "status", "ACTIVE", "default_slot", 1, "created_by", 99)); Map order = tx.execute( status -> orders.create( app, 10, map( "package_id", bandwidth, "merchant_order_no", "BANDWIDTH", "receiver_address", ADDRESS))); tasks.dispatch(number(order, "id")); Map current = store.get("wallet", wallet, false); assertEquals(1300000000L, number(current, "energy_reserved_sun")); assertEquals(800000000L, number(current, "bandwidth_reserved_sun")); } private long confirmed(String merchant) { long id = number(create(merchant), "id"); tasks.dispatch(id); Map task = store.one("SELECT * FROM rent_task WHERE order_id=?", id); tasks.report( node, map( "task_no", task.get("task_no"), "event_id", merchant, "state", "BUILT", "tx_id", String.join("", Collections.nCopies(64, "c")))); tasks.verify(number(task, "id")); return id; } @Test public void reclaimUsesOriginalSunAndKeepsRelationUntilResourcesRecovered() { long id = confirmed("RECLAIM"); store.update("order", id, map("next_reclaim_at", after(-1))); tasks.reclaim(id); Map task = store.one("SELECT * FROM rent_task WHERE order_id=? AND task_type='RECLAIM'", id); assertEquals(1300000000L, number(task, "delegate_sun")); assertNotNull(task.get("source_transaction_id")); assertEquals("NONE", text(task, "reservation_status")); tasks.report( node, map( "task_no", task.get("task_no"), "event_id", "reclaimBuilt", "state", "BUILT", "tx_id", String.join("", Collections.nCopies(64, "d")))); tasks.verify(number(task, "id")); assertEquals("RECOVERING", text(store.get("order", id, false), "reclaim_status")); assertEquals(1, number(store.get("order", id, false), "relation_slot")); tasks.recoverResource(id); assertEquals("DONE", text(store.get("order", id, false), "reclaim_status")); assertNull(store.get("order", id, false).get("relation_slot")); assertEquals("SUCCESS", text(store.get("order", id, false), "status")); } @Test public void missingHistoricalProofNeverChargesAndOnlyRecoveredManualOrderCanRelease() { proofAvailable = false; long id = confirmed("NOHISTORY"); Map order = store.get("order", id, false); assertEquals("MANUAL_REVIEW", text(order, "status")); assertEquals("HELD", text(order, "fund_status")); Map diagnostic = store.one("SELECT * FROM rent_event WHERE object_type='ORDER'" + " AND object_id=? AND action='DELIVERY_REVIEW'", id); assertTrue(text(diagnostic, "reason").contains("缺少完整历史履约证明")); List> visible = new RentalQueries(store).list("order", 10L, 1); assertEquals(text(diagnostic, "reason"), text(visible.get(0), "fulfillment_reason")); assertFalse(visible.get(0).containsKey("review_evidence")); assertTrue(new RentalQueries(store).list("order", 999L, 1).isEmpty()); store.execute("DELETE FROM rent_event WHERE id=?", diagnostic.get("id")); assertTrue(text(new RentalQueries(store).list("order", 10L, 1).get(0), "fulfillment_reason") .contains("缺少完整历史履约证明")); expectFailure(() -> tasks.resolveRecovered(id, 99, "not recovered")); store.update("order", id, map("next_reclaim_at", after(-1))); tasks.reclaim(id); Map task = store.one("SELECT * FROM rent_task WHERE order_id=? AND task_type='RECLAIM'", id); tasks.report( node, map( "task_no", task.get("task_no"), "event_id", "manualReclaim", "state", "BUILT", "tx_id", String.join("", Collections.nCopies(64, "e")))); tasks.verify(number(task, "id")); tasks.recoverResource(id); tasks.resolveRecovered(id, 99, "原本金与资源已回收,未确认交付"); assertEquals(money("100"), amount(store.get("account", payer, false), "available_amount")); assertEquals("FAILED", text(store.get("order", id, false), "status")); } @Test public void insufficientQuantityAndExpiredLeaseAreBothRecordedWithoutCharging() { verifiedResourceQuantity = 1; verificationBlockAgeSeconds = 100000; long id = confirmed("INSUFFICIENT-EXPIRED"); Map order = store.get("order", id, false); assertEquals("MANUAL_REVIEW", text(order, "status")); assertEquals("HELD", text(order, "fund_status")); String reason = text(new RentalQueries(store).list("order", null, 1).get(0), "fulfillment_reason"); assertTrue(reason.contains("实际核验资源数量不足")); assertTrue(reason.contains("核验完成时租期已结束")); assertFalse(reason.contains("缺少完整历史履约证明")); } @Test public void fulfillmentDiagnosticsRespectBoundaryAndDoNotGuessMissingProofQuantity() { java.time.Instant expiry = java.time.Instant.parse("2026-10-31T12:00:00Z"); assertEquals("", RentalDeliveryDiagnostics.explain(true, 18L, 18, expiry, expiry.minusMillis(1))); assertTrue(RentalDeliveryDiagnostics.explain(true, 18L, 18, expiry, expiry).contains("租期已结束")); assertTrue(RentalDeliveryDiagnostics.explain(false, null, 18, expiry, expiry.minusMillis(1)) .contains("缺少完整历史履约证明")); assertFalse(RentalDeliveryDiagnostics.explain(false, null, 18, expiry, expiry.minusMillis(1)) .contains("实际核验资源数量不足")); } @Test public void merchantAndSupplierSameAccountNoDoubleLockOrWrongBalance() { store.update("node", node, map("user_id", 10)); long id = confirmed("SAMEACCOUNT"); assertEquals(payer, number(store.get("order", id, false), "supplier_account_id")); assertEquals(money("90"), amount(store.get("account", payer, false), "available_amount")); assertEquals( money("7.6"), amount(store.get("account", payer, false), "supplier_pending_amount")); } @Test public void feeReturnedToSupplierIncludedInSettlementSourceAndReversalLinked() { long id = confirmed("FEE-RETURN"); long refund = tx.execute( status -> reviews.refund( id, map( "request_no", "FEE1", "reason", "fee test", "refund_amount", "1", "supplier_reverse_amount", "0", "platform_fee_reverse_amount", "0.2", "fee_return_to", "SUPPLIER"), 90)); tx.execute( status -> { reviews.approveRefund(refund, true, 91); return null; }); long settlement = tx.execute(status -> reviews.settlement(Collections.singletonList(id), 90)); assertEquals(money("7.8"), amount(store.get("settlement", settlement, false), "amount")); assertNotNull( store.one( "SELECT reversal_of_id FROM rent_ledger WHERE business_key=?", "REVERSAL:" + refund + ":FEE") .get("reversal_of_id")); } @Test public void reconciliationReportsManualCorruptionWithoutRepairingIt() { RentalReconciliation reconciliation = new RentalReconciliation(store); assertTrue(((List) reconciliation.check(0).get("differences")).isEmpty()); assertTrue(reconciliation.reservations().isEmpty()); store.update("account", payer, map("available_amount", money("99"))); assertFalse(((List) reconciliation.check(0).get("differences")).isEmpty()); assertEquals(money("99"), amount(store.get("account", payer, false), "available_amount")); } @Test public void boundedJsonAndSsrfGuard() throws Exception { // HTTP允许恰好512 KiB的ASCII JSON,超出1字节拒绝;节点通道仍保持64 KiB。 String httpBoundary = "\"" + String.join("", Collections.nCopies( RentalJson.MAX_HTTP_BODY_BYTES - 2, "a")) + "\""; RentalJson.bounded(httpBoundary, RentalJson.MAX_HTTP_BODY_BYTES); expectFailure(() -> RentalJson.bounded(httpBoundary + " ", RentalJson.MAX_HTTP_BODY_BYTES)); expectFailure(() -> RentalJson.bounded(httpBoundary)); expectFailure( () -> RentalJson.bounded( String.join("", Collections.nCopies(33, "[")) + "0" + String.join("", Collections.nCopies(33, "]")))); RentalJson.bounded("{\"quoted\":\"[[[\"}"); expectFailure(() -> RentalHttp.checkUrl("https://example.com/path?token=1")); assertFalse(RentalHttp.publicAddress(java.net.InetAddress.getByName("127.0.0.1"))); assertFalse(RentalHttp.publicAddress(java.net.InetAddress.getByName("100.64.0.1"))); assertFalse(RentalHttp.publicAddress(java.net.InetAddress.getByName("::1"))); } @Test public void tronWebMessageV2Utf8SignatureRecoversAndConsumesOnce() { // 使用公开测试向量,签名由锁定版本TronWeb6.0.4离线生成;不是运行钱包。 String address = "TMVQGm1qAQYVdetCeGRRkTWYYrLXuHK2HC", nonce = RentalCrypto.random(); String signature = "0x5e022ea29837ffca8a8940886b90308b3a66e092e3b00ba7ddff85c683bae2ed44888bfd2f1936680b3150598d956767d169334c2ed93f8b490da49aa3e447271b"; store.update( "wallet", wallet, map( "address", address, "ownership_message", "RENTAL OWNERSHIP TEST 中文", "ownership_challenge", nonce, "challenge_expires_at", after(300), "challenge_consumed_at", null)); RentalProvisioning provisioning = new RentalProvisioning(store, orders); tx.execute( status -> { provisioning.prove(wallet, nonce, signature, 20); return null; }); assertEquals( address, text(store.get("wallet", wallet, false), "ownership_verified_address")); expectFailure( () -> tx.execute( status -> { provisioning.prove(wallet, nonce, signature, 20); return null; })); } @Test public void refundReviewAndPayingCannotRelease() { long id = number(create("REFUND"), "id"); tasks.dispatch(id); Map task = store.one("SELECT * FROM rent_task WHERE order_id=?", id); tasks.report( node, map( "task_no", task.get("task_no"), "event_id", "built", "state", "BUILT", "tx_id", String.join("", Collections.nCopies(64, "b")))); tasks.verify(number(task, "id")); long refund = tx.execute( status -> reviews.refund( id, map( "request_no", "RF1", "reason", "test", "refund_amount", "2", "supplier_reverse_amount", "1", "platform_fee_reverse_amount", "0", "fee_return_to", "NONE"), 90)); expectFailure( () -> tx.execute( status -> { reviews.approveRefund(refund, true, 90); return null; })); tx.execute( status -> { reviews.approveRefund(refund, true, 91); reviews.approveRefund(refund, true, 91); return null; }); assertEquals( money("6.6"), amount(store.get("account", supplier, false), "supplier_pending_amount")); long settlement = tx.execute(status -> reviews.settlement(Collections.singletonList(id), 90)); tx.execute( status -> { reviews.transition(settlement, "approve", 91, "test"); reviews.transition(settlement, "pay", 91, "test"); return null; }); expectFailure( () -> tx.execute(status -> reviews.transition(settlement, "reject", 91, "test"))); assertEquals("PAYING", text(store.get("settlement", settlement, false), "status")); } }