ft/Client/Assets/Scripts/Services/PlayerData/PlayerKVSaveRouteEditorValidationHost.cs

#if UNITY_EDITOR && !SERVICE_HOST
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using game.Account;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace game.PlayerDataStorage
{
    internal static class PlayerKVSaveRouteEditorValidationHost
    {
        static int running;
        // Retain a failed cleanup's owner for diagnosis; never silently restart over it.
        static object failedLifetime;
        internal static async Task<string> RunAsync(string caseId)
        {
            if (caseId != "fixed-route") throw new ArgumentException("Unknown fixed validation case.");
            if (Interlocked.CompareExchange(ref running, 1, 0) != 0 || failedLifetime != null)
                throw new InvalidOperationException("Validation already running or cleanup failed.");
            var run = new Run();
            try { return await run.Execute(); }
            finally
            {
                try { await run.Close(); }
                catch { failedLifetime = run; throw; }
                finally { Interlocked.Exchange(ref running, 0); }
            }
        }

        sealed class Run
        {
            readonly Uri api = new Uri("http://kv-route.invalid/");
            readonly List<S101AccountSession> sessions = new List<S101AccountSession>();
            readonly Dictionary<string, Dictionary<string, string>> remote = new Dictionary<string, Dictionary<string, string>>
            { ["101"] = new Dictionary<string, string> { ["k"] = "A", ["empty"] = "" }, ["102"] = new Dictionary<string, string> { ["k"] = "B" } };
            readonly string cache = Path.GetFullPath(Path.Combine(UnityEngine.Application.dataPath,
                "../../CodexOutput/upserver/KVSaveRouteTests/unity-runs", DateTime.UtcNow.ToString("yyyyMMddHHmmss") + "_" + Guid.NewGuid().ToString("N")));
            PlayerKVGameSessionBridge bridge;
            PlayerKVGameLoadGuard guard;
            int assertions, auth, gets, writes;
            long epoch = 1;
            void Check(bool value) { assertions++; if (!value) throw new InvalidOperationException("Fixed route assertion " + assertions); }
            static HttpResponseMessage Json(object value) => new HttpResponseMessage(HttpStatusCode.OK)
            { Content = new StringContent(JsonConvert.SerializeObject(value)) };
            sealed class SyntheticHandler : HttpMessageHandler
            {
                readonly Func<HttpRequestMessage, Task<HttpResponseMessage>> send;
                internal SyntheticHandler(Func<HttpRequestMessage, Task<HttpResponseMessage>> send) { this.send = send; }
                protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken token) => send(request);
            }
            HttpMessageHandler KV(CookieContainer jar)
            {
                var id = jar.GetCookies(api)["sid"].Value;
                return new SyntheticHandler(async request =>
                {
                    Check(request.RequestUri.Host == "kv-route.invalid" && request.RequestUri.Port == 80);
                    var path = request.RequestUri.AbsolutePath;
                    Check(path == "/playerdata/Get" || path == "/playerdata/Set");
                    var body = JObject.Parse(await request.Content.ReadAsStringAsync());
                    if (path == "/playerdata/Get") { gets++; return Json(new { data = remote[id] }); }
                    writes++;
                    foreach (var p in ((JObject)body["data"]).Properties()) remote[id][p.Name] = (string)p.Value;
                    return Json(new { });
                });
            }
            async Task<PlayerKVGameSessionHandle> Open(string id)
            {
                var session = new S101AccountSession(api, jar => new SyntheticHandler(request =>
                {
                    Check(request.RequestUri.Host == "kv-route.invalid" && request.RequestUri.AbsolutePath == "/account/Login");
                    auth++; jar.Add(api, new Cookie("sid", id));
                    return Task.FromResult(Json(new { state = 0, internalId = int.Parse(id), newCreate = false,
                        createTime = "2026-01-01T00:00:00Z", svrTime = "2026-01-01T00:00:00Z" }));
                }));
                sessions.Add(session);
                Check((await session.LoginAsync(id)).Success);
                var opened = await bridge.OpenAsync(session, cache, id, api, epoch, e => e == epoch);
                Check(opened.Success); return opened.Handle;
            }
            internal async Task<string> Execute()
            {
                // Never disturb a guard held by another validation or a controlled login.
                Check(PlayerKVGameLoadGuard.TryEnter(out guard)); guard.Dispose(); guard = null;
                Directory.CreateDirectory(cache); bridge = new PlayerKVGameSessionBridge(KV);
                var a = await Open("101");
                var present = KVMgr.ReadKV(a, "k"); Check(present.Success && present.Found == true && present.Value == "A");
                Check(KVMgr.ReadKV(a, "missing").Found == false);
                Check(KVMgr.ReadKV(a, "empty").Found == true && KVMgr.ReadKV(a, "empty").Value == "");
                Check(KVMgr.ReadKV(a, null).Found == null);
                var edit = KVMgr.WriteKV(a, "k", "remote"); Check(edit.Accepted && edit.Ticket != null && writes == 0);
                var local = KVMgr.WriteKV(a, "k", "local", false); Check(local.Accepted && local.Ticket == null);
                Check(KVMgr.ReadKV(a, "k").Value == "local");
                var flush = await KVMgr.FlushKVAsync(a); Check(flush.Confirmed == 1 && remote["101"]["k"] == "remote");
                Check((await KVMgr.WaitForKVTicketAsync(a, edit.Ticket)).Status == PlayerKVTicketStatus.Confirmed);
                await bridge.CloseAsync(); epoch++;
                var b = await Open("102"); var writesBefore = writes;
                Check(KVMgr.ReadKV(a, "k").Error == PlayerKVKeyReadError.StaleOrClosing);
                Check(!KVMgr.WriteKV(a, "k", "late").Accepted);
                Check((await KVMgr.FlushKVAsync(a)).Blocked == 1);
                Check((await KVMgr.WaitForKVTicketAsync(b, edit.Ticket)).Status == PlayerKVTicketStatus.Blocked);
                Check(KVMgr.ReadKV(b, "k").Value == "B" && writes == writesBefore);
                Check(PlayerKVGameLoadGuard.TryEnter(out guard));
                Check(KVMgr.ReadKV(null, null).Error == PlayerKVKeyReadError.LoadGuardActive);
                Check(KVMgr.WriteKV(null, null, null).StateResult.Error == PlayerKVChangeError.Blocked);
                Check((await KVMgr.FlushKVAsync(b)).TransportError == PlayerKVError.Cancelled);
                Check((await KVMgr.WaitForKVTicketAsync(b, null)).TransportError == PlayerKVError.Cancelled);
                Check(guard.Violations == 4 && guard.Count(PlayerKVGuardPoint.ReadLocal) == 1 && guard.Count(PlayerKVGuardPoint.Update) == 1 && guard.Count(PlayerKVGuardPoint.Sync) == 2);
                Check(auth == 2 && gets == 2 && writes == 1);
                await Close();
                return JsonConvert.SerializeObject(new { success = true, assertions, auth, gets, writes, formalRequests = 0, restored = true, cache });
            }
            internal async Task Close()
            {
                if (bridge != null) await bridge.CloseAsync();
                foreach (var session in sessions) session.Dispose(); sessions.Clear();
                guard?.Dispose(); guard = null;
            }
        }
    }
}
#endif