Disable 'vitest/prefer-called-exactly-once-with' for now

Author: paescuj

eslint.config.js

@@ -54,7 +54,14 @@ export default defineConfig(
     },
     {
         files: ['**/*.spec.ts'],
-        ...pluginVitest.configs.recommended,
+        plugins: {
+            vitest: pluginVitest,
+        },
+        rules: {
+            ...pluginVitest.configs.recommended.rules,
+            // Currently produces false positives, see https://github.com/vitest-dev/eslint-plugin-vitest/issues/775
+            'vitest/prefer-called-exactly-once-with': 'off',
+        },
     },
     pluginPrettierRecommended,
 );

src/command.spec.ts

@@ -100,8 +100,7 @@ describe('#start()', () => {
         const { command } = createCommand({}, { detached: true });
         command.start();
 
-        expect(spawn).toHaveBeenCalledTimes(1);
-        expect(spawn).toHaveBeenCalledWith(command.command, { detached: true });
+        expect(spawn).toHaveBeenCalledExactlyOnceWith(command.command, { detached: true });
     });
 
     it('sets stdin, process and PID', () => {
@@ -447,16 +446,14 @@ describe('#kill()', () => {
         createdCommand.command.start();
         createdCommand.command.kill();
 
-        expect(killProcess).toHaveBeenCalledTimes(1);
-        expect(killProcess).toHaveBeenCalledWith(createdCommand.command.pid, undefined);
+        expect(killProcess).toHaveBeenCalledExactlyOnceWith(createdCommand.command.pid, undefined);
     });
 
     it('kills process with some signal', () => {
         createdCommand.command.start();
         createdCommand.command.kill('SIGKILL');
 
-        expect(killProcess).toHaveBeenCalledTimes(1);
-        expect(killProcess).toHaveBeenCalledWith(createdCommand.command.pid, 'SIGKILL');
+        expect(killProcess).toHaveBeenCalledExactlyOnceWith(createdCommand.command.pid, 'SIGKILL');
     });
 
     it('does not try to kill inexistent process', () => {

src/flow-control/input-handler.spec.ts

@@ -48,8 +48,7 @@ it('forwards input stream to default target ID', () => {
 
     inputStream.write('something');
 
-    expect(commands[0].stdin?.write).toHaveBeenCalledTimes(1);
-    expect(commands[0].stdin?.write).toHaveBeenCalledWith('something');
+    expect(commands[0].stdin?.write).toHaveBeenCalledExactlyOnceWith('something');
     expect(commands[1].stdin?.write).not.toHaveBeenCalled();
 });
 
@@ -90,8 +89,7 @@ it('does not forward input stream when input contains colon in a different forma
     inputStream.emit('data', Buffer.from('{:ruby_key=>:my_val}'));
     inputStream.emit('data', Buffer.from('js_obj = {key: "my_val"}'));
 
-    expect(commands[1].stdin?.write).toHaveBeenCalledTimes(1);
-    expect(commands[1].stdin?.write).toHaveBeenCalledWith('Ruby1::Const::Syntax');
+    expect(commands[1].stdin?.write).toHaveBeenCalledExactlyOnceWith('Ruby1::Const::Syntax');
     expect(commands[0].stdin?.write).toHaveBeenCalledTimes(6);
     expect(commands[0].stdin?.write).toHaveBeenCalledWith('Ruby0::Const::Syntax');
     expect(commands[0].stdin?.write).toHaveBeenCalledWith('ruby_symbol_arg :my_symbol');
@@ -107,8 +105,7 @@ it('forwards input stream to target name specified in input', () => {
     inputStream.write('bar:something');
 
     expect(commands[0].stdin?.write).not.toHaveBeenCalled();
-    expect(commands[1].stdin?.write).toHaveBeenCalledTimes(1);
-    expect(commands[1].stdin?.write).toHaveBeenCalledWith('something');
+    expect(commands[1].stdin?.write).toHaveBeenCalledExactlyOnceWith('something');
 });
 
 it('logs error if command has no stdin open', () => {
@@ -128,8 +125,7 @@ it('fallback to default input stream if command is not found', () => {
 
     inputStream.write('foobar:something');
 
-    expect(commands[0].stdin?.write).toHaveBeenCalledTimes(1);
-    expect(commands[0].stdin?.write).toHaveBeenCalledWith('foobar:something');
+    expect(commands[0].stdin?.write).toHaveBeenCalledExactlyOnceWith('foobar:something');
     expect(commands[1].stdin?.write).not.toHaveBeenCalled();
     expect(logger.logGlobalEvent).not.toHaveBeenCalled();
 });

src/flow-control/kill-others.spec.ts

@@ -65,8 +65,9 @@ describe.each(['success', 'failure'] as const)('on %s', (condition) => {
         assignProcess(commands[1]);
         commands[0].close.next(createFakeCloseEvent({ exitCode }));
 
-        expect(logger.logGlobalEvent).toHaveBeenCalledTimes(1);
-        expect(logger.logGlobalEvent).toHaveBeenCalledWith('Sending SIGTERM to other processes..');
+        expect(logger.logGlobalEvent).toHaveBeenCalledExactlyOnceWith(
+            'Sending SIGTERM to other processes..',
+        );
         expect(commands[0].kill).not.toHaveBeenCalled();
         expect(commands[1].kill).toHaveBeenCalledWith(undefined);
     });
@@ -76,8 +77,9 @@ describe.each(['success', 'failure'] as const)('on %s', (condition) => {
         assignProcess(commands[1]);
         commands[0].close.next(createFakeCloseEvent({ exitCode }));
 
-        expect(logger.logGlobalEvent).toHaveBeenCalledTimes(1);
-        expect(logger.logGlobalEvent).toHaveBeenCalledWith('Sending SIGKILL to other processes..');
+        expect(logger.logGlobalEvent).toHaveBeenCalledExactlyOnceWith(
+            'Sending SIGKILL to other processes..',
+        );
         expect(commands[0].kill).not.toHaveBeenCalled();
         expect(commands[1].kill).toHaveBeenCalledWith('SIGKILL');
     });

src/flow-control/log-timings.spec.ts

@@ -123,11 +123,9 @@ it('logs the sorted timings summary when all processes close successfully after
 
     onFinish?.();
 
-    expect(logger.logGlobalEvent).toHaveBeenCalledTimes(1);
-    expect(logger.logGlobalEvent).toHaveBeenCalledWith('Timings:');
-    expect(logger.logTable).toHaveBeenCalledTimes(1);
+    expect(logger.logGlobalEvent).toHaveBeenCalledExactlyOnceWith('Timings:');
     // sorted by duration
-    expect(logger.logTable).toHaveBeenCalledWith([
+    expect(logger.logTable).toHaveBeenCalledExactlyOnceWith([
         LogTimings.mapCloseEventToTimingInfo(command1ExitInfo),
         LogTimings.mapCloseEventToTimingInfo(command0ExitInfo),
     ]);

src/flow-control/restart-process.spec.ts

@@ -45,8 +45,7 @@ it('restarts processes that fail immediately, if no delay was passed', () => {
     scheduler.flush();
 
     expect(scheduler.now()).toBe(0);
-    expect(logger.logCommandEvent).toHaveBeenCalledTimes(1);
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+    expect(logger.logCommandEvent).toHaveBeenCalledExactlyOnceWith(
         `${commands[0].command} restarted`,
         commands[0],
     );
@@ -62,8 +61,7 @@ it('restarts processes that fail after delay ms has passed', () => {
     scheduler.flush();
 
     expect(scheduler.now()).toBe(100);
-    expect(logger.logCommandEvent).toHaveBeenCalledTimes(1);
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+    expect(logger.logCommandEvent).toHaveBeenCalledExactlyOnceWith(
         `${commands[0].command} restarted`,
         commands[0],
     );
@@ -125,8 +123,7 @@ it('restarts processes until they succeed', () => {
 
     scheduler.flush();
 
-    expect(logger.logCommandEvent).toHaveBeenCalledTimes(1);
-    expect(logger.logCommandEvent).toHaveBeenCalledWith(
+    expect(logger.logCommandEvent).toHaveBeenCalledExactlyOnceWith(
         `${commands[0].command} restarted`,
         commands[0],
     );

src/output-writer.spec.ts

@@ -49,17 +49,15 @@ describe('#write()', () => {
         it('writes instantly', () => {
             const writer = createWriter({ group: false });
             writer.write(commands[2], 'hello');
-            expect(outputStream.write).toHaveBeenCalledTimes(1);
-            expect(outputStream.write).toHaveBeenCalledWith('hello');
+            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
         });
     });
 
     describe('with group=true', () => {
         it('writes for null commands', () => {
             const writer = createWriter({ group: true });
             writer.write(undefined, 'hello');
-            expect(outputStream.write).toHaveBeenCalledTimes(1);
-            expect(outputStream.write).toHaveBeenCalledWith('hello');
+            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
         });
 
         it('does not write instantly for non-active command', () => {
@@ -72,8 +70,7 @@ describe('#write()', () => {
         it('write instantly for active command', () => {
             const writer = createWriter({ group: true });
             writer.write(commands[0], 'hello');
-            expect(outputStream.write).toHaveBeenCalledTimes(1);
-            expect(outputStream.write).toHaveBeenCalledWith('hello');
+            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
         });
 
         it('does not wait for write from next command to flush', () => {
@@ -108,8 +105,7 @@ describe('#write()', () => {
             closeCommand(commands[2]);
             expect(outputStream.write).toHaveBeenCalledTimes(0);
             closeCommand(commands[0]);
-            expect(outputStream.write).toHaveBeenCalledTimes(1);
-            expect(outputStream.write).toHaveBeenCalledWith('hello');
+            expect(outputStream.write).toHaveBeenCalledExactlyOnceWith('hello');
             expect(writer.activeCommandIndex).toBe(2);
         });
     });