8461174746

Committed 28 Mar 2024 01:41AM UTC coverage: 97.947% (-0.06%) from 98.005%

Build # 8461174746

Build Type

Pull #1132

github

Committed by

web-flow

Commit Message

Merge cf5b44b07 into ea3816c4c

Pull Request Pull Request #1132: fix "Jest: Run All Test" command blocked by watch mode run

Run Details

2171 of 2290 branches covered (94.8%)

Branch coverage included in aggregate %.

18 of 20 new or added lines in 3 files covered. (90.0%)

1 existing line in 1 file now uncovered.

3937 of 3946 relevant lines covered (99.77%)

49.44 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.29

/src/JestExt/process-session.ts

import {
  JestProcessManager,
  JestProcessRequest,
  JestProcessRequestBase,
  ScheduleStrategy,
  requestString,
  JestProcessInfo,
  JestProcessRequestTransform,
  UserDataType,
} from '../JestProcessManagement';
import { JestTestProcessType } from '../Settings';
import { RunTestListener, ListTestFileListener } from './process-listeners';
import { JestExtProcessContext } from './types';

type InternalProcessType = 'list-test-files';
export type ListTestFilesCallback = (
  fileNames?: string[],
  error?: string,
  exitCode?: number
) => void;
export type InternalRequestBase = {
  type: Extract<InternalProcessType, 'list-test-files'>;
  onResult: ListTestFilesCallback;
};

export type JestExtRequestType = JestProcessRequestBase | InternalRequestBase;
const isJestProcessRequestBase = (request: JestExtRequestType): request is JestProcessRequestBase =>
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  typeof (request as any).transform === 'function';
const getTransform = (request: JestExtRequestType): JestProcessRequestTransform | undefined => {
  if (isJestProcessRequestBase(request)) {
    return request.transform;
  }
};

const getScheduleStrategy = (requestType: JestTestProcessType): ScheduleStrategy => {
  switch (requestType) {
    // abort if there is already an pending request
    case 'all-tests':
      return { queue: 'blocking', dedupe: { filterByStatus: ['pending'] } };
    case 'watch-tests':
      return { queue: 'blocking', dedupe: { filterByStatus: ['pending'] } };
    case 'watch-all-tests':
      return {
        queue: 'blocking',
        dedupe: { filterByStatus: ['pending'] },
      };
    case 'by-file':
      return {
        queue: 'blocking-2',
        dedupe: { filterByStatus: ['pending'] },
      };
    case 'by-file-test':
      return {
        queue: 'blocking-2',
        dedupe: { filterByStatus: ['pending'], filterByContent: true },
      };
    case 'by-file-pattern':
      return {
        queue: 'blocking-2',
        dedupe: { filterByStatus: ['pending'] },
      };
    case 'by-file-test-pattern':
      return {
        queue: 'blocking-2',
        dedupe: { filterByStatus: ['pending'], filterByContent: true },
      };
    case 'not-test':
      return {
        queue: 'non-blocking',
        dedupe: { filterByStatus: ['pending'] },
      };
    default:
      throw new Error(`Unexpected request type ${requestType}`);
  }
};

export interface ProcessSession {
  start: () => Promise<void>;
  stop: () => Promise<void>;
  scheduleProcess: <T extends JestExtRequestType = JestExtRequestType>(
    request: T,
    userData?: UserDataType
  ) => JestProcessInfo | undefined;
}
export interface ListenerSession {
  context: JestExtProcessContext;
  scheduleProcess: <T extends JestExtRequestType = JestExtRequestType>(
    request: T
  ) => JestProcessInfo | undefined;
}

export const createProcessSession = (context: JestExtProcessContext): ProcessSession => {
  const jestProcessManager = new JestProcessManager(context);
  const logging = context.loggingFactory.create('ProcessSessionManager');

  /**
   *
   * @param type
   * @param stopRunning if true, will stop and remove processes with the same type, default is false
   */
  const scheduleProcess = <T extends JestExtRequestType = JestExtRequestType>(
    request: T,
    userData?: UserDataType
  ): JestProcessInfo | undefined => {
    logging('debug', `scheduling jest process: ${request.type}`);
    try {
      const pRequest = createProcessRequest(request);

      const process = jestProcessManager.scheduleJestProcess(pRequest, userData);
      if (!process) {
        logging('warn', `request schedule failed: ${requestString(pRequest)}`);
        return;
      }

      context.onRunEvent.fire({ type: 'scheduled', process });

      return process;
    } catch (e) {
      logging(
        'warn',
        '[scheduleProcess] failed to create/schedule process for ',
        request,
        'error:',
        e
      );
      return;
    }
  };
  const listenerSession: ListenerSession = { context, scheduleProcess };

  const createProcessRequest = (request: JestExtRequestType): JestProcessRequest => {
    const transform = (pRequest: JestProcessRequest): JestProcessRequest => {
      const t = getTransform(request);
      return t ? t(pRequest) : pRequest;
    };

    const lSession = listenerSession;
    switch (request.type) {
      case 'all-tests': {
        const schedule = getScheduleStrategy(request.type);
        if (request.nonBlocking) {
          schedule.queue = 'blocking-2';
        }
        return transform({
          ...request,
          listener: new RunTestListener(lSession),
          schedule,
        });
      }
      case 'watch-all-tests':
      case 'watch-tests':
      case 'by-file':
      case 'by-file-pattern':
      case 'by-file-test':
      case 'by-file-test-pattern': {
        const schedule = getScheduleStrategy(request.type);
        return transform({
          ...request,
          listener: new RunTestListener(lSession),
          schedule,
        });
      }
      case 'list-test-files': {
        const schedule = getScheduleStrategy('not-test');
        return transform({
          ...request,
          type: 'not-test',
          args: ['--listTests', '--json', '--watchAll=false'],
          listener: new ListTestFileListener(lSession, request.onResult),
          schedule,
        });
      }
    }
    throw new Error(`Unexpected process type ${request.type}`);
  };

  /**
   * start JestExt process session from clean state, find all test files and launch the "run.onSessionStart" processes
   */
  const start = async (): Promise<void> => {
    if (jestProcessManager.numberOfProcesses() > 0) {
      logging('debug', `${jestProcessManager.numberOfProcesses} queued, stopping all...`);
      await stop();
    }

    if (context.settings.runMode.config.runAllTestsOnStartup) {
      // on startup, run all tests in blocking mode always
      scheduleProcess({ type: 'all-tests', nonBlocking: false });
    }
    if (context.settings.runMode.config.type === 'watch') {
      scheduleProcess({ type: 'watch-tests' });
    }
  };

  /**
   * stop JestExt process session and remove all processes.
   */
  const stop = async (): Promise<void> => {
    return jestProcessManager.stopAll();
  };

  return {
    start,
    stop,
    scheduleProcess,
  };
};

1	import {	3✔
2	JestProcessManager,
3	JestProcessRequest,
4	JestProcessRequestBase,
5	ScheduleStrategy,
6	requestString,
7	JestProcessInfo,
8	JestProcessRequestTransform,
9	UserDataType,
10	} from '../JestProcessManagement';
11	import { JestTestProcessType } from '../Settings';
12	import { RunTestListener, ListTestFileListener } from './process-listeners';	3✔
13	import { JestExtProcessContext } from './types';
14
15	type InternalProcessType = 'list-test-files';
16	export type ListTestFilesCallback = (
17	fileNames?: string[],
18	error?: string,
19	exitCode?: number
20	) => void;
21	export type InternalRequestBase = {
22	type: Extract<InternalProcessType, 'list-test-files'>;
23	onResult: ListTestFilesCallback;
24	};
25
26	export type JestExtRequestType = JestProcessRequestBase \| InternalRequestBase;
27	const isJestProcessRequestBase = (request: JestExtRequestType): request is JestProcessRequestBase =>	3✔
28	// eslint-disable-next-line @typescript-eslint/no-explicit-any
29	typeof (request as any).transform === 'function';	24✔
30	const getTransform = (request: JestExtRequestType): JestProcessRequestTransform \| undefined => {	3✔
31	if (isJestProcessRequestBase(request)) {	24✔
32	return request.transform;	1✔
33	}
34	};
35
36	const getScheduleStrategy = (requestType: JestTestProcessType): ScheduleStrategy => {	3✔
37	switch (requestType) {	24!
38	// abort if there is already an pending request
39	case 'all-tests':
40	return { queue: 'blocking', dedupe: { filterByStatus: ['pending'] } };	9✔
41	case 'watch-tests':
42	return { queue: 'blocking', dedupe: { filterByStatus: ['pending'] } };	6✔
43	case 'watch-all-tests':
44	return {	2✔
45	queue: 'blocking',
46	dedupe: { filterByStatus: ['pending'] },
47	};
48	case 'by-file':
49	return {	2✔
50	queue: 'blocking-2',
51	dedupe: { filterByStatus: ['pending'] },
52	};
53	case 'by-file-test':
54	return {	1✔
55	queue: 'blocking-2',
56	dedupe: { filterByStatus: ['pending'], filterByContent: true },
57	};
58	case 'by-file-pattern':
59	return {	1✔
60	queue: 'blocking-2',
61	dedupe: { filterByStatus: ['pending'] },
62	};
63	case 'by-file-test-pattern':
64	return {	1✔
65	queue: 'blocking-2',
66	dedupe: { filterByStatus: ['pending'], filterByContent: true },
67	};
68	case 'not-test':
69	return {	2✔
70	queue: 'non-blocking',
71	dedupe: { filterByStatus: ['pending'] },
72	};
73	default:
NEW UNCOV 74	throw new Error(`Unexpected request type ${requestType}`);	×
75	}
76	};
77
78	export interface ProcessSession {
79	start: () => Promise<void>;
80	stop: () => Promise<void>;
81	scheduleProcess: <T extends JestExtRequestType = JestExtRequestType>(
82	request: T,
83	userData?: UserDataType
84	) => JestProcessInfo \| undefined;
85	}
86	export interface ListenerSession {
87	context: JestExtProcessContext;
88	scheduleProcess: <T extends JestExtRequestType = JestExtRequestType>(
89	request: T
90	) => JestProcessInfo \| undefined;
91	}
92
93	export const createProcessSession = (context: JestExtProcessContext): ProcessSession => {	3✔
94	const jestProcessManager = new JestProcessManager(context);	24✔
95	const logging = context.loggingFactory.create('ProcessSessionManager');	24✔
96
97	/**
98	*
99	* @param type
100	* @param stopRunning if true, will stop and remove processes with the same type, default is false
101	*/
102	const scheduleProcess = <T extends JestExtRequestType = JestExtRequestType>(	24✔
103	request: T,
104	userData?: UserDataType
105	): JestProcessInfo \| undefined => {
106	logging('debug', `scheduling jest process: ${request.type}`);	25✔
107	try {	25✔
108	const pRequest = createProcessRequest(request);	25✔
109
110	const process = jestProcessManager.scheduleJestProcess(pRequest, userData);	24✔
111	if (!process) {	24✔
112	logging('warn', `request schedule failed: ${requestString(pRequest)}`);	1✔
113	return;	1✔
114	}
115
116	context.onRunEvent.fire({ type: 'scheduled', process });	23✔
117
118	return process;	23✔
119	} catch (e) {
120	logging(	1✔
121	'warn',
122	'[scheduleProcess] failed to create/schedule process for ',
123	request,
124	'error:',
125	e
126	);
127	return;	1✔
128	}
129	};
130	const listenerSession: ListenerSession = { context, scheduleProcess };	24✔
131
132	const createProcessRequest = (request: JestExtRequestType): JestProcessRequest => {	24✔
133	const transform = (pRequest: JestProcessRequest): JestProcessRequest => {	25✔
134	const t = getTransform(request);	24✔
135	return t ? t(pRequest) : pRequest;	24✔
136	};
137
138	const lSession = listenerSession;	25✔
139	switch (request.type) {	25✔
140	case 'all-tests': {
141	const schedule = getScheduleStrategy(request.type);	9✔
142	if (request.nonBlocking) {	9!
NEW 143	schedule.queue = 'blocking-2';	×
144	}
145	return transform({	9✔
146	...request,
147	listener: new RunTestListener(lSession),
148	schedule,
149	});
150	}
151	case 'watch-all-tests':
152	case 'watch-tests':
153	case 'by-file':
154	case 'by-file-pattern':
155	case 'by-file-test':
156	case 'by-file-test-pattern': {
157	const schedule = getScheduleStrategy(request.type);	13✔
158	return transform({	13✔
159	...request,
160	listener: new RunTestListener(lSession),
161	schedule,
162	});
163	}
164	case 'list-test-files': {
165	const schedule = getScheduleStrategy('not-test');	2✔
166	return transform({	2✔
167	...request,
168	type: 'not-test',
169	args: ['--listTests', '--json', '--watchAll=false'],
170	listener: new ListTestFileListener(lSession, request.onResult),
171	schedule,
172	});
173	}
174	}
175	throw new Error(`Unexpected process type ${request.type}`);	1✔
176	};
177
178	/**
179	* start JestExt process session from clean state, find all test files and launch the "run.onSessionStart" processes
180	*/
181	const start = async (): Promise<void> => {	24✔
182	if (jestProcessManager.numberOfProcesses() > 0) {	6✔
183	logging('debug', `${jestProcessManager.numberOfProcesses} queued, stopping all...`);	1✔
184	await stop();	1✔
185	}
186
187	if (context.settings.runMode.config.runAllTestsOnStartup) {	6✔
188	// on startup, run all tests in blocking mode always
189	scheduleProcess({ type: 'all-tests', nonBlocking: false });	3✔
190	}
191	if (context.settings.runMode.config.type === 'watch') {	6✔
192	scheduleProcess({ type: 'watch-tests' });	4✔
193	}
194	};
195
196	/**
197	* stop JestExt process session and remove all processes.
198	*/
199	const stop = async (): Promise<void> => {	24✔
200	return jestProcessManager.stopAll();	2✔
201	};
202
203	return {	24✔
204	start,
205	stop,
206	scheduleProcess,
207	};
208	};

jest-community / vscode-jest / 8461174746

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous