Files
usdt/ruoyi-system/src/test/java/com/ruoyi/system/rental/RentalBusinessTest.java
T

2217 lines
121 KiB
Java

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<Future<Boolean>> 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<Boolean> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> detail = (Map<String, Object>) controller.nodeDetail(ownNode).get("data");
List<Map<String, Object>> wallets = (List<Map<String, Object>>) 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<String, Object> result = (Map<String, Object>) controller.appDetail(app).get("data");
Map<String, Object> appDetail = (Map<String, Object>) result.get("app");
assertEquals(time(store.get("app", app, false).get("created_at")).toEpochMilli(),
((Number) appDetail.get("created_at")).longValue());
List<Map<String, Object>> credentials =
(List<Map<String, Object>>) 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> historical = tx.execute(status -> identity.issue("APP", historicalApp, 10));
Map<String, Object> 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<String, Object> 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<String, Object> request = map("merchant_order_no", "AUTO-1", "receiver_address", ADDRESS, "user_id", 20);
Map<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> retry = map("merchant_order_no", "SCOPE-ORIGINAL", "receiver_address", ADDRESS);
Map<String, Object> 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<String, Object> 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<String, Object> 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<Map<String, Object>> products = (List<Map<String, Object>>) api.execute("packages",
signedRequest("/api/rental/v1/packages", "{\"network\":\"NILE\"}", key, secret, "API")).get("data");
assertEquals(2, products.size());
List<Map<String, Object>> filtered = (List<Map<String, Object>>) 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<String, Object> request = map("network", "NILE", "resource_type", "BANDWIDTH",
"receiver_address", ADDRESS, "merchant_order_no", "API-SCOPE");
Map<String, Object> quote = (Map<String, Object>) 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<String, Object> 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<String, Object> 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<String, Object> valid = map("network", "NILE", "resource_type", "ENERGY",
"receiver_address", ADDRESS, "merchant_order_no", "RESOURCE-ONLY");
List<Map<String, Object>> invalidRequests = new ArrayList<>();
for (String missing : Arrays.asList("network", "resource_type")) {
Map<String, Object> invalid = new LinkedHashMap<>(valid);
invalid.remove(missing); invalidRequests.add(invalid);
}
for (Object id : Arrays.asList(product, "", "99999")) {
Map<String, Object> invalid = new LinkedHashMap<>(valid);
invalid.put("package_id", id); invalidRequests.add(invalid);
}
Map<String, Object> unknown = new LinkedHashMap<>(valid);
unknown.put("resource_type", "BANDWIDTH"); invalidRequests.add(unknown);
for (Map<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<Future<?>> 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<String, Object> 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<Map<String, Object>> products = store.rows("SELECT * FROM rent_package WHERE package_code LIKE 'DEMO_%'");
assertEquals(3, products.size());
for (Map<String, Object> 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<String, Object> 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<String, Object> body) {
return json.valueToTree(map("balance", supplierBalanceSun));
}
@Override
public long relation(
String network, String owner, String receiver, String type) {
return 0;
}
@Override
public Map<String, Object> 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<String, Object> verify(
Map<String, Object> 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<String, Object> request = onchainRequest("onchain-idempotent");
Map<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> order = tx.execute(status -> orders.create(app, 10, onchainRequest("onchain-unknown")));
long orderId = number(order, "id");
tasks.dispatch(orderId);
Map<String, Object> 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<String, Object> request = onchainRequest("activation-idempotent");
Map<String, Object> original = tx.execute(status -> orders.create(app, 10, request));
receiverActivated = true;
Map<String, Object> retry = tx.execute(status -> orders.create(app, 10, request));
assertEquals(number(original, "id"), number(retry, "id"));
assertEquals(1, activationChecks);
}
private Map<String, Object> 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<String, Object> request = map("package_id", product, "merchant_order_no", "LONG-RENT",
"receiver_address", ADDRESS, "duration_seconds", 7200, "expected_amount", "20.000000");
Map<String, Object> 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<String, Object> 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<String, Object> data = map("network", "NILE", "resource_type", "ENERGY", "merchant_order_no", "API-RENT",
"duration_seconds", 7200, "receiver_address", ADDRESS);
Map<String, Object> quote = (Map<String, Object>) 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<String, Object> result = (Map<String, Object>) 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<String, Object> 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<String, Object> data = onchainRequest("API-ONCHAIN");
data.remove("order_type");
String body = json.writeValueAsString(data);
Map<String, Object> quote = (Map<String, Object>) 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<String, Object> created = (Map<String, Object>) 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<String, Object> queried = (Map<String, Object>) 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> buyer = dashboard.overview(10, "account", "NILE", 7);
Map<String, Object> seller = dashboard.overview(20, "supplier", "NILE", 7);
Map<String, Object> bought = (Map<String, Object>) buyer.get("orders");
Map<String, Object> sold = (Map<String, Object>) 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<String, Object>) buyer.get("monitoring"), "active_leases"));
assertEquals(0, number((Map<String, Object>) dashboard.overview(10, "supplier", "NILE", 7).get("orders"), "total"));
assertEquals(0, number((Map<String, Object>) dashboard.overview(20, "account", "NILE", 7).get("orders"), "total"));
assertEquals(0, number((Map<String, Object>) dashboard.overview(10, "account", "MAINNET", 7).get("orders"), "total"));
assertFalse(((Map<String, Object>) buyer.get("balance")).containsKey("pending"));
assertEquals(7, ((List<?>) buyer.get("trend")).size());
Map<String, Object> today = (Map<String, Object>) ((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<String, Object> result = dashboard.overview(20, "supplier", "NILE", 14);
assertEquals(1, number((Map<String, Object>) result.get("nodes"), "total"));
assertEquals(0, number((Map<String, Object>) result.get("nodes"), "online"));
assertEquals(Boolean.FALSE, ((Map<String, Object>) ((List<?>) result.get("node_status")).get(0)).get("online"));
assertEquals(500, number((Map<String, Object>) result.get("wallets"), "energy"));
assertEquals(200, number((Map<String, Object>) result.get("wallets"), "bandwidth"));
store.update("wallet", wallet, map("snapshot_expires_at", after(-1)));
assertEquals(0, number((Map<String, Object>) 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<String, Object> nonnegative = (Map<String, Object>) dashboard.overview(20, "supplier", "NILE", 14).get("wallets");
assertEquals(0, number(nonnegative, "energy"));
assertEquals(0, number(nonnegative, "bandwidth"));
assertEquals(0, number((Map<String, Object>) dashboard.overview(10, "supplier", "NILE", 14).get("nodes"), "total"));
}
@Test
@SuppressWarnings("unchecked")
public void dashboardAggregatesBeyondPageLimitAndEmptyReadsDoNotOpenAccounts() {
Map<String, Object> original = create("DASHBOARD-MANY");
Map<String, Object> 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<String, Object> result = dashboard.overview(10, "account", "NILE", 30);
assertEquals(56, number((Map<String, Object>) result.get("orders"), "total"));
assertEquals("0.000000", text((Map<String, Object>) result.get("orders"), "amount"));
assertEquals(6, ((List<?>) result.get("recent_orders")).size());
assertEquals(30, ((List<?>) result.get("trend")).size());
Map<String, Object> empty = dashboard.overview(999, "account", "MAINNET", 7);
assertEquals("NOT_OPEN", text((Map<String, Object>) 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<String, Object> 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<String, Object> result = dashboard.overview(10, "account", "NILE", 7);
assertEquals(0, number((Map<String, Object>) result.get("orders"), "total"));
assertEquals("-2.000000", text((Map<String, Object>) result.get("orders"), "amount"));
assertEquals(1, number((Map<String, Object>) result.get("monitoring"), "manual"));
assertEquals(1, number((Map<String, Object>) result.get("monitoring"), "reclaim_pending"));
assertEquals(1, number((Map<String, Object>) ((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<String, Object> 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<RentalDeliveryEvents> 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<Object> 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<String> 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<String, Object> oldAccount = new LinkedHashMap<>(store.get("account", payer, false));
Map<String, Object> order = create("CLEANUP-PRESERVE-FUNDS");
Map<String, Object> 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<String, Object> 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<String, Object> task = store.one("SELECT * FROM rent_task WHERE order_id=?", id);
Map<String, Object> 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<String, Object> 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<String, Object> firstAuth =
json.readValue(
text(json.readValue(first.messages.get(1), Map.class), "body"), Map.class);
Map<String, Object> authPayload = (Map<String, Object>) firstAuth.get("payload");
assertEquals(Long.toString(node), text(authPayload, "node_id"));
assertEquals("NILE", text(authPayload, "network"));
List<Map<String, Object>> verifiedWallets = (List<Map<String, Object>>) authPayload.get("verified_wallets");
assertEquals(1, verifiedWallets.size());
assertEquals(OWNER, text(verifiedWallets.get(0), "address"));
assertEquals("NILE", text(verifiedWallets.get(0), "network"));
Map<String, Object> credential =
store.one(
"SELECT * FROM rent_credential WHERE owner_type='NODE' AND owner_id=? AND"
+ " status='ACTIVE'",
node);
Map<String, Object> 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<String, Object> 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<String, Object> envelope = json.readValue(message, Map.class);
if (!envelope.containsKey("body")) {
continue; // 首个CHALLENGE不是签名业务帧。
}
Map<String, Object> 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<String, Object> auth =
json.readValue(
text(json.readValue(session.messages.get(1), Map.class), "body"),
Map.class);
Map<String, Object> 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<String, Object> response = json.readValue(text(json.readValue(session.messages.get(1), Map.class), "body"), Map.class);
Map<String, Object> payload = (Map<String, Object>) response.get("payload");
assertTrue(((List<?>) payload.get("verified_wallets")).isEmpty());
}
private void authenticate(RentalSocket socket, StubSocket session) throws Exception {
socket.afterConnectionEstablished(session);
Map<String, Object> challenge = json.readValue(session.messages.get(0), Map.class);
Map<String, Object> 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<String, Object> credential, Map<String, Object> 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<String> 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<String, Object> 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<org.springframework.web.socket.WebSocketExtension> 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<String, Object> 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<String, Object> task = store.one("SELECT * FROM rent_task WHERE order_id=?", id);
Map<String, Object> 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<String, Object> 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<String, Object> 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<Future<Boolean>> 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<Boolean> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> 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<String, Object> order = store.get("order", id, false);
assertEquals("MANUAL_REVIEW", text(order, "status"));
assertEquals("HELD", text(order, "fund_status"));
Map<String, Object> 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<Map<String, Object>> 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<String, Object> 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<String, Object> 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<String, Object> 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"));
}
}