AiDOPWarehouse/server/Admin.NET.Test/S8/S8OrderDeliveryRule02Tests.cs

using System.Reflection;
using System.Text.RegularExpressions;
using Admin.NET.Plugin.AiDOP.Entity.S8;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules.DataAccess;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules.DataAccess.Providers;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules.Definitions;
using Xunit;

namespace Admin.NET.Test.S8;

/// <summary>
/// S8-RULE02-ORDER-DELIVERY-WARNING-1：订单交付延期预警的结构契约。
///
/// <para>本文件锁定的每一条，都对应一种「代码照样跑、结论却是错的」的失效形态：</para>
/// <list type="bullet">
///   <item><b>ETA 必须来自源系统</b>——一旦有人用「交期前 N 天」「历史均值」「已完工数量倒推」
///     补一个 ETA，规则会从"预测"退化成"临期提醒"，而输出格式完全一样，看不出来。</item>
///   <item><b>只判未到期</b>——去掉 <c>plan_date &gt;= NOW()</c> 会让 385 条历史逾期单一次性涌进来，
///     且永远不会恢复。这不是"多报几条"，是这条规则从预警变成了积压清单。</item>
///   <item><b>身份是订单行</b>——退化成订单号会让同单多行只剩一条异常，其余行静默消失。</item>
///   <item><b>DedupKey 预算</b>——超预算的键被数据库截断后，两个订单行折叠成一条异常，无任何报错。</item>
///   <item><b>SQL 别名映射</b>——本仓 <c>EnableUnderLine = false</c>，别名写错会静默映射为 null，
///     行数照常返回但命中恒为 0（Rule 01 真实踩过一次）。</item>
/// </list>
///
/// <para>不接 DB、不接 DI。真库行为已由实施前只读核验覆盖（390 行 / 40 行有 ETA / 命中 2 条），
/// 本文件锁定的是结构。</para>
/// </summary>
public class S8OrderDeliveryRule02Tests
{
    private const long TenantId = 838257186181189;
    private const string RuleCode = S8OrderDeliveryRuleDefinitions.OrderDeliveryDelayWarningCode;

    private static readonly S8RuleCatalog Catalog =
        new(new IS8RuleDefinitionSource[]
        {
            new S8PurchaseDeliveryRuleDefinitions(),
            new S8OrderDeliveryRuleDefinitions()
        });

    private static S8RuleDefinition Definition => Catalog.GetRequired(RuleCode);

    private static AdoS8WatchRule NewRule() => new()
    {
        Id = 900201,
        RuleCode = RuleCode,
        SceneCode = "S1",
        WatchObjectType = S8OrderDeliveryRuleDefinitions.SalesOrderLineObjectType,
        SourceObjectType = S8OrderDeliveryRuleDefinitions.SalesOrderLineObjectType,
        Severity = "FOLLOW",
        RuleType = S8OutOfRangeRuleEvaluator.RuleTypeCode,
        DatasetCode = S8OrderDeliveryDatasetDefinitions.OrderDeliveryRiskCode
    };

    private static S8EffectiveRule Effective(AdoS8WatchRule rule) =>
        S8EffectiveRule.Resolve(rule, Definition);

    /// <summary>
    /// 构造一行订单行事实。<paramref name="delayDays"/> 是 Provider 在 SQL 里算好的
    /// <c>DATEDIFF(sys_capacity_date, plan_date)</c>，此处显式传入以便逐值锁定判定边界。
    /// </summary>
    private static S8OrderDeliveryDataProvider.OrderDeliveryRow Row(
        string billNo, int entrySeq, DateTime planDate, DateTime? sysCapacityDate,
        decimal? delayDays, decimal qty = 1000m, string itemName = "集控备机",
        string customName = "内部客户") => new()
    {
        SourceObjectId = $"{billNo}#{entrySeq}",
        RelatedObjectCode = billNo,
        RelatedObjectName = customName,
        DueAt = planDate,
        DelayDays = delayDays,
        BillNo = billNo,
        EntrySeq = entrySeq,
        PlanDate = planDate,
        SysCapacityDate = sysCapacityDate,
        Qty = qty,
        ItemNumber = "IT-0001",
        ItemName = itemName,
        CustomNo = "C-0001",
        CustomName = customName,
        OrderBillNo = billNo
    };

    private static S8MonitoringRowSet RowSet(params S8OrderDeliveryDataProvider.OrderDeliveryRow[] rows) =>
        S8MonitoringRowSet.FromRows(
            rows.Select(r => S8MonitoringRow.FromValues(S8OrderDeliveryDataProvider.ToCanonicalValues(r))));

    /// <summary>去掉块注释与行注释后的 SQL —— 断言只应看真正会执行的文本。</summary>
    private static string SqlWithoutComments() =>
        Regex.Replace(
            Regex.Replace(S8OrderDeliveryDataProvider.Sql, @"/\*.*?\*/", " ", RegexOptions.Singleline),
            @"--[^\n]*", " ");

    // ============================================================
    // A. 数据集定义与 Provider 的一致性
    // ============================================================

    [Fact]
    public void T1_Dataset_IsDeclared_WithOutOfRangeCapabilityOnly()
    {
        var definition = Assert.Single(new S8OrderDeliveryDatasetDefinitions().GetDefinitions());

        Assert.Equal(S8OrderDeliveryDatasetDefinitions.OrderDeliveryRiskCode, definition.DatasetCode);
        Assert.Equal(S8DatasetStatus.Defined, definition.Status);

        var c = definition.Capabilities;
        Assert.True(c.SupportsOutOfRange);
        Assert.True(c.HasMeasuredValue);
        Assert.True(c.HasSourceObjectId);
        Assert.True(c.HasRelatedObjectCode);

        // TIMEOUT / SHORTAGE 必须关闭：本数据集不表达「到期日已过」也不表达「数量缺口」。
        // 多声明一项能力会让配置页把跑不通的规则类型列成可选，用户配完才在运行期失败。
        Assert.False(c.SupportsTimeout);
        Assert.False(c.SupportsShortage);
    }

    [Fact]
    public void T2_Provider_And_Catalog_ShareTheSameCapabilityInstance()
    {
        var provider = new S8OrderDeliveryDataProvider(null!, null!);
        var definition = Assert.Single(new S8OrderDeliveryDatasetDefinitions().GetDefinitions());

        // 同一实例而非"值相等"：两处各写一份能力声明迟早会漂移，
        // 而漂移的表现是 Enable Gate 与 evaluator 对同一数据集有不同认知。
        Assert.Same(definition.Capabilities, provider.Capabilities);
        Assert.Equal(definition.DatasetCode, provider.DatasetCode);
    }

    [Fact]
    public void T3_RuleDefinition_PointsAtTheRegisteredDataset()
    {
        Assert.Equal(S8OrderDeliveryDatasetDefinitions.OrderDeliveryRiskCode, Definition.DatasetCode);
        Assert.Equal(new S8OrderDeliveryDataProvider(null!, null!).DatasetCode, Definition.DatasetCode);
    }

    [Fact]
    public void T4_RuleCatalog_AcceptsBothRules_WithoutCodeCollision()
    {
        // Catalog 构造期即做完整性校验 + 重复 rule_code 检测；能构造出来本身就是断言。
        Assert.True(Catalog.IsDefined(RuleCode));
        Assert.True(Catalog.IsDefined(S8PurchaseDeliveryRuleDefinitions.PurchaseDeliveryDateDelayCode));
        Assert.Equal(2, Catalog.Definitions.Count);
    }

    // ============================================================
    // B. SQL 契约：ETA 来源、时间窗、身份粒度
    // ============================================================

    [Fact]
    public void T5_Sql_RequiresRealEta_AndNeverSynthesizesOne()
    {
        var sql = SqlWithoutComments();

        // ETA 必须来自源系统字段，且缺失即出局。
        // （「ETA 是否晚于交期」不在这里判 —— 那是 evaluator 的事，见 T6 / T15 / T16。）
        Assert.Contains("e.sys_capacity_date IS NOT NULL", sql, StringComparison.Ordinal);
        Assert.Contains("DATEDIFF(e.sys_capacity_date, e.plan_date)", sql, StringComparison.Ordinal);

        // 以下任何一个出现，都意味着有人在自造 ETA：
        //   DATE_ADD / DATE_SUB / INTERVAL → 用「交期前 N 天」冒充预测
        //   AVG                            → 用历史均值造 ETA
        //   QtyCompleted / work_ord        → 用工单完工量倒推（该列真库 267 行全为 0）
        //   deliver_count                  → 已发数量，真库 100% 为空
        foreach (var forbidden in new[]
                 {
                     "DATE_ADD", "DATE_SUB", "INTERVAL", "AVG(",
                     "QtyCompleted", "qty_completed", "work_ord", "WorkOrd", "deliver_count"
                 })
        {
            Assert.DoesNotContain(forbidden, sql, StringComparison.OrdinalIgnoreCase);
        }
    }

    [Fact]
    public void T6_Sql_MustNotFilterByTimeOrByDelay_OrFalseRecoveryComesBack()
    {
        var sql = SqlWithoutComments();

        // ⚠️ 本仓最容易被"好心改回去"的一条。
        //
        // S8 的恢复判定唯一依据是「dedup_key 还在不在本轮 hits 里」
        // （ReconcileRecoveriesForRuleAsync），它无法区分「行不在结果集里」与
        // 「行还在但不越界」。所以任何被 SQL 滤掉的行 = 风险已解除。
        //
        // · 加回 plan_date >= NOW() → 订单跨过客户交期时行消失 → 风险**兑现**的那一刻
        //   被标成"已恢复"。这是 2026-09-07 实测复现并修掉的缺陷。
        // · 加回 sys_capacity_date > plan_date → ETA 修回时行同样消失，恢复结论碰巧对、
        //   理由是错的：正确的恢复形态必须是"行还在但不再命中"。
        //
        // 「只在到期前立案」由规则定义的 CreateOnlyBeforeDueAt 表达，不在取数层。
        Assert.DoesNotContain("NOW()", sql, StringComparison.OrdinalIgnoreCase);
        Assert.DoesNotContain("CURDATE", sql, StringComparison.OrdinalIgnoreCase);
        Assert.DoesNotContain("CURRENT_DATE", sql, StringComparison.OrdinalIgnoreCase);
        Assert.DoesNotContain("@Now", sql, StringComparison.OrdinalIgnoreCase);
        Assert.DoesNotContain("e.sys_capacity_date > e.plan_date", sql, StringComparison.Ordinal);

        // 反面：取数仍必须要求 ETA 存在 —— 没有 ETA 就没有判定依据，
        // 这条过滤与生命周期无关，去掉它会让 350 条无 ETA 的行涌进来。
        Assert.Contains("e.sys_capacity_date IS NOT NULL", sql, StringComparison.Ordinal);
    }

    [Fact]
    public void T7_Sql_ScopesByTenant_AndExcludesClosedOrDeletedOrders()
    {
        var sql = SqlWithoutComments();

        Assert.Contains("e.tenant_id = @TenantId", sql, StringComparison.Ordinal);
        Assert.Contains("o.closed = 0", sql, StringComparison.Ordinal);
        Assert.Contains("o.IsDeleted = 0", sql, StringComparison.Ordinal);
        Assert.Contains("e.IsDeleted = 0", sql, StringComparison.Ordinal);

        // 租户是唯一的安全边界（Phase 1 拍板）。补 factory_id 过滤会让规则恒返 0 行且不报错。
        Assert.DoesNotContain("factory_id", sql, StringComparison.OrdinalIgnoreCase);
    }

    [Fact]
    public void T8_Sql_IsReadOnly()
    {
        var sql = SqlWithoutComments();

        // 必须按整词匹配：软删列名 IsDeleted 内含 "Delete"，子串匹配会把一条只读 SQL 判成写操作。
        foreach (var write in new[] { "INSERT", "UPDATE", "DELETE", "REPLACE", "TRUNCATE", "ALTER", "DROP" })
            Assert.False(Regex.IsMatch(sql, $@"\b{write}\b", RegexOptions.IgnoreCase),
                $"取数 SQL 中出现写操作关键字 {write}；本 Provider 只允许 SELECT");
    }

    [Fact]
    public void T9_Sql_UsesOrderLineGrain_NotOrderGrain()
    {
        var sql = SqlWithoutComments();

        // 身份 = 单号 + 行号。退化成单号会让同一张订单的多个风险行只留下一条异常。
        Assert.Contains("CONCAT(e.bill_no, '#', e.entry_seq)", sql, StringComparison.Ordinal);
        Assert.Contains("e.entry_seq IS NOT NULL", sql, StringComparison.Ordinal);
        Assert.Contains("e.bill_no <> ''", sql, StringComparison.Ordinal);

        // 明细挂在 crm_seorderentry 上；主表只用来取客户与关闭状态。
        Assert.Contains("FROM crm_seorderentry e", sql, StringComparison.Ordinal);
        Assert.Contains("JOIN crm_seorder o ON o.Id = e.seorder_id", sql, StringComparison.Ordinal);
    }

    [Fact]
    public void T10_Sql_DoesNotReadProgress_BecauseItIsNotCompletionRate()
    {
        // crm_seorderentry.progress 是字符串状态码（0=再评审 1=新建 2=评审 3=确认），
        // 不是完成百分比。把它当进度用会得到一个看起来合理、实际无意义的判据。
        Assert.DoesNotContain("progress", SqlWithoutComments(), StringComparison.OrdinalIgnoreCase);
    }

    // ============================================================
    // C. SQL 别名 ↔ POCO 映射（EnableUnderLine = false 的静默失败防线）
    // ============================================================

    [Fact]
    public void T11_EverySelectAlias_MapsToRowProperty_AndViceVersa()
    {
        var aliases = Regex
            .Matches(S8OrderDeliveryDataProvider.Sql, @"\bAS\s+([A-Za-z_][A-Za-z0-9_]*)", RegexOptions.IgnoreCase)
            .Select(m => m.Groups[1].Value)
            .ToArray();

        var props = typeof(S8OrderDeliveryDataProvider.OrderDeliveryRow)
            .GetProperties(BindingFlags.Public | BindingFlags.Instance)
            .Select(p => p.Name)
            .ToArray();

        Assert.NotEmpty(aliases);

        // Ordinal 比较：SqlSugar 的名字匹配不该靠"大概能对上"来赌。
        var unmapped = aliases.Where(a => !props.Contains(a, StringComparer.Ordinal)).ToArray();
        Assert.True(unmapped.Length == 0,
            "以下 SQL 别名在 OrderDeliveryRow 上找不到同名属性，SqlSugar 会静默映射为 null：\n  "
            + string.Join("\n  ", unmapped));

        var uncovered = props.Where(p => !aliases.Contains(p, StringComparer.Ordinal)).ToArray();
        Assert.True(uncovered.Length == 0,
            "以下属性没有任何 SQL 别名覆盖，取数后恒为 null：\n  " + string.Join("\n  ", uncovered));
    }

    [Fact]
    public void T12_CanonicalMapping_PutsDelayDaysIntoMeasuredValue()
    {
        var values = S8OrderDeliveryDataProvider.ToCanonicalValues(
            Row("SO202609030003", 1, new DateTime(2026, 9, 30), new DateTime(2026, 10, 12), 12m));

        // measured_value 是判定输入；放错列 = evaluator 拿不到值 = 命中恒为 0。
        Assert.Equal(12m, Assert.IsType<decimal>(values[S8CanonicalColumns.MeasuredValue]));
        Assert.Equal("SO202609030003#1", values[S8CanonicalColumns.SourceObjectId]);
        Assert.Equal("SO202609030003", values[S8CanonicalColumns.RelatedObjectCode]);

        // due_at 随行输出供展示与排序，但不参与判定（数据集能力里 SupportsTimeout=false）。
        Assert.Equal(new DateTime(2026, 9, 30), values[S8CanonicalColumns.DueAt]);

        // 两个原始日期必须一并落 payload：延期天数是差值，脱离两端就无法复盘。
        Assert.Equal(new DateTime(2026, 9, 30), values["plan_date"]);
        Assert.Equal(new DateTime(2026, 10, 12), values["sys_capacity_date"]);
    }

    [Fact]
    public void T13_DedupKeyBudget_LeavesRoomForRealOrderLineIds()
    {
        var request = new S8MonitoringDataRequest
        {
            TenantId = TenantId,
            DatasetCode = S8OrderDeliveryDatasetDefinitions.OrderDeliveryRiskCode,
            RuleCode = RuleCode,
            RuleType = S8OutOfRangeRuleEvaluator.RuleTypeCode
        };

        var budget = S8OrderDeliveryDataProvider.ResolveSourceObjectIdBudget(request);

        // 预算随租户 / 规则编码变化，故现算而不是写死。真实身份形如 SO202609030003#1（16 字符）。
        Assert.True(budget >= "SO202609030003#1".Length,
            $"dedup_key 预算 {budget} 已经容不下真实订单行标识，Provider 会开始静默跳过行");

        var expectedPrefix =
            $"T{TenantId}:R{RuleCode}:{S8OrderDeliveryRuleDefinitions.SalesOrderLineObjectType}:";
        Assert.Equal(
            S8OrderDeliveryDataProvider.DedupKeyMaxLength - expectedPrefix.Length, budget);
    }

    // ============================================================
    // D. 判定：越界方向、边界值、身份
    // ============================================================

    [Fact]
    public void T14_Hits_WhenSystemEtaIsLaterThanCustomerDueDate()
    {
        // 真库 dry-run 的两条命中之一：SO202609030003#1，要求 09-30，系统建议 10-12，晚 12 天。
        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            RowSet(Row("SO202609030003", 1, new DateTime(2026, 9, 30), new DateTime(2026, 10, 12), 12m)),
            Effective(NewRule()), TenantId, new DateTime(2026, 9, 7));

        var hit = Assert.Single(hits);
        Assert.Equal("ORDER_DELIVERY_DELAY_WARNING", hit.ExceptionTypeCode);
        Assert.Equal("SALES_ORDER_LINE", hit.SourceObjectType);
        Assert.Equal("SO202609030003#1", hit.SourceObjectId);
        Assert.Equal("SO202609030003", hit.RelatedObjectCode);
        Assert.Equal("S1", hit.SceneCode);
        Assert.Equal("FOLLOW", hit.Severity);
        Assert.Equal(
            $"T{TenantId}:R{RuleCode}:SALES_ORDER_LINE:SO202609030003#1", hit.DedupKey);

        // 方向与偏差必须落 payload：业务看到的"晚几天"就是这个 deviation。
        Assert.Contains("\"direction\":\"ABOVE_UPPER\"", hit.SourcePayload, StringComparison.Ordinal);
        Assert.Contains("\"deviation\":12", hit.SourcePayload, StringComparison.Ordinal);
        Assert.Contains("delay_days", hit.SourcePayload, StringComparison.Ordinal);
    }

    [Fact]
    public void T15_NoHit_WhenEtaEqualsDueDate()
    {
        // 上限为 0、容差为 0：正好赶上不算延期。这是边界，写错一个符号就会把
        // 全部"刚好按期"的订单报成异常。
        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            RowSet(Row("SO-ONTIME", 1, new DateTime(2026, 9, 30), new DateTime(2026, 9, 30), 0m)),
            Effective(NewRule()), TenantId, new DateTime(2026, 9, 7));

        Assert.Empty(hits);
    }

    [Fact]
    public void T16_NoHit_WhenEtaIsEarlierThanDueDate()
    {
        // 提前完成是好事。LowerBound 未设 → 不存在"太早也算异常"这条判据。
        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            RowSet(Row("SO-EARLY", 1, new DateTime(2026, 9, 30), new DateTime(2026, 9, 20), -10m)),
            Effective(NewRule()), TenantId, new DateTime(2026, 9, 7));

        Assert.Empty(hits);
        Assert.Null(Definition.OutOfRange!.LowerBound);
    }

    [Fact]
    public void T17_NoHit_WhenEtaIsMissing()
    {
        // 没有 ETA = 没有证据。SQL 已经滤掉这类行，此处再锁一次判定层：
        // 即便将来有人放宽 SQL，evaluator 也不会凭空判它延期。
        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            RowSet(Row("SO-NO-ETA", 1, new DateTime(2026, 9, 30), null, null)),
            Effective(NewRule()), TenantId, new DateTime(2026, 9, 7));

        Assert.Empty(hits);
    }

    [Fact]
    public void T18_EachOrderLine_GetsItsOwnException()
    {
        // 真库 dry-run 的两条命中分属两张订单；这里用同一张单的两行，
        // 锁住"同单多行不会被折叠成一条"。
        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            RowSet(
                Row("SO202609030004", 1, new DateTime(2026, 9, 30), new DateTime(2026, 10, 12), 12m),
                Row("SO202609030004", 2, new DateTime(2026, 10, 15), new DateTime(2026, 10, 20), 5m)),
            Effective(NewRule()), TenantId, new DateTime(2026, 9, 7));

        Assert.Equal(2, hits.Count);
        Assert.Equal(2, hits.Select(h => h.DedupKey).Distinct(StringComparer.Ordinal).Count());
        Assert.Contains(hits, h => h.SourceObjectId == "SO202609030004#1");
        Assert.Contains(hits, h => h.SourceObjectId == "SO202609030004#2");
    }

    // ============================================================
    // E. 规则定义契约
    // ============================================================

    [Fact]
    public void T19_Rule_IsOutOfRange_WithZeroUpperBoundAndNoInventedTolerance()
    {
        Assert.Equal(S8OutOfRangeRuleEvaluator.RuleTypeCode, Definition.RuleType);

        var semantics = Definition.OutOfRange!;
        Assert.Equal(0m, semantics.UpperBound);

        // 容差非 0 意味着"晚 N 天以内不报"——本批没有任何业务依据支持这样一个数字，
        // 凭空填值会静默过滤掉真实风险。要放宽必须由业务给出天数。
        Assert.Equal(0m, semantics.ToleranceAbs);
        Assert.Equal(0m, semantics.ToleranceRatio);

        // 行内上下限列未启用：上限是"不延期"这个定义本身，不随行变化。
        Assert.Null(semantics.UpperBoundColumn);
        Assert.Null(semantics.LowerBoundColumn);
    }

    [Fact]
    public void T20_Rule_DeclaresAllFourReadinessGates()
    {
        var policy = Definition.Parameters!;

        // 每一条都对应一种运行期静默断裂，理由见规则定义处的注释。
        Assert.True(policy.RequiresDepartmentDefaultsForEnable);  // 数据集无部门列 → 建单必失败
        Assert.True(policy.RequiresHandlerPoolForEnable);         // 无人认领
        Assert.True(policy.RequiresVerification);                 // 复核候选为空，卡在 IN_PROGRESS
        Assert.True(policy.SupportsTimeoutEscalation);            // SLA 240 分钟 → 必进升级扫描

        // 预警不是事故：客户交期尚未到达，仍有处置窗口。与异常类型自身默认严重度一致。
        Assert.Equal("FOLLOW", policy.SeverityDefault);
    }

    [Fact]
    public void T21_Rule_CarriesBusinessFacingCopy_WithoutImplementationLeakage()
    {
        // 配置页展示的是"这条规则按什么判"，不是"它怎么实现的"。
        Assert.False(string.IsNullOrWhiteSpace(Definition.JudgementSummary));
        Assert.False(string.IsNullOrWhiteSpace(Definition.DedupIdentitySummary));

        foreach (var leak in new[]
                 {
                     "crm_seorderentry", "crm_seorder", "DATEDIFF",
                     "sys_capacity_date", "plan_date", "measured_value", "SQL"
                 })
        {
            Assert.DoesNotContain(leak, Definition.JudgementSummary!, StringComparison.OrdinalIgnoreCase);
            Assert.DoesNotContain(leak, Definition.DedupIdentitySummary!, StringComparison.OrdinalIgnoreCase);
        }
    }

    // ============================================================
    // F. 生命周期：CREATE → KEEP ACTIVE → RECOVER
    //
    // 这一组是 S8-RULE-LIFECYCLE-CREATE-GATE-1 的核心回归。它守护的不是
    // 「测试能过」，而是一条已经被系统识别出来的延期风险，
    // 不会因为客户交期真正到达反而被标记成"已恢复"。
    // ============================================================

    private const string LifecycleBillNo = "SO-LIFECYCLE-001";
    private const int LifecycleEntrySeq = 1;

    /// <summary>三个周期共用同一业务键；到期日与 ETA 按周期变化。</summary>
    private static S8MonitoringRowSet LifecycleRow(DateTime planDate, DateTime sysCapacityDate) =>
        RowSet(Row(LifecycleBillNo, LifecycleEntrySeq, planDate, sysCapacityDate,
            (decimal)(sysCapacityDate - planDate).TotalDays));

    [Fact]
    public void T22_Cycle1_FutureDueDate_Hits_AndIsCreateEligible()
    {
        // 客户交期 10-31 尚未到达，系统建议交期 11-12 —— 晚 12 天。
        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            LifecycleRow(new DateTime(2026, 10, 31), new DateTime(2026, 11, 12)),
            Effective(NewRule()), TenantId, detectedAt: new DateTime(2026, 10, 1));

        var hit = Assert.Single(hits);
        Assert.True(hit.CreateEligible, "交期未到的风险必须允许首次立案，否则这条规则永远建不出单");
    }

    [Fact]
    public void T23_Cycle2_AfterDueDate_StillHits_ButIsNotCreateEligible()
    {
        // 时间走到 11-01：客户交期（10-31）已经过去，而系统建议交期（11-12）一天没改。
        // 风险不但没解除，是**兑现**了。
        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            LifecycleRow(new DateTime(2026, 10, 31), new DateTime(2026, 11, 12)),
            Effective(NewRule()), TenantId, detectedAt: new DateTime(2026, 11, 1));

        var hit = Assert.Single(hits);

        // ① 仍然是命中 —— 这一条是整个修复的支点。
        //    只要它还在 hits 里，ReconcileRecoveriesForRuleAsync 就会因为
        //    hitDedupKeys.Contains(dedupKey) 而直接 continue，既有异常不累计 miss、不被恢复。
        //    把它从 hits 里剔除（哪怕理由是"反正不建单"）＝ 假恢复原地复活。
        Assert.NotEmpty(hits);

        // ② 但不允许再开一个新案子。
        Assert.False(hit.CreateEligible);
    }

    [Fact]
    public void T24_Cycle1And2_ShareTheSameDedupKey_SoTheSameExceptionIsMatched()
    {
        // 跨交期前后必须是同一个 dedup_key —— 否则 Cycle 2 既找不到既有异常去 refresh，
        // 也保护不了它，等于换一种方式把它放掉。
        var before = Assert.Single(S8OutOfRangeRuleEvaluator.EvaluateRows(
            LifecycleRow(new DateTime(2026, 10, 31), new DateTime(2026, 11, 12)),
            Effective(NewRule()), TenantId, new DateTime(2026, 10, 1)));

        var after = Assert.Single(S8OutOfRangeRuleEvaluator.EvaluateRows(
            LifecycleRow(new DateTime(2026, 10, 31), new DateTime(2026, 11, 12)),
            Effective(NewRule()), TenantId, new DateTime(2026, 11, 1)));

        Assert.Equal(before.DedupKey, after.DedupKey);
        Assert.Equal(before.SourceObjectId, after.SourceObjectId);
        Assert.NotEqual(before.CreateEligible, after.CreateEligible);
    }

    [Fact]
    public void T25_Cycle3_EtaPulledBackWithinDueDate_StopsHitting()
    {
        // 重新评审把建议交期拉回到 10-31（不晚于要求交期）→ 不再命中。
        // 行仍在数据集里（SQL 不滤延期条件），是 evaluator 判它不越界 ——
        // 这是本规则唯一合法的恢复形态：连续 RecoverCountRequired 轮未命中后写 recovered_at。
        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            LifecycleRow(new DateTime(2026, 10, 31), new DateTime(2026, 10, 31)),
            Effective(NewRule()), TenantId, detectedAt: new DateTime(2026, 11, 1));

        Assert.Empty(hits);
    }

    [Fact]
    public void T26_FullCycle_Create_KeepActive_Recover()
    {
        var rule = Effective(NewRule());
        var due = new DateTime(2026, 10, 31);
        var lateEta = new DateTime(2026, 11, 12);

        // Cycle 1 —— 交期未到，ETA 晚 → 命中且可立案
        var c1 = S8OutOfRangeRuleEvaluator.EvaluateRows(
            LifecycleRow(due, lateEta), rule, TenantId, new DateTime(2026, 10, 1));
        // Cycle 2 —— 交期已过，ETA 仍晚 → 仍命中，但不可立案（保持 active）
        var c2 = S8OutOfRangeRuleEvaluator.EvaluateRows(
            LifecycleRow(due, lateEta), rule, TenantId, new DateTime(2026, 11, 1));
        // Cycle 3 —— ETA 拉回交期以内 → 不再命中（合法恢复）
        var c3 = S8OutOfRangeRuleEvaluator.EvaluateRows(
            LifecycleRow(due, due), rule, TenantId, new DateTime(2026, 11, 8));

        Assert.True(Assert.Single(c1).CreateEligible);
        Assert.False(Assert.Single(c2).CreateEligible);
        Assert.Empty(c3);

        // 关键否定断言：Cycle 2 不得表现为"不再命中"。
        Assert.Contains(Assert.Single(c1).DedupKey, c2.Select(h => h.DedupKey));
    }

    [Fact]
    public void T27_HistoricalRowsHit_ButNoneOfThemMayOpenANewCase()
    {
        // 真库形态的缩影：2 条未到期 + 7 条已过期，全部 ETA 晚。
        // 取消 SQL 时间过滤后 9 条都会命中；允许立案的必须只有那 2 条。
        // 用 fixture 表达数量关系，不绑定真实单号。
        const int futureCount = 2;
        const int historicalCount = 7;
        var detectedAt = new DateTime(2026, 9, 7);
        var rows = new List<S8OrderDeliveryDataProvider.OrderDeliveryRow>();

        for (var i = 0; i < futureCount; i++)
            rows.Add(Row($"SO-FUTURE-{i}", 1, detectedAt.AddDays(23), detectedAt.AddDays(35), 12m));
        for (var i = 0; i < historicalCount; i++)
            rows.Add(Row($"SO-PAST-{i}", 1, detectedAt.AddDays(-30 - i), detectedAt.AddDays(-25 - i), 5m));

        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            RowSet(rows.ToArray()), Effective(NewRule()), TenantId, detectedAt);

        Assert.Equal(futureCount + historicalCount, hits.Count);
        Assert.Equal(futureCount, hits.Count(h => h.CreateEligible));
        Assert.Equal(historicalCount, hits.Count(h => !h.CreateEligible));
    }

    [Fact]
    public void T28_MissingDueDate_FailsOpen_SoTheRuleNeverGoesSilent()
    {
        // 到期日缺失时闸门放行。闸门的职责是"到期后别开新案子"，
        // 不是"没有到期日就别报警"—— 缺列时静默拒绝建单会让规则表现为
        // 「每轮都命中、一条异常也建不出来」，正是本仓反复在防的静默失败。
        var row = Row("SO-NO-DUE", 1, new DateTime(2026, 10, 31), new DateTime(2026, 11, 12), 12m);
        var values = S8OrderDeliveryDataProvider.ToCanonicalValues(row);
        values[S8CanonicalColumns.DueAt] = null!;

        var hit = Assert.Single(S8OutOfRangeRuleEvaluator.EvaluateRows(
            S8MonitoringRowSet.FromRows(new[] { S8MonitoringRow.FromValues(values) }),
            Effective(NewRule()), TenantId, new DateTime(2026, 11, 1)));

        Assert.True(hit.CreateEligible);
    }

    [Fact]
    public void T29_Rule02_DeclaresTheCreateWindow_AndItsDatasetCanCarryDueAt()
    {
        Assert.True(Definition.CreateOnlyBeforeDueAt);

        // 闸门读的是 canonical due_at，因此数据集必须声明带得出到期日。
        var dataset = Assert.Single(new S8OrderDeliveryDatasetDefinitions().GetDefinitions());
        Assert.True(dataset.Capabilities.HasDueAt);
    }

    // ============================================================
    // G. Rule01 回归 + 通用契约默认值
    // ============================================================

    [Fact]
    public void T30_Rule01_DoesNotDeclareTheGate_SoItsBehaviourIsByteForByteUnchanged()
    {
        var rule01 = Catalog.GetRequired(S8PurchaseDeliveryRuleDefinitions.PurchaseDeliveryDateDelayCode);
        Assert.False(rule01.CreateOnlyBeforeDueAt);
    }

    [Fact]
    public void T31_CreateEligible_DefaultsToTrue_OnAFreshHit()
    {
        // 默认 true 是"未声明规则行为不变"的唯一保证。
        // 一旦有人把默认值改成 false，所有未声明闸门的规则会当场停止建单，
        // 且表现为"命中很多、一条也没建"——最难定位的一类静默失败。
        Assert.True(new S8RuleHit().CreateEligible);
    }

    [Fact]
    public void T32_TimeoutEvaluator_LeavesEveryHitCreateEligible()
    {
        // Rule01 走 TIMEOUT，其 evaluator 不参与闸门。逐条证明而不是靠"我没改它"。
        var rule01Row = new AdoS8WatchRule
        {
            Id = 900101,
            RuleCode = S8PurchaseDeliveryRuleDefinitions.PurchaseDeliveryDateDelayCode,
            SceneCode = "S4",
            WatchObjectType = "PURCHASE_ORDER_LINE",
            SourceObjectType = "PURCHASE_ORDER_LINE",
            Severity = "SERIOUS",
            RuleType = S8TimeoutRuleEvaluator.RuleTypeCode,
            DatasetCode = S8BusinessDatasetDefinitions.PurchaseDeliveryCode
        };
        var effective = S8EffectiveRule.Resolve(
            rule01Row, Catalog.GetRequired(S8PurchaseDeliveryRuleDefinitions.PurchaseDeliveryDateDelayCode));

        var overdue = new S8PurchaseDeliveryDataProvider.PurchaseDeliveryRow
        {
            SourceObjectId = "PO-REG-1#1",
            RelatedObjectCode = "PO-REG-1",
            RelatedObjectName = "供应商",
            DueAt = new DateTime(2026, 8, 1),
            Status = "DELAYED",
            DueAtSource = "need_date"
        };

        var hits = S8TimeoutRuleEvaluator.EvaluateRows(
            S8MonitoringRowSet.FromRows(new[] {
                S8MonitoringRow.FromValues(S8PurchaseDeliveryDataProvider.ToCanonicalValues(overdue)) }),
            effective, TenantId, new DateTime(2026, 9, 5));

        Assert.NotEmpty(hits);
        Assert.All(hits, h => Assert.True(h.CreateEligible));
    }

    // ============================================================
    // H. 调度器顺序守卫
    //
    // 闸门的正确性完全取决于它在 ProcessSingleRuleAsync 里的位置。
    // 该方法是私有的、依赖 4 个 repository，本仓对它既有的守护
    // （S8SystemRecoveredTimelineTests）同样采用源码文本断言，此处沿用同一标准。
    // ============================================================

    private static string SchedulerCode()
    {
        var path = Path.GetFullPath(Path.Combine(
            AppContext.BaseDirectory,
            "../../../../Plugins/Admin.NET.Plugin.AiDOP/Service/S8/S8WatchSchedulerService.cs"));
        Assert.True(File.Exists(path), $"调度器源码路径需同步更新：{path}");

        // 去掉注释行：本节断言的是**执行顺序**，不能被文档里的同名字样带偏。
        return string.Join('\n', File.ReadAllLines(path)
            .Where(l =>
            {
                var t = l.TrimStart();
                return !t.StartsWith("///", StringComparison.Ordinal)
                       && !t.StartsWith("//", StringComparison.Ordinal);
            }));
    }

    [Fact]
    public void T33_RecoveryReconcile_RunsBeforeTheHitLoop()
    {
        var code = SchedulerCode();

        var reconcileIdx = code.IndexOf("ReconcileRecoveriesForRuleAsync(tenantId, rule, ruleType, hits, runId)",
            StringComparison.Ordinal);
        var loopIdx = code.IndexOf("foreach (var hit in hits)", StringComparison.Ordinal);

        Assert.True(reconcileIdx > 0 && loopIdx > 0);
        Assert.True(reconcileIdx < loopIdx,
            "恢复判定必须在 hit 循环之前、且拿到完整 hits —— 否则 CreateEligible=false 的命中" +
            "保护不了既有异常，假恢复会原地复活");
    }

    [Fact]
    public void T34_CreateGate_SitsAfterRefresh_AndBeforeCreate()
    {
        var code = SchedulerCode();

        var refreshIdx = code.IndexOf("await RefreshDetectionAsync(matchedId, hit);", StringComparison.Ordinal);
        var backfillIdx = code.IndexOf("await BackfillLegacyExceptionAsync(compatId, hit);", StringComparison.Ordinal);
        var gateIdx = code.IndexOf("if (!hit.CreateEligible)", StringComparison.Ordinal);
        var createIdx = code.IndexOf("await _reportDispatcher.CreateFromHitAsync(tenantId, hit);", StringComparison.Ordinal);

        Assert.True(refreshIdx > 0 && backfillIdx > 0 && gateIdx > 0 && createIdx > 0);

        // 在刷新之后：跨过交期的既有预警 CreateEligible 变 false，但必须照常 refresh 才能保持 active。
        Assert.True(refreshIdx < gateIdx, "闸门必须在既有异常刷新之后，否则跨期预警会停止刷新");
        Assert.True(backfillIdx < gateIdx, "闸门必须在 legacy 回填之后，那同样是保活而非建单");

        // 在建单之前：历史风险行不得被倒成一批"预警"。
        Assert.True(gateIdx < createIdx, "闸门必须在首次建单之前");

        // 结果原因必须是可解释的独立值，不能混进 failed 家族。
        Assert.Contains("\"create_not_eligible\"", code, StringComparison.Ordinal);
    }

    [Fact]
    public void T35_CreateNotEligible_IsNotCountedAsFailure()
    {
        var code = SchedulerCode();

        // Failed 统计只认这四个 reason；create_not_eligible 不在其中，
        // 否则规则每轮都会显示"有失败"，而它其实工作得完全正确。
        var failedLine = code.Split('\n').First(l => l.Contains("Failed = results.Count(", StringComparison.Ordinal));
        Assert.DoesNotContain("create_not_eligible", failedLine, StringComparison.Ordinal);
    }
}