mockaton 8.3.1 → 8.3.3

package/README.md

@@ -51,7 +51,7 @@ import { Mockaton } from 'mockaton'
 
 // See the Config section for more options
 Mockaton({
-  mocksDir: resolve('my-mocks-dir'),
+  mocksDir: resolve('my-mocks-dir'), // must exist
   port: 2345
 })
 ```

package/index.d.ts

@@ -11,9 +11,8 @@ type Plugin = (
 
 interface Config {
 	mocksDir: string
-	ignore?: RegExp
-
 	staticDir?: string
+	ignore?: RegExp
 
 	host?: string,
 	port?: number

package/package.json

@@ -2,7 +2,7 @@
 	"name": "mockaton",
 	"description": "A deterministic server-side for developing and testing frontend clients",
 	"type": "module",
-	"version": "8.3.1",
+	"version": "8.3.3",
 	"main": "index.js",
 	"types": "index.d.ts",
 	"license": "MIT",

package/src/Api.js

@@ -5,7 +5,7 @@
 
 import { join } from 'node:path'
 import { cookie } from './cookie.js'
-import { Config } from './Config.js'
+import { config } from './config.js'
 import { DF, API } from './ApiConstants.js'
 import { parseJSON } from './utils/http-request.js'
 import { listFilesRecursively } from './utils/fs.js'
@@ -35,11 +35,12 @@ export const apiPatchRequests = new Map([
 	[API.reset, reinitialize],
 	[API.cookies, selectCookie],
 	[API.fallback, updateProxyFallback],
+	[API.collectProxied, setCollectProxied],
 	[API.bulkSelect, bulkUpdateBrokersByCommentTag],
 	[API.cors, setCorsAllowed]
 ])
 
-/* GET */
+/* === GET === */
 
 function serveDashboard(_, response) { sendFile(response, join(import.meta.dirname, 'Dashboard.html')) }
 function serveDashboardAsset(req, response) { sendFile(response, join(import.meta.dirname, req.url)) }
@@ -47,13 +48,13 @@ function serveDashboardAsset(req, response) { sendFile(response, join(import.met
 function listCookies(_, response) { sendJSON(response, cookie.list()) }
 function listComments(_, response) { sendJSON(response, mockBrokersCollection.extractAllComments()) }
 function listMockBrokers(_, response) { sendJSON(response, mockBrokersCollection.getAll()) }
-function getProxyFallback(_, response) { sendJSON(response, Config.proxyFallback) }
-function getIsCorsAllowed(_, response) { sendJSON(response, Config.corsAllowed) }
+function getProxyFallback(_, response) { sendJSON(response, config.proxyFallback) }
+function getIsCorsAllowed(_, response) { sendJSON(response, config.corsAllowed) }
 
-async function listStaticFiles(req, response) { // TESTME
+function listStaticFiles(req, response) {
 	try {
-		const files = Config.staticDir
-			? listFilesRecursively(Config.staticDir).filter(f => !Config.ignore.test(f))
+		const files = config.staticDir
+			? listFilesRecursively(config.staticDir).filter(f => !config.ignore.test(f))
 			: []
 		sendJSON(response, files)
 	}
@@ -63,7 +64,7 @@ async function listStaticFiles(req, response) { // TESTME
 }
 
 
-/* PATCH */
+/* === PATCH === */
 
 function reinitialize(_, response) {
 	mockBrokersCollection.init()
@@ -72,8 +73,11 @@ function reinitialize(_, response) {
 
 async function selectCookie(req, response) {
 	try {
-		cookie.setCurrent(await parseJSON(req))
-		sendOK(response)
+		const error = cookie.setCurrent(await parseJSON(req))
+		if (error)
+			sendUnprocessableContent(response, error)
+		else
+			sendOK(response)
 	}
 	catch (error) {
 		sendBadRequest(response, error)
@@ -113,10 +117,10 @@ async function setRouteIsDelayed(req, response) {
 async function updateProxyFallback(req, response) {
 	try {
 		const fallback = await parseJSON(req)
-		if (fallback && !URL.canParse(fallback)) // TESTME
+		if (fallback && !URL.canParse(fallback))
 			sendUnprocessableContent(response)
 		else {
-			Config.proxyFallback = fallback
+			config.proxyFallback = fallback
 			sendOK(response)
 		}
 	}
@@ -125,6 +129,16 @@ async function updateProxyFallback(req, response) {
 	}
 }
 
+async function setCollectProxied(req, response) {
+	try {
+		config.collectProxied = await parseJSON(req)
+		sendOK(response)
+	}
+	catch (error) {
+		sendBadRequest(response, error)
+	}
+}
+
 async function bulkUpdateBrokersByCommentTag(req, response) {
 	try {
 		mockBrokersCollection.setMocksMatchingComment(await parseJSON(req))
@@ -137,7 +151,7 @@ async function bulkUpdateBrokersByCommentTag(req, response) {
 
 async function setCorsAllowed(req, response) {
 	try {
-		Config.corsAllowed = await parseJSON(req)
+		config.corsAllowed = await parseJSON(req)
 		sendOK(response)
 	}
 	catch (error) {

package/src/ApiConstants.js

@@ -9,6 +9,7 @@ export const API = {
 	reset: MOUNT + '/reset',
 	cookies: MOUNT + '/cookies',
 	fallback: MOUNT + '/fallback',
+	collectProxied: MOUNT + '/collect-proxied',
 	cors: MOUNT + '/cors',
 	static: MOUNT + '/static'
 }
@@ -21,5 +22,4 @@ export const DF = { // Dashboard Fields (XHR)
 
 export const DEFAULT_500_COMMENT = '(Mockaton 500)'
 export const DEFAULT_MOCK_COMMENT = '(default)'
-
 export const EXT_FOR_UNKNOWN_MIME = 'unknown'

package/src/Commander.js

@@ -54,6 +54,10 @@ export class Commander {
 		return this.#patch(API.fallback, proxyAddr)
 	}
 
+	setCollectProxied(shouldCollect) {
+		return this.#patch(API.collectProxied, shouldCollect)
+	}
+
 	reset() {
 		return this.#patch(API.reset)
 	}

package/src/Dashboard.css

@@ -54,6 +54,13 @@ body {
 	margin: 0;
 	font-family: system-ui, sans-serif;
 	font-size: 100%;
+	outline: 0
+}
+
+select, a, input, button, summary {
+	&:focus-visible {
+		outline: 2px solid var(--colorAccent);
+	}
 }
 
 select {
@@ -116,7 +123,6 @@ menu {
 		}
 
 		input[type=url] {
-			outline: 0;
 			padding: 0 6px;
 			box-shadow: var(--boxShadow1);
 			color: var(--colorText);
@@ -244,7 +250,14 @@ main {
 	cursor: pointer;
 
 	> input {
-		display: none;
+		appearance: none;
+
+		&:focus-visible {
+			outline: 0;
+			& ~ svg {
+				outline: 2px solid var(--colorAccent)
+			}
+		}
 
 		&:checked ~ svg {
 			background: var(--colorAccent);
@@ -274,7 +287,14 @@ main {
 	cursor: pointer;
 
 	> input {
-		display: none;
+		appearance: none;
+
+		&:focus-visible {
+			outline: 0;
+			& ~ span {
+				outline: 2px solid var(--colorAccent)
+			}
+		}
 
 		&:checked ~ span {
 			color: white;
@@ -331,18 +351,25 @@ main {
 	margin-top: 40px;
 
 	summary {
+		width: max-content;
 		margin-bottom: 8px;
 		cursor: pointer;
 		font-weight: bold;
 	}
 
+	ul {
+		position: relative;
+		left: -6px;
+	}
+
 	li {
 		list-style: none;
 	}
 
 	a {
 		display: inline-block;
-		padding: 6px 0;
+		border-radius: 6px;
+		padding: 6px;
 		color: var(--colorAccentAlt);
 		text-decoration: none;
 

package/src/Dashboard.js

@@ -138,7 +138,6 @@ function ProxyFallbackField({ fallbackAddress = '' }) {
 			mockaton.setProxyFallback(input.value)
 				.catch(onError)
 	}
-
 	return (
 		r('label', null,
 			r('span', null, Strings.fallback_server),

package/src/MockBroker.js

@@ -1,4 +1,4 @@
-import { Config } from './Config.js'
+import { config } from './config.js'
 import { DEFAULT_500_COMMENT, DEFAULT_MOCK_COMMENT } from './ApiConstants.js'
 import { includesComment, extractComments, parseFilename } from './Filename.js'
 
@@ -38,7 +38,7 @@ export class MockBroker {
 
 	selectDefaultFile() {
 		const userSpecifiedDefault = this.#findMockWithDefaultComment()
-		if (userSpecifiedDefault) // Sort for dashboard list TESTME
+		if (userSpecifiedDefault) // Sort for dashboard list
 			this.mocks = [
 				userSpecifiedDefault,
 				...this.mocks.filter(m => m !== userSpecifiedDefault)
@@ -53,7 +53,7 @@ export class MockBroker {
 
 	mockExists(file) { return this.mocks.includes(file) }
 	updateFile(filename) { this.currentMock.file = filename }
-	updateDelay(delayed) { this.currentMock.delay = Number(delayed) * Config.delay }
+	updateDelay(delayed) { this.currentMock.delay = Number(delayed) * config.delay }
 
 	setByMatchingComment(comment) {
 		for (const file of this.mocks)
@@ -79,8 +79,8 @@ export class MockBroker {
 	}
 	#registerTemp500() {
 		const { urlMask, method } = parseFilename(this.mocks[0])
-		const file = urlMask.replace(/^\//, '') // Removes leading slash TESTME
-		this.register(`${file}${DEFAULT_500_COMMENT}.${method}.500.txt`)
+		const file = urlMask.replace(/^\//, '') // Removes leading slash
+		this.register(`${file}${DEFAULT_500_COMMENT}.${method}.500.empty`)
 	}
 }
 

package/src/MockDispatcher.js

@@ -2,7 +2,7 @@ import { join } from 'node:path'
 
 import { proxy } from './ProxyRelay.js'
 import { cookie } from './cookie.js'
-import { Config } from './Config.js'
+import { config } from './config.js'
 import { applyPlugins } from './MockDispatcherPlugins.js'
 import * as mockBrokerCollection from './mockBrokersCollection.js'
 import { BodyReaderError } from './utils/http-request.js'
@@ -13,7 +13,7 @@ export async function dispatchMock(req, response) {
 	try {
 		const broker = mockBrokerCollection.getBrokerForUrl(req.method, req.url)
 		if (!broker) {
-			if (Config.proxyFallback)
+			if (config.proxyFallback)
 				await proxy(req, response)
 			else
 				sendNotFound(response)
@@ -26,12 +26,12 @@ export async function dispatchMock(req, response) {
 		if (cookie.getCurrent())
 			response.setHeader('Set-Cookie', cookie.getCurrent())
 
-		for (let i = 0; i < Config.extraHeaders.length; i += 2)
-			response.setHeader(Config.extraHeaders[i], Config.extraHeaders[i + 1])
+		for (let i = 0; i < config.extraHeaders.length; i += 2)
+			response.setHeader(config.extraHeaders[i], config.extraHeaders[i + 1])
 
 		const { mime, body } = broker.isTemp500
 			? { mime: '', body: '' }
-			: await applyPlugins(join(Config.mocksDir, broker.file), req, response)
+			: await applyPlugins(join(config.mocksDir, broker.file), req, response)
 
 		response.setHeader('Content-Type', mime)
 		setTimeout(() => response.end(body), broker.delay)

package/src/MockDispatcherPlugins.js

@@ -1,10 +1,10 @@
 import { readFileSync as read } from 'node:fs'
 import { mimeFor } from './utils/mime.js'
-import { Config } from './Config.js'
+import { config } from './config.js'
 
 
 export async function applyPlugins(filePath, req, response) {
-	for (const [regex, plugin] of Config.plugins) // TESTME capitalizePlugin
+	for (const [regex, plugin] of config.plugins)
 		if (regex.test(filePath))
 			return await plugin(filePath, req, response)
 	return {

package/src/Mockaton.js

@@ -2,7 +2,7 @@ import { createServer } from 'node:http'
 
 import { API } from './ApiConstants.js'
 import { dispatchMock } from './MockDispatcher.js'
-import { Config, setup } from './Config.js'
+import { config, setup } from './config.js'
 import { sendNoContent } from './utils/http-response.js'
 import * as mockBrokerCollection from './mockBrokersCollection.js'
 import { dispatchStatic, isStatic } from './StaticDispatcher.js'
@@ -13,7 +13,7 @@ import { apiPatchRequests, apiGetRequests } from './Api.js'
 export function Mockaton(options) {
 	setup(options)
 	mockBrokerCollection.init()
-	return createServer(onRequest).listen(Config.port, Config.host, function (error) {
+	return createServer(onRequest).listen(config.port, config.host, function (error) {
 		const { address, port } = this.address()
 		const url = `http://${address}:${port}`
 		console.log('Listening', url)
@@ -21,21 +21,21 @@ export function Mockaton(options) {
 		if (error)
 			console.error(error)
 		else
-			Config.onReady(url + API.dashboard)
+			config.onReady(url + API.dashboard)
 	})
 }
 
 async function onRequest(req, response) {
 	response.setHeader('Server', 'Mockaton')
 
-	if (Config.corsAllowed)
+	if (config.corsAllowed)
 		setCorsHeaders(req, response, {
-			origins: Config.corsOrigins,
-			headers: Config.corsHeaders,
-			methods: Config.corsMethods,
-			maxAge: Config.corsMaxAge,
-			credentials: Config.corsCredentials,
-			exposedHeaders: Config.corsExposedHeaders
+			origins: config.corsOrigins,
+			headers: config.corsHeaders,
+			methods: config.corsMethods,
+			maxAge: config.corsMaxAge,
+			credentials: config.corsCredentials,
+			exposedHeaders: config.corsExposedHeaders
 		})
 
 	const { url, method } = req

package/src/Mockaton.test.js

@@ -1,17 +1,21 @@
 import { tmpdir } from 'node:os'
-import { dirname } from 'node:path'
+import { dirname, join } from 'node:path'
 import { promisify } from 'node:util'
 import { describe, it } from 'node:test'
 import { createServer } from 'node:http'
+import { randomUUID } from 'node:crypto'
 import { equal, deepEqual, match } from 'node:assert/strict'
 import { writeFileSync, mkdtempSync, mkdirSync } from 'node:fs'
 
-import { Config } from './Config.js'
+
+import { config } from './config.js'
 import { mimeFor } from './utils/mime.js'
 import { Mockaton } from './Mockaton.js'
+import { readBody } from './utils/http-request.js'
 import { Commander } from './Commander.js'
-import { parseFilename } from './Filename.js'
 import { CorsHeader } from './utils/http-cors.js'
+import { parseFilename } from './Filename.js'
+import { listFilesRecursively, read } from './utils/fs.js'
 import { API, DEFAULT_500_COMMENT, DEFAULT_MOCK_COMMENT } from './ApiConstants.js'
 
 
@@ -26,7 +30,7 @@ const fixtureCustomMime = [
 ]
 const fixtureNonDefaultInName = [
 	'/api/the-route',
-	'api/the-route(default).GET.200.json',
+	'api/the-route.GET.200.json',
 	'default my route body content'
 ]
 const fixtureDefaultInName = [
@@ -137,11 +141,14 @@ write('api/ignored.GET.200.json~', '')
 // JavaScript to JSON
 write('/api/object.GET.200.js', 'export default { JSON_FROM_JS: true }')
 
-writeStatic('index.html', '<h1>Static</h1>')
-writeStatic('assets/app.js', 'const app = 1')
-writeStatic('another-entry/index.html', '<h1>Another</h1>')
-
-
+const staticFiles = [
+	['index.html', '<h1>Static</h1>'],
+	['assets/app.js', 'const app = 1'],
+	['another-entry/index.html', '<h1>Another</h1>']
+]
+writeStatic('ignored.js~', 'ignored_file_body')
+for (const [file, body] of staticFiles)
+	writeStatic(file, body)
 
 const server = Mockaton({
 	mocksDir: tmpDir,
@@ -156,7 +163,8 @@ const server = Mockaton({
 	extraMimes: {
 		my_custom_extension: 'my_custom_mime'
 	},
-	corsOrigins: ['http://example.com']
+	corsOrigins: ['http://example.com'],
+	corsExposedHeaders: ['Content-Encoding']
 })
 server.on('listening', runTests)
 
@@ -186,7 +194,7 @@ async function runTests() {
 
 	await testAutogenerates500(
 		'/api/alternative',
-		`api/alternative${DEFAULT_500_COMMENT}.GET.500.txt`)
+		`api/alternative${DEFAULT_500_COMMENT}.GET.500.empty`)
 
 	await testPreservesExiting500(
 		'/api',
@@ -225,11 +233,14 @@ async function runTests() {
 	await testMockDispatching(...fixtureCustomMime, 'my_custom_mime')
 	await testJsFunctionMocks()
 
-	await testItUpdatesUserRole()
+	await testItUpdatesCookie()
 	await testStaticFileServing()
+	await testStaticFileList()
 	await testInvalidFilenamesAreIgnored()
 	await testEnableFallbackSoRoutesWithoutMocksGetRelayed()
+	await testValidatesProxyFallbackURL()
 	await testCorsAllowed()
+	testWindowsPaths()
 
 	server.close()
 }
@@ -255,6 +266,10 @@ async function test404() {
 		const res = await request('/api/ignored')
 		equal(res.status, 404)
 	})
+	await it('Ignores static files ending in ~ by default, e.g. JetBrains temp files', async () => {
+		const res = await request('/ignored.js~')
+		equal(res.status, 404)
+	})
 }
 
 async function testMockDispatching(url, file, expectedBody, forcedMime = undefined) {
@@ -275,6 +290,13 @@ async function testMockDispatching(url, file, expectedBody, forcedMime = undefin
 
 async function testDefaultMock() {
 	await testMockDispatching(...fixtureDefaultInName)
+	await it('sorts mocks list with the user specified default first for dashboard display', async () => {
+		const res = await commander.listMocks()
+		const body = await res.json()
+		const { mocks } = body.GET[fixtureDefaultInName[0]]
+		equal(mocks[0], fixtureDefaultInName[1])
+		equal(mocks[1], fixtureNonDefaultInName[1])
+	})
 }
 
 async function testItUpdatesTheCurrentSelectedMock(url, file, expectedStatus, expectedBody) {
@@ -295,7 +317,7 @@ async function testItUpdatesRouteDelay(url, file, expectedBody) {
 	const body = await res.text()
 	await describe('url: ' + url, () => {
 		it('body is: ' + expectedBody, () => equal(body, JSON.stringify(expectedBody)))
-		it('delay', () => equal((new Date()).getTime() - now.getTime() > Config.delay, true))
+		it('delay', () => equal((new Date()).getTime() - now.getTime() > config.delay, true))
 	})
 }
 
@@ -342,7 +364,7 @@ async function testItBulkSelectsByComment(comment, tests) {
 }
 
 
-async function testItUpdatesUserRole() {
+async function testItUpdatesCookie() {
 	await describe('Cookie', () => {
 		it('Defaults to the first key:value', async () => {
 			const res = await commander.listCookies()
@@ -352,7 +374,7 @@ async function testItUpdatesUserRole() {
 			])
 		})
 
-		it('Update the selected cookie', async () => {
+		it('Updates selected cookie', async () => {
 			await commander.selectCookie('userB')
 			const res = await commander.listCookies()
 			deepEqual(await res.json(), [
@@ -360,6 +382,11 @@ async function testItUpdatesUserRole() {
 				['userB', true]
 			])
 		})
+
+		it('422 when trying to select non-existing cookie', async () => {
+			const res = await commander.selectCookie('non-existing-cookie-key')
+			equal(res.status, 422)
+		})
 	})
 }
 
@@ -404,6 +431,13 @@ async function testStaticFileServing() {
 	})
 }
 
+async function testStaticFileList() {
+	await it('Static File List', async () => {
+		const res = await commander.listStaticFiles()
+		deepEqual((await res.json()).sort(), staticFiles.map(([file]) => file).sort())
+	})
+}
+
 async function testInvalidFilenamesAreIgnored() {
 	await it('Invalid filenames get skipped, so they don’t crash the server', async (t) => {
 		const consoleErrorSpy = t.mock.method(console, 'error')
@@ -421,26 +455,50 @@ async function testInvalidFilenamesAreIgnored() {
 
 async function testEnableFallbackSoRoutesWithoutMocksGetRelayed() {
 	await describe('Fallback', async () => {
-		const fallbackServer = createServer((_, response) => {
-			response.setHeader('custom_header', 'my_custom_header')
-			response.statusCode = 423
-			response.end('From_Fallback_Server')
+		const fallbackServer = createServer(async (req, response) => {
+			response.writeHead(423, {
+				'custom_header': 'my_custom_header',
+				'content-type': mimeFor('txt'),
+				'set-cookie': [
+					'cookieA=A',
+					'cookieB=B'
+				]
+			})
+			response.end(await readBody(req)) // echoes they req body payload
 		})
 		await promisify(fallbackServer.listen).bind(fallbackServer, 0, '127.0.0.1')()
 
 		await commander.setProxyFallback(`http://localhost:${fallbackServer.address().port}`)
-		await it('Relays to fallback server', async () => {
-			const res = await request('/non-existing-mock')
-			equal(res.headers.get('custom_header'), 'my_custom_header')
+		await commander.setCollectProxied(true)
+		await it('Relays to fallback server and saves the mock', async () => {
+			const reqBodyPayload = 'text_req_body'
+
+			const res = await request(`/api/non-existing-mock/${randomUUID()}`, {
+				method: 'POST',
+				body: reqBodyPayload
+			})
 			equal(res.status, 423)
-			equal(await res.text(), 'From_Fallback_Server')
+			equal(res.headers.get('custom_header'), 'my_custom_header')
+			equal(res.headers.get('set-cookie'), ['cookieA=A', 'cookieB=B'].join(', '))
+			equal(await res.text(), reqBodyPayload)
+
+			const savedBody = read(join(tmpDir, 'api/non-existing-mock/[id].POST.423.txt'))
+			equal(savedBody, reqBodyPayload)
+
 			fallbackServer.close()
 		})
 	})
 }
 
+async function testValidatesProxyFallbackURL() {
+	await it('422 when value is not a valid URL', async () => {
+		const res = await commander.setProxyFallback('bad url')
+		equal(res.status, 422)
+	})
+}
+
 async function testCorsAllowed() {
-	await it('cors', async () => {
+	await it('cors preflight', async () => {
 		await commander.setCorsAllowed(true)
 		const res = await request('/does-not-matter', {
 			method: 'OPTIONS',
@@ -453,6 +511,23 @@ async function testCorsAllowed() {
 		equal(res.headers.get(CorsHeader.AccessControlAllowOrigin), 'http://example.com')
 		equal(res.headers.get(CorsHeader.AccessControlAllowMethods), 'GET')
 	})
+	await it('cors actual response', async () => {
+		const res = await request(fixtureDefaultInName[0], {
+			headers: {
+				[CorsHeader.Origin]: 'http://example.com'
+			}
+		})
+		equal(res.status, 200)
+		equal(res.headers.get(CorsHeader.AccessControlAllowOrigin), 'http://example.com')
+		equal(res.headers.get(CorsHeader.AccessControlExposeHeaders), 'Content-Encoding')
+	})
+}
+
+function testWindowsPaths() {
+	it('normalizes backslashes with forward ones', () => {
+		const files = listFilesRecursively(config.mocksDir)
+		equal(files[0], 'api/.GET.200.json')
+	})
 }
 
 

package/src/ProxyRelay.js

@@ -1,27 +1,29 @@
 import { join } from 'node:path'
 import { write } from './utils/fs.js'
-import { Config } from './Config.js'
+import { config } from './config.js'
 import { extFor } from './utils/mime.js'
 import { readBody } from './utils/http-request.js'
 import { makeMockFilename } from './Filename.js'
 
 
 export async function proxy(req, response) {
-	const proxyResponse = await fetch(Config.proxyFallback + req.url, {
+	const proxyResponse = await fetch(config.proxyFallback + req.url, {
 		method: req.method,
 		headers: req.headers,
-		body: req.method === 'GET' || req.method === 'HEAD' // TESTME
+		body: req.method === 'GET' || req.method === 'HEAD'
 			? undefined
 			: await readBody(req)
 	})
-	// TODO investigate how to include many repeated headers such as set-cookie
-	response.writeHead(proxyResponse.status, Object.fromEntries(proxyResponse.headers))
+
+	const headers = Object.fromEntries(proxyResponse.headers)
+	headers['set-cookie'] = proxyResponse.headers.getSetCookie() // parses multiple into an array
+	response.writeHead(proxyResponse.status, headers)
 	const body = await proxyResponse.text()
 	response.end(body)
 
-	if (Config.collectProxied) { // TESTME
+	if (config.collectProxied) {
 		const ext = extFor(proxyResponse.headers.get('content-type'))
 		const filename = makeMockFilename(req.url, req.method, proxyResponse.status, ext)
-		write(join(Config.mocksDir, filename), body)
+		write(join(config.mocksDir, filename), body)
 	}
 }

package/src/StaticDispatcher.js

@@ -1,16 +1,14 @@
 import { join } from 'node:path'
-import { Config } from './Config.js'
+import { config } from './config.js'
 import { isDirectory, isFile } from './utils/fs.js'
 import { sendFile, sendPartialContent, sendNotFound } from './utils/http-response.js'
 
 
 export function isStatic(req) {
-	if (!Config.staticDir)
+	if (!config.staticDir)
 		return false
-
 	const f = resolvePath(req.url)
-	return !Config.ignore.test(f) // TESTME
-		&& Boolean(f)
+	return !config.ignore.test(f) && Boolean(f)
 }
 
 export async function dispatchStatic(req, response) {
@@ -24,7 +22,7 @@ export async function dispatchStatic(req, response) {
 }
 
 function resolvePath(url) {
-	let candidate = join(Config.staticDir, url)
+	let candidate = join(config.staticDir, url)
 	if (isDirectory(candidate))
 		candidate += '/index.html'
 	if (isFile(candidate))

package/src/{Config.js → config.js}

@@ -2,14 +2,13 @@ import { isDirectory } from './utils/fs.js'
 import { openInBrowser } from './utils/openInBrowser.js'
 import { jsToJsonPlugin } from './MockDispatcherPlugins.js'
 import { StandardMethods } from './utils/http-request.js'
-import { validate, is, optional } from './utils/validate.js'
+import { validateCorsAllowedMethods, validateCorsAllowedOrigins } from './utils/http-cors.js'
 
 
-export const Config = Object.seal({
+export const config = Object.seal({
 	mocksDir: '',
-	ignore: /(\.DS_Store|~)$/,
-
 	staticDir: '',
+	ignore: /(\.DS_Store|~)$/,
 
 	host: '127.0.0.1',
 	port: 0, // auto-assigned
@@ -38,12 +37,11 @@ export const Config = Object.seal({
 
 
 export function setup(options) {
-	Object.assign(Config, options)
-	validate(Config, {
+	Object.assign(config, options)
+	validate(config, {
 		mocksDir: isDirectory,
-		ignore: is(RegExp),
-
 		staticDir: optional(isDirectory),
+		ignore: is(RegExp),
 
 		host: is(String),
 		port: port => Number.isInteger(port) && port >= 0 && port < 2 ** 16,
@@ -70,20 +68,16 @@ export function setup(options) {
 }
 
 
-function validateCorsAllowedOrigins(arr) {
-	if (!Array.isArray(arr))
-		return false
-
-	if (arr.length === 1 && arr[0] === '*')
-		return true
-
-	return arr.every(o => URL.canParse(o))
+function validate(obj, shape) {
+	for (const [field, value] of Object.entries(obj))
+		if (!shape[field](value))
+			throw new TypeError(`config.${field}=${JSON.stringify(value)} is invalid`)
 }
 
+function is(ctor) {
+	return val => val.constructor === ctor
+}
 
-function validateCorsAllowedMethods(arr) {
-	if (!Array.isArray(arr))
-		return false
-
-	return arr.every(m => StandardMethods.includes(m))
+function optional(tester) {
+	return val => !val || tester(val)
 }

package/src/cookie.js

@@ -17,7 +17,7 @@ export const cookie = new class {
 		if (key in this.#cookies)
 			this.#currentKey = key
 		else
-			throw 'Cookie key not found' // TESTME
+			return 'Cookie key not found'
 	}
 
 	list() {

package/src/mockBrokersCollection.js

@@ -1,4 +1,4 @@
-import { Config } from './Config.js'
+import { config } from './config.js'
 import { cookie } from './cookie.js'
 import { MockBroker } from './MockBroker.js'
 import { listFilesRecursively } from './utils/fs.js'
@@ -19,11 +19,11 @@ let collection = {}
 
 export function init() {
 	collection = {}
-	cookie.init(Config.cookies)
+	cookie.init(config.cookies)
 
-	const files = listFilesRecursively(Config.mocksDir)
+	const files = listFilesRecursively(config.mocksDir)
 		.sort()
-		.filter(f => !Config.ignore.test(f) && filenameIsValid(f))
+		.filter(f => !config.ignore.test(f) && filenameIsValid(f))
 
 	for (const file of files) {
 		const { method, urlMask } = parseFilename(file)

package/src/utils/fs.js

@@ -1,21 +1,21 @@
-import path, { join } from 'node:path'
+import { join, dirname, sep, posix } from 'node:path'
 import { lstatSync, readFileSync, readdirSync, writeFileSync, mkdirSync } from 'node:fs'
 
 
 export const isFile = path => lstatSync(path, { throwIfNoEntry: false })?.isFile()
 export const isDirectory = path => lstatSync(path, { throwIfNoEntry: false })?.isDirectory()
 
-export const read = path => readFileSync(path)
+export const read = path => readFileSync(path, 'utf8')
 
 /** @returns {Array<string>} paths relative to `dir` */
 export const listFilesRecursively = dir => {
 	const files = readdirSync(dir, { recursive: true }).filter(f => isFile(join(dir, f)))
 	return process.platform === 'win32'
-		? files.map(f => f.replaceAll(path.sep, path.posix.sep)) // TESTME
+		? files.map(f => f.replaceAll(sep, posix.sep))
 		: files
 }
 
-export const write = (fPath, body) => {
-	mkdirSync(path.dirname(fPath), { recursive: true })
-	writeFileSync(fPath, body)
+export const write = (path, body) => {
+	mkdirSync(dirname(path), { recursive: true })
+	writeFileSync(path, body)
 }

package/src/utils/http-cors.js

@@ -1,19 +1,35 @@
 import { StandardMethods } from './http-request.js'
 
-// https://www.w3.org/TR/2020/SPSD-cors-20200602/#resource-processing-model
+
+/* https://www.w3.org/TR/2020/SPSD-cors-20200602/#resource-processing-model */
+
+
+export function validateCorsAllowedOrigins(arr) {
+	if (!Array.isArray(arr))
+		return false
+	if (arr.length === 1 && arr[0] === '*')
+		return true
+	return arr.every(o => URL.canParse(o))
+}
+
+export function validateCorsAllowedMethods(arr) {
+	return Array.isArray(arr)
+		&& arr.every(m => StandardMethods.includes(m))
+}
+
 
 export const CorsHeader = {
-	// request
+	// Request
 	Origin: 'origin',
 	AccessControlRequestMethod: 'access-control-request-method',
 	AccessControlRequestHeaders: 'access-control-request-headers', // Comma separated
 
-	// response
+	// Response
 	AccessControlMaxAge: 'Access-Control-Max-Age',
 	AccessControlAllowOrigin: 'Access-Control-Allow-Origin', // '*' | Space delimited | null
 	AccessControlAllowMethods: 'Access-Control-Allow-Methods', // '*' | Comma delimited
 	AccessControlAllowHeaders: 'Access-Control-Allow-Headers', // '*' | Comma delimited 
-	AccessControlExposeHeaders: 'Access-Control-Expose-Headers', // '*' | Comma delimited 
+	AccessControlExposeHeaders: 'Access-Control-Expose-Headers', // '*' | Comma delimited (headers client-side JS can read)
 	AccessControlAllowCredentials: 'Access-Control-Allow-Credentials' // 'true'
 }
 const CH = CorsHeader
@@ -45,26 +61,16 @@ export function setCorsHeaders(req, response, {
 
 	if (req.headers[CH.AccessControlRequestMethod])
 		setPreflightSpecificHeaders(req, response, methods, headers, maxAge)
-	else
-		setActualRequestHeaders(response, exposedHeaders)
+	else if (exposedHeaders.length)
+		response.setHeader(CH.AccessControlExposeHeaders, exposedHeaders.join(','))
 }
 
-
 function setPreflightSpecificHeaders(req, response, methods, headers, maxAge) {
 	const methodAskingFor = req.headers[CH.AccessControlRequestMethod]
 	if (!methods.includes(methodAskingFor))
 		return
-
 	response.setHeader(CH.AccessControlMaxAge, maxAge)
 	response.setHeader(CH.AccessControlAllowMethods, methodAskingFor)
 	if (headers.length)
 		response.setHeader(CH.AccessControlAllowHeaders, headers.join(','))
 }
-
-
-// TESTME
-function setActualRequestHeaders(response, exposedHeaders) {
-	// Exposed means the client-side JavaScript can read them
-	if (exposedHeaders.length)
-		response.setHeader(CH.AccessControlExposeHeaders, exposedHeaders.join(','))
-}

package/src/utils/mime.js

@@ -1,4 +1,4 @@
-import { Config } from '../Config.js'
+import { config } from '../config.js'
 import { EXT_FOR_UNKNOWN_MIME } from '../ApiConstants.js'
 
 // https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
@@ -89,7 +89,7 @@ const mimes = {
 
 export function mimeFor(filename) {
 	const ext = filename.replace(/.*\./, '').toLowerCase()
-	return Config.extraMimes[ext] || mimes[ext] || ''
+	return config.extraMimes[ext] || mimes[ext] || ''
 }
 
 export function extFor(mime) {
@@ -99,7 +99,7 @@ export function extFor(mime) {
 }
 
 function findExt(targetMime) {
-	for (const [ext, mime] of Object.entries(Config.extraMimes))
+	for (const [ext, mime] of Object.entries(config.extraMimes))
 		if (targetMime === mime)
 			return ext
 	for (const [ext, mime] of Object.entries(mimes))

package/src/utils/validate.js

@@ -1,8 +0,0 @@
-export function validate(obj, shape) {
-	for (const [field, value] of Object.entries(obj))
-		if (!shape[field](value))
-			throw new TypeError(`Config.${field}=${JSON.stringify(value)} is invalid`)
-}
-
-export const is = ctor => val => val.constructor === ctor
-export const optional = tester => val => !val || tester(val)