make TaskKeyConverter public; update wiki docs for object keys and testing

- TaskKeyConverter.ToKey is now public so consumers can resolve keys in tests
- wiki/Testing.md: fix manual mock examples (string -> object), add TaskKeyConverter.ToKey section for store-level assertions, add object key example
- wiki/Migrating-to-v2.md: note TaskKeyConverter.ToKey is public

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: chunty

TaskKeyConverter.cs

@@ -5,13 +5,23 @@
 namespace TaskTurnstile;
 
 /// <summary>
-/// Converts an <see cref="object"/> task key to the string used by the backing store.
-/// Strings are used as-is. All other types are serialized to JSON and hashed with SHA-256,
-/// prefixed with the type name so keys are identifiable in the database.
+/// Converts an <see cref="object"/> task key to the string stored in the backing store.
 /// </summary>
-internal static class TaskKeyConverter
+/// <remarks>
+/// Conversion rules:
+/// <list type="bullet">
+///   <item><description><see langword="string"/> — used as-is.</description></item>
+///   <item><description>Primitives, enums, <see cref="Guid"/>, <see cref="decimal"/>, <see cref="DateTime"/>, <see cref="DateOnly"/>, <see cref="TimeOnly"/>, <see cref="DateTimeOffset"/> — <c>{TypeFullName}:{value}</c>, e.g. <c>System.Int32:42</c>.</description></item>
+///   <item><description>All other types — JSON-serialised, SHA-256 hashed: <c>{TypeFullName}:{hex}</c>.</description></item>
+/// </list>
+/// Use this in tests to compute the expected store key when asserting against <see cref="ITaskStateStore"/>.
+/// </remarks>
+public static class TaskKeyConverter
 {
-    internal static string ToKey(object key)
+    /// <summary>
+    /// Converts <paramref name="key"/> to the string used by the backing store.
+    /// </summary>
+    public static string ToKey(object key)
     {
         if (key is string s) return s;
         var type = key.GetType();

wiki/Migrating-to-v2.md

@@ -52,3 +52,4 @@ If you were calling these extension methods they will need updating to call the
 
 - **Object task keys** — pass any type as a task key. Strings are unchanged; primitives, enums, `Guid`, `DateTime`, and other value types use `ToString()` prefixed with the type name; complex objects are JSON-serialised and SHA-256 hashed.
 - Keys are always human-readable in the database (type name prefix makes them identifiable).
+- **`TaskKeyConverter.ToKey(object key)`** is public — use it in tests to resolve the expected store key when asserting against `ITaskStateStore`.

wiki/Testing.md

@@ -50,10 +50,13 @@ manager.SetupTryRunAsyncToSkip<int>();
 Pass `taskKey` to make the setup match only that key. Any other key falls through to the Moq / NSubstitute default. This is useful when the thing you're testing is *which* key gets passed:
 
 ```csharp
-// Moq
+// Moq — string key
 Mocker.GetMock<ITaskStateManager>().SetupTryRunAsync(returns: true, taskKey: "import-job");
 
-// Verify the correct name was used
+// Moq — object key
+Mocker.GetMock<ITaskStateManager>().SetupTryRunAsync(returns: true, taskKey: new JobKey { TenantId = 42 });
+
+// Verify the correct key was used
 Mocker.GetMock<ITaskStateManager>()
     .Verify(m => m.TryRunAsync(
         "import-job",
@@ -73,6 +76,26 @@ await manager.Received(1).TryRunAsync(
     Arg.Any<CancellationToken>());
 ```
 
+### Resolving object keys in store-level assertions
+
+When asserting on `ITaskStateStore` calls directly (e.g., in custom store tests), you need the resolved string key. Use `TaskKeyConverter.ToKey` to compute it:
+
+```csharp
+using TaskTurnstile;
+
+var key = new JobKey { TenantId = 42 };
+var storeKey = TaskKeyConverter.ToKey(key); // e.g. "MyApp.JobKey:a3f9..."
+
+storeMock.Verify(s => s.SetRunningAsync(storeKey, It.IsAny<TimeSpan?>(), It.IsAny<CancellationToken>()));
+```
+
+For string and primitive keys:
+
+```csharp
+TaskKeyConverter.ToKey("import-job")  // → "import-job"
+TaskKeyConverter.ToKey(42)            // → "System.Int32:42"
+```
+
 ---
 
 ## Manual mocking (without TaskTurnstile.Testing)
@@ -84,11 +107,11 @@ If you prefer to wire up your mocking framework directly without the helper exte
 ```csharp
 Mocker.GetMock<ITaskStateManager>()
     .Setup(m => m.TryRunAsync(
-        It.IsAny<string>(),
+        It.IsAny<object>(),
         It.IsAny<Func<CancellationToken, Task>>(),
         It.IsAny<TimeSpan?>(),
         It.IsAny<CancellationToken>()))
-    .Returns<string, Func<CancellationToken, Task>, TimeSpan?, CancellationToken>(
+    .Returns<object, Func<CancellationToken, Task>, TimeSpan?, CancellationToken>(
         async (_, work, _, ct) => { await work(ct); return true; });
 ```
 
@@ -97,7 +120,7 @@ Mocker.GetMock<ITaskStateManager>()
 ```csharp
 Mocker.GetMock<ITaskStateManager>()
     .Setup(m => m.TryRunAsync(
-        It.IsAny<string>(),
+        It.IsAny<object>(),
         It.IsAny<Func<CancellationToken, Task>>(),
         It.IsAny<TimeSpan?>(),
         It.IsAny<CancellationToken>()))
@@ -108,7 +131,7 @@ Mocker.GetMock<ITaskStateManager>()
 
 ```csharp
 manager.TryRunAsync(
-        Arg.Any<string>(),
+        Arg.Any<object>(),
         Arg.Any<Func<CancellationToken, Task>>(),
         Arg.Any<TimeSpan?>(),
         Arg.Any<CancellationToken>())