AiDOPWarehouse/server/Plugins/Admin.NET.Plugin.AiDOP.Tests/S5/MaterialWarehouse/MissedPrintConsumerScopeTests.cs

using System.Text.RegularExpressions;
using SqlSugar;
using Xunit;

namespace Admin.NET.Plugin.AiDOP.Tests.S5.MaterialWarehouse;

/// <summary>
/// S5 MissedPrint 剩余消费点 P1/P2 收口守卫（FUNC-S5-009 / IqcWmsResultPush / InventoryBalanceReader）。
/// <para>
/// 源码断言部分无门禁，普通 CI 也会执行；数据面断言需 AIDOP_IT=1，且**全程只读**，
/// 不写任何业务表、不触发 165 推送。
/// </para>
/// <para>
/// 背景：MissedPrint.tenant_id 已是正式租户列（生成标签写入 + 1.0.442 回填，152 行 0 NULL）。
/// 但 797 的 104 行 Domain='8010'、UAT 的 48 行 Domain=''，而 SourceDomainTenantResolver
/// 对两者都解析出 '8010' —— 因此凡是按 Domain 过滤 MissedPrint 的路径，对 UAT 而言候选宇宙
/// 100% 由 797 构成，方向是反的。本组把「一律直接用 tenant_id」钉死。
/// </para>
/// </summary>
public class MissedPrintConsumerScopeTests
{
    private const long TenantUat = 838257186181189L;
    private const long TenantAidop = 797403760988229L;

    private static bool ItEnabled => Environment.GetEnvironmentVariable("AIDOP_IT") == "1";

    private readonly Xunit.Abstractions.ITestOutputHelper _out;
    public MissedPrintConsumerScopeTests(Xunit.Abstractions.ITestOutputHelper output) => _out = output;

    private static readonly string PluginRoot =
        Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../Admin.NET.Plugin.AiDOP"));

    private const string PendingSrc = "MaterialWarehouse/PendingInspectionService.cs";
    private const string IqcPushSrc = "MaterialWarehouse/IqcWmsResultPushService.cs";
    private const string BalanceSrc = "MaterialWarehouse/InventoryBalanceReader.cs";
    private const string StocktakeSrc = "MaterialWarehouse/StocktakeResultService.cs";

    private static string ReadSource(string relativePath)
    {
        var full = Path.Combine(PluginRoot, relativePath);
        Assert.True(File.Exists(full), $"源码文件不存在，路径需同步更新：{full}");
        return File.ReadAllText(full);
    }

    /// <summary>只取可执行代码行：注释里为留档会提到旧写法，不应算违规。</summary>
    private static List<string> CodeLines(string relativePath) =>
        ReadSource(relativePath)
            .Split('\n')
            .Select(l => l.Trim())
            .Where(l => !l.StartsWith("///", StringComparison.Ordinal)
                        && !l.StartsWith("//", StringComparison.Ordinal)
                        && !l.StartsWith("--", StringComparison.Ordinal))
            .ToList();

    private static ISqlSugarClient? BuildAidopdev()
    {
        const string path = "/home/yy968/work/New9S/AiDOPWarehouse/server/Admin.NET.Application/Configuration/Database.json";
        if (!File.Exists(path)) return null;
        var cs = File.ReadLines(path)
            .Select(l => l.Trim())
            .Where(l => !l.StartsWith("//") && l.Contains("\"ConnectionString\"")
                        && l.Contains("Database=aidopdev") && l.Contains("123.60.180.165"))
            .Select(l => Regex.Match(l, "\"ConnectionString\"\\s*:\\s*\"([^\"]+)\"").Groups[1].Value)
            .FirstOrDefault(v => !string.IsNullOrEmpty(v));
        if (string.IsNullOrEmpty(cs)) return null;
        return new SqlSugarScope(new ConnectionConfig
        {
            ConfigId = "aidopdev-mp-consumer-it", DbType = DbType.MySql, ConnectionString = cs, IsAutoCloseConnection = true,
        });
    }

    /// <summary>取源码中某条 SQL 片段。</summary>
    private static string Slice(string src, string from, string to)
    {
        var i = src.IndexOf(from, StringComparison.Ordinal);
        Assert.True(i >= 0, $"源码中找不到锚点：{from}");
        var j = src.IndexOf(to, i + from.Length, StringComparison.Ordinal);
        Assert.True(j >= 0, $"源码中找不到结束锚点：{to}");
        return src.Substring(i, j - i);
    }

    // ===================== FUNC-S5-009 PendingInspection =====================

    [Fact]
    public void F009_Anchor_MustFilterByTenantId()
    {
        var src = ReadSource(PendingSrc);
        Assert.Contains("\"m.tenant_id = @TenantId\"", src, StringComparison.Ordinal);
    }

    /// <summary>
    /// 锚表不得再带 Domain：它对租户内零过滤价值，却会把整个 UAT 清零。
    /// </summary>
    [Fact]
    public void F009_Anchor_MustNotFilterByDomain()
    {
        var offenders = CodeLines(PendingSrc)
            .Where(l => l.Contains("m.Domain", StringComparison.Ordinal)
                        || l.Contains("\"@Domain\"", StringComparison.Ordinal))
            .ToList();
        Assert.True(offenders.Count == 0, $"009 仍在按 Domain 过滤：{string.Join(" | ", offenders)}");
    }

    [Fact]
    public void F009_SupplierOptions_MustBeTenantScoped()
    {
        var src = ReadSource(PendingSrc);
        var stmt = Slice(src, "SELECT DISTINCT m.Supply", "ORDER BY m.Supply");
        Assert.Contains("m.tenant_id = @TenantId", stmt, StringComparison.Ordinal);
        Assert.Contains("s.tenant_id = @TenantId", stmt, StringComparison.Ordinal);
        Assert.DoesNotContain("@Domain", stmt, StringComparison.Ordinal);
    }

    /// <summary>主数据关联改按租户：(Domain, ItemNum) / (Domain, Supp) 都不唯一，会一对多放大。</summary>
    [Fact]
    public void F009_MasterDataJoins_MustBeTenantScoped()
    {
        var src = ReadSource(PendingSrc);
        Assert.Contains("LEFT JOIN ItemMaster i ON i.tenant_id = @TenantId", src, StringComparison.Ordinal);
        Assert.Contains("LEFT JOIN SuppMaster s ON s.tenant_id = @TenantId", src, StringComparison.Ordinal);
    }

    // ===================== IqcWmsResultPushService =====================

    [Fact]
    public void IqcPush_MissedPrint_MustBeTenantScoped()
    {
        var src = ReadSource(IqcPushSrc);
        var stmt = Slice(src, "FROM MissedPrint", "IFNULL(Type,'') <> 'Card'");
        Assert.Contains("tenant_id = @TenantId", stmt, StringComparison.Ordinal);
    }

    /// <summary>
    /// <c>IFNULL(Domain,'') IN ('', @Domain)</c> 会同时命中 UAT（Domain=''）与 797（Domain='8010'）
    /// 两个分区，是本仓唯一一处结构性合并两租户的 MissedPrint 查询，必须彻底消失。
    /// </summary>
    [Fact]
    public void IqcPush_MustNotUseCrossPartitionDomainPredicate()
    {
        var offenders = CodeLines(IqcPushSrc)
            .Where(l => l.Contains("IN ('', @Domain)", StringComparison.Ordinal))
            .ToList();
        Assert.True(offenders.Count == 0, $"仍存在跨分区 Domain 谓词：{string.Join(" | ", offenders)}");
    }

    [Fact]
    public void IqcPush_MustNotHardcodeDomain()
    {
        var offenders = CodeLines(IqcPushSrc)
            .Where(l => l.Contains("\"8010\"", StringComparison.Ordinal))
            .ToList();
        Assert.True(offenders.Count == 0, $"仍硬编码 Domain：{string.Join(" | ", offenders)}");
        // 必须改走统一 resolver 并按当前租户解析
        Assert.Contains(CodeLines(IqcPushSrc),
            l => l.Contains("_domainTenant.ResolveDomainAsync(SourceCode, tenantId", StringComparison.Ordinal));
    }

    /// <summary>推送链租户一致性：入队的 TenantId 必须就是取数用的 tenantId，不得另起来源。</summary>
    [Fact]
    public void IqcPush_OutboxTenant_MatchesSourceTenant()
    {
        var lines = CodeLines(IqcPushSrc);
        var outboxTenants = lines.Where(l => l.Contains("TenantId =", StringComparison.Ordinal)).ToList();
        Assert.NotEmpty(outboxTenants);
        Assert.All(outboxTenants, l => Assert.Contains("TenantId = tenantId", l, StringComparison.Ordinal));
    }

    // ===================== InventoryBalanceReader（010 富化） =====================

    /// <summary>Live165 与 STD 两处标签富化都必须按租户，且不得退回 Domain-only。</summary>
    [Fact]
    public void Balance_BothEnrichments_MustBeTenantScoped()
    {
        var src = ReadSource(BalanceSrc);
        var occurrences = Regex.Matches(src, @"FROM MissedPrint\s*\r?\n\s*WHERE\s+tenant_id=@TenantId").Count;
        Assert.Equal(2, occurrences);

        var offenders = CodeLines(BalanceSrc)
            .Where(l => l.Contains("WHERE Domain=@Domain AND IFNULL(Status", StringComparison.Ordinal))
            .ToList();
        Assert.True(offenders.Count == 0, $"仍存在 Domain-only 的标签富化：{string.Join(" | ", offenders)}");
    }

    /// <summary>富化只能影响展示列，绝不能碰数量列 —— 这是 010 保持 CLOSED 的前提。</summary>
    [Fact]
    public void Balance_Enrichment_TouchesOnlyDisplayColumns()
    {
        var src = ReadSource(BalanceSrc);
        foreach (var stmt in new[]
                 {
                     Slice(src, "SELECT Location, ItemNum, IFNULL(LotSerial,'') AS LotSerial", "GROUP BY Location"),
                 })
        {
            Assert.Contains("MAX(Shelf)", stmt, StringComparison.Ordinal);
            Assert.Contains("MAX(LevelChar)", stmt, StringComparison.Ordinal);
            Assert.Contains("MAX(Supply)", stmt, StringComparison.Ordinal);
            Assert.DoesNotContain("QtyOnHand", stmt, StringComparison.Ordinal);
            Assert.DoesNotContain("AvailStatusQty", stmt, StringComparison.Ordinal);
        }
    }

    // ===================== FUNC-S5-013 StocktakeResult =====================

    [Fact]
    public void F013_MissedPrint_MustFilterByTenantId()
    {
        var src = ReadSource(StocktakeSrc);
        Assert.Contains("\"m.tenant_id = @TenantId\"", src, StringComparison.Ordinal);
    }

    /// <summary>
    /// 013 不得再把 Domain 当租户边界：UAT 的 48 行 Domain 为空串，
    /// 而 resolver 给出 '8010'，叠加后会把本租户数据整体清零（单向误杀）。
    /// </summary>
    [Fact]
    public void F013_MustNotUseDomainAsTenantBoundary()
    {
        var offenders = CodeLines(StocktakeSrc)
            .Where(l => l.Contains("m.Domain", StringComparison.Ordinal)
                        || l.Contains("\"@Domain\"", StringComparison.Ordinal)
                        || l.Contains("ResolveDomainAsync", StringComparison.Ordinal))
            .ToList();
        Assert.True(offenders.Count == 0, $"013 仍在按 Domain 过滤/解析：{string.Join(" | ", offenders)}");
    }

    /// <summary>013 的 ItemMaster 关联必须 tenant-aware，且不得回落到 Domain-only。</summary>
    [Fact]
    public void F013_ItemMasterJoin_MustBeTenantAware()
    {
        var src = ReadSource(StocktakeSrc);
        Assert.Contains("LEFT JOIN ItemMaster i ON i.tenant_id = m.tenant_id AND i.ItemNum = m.ItemNum",
            src, StringComparison.Ordinal);
        Assert.DoesNotContain(CodeLines(StocktakeSrc),
            l => l.Contains("ON m.Domain = i.Domain", StringComparison.Ordinal));
    }

    /// <summary>
    /// COUNT 与 SELECT 必须建立在同一业务集合上：COUNT 只查 MissedPrint，
    /// SELECT 多一个 LEFT JOIN —— 该 JOIN 必须恒为 1:1，否则分页取回行数会大于 total。
    /// </summary>
    [Fact]
    public void F013_CountAndSelect_ShareSameWhereClause()
    {
        var src = ReadSource(StocktakeSrc);
        Assert.Contains("SELECT COUNT(1) FROM MissedPrint m WHERE {whereSql}", src, StringComparison.Ordinal);
        // SELECT 侧复用同一个 whereSql，不得另起条件
        var select = Slice(src, "FROM MissedPrint m", "ORDER BY m.UpdateTime");
        Assert.Contains("WHERE {whereSql}", select, StringComparison.Ordinal);
    }

    /// <summary>013 仍须保持只读，且 IsTag=1 业务语义不得被改动。</summary>
    [Fact]
    public void F013_MustRemainReadOnly_AndKeepIsTagSemantics()
    {
        var src = ReadSource(StocktakeSrc);
        Assert.Contains("\"m.IsTag = 1\"", src, StringComparison.Ordinal);
        foreach (var verb in new[] { "HttpPost", "HttpPut", "HttpDelete", "HttpPatch" })
            Assert.DoesNotContain(verb, src, StringComparison.Ordinal);
    }

    // ===================== 数据面（AIDOP_IT=1，只读） =====================

    /// <summary>
    /// §3.2 的判据固化：Domain 在 MissedPrint 层对租户内零过滤价值（每租户单一 Domain 值），
    /// 却会整租户清零 —— UAT 就是被清零的那一个。
    /// </summary>
    [Fact]
    public async Task Data_DomainIsUselessAndHarmfulOnMissedPrint()
    {
        if (!ItEnabled) return;
        var db = BuildAidopdev();
        Assert.NotNull(db);

        var multiDomainTenants = await db!.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM (SELECT tenant_id FROM MissedPrint GROUP BY tenant_id HAVING COUNT(DISTINCT IFNULL(Domain,''))>1) x");
        var uatUnderDomain8010 = await db.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM MissedPrint WHERE tenant_id=@T AND Domain='8010'",
            new List<SugarParameter> { new("@T", TenantUat) });
        var uatTotal = await db.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM MissedPrint WHERE tenant_id=@T", new List<SugarParameter> { new("@T", TenantUat) });

        _out.WriteLine($"多 Domain 租户数={multiDomainTenants}；UAT 总数={uatTotal}，其中 Domain='8010' 的={uatUnderDomain8010}");
        Assert.Equal(0, multiDomainTenants);          // 每租户单一 Domain → Domain 无租户内过滤价值
        Assert.True(uatTotal > 0);
        Assert.Equal(0, uatUnderDomain8010);          // 而 resolver 给 UAT 的正是 '8010' → 旧写法整租户清零
    }

    /// <summary>§4.5：IQC 推送候选集，修复前跨两租户 130 行，修复后按租户切分且互不重叠。</summary>
    [Fact]
    public async Task Data_IqcPushCandidates_SplitByTenant()
    {
        if (!ItEnabled) return;
        var db = BuildAidopdev();
        Assert.NotNull(db);

        const string tail = "IFNULL(Status,'')<>'C' AND IFNULL(Type,'')<>'Card'";
        var legacy = await db!.Ado.GetIntAsync(
            $"SELECT COUNT(1) FROM MissedPrint WHERE IFNULL(Domain,'') IN ('', '8010') AND {tail}");
        var uat = await db.Ado.GetIntAsync(
            $"SELECT COUNT(1) FROM MissedPrint WHERE tenant_id=@T AND {tail}",
            new List<SugarParameter> { new("@T", TenantUat) });
        var aidop = await db.Ado.GetIntAsync(
            $"SELECT COUNT(1) FROM MissedPrint WHERE tenant_id=@T AND {tail}",
            new List<SugarParameter> { new("@T", TenantAidop) });

        _out.WriteLine($"旧写法候选={legacy}（跨两租户）；按租户切分 UAT={uat} / 797={aidop}");
        Assert.True(legacy > uat && legacy > aidop, "旧写法应当同时并入两个租户，否则用例失去意义");
        Assert.Equal(legacy, uat + aidop);   // 不重不漏
    }

    /// <summary>§5.3：富化 JOIN 键在租户内唯一，加 tenant_id 后不会放大分页。</summary>
    [Fact]
    public async Task Data_EnrichmentJoinKey_UniqueWithinTenant()
    {
        if (!ItEnabled) return;
        var db = BuildAidopdev();
        Assert.NotNull(db);

        var dupWithinTenant = await db!.Ado.GetIntAsync(
            """
            SELECT COUNT(1) FROM (
              SELECT tenant_id, Location, ItemNum, IFNULL(LotSerial,'') l
              FROM MissedPrint WHERE IFNULL(Location,'')<>''
              GROUP BY tenant_id, Location, ItemNum, l HAVING COUNT(*)>1) x
            """);
        // 负向对照：不带租户时，(Location,ItemNum,LotSerial) 在 mdp_std_inventory 已跨租户碰撞
        var stdCollision = await db.Ado.GetIntAsync(
            """
            SELECT COUNT(1) FROM (
              SELECT location, item_num, IFNULL(lot_serial,'') l FROM mdp_std_inventory
              WHERE (location, item_num, IFNULL(lot_serial,'')) IN (
                  SELECT Location, ItemNum, IFNULL(LotSerial,'') FROM MissedPrint
                  WHERE IFNULL(Status,'') NOT IN ('U','P','C') AND IFNULL(Location,'')<>'' AND Qty>0)
              GROUP BY location, item_num, l HAVING COUNT(DISTINCT tenant_id)>1) x
            """);

        _out.WriteLine($"MissedPrint 租户内键重复={dupWithinTenant}；标签键在 STD 里跨租户碰撞={stdCollision}");
        Assert.Equal(0, dupWithinTenant);
        Assert.True(stdCollision > 0, "碰撞若已消失，需重新评估本条 HARDEN 的必要性");
    }

    /// <summary>§3.4：主数据关联改按租户后是 1:1；按 Domain 则会放大。</summary>
    [Fact]
    public async Task Data_MasterDataJoin_TenantScopedIsOneToOne()
    {
        if (!ItEnabled) return;
        var db = BuildAidopdev();
        Assert.NotNull(db);

        var itemByTenant = await db!.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM (SELECT tenant_id,ItemNum FROM ItemMaster GROUP BY tenant_id,ItemNum HAVING COUNT(*)>1) x");
        var itemByDomain = await db.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM (SELECT Domain,ItemNum FROM ItemMaster GROUP BY Domain,ItemNum HAVING COUNT(*)>1) x");
        var suppByTenant = await db.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM (SELECT tenant_id,Supp FROM SuppMaster GROUP BY tenant_id,Supp HAVING COUNT(*)>1) x");
        var suppByDomain = await db.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM (SELECT Domain,Supp FROM SuppMaster GROUP BY Domain,Supp HAVING COUNT(*)>1) x");

        _out.WriteLine($"ItemMaster 重复：按租户={itemByTenant} 按Domain={itemByDomain}；" +
                       $"SuppMaster 重复：按租户={suppByTenant} 按Domain={suppByDomain}");
        Assert.Equal(0, itemByTenant);
        Assert.Equal(0, suppByTenant);
        Assert.True(itemByDomain > 0 && suppByDomain > 0, "Domain-only 若已唯一，本条放大论证需重做");
    }

    /// <summary>
    /// §三 dry-run 固化：013 的 Domain 条件会单向清零 UAT。
    /// 当前 IsTag=1 全库 0，故放宽 IsTag 做候选集模拟（不造数据）。
    /// </summary>
    [Fact]
    public async Task Data_F013_DomainCondition_WipesOutUatOnly()
    {
        if (!ItEnabled) return;
        var db = BuildAidopdev();
        Assert.NotNull(db);

        async Task<int> Cnt(long t, bool withDomain) => await db!.Ado.GetIntAsync(
            withDomain
                ? "SELECT COUNT(1) FROM MissedPrint WHERE tenant_id=@T AND Domain='8010'"
                : "SELECT COUNT(1) FROM MissedPrint WHERE tenant_id=@T",
            new List<SugarParameter> { new("@T", t) });

        var uatOnly = await Cnt(TenantUat, false);
        var uatWithDomain = await Cnt(TenantUat, true);
        var aidopOnly = await Cnt(TenantAidop, false);
        var aidopWithDomain = await Cnt(TenantAidop, true);

        _out.WriteLine($"UAT tenant-only={uatOnly} / tenant+Domain={uatWithDomain}；" +
                       $"797 tenant-only={aidopOnly} / tenant+Domain={aidopWithDomain}");
        Assert.True(uatOnly > 0);
        Assert.Equal(0, uatWithDomain);           // Domain 把 UAT 自己的数据整体清零
        Assert.Equal(aidopOnly, aidopWithDomain); // 对 797 无影响 —— 单向误杀
    }

    /// <summary>
    /// §六/§七 JOIN 基数：租户内 ItemNum 唯一 → 1:1 不放大；
    /// 且按租户关联能取到的物料主数据严格多于按 Domain（今日 104 → 152）。
    /// </summary>
    [Fact]
    public async Task Data_F013_ItemMasterJoin_OneToOne_AndMoreComplete()
    {
        if (!ItEnabled) return;
        var db = BuildAidopdev();
        Assert.NotNull(db);

        var dupByTenant = await db!.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM (SELECT tenant_id,ItemNum FROM ItemMaster GROUP BY tenant_id,ItemNum HAVING COUNT(*)>1) x");
        var dupByDomain = await db.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM (SELECT Domain,ItemNum FROM ItemMaster GROUP BY Domain,ItemNum HAVING COUNT(*)>1) x");

        var baseRows = await db.Ado.GetIntAsync("SELECT COUNT(1) FROM MissedPrint");
        var newJoinRows = await db.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM MissedPrint m LEFT JOIN ItemMaster i ON i.tenant_id=m.tenant_id AND i.ItemNum=m.ItemNum");
        var newWorst = await db.Ado.GetIntAsync(
            """
            SELECT IFNULL(MAX(c),0) FROM (
              SELECT m.RecID, COUNT(i.ItemNum) c FROM MissedPrint m
              LEFT JOIN ItemMaster i ON i.tenant_id=m.tenant_id AND i.ItemNum=m.ItemNum
              GROUP BY m.RecID) x
            """);
        var oldMatched = await db.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM MissedPrint m JOIN ItemMaster i ON m.Domain=i.Domain AND m.ItemNum=i.ItemNum");
        var newMatched = await db.Ado.GetIntAsync(
            "SELECT COUNT(1) FROM MissedPrint m JOIN ItemMaster i ON i.tenant_id=m.tenant_id AND i.ItemNum=m.ItemNum");

        _out.WriteLine($"重复组：按租户={dupByTenant} 按Domain={dupByDomain}；" +
                       $"base={baseRows} newJoin={newJoinRows} 单行最大命中={newWorst}；" +
                       $"能取到物料名：old={oldMatched} new={newMatched}");

        Assert.Equal(0, dupByTenant);              // 租户内唯一 → 可直接收口
        Assert.True(dupByDomain > 0, "Domain-only 若已唯一，放大论证需重做");
        Assert.Equal(baseRows, newJoinRows);       // 不放大：SELECT 行数 == COUNT 基集
        Assert.True(newWorst <= 1);
        Assert.True(newMatched > oldMatched, "按租户关联应当严格覆盖更多行（UAT 原本一条都取不到）");
    }

    /// <summary>回归：MissedPrint 租户归属未被本批破坏。</summary>
    [Fact]
    public async Task Data_Regression_TenantSplitUnchanged()
    {
        if (!ItEnabled) return;
        var db = BuildAidopdev();
        Assert.NotNull(db);

        var total = await db!.Ado.GetIntAsync("SELECT COUNT(1) FROM MissedPrint");
        var nullTenant = await db.Ado.GetIntAsync("SELECT COUNT(1) FROM MissedPrint WHERE tenant_id IS NULL");
        var uat = await db.Ado.GetIntAsync("SELECT COUNT(1) FROM MissedPrint WHERE tenant_id=@T",
            new List<SugarParameter> { new("@T", TenantUat) });
        var aidop = await db.Ado.GetIntAsync("SELECT COUNT(1) FROM MissedPrint WHERE tenant_id=@T",
            new List<SugarParameter> { new("@T", TenantAidop) });

        _out.WriteLine($"total={total} null={nullTenant} UAT={uat} 797={aidop}");
        Assert.Equal(0, nullTenant);
        Assert.Equal(total, uat + aidop);
    }
}