Implement worker AddItem commands

2026-04-26 18:26:44 -04:00
parent 653f17c669
commit 59c710d789
11 changed files with 803 additions and 2 deletions
@@ -78,6 +78,166 @@ public sealed class MxAccessCommandExecutorTests
        Assert.Equal(44, registeredServerHandle.ServerHandle);
    }

+    [Fact]
+    public async Task DispatchAsync_AddItem_CallsMxAccessOnStaAndTracksItemHandle()
+    {
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 46,
+            addItemHandle: 501);
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+        await session.DispatchAsync(CreateRegisterCommand("register-before-add", "client-a"));
+
+        MxCommandReply reply = await session.DispatchAsync(CreateAddItemCommand(
+            "add-item",
+            46,
+            "Galaxy.Tag.Value"));
+
+        Assert.Equal(ProtocolStatusCode.Ok, reply.ProtocolStatus.Code);
+        Assert.True(reply.HasHresult);
+        Assert.Equal(0, reply.Hresult);
+        Assert.Equal(501, reply.AddItem.ItemHandle);
+        Assert.Equal(MxDataType.Integer, reply.ReturnValue.DataType);
+        Assert.Equal(501, reply.ReturnValue.Int32Value);
+        Assert.Equal(46, fakeComObject.AddItemServerHandle);
+        Assert.Equal("Galaxy.Tag.Value", fakeComObject.AddItemDefinition);
+        Assert.Equal(runtime.StaThreadId, fakeComObject.AddItemThreadId);
+
+        RegisteredItemHandle registeredItemHandle = Assert.Single(
+            await session.GetRegisteredItemHandlesAsync());
+        Assert.Equal(46, registeredItemHandle.ServerHandle);
+        Assert.Equal(501, registeredItemHandle.ItemHandle);
+        Assert.Equal("Galaxy.Tag.Value", registeredItemHandle.ItemDefinition);
+        Assert.Equal(string.Empty, registeredItemHandle.ItemContext);
+        Assert.False(registeredItemHandle.HasItemContext);
+    }
+
+    [Fact]
+    public async Task DispatchAsync_AddItem2_PassesContextExactlyAndTracksItemHandle()
+    {
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 47,
+            addItem2Handle: 502);
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+        await session.DispatchAsync(CreateRegisterCommand("register-before-add2", "client-a"));
+
+        MxCommandReply reply = await session.DispatchAsync(CreateAddItem2Command(
+            "add-item2",
+            47,
+            "TestInt",
+            "TestChildObject"));
+
+        Assert.Equal(ProtocolStatusCode.Ok, reply.ProtocolStatus.Code);
+        Assert.Equal(502, reply.AddItem2.ItemHandle);
+        Assert.Equal(MxDataType.Integer, reply.ReturnValue.DataType);
+        Assert.Equal(502, reply.ReturnValue.Int32Value);
+        Assert.Equal(47, fakeComObject.AddItem2ServerHandle);
+        Assert.Equal("TestInt", fakeComObject.AddItem2Definition);
+        Assert.Equal("TestChildObject", fakeComObject.AddItem2Context);
+        Assert.Equal(runtime.StaThreadId, fakeComObject.AddItem2ThreadId);
+
+        RegisteredItemHandle registeredItemHandle = Assert.Single(
+            await session.GetRegisteredItemHandlesAsync());
+        Assert.Equal(47, registeredItemHandle.ServerHandle);
+        Assert.Equal(502, registeredItemHandle.ItemHandle);
+        Assert.Equal("TestInt", registeredItemHandle.ItemDefinition);
+        Assert.Equal("TestChildObject", registeredItemHandle.ItemContext);
+        Assert.True(registeredItemHandle.HasItemContext);
+    }
+
+    [Fact]
+    public async Task DispatchAsync_RemoveItem_CallsMxAccessOnStaAndRemovesTrackedItemHandle()
+    {
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 48,
+            addItemHandle: 503);
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+        await session.DispatchAsync(CreateRegisterCommand("register-before-remove", "client-a"));
+        await session.DispatchAsync(CreateAddItemCommand("add-before-remove", 48, "Galaxy.Tag.Value"));
+
+        MxCommandReply reply = await session.DispatchAsync(CreateRemoveItemCommand(
+            "remove-item",
+            48,
+            503));
+
+        Assert.Equal(ProtocolStatusCode.Ok, reply.ProtocolStatus.Code);
+        Assert.True(reply.HasHresult);
+        Assert.Equal(0, reply.Hresult);
+        Assert.Equal(48, fakeComObject.RemoveItemServerHandle);
+        Assert.Equal(503, fakeComObject.RemovedItemHandle);
+        Assert.Equal(runtime.StaThreadId, fakeComObject.RemoveItemThreadId);
+        Assert.Empty(await session.GetRegisteredItemHandlesAsync());
+    }
+
+    [Fact]
+    public async Task DispatchAsync_RemoveItemWithCrossServerHandle_PreservesHResultAndKeepsTrackedItemHandle()
+    {
+        const int hresult = unchecked((int)0x80070057);
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 49,
+            addItemHandle: 504,
+            removeItemException: new COMException("Invalid item handle.", hresult));
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+        await session.DispatchAsync(CreateRegisterCommand("register-before-remove-failure", "client-a"));
+        await session.DispatchAsync(CreateAddItemCommand("add-before-remove-failure", 49, "Galaxy.Tag.Value"));
+
+        MxCommandReply reply = await session.DispatchAsync(CreateRemoveItemCommand(
+            "remove-item-failure",
+            999,
+            504));
+
+        Assert.Equal(ProtocolStatusCode.MxaccessFailure, reply.ProtocolStatus.Code);
+        Assert.True(reply.HasHresult);
+        Assert.Equal(hresult, reply.Hresult);
+        Assert.Contains("0x80070057", reply.DiagnosticMessage);
+        Assert.Equal(999, fakeComObject.RemoveItemServerHandle);
+        Assert.Equal(504, fakeComObject.RemovedItemHandle);
+
+        RegisteredItemHandle registeredItemHandle = Assert.Single(
+            await session.GetRegisteredItemHandlesAsync());
+        Assert.Equal(49, registeredItemHandle.ServerHandle);
+        Assert.Equal(504, registeredItemHandle.ItemHandle);
+    }
+
+    [Fact]
+    public async Task DispatchAsync_AddItem2WhenMxAccessThrows_PreservesHResultAndDoesNotTrackItemHandle()
+    {
+        const int hresult = unchecked((int)0x80070057);
+        FakeMxAccessComObject fakeComObject = new(
+            registerHandle: 50,
+            addItem2Exception: new COMException("Invalid server handle.", hresult));
+        FakeMxAccessComObjectFactory factory = new(fakeComObject);
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+
+        MxCommandReply reply = await session.DispatchAsync(CreateAddItem2Command(
+            "add-item2-failure",
+            9001,
+            "TestInt",
+            "TestChildObject"));
+
+        Assert.Equal(ProtocolStatusCode.MxaccessFailure, reply.ProtocolStatus.Code);
+        Assert.True(reply.HasHresult);
+        Assert.Equal(hresult, reply.Hresult);
+        Assert.Contains("0x80070057", reply.DiagnosticMessage);
+        Assert.Equal(9001, fakeComObject.AddItem2ServerHandle);
+        Assert.Equal("TestInt", fakeComObject.AddItem2Definition);
+        Assert.Equal("TestChildObject", fakeComObject.AddItem2Context);
+        Assert.Empty(await session.GetRegisteredItemHandlesAsync());
+    }
+
    [Fact]
    public async Task DispatchAsync_RegisterWithoutPayload_ReturnsInvalidRequest()
    {
@@ -98,6 +258,26 @@ public sealed class MxAccessCommandExecutorTests
        Assert.Null(factory.FakeComObject.RegisteredClientName);
    }

+    [Fact]
+    public async Task DispatchAsync_AddItemWithoutPayload_ReturnsInvalidRequest()
+    {
+        FakeMxAccessComObjectFactory factory = new(new FakeMxAccessComObject(registerHandle: 51));
+        using StaRuntime runtime = CreateRuntime();
+        using MxAccessStaSession session = new(runtime, factory, new NoopEventSink());
+        await session.StartAsync(workerProcessId: 1234);
+
+        MxCommandReply reply = await session.DispatchAsync(new StaCommand(
+            "session-1",
+            "missing-add-payload",
+            new MxCommand
+            {
+                Kind = MxCommandKind.AddItem,
+            }));
+
+        Assert.Equal(ProtocolStatusCode.InvalidRequest, reply.ProtocolStatus.Code);
+        Assert.Null(factory.FakeComObject.AddItemDefinition);
+    }
+
    private static StaCommand CreateRegisterCommand(
        string correlationId,
        string clientName)
@@ -132,6 +312,65 @@ public sealed class MxAccessCommandExecutorTests
            });
    }

+    private static StaCommand CreateAddItemCommand(
+        string correlationId,
+        int serverHandle,
+        string itemDefinition)
+    {
+        return new StaCommand(
+            "session-1",
+            correlationId,
+            new MxCommand
+            {
+                Kind = MxCommandKind.AddItem,
+                AddItem = new AddItemCommand
+                {
+                    ServerHandle = serverHandle,
+                    ItemDefinition = itemDefinition,
+                },
+            });
+    }
+
+    private static StaCommand CreateAddItem2Command(
+        string correlationId,
+        int serverHandle,
+        string itemDefinition,
+        string itemContext)
+    {
+        return new StaCommand(
+            "session-1",
+            correlationId,
+            new MxCommand
+            {
+                Kind = MxCommandKind.AddItem2,
+                AddItem2 = new AddItem2Command
+                {
+                    ServerHandle = serverHandle,
+                    ItemDefinition = itemDefinition,
+                    ItemContext = itemContext,
+                },
+            });
+    }
+
+    private static StaCommand CreateRemoveItemCommand(
+        string correlationId,
+        int serverHandle,
+        int itemHandle)
+    {
+        return new StaCommand(
+            "session-1",
+            correlationId,
+            new MxCommand
+            {
+                Kind = MxCommandKind.RemoveItem,
+                RemoveItem = new RemoveItemCommand
+                {
+                    ServerHandle = serverHandle,
+                    ItemHandle = itemHandle,
+                },
+            });
+    }
+
    private static StaRuntime CreateRuntime()
    {
        return new StaRuntime(
@@ -143,14 +382,29 @@ public sealed class MxAccessCommandExecutorTests
    private sealed class FakeMxAccessComObject
    {
        private readonly int registerHandle;
+        private readonly int addItemHandle;
+        private readonly int addItem2Handle;
        private readonly Exception? unregisterException;
+        private readonly Exception? addItemException;
+        private readonly Exception? addItem2Exception;
+        private readonly Exception? removeItemException;

        public FakeMxAccessComObject(
            int registerHandle,
-            Exception? unregisterException = null)
+            int addItemHandle = 0,
+            int addItem2Handle = 0,
+            Exception? unregisterException = null,
+            Exception? addItemException = null,
+            Exception? addItem2Exception = null,
+            Exception? removeItemException = null)
        {
            this.registerHandle = registerHandle;
+            this.addItemHandle = addItemHandle;
+            this.addItem2Handle = addItem2Handle;
            this.unregisterException = unregisterException;
+            this.addItemException = addItemException;
+            this.addItem2Exception = addItem2Exception;
+            this.removeItemException = removeItemException;
        }

        public string? RegisteredClientName { get; private set; }
@@ -161,6 +415,26 @@ public sealed class MxAccessCommandExecutorTests

        public int? UnregisterThreadId { get; private set; }

+        public int? AddItemServerHandle { get; private set; }
+
+        public string? AddItemDefinition { get; private set; }
+
+        public int? AddItemThreadId { get; private set; }
+
+        public int? AddItem2ServerHandle { get; private set; }
+
+        public string? AddItem2Definition { get; private set; }
+
+        public string? AddItem2Context { get; private set; }
+
+        public int? AddItem2ThreadId { get; private set; }
+
+        public int? RemoveItemServerHandle { get; private set; }
+
+        public int? RemovedItemHandle { get; private set; }
+
+        public int? RemoveItemThreadId { get; private set; }
+
        public int Register(string clientName)
        {
            RegisteredClientName = clientName;
@@ -179,6 +453,54 @@ public sealed class MxAccessCommandExecutorTests
                throw unregisterException;
            }
        }
+
+        public int AddItem(
+            int serverHandle,
+            string itemDefinition)
+        {
+            AddItemServerHandle = serverHandle;
+            AddItemDefinition = itemDefinition;
+            AddItemThreadId = Environment.CurrentManagedThreadId;
+
+            if (addItemException is not null)
+            {
+                throw addItemException;
+            }
+
+            return addItemHandle;
+        }
+
+        public int AddItem2(
+            int serverHandle,
+            string itemDefinition,
+            string itemContext)
+        {
+            AddItem2ServerHandle = serverHandle;
+            AddItem2Definition = itemDefinition;
+            AddItem2Context = itemContext;
+            AddItem2ThreadId = Environment.CurrentManagedThreadId;
+
+            if (addItem2Exception is not null)
+            {
+                throw addItem2Exception;
+            }
+
+            return addItem2Handle;
+        }
+
+        public void RemoveItem(
+            int serverHandle,
+            int itemHandle)
+        {
+            RemoveItemServerHandle = serverHandle;
+            RemovedItemHandle = itemHandle;
+            RemoveItemThreadId = Environment.CurrentManagedThreadId;
+
+            if (removeItemException is not null)
+            {
+                throw removeItemException;
+            }
+        }
    }

    private sealed class FakeMxAccessComObjectFactory : IMxAccessComObjectFactory