test: tighten backup command assertions

steipete · steipete · commit d9fe18c57445 · 2026-05-11T07:48:50.000+01:00
diff --git a/src/cli/program/register.backup.test.ts b/src/cli/program/register.backup.test.ts
@@ -41,64 +41,54 @@ describe("registerBackupCommand", () => {
     backupVerifyCommand.mockResolvedValue(undefined);
   });
 
+  function expectForwardedOptions(command: typeof backupCreateCommand): Record<string, unknown> {
+    expect(command).toHaveBeenCalledTimes(1);
+    const [runtimeArg, options] = command.mock.calls[0] as unknown as [
+      typeof runtime,
+      Record<string, unknown>,
+    ];
+    expect(runtimeArg).toBe(runtime);
+    return options;
+  }
+
   it("runs backup create with forwarded options", async () => {
     await runCli(["backup", "create", "--output", "/tmp/backups", "--json", "--dry-run"]);
 
-    expect(backupCreateCommand).toHaveBeenCalledWith(
-      runtime,
-      expect.objectContaining({
-        output: "/tmp/backups",
-        json: true,
-        dryRun: true,
-        verify: false,
-        onlyConfig: false,
-        includeWorkspace: true,
-      }),
-    );
+    const options = expectForwardedOptions(backupCreateCommand);
+    expect(options.output).toBe("/tmp/backups");
+    expect(options.json).toBe(true);
+    expect(options.dryRun).toBe(true);
+    expect(options.verify).toBe(false);
+    expect(options.onlyConfig).toBe(false);
+    expect(options.includeWorkspace).toBe(true);
   });
 
   it("honors --no-include-workspace", async () => {
     await runCli(["backup", "create", "--no-include-workspace"]);
 
-    expect(backupCreateCommand).toHaveBeenCalledWith(
-      runtime,
-      expect.objectContaining({
-        includeWorkspace: false,
-      }),
-    );
+    const options = expectForwardedOptions(backupCreateCommand);
+    expect(options.includeWorkspace).toBe(false);
   });
 
   it("forwards --verify to backup create", async () => {
     await runCli(["backup", "create", "--verify"]);
 
-    expect(backupCreateCommand).toHaveBeenCalledWith(
-      runtime,
-      expect.objectContaining({
-        verify: true,
-      }),
-    );
+    const options = expectForwardedOptions(backupCreateCommand);
+    expect(options.verify).toBe(true);
   });
 
   it("forwards --only-config to backup create", async () => {
     await runCli(["backup", "create", "--only-config"]);
 
-    expect(backupCreateCommand).toHaveBeenCalledWith(
-      runtime,
-      expect.objectContaining({
-        onlyConfig: true,
-      }),
-    );
+    const options = expectForwardedOptions(backupCreateCommand);
+    expect(options.onlyConfig).toBe(true);
   });
 
   it("runs backup verify with forwarded options", async () => {
     await runCli(["backup", "verify", "/tmp/openclaw-backup.tar.gz", "--json"]);
 
-    expect(backupVerifyCommand).toHaveBeenCalledWith(
-      runtime,
-      expect.objectContaining({
-        archive: "/tmp/openclaw-backup.tar.gz",
-        json: true,
-      }),
-    );
+    const options = expectForwardedOptions(backupVerifyCommand);
+    expect(options.archive).toBe("/tmp/openclaw-backup.tar.gz");
+    expect(options.json).toBe(true);
   });
 });
