Исправление ебучего теста (#4054)

Author: ThereDrD0

Content.IntegrationTests/Tests/_Sunrise/Networking/NetTexturesRegressionTest.cs

@@ -1,3 +1,4 @@
+using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -12,6 +13,7 @@
 using Content.Shared._Sunrise.SunriseCCVars;
 using Content.Shared._Sunrise.NetTextures;
 using Robust.Client.ResourceManagement;
+using Robust.Shared;
 using Robust.Shared.GameObjects;
 using Robust.Client.State;
 using Robust.Shared.ContentPack;
@@ -274,7 +276,19 @@ await client.WaitPost(() =>
             client.CfgMan.SetCVar(SunriseCCVars.LobbyBackgroundType, "Animation");
         });
 
-        await pair.RunTicksSync(5);
+        await WaitUntilClientCondition(
+            client,
+            () =>
+            {
+                var lobbyState = stateManager.CurrentState as LobbyState;
+                return lobbyState?.Lobby != null &&
+                       !lobbyState.Lobby.LoadingAnimationContainer.Visible &&
+                       lobbyState.Lobby.LobbyAnimation.Visible &&
+                       lobbyState.Lobby.LobbyAnimation.DisplayRect.Texture != null &&
+                       client.CfgMan.GetCVar(SunriseCCVars.LobbyAnimation) == invalidAnimationId;
+            },
+            timeoutSeconds: 10,
+            "network lobby animation transient fallback to finish loading");
 
         await client.WaitAssertion(() =>
         {
@@ -797,12 +811,12 @@ private static async Task WaitUntilTextureReady(
         string resourcePath,
         int maxTicks)
     {
-        await PoolManager.WaitUntil(client, async () =>
-        {
-            var ready = false;
-            await client.WaitPost(() => ready = manager.TryGetTexture(resourcePath, out _));
-            return ready;
-        }, maxTicks: maxTicks);
+        await WaitUntilClientCondition(
+            client,
+            () => manager.TryGetTexture(resourcePath, out _),
+            ConvertLegacyTickBudgetToSeconds(maxTicks),
+            $"texture '{resourcePath}' to become ready",
+            () => DescribeTextureLoadState(manager, resourcePath));
     }
 
     private static MemoryStream CreateTransferStream(List<(ResPath Relative, byte[] Data)> files)
@@ -850,12 +864,99 @@ private static async Task WaitUntilAnimationStateReady(
         string stateId,
         int maxTicks)
     {
-        await PoolManager.WaitUntil(client, async () =>
+        await WaitUntilClientCondition(
+            client,
+            () => manager.TryGetAnimationState(resourcePath, stateId, out _),
+            ConvertLegacyTickBudgetToSeconds(maxTicks),
+            $"animation state '{stateId}' for '{resourcePath}' to become ready",
+            () => DescribeAnimationLoadState(manager, resourcePath, stateId));
+    }
+
+    private static async Task WaitUntilClientCondition(
+        RobustIntegrationTest.ClientIntegrationInstance client,
+        Func<bool> predicate,
+        int timeoutSeconds,
+        string description,
+        Func<string> diagnostics = null,
+        int tickStep = 5,
+        int pollDelayMs = 5)
+    {
+        var maxTicks = GetTickBudgetForSeconds(client, timeoutSeconds);
+        var ticksAwaited = 0;
+
+        await client.WaitIdleAsync();
+
+        while (ticksAwaited < maxTicks)
         {
             var ready = false;
-            await client.WaitPost(() => ready = manager.TryGetAnimationState(resourcePath, stateId, out _));
-            return ready;
-        }, maxTicks: maxTicks);
+            await client.WaitPost(() => ready = predicate());
+            if (ready)
+                return;
+
+            var ticksToRun = Math.Min(tickStep, maxTicks - ticksAwaited);
+            await client.WaitRunTicks(ticksToRun);
+            ticksAwaited += ticksToRun;
+
+            if (pollDelayMs > 0)
+                await Task.Delay(pollDelayMs);
+        }
+
+        string debugState = null;
+        if (diagnostics != null)
+            await client.WaitPost(() => debugState = diagnostics());
+
+        Assert.Fail(
+            $"Condition did not pass after {maxTicks} ticks while waiting for {description}." +
+            (string.IsNullOrEmpty(debugState) ? string.Empty : $"\n{debugState}"));
+    }
+
+    private static int ConvertLegacyTickBudgetToSeconds(int maxTicks)
+    {
+        var defaultTickrate = CVars.NetTickrate.DefaultValue;
+        return Math.Max(5, (int) Math.Ceiling((double) maxTicks / defaultTickrate));
+    }
+
+    private static int GetTickBudgetForSeconds(
+        RobustIntegrationTest.ClientIntegrationInstance client,
+        int timeoutSeconds)
+    {
+        var tickrate = Math.Max(1, client.CfgMan.GetCVar(CVars.NetTickrate));
+        return Math.Max(1, timeoutSeconds * tickrate);
+    }
+
+    private static string DescribeTextureLoadState(ClientNetTexturesManager manager, string resourcePath)
+    {
+        var resourceKey = new ResPath(resourcePath).Clean().ToString();
+        var pendingResources = GetPrivateField<Dictionary<string, ResPath>>(manager, "_pendingResources");
+        var preparingResources = GetPrivateField<HashSet<string>>(manager, "_preparingResources");
+        var failedResources = GetPrivateField<HashSet<string>>(manager, "_failedResources");
+        var prepareRequests = GetPrivateField<ICollection>(manager, "_prepareRequests");
+        var preparedUploads = GetPrivateField<ICollection>(manager, "_preparedUploads");
+        var workerRunning = GetPrivateField<bool>(manager, "_prepareWorkerRunning");
+
+        return $"NetTextures state for {resourceKey}: pending={pendingResources.ContainsKey(resourceKey)}, " +
+               $"preparing={preparingResources.Contains(resourceKey)}, failed={failedResources.Contains(resourceKey)}, " +
+               $"workerRunning={workerRunning}, queuedRequests={prepareRequests.Count}, preparedUploads={preparedUploads.Count}.";
+    }
+
+    private static string DescribeAnimationLoadState(
+        ClientNetTexturesManager manager,
+        string resourcePath,
+        string stateId)
+    {
+        var resourceKey = new ResPath(resourcePath).Clean().ToString();
+        var pendingResources = GetPrivateField<Dictionary<string, ResPath>>(manager, "_pendingResources");
+        var preparingResources = GetPrivateField<HashSet<string>>(manager, "_preparingResources");
+        var failedResources = GetPrivateField<HashSet<string>>(manager, "_failedResources");
+        var prepareRequests = GetPrivateField<ICollection>(manager, "_prepareRequests");
+        var preparedUploads = GetPrivateField<ICollection>(manager, "_preparedUploads");
+        var workerRunning = GetPrivateField<bool>(manager, "_prepareWorkerRunning");
+        var hasState = manager.TryGetAnimationState(resourcePath, stateId, out _);
+
+        return $"NetTextures state for {resourceKey}#{stateId}: pending={pendingResources.ContainsKey(resourceKey)}, " +
+               $"preparing={preparingResources.Contains(resourceKey)}, failed={failedResources.Contains(resourceKey)}, " +
+               $"workerRunning={workerRunning}, queuedRequests={prepareRequests.Count}, preparedUploads={preparedUploads.Count}, " +
+               $"stateReady={hasState}.";
     }
 
     private static async Task DispatchFallbackChunk(