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.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
{
    // ============================================================
    // A / D. Legacy 兼容与向后兼容
    // ============================================================

    [Fact]
    public void DataAccessMode_Null_ResolvesTo_LegacySql()
    {
        // 132 条历史规则 data_access_mode 列为 NULL，必须继续走原 SQL 路径。
        Assert.Equal(S8DataAccessMode.LegacySql, S8DataAccessMode.Resolve(null));
    }

    [Fact]
    public void DataAccessMode_EmptyOrWhitespace_ResolvesTo_LegacySql()
    {
        Assert.Equal(S8DataAccessMode.LegacySql, S8DataAccessMode.Resolve(""));
        Assert.Equal(S8DataAccessMode.LegacySql, S8DataAccessMode.Resolve("   "));
    }

    [Fact]
    public void DataAccessMode_StandardDataset_IsRecognized_CaseInsensitive()
    {
        Assert.Equal(S8DataAccessMode.StandardDataset, S8DataAccessMode.Resolve("STANDARD_DATASET"));
        Assert.Equal(S8DataAccessMode.StandardDataset, S8DataAccessMode.Resolve("standard_dataset"));
    }

    [Fact]
    public void DataAccessMode_UnknownValue_Throws_RatherThanSilentlyRunningLegacySql()
    {
        // 未知模式静默回落 LEGACY_SQL 会让配置错误伪装成"正常运行"，因此必须显式失败。
        var ex = Assert.Throws<S8RuleEvaluatorException>(() => S8DataAccessMode.Resolve("SOMETHING_ELSE"));
        Assert.Equal("data_access_mode_invalid", ex.Reason);
    }

    // ============================================================
    // 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
    };

    [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 parameters = S8TimeoutParams.Parse(
            """{"dueAtField":"due_at","statusField":"status","completedStates":["COMPLETED"],"exceptionTypeCode":"DELIVERY_DELAY"}""");

        var hits = S8TimeoutRuleEvaluator.EvaluateRows(
            rowSet, parameters, NewRule("TIMEOUT"),
            tenantId: 11, factoryId: 22, dataSourceId: 0,
            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:F22: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 parameters = S8TimeoutParams.Parse(
            """{"dueAtField":"due_at","statusField":"status","completedStates":["COMPLETED"],"exceptionTypeCode":"X"}""");

        var hits = S8TimeoutRuleEvaluator.EvaluateRows(
            rowSet, parameters, NewRule("TIMEOUT"), 11, 22, 0, new DateTime(2026, 6, 1));

        Assert.Empty(hits);
    }

    [Fact]
    public void Timeout_EvaluateRows_FallsBackToParamsColumn_WhenCanonicalAbsent()
    {
        // 历史未别名规则：结果集没有 due_at/status，只能按 params 指定的真实列名读取。
        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 parameters = S8TimeoutParams.Parse(
            """{"dueAtField":"planner_end_date","statusField":"morder_state","exceptionTypeCode":"X"}""");

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

        Assert.Single(hits);
        Assert.Equal("WO-1", hits[0].SourceObjectId);
    }

    [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 parameters = S8OutOfRangeParams.Parse(
            """{"measuredValueField":"measured_value","upperBound":100,"exceptionTypeCode":"QUALITY_OUT_OF_SPEC"}""");

        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            rowSet, parameters, NewRule("OUT_OF_RANGE"), 11, 22, 0, 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 parameters = S8OutOfRangeParams.Parse(
            """{"measuredValueField":"measured_value","upperBound":100,"lowerBound":10}""");

        var hits = S8OutOfRangeRuleEvaluator.EvaluateRows(
            rowSet, parameters, NewRule("OUT_OF_RANGE"), 1, 1, 0, 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 parameters = S8ShortageParams.Parse(
            """{"targetQtyField":"target_qty","actualQtyField":"actual_qty","exceptionTypeCode":"MATERIAL_SHORTAGE"}""");

        var hits = S8ShortageRuleEvaluator.EvaluateRows(
            rowSet, parameters, NewRule("SHORTAGE"), 11, 22, 0, 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 parameters = S8TimeoutParams.Parse(
            """{"dueAtField":"due_at","statusField":"status","exceptionTypeCode":"X"}""");

        var hits = S8TimeoutRuleEvaluator.EvaluateRows(
            rowSet, parameters, NewRule("TIMEOUT"), 1, 1, 0, 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_CarriesExplicitTenantAndFactory()
    {
        var request = new S8MonitoringDataRequest
        {
            TenantId = 797403760988229,
            FactoryId = 1,
            DatasetCode = "UT_DATASET",
            RuleId = 1,
            RuleCode = "UT",
            RuleType = "TIMEOUT"
        };

        Assert.Equal(797403760988229, request.TenantId);
        Assert.Equal(1, request.FactoryId);
    }

    [Fact]
    public void DataRequest_RejectsNonPositiveTenantOrFactory()
    {
        // 禁止 Provider 在缺少作用域时"猜"租户；缺失必须显式失败。
        Assert.Throws<S8RuleEvaluatorException>(() =>
            new S8MonitoringDataRequest { TenantId = 0, FactoryId = 1, DatasetCode = "D", RuleCode = "R", RuleType = "TIMEOUT" }.EnsureValid());
        Assert.Throws<S8RuleEvaluatorException>(() =>
            new S8MonitoringDataRequest { TenantId = 1, FactoryId = 0, 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}-F{request.FactoryId}",
                    ["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_ReceivesTenantAndFactory_NoImplicitContext()
    {
        var registry = new S8MonitoringDataProviderRegistry(new[] { new FakeDatasetProvider() });
        var provider = registry.Resolve("UT_FAKE_DATASET");

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

        Assert.Equal("T555-F66", 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,
            FactoryId = 22,
            DatasetCode = "UT_FAKE_DATASET",
            RuleId = 1,
            RuleCode = "UT_DATASET_RULE",
            RuleType = "TIMEOUT"
        });

        var hits = S8TimeoutRuleEvaluator.EvaluateRows(
            rowSet,
            S8TimeoutParams.Parse("""{"dueAtField":"due_at","statusField":"status","exceptionTypeCode":"X"}"""),
            NewRule("TIMEOUT"), 11, 22, 0, new DateTime(2026, 6, 1));

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