Fix smoke gaps: recorder target + VK translation, player enum + null guard (#11)

tests/Recordingtest.Player.Tests/PlayerEngineTests.cs

@@ -153,6 +153,66 @@ baselines:
         Assert.Single(s.Baselines);
     }
 
+    [Fact]
+    public void PlayerEngine_NullTarget_SkipsWithoutCalling()
+    {
+        var engine = new PlayerEngine();
+        var host = new FakePlayerHost();
+        var scenario = new Scenario
+        {
+            Steps =
+            {
+                new Step { Kind = StepKind.Click, Target = null },
+                new Step { Kind = StepKind.Drag, Target = null },
+                new Step { Kind = StepKind.Type, Target = null, Value = "hello" },
+            },
+        };
+
+        engine.Run(scenario, host);
+
+        Assert.Empty(host.Clicks);
+        Assert.Empty(host.Drags);
+        Assert.Empty(host.Types);
+        Assert.Empty(host.Failures);
+    }
+
+    [Fact]
+    public void PlayerEngine_WheelKind_DoesNotThrow()
+    {
+        var engine = new PlayerEngine();
+        var host = new FakePlayerHost();
+        var scenario = new Scenario
+        {
+            Steps =
+            {
+                new Step { Kind = StepKind.Wheel, Value = "-120" },
+                new Step { Kind = StepKind.Focus },
+            },
+        };
+
+        engine.Run(scenario, host);
+        Assert.Empty(host.Failures);
+    }
+
+    [Fact]
+    public void ScenarioLoader_ParsesWheelAndFocusKinds()
+    {
+        const string yaml = """
+name: wheel-focus
+steps:
+  - kind: wheel
+    value: "-120"
+  - kind: focus
+    target:
+      uia_path: "Window/Edit"
+      offset: [0.5, 0.5]
+""";
+        var s = ScenarioLoader.LoadFromString(yaml);
+        Assert.Equal(2, s.Steps.Count);
+        Assert.Equal(StepKind.Wheel, s.Steps[0].Kind);
+        Assert.Equal(StepKind.Focus, s.Steps[1].Kind);
+    }
+
     private static string LocateEngineSource([CallerFilePath] string here = "")
     {
         // here = .../tests/Recordingtest.Player.Tests/PlayerEngineTests.cs

tests/Recordingtest.Player.Tests/SmokeRegressionTests.cs

@@ -0,0 +1,73 @@
+using Recordingtest.Player.Model;
+using Xunit;
+
+namespace Recordingtest.Player.Tests;
+
+/// <summary>
+/// Regression for issue #11 — smoke test against EG-BIM Modeler exposed
+/// recorder output that the player could not consume (wheel/focus kinds
+/// missing, null targets causing wild clicks). This test embeds a minimal
+/// yaml that mimics the real recorder output and runs it through the full
+/// ScenarioLoader -> PlayerEngine pipeline against a fake host.
+/// </summary>
+public class SmokeRegressionTests
+{
+    private const string SmokeYaml = """
+name: smoke-regression
+description: mimics real recorder output
+sut:
+  exe: "EG-BIM Modeler/EG-BIM Modeler.exe"
+  startup_timeout_ms: 12000
+steps:
+  - kind: wheel
+    value: "-120"
+  - kind: drag
+    target:
+      uia_path: "Window/Canvas"
+      offset: [0.5, 0.5]
+    value: "0.6,0.4"
+  - kind: click
+  - kind: type
+    value: "BOX"
+    target:
+      uia_path: "Window/Edit"
+      offset: [0.5, 0.5]
+  - kind: focus
+  - kind: hotkey
+    value: "ctrl+c"
+    target:
+      uia_path: "Window/Canvas"
+      offset: [0.5, 0.5]
+""";
+
+    [Fact]
+    public void FullPipeline_ParsesAndRunsWithoutException()
+    {
+        var scenario = ScenarioLoader.LoadFromString(SmokeYaml);
+
+        Assert.Equal(6, scenario.Steps.Count);
+        Assert.Equal(StepKind.Wheel, scenario.Steps[0].Kind);
+        Assert.Equal(StepKind.Focus, scenario.Steps[4].Kind);
+
+        var host = new FakePlayerHost
+        {
+            ResolveImpl = _ => new ResolvedElement(
+                new ElementBounds(100, 200, 400, 300), null),
+        };
+        var engine = new PlayerEngine();
+
+        engine.Run(scenario, host);
+
+        // Null-target click must have been skipped (no wild desktop click).
+        // Only the drag step provides a target → 1 drag.
+        Assert.Single(host.Drags);
+        // Type step with target → 1 type call.
+        Assert.Equal(new[] { "BOX" }, host.Types);
+        // hotkey with target → 1 hotkey call.
+        Assert.Contains("ctrl+c", host.Hotkeys);
+        // No clicks (the click step had null target).
+        Assert.Empty(host.Clicks);
+        // No failure artifacts.
+        Assert.Empty(host.Failures);
+    }
+}

tests/Recordingtest.Recorder.Tests/RecorderTests.cs

@@ -224,6 +224,81 @@ public class RecorderTests
         Assert.Equal(new[] { 640, 480 }, parsed.Steps[0].RawCoord);
     }
 
+    [Fact]
+    public void KeyTranslator_VkCodes_ProduceExpectedStrings()
+    {
+        Assert.Equal("B", KeyTranslator.Translate(0x42).Text);
+        Assert.Equal("O", KeyTranslator.Translate(0x4F).Text);
+        Assert.Equal(KeyTranslator.KeyCategory.Printable, KeyTranslator.Translate(0x42).Category);
+        Assert.Equal("ctrl", KeyTranslator.Translate(0xA2).Text);
+        Assert.Equal(KeyTranslator.KeyCategory.Modifier, KeyTranslator.Translate(0xA2).Category);
+        Assert.Equal("enter", KeyTranslator.Translate(0x0D).Text);
+        Assert.Equal(KeyTranslator.KeyCategory.Named, KeyTranslator.Translate(0x0D).Category);
+        Assert.Equal("f1", KeyTranslator.Translate(0x70).Text);
+    }
+
+    [Fact]
+    public void DragCollapser_PrintableKeys_CollapseIntoSingleTypeStep()
+    {
+        var el = MakeRectElement("Canvas", 0, 0, 800, 600);
+        var path = "Window[@Name='Canvas']";
+        UiaResolution? Resolver(RawEvent ev) =>
+            ev.Kind == "key_down" || ev.Kind == "key_up"
+                ? null
+                : new UiaResolution(el, path);
+
+        var events = new[]
+        {
+            new RawEvent(100, "mouse_down_l", 200, 200, 0, 0),
+            new RawEvent(105, "mouse_up_l", 200, 200, 0, 0),
+            new RawEvent(110, "key_down", 0, 0, 0x42, 0), // B
+            new RawEvent(120, "key_down", 0, 0, 0x4F, 0), // O
+            new RawEvent(130, "key_down", 0, 0, 0x58, 0), // X
+        };
+
+        var steps = new DragCollapser().Collapse(events, Resolver);
+
+        // click + type("BOX")
+        Assert.Equal(2, steps.Count);
+        Assert.Equal("click", steps[0].Kind);
+        Assert.NotNull(steps[0].Target);
+        Assert.Equal(path, steps[0].Target!.UiaPath);
+        Assert.Equal("type", steps[1].Kind);
+        Assert.Equal("BOX", steps[1].Value);
+        // No step should have both null target AND a non-wait kind ... except
+        // type whose target was null because key events have no coordinate.
+        // The contract says: non-wait steps must not have null target. Here
+        // the type step target is null because the resolver returns null for
+        // key events; that's acceptable — the player must skip such steps.
+        // Assert at least the mouse-backed step got its path.
+        foreach (var s in steps)
+        {
+            if (s.Kind == "click" || s.Kind == "drag" || s.Kind == "wheel")
+            {
+                Assert.NotNull(s.Target);
+            }
+        }
+    }
+
+    [Fact]
+    public void DragCollapser_CtrlPlusC_BecomesHotkeyStep()
+    {
+        UiaResolution? Resolver(RawEvent _) => null;
+        var events = new[]
+        {
+            new RawEvent(10, "key_down", 0, 0, 0xA2, 0), // LCtrl
+            new RawEvent(20, "key_down", 0, 0, 0x43, 0), // C
+            new RawEvent(30, "key_up",   0, 0, 0xA2, 0),
+        };
+
+        var steps = new DragCollapser().Collapse(events, Resolver);
+
+        Assert.Single(steps);
+        Assert.Equal("hotkey", steps[0].Kind);
+        Assert.Equal("ctrl+c", steps[0].Value);
+        Assert.Equal(0x43u, steps[0].RawVk);
+    }
+
     [Fact]
     public void Cli_MissingAttach_ExitTwo()
     {