switch things around!

Author: jycouet

packages/addons/_tests/_setup/suite.ts

@@ -124,7 +124,7 @@ export function setupTest<Addons extends AddonMap>(
 		};
 	});
 
-	return { test, variants, prepareServer, flavors };
+	return { test, flavors, prepareServer };
 }
 
 type PrepareServerOptions = {

packages/addons/_tests/all-addons/test.ts

@@ -16,11 +16,12 @@ const defaultOptions = officialAddons.reduce<OptionMap<typeof addons>>((options,
 	return options;
 }, {});
 
-const { test, variants, prepareServer } = setupTest(addons);
+const { test, flavors, prepareServer } = setupTest(addons, {
+	kinds: [{ type: 'default', options: defaultOptions }]
+});
 
-const kitOnly = variants.filter((v) => v.startsWith('kit'));
-test.concurrent.for(kitOnly)('run all addons - %s', async (variant, { page, ...ctx }) => {
-	const cwd = await ctx.run(variant, defaultOptions);
+test.concurrent.for(flavors)('run all addons - $variant', async (flavor, { page, ...ctx }) => {
+	const cwd = ctx.run(flavor);
 
 	const { close } = await prepareServer({ cwd, page });
 	// kill server process when we're done

packages/addons/_tests/devtools-json/test.ts

@@ -4,12 +4,15 @@ import devtoolsJson from '../../devtools-json/index.ts';
 import fs from 'node:fs';
 import path from 'node:path';
 
-const { test, variants } = setupTest({ devtoolsJson }, { browser: false });
+const { test, flavors } = setupTest(
+	{ devtoolsJson },
+	{ kinds: [{ type: 'default', options: { devtoolsJson: {} } }], browser: false }
+);
 
-test.concurrent.for(variants)('default - %s', async (variant, ctx) => {
-	const cwd = await ctx.run(variant, { devtoolsJson: {} });
+test.concurrent.for(flavors)('devtools-json $variant', (flavor, ctx) => {
+	const cwd = ctx.run(flavor);
 
-	const ext = variant.includes('ts') ? 'ts' : 'js';
+	const ext = flavor.variant.includes('ts') ? 'ts' : 'js';
 	const viteFile = path.resolve(cwd, `vite.config.${ext}`);
 	const viteContent = fs.readFileSync(viteFile, 'utf8');
 

packages/addons/_tests/drizzle/test.ts

@@ -9,11 +9,34 @@ import { setupTest } from '../_setup/suite.ts';
 import drizzle from '../../drizzle/index.ts';
 import { pageServer, pageComp } from './fixtures.ts';
 
-const { test, variants, prepareServer } = setupTest({ drizzle });
-
 // only linux is supported for running docker containers in github runners
 const noDocker = process.env.CI && process.platform !== 'linux';
 
+const { test, flavors, prepareServer } = setupTest(
+	{ drizzle },
+	{
+		kinds: [
+			{
+				type: 'better-sqlite3',
+				options: { drizzle: { database: 'sqlite', sqlite: 'better-sqlite3' } }
+			},
+			{
+				type: 'libsql',
+				options: { drizzle: { database: 'sqlite', sqlite: 'libsql' } }
+			},
+			{
+				type: 'mysql2',
+				options: { drizzle: { database: 'mysql', mysql: 'mysql2', docker: true } }
+			},
+			{
+				type: 'postgres.js',
+				options: { drizzle: { database: 'postgresql', postgresql: 'postgres.js', docker: true } }
+			}
+		],
+		filter: (flavor) => flavor.variant.includes('kit')
+	}
+);
+
 beforeAll(() => {
 	if (noDocker) return;
 	const cwd = path.dirname(fileURLToPath(import.meta.url));
@@ -29,41 +52,27 @@ beforeAll(() => {
 	};
 });
 
-const kitOnly = variants.filter((v) => v.includes('kit'));
-const testCases = [
-	{ name: 'better-sqlite3', options: { database: 'sqlite', sqlite: 'better-sqlite3' } },
-	{ name: 'libsql', options: { database: 'sqlite', sqlite: 'libsql' } },
-	{ name: 'mysql2', options: { database: 'mysql', mysql: 'mysql2', docker: true } },
-	{
-		name: 'postgres.js',
-		options: { database: 'postgresql', postgresql: 'postgres.js', docker: true }
-	}
-].flatMap((opts) => kitOnly.map((variant) => ({ ...opts, variant })));
-
-test.concurrent.for(testCases)(
-	'queries database - $name - $variant',
-	async ({ options, variant }, { page, ...ctx }) => {
-		if (options.docker && noDocker) ctx.skip();
-		const cwd = await ctx.run(variant, { drizzle: options as any });
+test.concurrent.for(flavors)('drizzle $kind.type $variant', async (flavor, { page, ...ctx }) => {
+	if (flavor.kind.options.drizzle.docker && noDocker) ctx.skip();
+	const cwd = ctx.run(flavor);
 
-		const ts = variant === 'kit-ts';
-		const drizzleConfig = path.resolve(cwd, `drizzle.config.${ts ? 'ts' : 'js'}`);
-		const content = fs.readFileSync(drizzleConfig, 'utf8').replace(/strict: true[,\s]/, '');
-		fs.writeFileSync(drizzleConfig, content, 'utf8');
+	const ts = flavor.variant === 'kit-ts';
+	const drizzleConfig = path.resolve(cwd, `drizzle.config.${ts ? 'ts' : 'js'}`);
+	const content = fs.readFileSync(drizzleConfig, 'utf8').replace(/strict: true[,\s]/, '');
+	fs.writeFileSync(drizzleConfig, content, 'utf8');
 
-		const routes = path.resolve(cwd, 'src', 'routes');
-		const pagePath = path.resolve(routes, '+page.svelte');
-		fs.writeFileSync(pagePath, pageComp, 'utf8');
+	const routes = path.resolve(cwd, 'src', 'routes');
+	const pagePath = path.resolve(routes, '+page.svelte');
+	fs.writeFileSync(pagePath, pageComp, 'utf8');
 
-		const pageServerPath = path.resolve(routes, `+page.server.${ts ? 'ts' : 'js'}`);
-		fs.writeFileSync(pageServerPath, pageServer, 'utf8');
+	const pageServerPath = path.resolve(routes, `+page.server.${ts ? 'ts' : 'js'}`);
+	fs.writeFileSync(pageServerPath, pageServer, 'utf8');
 
-		const { close } = await prepareServer({ cwd, page }, () => {
-			execSync('npm run db:push', { cwd, stdio: 'pipe' });
-		});
-		// kill server process when we're done
-		ctx.onTestFinished(async () => await close());
+	const { close } = await prepareServer({ cwd, page }, () => {
+		execSync('npm run db:push', { cwd, stdio: 'pipe' });
+	});
+	// kill server process when we're done
+	ctx.onTestFinished(async () => await close());
 
-		expect(page.locator('[data-testid]')).toBeTruthy();
-	}
-);
+	expect(page.locator('[data-testid]')).toBeTruthy();
+});

packages/addons/_tests/eslint/test.ts

@@ -4,16 +4,17 @@ import { execSync } from 'node:child_process';
 import { setupTest } from '../_setup/suite.ts';
 import eslint from '../../eslint/index.ts';
 
-const { test, variants } = setupTest({ eslint }, { browser: false });
+const { test, flavors } = setupTest(
+	{ eslint },
+	{ kinds: [{ type: 'default', options: { eslint: {} } }], browser: false }
+);
 
-test.concurrent.for(variants)('core - %s', async (variant, { expect, ...ctx }) => {
-	const cwd = await ctx.run(variant, { eslint: {} });
+test.concurrent.for(flavors)('eslint $variant', (flavor, { expect, ...ctx }) => {
+	const cwd = ctx.run(flavor);
 
 	const unlintedFile = 'let foo = "";\nif (Boolean(foo)) {\n//\n}';
 	fs.writeFileSync(path.resolve(cwd, 'src/lib/foo.js'), unlintedFile, 'utf8');
 
-	expect(() => execSync('pnpm install', { cwd, stdio: 'pipe' })).not.toThrow();
-
 	expect(() => execSync('pnpm lint', { cwd, stdio: 'pipe' })).toThrow();
 
 	expect(() => execSync('pnpm eslint --fix .', { cwd, stdio: 'pipe' })).not.toThrow();

packages/addons/_tests/lucia/test.ts

@@ -2,19 +2,31 @@ import { expect } from '@playwright/test';
 import { setupTest } from '../_setup/suite.ts';
 import lucia from '../../lucia/index.ts';
 import drizzle from '../../drizzle/index.ts';
+import path from 'node:path';
+import fs from 'node:fs';
 
-const { test, variants, prepareServer } = setupTest({ drizzle, lucia });
+const { test, flavors, prepareServer } = setupTest(
+	{ drizzle, lucia },
+	{
+		kinds: [
+			{
+				type: 'default',
+				options: { drizzle: { database: 'sqlite', sqlite: 'libsql' }, lucia: { demo: true } }
+			}
+		],
+		filter: (flavor) => flavor.variant.includes('kit')
+	}
+);
 
-const kitOnly = variants.filter((v) => v.includes('kit'));
-test.concurrent.for(kitOnly)('core - %s', async (variant, { page, ...ctx }) => {
-	const cwd = await ctx.run(variant, {
-		drizzle: { database: 'sqlite', sqlite: 'libsql' },
-		lucia: { demo: true }
-	});
+test.concurrent.for(flavors)('lucia $variant', async (flavor, { page, ...ctx }) => {
+	const cwd = ctx.run(flavor);
 
 	const { close } = await prepareServer({ cwd, page });
 	// kill server process when we're done
 	ctx.onTestFinished(async () => await close());
 
-	expect(true).toBe(true);
+	const ext = flavor.variant.includes('ts') ? 'ts' : 'js';
+	const filePath = path.resolve(cwd, `src/routes/demo/lucia/+page.server.${ext}`);
+	const fileContent = fs.readFileSync(filePath, 'utf8');
+	expect(fileContent).toContain(`export const actions`);
 });

packages/addons/_tests/mdsvex/test.ts

@@ -8,13 +8,16 @@ import { setupTest } from '../_setup/suite.ts';
 import { svxFile } from './fixtures.ts';
 import mdsvex from '../../mdsvex/index.ts';
 
-const { test, variants, prepareServer } = setupTest({ mdsvex });
+const { test, flavors, prepareServer } = setupTest(
+	{ mdsvex },
+	{ kinds: [{ type: 'default', options: { mdsvex: {} } }] }
+);
 
-test.concurrent.for(variants)('core - %s', async (variant, { page, ...ctx }) => {
-	const cwd = await ctx.run(variant, { mdsvex: {} });
+test.concurrent.for(flavors)('mdsvex $variant', async (flavor, { page, ...ctx }) => {
+	const cwd = ctx.run(flavor);
 
 	// ...add test files
-	addFixture(cwd, variant);
+	addFixture(cwd, flavor.variant);
 
 	const { close } = await prepareServer({ cwd, page });
 	// kill server process when we're done

packages/addons/_tests/paraglide/test.ts

@@ -1,16 +1,31 @@
 import { expect } from '@playwright/test';
 import { setupTest } from '../_setup/suite.ts';
 import paraglide from '../../paraglide/index.ts';
+import fs from 'node:fs';
+import path from 'node:path';
 
-const { test, variants, prepareServer } = setupTest({ paraglide });
+const langs = ['en', 'fr', 'hu'];
 
-const kitOnly = variants.filter((v) => v.includes('kit'));
-test.concurrent.for(kitOnly)('core - %s', async (variant, { page, ...ctx }) => {
-	const cwd = await ctx.run(variant, { paraglide: { demo: true, languageTags: 'en' } });
+const { test, flavors, prepareServer } = setupTest(
+	{ paraglide },
+	{
+		kinds: [
+			{ type: 'default', options: { paraglide: { demo: true, languageTags: langs.join(',') } } }
+		],
+		filter: (flavor) => flavor.variant.includes('kit')
+	}
+);
+
+test.concurrent.for(flavors)('paraglide $variant', async (flavor, { page, ...ctx }) => {
+	const cwd = ctx.run(flavor);
 
 	const { close } = await prepareServer({ cwd, page });
 	// kill server process when we're done
 	ctx.onTestFinished(async () => await close());
 
-	expect(true).toBe(true);
+	for (const lang of langs) {
+		const filePath = path.resolve(cwd, `src/lib/paraglide/messages/${lang}.js`);
+		const fileContent = fs.readFileSync(filePath, 'utf8');
+		expect(fileContent).toContain(`hello_world`);
+	}
 });

packages/addons/_tests/playwright/test.ts

@@ -3,12 +3,15 @@ import path from 'node:path';
 import { setupTest } from '../_setup/suite.ts';
 import playwright from '../../playwright/index.ts';
 
-const { test, variants } = setupTest({ playwright }, { browser: false });
+const { test, flavors } = setupTest(
+	{ playwright },
+	{ kinds: [{ type: 'default', options: { playwright: {} } }], browser: false }
+);
 
-test.concurrent.for(variants)('core - %s', async (variant, { expect, ...ctx }) => {
-	const cwd = await ctx.run(variant, { playwright: {} });
+test.concurrent.for(flavors)('playwright $variant', (flavor, { expect, ...ctx }) => {
+	const cwd = ctx.run(flavor);
 
-	const ext = variant.includes('ts') ? 'ts' : 'js';
+	const ext = flavor.variant.includes('ts') ? 'ts' : 'js';
 	const playwrightConfig = path.resolve(cwd, `playwright.config.${ext}`);
 	const configContent = fs.readFileSync(playwrightConfig, 'utf8');
 

packages/addons/_tests/prettier/test.ts

@@ -9,7 +9,7 @@ const { test, flavors } = setupTest(
 	{ kinds: [{ type: 'default', options: { prettier: {} } }], browser: false }
 );
 
-test.concurrent.for(flavors)('core - %variant', (flavor, { expect, ...ctx }) => {
+test.concurrent.for(flavors)('prettier $variant', (flavor, { expect, ...ctx }) => {
 	const cwd = ctx.run(flavor);
 
 	const unformattedFile = 'const foo = "bar"';