Testing Solid.js code beyond jest

npm i --save-dev solid-register jsdom

# test runner that supports the `-r` register argument$testrunner -r solid-register ...# test runner without support for the `r` argumentnode -r solid-register node_modules/.bin/$testrunner ...

npm -i --save-dev uvu# ornpm -i --save-dev tape

{  "scripts": {    "test": "uvu -r solid-register **/*.test.[tj]s **/*.test.[tj]sx"  }}// or{  "scripts": {    "test": "tape -r solid-register **/*.test.[tj]s **/*.test.[tj]sx"  }}

const loremIpsumWords = 'Lorem ipsum dolor sit amet, consectetur adipisici elit, sed eiusmod tempor incidunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquid ex ea commodi consequat. Quis aute iure reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint obcaecat cupiditat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.'.split(/\s+/);const createLorem = (words: Accessor<number> | number) => {  return createMemo(() => {    const output = [],      len = typeof words === 'function' ? words() : words;    while (output.length <= len) {      output.push(...loremIpsumWords);    }    return output.slice(0, len).join(' ');  });};

import { createEffect, createRoot, createSignal } from "solid-js";import { suite } from 'uvu';import * as assert from 'uvu/assert';const testLorem = suite('createLorem');testLorem('it updates the result when words update', async () => {  const input = [3, 2, 5],  expectedOutput = [    'Lorem ipsum dolor',    'Lorem ipsum',    'Lorem ipsum dolor sit amet'  ];  const actualOutput = await new Promise<string[]>(resolve => createRoot(dispose => {    const [words, setWords] = createSignal(input.shift() ?? 3);    const lorem = createLorem(words);    const output: string[] = [];    createEffect(() => {      // effects are batched, so the escape condition needs      // to run after the output is complete:      if (input.length === 0) {        dispose();        resolve(output);      }      output.push(lorem());      setWords(input.shift() ?? 0);    });  }));  assert.equal(actualOutput, expectedOutput, 'output differs');});testLorem.run();

export type FullscreenDirective = (  ref: HTMLElement,  active: Accessor<boolean | FullscreenOptions>) => void;

const [fs, setFs] = createSignal(false);return <div use:FullscreenDirective={fs}>...</div>;

npm i --save-dev solid-testing-library

import { createSignal, Component, JSX } from 'solid-js';export const MyComponent: Component<JSX.HTMLAttributes<HTMLDivElement>> = (props) => {  const [clicked, setClicked] = createSignal(false);  return <div {...props} role="button" onClick={() => setClicked(true)}>    {clicked() ? 'Test this!' : 'Click me!'}  </div>;};

import { suite } from 'uvu';import * as assert from 'uvu/assert';import { screen, render, fireEvent } from 'solid-testing-library';import { MyComponent } from './my-component';const isInDom = (node: Node): boolean => !!node.parentNode &&   (node.parentNode === document || isInDom(node.parentNode));const test = suite('MyComponent');test('changes text on click', async () => {  await render(() => <MyComponent />);  const component = await screen.findByRole('button', { name: 'Click me!' });  assert.ok(isInDom(component));  fireEvent.click(component);  assert.ok(isInDom(await screen.findByRole('button', { name: 'Test this!' })));});

npm i --save-dev @babel/core @babel/register \@babel/preset-env @babel/preset-typescript \babel-preset-solid

require('@babel/register')({  "presets": [    "@babel/preset-env",    "babel-preset-solid",    "@babel/preset-typescript"  ],  extensions: ['.jsx', '.tsx', '.ts', '.mjs']});

npm i --save-dev ts-jest babel-preset-solid @babel/preset-env

require('ts-node').register({ babelConfig: {  presets: ['babel-preset-solid', '@babel/preset-env']} });

npm initnpm i --save-dev @babel/core @babel/preset-env \@babel/preset-typescript babel-preset-solid \typescript @types/node

// pseudo code to explain the API,// it's a bit more complex in reality:require.extensions[extension: string = '.js'] =  (module: module, filename: string) => {    const content = readFromCache(module)      ?? fs.readFileSync(filename, 'UTF-8');    module._compile(content, filename);  };

export const registerExtension = (  extension: string | string[],  compile: (code: string, filename: string) => string) => {  if (Array.isArray(extension)) {    extension.forEach(ext => registerExtension(ext, compile));  } else {    const modLoad = require.extensions[extension] ?? require.extensions['.js'];    require.extensions[extension] = (module: NodeJS.Module, filename: string) => {      const mod = module as NodeJS.Module  & { _compile: (code) => void };      const modCompile = mod._compile.bind(mod);      mod._compile = (code) => modCompile(compile(code, filename));      modLoad(mod, filename);    }  }};

const { transformSync } = require('@babel/core');const presetEnv = require('@babel/preset-env');const presetSolid = require('babel-preset-solid');const presetTypeScript = require('@babel/preset-typescript');import { registerExtension } from "./register-extension";registerExtension('.jsx', (code, filename) =>  transformSync(code, { filename, presets: [presetEnv, presetSolid] }));registerExtension('.ts', (code, filename) =>  transformSync(code, { filename, presets: [presetEnv, presetTypeScript] }));registerExtension('.tsx', (code, filename) =>  transformSync(code, { filename, presets: [presetEnv, presetSolid, presetTypeScript] }));

const aliases = {  'solid-js\/dist\/server': 'solid-js/dist/dev',  'solid-js\/web\/dist\/server': 'solid-js/web/dist/dev'  // add your own here};const alias_regexes = Object.keys(aliases)  .reduce((regexes, match) => {     regexes[match] = new RegExp(match);    return regexes;  }, {});const filenameAliasing = (filename) =>   Object.entries(aliases).reduce(    (name, [match, replace]) =>       !name && alias_regexes[match].test(filename)      ? filename.replace(alias_regexes[match], replace)      : name,    null) ?? filename;const extensions = ['.js', '.jsx', '.ts', '.tsx'];extensions.forEach(ext => {  const loadMod = require.extensions[ext] ?? require.extensions['.js'];  require.extensions[ext] = (module: NodeJS.Module, filename: string) => {    loadMod(module, filenameAliasing(filename));  };});

import { registerExtension } from "./register-extension";const loadStyles = (filename: string, styles: string) =>  `if (!document.querySelector(\`[data-filename="${filename}"]\`)) {  const div = document.createElement('div');  div.innerHTML = \`<style data-filename="${filename}">${styles}</style>\`;  document.head.appendChild(div.firstChild);  styles.replace(/@import (["'])(.*?)\1/g, (_, __, requiredFile) => {    try {      require(requiredFile);    } catch(e) {      console.warn(\`attempt to @import css \${requiredFile}\` failed); }    }  });}`;const toCamelCase = (name: string): string =>  name.replace(/[-_]+(\w)/g, (_, char) => char.toUpperCase());const getModuleClasses = (styles): Record<string, string> => {  const identifiers: Record<string, string> = {};  styles.replace(    /(?:^|}[\r
\s]*)(\.\w[\w-_]*)|@keyframes\s+([\{\s\r
]+?)[\r
\s]*\{/g,    (_, classname, animation) => {      if (classname) {        identifiers[classname] = identifiers[toCamelCase(classname)] = classname;      }      if (animation) {        identifiers[animation] = identifiers[toCamelCase(animation)] = animation;      }    }  );  return identifiers;};registerExtension('.css', (styles, filename) => loadStyles(filename, styles));registerExtension('.module.css', (styles, filename) =>  `${loadStyles(filename, styles)}module.exports = ${JSON.stringify(getModuleClasses(styles))};`);

import { registerExtension } from "./register-extension";const assetExtensions = ['.svg', '.png', '.gif', '.jpg', '.jpeg'];registerExtension(assetExtensions, (_, filename) =>   `module.exports = "./assets/${filename.replace(/.*\//, '')}";`);

import { JSDOM } from 'jsdom';const { window } = new JSDOM(  '<!doctype html><html><head></head><body></body></html>',  { url: 'https://localhost:3000' });Object.assign(globalThis, window);

import { Window } from 'happy-dom';const window = new Window();window.location.href = 'https://localhost:3000';for (const key of Object.keys(window)) {  if ((globalThis as any)[key] === undefined && key !== 'undefined') {    (globalThis as any)[key] = (window as any)[key];  }}

// prerequisitesconst parseHTML = require('linkedom').parseHTML;const emptyHTML = `<!doctype html><html lang="en">  <head><title></title></head>  <body></body></html>`;// create DOMconst {    window,    document,    Node,    HTMLElement,    requestAnimationFrame,    cancelAnimationFrame,    navigator} = parseHTML(emptyHTML);// put DOM into global contextObject.assign(globalThis, {    window,    document,    Node,    HTMLElement,    requestAnimationFrame,    cancelAnimationFrame,    navigator});