Browse Source

feat(edayun): 对接取消前校验与取消订单

两个接口请求体同构(orderNo / poNumber 二选一,orderNo 优先级更高):
- POST /webApi/order/v1/checkCancelStatus → CancelEligibility
- POST /webApi/order/v1/cancelOrder → CancelResult

enums/EdayunCancelStatus 按文档口径映射:
- Published → FREE(可不收费取消)
- Shipment  → CHARGED(可取消但收费)
- Cancelled / InterceptSuccess / InterceptProcessing / InterceptFailure /
  UnableCancel → BLOCKED
- 未知值 → BLOCKED(取消不可逆,认不出时宁可拒绝)

**文档笔误**:响应说明里 InterceptSuccess 出现两次(一次成功一次失败)。
按订单状态字典命名,失败按 InterceptFailure 处理,已在枚举 Javadoc 注明。

cancel 的 data=false 不当异常:表示仓侧拒绝,msg 带原因,回填到 rawStatus。

不做「CHARGED 必须 acceptCharge」的强制拦截——校验与取消是两次调用,
中间状态可能变化,是否继续由宿主决定。

测试 15 个(状态映射 5 + 请求响应 10)。只跑 edayun 模块:71 个全绿。

Co-Authored-By: Claude <noreply@anthropic.com>
master
chenchuchuan 1 week ago
parent
commit
274425c0e5
  1. 42
      docs-warehouse/edayun/README.md
  2. 6
      warehouse-sdk-edayun/src/main/java/common/ecommerce/edayun/EdayunConstants.java
  3. 70
      warehouse-sdk-edayun/src/main/java/common/ecommerce/edayun/adapter/EdayunAdapter.java
  4. 67
      warehouse-sdk-edayun/src/main/java/common/ecommerce/edayun/dto/EdayunCancelDtos.java
  5. 84
      warehouse-sdk-edayun/src/main/java/common/ecommerce/edayun/enums/EdayunCancelStatus.java
  6. 62
      warehouse-sdk-edayun/src/test/java/common/ecommerce/edayun/adapter/EdayunCancelStatusTest.java
  7. 183
      warehouse-sdk-edayun/src/test/java/common/ecommerce/edayun/adapter/EdayunCancelTest.java

42
docs-warehouse/edayun/README.md

@ -11,6 +11,8 @@
| 创建出库单 | ✅ 已对接(`POST /webApi/order/v1/createOrder`) | | 创建出库单 | ✅ 已对接(`POST /webApi/order/v1/createOrder`) |
| 查询出库单 | ✅ 已对接(`POST /webApi/order/v1/getOrderInfo`) | | 查询出库单 | ✅ 已对接(`POST /webApi/order/v1/getOrderInfo`) |
| 查询面单 | ✅ 已对接(`POST /webApi/order/v1/getOrderLabel`) | | 查询面单 | ✅ 已对接(`POST /webApi/order/v1/getOrderLabel`) |
| 取消前校验 | ✅ 已对接(`POST /webApi/order/v1/checkCancelStatus`) |
| 取消订单 | ✅ 已对接(`POST /webApi/order/v1/cancelOrder`) |
| 其它业务接口 | ⬜ 等文档 | | 其它业务接口 | ⬜ 等文档 |
| 回调 | ⬜ 等文档 | | 回调 | ⬜ 等文档 |
| 真机验证 | ⬜ 等测试环境 | | 真机验证 | ⬜ 等测试环境 |
@ -234,10 +236,46 @@ POST /webApi/order/v1/getOrderLabel → List<PackageResult>(含 labelRef)
标准模型口径是**二字码**,所以优先取 `destProvince`,缺失才用全称。 标准模型口径是**二字码**,所以优先取 `destProvince`,缺失才用全称。
## 取消前校验 / 取消
```
POST /webApi/order/v1/checkCancelStatus → CancelEligibility
POST /webApi/order/v1/cancelOrder → CancelResult
```
### 取消资格映射
| 易达云 `data` | 含义 | 统一资格 |
|---|---|---|
| `Published` | 可直接取消,**不收费** | `FREE` |
| `Shipment` | 可取消,**收费** | `CHARGED` |
| `Cancelled` / `InterceptSuccess` | 已取消 / 拦截成功 | `BLOCKED` |
| `InterceptProcessing` / `InterceptFailure` | 拦截中 / 拦截失败 | `BLOCKED` |
| `UnableCancel` | 状态不允许 | `BLOCKED` |
| **未知值** | — | **`BLOCKED`** |
**未知一律归 BLOCKED**:取消有代价(可能收费、不可逆),认不出时宁可拒绝。
### 文档笔误
响应说明里 `InterceptSuccess` 出现了两次(一次是「拦截取消成功」、
一次是「拦截取消失败」)。按订单状态字典的命名,失败按 `InterceptFailure` 处理。
### 请求体优先级
两个接口请求体相同:`orderNo`(仓侧 ORD 单号)优先级高于 `poNumber`(我们的来源单号)。
实现里两个都给,让仓方按优先级取。
### 不做「收费必须 acceptCharge」拦截
`checkCancel` 与 `cancel` 是两次调用,中间状态可能变化;是否在 `CHARGED` 时继续取消
由宿主决定。`CancelResult.rawStatus()` 回填仓方的 `msg`(如「订单已出库」)。
`cancel` 返回 `data=false` 时**不是异常**——表示仓侧拒绝,`msg` 带原因。
### 本期未接的出库能力 ### 本期未接的出库能力
`query` / `cancel` / `checkCancel` 显式抛 `WarehouseUnsupportedCapabilityException` `query`(列表查询)显式抛 `WarehouseUnsupportedCapabilityException`——文档还没给。
——文档还没给这几个接口。
## 待确认(问易达云) ## 待确认(问易达云)

6
warehouse-sdk-edayun/src/main/java/common/ecommerce/edayun/EdayunConstants.java

@ -45,6 +45,12 @@ public final class EdayunConstants {
/** 查询出库单面单({@code POST /webApi/order/v1/getOrderLabel})。 */ /** 查询出库单面单({@code POST /webApi/order/v1/getOrderLabel})。 */
public static final String PATH_ORDER_LABEL = "/webApi/order/v1/getOrderLabel"; public static final String PATH_ORDER_LABEL = "/webApi/order/v1/getOrderLabel";
/** 取消前校验状态({@code POST /webApi/order/v1/checkCancelStatus})。 */
public static final String PATH_ORDER_CHECK_CANCEL = "/webApi/order/v1/checkCancelStatus";
/** 取消订单({@code POST /webApi/order/v1/cancelOrder})。 */
public static final String PATH_ORDER_CANCEL = "/webApi/order/v1/cancelOrder";
/** 物流增值:签收服务。 */ /** 物流增值:签收服务。 */
public static final String ADD_SERVICE_SIGNATURE = "is_signature"; public static final String ADD_SERVICE_SIGNATURE = "is_signature";

70
warehouse-sdk-edayun/src/main/java/common/ecommerce/edayun/adapter/EdayunAdapter.java

@ -3,9 +3,11 @@ package common.ecommerce.edayun.adapter;
import common.ecommerce.edayun.EdayunConstants; import common.ecommerce.edayun.EdayunConstants;
import common.ecommerce.edayun.auth.EdayunTokenClient; import common.ecommerce.edayun.auth.EdayunTokenClient;
import common.ecommerce.edayun.dto.EdayunCreateOrderDtos; import common.ecommerce.edayun.dto.EdayunCreateOrderDtos;
import common.ecommerce.edayun.dto.EdayunCancelDtos;
import common.ecommerce.edayun.dto.EdayunCreateProductDtos; import common.ecommerce.edayun.dto.EdayunCreateProductDtos;
import common.ecommerce.edayun.dto.EdayunGetOrderDtos; import common.ecommerce.edayun.dto.EdayunGetOrderDtos;
import common.ecommerce.edayun.dto.EdayunGetOrderLabelDtos; import common.ecommerce.edayun.dto.EdayunGetOrderLabelDtos;
import common.ecommerce.edayun.enums.EdayunCancelStatus;
import common.ecommerce.edayun.http.EdayunRequestFactory; import common.ecommerce.edayun.http.EdayunRequestFactory;
import common.ecommerce.http.HttpRequest; import common.ecommerce.http.HttpRequest;
import common.ecommerce.http.HttpResponse; import common.ecommerce.http.HttpResponse;
@ -245,14 +247,78 @@ public final class EdayunAdapter implements WarehouseAdapter, WarehouseProductCa
throw new WarehouseUnsupportedCapabilityException(WarehouseCapability.OUTBOUND); throw new WarehouseUnsupportedCapabilityException(WarehouseCapability.OUTBOUND);
} }
/**
* 取消前校验({@code POST /webApi/order/v1/checkCancelStatus})。
*
* <p>返回能不能不收费取消:{@code Published} 免费 / {@code Shipment} 收费 /
* 其余(含无法识别)按不可取消。</p>
*/
@Override @Override
public CancelEligibility checkCancel(WarehouseContext ctx, OutboundRef ref) { public CancelEligibility checkCancel(WarehouseContext ctx, OutboundRef ref) {
throw new WarehouseUnsupportedCapabilityException(WarehouseCapability.OUTBOUND); EdayunCancelDtos.CancelRequest body = cancelRequestOf(
ref.outboundRequestNo(), ref.providerOrderId());
String bodyJson = json.toJson(body);
HttpResponse resp = send(ctx, EdayunConstants.PATH_ORDER_CHECK_CANCEL, bodyJson,
"warehouse.outbound.checkCancel");
EdayunCancelDtos.CheckCancelResponse parsed =
json.fromJson(resp.body(), EdayunCancelDtos.CheckCancelResponse.class);
requireSuccess(ctx, parsed == null ? null : parsed.code,
parsed == null ? null : parsed.msg, resp, "warehouse.outbound.checkCancel");
return EdayunCancelStatus.toCore(parsed.data);
} }
/**
* 取消订单({@code POST /webApi/order/v1/cancelOrder})。
*
* <p>文档说明仓库操作后会收取取消费,可以先用 {@link #checkCancel} 判定。
* 这里不做「收费必须 acceptCharge」的强制拦截——因为校验与实际取消是两次调用,
* 中间状态可能变化;是否调用由宿主决定。收费与否通过 {@link CancelResult#cancelFee()}
* 之外的 {@code rawStatus} 与后续账单体现。</p>
*/
@Override @Override
public CancelResult cancel(WarehouseContext ctx, CancelCommand cmd) { public CancelResult cancel(WarehouseContext ctx, CancelCommand cmd) {
throw new WarehouseUnsupportedCapabilityException(WarehouseCapability.OUTBOUND); EdayunCancelDtos.CancelRequest body = cancelRequestOf(
cmd.outboundRequestNo(), cmd.providerOrderId());
String bodyJson = json.toJson(body);
HttpResponse resp = send(ctx, EdayunConstants.PATH_ORDER_CANCEL, bodyJson,
"warehouse.outbound.cancel");
EdayunCancelDtos.CancelOrderResponse parsed =
json.fromJson(resp.body(), EdayunCancelDtos.CancelOrderResponse.class);
requireSuccess(ctx, parsed == null ? null : parsed.code,
parsed == null ? null : parsed.msg, resp, "warehouse.outbound.cancel");
boolean cancelled = parsed.data != null && parsed.data;
return CancelResult.builder()
.outboundRequestNo(cmd.outboundRequestNo())
.providerOrderId(cmd.providerOrderId())
// data=false 表示仓侧拒绝,具体原因在 msg 里
.cancelled(cancelled)
.eligibility(cancelled ? CancelEligibility.FREE : CancelEligibility.BLOCKED)
.rawStatus(parsed.msg)
.build();
}
/**
* 取消类请求体:{@code orderNo}(仓侧)优先级高于 {@code poNumber}(我们的单号)。
*
* <p>与文档一致:「ORD 单号优先级更高」。</p>
*/
private static EdayunCancelDtos.CancelRequest cancelRequestOf(String outboundRequestNo,
String providerOrderId) {
EdayunCancelDtos.CancelRequest body = new EdayunCancelDtos.CancelRequest();
if (hasText(providerOrderId)) {
body.orderNo = providerOrderId.trim();
}
if (hasText(outboundRequestNo)) {
body.poNumber = outboundRequestNo.trim();
}
if (body.orderNo == null && body.poNumber == null) {
throw new IllegalArgumentException(
"edayun cancel needs outboundRequestNo (poNumber) or providerOrderId (orderNo)");
}
return body;
} }
/** /**

67
warehouse-sdk-edayun/src/main/java/common/ecommerce/edayun/dto/EdayunCancelDtos.java

@ -0,0 +1,67 @@
package common.ecommerce.edayun.dto;
import com.fasterxml.jackson.annotation.JsonInclude;
/**
* 易达云报文结构:取消相关的两个接口。
*
* <ul>
* <li>{@code POST /webApi/order/v1/checkCancelStatus} —— 取消前校验,判断是否收费</li>
* <li>{@code POST /webApi/order/v1/cancelOrder} —— 执行取消</li>
* </ul>
*
* <p>两个接口请求体相同({@code orderNo} / {@code poNumber} 二选一),
* 但响应 {@code data} 类型不同:一个是状态字符串,一个是布尔。</p>
*/
public final class EdayunCancelDtos {
private EdayunCancelDtos() {
}
/**
* 取消 / 校验的请求体。
*
* <p>{@code orderNo}(仓侧 ORD 单号)优先级高于 {@code poNumber}。</p>
*/
@JsonInclude(JsonInclude.Include.NON_NULL)
public static final class CancelRequest {
/** EDA 订单号(ORD 开头);优先级更高。 */
public String orderNo;
/** 平台单号(客户单号)。 */
public String poNumber;
}
/**
* 取消前校验的响应。
*
* <p>{@code data} 是状态字符串:</p>
* <table>
* <tr><th>值</th><th>含义</th></tr>
* <tr><td>Cancelled</td><td>已取消</td></tr>
* <tr><td>Published</td><td>可以直接取消(<b>不收费</b>)</td></tr>
* <tr><td>Shipment</td><td>可以取消(<b>收费</b>)</td></tr>
* <tr><td>InterceptProcessing</td><td>拦截取消中</td></tr>
* <tr><td>InterceptSuccess</td><td>拦截成功</td></tr>
* <tr><td>InterceptFailure</td><td>拦截失败(文档误写成两个 InterceptSuccess)</td></tr>
* <tr><td>UnableCancel</td><td>无法取消(状态不允许)</td></tr>
* </table>
*/
@JsonInclude(JsonInclude.Include.NON_NULL)
public static final class CheckCancelResponse {
public Integer code;
public String msg;
/** 取消资格状态字符串。 */
public String data;
public String traceId;
}
/** 执行取消的响应。 */
@JsonInclude(JsonInclude.Include.NON_NULL)
public static final class CancelOrderResponse {
public Integer code;
public String msg;
/** true 取消成功,其他失败。 */
public Boolean data;
public String traceId;
}
}

84
warehouse-sdk-edayun/src/main/java/common/ecommerce/edayun/enums/EdayunCancelStatus.java

@ -0,0 +1,84 @@
package common.ecommerce.edayun.enums;
import common.ecommerce.warehouse.enums.CancelEligibility;
/**
* 易达云取消资格({@code checkCancelStatus} 的 {@code data})。
*
* <p>文档口径:</p>
* <ul>
* <li>{@code Published} —— 可以直接取消,<b>不收费</b></li>
* <li>{@code Shipment} —— 可以取消,<b>收费</b></li>
* <li>{@code UnableCancel} —— 无法取消(状态不允许)</li>
* <li>{@code Cancelled} —— 已取消(无需再取消)</li>
* <li>拦截类三态 —— 取消动作已在进行中或已完成</li>
* </ul>
*
* <p><b>注意文档笔误</b>:响应说明里 `InterceptSuccess` 出现了两次
* (一次是「拦截取消成功」、一次是「拦截取消失败」)。这里按
* {@code InterceptFailure} 处理失败——与订单状态字典的命名一致。</p>
*/
public enum EdayunCancelStatus {
/** 可以直接取消(不收费)。 */
PUBLISHED("Published", CancelEligibility.FREE),
/** 可以取消(收费)。 */
SHIPMENT("Shipment", CancelEligibility.CHARGED),
/** 已取消;再取消没有意义,按不可取消处理。 */
CANCELLED("Cancelled", CancelEligibility.BLOCKED),
/** 拦截取消中。 */
INTERCEPT_PROCESSING("InterceptProcessing", CancelEligibility.BLOCKED),
/** 拦截取消成功;同「已取消」。 */
INTERCEPT_SUCCESS("InterceptSuccess", CancelEligibility.BLOCKED),
/** 拦截取消失败(文档误写成两个 InterceptSuccess)。 */
INTERCEPT_FAILURE("InterceptFailure", CancelEligibility.BLOCKED),
/** 无法取消(订单状态不允许)。 */
UNABLE_CANCEL("UnableCancel", CancelEligibility.BLOCKED),
/** 无法识别。 */
UNKNOWN(null, CancelEligibility.BLOCKED);
private final String rawValue;
private final CancelEligibility core;
EdayunCancelStatus(String rawValue, CancelEligibility core) {
this.rawValue = rawValue;
this.core = core;
}
/** 易达云原值;null 表示无法识别。 */
public String rawValue() {
return rawValue;
}
/** 对应的底层资格。 */
public CancelEligibility toCore() {
return core;
}
/**
* 易达云原值 → 平台枚举。
*
* <p><b>未知一律归 BLOCKED</b>:取消是有代价的操作(可能收费、且不可逆),
* 认不出时宁可拒绝也不能贸然放行。</p>
*/
public static EdayunCancelStatus of(String rawStatus) {
if (rawStatus == null) {
return UNKNOWN;
}
String s = rawStatus.trim();
if (s.isEmpty()) {
return UNKNOWN;
}
for (EdayunCancelStatus v : values()) {
if (v.rawValue != null && s.equalsIgnoreCase(v.rawValue)) {
return v;
}
}
return UNKNOWN;
}
/** 易达云原值 → 底层资格。 */
public static CancelEligibility toCore(String rawStatus) {
return of(rawStatus).toCore();
}
}

62
warehouse-sdk-edayun/src/test/java/common/ecommerce/edayun/adapter/EdayunCancelStatusTest.java

@ -0,0 +1,62 @@
package common.ecommerce.edayun.adapter;
import common.ecommerce.edayun.enums.EdayunCancelStatus;
import common.ecommerce.warehouse.enums.CancelEligibility;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* 取消资格映射({@code checkCancelStatus} 的 {@code data})。
*
* <p>核心原则:取消有代价(可能收费且不可逆),<b>认不出时归 BLOCKED</b>,
* 不贸然放行。</p>
*/
class EdayunCancelStatusTest {
/** 文档定义的两个「可取消」:Published 免费 / Shipment 收费。 */
@Test
void cancelableStatuses() {
assertEquals(CancelEligibility.FREE, EdayunCancelStatus.toCore("Published"));
assertEquals(CancelEligibility.CHARGED, EdayunCancelStatus.toCore("Shipment"));
}
/** 其余一律不可取消。 */
@Test
void blockingStatuses() {
for (String s : new String[] {"Cancelled", "InterceptProcessing", "InterceptSuccess",
"InterceptFailure", "UnableCancel"}) {
assertEquals(CancelEligibility.BLOCKED, EdayunCancelStatus.toCore(s), s);
}
}
/**
* 未知状态必须归 BLOCKED,不能因为「不认识」就放行。
*
* <p>反之若这里返回 FREE,宿主会在不确定的情况下发出取消请求——
* 可能产生取消费,且取消不可逆。</p>
*/
@Test
void unknownIsBlockedNotFree() {
assertEquals(CancelEligibility.BLOCKED, EdayunCancelStatus.toCore("SomeNewStatus"));
assertEquals(CancelEligibility.BLOCKED, EdayunCancelStatus.toCore(null));
assertEquals(CancelEligibility.BLOCKED, EdayunCancelStatus.toCore(""));
assertEquals(CancelEligibility.BLOCKED, EdayunCancelStatus.toCore(" "));
}
/** 大小写不敏感,但仍是精确匹配。 */
@Test
void caseInsensitiveExactMatch() {
assertEquals(CancelEligibility.FREE, EdayunCancelStatus.toCore("published"));
assertEquals(CancelEligibility.CHARGED, EdayunCancelStatus.toCore("SHIPMENT"));
// 子串不算:Published 之外的 xxPublishedxx 不应命中
assertEquals(CancelEligibility.BLOCKED, EdayunCancelStatus.toCore("NotPublished"));
}
/** 文档笔误:InterceptSuccess 出现了两次,失败按 InterceptFailure 处理。 */
@Test
void interceptFailureIsRecognised() {
assertEquals(CancelEligibility.BLOCKED, EdayunCancelStatus.toCore("InterceptFailure"));
assertEquals("InterceptFailure", EdayunCancelStatus.INTERCEPT_FAILURE.rawValue());
}
}

183
warehouse-sdk-edayun/src/test/java/common/ecommerce/edayun/adapter/EdayunCancelTest.java

@ -0,0 +1,183 @@
package common.ecommerce.edayun.adapter;
import common.ecommerce.edayun.EdayunConstants;
import common.ecommerce.edayun.dto.EdayunCancelDtos;
import common.ecommerce.shared.testkit.RecordingTransport;
import common.ecommerce.warehouse.model.CancelCommand;
import common.ecommerce.warehouse.model.CancelResult;
import common.ecommerce.warehouse.model.OutboundRef;
import common.ecommerce.warehouse.enums.CancelEligibility;
import common.ecommerce.warehouse.sdk.WarehouseConnection;
import common.ecommerce.warehouse.sdk.WarehouseContext;
import common.ecommerce.warehouse.enums.WarehouseProvider;
import common.ecommerce.http.JacksonJsonCodec;
import common.ecommerce.shared.spi.ChannelSecret;
import common.ecommerce.shared.testkit.Responses;
import org.junit.jupiter.api.Test;
import java.time.Clock;
import java.time.Instant;
import java.time.ZoneOffset;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* 取消前校验与取消订单的请求构造与响应映射。
*
* <p>不实际发请求——用 RecordingTransport 打桩。</p>
*/
class EdayunCancelTest {
private static final Clock CLOCK = Clock.fixed(Instant.parse("2026-11-12T00:00:00Z"), ZoneOffset.UTC);
private static final String BASE = "https://api.edayun.test";
private static WarehouseContext ctx() {
return WarehouseContext.of("EDY-WH-1", WarehouseProvider.EDAYUN, "2",
WarehouseConnection.of(BASE,
ChannelSecret.builder()
.appKey("ak").appSecret("sk")
.clientId("u").clientSecret("p").build()),
"req-1", CLOCK);
}
/** 每次业务调用前会先取 token,所以桩里要同时路由 /oauth/token。 */
private static EdayunAdapter adapter(RecordingTransport transport) {
return new EdayunAdapter(transport, new JacksonJsonCodec());
}
/** 带 token 路由的传输层。 */
private static RecordingTransport transport() {
return RecordingTransport.create()
.route(EdayunConstants.PATH_TOKEN, req -> Responses.ok(
"{\"access_token\":\"T1\",\"token_type\":\"bearer\"}"));
}
// ------------------------------------------------------------ 校验
@Test
void checkCancelMapsPublishedToFree() {
RecordingTransport transport = transport()
.route(EdayunConstants.PATH_ORDER_CHECK_CANCEL, req -> Responses.ok(
"{\"code\":200,\"msg\":\"ok\",\"data\":\"Published\",\"traceId\":\"t\"}"));
CancelEligibility eligibility = adapter(transport)
.checkCancel(ctx(), OutboundRef.ofRequestNo("P-20261112"));
assertEquals(CancelEligibility.FREE, eligibility);
String body = transport.lastDataRequest().body();
assertTrue(body.contains("\"poNumber\":\"P-20261112\""), body);
}
@Test
void checkCancelMapsShipmentToCharged() {
RecordingTransport transport = transport()
.route(EdayunConstants.PATH_ORDER_CHECK_CANCEL, req -> Responses.ok(
"{\"code\":200,\"data\":\"Shipment\"}"));
assertEquals(CancelEligibility.CHARGED, adapter(transport)
.checkCancel(ctx(), OutboundRef.ofRequestNo("P-1")));
}
@Test
void checkCancelMapsUnableCancelToBlocked() {
RecordingTransport transport = transport()
.route(EdayunConstants.PATH_ORDER_CHECK_CANCEL, req -> Responses.ok(
"{\"code\":200,\"data\":\"UnableCancel\"}"));
assertEquals(CancelEligibility.BLOCKED, adapter(transport)
.checkCancel(ctx(), OutboundRef.ofRequestNo("P-1")));
}
/** 按仓单号引用时走 orderNo(文档说优先级更高)。 */
@Test
void checkCancelSendsOrderNoWhenGivenProviderOrderId() {
RecordingTransport transport = transport()
.route(EdayunConstants.PATH_ORDER_CHECK_CANCEL, req -> Responses.ok(
"{\"code\":200,\"data\":\"Published\"}"));
adapter(transport).checkCancel(ctx(), OutboundRef.ofProviderOrderId("ORD-9"));
String body = transport.lastDataRequest().body();
assertTrue(body.contains("\"orderNo\":\"ORD-9\""), body);
org.junit.jupiter.api.Assertions.assertFalse(body.contains("poNumber"), body);
}
/** OutboundRef 本身要求两个单号至少给一个。 */
@Test
void checkCancelRejectsWithoutAnyNumber() {
org.junit.jupiter.api.Assertions.assertThrows(IllegalArgumentException.class,
() -> OutboundRef.ofRequestNo(""));
}
// ------------------------------------------------------------ 取消
@Test
void cancelSucceeds() {
RecordingTransport transport = transport()
.route(EdayunConstants.PATH_ORDER_CANCEL, req -> Responses.ok(
"{\"code\":200,\"msg\":\"ok\",\"data\":true}"));
CancelResult result = adapter(transport).cancel(ctx(),
CancelCommand.builder().outboundRequestNo("P-1").build());
assertTrue(result.cancelled());
assertEquals(CancelEligibility.FREE, result.eligibility());
assertEquals("ok", result.rawStatus());
}
/** data=false 表示仓侧拒绝,不是异常;msg 带原因。 */
@Test
void cancelRejectedByWarehouse() {
RecordingTransport transport = transport()
.route(EdayunConstants.PATH_ORDER_CANCEL, req -> Responses.ok(
"{\"code\":200,\"msg\":\"订单已出库\",\"data\":false}"));
CancelResult result = adapter(transport).cancel(ctx(),
CancelCommand.builder().outboundRequestNo("P-1").build());
assertFalse(result.cancelled());
assertEquals(CancelEligibility.BLOCKED, result.eligibility());
assertEquals("订单已出库", result.rawStatus());
}
/** 业务码非 200 要抛,而不是当成「取消失败」。 */
@Test
void nonSuccessBusinessCodeThrows() {
RecordingTransport transport = transport()
.route(EdayunConstants.PATH_ORDER_CANCEL, req -> Responses.ok(
"{\"code\":500,\"msg\":\"参数错误\"}"));
org.junit.jupiter.api.Assertions.assertThrows(RuntimeException.class,
() -> adapter(transport).cancel(ctx(),
CancelCommand.builder().outboundRequestNo("P-1").build()));
}
/** 请求体字段是 orderNo / poNumber。 */
@Test
void cancelUsesSameRequestBodyShape() {
RecordingTransport transport = transport()
.route(EdayunConstants.PATH_ORDER_CANCEL, req -> Responses.ok(
"{\"code\":200,\"data\":true}"));
adapter(transport).cancel(ctx(),
CancelCommand.builder().outboundRequestNo("P-1").build());
String body = transport.lastDataRequest().body();
assertTrue(body.contains("\"poNumber\":\"P-1\""), body);
org.junit.jupiter.api.Assertions.assertFalse(body.contains("acceptCharge"));
}
/** 校验与取消的请求体同构(复用 CancelRequest)。 */
@Test
void bothEndpointsShareRequestShape() {
EdayunCancelDtos.CancelRequest req = new EdayunCancelDtos.CancelRequest();
req.orderNo = "ORD-1";
req.poNumber = "P-1";
String json = new JacksonJsonCodec().toJson(req);
assertTrue(json.contains("\"orderNo\":\"ORD-1\""), json);
assertTrue(json.contains("\"poNumber\":\"P-1\""), json);
}
}
Loading…
Cancel
Save