fix test and update server-side-rendering test

test/hydration/index.ts

@@ -40,63 +40,71 @@ describe('hydration', () => {
 			});
 			register.setCompile(svelte.compile);
 			register.setOutputFolderName('hydratable');
+			register.clearRequireCache();
+			register.clearCompileOutputCache();
 
 			const window = env();
 
-			global.window = window;
+			try {
+				global.window = window;
 
-			const SvelteComponent = require(`${cwd}/main.svelte`).default;
+				const SvelteComponent = require(`${cwd}/main.svelte`).default;
 
-			const target = window.document.body;
+				const target = window.document.body;
-			const head = window.document.head;
+				const head = window.document.head;
 
-			target.innerHTML = fs.readFileSync(`${cwd}/_before.html`, 'utf-8');
+				target.innerHTML = fs.readFileSync(`${cwd}/_before.html`, 'utf-8');
 
-			let before_head;
+				let before_head;
-			try {
+				try {
-				before_head = fs.readFileSync(`${cwd}/_before_head.html`, 'utf-8');
+					before_head = fs.readFileSync(`${cwd}/_before_head.html`, 'utf-8');
-				head.innerHTML = before_head;
+					head.innerHTML = before_head;
-			} catch (err) {
+				} catch (err) {
-				// continue regardless of error
+					// continue regardless of error
-			}
+				}
 
-			const snapshot = config.snapshot ? config.snapshot(target) : {};
+				const snapshot = config.snapshot ? config.snapshot(target) : {};
 
-			const component = new SvelteComponent({
+				const component = new SvelteComponent({
-				target,
+					target,
-				hydrate: true,
+					hydrate: true,
-				props: config.props
+					props: config.props
-			});
+				});
 
-			try {
-				assert.htmlEqual(target.innerHTML, fs.readFileSync(`${cwd}/_after.html`, 'utf-8'));
-			} catch (error) {
-				if (shouldUpdateExpected()) {
-					fs.writeFileSync(`${cwd}/_after.html`, target.innerHTML);
-					console.log(`Updated ${cwd}/_after.html.`);
-				} else {
-					throw error;
-				}
-			}
-
-			if (before_head) {
 				try {
-					assert.htmlEqual(head.innerHTML, fs.readFileSync(`${cwd}/_after_head.html`, 'utf-8'));
+					assert.htmlEqual(target.innerHTML, fs.readFileSync(`${cwd}/_after.html`, 'utf-8'));
 				} catch (error) {
 					if (shouldUpdateExpected()) {
-						fs.writeFileSync(`${cwd}/_after_head.html`, head.innerHTML);
+						fs.writeFileSync(`${cwd}/_after.html`, target.innerHTML);
-						console.log(`Updated ${cwd}/_after_head.html.`);
+						console.log(`Updated ${cwd}/_after.html.`);
 					} else {
 						throw error;
 					}
 				}
-			}
 
-			if (config.test) {
+				if (before_head) {
-				config.test(assert, target, snapshot, component, window);
+					try {
-			} else {
+						assert.htmlEqual(head.innerHTML, fs.readFileSync(`${cwd}/_after_head.html`, 'utf-8'));
-				component.$destroy();
+					} catch (error) {
-				assert.equal(target.innerHTML, '');
+						if (shouldUpdateExpected()) {
+							fs.writeFileSync(`${cwd}/_after_head.html`, head.innerHTML);
+							console.log(`Updated ${cwd}/_after_head.html.`);
+						} else {
+							throw error;
+						}
+					}
+				}
+
+				if (config.test) {
+					config.test(assert, target, snapshot, component, window);
+				} else {
+					component.$destroy();
+					assert.equal(target.innerHTML, '');
+				}
+			} catch (err) {
+				// saves the compiled output into file system
+				register.writeCompileOutputCacheToFile();
+				throw err;
 			}
 		});
 	}

test/register.ts

@@ -38,7 +38,7 @@ export function clearRequireCache() {
 }
 
 function registerExtension(extension: string) {
-	require.extensions[extension] = function(module, filename) {
+	require.extensions[extension] = function (module, filename) {
 		const name = path
 			.parse(filename)
 			.name.replace(/^\d/, '_$&')
@@ -56,22 +56,33 @@ function registerExtension(extension: string) {
 		} = compile(fs.readFileSync(filename, 'utf-8'), options);
 
 		if (!process.env.CI) {
-			saveGeneratedOutput(code, filename);
+			saveGeneratedOutputToCache(code, filename);
 		}
 
 		return module._compile(code, filename);
 	};
 }
 
-function saveGeneratedOutput(code: string, filename: string) {
+const outputCache = new Map();
+function saveGeneratedOutputToCache(code: string, filename: string) {
 	filename = filename.split('\\').join('/');
 	filename = filename.replace(
 		/samples\/([^/]+)\/(.*)\.svelte$/,
 		`samples/$1/_output/${folderName}/$2.js`
 	);
+	outputCache.set(filename, code);
+}
+
+export function clearCompileOutputCache() {
+	outputCache.clear();
+}
 
-	mkdirp(path.dirname(filename));
+export function writeCompileOutputCacheToFile() {
-	fs.writeFileSync(filename, code, 'utf8');
+	for (const [filename, code] of outputCache) {
+		mkdirp(path.dirname(filename));
+		fs.writeFileSync(filename, code, 'utf8');
+	}
+	clearCompileOutputCache();
 }
 
 extensions.forEach(registerExtension);

test/runtime/index.ts

@@ -65,6 +65,7 @@ describe('runtime', () => {
 				accessors: 'accessors' in config ? config.accessors : true
 			};
 
+			register.clearCompileOutputCache();
 			register.clearRequireCache();
 			register.setCompile((config.preserveIdentifiers ? svelte : svelte$).compile);
 			register.setCompileOptions(compileOptions);
@@ -191,11 +192,10 @@ describe('runtime', () => {
 					}
 				}).catch(err => {
 					failed.add(dir);
-					throw err;
-				})
-				.catch(err => {
 					// print a clickable link to open the directory
 					err.stack += `\n\ncmd-click: ${path.relative(process.cwd(), cwd)}/main.svelte`;
+					// saves the compiled output into file system
+					register.writeCompileOutputCacheToFile();
 					throw err;
 				})
 				.then(() => {

test/server-side-rendering/index.ts

@@ -8,7 +8,6 @@ import {
 	loadSvelte,
 	setupHtmlEqual,
 	tryToLoadJson,
-	cleanRequireCache,
 	shouldUpdateExpected
 } from '../helpers';
 import { set_current_component } from '../../internal';
@@ -55,19 +54,18 @@ describe('ssr', () => {
 		(solo ? it.only : it)(dir, (done) => {
 
 			try {
-
 				dir = path.resolve(`${__dirname}/samples`, dir);
 
-				cleanRequireCache();
+				register.clearCompileOutputCache();
-
+				register.clearRequireCache();
 				const compileOptions = {
 					sveltePath,
 					...config.compileOptions,
 					generate: 'ssr',
 					format: 'cjs'
 				};
-
+				register.setCompileOptions(compileOptions);
-				require('../../register')(compileOptions);
+				register.setOutputFolderName('ssr');
 
 				const Component = require(`${dir}/main.svelte`).default;
 
@@ -134,6 +132,7 @@ describe('ssr', () => {
 				done();
 			} catch (err) {
 				err.stack += `\n\ncmd-click: ${path.relative(process.cwd(), dir)}/main.svelte`;
+				register.writeCompileOutputCacheToFile();
 				done(err);
 			} finally {
 				set_current_component(null);
@@ -143,7 +142,7 @@ describe('ssr', () => {
 
 	// duplicate client-side tests, as far as possible
 	runRuntimeSamples('runtime');
-	runRuntimeSamples('runtime-puppeteer');
+	// runRuntimeSamples('runtime-puppeteer');
 
 	function runRuntimeSamples(suite) {
 		fs.readdirSync(`test/${suite}/samples`).forEach(dir => {
@@ -162,50 +161,54 @@ describe('ssr', () => {
 				const cwd = path.resolve(`test/${suite}/samples`, dir);
 
 				delete global.window;
-				register.clearRequireCache();
-				register.setCompileOptions({
-					sveltePath,
-					...config.compileOptions,
-					generate: 'ssr',
-					format: 'cjs'
-				});
 
-				register.setOutputFolderName('ssr');
+				return Promise.resolve()
-
+					.then(() => {
-				try {
+						register.clearCompileOutputCache();
-					if (config.before_test) config.before_test();
+						register.clearRequireCache();
-
+						register.setCompileOptions({
-					const Component = require(`../${suite}/samples/${dir}/main.svelte`).default;
+							sveltePath,
-					const { html } = Component.render(config.props, {
+							...config.compileOptions,
-						store: (config.store !== true) && config.store
+							generate: 'ssr',
-					});
+							format: 'cjs'
-
+						});
-					if (config.ssrHtml) {
+						register.setOutputFolderName('ssr');
-						assert.htmlEqual(html, config.ssrHtml);
+
-					} else if (config.html) {
+						if (config.before_test) config.before_test();
-						assert.htmlEqual(html, config.html);
+
-					}
+						const Component = require(`../${suite}/samples/${dir}/main.svelte`).default;
-
+						const { html } = Component.render(config.props, {
-					if (config.test_ssr) {
+							store: (config.store !== true) && config.store
-						config.test_ssr({ assert });
+						});
-					}
+
+						if (config.ssrHtml) {
+							assert.htmlEqual(html, config.ssrHtml);
+						} else if (config.html) {
+							assert.htmlEqual(html, config.html);
+						}
 
-					if (config.after_test) config.after_test();
+						if (config.test_ssr) {
-				} catch (err) {
+							config.test_ssr({ assert });
-					err.stack += `\n\ncmd-click: ${path.relative(process.cwd(), cwd)}/main.svelte`;
+						}
 
-					if (config.error) {
+						if (config.after_test) config.after_test();
-						if (typeof config.error === 'function') {
+						set_current_component(null);
-							config.error(assert, err);
+					}).catch(err => {
+						if (config.error) {
+							if (typeof config.error === 'function') {
+								config.error(assert, err);
+							} else {
+								assert.equal(err.message, config.error);
+							}
 						} else {
-							assert.equal(err.message, config.error);
+							throw err;
 						}
-					} else {
+					}).catch(err => {
+						err.stack += `\n\ncmd-click: ${path.relative(process.cwd(), cwd)}/main.svelte`;
+						register.writeCompileOutputCacheToFile();
+						set_current_component(null);
 						throw err;
-					}
+					});
-				} finally {
-					set_current_component(null);
-				}
 			});
 		});
 	}