Browse Source

feat(xincang): 对接删除订单与删除转运

- 删除订单 POST api.delete_order:order_no / ckh 二选一,空 body,
  按状态分流(待审核→删除、待发货→已取消、拣货/已拣货→已拦截),
  统一映射为 CancelResult
- 删除转运 POST fba.delete_fba:必填 order_no,仅待审核可删

取消资格预判:
- 信仓没有独立预判接口,checkCancel 走订单详情按状态推断
- SHIPPED / CANCELLED / INTERCEPTED / DELETED / UNKNOWN → BLOCKED,
  其余状态 → FREE
- 查询失败直接抛出,不猜成 FREE,避免下发注定被拒的写请求
- 仓拒绝删除时抛 OutboundCancelBlockedException,与参数错误区分

core 只新增、不修改:
- TransferCapable 增加 default deleteTransfer(ctx, providerTransferNo)
- WarehouseOperations 增加 deleteTransfer,走幂等守卫,
  动作键 warehouseCode + providerTransferNo + delete

Co-Authored-By: Claude Code <noreply@anthropic.com>
feature/supplier-lingxing
lml 1 week ago
parent
commit
940e205cd7
  1. 2
      README.md
  2. 14
      warehouse-sdk-core/src/main/java/common/ecommerce/warehouse/capability/TransferCapable.java
  3. 22
      warehouse-sdk-core/src/main/java/common/ecommerce/warehouse/sdk/WarehouseOperations.java
  4. 6
      warehouse-sdk-xincang/src/main/java/common/ecommerce/xincang/XincangConstants.java
  5. 89
      warehouse-sdk-xincang/src/main/java/common/ecommerce/xincang/adapter/XincangAdapter.java
  6. 11
      warehouse-sdk-xincang/src/main/java/common/ecommerce/xincang/adapter/XincangUnsupportedOutbound.java
  7. 158
      warehouse-sdk-xincang/src/test/java/common/ecommerce/xincang/adapter/XincangCancelOrderTest.java
  8. 89
      warehouse-sdk-xincang/src/test/java/common/ecommerce/xincang/adapter/XincangDeleteTransferTest.java

2
README.md

@ -135,7 +135,7 @@ sequenceDiagram
| `warehouse-sdk-testkit` | 仓库域测试替身:InMemory 仓仓库 / 落库 / 去重、FakeWarehouseAdapter | | `warehouse-sdk-testkit` | 仓库域测试替身:InMemory 仓仓库 / 落库 / 去重、FakeWarehouseAdapter |
| `common-ecommerce-lingxing` | 领星聚合适配器(多子平台)。DTO 用 Lombok 生成访问器 | | `common-ecommerce-lingxing` | 领星聚合适配器(多子平台)。DTO 用 Lombok 生成访问器 |
| `warehouse-sdk-yqn` | 运去哪三方仓适配器(P1 出库闭环,组织级固定 token 鉴权) | | `warehouse-sdk-yqn` | 运去哪三方仓适配器(P1 出库闭环,组织级固定 token 鉴权) |
| `warehouse-sdk-xincang` | 信仓三方仓适配器(登录换 token、商品建档、一单多件下单、转运创建 / 审核) | | `warehouse-sdk-xincang` | 信仓三方仓适配器(登录换 token、商品建档、下单 / 详情 / 删除、转运创建 / 审核 / 详情 / 删除) |
依赖方向: 依赖方向:
``` ```

14
warehouse-sdk-core/src/main/java/common/ecommerce/warehouse/capability/TransferCapable.java

@ -53,4 +53,18 @@ public interface TransferCapable extends WarehouseAdapter {
throw new common.ecommerce.warehouse.error.WarehouseUnsupportedCapabilityException( throw new common.ecommerce.warehouse.error.WarehouseUnsupportedCapabilityException(
common.ecommerce.warehouse.enums.WarehouseCapability.TRANSFER); common.ecommerce.warehouse.enums.WarehouseCapability.TRANSFER);
} }
/**
* 删除(撤销)调拨单。<b>写操作</b>,幂等键
* {@code warehouseCode + providerTransferNo + "delete"}。
*
* <p>信仓的「删除转运」({@code POST fba.delete_fba})走这里,且<b>只有待审核状态可删</b>;
* 其余状态由仓方拒绝,适配器原样抛出,不擅自改成「取消」。</p>
*
* <p>未实现删除的仓默认拒绝。</p>
*/
default void deleteTransfer(WarehouseContext ctx, String providerTransferNo) {
throw new common.ecommerce.warehouse.error.WarehouseUnsupportedCapabilityException(
common.ecommerce.warehouse.enums.WarehouseCapability.TRANSFER);
}
} }

22
warehouse-sdk-core/src/main/java/common/ecommerce/warehouse/sdk/WarehouseOperations.java

@ -146,6 +146,28 @@ public final class WarehouseOperations {
() -> ((TransferCapable) adapter).getTransfer(ctx, providerTransferNo)); () -> ((TransferCapable) adapter).getTransfer(ctx, providerTransferNo));
} }
/**
* 删除(撤销)调拨单。<b>写操作</b>:强制经幂等守卫,幂等键
* {@code warehouseCode + providerTransferNo + delete}。
*
* @param providerTransferNo 仓侧调拨单号
*/
public void deleteTransfer(final String providerTransferNo) {
require(WarehouseCapability.TRANSFER, TransferCapable.class);
if (guard == null) {
throw new IllegalStateException("WarehouseSdk requires an idempotencyStore for write operations");
}
final TransferCapable capable = (TransferCapable) adapter;
guard.execute(
WarehouseWriteScope.of(provider.name(), account.warehouseCode(),
providerTransferNo, "delete"),
() -> {
capable.deleteTransfer(ctx, providerTransferNo);
return providerTransferNo;
},
ref -> ref);
}
/** 库存视图。 */ /** 库存视图。 */
public InventoryView inventory() { public InventoryView inventory() {
return new InventoryView(); return new InventoryView();

6
warehouse-sdk-xincang/src/main/java/common/ecommerce/xincang/XincangConstants.java

@ -56,6 +56,9 @@ public final class XincangConstants {
/** 订单详情;{@code order_no} 与 {@code ckh} 二选一。 */ /** 订单详情;{@code order_no} 与 {@code ckh} 二选一。 */
public static final String PATH_ORDER_DETAIL = "/api.get_order"; public static final String PATH_ORDER_DETAIL = "/api.get_order";
/** 删除订单;{@code order_no} 与 {@code ckh} 二选一,空 body。 */
public static final String PATH_ORDER_DELETE = "/api.delete_order";
/** 新增转运({@code application/json})。 */ /** 新增转运({@code application/json})。 */
public static final String PATH_TRANSFER_CREATE = "/fba.do_fba"; public static final String PATH_TRANSFER_CREATE = "/fba.do_fba";
@ -68,6 +71,9 @@ public final class XincangConstants {
/** 转运详情;必填 {@code order_no}(转运单号)。 */ /** 转运详情;必填 {@code order_no}(转运单号)。 */
public static final String PATH_TRANSFER_DETAIL = "/fba.fba_detail"; public static final String PATH_TRANSFER_DETAIL = "/fba.fba_detail";
/** 删除转运;必填 {@code order_no},仅待审核状态可删。 */
public static final String PATH_TRANSFER_DELETE = "/fba.delete_fba";
/** 登录响应里的 token 归入哪个作用域;信仓用 query 参数传递,不是 {@code Authorization} 头。 */ /** 登录响应里的 token 归入哪个作用域;信仓用 query 参数传递,不是 {@code Authorization} 头。 */
public static final String TOKEN_LOCATION = "query"; public static final String TOKEN_LOCATION = "query";

89
warehouse-sdk-xincang/src/main/java/common/ecommerce/xincang/adapter/XincangAdapter.java

@ -16,8 +16,10 @@ import common.ecommerce.warehouse.capability.TransferCapable;
import common.ecommerce.warehouse.capability.WarehouseProduct; import common.ecommerce.warehouse.capability.WarehouseProduct;
import common.ecommerce.warehouse.capability.WarehouseProductCapable; import common.ecommerce.warehouse.capability.WarehouseProductCapable;
import common.ecommerce.warehouse.enums.CancelEligibility; import common.ecommerce.warehouse.enums.CancelEligibility;
import common.ecommerce.warehouse.enums.OutboundStatus;
import common.ecommerce.warehouse.enums.WarehouseCapability; import common.ecommerce.warehouse.enums.WarehouseCapability;
import common.ecommerce.warehouse.enums.WarehouseProvider; import common.ecommerce.warehouse.enums.WarehouseProvider;
import common.ecommerce.warehouse.error.OutboundCancelBlockedException;
import common.ecommerce.warehouse.error.WarehouseException; import common.ecommerce.warehouse.error.WarehouseException;
import common.ecommerce.warehouse.model.CancelCommand; import common.ecommerce.warehouse.model.CancelCommand;
import common.ecommerce.warehouse.model.CancelResult; import common.ecommerce.warehouse.model.CancelResult;
@ -247,14 +249,79 @@ public final class XincangAdapter implements WarehouseProductCapable, OutboundCa
throw XincangUnsupportedOutbound.queryUnsupported(ctx); throw XincangUnsupportedOutbound.queryUnsupported(ctx);
} }
/**
* 取消资格预判。
*
* <p>信仓没有独立的取消预判接口,也没有收费取消:按订单详情状态推断。
* 文档「删除订单」的语义是——待审核→删除、待发货→已取消、拣货中/已拣货→已拦截;
* 已发货、已取消、已删除、已拦截都不再接受删除,判为 {@link CancelEligibility#BLOCKED}。</p>
*
* <p>查询失败时直接抛出,不猜成 FREE——猜错会下发出一个注定被拒的删除请求。</p>
*/
@Override @Override
public CancelEligibility checkCancel(WarehouseContext ctx, OutboundRef ref) { public CancelEligibility checkCancel(WarehouseContext ctx, OutboundRef ref) {
throw XincangUnsupportedOutbound.checkCancelUnsupported(ctx); OutboundOrder order = get(ctx, ref);
return cancelEligibilityOf(order.status());
} }
/**
* 删除订单({@code POST api.delete_order})。
*
* <p>信仓的「删除」按订单状态分流:待审核→删除、待发货→已取消、
* 拣货中/已拣货→已拦截,因此统一模型里映射为 {@link CancelResult}。
* 仓拒绝时按 {@link OutboundCancelBlockedException} 抛出,方便与参数错误区分。</p>
*/
@Override @Override
public CancelResult cancel(WarehouseContext ctx, CancelCommand cmd) { public CancelResult cancel(WarehouseContext ctx, CancelCommand cmd) {
throw XincangUnsupportedOutbound.cancelUnsupported(ctx); Map<String, Object> params = new LinkedHashMap<String, Object>();
if (!blank(cmd.providerOrderId())) {
params.put("order_no", cmd.providerOrderId());
} else if (!blank(cmd.outboundRequestNo())) {
params.put("ckh", cmd.outboundRequestNo());
}
try {
executePostQuery(ctx, XincangConstants.PATH_ORDER_DELETE, params,
"warehouse.outbound.cancel");
} catch (PlatformBusinessException e) {
// 信仓失败只回 err 文本,无法细分原因;取消场景统一按「不可取消」表达
throw new OutboundCancelBlockedException(WarehouseException.builder()
.message("xincang refused order deletion: " + e.getMessage())
.operation("warehouse.outbound.cancel")
.warehouseCode(ctx.warehouseCode())
.provider(provider().name())
.requestId(ctx.requestId())
.platformCode(e.platformCode())
.rawResponse(e.rawResponse())
.retryable(false));
}
return CancelResult.builder()
.outboundRequestNo(cmd.outboundRequestNo())
.providerOrderId(cmd.providerOrderId())
.eligibility(CancelEligibility.FREE)
.cancelled(true)
.build();
}
/**
* 取消资格映射。
*
* <p>只有「尚未进入不可逆阶段」的状态可删;{@link OutboundStatus#UNKNOWN}
* 也判为 BLOCKED,避免拿不准就下写请求。</p>
*/
static CancelEligibility cancelEligibilityOf(OutboundStatus status) {
if (status == null) {
return CancelEligibility.BLOCKED;
}
switch (status) {
case SHIPPED:
case CANCELLED:
case INTERCEPTED:
case DELETED:
case UNKNOWN:
return CancelEligibility.BLOCKED;
default:
return CancelEligibility.FREE;
}
} }
@Override @Override
@ -331,6 +398,24 @@ public final class XincangAdapter implements WarehouseProductCapable, OutboundCa
return XincangTransferDetailMapper.toOrder(detail); return XincangTransferDetailMapper.toOrder(detail);
} }
/**
* 删除转运({@code POST fba.delete_fba})。
*
* <p>信仓<b>只允许待审核状态</b>删除,其余状态由仓方拒绝(errno != 0),
* 这里原样抛出业务异常,不擅自退化成「取消」。</p>
*/
@Override
public void deleteTransfer(WarehouseContext ctx, String providerTransferNo) {
if (blank(providerTransferNo)) {
throw XincangUnsupportedOutbound.businessError(ctx, "warehouse.transfer.delete",
"providerTransferNo must not be blank");
}
Map<String, Object> params = new LinkedHashMap<String, Object>();
params.put("order_no", providerTransferNo);
executePostQuery(ctx, XincangConstants.PATH_TRANSFER_DELETE, params,
"warehouse.transfer.delete");
}
// ------------------------------------------------------------------ internals // ------------------------------------------------------------------ internals
/** 写接口:JSON 请求体(含 token)+ query token。 */ /** 写接口:JSON 请求体(含 token)+ query token。 */

11
warehouse-sdk-xincang/src/main/java/common/ecommerce/xincang/adapter/XincangUnsupportedOutbound.java

@ -9,7 +9,8 @@ import common.ecommerce.warehouse.sdk.WarehouseContext;
/** /**
* 信仓暂时不支持的出库 / 调拨能力。 * 信仓暂时不支持的出库 / 调拨能力。
* *
* <p>「新增订单」「订单详情」「转运创建 / 审核 / 详情」已接入;列表查询、取消、包裹还没接。 * <p>「新增订单」「订单详情 / 删除」「转运创建 / 审核 / 详情 / 删除」已接入;
* 列表查询与包裹还没接。
* 这里统一抛 {@link ValidationException}({@code retryable=false}),<b>不返回空集合</b>—— * 这里统一抛 {@link ValidationException}({@code retryable=false}),<b>不返回空集合</b>——
* 静默返回 {@code null} / 空会让调用方以为「仓说没有这单」。</p> * 静默返回 {@code null} / 空会让调用方以为「仓说没有这单」。</p>
*/ */
@ -22,14 +23,6 @@ final class XincangUnsupportedOutbound {
throw unsupported(ctx, "warehouse.outbound.query"); throw unsupported(ctx, "warehouse.outbound.query");
} }
static ValidationException checkCancelUnsupported(WarehouseContext ctx) {
throw unsupported(ctx, "warehouse.outbound.checkCancel");
}
static ValidationException cancelUnsupported(WarehouseContext ctx) {
throw unsupported(ctx, "warehouse.outbound.cancel");
}
static ValidationException packagesUnsupported(WarehouseContext ctx) { static ValidationException packagesUnsupported(WarehouseContext ctx) {
throw unsupported(ctx, "warehouse.outbound.packages"); throw unsupported(ctx, "warehouse.outbound.packages");
} }

158
warehouse-sdk-xincang/src/test/java/common/ecommerce/xincang/adapter/XincangCancelOrderTest.java

@ -0,0 +1,158 @@
package common.ecommerce.xincang.adapter;
import common.ecommerce.shared.error.PlatformBusinessException;
import common.ecommerce.shared.spi.ChannelSecret;
import common.ecommerce.shared.testkit.InMemoryLockProvider;
import common.ecommerce.shared.testkit.InMemoryTokenStore;
import common.ecommerce.shared.testkit.MutableClock;
import common.ecommerce.shared.testkit.RecordingTransport;
import common.ecommerce.shared.testkit.Responses;
import common.ecommerce.warehouse.enums.CancelEligibility;
import common.ecommerce.warehouse.enums.OutboundStatus;
import common.ecommerce.warehouse.enums.WarehouseProvider;
import common.ecommerce.warehouse.error.OutboundCancelBlockedException;
import common.ecommerce.warehouse.model.CancelCommand;
import common.ecommerce.warehouse.model.CancelResult;
import common.ecommerce.warehouse.model.OutboundRef;
import common.ecommerce.warehouse.sdk.WarehouseConnection;
import common.ecommerce.warehouse.sdk.WarehouseContext;
import common.ecommerce.xincang.XincangConstants;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.time.Clock;
import java.time.Duration;
import static org.junit.jupiter.api.Assertions.*;
/**
* 删除订单({@code POST api.delete_order})与取消资格预判契约测试。
*/
class XincangCancelOrderTest {
private static final String BASE = XincangConstants.TEST_BASE_URL;
private static final String APP_KEY = "ak-1";
private static final String DETAIL_PENDING = "{\"rst\":{"
+ "\"order_no\":\"DS-1\",\"ckh\":\"OB-1\",\"state\":\"0\",\"state_name\":\"待审核\","
+ "\"order_type\":\"common\",\"warehouse_code\":\"NJ-2605\","
+ "\"products\":[{\"sku\":\"SKU-A\",\"qty\":\"1\"}]},"
+ "\"errno\":0,\"err\":\"\",\"trace_id\":\"t-1\"}";
private RecordingTransport transport;
private XincangAdapter adapter;
@BeforeEach
void setUp() {
transport = RecordingTransport.create();
MutableClock clock = MutableClock.atUtc("2026-11-10T00:00:00Z");
transport.route(XincangConstants.PATH_LOGIN, req -> Responses.ok(
"{\"rst\":{\"id\":\"c-1\",\"token\":\"{T-1}\",\"token_expire_time\":\""
+ java.time.LocalDateTime.ofInstant(clock.instant().plus(Duration.ofHours(2)),
XincangConstants.SYSTEM_ZONE)
.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
+ "\"},\"errno\":0,\"err\":\"\",\"trace_id\":\"t-login\"}"));
adapter = new XincangAdapter(transport, new common.ecommerce.http.JacksonJsonCodec(),
new InMemoryTokenStore(), new InMemoryLockProvider(), clock);
}
private static WarehouseContext ctx() {
return WarehouseContext.of("XC-NJ-2605", WarehouseProvider.XINCANG, "NJ-2605",
WarehouseConnection.of(BASE, ChannelSecret.builder()
.appKey(APP_KEY).appSecret("sk").build()),
"req-1", Clock.systemUTC());
}
@Test
void cancelByProviderOrderId() {
transport.route(XincangConstants.PATH_ORDER_DELETE, req -> Responses.ok(
"{\"rst\":true,\"errno\":0,\"err\":\"\",\"trace_id\":\"t-del\"}"));
CancelCommand cmd = CancelCommand.builder()
.providerOrderId("DS-1")
.outboundRequestNo("OB-1")
.build();
CancelResult result = adapter.cancel(ctx(), cmd);
common.ecommerce.http.HttpRequest req = transport.lastDataRequest();
assertEquals("POST", req.method());
assertTrue(req.url().contains("/api.delete_order?"), req.url());
assertTrue(req.url().contains("order_no=DS-1"), req.url());
assertFalse(req.url().contains("ckh="), "有仓单号时不再传参考号");
assertTrue(req.url().contains("token=%7BT-1%7D"), req.url());
assertNull(req.body(), "删除订单无请求体");
assertTrue(result.cancelled());
assertEquals(CancelEligibility.FREE, result.eligibility());
assertEquals("DS-1", result.providerOrderId());
assertEquals("OB-1", result.outboundRequestNo());
}
@Test
void cancelFallsBackToReferenceNumber() {
transport.route(XincangConstants.PATH_ORDER_DELETE, req -> Responses.ok(
"{\"rst\":true,\"errno\":0,\"err\":\"\"}"));
CancelCommand cmd = CancelCommand.builder().outboundRequestNo("OB-1").build();
adapter.cancel(ctx(), cmd);
String url = transport.lastDataRequest().url();
assertTrue(url.contains("ckh=OB-1"), url);
assertFalse(url.contains("order_no="), url);
}
@Test
void refusedDeletionBecomesBlockedException() {
transport.route(XincangConstants.PATH_ORDER_DELETE, req -> Responses.ok(
"{\"rst\":null,\"errno\":-1,"
+ "\"err\":\"DS-BZY01-26101500005在该状态下不允许修改\",\"trace_id\":\"t-bad\"}"));
OutboundCancelBlockedException e = assertThrows(OutboundCancelBlockedException.class,
() -> adapter.cancel(ctx(), CancelCommand.builder().providerOrderId("DS-1").build()));
assertTrue(e.getMessage().contains("该状态下不允许修改"), e.getMessage());
assertFalse(e.retryable());
}
@Test
void checkCancelUsesOrderStatus() {
transport.route(XincangConstants.PATH_ORDER_DETAIL, req -> Responses.ok(DETAIL_PENDING));
assertEquals(CancelEligibility.FREE,
adapter.checkCancel(ctx(), OutboundRef.ofProviderOrderId("DS-1")));
}
@Test
void checkCancelMapsTerminalStatesToBlocked() {
assertBlocked(OutboundStatus.SHIPPED);
assertBlocked(OutboundStatus.CANCELLED);
assertBlocked(OutboundStatus.INTERCEPTED);
assertBlocked(OutboundStatus.DELETED);
assertBlocked(OutboundStatus.UNKNOWN);
}
@Test
void checkCancelAllowsPreShipmentStates() {
assertFree(OutboundStatus.PENDING_REVIEW);
assertFree(OutboundStatus.PENDING_SHIPMENT);
assertFree(OutboundStatus.REVIEWING);
assertFree(OutboundStatus.PICKING);
assertFree(OutboundStatus.PICKED);
}
@Test
void checkCancelPropagatesLookupFailure() {
transport.route(XincangConstants.PATH_ORDER_DETAIL, req -> Responses.ok(
"{\"rst\":null,\"errno\":-1,\"err\":\"订单不存在\",\"trace_id\":\"t-404\"}"));
assertThrows(PlatformBusinessException.class,
() -> adapter.checkCancel(ctx(), OutboundRef.ofProviderOrderId("DS-X")));
}
private static void assertBlocked(OutboundStatus status) {
assertEquals(CancelEligibility.BLOCKED, XincangAdapter.cancelEligibilityOf(status), status.name());
}
private static void assertFree(OutboundStatus status) {
assertEquals(CancelEligibility.FREE, XincangAdapter.cancelEligibilityOf(status), status.name());
}
}

89
warehouse-sdk-xincang/src/test/java/common/ecommerce/xincang/adapter/XincangDeleteTransferTest.java

@ -0,0 +1,89 @@
package common.ecommerce.xincang.adapter;
import common.ecommerce.shared.error.PlatformBusinessException;
import common.ecommerce.shared.error.ValidationException;
import common.ecommerce.shared.spi.ChannelSecret;
import common.ecommerce.shared.testkit.InMemoryLockProvider;
import common.ecommerce.shared.testkit.InMemoryTokenStore;
import common.ecommerce.shared.testkit.MutableClock;
import common.ecommerce.shared.testkit.RecordingTransport;
import common.ecommerce.shared.testkit.Responses;
import common.ecommerce.warehouse.enums.WarehouseProvider;
import common.ecommerce.warehouse.sdk.WarehouseConnection;
import common.ecommerce.warehouse.sdk.WarehouseContext;
import common.ecommerce.xincang.XincangConstants;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.time.Clock;
import java.time.Duration;
import static org.junit.jupiter.api.Assertions.*;
/**
* 删除转运({@code POST fba.delete_fba})契约测试。
*/
class XincangDeleteTransferTest {
private static final String BASE = XincangConstants.TEST_BASE_URL;
private static final String APP_KEY = "ak-1";
private RecordingTransport transport;
private XincangAdapter adapter;
@BeforeEach
void setUp() {
transport = RecordingTransport.create();
MutableClock clock = MutableClock.atUtc("2026-11-10T00:00:00Z");
transport.route(XincangConstants.PATH_LOGIN, req -> Responses.ok(
"{\"rst\":{\"id\":\"c-1\",\"token\":\"{T-1}\",\"token_expire_time\":\""
+ java.time.LocalDateTime.ofInstant(clock.instant().plus(Duration.ofHours(2)),
XincangConstants.SYSTEM_ZONE)
.format(java.time.format.DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"))
+ "\"},\"errno\":0,\"err\":\"\",\"trace_id\":\"t-login\"}"));
adapter = new XincangAdapter(transport, new common.ecommerce.http.JacksonJsonCodec(),
new InMemoryTokenStore(), new InMemoryLockProvider(), clock);
}
private static WarehouseContext ctx() {
return WarehouseContext.of("XC-CA-15950", WarehouseProvider.XINCANG, "CA-15950",
WarehouseConnection.of(BASE, ChannelSecret.builder()
.appKey(APP_KEY).appSecret("sk").build()),
"req-1", Clock.systemUTC());
}
@Test
void deletesTransferByOrderNo() {
transport.route(XincangConstants.PATH_TRANSFER_DELETE, req -> Responses.ok(
"{\"rst\":true,\"errno\":0,\"err\":\"\",\"trace_id\":\"t-del\"}"));
adapter.deleteTransfer(ctx(), "LTL26101500002");
common.ecommerce.http.HttpRequest req = transport.lastDataRequest();
assertEquals("POST", req.method());
assertTrue(req.url().contains("/fba.delete_fba?"), req.url());
assertTrue(req.url().contains("order_no=LTL26101500002"), req.url());
assertTrue(req.url().contains("token=%7BT-1%7D"), req.url());
assertNull(req.body(), "删除转运无请求体");
}
@Test
void nonPendingTransferIsRejectedByWarehouse() {
transport.route(XincangConstants.PATH_TRANSFER_DELETE, req -> Responses.ok(
"{\"rst\":null,\"errno\":-1,\"err\":\"只有待审核状态的订单可以删除\",\"trace_id\":\"t-bad\"}"));
PlatformBusinessException e = assertThrows(PlatformBusinessException.class,
() -> adapter.deleteTransfer(ctx(), "LTL-1"));
assertTrue(e.getMessage().contains("待审核"), e.getMessage());
assertFalse(e.retryable());
}
@Test
void blankOrderNoIsRejectedBeforeSending() {
ValidationException e = assertThrows(ValidationException.class,
() -> adapter.deleteTransfer(ctx(), " "));
assertTrue(e.getMessage().contains("providerTransferNo"), e.getMessage());
assertFalse(transport.recorded().stream()
.anyMatch(r -> r.url().contains(XincangConstants.PATH_TRANSFER_DELETE)));
}
}
Loading…
Cancel
Save