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

using System.Data;
using Admin.NET.Plugin.AiDOP.Entity.S8;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules.Definitions;
using Admin.NET.Plugin.AiDOP.Service.S8.Rules.DataAccess;
using Xunit;

namespace Admin.NET.Test.S8;

/// <summary>
/// S8-DATASET-PROVIDER-FOUNDATION-1 契约回归。
///
/// 本批目标是建立 Rule → DataAccessMode → Provider → Canonical Row → Evaluator 的稳定边界。
/// 本测试类锁定四件事：
///   A. Legacy 兼容：DataAccessMode 为空（132 条历史规则的现状）必须解析为 LEGACY_SQL；
///   B. 标准数据集契约：三个 evaluator 的判定核心可在完全没有 SQL / DataTable 的情况下运行；
///   C. Tenant/Factory 必须由请求显式携带，不得隐式取值；
///   D. 旧行 DataAccessMode/DatasetCode = NULL 不导致任何解析失败。
///
/// 不接 DB、不接 DI、不触发任何真实规则。
/// </summary>
public class S8MonitoringDataContractTests
{
    // S8-STANDARD-DATASET-HARD-CUTOVER-1：此处原有 4 条 DataAccessMode 解析用例
    //   （NULL/空白 → LEGACY_SQL、STANDARD_DATASET 大小写不敏感、未知值抛错）。
    // S8DataAccessMode 整个类型已删除 —— 取数方式只剩一种，枚举本身失去意义。
    // 「不存在第二种取数方式」由 S8MonitoringDataGatewayTests.Gateway_HasNoLegacyDependency
    // 与 WatchRule_HasNoSqlOrDataSourceFields 断言。

    // ============================================================
    // Canonical Row / RowSet 表示层：必须与原 DataTable 读取语义等价
    // ============================================================

    [Fact]
    public void RowSet_FromDataTable_PreservesAllColumns_ForPayloadDump()
    {
        // payload 依赖"把结果集所有列原样落进 JSON"，因此 RowSet 必须保留全部列（含非 canonical 列）。
        var table = new DataTable();
        table.Columns.Add("source_object_id", typeof(string));
        table.Columns.Add("vendor_specific_col", typeof(string));
        var row = table.NewRow();
        row["source_object_id"] = "SO-1";
        row["vendor_specific_col"] = "keep-me";
        table.Rows.Add(row);

        var rowSet = S8MonitoringRowSet.FromDataTable(table);

        Assert.Single(rowSet.Rows);
        Assert.True(rowSet.HasColumn("source_object_id"));
        Assert.True(rowSet.HasColumn("vendor_specific_col"));
        Assert.Equal("keep-me", rowSet.Rows[0].Values["vendor_specific_col"]);
    }

    [Fact]
    public void RowSet_HasColumn_False_ForAbsentColumn_DrivesParamsFallback()
    {
        // evaluator 的 canonical→params 回退依赖"结果集是否含 canonical 列"这一判断。
        var table = new DataTable();
        table.Columns.Add("planner_end_date", typeof(DateTime));
        var rowSet = S8MonitoringRowSet.FromDataTable(table);

        Assert.False(rowSet.HasColumn("due_at"));
        Assert.True(rowSet.HasColumn("planner_end_date"));
    }

    [Fact]
    public void Row_GetString_ReturnsNull_ForDbNull_AndTrims()
    {
        var table = new DataTable();
        table.Columns.Add("a", typeof(string));
        table.Columns.Add("b", typeof(string));
        var r = table.NewRow();
        r["a"] = "  padded  ";
        r["b"] = DBNull.Value;
        table.Rows.Add(r);

        var row = S8MonitoringRowSet.FromDataTable(table).Rows[0];

        Assert.Equal("padded", row.GetString("a"));
        Assert.Null(row.GetString("b"));
        Assert.Null(row.GetString("column_that_does_not_exist"));
    }

    [Fact]
    public void Row_GetDecimal_And_GetDateTime_ParseFromStringLikeLegacyReader()
    {
        // 旧实现用 Convert.ToString + TryParse，标准 Provider 也可能给出强类型值，两者都要支持。
        var row = S8MonitoringRow.FromValues(new Dictionary<string, object>
        {
            ["num_text"] = "12.5",
            ["num_typed"] = 7m,
            ["date_text"] = "2026-01-02 03:04:05",
            ["date_typed"] = new DateTime(2026, 1, 2, 3, 4, 5),
            ["not_a_number"] = "abc"
        });

        Assert.Equal(12.5m, row.GetDecimal("num_text"));
        Assert.Equal(7m, row.GetDecimal("num_typed"));
        Assert.Equal(new DateTime(2026, 1, 2, 3, 4, 5), row.GetDateTime("date_text"));
        Assert.Equal(new DateTime(2026, 1, 2, 3, 4, 5), row.GetDateTime("date_typed"));
        Assert.Null(row.GetDecimal("not_a_number"));
    }

    [Fact]
    public void Row_NullValue_IsRealNull_NotTheStringLiteralNull()
    {
        var row = S8MonitoringRow.FromValues(new Dictionary<string, object> { ["x"] = null });
        Assert.Null(row.GetString("x"));
        Assert.NotEqual("null", row.GetString("x"));
    }

    // ============================================================
    // B. 标准数据集契约：evaluator 判定核心脱离 SQL 运行（本批最重要验收）
    // ============================================================

    private static AdoS8WatchRule NewRule(string ruleType) => new()
    {
        Id = 900001,
        RuleCode = "UT_DATASET_RULE",
        SceneCode = "S1",
        WatchObjectType = "ORDER",
        SourceObjectType = "ORDER",
        Severity = "FOLLOW",
        RuleType = ruleType
    };

    /// <summary>
    /// S8-RULE-GOVERNANCE-BATCH1：判定语义已迁至代码定义。
    /// 这些用例原先手写一份 params_json 来表达"这条规则判什么"，现在改为构造对应的
    /// <see cref="S8RuleDefinition"/> —— 断言内容一字未改，只是语义来源换成了正确的那一处。
    /// </summary>
    private static S8EffectiveRule Effective(
        string ruleType,
        string exceptionTypeCode = "X",
        string[]? completedStates = null,
        decimal? upperBound = null,
        decimal? lowerBound = null)
    {
        var definition = new S8RuleDefinition
        {
            RuleCode = "UT_DATASET_RULE",
            DisplayName = "单测规则",
            Description = "契约测试用",
            DatasetCode = "UT_FAKE_DATASET",
            RuleType = ruleType,
            RuleMechanism = "DATE",
            SourceObjectType = "ORDER",
            SceneCode = "S1",
            StageCode = "S1",
            ExceptionTypeCode = exceptionTypeCode,
            Timeout = ruleType == "TIMEOUT"
                ? new S8TimeoutSemantics { CompletedStates = completedStates ?? Array.Empty<string>() }
                : null,
            Shortage = ruleType == "SHORTAGE" ? new S8ShortageSemantics() : null,
            OutOfRange = ruleType == "OUT_OF_RANGE"
                ? new S8OutOfRangeSemantics { UpperBound = upperBound, LowerBound = lowerBound }
                : null
        };
        return S8EffectiveRule.Resolve(NewRule(ruleType), definition);
    }

    [Fact]
    public void Timeout_EvaluateRows_ProducesHit_WithoutAnySql()
    {
        // 关键验收：输入是 canonical rows，没有 expression、没有 DataTable、没有数据源。
        var rowSet = S8MonitoringRowSet.FromRows(new[]
        {
            S8MonitoringRow.FromValues(new Dictionary<string, object>
            {
                ["source_object_id"] = "SO-OVERDUE",
                ["related_object_code"] = "SO-OVERDUE",
                ["due_at"] = new DateTime(2026, 1, 1, 0, 0, 0),
                ["status"] = "RUNNING"
            })
        });
        var hits = S8TimeoutRuleEvaluator.EvaluateRows(
            rowSet,
            Effective("TIMEOUT", exceptionTypeCode: "DELIVERY_DELAY", completedStates: new[] { "COMPLETED" }),
            tenantId: 11,
            detectedAt: new DateTime(2026, 6, 1, 0, 0, 0));

        var hit = Assert.Single(hits);
        Assert.Equal("SO-OVERDUE", hit.SourceObjectId);
        Assert.Equal("ORDER", hit.SourceObjectType);
        Assert.Equal("DELIVERY_DELAY", hit.ExceptionTypeCode);
        Assert.Equal("T11:RUT_DATASET_RULE:ORDER:SO-OVERDUE", hit.DedupKey);
    }

    [Fact]
    public void Timeout_EvaluateRows_SkipsCompletedStates_SemanticsUnchanged()
    {
        var rowSet = S8MonitoringRowSet.FromRows(new[]
        {
            S8MonitoringRow.FromValues(new Dictionary<string, object>
            {
                ["source_object_id"] = "SO-DONE",
                ["related_object_code"] = "SO-DONE",
                ["due_at"] = new DateTime(2026, 1, 1),
                ["status"] = "COMPLETED"
            })
        });
        var hits = S8TimeoutRuleEvaluator.EvaluateRows(
            rowSet, Effective("TIMEOUT", completedStates: new[] { "COMPLETED" }),
            11, new DateTime(2026, 6, 1));

        Assert.Empty(hits);
    }

    /// <summary>
    /// S8-RULE-GOVERNANCE-BATCH1：原用例 <c>Timeout_EvaluateRows_FallsBackToParamsColumn_WhenCanonicalAbsent</c>
    /// 验证的是「结果集没有 canonical 列时，回退到 params_json 指定的真实列名」。
    ///
    /// <para>那条回退已随本批**刻意移除**：它是"用户可以在 JSON 里指定判定读哪一列"这项能力的
    /// 最后一段实现，而该能力正是本批要取消的。Provider 现在必须按 canonical 契约产出行
    /// （由 <c>S8PurchaseDeliverySqlMappingTests</c> 守护），不存在"结果集没有 canonical 列"的合法情形。</para>
    ///
    /// <para>本用例把新语义钉住：非 canonical 列名一律读不到，该行不命中 —— 而不是悄悄换一列读。</para>
    /// </summary>
    [Fact]
    public void Timeout_EvaluateRows_NoLongerFallsBackToNonCanonicalColumns()
    {
        var rowSet = S8MonitoringRowSet.FromRows(new[]
        {
            S8MonitoringRow.FromValues(new Dictionary<string, object>
            {
                ["related_object_code"] = "WO-1",
                ["planner_end_date"] = new DateTime(2026, 1, 1),
                ["morder_state"] = "RUNNING"
            })
        });

        var hits = S8TimeoutRuleEvaluator.EvaluateRows(
            rowSet, Effective("TIMEOUT"), 1, new DateTime(2026, 6, 1));

        Assert.Empty(hits);
    }

    [Fact]
    public void OutOfRange_EvaluateRows_AboveUpper_WithoutAnySql()
    {
        var rowSet = S8MonitoringRowSet.FromRows(new[]
        {
            S8MonitoringRow.FromValues(new Dictionary<string, object>
            {
                ["source_object_id"] = "ITEM-1",
                ["related_object_code"] = "ITEM-1",
                ["measured_value"] = 130m
            })
        });
        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            rowSet, Effective("OUT_OF_RANGE", exceptionTypeCode: "QUALITY_OUT_OF_SPEC", upperBound: 100m),
            11, DateTime.Now);

        var hit = Assert.Single(hits);
        Assert.Equal("ITEM-1", hit.SourceObjectId);
        Assert.Equal("QUALITY_OUT_OF_SPEC", hit.ExceptionTypeCode);
        Assert.Contains("超差", hit.Title);
    }

    [Fact]
    public void OutOfRange_EvaluateRows_WithinBounds_NoHit()
    {
        var rowSet = S8MonitoringRowSet.FromRows(new[]
        {
            S8MonitoringRow.FromValues(new Dictionary<string, object>
            {
                ["source_object_id"] = "ITEM-OK",
                ["related_object_code"] = "ITEM-OK",
                ["measured_value"] = 50m
            })
        });
        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            rowSet, Effective("OUT_OF_RANGE", upperBound: 100m, lowerBound: 10m),
            1, DateTime.Now);

        Assert.Empty(hits);
    }

    [Fact]
    public void Shortage_EvaluateRows_WithoutAnySql()
    {
        var rowSet = S8MonitoringRowSet.FromRows(new[]
        {
            S8MonitoringRow.FromValues(new Dictionary<string, object>
            {
                ["related_object_code"] = "PO-1",
                ["target_qty"] = 100m,
                ["actual_qty"] = 40m
            })
        });
        var hits = S8ShortageRuleEvaluator.EvaluateRows(
            rowSet, Effective("SHORTAGE", exceptionTypeCode: "MATERIAL_SHORTAGE"),
            11, DateTime.Now);

        var hit = Assert.Single(hits);
        Assert.Equal("PO-1", hit.SourceObjectId);
        Assert.Equal("MATERIAL_SHORTAGE", hit.ExceptionTypeCode);
    }

    [Fact]
    public void EvaluateRows_PayloadStillContainsAllSourceColumns()
    {
        // 迁移后 payload 仍须保留结果集原始列（下游排查依赖它）。
        var rowSet = S8MonitoringRowSet.FromRows(new[]
        {
            S8MonitoringRow.FromValues(new Dictionary<string, object>
            {
                ["source_object_id"] = "SO-P",
                ["related_object_code"] = "SO-P",
                ["due_at"] = new DateTime(2026, 1, 1),
                ["status"] = "RUNNING",
                ["extra_business_column"] = "must-survive"
            })
        });
        var hits = S8TimeoutRuleEvaluator.EvaluateRows(
            rowSet, Effective("TIMEOUT"), 1, new DateTime(2026, 6, 1));

        Assert.Contains("extra_business_column", hits[0].SourcePayload);
        Assert.Contains("must-survive", hits[0].SourcePayload);
    }

    // ============================================================
    // C. Tenant / Factory 显式传递
    // ============================================================

    [Fact]
    public void DataRequest_CarriesExplicitTenant_AndHasNoFactoryDimension()
    {
        var request = new S8MonitoringDataRequest
        {
            TenantId = 797403760988229,
            DatasetCode = "UT_DATASET",
            RuleId = 1,
            RuleCode = "UT",
            RuleType = "TIMEOUT"
        };

        Assert.Equal(797403760988229, request.TenantId);

        // S8-TENANT-ONLY-BATCH5：取数作用域里不得再有工厂这一维。
        // 唯一的 Provider 的 WHERE 从一开始就只有 tenant_id，工厂形参从来只是个
        // 不影响结果、却能把零工厂/多工厂租户挡在门外的形式门槛。
        Assert.Null(typeof(S8MonitoringDataRequest).GetProperty("FactoryId"));
    }

    /// <summary>
    /// 原用例 <c>DataRequest_RejectsNonPositiveTenantOrFactory</c> 的继任者。
    ///
    /// <para>租户缺失仍必须显式失败（禁止 Provider "猜"租户）；
    /// 而「工厂为 0 也拒绝」那一半必须**反过来**——工厂已不是作用域，
    /// 不得再有任何取数请求因它被拒。这正是 Batch 2 供给出的
    /// <c>factory_id = 0</c> 运行策略此前被静默挡死的那道门。</para>
    /// </summary>
    [Fact]
    public void DataRequest_RejectsNonPositiveTenant_ButHasNoFactoryGate()
    {
        var ex = Assert.Throws<S8RuleEvaluatorException>(() =>
            new S8MonitoringDataRequest { TenantId = 0, DatasetCode = "D", RuleCode = "R", RuleType = "TIMEOUT" }.EnsureValid());
        Assert.Equal("dataset_scope_invalid", ex.Reason);
        Assert.DoesNotContain("Factory", ex.Message, StringComparison.OrdinalIgnoreCase);

        // 合法租户 → 通过；没有任何"工厂必须为正"的附加条件可以让它失败。
        new S8MonitoringDataRequest { TenantId = 1, DatasetCode = "D", RuleCode = "R", RuleType = "TIMEOUT" }
            .EnsureValid();
    }

    // ============================================================
    // Registry / Capability 校验
    // ============================================================

    private sealed class FakeDatasetProvider : IS8MonitoringDataProvider
    {
        public string DatasetCode => "UT_FAKE_DATASET";
        public S8DatasetCapabilities Capabilities => new() { SupportsTimeout = true };
        public Task<S8MonitoringRowSet> LoadAsync(S8MonitoringDataRequest request, CancellationToken cancellationToken = default)
        {
            request.EnsureValid();
            return Task.FromResult(S8MonitoringRowSet.FromRows(new[]
            {
                S8MonitoringRow.FromValues(new Dictionary<string, object>
                {
                    ["source_object_id"] = $"T{request.TenantId}",
                    ["related_object_code"] = "R",
                    ["due_at"] = new DateTime(2026, 1, 1),
                    ["status"] = "RUNNING"
                })
            }));
        }
    }

    [Fact]
    public void Registry_ResolvesRegisteredProvider()
    {
        var registry = new S8MonitoringDataProviderRegistry(new[] { new FakeDatasetProvider() });
        Assert.True(registry.IsRegistered("UT_FAKE_DATASET"));
        Assert.Equal("UT_FAKE_DATASET", registry.Resolve("UT_FAKE_DATASET").DatasetCode);
    }

    [Fact]
    public void Registry_UnknownDatasetCode_Throws()
    {
        var registry = new S8MonitoringDataProviderRegistry(new[] { new FakeDatasetProvider() });
        Assert.False(registry.IsRegistered("NO_SUCH_DATASET"));
        var ex = Assert.Throws<S8RuleEvaluatorException>(() => registry.Resolve("NO_SUCH_DATASET"));
        Assert.Equal("dataset_provider_not_registered", ex.Reason);
    }

    [Fact]
    public void Capabilities_RejectRuleTypeTheDatasetCannotServe()
    {
        // TIMEOUT 规则挂到不提供 due_at 能力的 Dataset 上，必须在校验期被拒绝，
        // 而不是运行期解析不到列后静默不命中。
        var caps = new S8DatasetCapabilities { SupportsTimeout = false, SupportsOutOfRange = true };
        Assert.False(caps.Supports(S8TimeoutRuleEvaluator.RuleTypeCode));
        Assert.True(caps.Supports(S8OutOfRangeRuleEvaluator.RuleTypeCode));
    }

    [Fact]
    public async Task Provider_ReceivesTenant_NoImplicitContext()
    {
        var registry = new S8MonitoringDataProviderRegistry(new[] { new FakeDatasetProvider() });
        var provider = registry.Resolve("UT_FAKE_DATASET");

        var rowSet = await provider.LoadAsync(new S8MonitoringDataRequest
        {
            TenantId = 555,
            DatasetCode = "UT_FAKE_DATASET",
            RuleId = 1,
            RuleCode = "UT",
            RuleType = "TIMEOUT"
        });

        // 作用域必须来自请求本身，不得来自任何隐式上下文。
        Assert.Equal("T555", rowSet.Rows[0].GetString("source_object_id"));
    }

    [Fact]
    public async Task EndToEnd_StandardDataset_FeedsEvaluator_WithoutSql()
    {
        // 本批最终验收：Provider → Canonical Row → Evaluator，全程无 SQL 字符串。
        var registry = new S8MonitoringDataProviderRegistry(new[] { new FakeDatasetProvider() });
        var provider = registry.Resolve("UT_FAKE_DATASET");
        var rowSet = await provider.LoadAsync(new S8MonitoringDataRequest
        {
            TenantId = 11,
            DatasetCode = "UT_FAKE_DATASET",
            RuleId = 1,
            RuleCode = "UT_DATASET_RULE",
            RuleType = "TIMEOUT"
        });

        var hits = S8TimeoutRuleEvaluator.EvaluateRows(
            rowSet, Effective("TIMEOUT"), 11, new DateTime(2026, 6, 1));

        Assert.Single(hits);
        Assert.Equal("T11:RUT_DATASET_RULE:ORDER:T11", hits[0].DedupKey);
    }
}