@player-devtools/client-flipper 0.15.2-next.0 → 0.16.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cjs/index.cjs +147 -5
- package/dist/cjs/index.cjs.map +1 -1
- package/dist/index.legacy-esm.js +147 -5
- package/dist/index.mjs +147 -5
- package/dist/index.mjs.map +1 -1
- package/package.json +2 -2
- package/src/__tests__/transport.test.ts +429 -5
- package/src/transport.ts +207 -7
- package/types/transport.d.ts +54 -0
|
@@ -1,5 +1,9 @@
|
|
|
1
1
|
import { describe, it, expect, vi } from "vitest";
|
|
2
|
+
import * as fs from "fs";
|
|
3
|
+
import * as os from "os";
|
|
4
|
+
import * as path from "path";
|
|
2
5
|
import type { FlipperServer } from "flipper-server-client";
|
|
6
|
+
|
|
3
7
|
import { FlipperServerTransport } from "../transport";
|
|
4
8
|
|
|
5
9
|
const INSTALLED = {
|
|
@@ -25,6 +29,22 @@ function fakeFlipperServer(
|
|
|
25
29
|
return { exec } as unknown as FlipperServer;
|
|
26
30
|
}
|
|
27
31
|
|
|
32
|
+
/** Access private fields for seeding — avoids real sockets/child processes
|
|
33
|
+
* while exercising the connection-state and plugin-activation surfaces. */
|
|
34
|
+
type TransportInternals = {
|
|
35
|
+
server: unknown;
|
|
36
|
+
refcount: { peek: () => { pid: number; refs: number } | null };
|
|
37
|
+
owns: boolean;
|
|
38
|
+
host: string;
|
|
39
|
+
port: number;
|
|
40
|
+
connectedClientIds: Set<string>;
|
|
41
|
+
activeClientIds: Set<string>;
|
|
42
|
+
};
|
|
43
|
+
|
|
44
|
+
function internals(transport: FlipperServerTransport): TransportInternals {
|
|
45
|
+
return transport as unknown as TransportInternals;
|
|
46
|
+
}
|
|
47
|
+
|
|
28
48
|
/** Reaches into the transport's private fields to set up state without going through `connect()`. */
|
|
29
49
|
function attach(
|
|
30
50
|
transport: FlipperServerTransport,
|
|
@@ -37,16 +57,25 @@ function attach(
|
|
|
37
57
|
activeClientIds?: Array<string>;
|
|
38
58
|
} = {},
|
|
39
59
|
): void {
|
|
40
|
-
const t = transport
|
|
41
|
-
server: FlipperServer;
|
|
42
|
-
connectedClientIds: Set<string>;
|
|
43
|
-
activeClientIds: Set<string>;
|
|
44
|
-
};
|
|
60
|
+
const t = internals(transport);
|
|
45
61
|
t.server = server;
|
|
46
62
|
t.connectedClientIds = new Set(connectedClientIds);
|
|
47
63
|
t.activeClientIds = new Set(activeClientIds);
|
|
48
64
|
}
|
|
49
65
|
|
|
66
|
+
/**
|
|
67
|
+
* A transport whose refcount is stubbed to `null` so tests don't depend on
|
|
68
|
+
* (or race) a real `flipper-server.refcount` file possibly left on disk by
|
|
69
|
+
* other processes on the machine running the test.
|
|
70
|
+
*/
|
|
71
|
+
function makeIsolatedTransport(
|
|
72
|
+
options?: ConstructorParameters<typeof FlipperServerTransport>[0],
|
|
73
|
+
): FlipperServerTransport {
|
|
74
|
+
const transport = new FlipperServerTransport(options);
|
|
75
|
+
internals(transport).refcount = { peek: () => null };
|
|
76
|
+
return transport;
|
|
77
|
+
}
|
|
78
|
+
|
|
50
79
|
describe("FlipperServerTransport", () => {
|
|
51
80
|
describe("ensurePluginInstalled", () => {
|
|
52
81
|
it("returns the existing plugin without installing when already present", async () => {
|
|
@@ -263,4 +292,399 @@ describe("FlipperServerTransport", () => {
|
|
|
263
292
|
await expect(transport.disablePlugin()).rejects.toThrow("not connected");
|
|
264
293
|
});
|
|
265
294
|
});
|
|
295
|
+
|
|
296
|
+
describe("getDiagnostics", () => {
|
|
297
|
+
it("reports disconnected defaults before connect() is called", () => {
|
|
298
|
+
const transport = makeIsolatedTransport();
|
|
299
|
+
expect(transport.getDiagnostics()).toEqual({
|
|
300
|
+
connected: false,
|
|
301
|
+
host: "localhost",
|
|
302
|
+
port: 52342,
|
|
303
|
+
owns: false,
|
|
304
|
+
refs: null,
|
|
305
|
+
activeClientIds: [],
|
|
306
|
+
connectedClientIds: [],
|
|
307
|
+
});
|
|
308
|
+
});
|
|
309
|
+
|
|
310
|
+
it("reflects custom host/port options even before connecting", () => {
|
|
311
|
+
const transport = makeIsolatedTransport({
|
|
312
|
+
host: "127.0.0.1",
|
|
313
|
+
port: 9999,
|
|
314
|
+
});
|
|
315
|
+
// host/port are resolved from options at construction time, so they're
|
|
316
|
+
// already correct before connect() has ever run.
|
|
317
|
+
expect(transport.getDiagnostics()).toMatchObject({
|
|
318
|
+
host: "127.0.0.1",
|
|
319
|
+
port: 9999,
|
|
320
|
+
});
|
|
321
|
+
});
|
|
322
|
+
|
|
323
|
+
it("reports connected + owns + refs + activeClientIds + connectedClientIds once seeded", () => {
|
|
324
|
+
const transport = makeIsolatedTransport();
|
|
325
|
+
const state = internals(transport);
|
|
326
|
+
state.server = {};
|
|
327
|
+
state.owns = true;
|
|
328
|
+
state.activeClientIds = new Set(["a", "b"]);
|
|
329
|
+
state.connectedClientIds = new Set(["a", "b", "c"]);
|
|
330
|
+
state.refcount = { peek: () => ({ pid: 123, refs: 1 }) };
|
|
331
|
+
|
|
332
|
+
expect(transport.getDiagnostics()).toEqual({
|
|
333
|
+
connected: true,
|
|
334
|
+
host: "localhost",
|
|
335
|
+
port: 52342,
|
|
336
|
+
owns: true,
|
|
337
|
+
refs: 1,
|
|
338
|
+
activeClientIds: ["a", "b"],
|
|
339
|
+
connectedClientIds: ["a", "b", "c"],
|
|
340
|
+
});
|
|
341
|
+
});
|
|
342
|
+
});
|
|
343
|
+
|
|
344
|
+
describe("FlipperRefcount.peek (via getDiagnostics)", () => {
|
|
345
|
+
it("does not mutate the refcount file", () => {
|
|
346
|
+
const dir = path.join(os.tmpdir(), "player-devtools-mcp");
|
|
347
|
+
const file = path.join(dir, "flipper-server.refcount");
|
|
348
|
+
fs.mkdirSync(dir, { recursive: true });
|
|
349
|
+
fs.writeFileSync(file, JSON.stringify({ pid: process.pid, refs: 4 }));
|
|
350
|
+
|
|
351
|
+
try {
|
|
352
|
+
const transport = new FlipperServerTransport();
|
|
353
|
+
const before = fs.readFileSync(file, "utf8");
|
|
354
|
+
const { refs } = transport.getDiagnostics();
|
|
355
|
+
const after = fs.readFileSync(file, "utf8");
|
|
356
|
+
|
|
357
|
+
expect(refs).toBe(4);
|
|
358
|
+
expect(after).toBe(before);
|
|
359
|
+
} finally {
|
|
360
|
+
fs.rmSync(file, { force: true });
|
|
361
|
+
}
|
|
362
|
+
});
|
|
363
|
+
});
|
|
364
|
+
|
|
365
|
+
describe("restart", () => {
|
|
366
|
+
it("soft-errors without touching the daemon when this instance does not own it", async () => {
|
|
367
|
+
const transport = new FlipperServerTransport();
|
|
368
|
+
const close = vi.spyOn(transport, "close");
|
|
369
|
+
const connect = vi.spyOn(transport, "connect");
|
|
370
|
+
|
|
371
|
+
const result = await transport.restart();
|
|
372
|
+
|
|
373
|
+
expect(result).toEqual({
|
|
374
|
+
ok: false,
|
|
375
|
+
reason: "this instance does not own the flipper-server daemon",
|
|
376
|
+
});
|
|
377
|
+
expect(close).not.toHaveBeenCalled();
|
|
378
|
+
expect(connect).not.toHaveBeenCalled();
|
|
379
|
+
});
|
|
380
|
+
|
|
381
|
+
it("soft-errors without touching the daemon when other consumers are attached", async () => {
|
|
382
|
+
const transport = new FlipperServerTransport();
|
|
383
|
+
const state = internals(transport);
|
|
384
|
+
state.owns = true;
|
|
385
|
+
state.refcount = { peek: () => ({ pid: 1, refs: 3 }) };
|
|
386
|
+
|
|
387
|
+
const close = vi.spyOn(transport, "close");
|
|
388
|
+
const connect = vi.spyOn(transport, "connect");
|
|
389
|
+
|
|
390
|
+
const result = await transport.restart();
|
|
391
|
+
|
|
392
|
+
expect(result).toEqual({
|
|
393
|
+
ok: false,
|
|
394
|
+
reason: "other consumers are attached to this daemon",
|
|
395
|
+
});
|
|
396
|
+
expect(close).not.toHaveBeenCalled();
|
|
397
|
+
expect(connect).not.toHaveBeenCalled();
|
|
398
|
+
});
|
|
399
|
+
|
|
400
|
+
it("closes and reconnects when this instance is the sole owner", async () => {
|
|
401
|
+
const transport = new FlipperServerTransport();
|
|
402
|
+
const state = internals(transport);
|
|
403
|
+
state.owns = true;
|
|
404
|
+
state.refcount = { peek: () => ({ pid: 1, refs: 1 }) };
|
|
405
|
+
|
|
406
|
+
const close = vi.spyOn(transport, "close").mockResolvedValue(undefined);
|
|
407
|
+
const connect = vi
|
|
408
|
+
.spyOn(transport, "connect")
|
|
409
|
+
.mockResolvedValue(undefined);
|
|
410
|
+
|
|
411
|
+
const result = await transport.restart();
|
|
412
|
+
|
|
413
|
+
expect(close).toHaveBeenCalledOnce();
|
|
414
|
+
expect(connect).toHaveBeenCalledOnce();
|
|
415
|
+
expect(result).toEqual({ ok: true, host: "localhost", port: 52342 });
|
|
416
|
+
});
|
|
417
|
+
|
|
418
|
+
it("aborts with a soft error when refs change between the initial check and the pre-kill re-check", async () => {
|
|
419
|
+
const transport = new FlipperServerTransport();
|
|
420
|
+
const state = internals(transport);
|
|
421
|
+
state.owns = true;
|
|
422
|
+
let calls = 0;
|
|
423
|
+
state.refcount = {
|
|
424
|
+
peek: () => {
|
|
425
|
+
calls += 1;
|
|
426
|
+
// First peek (in the initial guard) sees refs=1; the re-check
|
|
427
|
+
// immediately before close() sees a consumer that just attached.
|
|
428
|
+
return calls === 1 ? { pid: 1, refs: 1 } : { pid: 1, refs: 2 };
|
|
429
|
+
},
|
|
430
|
+
};
|
|
431
|
+
|
|
432
|
+
const close = vi.spyOn(transport, "close");
|
|
433
|
+
const connect = vi.spyOn(transport, "connect");
|
|
434
|
+
|
|
435
|
+
const result = await transport.restart();
|
|
436
|
+
|
|
437
|
+
expect(result).toEqual({
|
|
438
|
+
ok: false,
|
|
439
|
+
reason: "other consumers attached to this daemon just before restart",
|
|
440
|
+
});
|
|
441
|
+
expect(close).not.toHaveBeenCalled();
|
|
442
|
+
expect(connect).not.toHaveBeenCalled();
|
|
443
|
+
});
|
|
444
|
+
|
|
445
|
+
it("returns a soft error and resets owns to false when connect() fails after close() succeeds", async () => {
|
|
446
|
+
const transport = new FlipperServerTransport();
|
|
447
|
+
const state = internals(transport);
|
|
448
|
+
state.owns = true;
|
|
449
|
+
state.refcount = { peek: () => ({ pid: 1, refs: 1 }) };
|
|
450
|
+
|
|
451
|
+
const close = vi.spyOn(transport, "close").mockResolvedValue(undefined);
|
|
452
|
+
const connect = vi
|
|
453
|
+
.spyOn(transport, "connect")
|
|
454
|
+
.mockRejectedValue(new Error("Timed out waiting for localhost:52342"));
|
|
455
|
+
|
|
456
|
+
const result = await transport.restart();
|
|
457
|
+
|
|
458
|
+
expect(close).toHaveBeenCalledOnce();
|
|
459
|
+
expect(connect).toHaveBeenCalledOnce();
|
|
460
|
+
expect(result).toEqual({
|
|
461
|
+
ok: false,
|
|
462
|
+
reason: "Timed out waiting for localhost:52342",
|
|
463
|
+
});
|
|
464
|
+
expect(internals(transport).owns).toBe(false);
|
|
465
|
+
});
|
|
466
|
+
});
|
|
467
|
+
|
|
468
|
+
describe("getPluginInstallStatus", () => {
|
|
469
|
+
it("returns not-installed when the server is not connected", async () => {
|
|
470
|
+
const transport = new FlipperServerTransport();
|
|
471
|
+
await expect(transport.getPluginInstallStatus()).resolves.toEqual({
|
|
472
|
+
installed: false,
|
|
473
|
+
reason: "not connected",
|
|
474
|
+
});
|
|
475
|
+
});
|
|
476
|
+
|
|
477
|
+
it("returns not-installed when the daemon has no matching plugin", async () => {
|
|
478
|
+
const transport = new FlipperServerTransport();
|
|
479
|
+
internals(transport).server = {
|
|
480
|
+
exec: vi.fn().mockResolvedValue([{ id: "some-other-plugin" }]),
|
|
481
|
+
};
|
|
482
|
+
|
|
483
|
+
await expect(transport.getPluginInstallStatus()).resolves.toEqual({
|
|
484
|
+
installed: false,
|
|
485
|
+
});
|
|
486
|
+
});
|
|
487
|
+
|
|
488
|
+
it("matches by id and reports the version when present", async () => {
|
|
489
|
+
const transport = new FlipperServerTransport();
|
|
490
|
+
internals(transport).server = {
|
|
491
|
+
exec: vi
|
|
492
|
+
.fn()
|
|
493
|
+
.mockResolvedValue([{ id: "player-ui-devtools", version: "1.2.3" }]),
|
|
494
|
+
};
|
|
495
|
+
|
|
496
|
+
await expect(transport.getPluginInstallStatus()).resolves.toEqual({
|
|
497
|
+
installed: true,
|
|
498
|
+
version: "1.2.3",
|
|
499
|
+
});
|
|
500
|
+
});
|
|
501
|
+
|
|
502
|
+
it("matches by name when id is absent, without a version", async () => {
|
|
503
|
+
const transport = new FlipperServerTransport();
|
|
504
|
+
internals(transport).server = {
|
|
505
|
+
exec: vi.fn().mockResolvedValue([{ name: "player-ui-devtools" }]),
|
|
506
|
+
};
|
|
507
|
+
|
|
508
|
+
await expect(transport.getPluginInstallStatus()).resolves.toEqual({
|
|
509
|
+
installed: true,
|
|
510
|
+
});
|
|
511
|
+
});
|
|
512
|
+
|
|
513
|
+
it("resolves with a failure reason instead of throwing when exec() rejects", async () => {
|
|
514
|
+
const transport = new FlipperServerTransport();
|
|
515
|
+
internals(transport).server = {
|
|
516
|
+
exec: vi.fn().mockRejectedValue(new Error("daemon dropped")),
|
|
517
|
+
};
|
|
518
|
+
|
|
519
|
+
await expect(transport.getPluginInstallStatus()).resolves.toEqual({
|
|
520
|
+
installed: false,
|
|
521
|
+
reason: "daemon dropped",
|
|
522
|
+
});
|
|
523
|
+
});
|
|
524
|
+
|
|
525
|
+
it("returns the soft-error shape instead of throwing when exec() resolves with a malformed non-array value", async () => {
|
|
526
|
+
const transport = new FlipperServerTransport();
|
|
527
|
+
internals(transport).server = {
|
|
528
|
+
// Simulates a version-mismatched daemon response: exec() resolves
|
|
529
|
+
// (doesn't reject) with something that isn't an array, so `.find()`
|
|
530
|
+
// would throw a TypeError if called outside the try/catch.
|
|
531
|
+
exec: vi.fn().mockResolvedValue({ unexpected: "shape" }),
|
|
532
|
+
};
|
|
533
|
+
|
|
534
|
+
await expect(transport.getPluginInstallStatus()).resolves.toEqual({
|
|
535
|
+
installed: false,
|
|
536
|
+
reason: "plugins.find is not a function",
|
|
537
|
+
});
|
|
538
|
+
});
|
|
539
|
+
});
|
|
540
|
+
|
|
541
|
+
describe("close", () => {
|
|
542
|
+
it("waits for the killed daemon process to actually exit before resolving", async () => {
|
|
543
|
+
vi.useFakeTimers();
|
|
544
|
+
try {
|
|
545
|
+
const transport = new FlipperServerTransport();
|
|
546
|
+
const state = internals(transport);
|
|
547
|
+
state.refcount = {
|
|
548
|
+
peek: () => null,
|
|
549
|
+
} as unknown as TransportInternals["refcount"];
|
|
550
|
+
(
|
|
551
|
+
transport as unknown as {
|
|
552
|
+
refcount: { release: () => number | null };
|
|
553
|
+
}
|
|
554
|
+
).refcount.release = () => 4242;
|
|
555
|
+
|
|
556
|
+
let alive = true;
|
|
557
|
+
const killSpy = vi.spyOn(process, "kill").mockImplementation(((
|
|
558
|
+
pid: number,
|
|
559
|
+
signal?: string | number,
|
|
560
|
+
) => {
|
|
561
|
+
if (signal === 0) {
|
|
562
|
+
if (!alive) throw new Error("ESRCH");
|
|
563
|
+
return true;
|
|
564
|
+
}
|
|
565
|
+
return true;
|
|
566
|
+
}) as typeof process.kill);
|
|
567
|
+
|
|
568
|
+
const closePromise = transport.close();
|
|
569
|
+
let resolved = false;
|
|
570
|
+
void closePromise.then(() => {
|
|
571
|
+
resolved = true;
|
|
572
|
+
});
|
|
573
|
+
|
|
574
|
+
// Still "alive" — close() must not have resolved yet.
|
|
575
|
+
await vi.advanceTimersByTimeAsync(300);
|
|
576
|
+
expect(resolved).toBe(false);
|
|
577
|
+
|
|
578
|
+
// Now the process exits; the next poll should observe it and resolve.
|
|
579
|
+
alive = false;
|
|
580
|
+
await vi.advanceTimersByTimeAsync(200);
|
|
581
|
+
await closePromise;
|
|
582
|
+
expect(resolved).toBe(true);
|
|
583
|
+
|
|
584
|
+
killSpy.mockRestore();
|
|
585
|
+
} finally {
|
|
586
|
+
vi.useRealTimers();
|
|
587
|
+
}
|
|
588
|
+
});
|
|
589
|
+
|
|
590
|
+
it("is idempotent: a second concurrent close() does not re-run teardown", async () => {
|
|
591
|
+
const transport = new FlipperServerTransport();
|
|
592
|
+
|
|
593
|
+
let releaseCalls = 0;
|
|
594
|
+
(
|
|
595
|
+
transport as unknown as {
|
|
596
|
+
refcount: { release: () => number | null };
|
|
597
|
+
}
|
|
598
|
+
).refcount = {
|
|
599
|
+
peek: () => null,
|
|
600
|
+
release: () => {
|
|
601
|
+
releaseCalls += 1;
|
|
602
|
+
return null;
|
|
603
|
+
},
|
|
604
|
+
} as unknown as TransportInternals["refcount"];
|
|
605
|
+
|
|
606
|
+
const first = transport.close();
|
|
607
|
+
const second = transport.close();
|
|
608
|
+
|
|
609
|
+
await Promise.all([first, second]);
|
|
610
|
+
|
|
611
|
+
expect(releaseCalls).toBe(1);
|
|
612
|
+
});
|
|
613
|
+
});
|
|
614
|
+
|
|
615
|
+
describe("connect", () => {
|
|
616
|
+
it("kills the spawned child and waits for it to exit when waitForPort fails after spawn", async () => {
|
|
617
|
+
// Exercises connect()'s `shouldStart` spawn path: the real flipper-server
|
|
618
|
+
// child is spawned, but nothing is listening on the target port, so
|
|
619
|
+
// waitForPort() times out. Nothing has committed this child's PID to
|
|
620
|
+
// the refcount file yet, so connect() must kill it itself (via the same
|
|
621
|
+
// killAndWait() used elsewhere in this file) or it orphans.
|
|
622
|
+
//
|
|
623
|
+
// Under this workspace's vitest environment (happy-dom), `vi.mock`
|
|
624
|
+
// cannot reliably intercept Node builtin modules (`child_process`,
|
|
625
|
+
// `net`) for code paths already resolved outside the test file's own
|
|
626
|
+
// module graph, so this spies on the module-level `process.kill`
|
|
627
|
+
// instead — the real spawn() runs, but against a port nothing listens
|
|
628
|
+
// on, and fake timers fast-forward both waitForPort's 30s polling loop
|
|
629
|
+
// and killAndWait's exit-confirmation poll.
|
|
630
|
+
let alive = true;
|
|
631
|
+
const processKillSpy = vi.spyOn(process, "kill").mockImplementation(((
|
|
632
|
+
pid: number,
|
|
633
|
+
signal?: string | number,
|
|
634
|
+
) => {
|
|
635
|
+
if (signal === 0) {
|
|
636
|
+
if (!alive) throw new Error("ESRCH");
|
|
637
|
+
return true;
|
|
638
|
+
}
|
|
639
|
+
// The SIGTERM sent by killAndWait().
|
|
640
|
+
alive = false;
|
|
641
|
+
return true;
|
|
642
|
+
}) as typeof process.kill);
|
|
643
|
+
|
|
644
|
+
vi.useFakeTimers();
|
|
645
|
+
try {
|
|
646
|
+
const transport = new FlipperServerTransport({
|
|
647
|
+
host: "127.0.0.1",
|
|
648
|
+
// Reserved/unused port: nothing should ever be listening here in CI
|
|
649
|
+
// or locally, so real net.connect attempts genuinely fail fast.
|
|
650
|
+
port: 1,
|
|
651
|
+
});
|
|
652
|
+
const state = internals(transport);
|
|
653
|
+
state.refcount = {
|
|
654
|
+
peek: () => null,
|
|
655
|
+
} as unknown as TransportInternals["refcount"];
|
|
656
|
+
(
|
|
657
|
+
transport as unknown as {
|
|
658
|
+
refcount: {
|
|
659
|
+
acquire: () => {
|
|
660
|
+
shouldStart: boolean;
|
|
661
|
+
commit: (pid: number) => void;
|
|
662
|
+
};
|
|
663
|
+
};
|
|
664
|
+
}
|
|
665
|
+
).refcount.acquire = () => ({
|
|
666
|
+
shouldStart: true,
|
|
667
|
+
commit: vi.fn(),
|
|
668
|
+
});
|
|
669
|
+
|
|
670
|
+
const connectPromise = transport.connect().catch((err) => err as Error);
|
|
671
|
+
|
|
672
|
+
// Advance past waitForPort's internal 30s timeout so it rejects, then
|
|
673
|
+
// past killAndWait's poll interval so it observes the SIGTERM'd
|
|
674
|
+
// child's exit before connect() rethrows.
|
|
675
|
+
await vi.advanceTimersByTimeAsync(31_200);
|
|
676
|
+
|
|
677
|
+
const result = await connectPromise;
|
|
678
|
+
|
|
679
|
+
expect(result).toBeInstanceOf(Error);
|
|
680
|
+
// The SIGTERM from killAndWait().
|
|
681
|
+
expect(processKillSpy).toHaveBeenCalledWith(expect.any(Number));
|
|
682
|
+
// The liveness poll from killAndWait()'s isPidAlive().
|
|
683
|
+
expect(processKillSpy).toHaveBeenCalledWith(expect.any(Number), 0);
|
|
684
|
+
} finally {
|
|
685
|
+
vi.useRealTimers();
|
|
686
|
+
processKillSpy.mockRestore();
|
|
687
|
+
}
|
|
688
|
+
});
|
|
689
|
+
});
|
|
266
690
|
});
|