2217 lines
121 KiB
Java
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"));
|
|
}
|
|
}
|