Implement engine-bridge v2 plugin masquerade (#10)

tests/Recordingtest.EngineBridge.IntegrationTests/FakeBridgeServer.cs

@@ -0,0 +1,72 @@
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+
+namespace Recordingtest.EngineBridge.IntegrationTests;
+
+public sealed class FakeBridgeServer : IDisposable
+{
+    public Dictionary<string, string> Responses { get; } = new();
+    public TimeSpan ResponseDelay { get; set; } = TimeSpan.Zero;
+
+    private readonly HttpListener _listener;
+    private readonly Thread _thread;
+    private volatile bool _stop;
+
+    public int Port { get; }
+    public string BaseUrl => $"http://localhost:{Port}";
+
+    public FakeBridgeServer()
+    {
+        Port = FindFreePort();
+        _listener = new HttpListener();
+        _listener.Prefixes.Add($"http://localhost:{Port}/");
+        _listener.Start();
+        _thread = new Thread(Loop) { IsBackground = true };
+        _thread.Start();
+    }
+
+    private static int FindFreePort()
+    {
+        var l = new TcpListener(IPAddress.Loopback, 0);
+        l.Start();
+        var p = ((IPEndPoint)l.LocalEndpoint).Port;
+        l.Stop();
+        return p;
+    }
+
+    private void Loop()
+    {
+        while (!_stop && _listener.IsListening)
+        {
+            HttpListenerContext ctx;
+            try { ctx = _listener.GetContext(); }
+            catch { return; }
+            try
+            {
+                if (ResponseDelay > TimeSpan.Zero) Thread.Sleep(ResponseDelay);
+                var path = ctx.Request.Url?.AbsolutePath ?? "/";
+                if (Responses.TryGetValue(path, out var body))
+                {
+                    var bytes = Encoding.UTF8.GetBytes(body);
+                    ctx.Response.StatusCode = 200;
+                    ctx.Response.ContentType = "application/json";
+                    ctx.Response.OutputStream.Write(bytes, 0, bytes.Length);
+                }
+                else
+                {
+                    ctx.Response.StatusCode = 404;
+                }
+                ctx.Response.OutputStream.Close();
+            }
+            catch { try { ctx.Response.Abort(); } catch { } }
+        }
+    }
+
+    public void Dispose()
+    {
+        _stop = true;
+        try { _listener.Stop(); } catch { }
+        try { _listener.Close(); } catch { }
+    }
+}

tests/Recordingtest.EngineBridge.IntegrationTests/HmEgHttpSnapshotTests.cs

@@ -0,0 +1,66 @@
+using Recordingtest.EngineBridge.Client;
+using Xunit;
+
+namespace Recordingtest.EngineBridge.IntegrationTests;
+
+public class HmEgHttpSnapshotTests
+{
+    [Fact]
+    public void Client_SelectionEndpoint_ReturnsIds()
+    {
+        using var srv = new FakeBridgeServer();
+        srv.Responses["/selection"] = "{\"selected_ids\":[\"a\",\"b\"]}";
+        using var c = new HmEgHttpSnapshot(srv.BaseUrl);
+        Assert.Equal(new[] { "a", "b" }, c.SelectedObjectIds);
+    }
+
+    [Fact]
+    public void Client_CameraEndpoint_ReturnsCameraState()
+    {
+        using var srv = new FakeBridgeServer();
+        srv.Responses["/camera"] = "{\"eye\":[1,2,3],\"target\":[4,5,6],\"up\":[0,0,1],\"fov\":50}";
+        using var c = new HmEgHttpSnapshot(srv.BaseUrl);
+        var cam = c.Camera;
+        Assert.Equal(new double[] { 1, 2, 3 }, cam.EyePoint);
+        Assert.Equal(new double[] { 4, 5, 6 }, cam.Target);
+        Assert.Equal(50, cam.Fov);
+    }
+
+    [Fact]
+    public void Client_SceneEndpoint_ReturnsSceneSummary()
+    {
+        using var srv = new FakeBridgeServer();
+        srv.Responses["/scene"] = "{\"object_count\":42,\"document_path\":\"C:/m.hmeg\"}";
+        using var c = new HmEgHttpSnapshot(srv.BaseUrl);
+        var s = c.Scene;
+        Assert.Equal(42, s.ObjectCount);
+        Assert.Equal("C:/m.hmeg", s.DocumentPath);
+    }
+
+    [Fact]
+    public void Client_RenderEndpoint_ReturnsIsComplete()
+    {
+        using var srv = new FakeBridgeServer();
+        srv.Responses["/render"] = "{\"complete\":true}";
+        using var c = new HmEgHttpSnapshot(srv.BaseUrl);
+        Assert.True(c.IsRenderComplete);
+    }
+
+    [Fact]
+    public void Client_HealthEndpoint_ReturnsOk()
+    {
+        using var srv = new FakeBridgeServer();
+        srv.Responses["/health"] = "{\"status\":\"ok\",\"port\":1}";
+        using var c = new HmEgHttpSnapshot(srv.BaseUrl);
+        Assert.True(c.IsHealthy);
+    }
+
+    [Fact]
+    public void Client_Timeout_ThrowsEngineBridgeException()
+    {
+        using var srv = new FakeBridgeServer { ResponseDelay = TimeSpan.FromSeconds(5) };
+        srv.Responses["/selection"] = "{\"selected_ids\":[]}";
+        using var c = new HmEgHttpSnapshot(srv.BaseUrl, timeout: TimeSpan.FromMilliseconds(500));
+        Assert.Throws<EngineBridgeException>(() => _ = c.SelectedObjectIds);
+    }
+}

tests/Recordingtest.EngineBridge.IntegrationTests/Recordingtest.EngineBridge.IntegrationTests.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <IsPackable>false</IsPackable>
+    <RootNamespace>Recordingtest.EngineBridge.IntegrationTests</RootNamespace>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+    <PackageReference Include="xunit" Version="2.9.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Recordingtest.EngineBridge.Client\Recordingtest.EngineBridge.Client.csproj" />
+  </ItemGroup>
+</Project>