Add key option to registerSharedWorker()

lib/fork.js

@@ -113,8 +113,9 @@ export default function loadFork(file, options, execArgv = process.execArgv) {
 					send({type: 'options', options});
 					break;
 				case 'shared-worker-connect': {
-					const {channelId, filename, initialData, port} = message.ava;
+					const {channelId, key, filename, initialData, port} = message.ava;
 					emitter.emit('connectSharedWorker', {
+						key,
 						filename,
 						initialData,
 						port,

lib/plugin-support/shared-workers.js

@@ -16,9 +16,9 @@ const waitForAvailable = async worker => {
 	}
 };
 
-function launchWorker(filename, initialData) {
-	if (launchedWorkers.has(filename)) {
-		return launchedWorkers.get(filename);
+function launchWorker(key, filename, initialData) {
+	if (launchedWorkers.has(key)) {
+		return launchedWorkers.get(key);
 	}
 
 	const worker = new Worker(LOADER, {
@@ -40,7 +40,7 @@ function launchWorker(filename, initialData) {
 		worker,
 	};
 
-	launchedWorkers.set(filename, launched);
+	launchedWorkers.set(key, launched);
 	worker.once('exit', () => {
 		launched.exited = true;
 	});
@@ -61,8 +61,8 @@ export async function observeWorkerProcess(fork, runStatus) {
 		}
 	});
 
-	fork.onConnectSharedWorker(async ({filename, initialData, port, signalError}) => {
-		const launched = launchWorker(filename, initialData);
+	fork.onConnectSharedWorker(async ({key, filename, initialData, port, signalError}) => {
+		const launched = launchWorker(key, filename, initialData);
 
 		const handleWorkerMessage = async message => {
 			if (message.type === 'deregistered-test-worker' && message.id === fork.threadId) {

lib/worker/channel.cjs

@@ -180,7 +180,7 @@ function createChannelEmitter(channelId) {
 	return [emitter, () => channelEmitters.delete(channelId)];
 }
 
-function registerSharedWorker(filename, initialData) {
+function registerSharedWorker(key, filename, initialData) {
 	const channelId = `${threadId}/channel/${++channelCounter}`;
 
 	const {port1: ourPort, port2: theirPort} = new MessageChannel();
@@ -191,6 +191,7 @@ function registerSharedWorker(filename, initialData) {
 	handle.send({
 		type: 'shared-worker-connect',
 		channelId,
+		key,
 		filename,
 		initialData,
 		port: theirPort,

lib/worker/plugin.cjs

@@ -9,8 +9,8 @@ require('./guard-environment.cjs'); // eslint-disable-line import/no-unassigned-
 const workers = new Map();
 const workerTeardownFns = new WeakMap();
 
-function createSharedWorker(filename, initialData, teardown) {
-	const {channel, forceUnref, ready} = register(filename, initialData, teardown);
+function createSharedWorker(key, filename, initialData, teardown) {
+	const {channel, forceUnref, ready} = register(key, filename, initialData, teardown);
 	waitForReady.push(ready);
 	sharedWorkerTeardowns.push(async () => {
 		try {
@@ -85,6 +85,7 @@ function createSharedWorker(filename, initialData, teardown) {
 
 function registerSharedWorker({
 	filename,
+	key,
 	initialData,
 	supportedProtocols,
 	teardown,
@@ -100,10 +101,11 @@ function registerSharedWorker({
 	}
 
 	filename = String(filename); // Allow URL instances.
+	key = key ? key : filename; // Fallback to filename for key
 
-	let worker = workers.get(filename);
+	let worker = workers.get(key);
 	if (worker === undefined) {
-		worker = createSharedWorker(filename, initialData, async () => {
+		worker = createSharedWorker(key, filename, initialData, async () => {
 			// Run possibly asynchronous teardown functions serially, in reverse
 			// order. Any error will crash the worker.
 			const teardownFns = workerTeardownFns.get(worker);
@@ -113,7 +115,7 @@ function registerSharedWorker({
 				}
 			}
 		});
-		workers.set(filename, worker);
+		workers.set(key, worker);
 	}
 
 	if (teardown !== undefined) {

plugin.d.ts

@@ -47,6 +47,7 @@ export namespace SharedWorker {
 	export namespace Plugin {
 		export type RegistrationOptions<Identifier extends ProtocolIdentifier, Data = unknown> = {
 			readonly filename: string | URL;
+			readonly key?: string;
 			readonly initialData?: Data;
 			readonly supportedProtocols: readonly Identifier[];
 			readonly teardown?: () => void;

test/shared-workers/keyed-workers-are-not-deduped/fixtures/_plugin.js

@@ -0,0 +1,15 @@
+import * as plugin from 'ava/plugin';
+
+export const getWorker = key => {
+	const worker = plugin.registerSharedWorker({
+		key,
+		filename: new URL('_worker.js', import.meta.url),
+		supportedProtocols: ['ava-4'],
+	});
+
+	const messages = worker.subscribe();
+
+	const random = messages.next().then(({value}) => value).finally(() => messages.return());
+
+	return {random};
+};

test/shared-workers/keyed-workers-are-not-deduped/fixtures/_worker.js

@@ -0,0 +1,10 @@
+import crypto from 'node:crypto';
+
+export default async ({negotiateProtocol}) => {
+	const protocol = negotiateProtocol(['ava-4']).ready();
+
+	const random = crypto.randomBytes(16).toString('hex');
+	for await (const testWorker of protocol.testWorkers()) {
+		testWorker.publish({random});
+	}
+};

test/shared-workers/keyed-workers-are-not-deduped/fixtures/package.json

@@ -0,0 +1,8 @@
+{
+	"type": "module",
+	"ava": {
+		"files": [
+			"*"
+		]
+	}
+}

test/shared-workers/keyed-workers-are-not-deduped/fixtures/test-1.js

@@ -0,0 +1,11 @@
+import test from 'ava';
+
+import {getWorker} from './_plugin.js';
+
+const {random} = getWorker('test-1');
+
+test('the shared worker produces a random value', async t => {
+	const {data} = await random;
+	t.log(data);
+	t.pass();
+});

test/shared-workers/keyed-workers-are-not-deduped/fixtures/test-2.js

@@ -0,0 +1,11 @@
+import test from 'ava';
+
+import {getWorker} from './_plugin.js';
+
+const {random} = getWorker('test-2');
+
+test('the shared worker produces a random value', async t => {
+	const {data} = await random;
+	t.log(data);
+	t.pass();
+});

test/shared-workers/keyed-workers-are-not-deduped/test.js

@@ -0,0 +1,10 @@
+import test from '@ava/test';
+
+import {fixture} from '../../helpers/exec.js';
+
+test('keyed workers are not deduped', async t => {
+	const result = await fixture();
+	const logs = result.stats.passed.map(object => result.stats.getLogs(object));
+	t.is(logs.length, 2);
+	t.notDeepEqual(logs[0], logs[1]);
+});