msb-public
/
svelte
mirror of https://github.com/sveltejs/svelte
1
0
Code Issues Projects Releases Wiki Activity

prettierfy test files

Browse Source
pull/618/head
Rich Harris 7 years ago
parent 66e4c7307a
commit 10ecd81734
13 changed files with 557 additions and 468 deletions
Show Stats Download Patch File Download Diff File

26
test/create/index.js
Unescape View File

@ -1,40 +1,40 @@
import deindent from '../../src/utils/deindent.js'; import deindent from "../../src/utils/deindent.js";
import assert from 'assert'; import assert from "assert";
import { svelte } from '../helpers.js'; import { svelte } from "../helpers.js";
describe( 'create', () => { describe("create", () => {
it( 'should return a component constructor', () => { it("should return a component constructor", () => {
const source = deindent` const source = deindent`
<div>{{prop}}</div> <div>{{prop}}</div>
`; `;
const component = svelte.create( source ); const component = svelte.create(source);
assert( component instanceof Function ); assert(component instanceof Function);
}); });
it( 'should throw error when source is invalid ', done => { it("should throw error when source is invalid ", done => {
const source = deindent` const source = deindent`
<div>{{prop}</div> <div>{{prop}</div>
`; `;
const component = svelte.create( source, { const component = svelte.create(source, {
onerror: () => { onerror: () => {
done(); done();
} }
}); });
assert.equal( component, undefined ); assert.equal(component, undefined);
}); });
it( 'should return undefined when source is invalid ', () => { it("should return undefined when source is invalid ", () => {
const source = deindent` const source = deindent`
<div>{{prop}</div> <div>{{prop}</div>
`; `;
const component = svelte.create( source, { const component = svelte.create(source, {
onerror: () => {} onerror: () => {}
}); });
assert.equal( component, undefined ); assert.equal(component, undefined);
}); });
}); });

45
test/css/index.js
Unescape View File

@ -1,36 +1,41 @@
import assert from 'assert'; import assert from "assert";
import * as fs from 'fs'; import * as fs from "fs";
import { svelte } from '../helpers.js'; import { svelte } from "../helpers.js";
function tryRequire ( file ) { function tryRequire(file) {
try { try {
return require( file ).default; return require(file).default;
} catch ( err ) { } catch (err) {
if ( err.code !== 'MODULE_NOT_FOUND' ) throw err; if (err.code !== "MODULE_NOT_FOUND") throw err;
return null; return null;
} }
} }
describe( 'css', () => { describe("css", () => {
fs.readdirSync( 'test/css/samples' ).forEach( dir => { fs.readdirSync("test/css/samples").forEach(dir => {
if ( dir[0] === '.' ) return; if (dir[0] === ".") return;
// add .solo to a sample directory name to only run that test // add .solo to a sample directory name to only run that test
const solo = /\.solo/.test( dir ); const solo = /\.solo/.test(dir);
if ( solo && process.env.CI ) { if (solo && process.env.CI) {
throw new Error( 'Forgot to remove `solo: true` from test' ); throw new Error("Forgot to remove `solo: true` from test");
} }
( solo ? it.only : it )( dir, () => { (solo ? it.only : it)(dir, () => {
const config = tryRequire( `./samples/${dir}/_config.js` ) || {}; const config = tryRequire(`./samples/${dir}/_config.js`) || {};
const input = fs.readFileSync( `test/css/samples/${dir}/input.html`, 'utf-8' ).replace( /\s+$/, '' ); const input = fs
.readFileSync(`test/css/samples/${dir}/input.html`, "utf-8")
.replace(/\s+$/, "");
const actual = svelte.compile( input, config ).css; const actual = svelte.compile(input, config).css;
fs.writeFileSync( `test/css/samples/${dir}/_actual.css`, actual ); fs.writeFileSync(`test/css/samples/${dir}/_actual.css`, actual);
const expected = fs.readFileSync( `test/css/samples/${dir}/expected.css`, 'utf-8' ); const expected = fs.readFileSync(
`test/css/samples/${dir}/expected.css`,
"utf-8"
);
assert.equal( actual.trim(), expected.trim() ); assert.equal(actual.trim(), expected.trim());
}); });
}); });
}); });

142
test/formats/index.js
Unescape View File

@ -1,88 +1,94 @@
import deindent from '../../src/utils/deindent.js'; import deindent from "../../src/utils/deindent.js";
import assert from 'assert'; import assert from "assert";
import { svelte, env, setupHtmlEqual } from '../helpers.js'; import { svelte, env, setupHtmlEqual } from "../helpers.js";
function testAmd ( code, expectedId, dependencies, html ) { function testAmd(code, expectedId, dependencies, html) {
const fn = new Function( 'define', code ); const fn = new Function("define", code);
return env().then( window => { return env().then(window => {
function define ( id, deps, factory ) { function define(id, deps, factory) {
assert.equal( id, expectedId ); assert.equal(id, expectedId);
assert.deepEqual( deps, Object.keys( dependencies ) ); assert.deepEqual(deps, Object.keys(dependencies));
const SvelteComponent = factory( ...Object.keys( dependencies ).map( key => dependencies[ key ] ) ); const SvelteComponent = factory(
...Object.keys(dependencies).map(key => dependencies[key])
);
const main = window.document.body.querySelector( 'main' ); const main = window.document.body.querySelector("main");
const component = new SvelteComponent({ target: main }); const component = new SvelteComponent({ target: main });
assert.htmlEqual( main.innerHTML, html ); assert.htmlEqual(main.innerHTML, html);
component.destroy(); component.destroy();
} }
define.amd = true; define.amd = true;
fn( define ); fn(define);
}); });
} }
function testCjs ( code, dependencyById, html ) { function testCjs(code, dependencyById, html) {
const fn = new Function( 'module', 'exports', 'require', code ); const fn = new Function("module", "exports", "require", code);
return env().then( window => { return env().then(window => {
const module = { exports: {} }; const module = { exports: {} };
const require = id => { const require = id => {
return dependencyById[ id ]; return dependencyById[id];
}; };
fn( module, module.exports, require ); fn(module, module.exports, require);
const SvelteComponent = module.exports; const SvelteComponent = module.exports;
const main = window.document.body.querySelector( 'main' ); const main = window.document.body.querySelector("main");
const component = new SvelteComponent({ target: main }); const component = new SvelteComponent({ target: main });
assert.htmlEqual( main.innerHTML, html ); assert.htmlEqual(main.innerHTML, html);
component.destroy(); component.destroy();
}); });
} }
function testIife ( code, name, globals, html ) { function testIife(code, name, globals, html) {
const fn = new Function( Object.keys( globals ), `${code}\n\nreturn ${name};` ); const fn = new Function(Object.keys(globals), `${code}\n\nreturn ${name};`);
return env().then( window => { return env().then(window => {
const SvelteComponent = fn( ...Object.keys( globals ).map( key => globals[ key ] ) ); const SvelteComponent = fn(
...Object.keys(globals).map(key => globals[key])
);
const main = window.document.body.querySelector( 'main' ); const main = window.document.body.querySelector("main");
const component = new SvelteComponent({ target: main }); const component = new SvelteComponent({ target: main });
assert.htmlEqual( main.innerHTML, html ); assert.htmlEqual(main.innerHTML, html);
component.destroy(); component.destroy();
}); });
} }
function testEval ( code, name, globals, html ) { function testEval(code, name, globals, html) {
const fn = new Function( Object.keys( globals ), `return ${code};` ); const fn = new Function(Object.keys(globals), `return ${code};`);
return env().then( window => { return env().then(window => {
const SvelteComponent = fn( ...Object.keys( globals ).map( key => globals[ key ] ) ); const SvelteComponent = fn(
...Object.keys(globals).map(key => globals[key])
);
const main = window.document.body.querySelector( 'main' ); const main = window.document.body.querySelector("main");
const component = new SvelteComponent({ target: main }); const component = new SvelteComponent({ target: main });
assert.htmlEqual( main.innerHTML, html ); assert.htmlEqual(main.innerHTML, html);
component.destroy(); component.destroy();
}); });
} }
describe( 'formats', () => { describe("formats", () => {
before( setupHtmlEqual ); before(setupHtmlEqual);
describe( 'amd', () => { describe("amd", () => {
it( 'generates an AMD module', () => { it("generates an AMD module", () => {
const source = deindent` const source = deindent`
<div>{{answer}}</div> <div>{{answer}}</div>
@ -97,17 +103,17 @@ describe( 'formats', () => {
</script> </script>
`; `;
const { code } = svelte.compile( source, { const { code } = svelte.compile(source, {
format: 'amd', format: "amd",
amd: { id: 'foo' } amd: { id: "foo" }
}); });
return testAmd( code, 'foo', { answer: 42 }, `<div>42</div>` ); return testAmd(code, "foo", { answer: 42 }, `<div>42</div>`);
}); });
}); });
describe( 'cjs', () => { describe("cjs", () => {
it( 'generates a CommonJS module', () => { it("generates a CommonJS module", () => {
const source = deindent` const source = deindent`
<div>{{answer}}</div> <div>{{answer}}</div>
@ -122,16 +128,16 @@ describe( 'formats', () => {
</script> </script>
`; `;
const { code } = svelte.compile( source, { const { code } = svelte.compile(source, {
format: 'cjs' format: "cjs"
}); });
return testCjs( code, { answer: 42 }, `<div>42</div>` ); return testCjs(code, { answer: 42 }, `<div>42</div>`);
}); });
}); });
describe( 'iife', () => { describe("iife", () => {
it( 'generates a self-executing script', () => { it("generates a self-executing script", () => {
const source = deindent` const source = deindent`
<div>{{answer}}</div> <div>{{answer}}</div>
@ -146,20 +152,20 @@ describe( 'formats', () => {
</script> </script>
`; `;
const { code } = svelte.compile( source, { const { code } = svelte.compile(source, {
format: 'iife', format: "iife",
name: 'Foo', name: "Foo",
globals: { globals: {
answer: 'answer' answer: "answer"
} }
}); });
return testIife( code, 'Foo', { answer: 42 }, `<div>42</div>` ); return testIife(code, "Foo", { answer: 42 }, `<div>42</div>`);
}); });
}); });
describe( 'umd', () => { describe("umd", () => {
it( 'generates a UMD build', () => { it("generates a UMD build", () => {
const source = deindent` const source = deindent`
<div>{{answer}}</div> <div>{{answer}}</div>
@ -174,25 +180,25 @@ describe( 'formats', () => {
</script> </script>
`; `;
const { code } = svelte.compile( source, { const { code } = svelte.compile(source, {
format: 'umd', format: "umd",
name: 'Foo', name: "Foo",
globals: { globals: {
answer: 'answer' answer: "answer"
}, },
amd: { amd: {
id: 'foo' id: "foo"
} }
}); });
return testAmd( code, 'foo', { answer: 42 }, `<div>42</div>` ) return testAmd(code, "foo", { answer: 42 }, `<div>42</div>`)
.then( () => testCjs( code, { answer: 42 }, `<div>42</div>` ) ) .then(() => testCjs(code, { answer: 42 }, `<div>42</div>`))
.then( () => testIife( code, 'Foo', { answer: 42 }, `<div>42</div>` ) ); .then(() => testIife(code, "Foo", { answer: 42 }, `<div>42</div>`));
}); });
}); });
describe( 'eval', () => { describe("eval", () => {
it( 'generates a self-executing script that returns the component on eval', () => { it("generates a self-executing script that returns the component on eval", () => {
const source = deindent` const source = deindent`
<div>{{answer}}</div> <div>{{answer}}</div>
@ -207,14 +213,14 @@ describe( 'formats', () => {
</script> </script>
`; `;
const { code } = svelte.compile( source, { const { code } = svelte.compile(source, {
format: 'eval', format: "eval",
globals: { globals: {
answer: 'answer' answer: "answer"
} }
}); });
return testEval( code, 'Foo', { answer: 42 }, `<div>42</div>` ); return testEval(code, "Foo", { answer: 42 }, `<div>42</div>`);
}); });
}); });
}); });

153
test/helpers.js
Unescape View File

@ -1,137 +1,143 @@
import jsdom from 'jsdom'; import jsdom from "jsdom";
import assert from 'assert'; import assert from "assert";
import * as fs from 'fs'; import * as fs from "fs";
import * as consoleGroup from 'console-group'; import * as consoleGroup from "console-group";
consoleGroup.install(); consoleGroup.install();
import * as sourceMapSupport from 'source-map-support'; import * as sourceMapSupport from "source-map-support";
sourceMapSupport.install(); sourceMapSupport.install();
// for coverage purposes, we need to test source files, // for coverage purposes, we need to test source files,
// but for sanity purposes, we need to test dist files // but for sanity purposes, we need to test dist files
export function loadSvelte ( test ) { export function loadSvelte(test) {
if ( test ) global.__svelte_test = true; if (test) global.__svelte_test = true;
const resolved = process.env.COVERAGE ? const resolved = process.env.COVERAGE
require.resolve( '../src/index.js' ) : ? require.resolve("../src/index.js")
require.resolve( '../compiler/svelte.js' ); : require.resolve("../compiler/svelte.js");
delete require.cache[ resolved ]; delete require.cache[resolved];
return require( resolved ); return require(resolved);
} }
export const svelte = loadSvelte(); export const svelte = loadSvelte();
export function exists ( path ) { export function exists(path) {
try { try {
fs.statSync( path ); fs.statSync(path);
return true; return true;
} catch ( err ) { } catch (err) {
return false; return false;
} }
} }
export function tryToLoadJson ( file ) { export function tryToLoadJson(file) {
try { try {
return JSON.parse( fs.readFileSync( file ) ); return JSON.parse(fs.readFileSync(file));
} catch ( err ) { } catch (err) {
if ( err.code !== 'ENOENT' ) throw err; if (err.code !== "ENOENT") throw err;
return null; return null;
} }
} }
export function tryToReadFile ( file ) { export function tryToReadFile(file) {
try { try {
return fs.readFileSync( file, 'utf-8' ); return fs.readFileSync(file, "utf-8");
} catch ( err ) { } catch (err) {
if ( err.code !== 'ENOENT' ) throw err; if (err.code !== "ENOENT") throw err;
return null; return null;
} }
} }
export function env () { export function env() {
return new Promise( ( fulfil, reject ) => { return new Promise((fulfil, reject) => {
jsdom.env( '<main></main>', ( err, window ) => { jsdom.env("<main></main>", (err, window) => {
if ( err ) { if (err) {
reject( err ); reject(err);
} else { } else {
global.document = window.document; global.document = window.document;
fulfil( window ); fulfil(window);
} }
}); });
}); });
} }
function cleanChildren ( node ) { function cleanChildren(node) {
let previous = null; let previous = null;
[ ...node.childNodes ].forEach( child => { [...node.childNodes].forEach(child => {
if ( child.nodeType === 8 ) { if (child.nodeType === 8) {
// comment // comment
node.removeChild( child ); node.removeChild(child);
return; return;
} }
if ( child.nodeType === 3 ) { if (child.nodeType === 3) {
if ( node.namespaceURI === 'http://www.w3.org/2000/svg' && node.tagName !== 'text' && node.tagName !== 'tspan' ) { if (
node.removeChild( child ); node.namespaceURI === "http://www.w3.org/2000/svg" &&
node.tagName !== "text" &&
node.tagName !== "tspan"
) {
node.removeChild(child);
} }
child.data = child.data.replace( /\s{2,}/, '\n' ); child.data = child.data.replace(/\s{2,}/, "\n");
// text // text
if ( previous && previous.nodeType === 3 ) { if (previous && previous.nodeType === 3) {
previous.data += child.data; previous.data += child.data;
previous.data = previous.data.replace( /\s{2,}/, '\n' ); previous.data = previous.data.replace(/\s{2,}/, "\n");
node.removeChild( child ); node.removeChild(child);
child = previous; child = previous;
} }
} } else {
cleanChildren(child);
else {
cleanChildren( child );
} }
previous = child; previous = child;
}); });
// collapse whitespace // collapse whitespace
if ( node.firstChild && node.firstChild.nodeType === 3 ) { if (node.firstChild && node.firstChild.nodeType === 3) {
node.firstChild.data = node.firstChild.data.replace( /^\s+/, '' ); node.firstChild.data = node.firstChild.data.replace(/^\s+/, "");
if ( !node.firstChild.data ) node.removeChild( node.firstChild ); if (!node.firstChild.data) node.removeChild(node.firstChild);
} }
if ( node.lastChild && node.lastChild.nodeType === 3 ) { if (node.lastChild && node.lastChild.nodeType === 3) {
node.lastChild.data = node.lastChild.data.replace( /\s+$/, '' ); node.lastChild.data = node.lastChild.data.replace(/\s+$/, "");
if ( !node.lastChild.data ) node.removeChild( node.lastChild ); if (!node.lastChild.data) node.removeChild(node.lastChild);
} }
} }
export function setupHtmlEqual () { export function setupHtmlEqual() {
return env().then( window => { return env().then(window => {
assert.htmlEqual = ( actual, expected, message ) => { assert.htmlEqual = (actual, expected, message) => {
window.document.body.innerHTML = actual.replace( />[\s\r\n]+</g, '><' ).trim(); window.document.body.innerHTML = actual
cleanChildren( window.document.body, '' ); .replace(/>[\s\r\n]+</g, "><")
.trim();
cleanChildren(window.document.body, "");
actual = window.document.body.innerHTML; actual = window.document.body.innerHTML;
window.document.body.innerHTML = expected.replace( />[\s\r\n]+</g, '><' ).trim(); window.document.body.innerHTML = expected
cleanChildren( window.document.body, '' ); .replace(/>[\s\r\n]+</g, "><")
.trim();
cleanChildren(window.document.body, "");
expected = window.document.body.innerHTML; expected = window.document.body.innerHTML;
assert.deepEqual( actual, expected, message ); assert.deepEqual(actual, expected, message);
}; };
}); });
} }
export function loadConfig ( file ) { export function loadConfig(file) {
try { try {
const resolved = require.resolve( file ); const resolved = require.resolve(file);
delete require.cache[ resolved ]; delete require.cache[resolved];
return require( resolved ).default; return require(resolved).default;
} catch ( err ) { } catch (err) {
if ( err.code === 'E_NOT_FOUND' ) { if (err.code === "E_NOT_FOUND") {
return {}; return {};
} }
@ -139,11 +145,16 @@ export function loadConfig ( file ) {
} }
} }
export function addLineNumbers ( code ) { export function addLineNumbers(code) {
return code.split( '\n' ).map( ( line, i ) => { return code
i = String( i + 1 ); .split("\n")
while ( i.length < 3 ) i = ` ${i}`; .map((line, i) => {
i = String(i + 1);
return `${i}: ${line.replace( /^\t+/, match => match.split( '\t' ).join( ' ' ) )}`; while (i.length < 3) i = ` ${i}`;
}).join( '\n' );
return `${i}: ${line.replace(/^\t+/, match =>
match.split("\t").join(" ")
)}`;
})
.join("\n");
} }

72
test/js/index.js
Unescape View File

@ -1,60 +1,68 @@
import assert from 'assert'; import assert from "assert";
import * as fs from 'fs'; import * as fs from "fs";
import * as path from 'path'; import * as path from "path";
import { rollup } from 'rollup'; import { rollup } from "rollup";
import { svelte } from '../helpers.js'; import { svelte } from "../helpers.js";
describe( 'js', () => { describe("js", () => {
fs.readdirSync( 'test/js/samples' ).forEach( dir => { fs.readdirSync("test/js/samples").forEach(dir => {
if ( dir[0] === '.' ) return; if (dir[0] === ".") return;
// add .solo to a sample directory name to only run that test // add .solo to a sample directory name to only run that test
const solo = /\.solo/.test( dir ); const solo = /\.solo/.test(dir);
if ( solo && process.env.CI ) { if (solo && process.env.CI) {
throw new Error( 'Forgot to remove `solo: true` from test' ); throw new Error("Forgot to remove `solo: true` from test");
} }
( solo ? it.only : it )( dir, () => { (solo ? it.only : it)(dir, () => {
dir = path.resolve( 'test/js/samples', dir ); dir = path.resolve("test/js/samples", dir);
const input = fs.readFileSync( `${dir}/input.html`, 'utf-8' ).replace( /\s+$/, '' ); const input = fs
.readFileSync(`${dir}/input.html`, "utf-8")
.replace(/\s+$/, "");
let actual; let actual;
try { try {
actual = svelte.compile( input, { actual = svelte.compile(input, {
shared: true shared: true
}).code; }).code;
} catch ( err ) { } catch (err) {
console.log( err.frame ); console.log(err.frame);
throw err; throw err;
} }
fs.writeFileSync( `${dir}/_actual.js`, actual ); fs.writeFileSync(`${dir}/_actual.js`, actual);
const expected = fs.readFileSync( `${dir}/expected.js`, 'utf-8' ); const expected = fs.readFileSync(`${dir}/expected.js`, "utf-8");
const expectedBundle = fs.readFileSync( `${dir}/expected-bundle.js`, 'utf-8' ); const expectedBundle = fs.readFileSync(
`${dir}/expected-bundle.js`,
"utf-8"
);
return rollup({ return rollup({
entry: `${dir}/_actual.js`, entry: `${dir}/_actual.js`,
plugins: [{ plugins: [
resolveId ( importee, importer ) { {
if ( !importer ) return importee; resolveId(importee, importer) {
if ( importee === 'svelte/shared.js' ) return path.resolve('shared.js'); if (!importer) return importee;
return null; if (importee === "svelte/shared.js")
return path.resolve("shared.js");
return null;
}
} }
}] ]
}).then(bundle => { }).then(bundle => {
const actualBundle = bundle.generate({ format: 'es' }).code; const actualBundle = bundle.generate({ format: "es" }).code;
fs.writeFileSync( `${dir}/_actual-bundle.js`, actualBundle ); fs.writeFileSync(`${dir}/_actual-bundle.js`, actualBundle);
assert.equal( assert.equal(
actual.trim().replace( /^\s+$/gm, '' ), actual.trim().replace(/^\s+$/gm, ""),
expected.trim().replace( /^\s+$/gm, '' ) expected.trim().replace(/^\s+$/gm, "")
); );
assert.equal( assert.equal(
actualBundle.trim().replace( /^\s+$/gm, '' ), actualBundle.trim().replace(/^\s+$/gm, ""),
expectedBundle.trim().replace( /^\s+$/gm, '' ) expectedBundle.trim().replace(/^\s+$/gm, "")
); );
}); });
}); });

15
test/js/update.js
Unescape View File

@ -1,10 +1,13 @@
// this file will replace all the expected.js and expected-bundle.js files with // this file will replace all the expected.js and expected-bundle.js files with
// their _actual equivalents. Only use it when you're sure that you haven't // their _actual equivalents. Only use it when you're sure that you haven't
// broken anything! // broken anything!
const fs = require('fs'); const fs = require("fs");
const glob = require('glob'); const glob = require("glob");
glob.sync('samples/*/_actual*', {cwd: __dirname}).forEach(file => { glob.sync("samples/*/_actual*", { cwd: __dirname }).forEach(file => {
const actual = fs.readFileSync(`${__dirname}/${file}`, 'utf-8'); const actual = fs.readFileSync(`${__dirname}/${file}`, "utf-8");
fs.writeFileSync(`${__dirname}/${file.replace('_actual', 'expected')}`, actual); fs.writeFileSync(
}); `${__dirname}/${file.replace("_actual", "expected")}`,
actual
);
});

75
test/parser/index.js
Unescape View File

@ -1,61 +1,68 @@
import assert from 'assert'; import assert from "assert";
import * as fs from 'fs'; import * as fs from "fs";
import { svelte } from '../helpers.js'; import { svelte } from "../helpers.js";
describe( 'parse', () => { describe("parse", () => {
fs.readdirSync( 'test/parser/samples' ).forEach( dir => { fs.readdirSync("test/parser/samples").forEach(dir => {
if ( dir[0] === '.' ) return; if (dir[0] === ".") return;
// add .solo to a sample directory name to only run that test // add .solo to a sample directory name to only run that test
const solo = /\.solo$/.test( dir ); const solo = /\.solo$/.test(dir);
if ( solo && process.env.CI ) { if (solo && process.env.CI) {
throw new Error( `Forgot to remove '.solo' from test parser/samples/${dir}` ); throw new Error(
`Forgot to remove '.solo' from test parser/samples/${dir}`
);
} }
( solo ? it.only : it )( dir, () => { (solo ? it.only : it)(dir, () => {
const input = fs.readFileSync( `test/parser/samples/${dir}/input.html`, 'utf-8' ).replace( /\s+$/, '' ); const input = fs
.readFileSync(`test/parser/samples/${dir}/input.html`, "utf-8")
.replace(/\s+$/, "");
try { try {
const actual = svelte.parse( input ); const actual = svelte.parse(input);
fs.writeFileSync( `test/parser/samples/${dir}/_actual.json`, JSON.stringify( actual, null, '\t' ) ); fs.writeFileSync(
const expected = require( `./samples/${dir}/output.json` ); `test/parser/samples/${dir}/_actual.json`,
JSON.stringify(actual, null, "\t")
);
const expected = require(`./samples/${dir}/output.json`);
assert.deepEqual( actual.html, expected.html ); assert.deepEqual(actual.html, expected.html);
assert.deepEqual( actual.css, expected.css ); assert.deepEqual(actual.css, expected.css);
assert.deepEqual( actual.js, expected.js ); assert.deepEqual(actual.js, expected.js);
} catch ( err ) { } catch (err) {
if ( err.name !== 'ParseError' ) throw err; if (err.name !== "ParseError") throw err;
try { try {
const expected = require( `./samples/${dir}/error.json` ); const expected = require(`./samples/${dir}/error.json`);
assert.equal( err.message, expected.message ); assert.equal(err.message, expected.message);
assert.deepEqual( err.loc, expected.loc ); assert.deepEqual(err.loc, expected.loc);
assert.equal( err.pos, expected.pos ); assert.equal(err.pos, expected.pos);
} catch ( err2 ) { } catch (err2) {
throw err2.code === 'MODULE_NOT_FOUND' ? err : err2; throw err2.code === "MODULE_NOT_FOUND" ? err : err2;
} }
} }
}); });
}); });
it( 'handles errors with options.onerror', () => { it("handles errors with options.onerror", () => {
let errored = false; let errored = false;
svelte.compile( `<h1>unclosed`, { svelte.compile(`<h1>unclosed`, {
onerror ( err ) { onerror(err) {
errored = true; errored = true;
assert.equal( err.message, `<h1> was left open` ); assert.equal(err.message, `<h1> was left open`);
} }
}); });
assert.ok( errored ); assert.ok(errored);
}); });
it( 'throws without options.onerror', () => { it("throws without options.onerror", () => {
assert.throws( () => { assert.throws(() => {
svelte.compile( `<h1>unclosed` ); svelte.compile(`<h1>unclosed`);
}, /<h1> was left open/ ); }, /<h1> was left open/);
}); });
}); });

189
test/runtime/index.js
Unescape View File

@ -1,56 +1,65 @@
import spaces from '../../src/utils/spaces.js'; import spaces from "../../src/utils/spaces.js";
import assert from 'assert'; import assert from "assert";
import * as path from 'path'; import * as path from "path";
import * as fs from 'fs'; import * as fs from "fs";
import * as acorn from 'acorn'; import * as acorn from "acorn";
import * as babel from 'babel-core'; import * as babel from "babel-core";
import { transitionManager } from '../../shared.js'; import { transitionManager } from "../../shared.js";
import { addLineNumbers, loadConfig, loadSvelte, env, setupHtmlEqual } from '../helpers.js'; import {
addLineNumbers,
loadConfig,
loadSvelte,
env,
setupHtmlEqual
} from "../helpers.js";
let svelte; let svelte;
let showCompiledCode = false; let showCompiledCode = false;
let compileOptions = null; let compileOptions = null;
function getName ( filename ) { function getName(filename) {
const base = path.basename( filename ).replace( '.html', '' ); const base = path.basename(filename).replace(".html", "");
return base[0].toUpperCase() + base.slice( 1 ); return base[0].toUpperCase() + base.slice(1);
} }
const nodeVersionMatch = /^v(\d)/.exec( process.version ); const nodeVersionMatch = /^v(\d)/.exec(process.version);
const legacy = +nodeVersionMatch[1] < 6; const legacy = +nodeVersionMatch[1] < 6;
const babelrc = require( '../../package.json' ).babel; const babelrc = require("../../package.json").babel;
require.extensions[ '.html' ] = function ( module, filename ) { require.extensions[".html"] = function(module, filename) {
const options = Object.assign({ filename, name: getName( filename ) }, compileOptions ); const options = Object.assign(
let { code } = svelte.compile( fs.readFileSync( filename, 'utf-8' ), options ); { filename, name: getName(filename) },
compileOptions
);
let { code } = svelte.compile(fs.readFileSync(filename, "utf-8"), options);
if ( showCompiledCode ) console.log( addLineNumbers( code ) ); // eslint-disable-line no-console if (showCompiledCode) console.log(addLineNumbers(code)); // eslint-disable-line no-console
if ( legacy ) code = babel.transform( code, babelrc ).code; if (legacy) code = babel.transform(code, babelrc).code;
return module._compile( code, filename ); return module._compile(code, filename);
}; };
const Object_assign = Object.assign; const Object_assign = Object.assign;
describe( 'runtime', () => { describe("runtime", () => {
before( () => { before(() => {
svelte = loadSvelte( true ); svelte = loadSvelte(true);
return setupHtmlEqual(); return setupHtmlEqual();
}); });
function runTest ( dir, shared ) { function runTest(dir, shared) {
if ( dir[0] === '.' ) return; if (dir[0] === ".") return;
const config = loadConfig( `./runtime/samples/${dir}/_config.js` ); const config = loadConfig(`./runtime/samples/${dir}/_config.js`);
if ( config.solo && process.env.CI ) { if (config.solo && process.env.CI) {
throw new Error( 'Forgot to remove `solo: true` from test' ); throw new Error("Forgot to remove `solo: true` from test");
} }
( config.skip ? it.skip : config.solo ? it.only : it )( dir, () => { (config.skip ? it.skip : config.solo ? it.only : it)(dir, () => {
let compiled; let compiled;
showCompiledCode = config.show; showCompiledCode = config.show;
@ -59,11 +68,14 @@ describe( 'runtime', () => {
compileOptions.dev = config.dev; compileOptions.dev = config.dev;
try { try {
const source = fs.readFileSync( `test/runtime/samples/${dir}/main.html`, 'utf-8' ); const source = fs.readFileSync(
compiled = svelte.compile( source, compileOptions ); `test/runtime/samples/${dir}/main.html`,
} catch ( err ) { "utf-8"
if ( config.compileError ) { );
config.compileError( err ); compiled = svelte.compile(source, compileOptions);
} catch (err) {
if (config.compileError) {
config.compileError(err);
return; return;
} else { } else {
throw err; throw err;
@ -73,28 +85,33 @@ describe( 'runtime', () => {
const { code } = compiled; const { code } = compiled;
// check that no ES2015+ syntax slipped in // check that no ES2015+ syntax slipped in
if ( !config.allowES2015 ) { if (!config.allowES2015) {
try { try {
const startIndex = code.indexOf( 'function create_main_fragment' ); // may change! const startIndex = code.indexOf("function create_main_fragment"); // may change!
if ( startIndex === -1 ) throw new Error( 'missing create_main_fragment' ); if (startIndex === -1)
const es5 = spaces( startIndex ) + code.slice( startIndex ).replace( /export default .+/, '' ); throw new Error("missing create_main_fragment");
acorn.parse( es5, { ecmaVersion: 5 }); const es5 =
} catch ( err ) { spaces(startIndex) +
if ( !config.show ) console.log( addLineNumbers( code ) ); // eslint-disable-line no-console code.slice(startIndex).replace(/export default .+/, "");
acorn.parse(es5, { ecmaVersion: 5 });
} catch (err) {
if (!config.show) console.log(addLineNumbers(code)); // eslint-disable-line no-console
throw err; throw err;
} }
} }
Object.keys( require.cache ).filter( x => x.endsWith( '.html' ) ).forEach( file => { Object.keys(require.cache)
delete require.cache[ file ]; .filter(x => x.endsWith(".html"))
}); .forEach(file => {
delete require.cache[file];
});
let SvelteComponent; let SvelteComponent;
let unintendedError = null; let unintendedError = null;
return env() return env()
.then( window => { .then(window => {
// set of hacks to support transition tests // set of hacks to support transition tests
transitionManager.running = false; transitionManager.running = false;
transitionManager.transitions = []; transitionManager.transitions = [];
@ -104,14 +121,14 @@ describe( 'runtime', () => {
callback: null, callback: null,
tick: now => { tick: now => {
raf.time = now; raf.time = now;
if ( raf.callback ) raf.callback(); if (raf.callback) raf.callback();
} }
}; };
window.performance = { now: () => raf.time }; window.performance = { now: () => raf.time };
global.requestAnimationFrame = cb => { global.requestAnimationFrame = cb => {
let called = false; let called = false;
raf.callback = () => { raf.callback = () => {
if ( !called ) { if (!called) {
called = true; called = true;
cb(); cb();
} }
@ -121,14 +138,16 @@ describe( 'runtime', () => {
global.window = window; global.window = window;
try { try {
SvelteComponent = require( `./samples/${dir}/main.html` ).default; SvelteComponent = require(`./samples/${dir}/main.html`).default;
} catch ( err ) { } catch (err) {
if ( !config.show ) console.log( addLineNumbers( code ) ); // eslint-disable-line no-console if (!config.show) console.log(addLineNumbers(code)); // eslint-disable-line no-console
throw err; throw err;
} }
Object.assign = () => { Object.assign = () => {
throw new Error( 'cannot use Object.assign in generated code, as it is not supported everywhere' ); throw new Error(
"cannot use Object.assign in generated code, as it is not supported everywhere"
);
}; };
global.window = window; global.window = window;
@ -136,12 +155,12 @@ describe( 'runtime', () => {
// Put the constructor on window for testing // Put the constructor on window for testing
window.SvelteComponent = SvelteComponent; window.SvelteComponent = SvelteComponent;
const target = window.document.querySelector( 'main' ); const target = window.document.querySelector("main");
const warnings = []; const warnings = [];
const warn = console.warn; const warn = console.warn;
console.warn = warning => { console.warn = warning => {
warnings.push( warning ); warnings.push(warning);
}; };
const component = new SvelteComponent({ const component = new SvelteComponent({
@ -153,70 +172,70 @@ describe( 'runtime', () => {
console.warn = warn; console.warn = warn;
if ( config.error ) { if (config.error) {
unintendedError = true; unintendedError = true;
throw new Error( 'Expected a runtime error' ); throw new Error("Expected a runtime error");
} }
if ( config.warnings ) { if (config.warnings) {
assert.deepEqual( warnings, config.warnings ); assert.deepEqual(warnings, config.warnings);
} else if ( warnings.length ) { } else if (warnings.length) {
unintendedError = true; unintendedError = true;
throw new Error( 'Received unexpected warnings' ); throw new Error("Received unexpected warnings");
} }
if ( config.html ) { if (config.html) {
assert.htmlEqual( target.innerHTML, config.html ); assert.htmlEqual(target.innerHTML, config.html);
} }
Object.assign = Object_assign; Object.assign = Object_assign;
if ( config.test ) { if (config.test) {
config.test( assert, component, target, window, raf ); config.test(assert, component, target, window, raf);
} else { } else {
component.destroy(); component.destroy();
assert.equal( target.innerHTML, '' ); assert.equal(target.innerHTML, "");
} }
}) })
.catch( err => { .catch(err => {
Object.assign = Object_assign; Object.assign = Object_assign;
if ( config.error && !unintendedError ) { if (config.error && !unintendedError) {
config.error( assert, err ); config.error(assert, err);
} } else {
if (!config.show) console.log(addLineNumbers(code)); // eslint-disable-line no-console
else {
if ( !config.show ) console.log( addLineNumbers( code ) ); // eslint-disable-line no-console
throw err; throw err;
} }
}); });
}); });
} }
describe( 'inline helpers', () => { describe("inline helpers", () => {
fs.readdirSync( 'test/runtime/samples' ).forEach( dir => { fs.readdirSync("test/runtime/samples").forEach(dir => {
runTest( dir, null ); runTest(dir, null);
}); });
}); });
const shared = path.resolve( 'shared.js' ); const shared = path.resolve("shared.js");
describe( 'shared helpers', () => { describe("shared helpers", () => {
fs.readdirSync( 'test/runtime/samples' ).forEach( dir => { fs.readdirSync("test/runtime/samples").forEach(dir => {
runTest( dir, shared ); runTest(dir, shared);
}); });
}); });
it( 'fails if options.target is missing in dev mode', () => { it("fails if options.target is missing in dev mode", () => {
const { code } = svelte.compile( `<div></div>`, { const { code } = svelte.compile(`<div></div>`, {
format: 'iife', format: "iife",
name: 'SvelteComponent', name: "SvelteComponent",
dev: true dev: true
}); });
const SvelteComponent = eval( `(function () { ${code}; return SvelteComponent; }())` ); const SvelteComponent = eval(
`(function () { ${code}; return SvelteComponent; }())`
);
assert.throws( () => { assert.throws(() => {
new SvelteComponent(); new SvelteComponent();
}, /'target' is a required option/ ); }, /'target' is a required option/);
}); });
}); });

142
test/server-side-rendering/index.js
Unescape View File

@ -1,128 +1,140 @@
import assert from 'assert'; import assert from "assert";
import * as fs from 'fs'; import * as fs from "fs";
import * as path from 'path'; import * as path from "path";
import { addLineNumbers, loadConfig, setupHtmlEqual, svelte, tryToLoadJson } from '../helpers.js'; import {
addLineNumbers,
function tryToReadFile ( file ) { loadConfig,
setupHtmlEqual,
svelte,
tryToLoadJson
} from "../helpers.js";
function tryToReadFile(file) {
try { try {
return fs.readFileSync( file, 'utf-8' ); return fs.readFileSync(file, "utf-8");
} catch ( err ) { } catch (err) {
if ( err.code !== 'ENOENT' ) throw err; if (err.code !== "ENOENT") throw err;
return null; return null;
} }
} }
function capitalize ( str ) { function capitalize(str) {
return str[0].toUpperCase() + str.slice( 1 ); return str[0].toUpperCase() + str.slice(1);
} }
describe( 'ssr', () => { describe("ssr", () => {
before( () => { before(() => {
require( process.env.COVERAGE ? require(process.env.COVERAGE
'../../src/server-side-rendering/register.js' : ? "../../src/server-side-rendering/register.js"
'../../ssr/register' ); : "../../ssr/register");
return setupHtmlEqual(); return setupHtmlEqual();
}); });
fs.readdirSync( 'test/server-side-rendering/samples' ).forEach( dir => { fs.readdirSync("test/server-side-rendering/samples").forEach(dir => {
if ( dir[0] === '.' ) return; if (dir[0] === ".") return;
// add .solo to a sample directory name to only run that test, or // add .solo to a sample directory name to only run that test, or
// .show to always show the output. or both // .show to always show the output. or both
const solo = /\.solo/.test( dir ); const solo = /\.solo/.test(dir);
let show = /\.show/.test( dir ); let show = /\.show/.test(dir);
if ( solo && process.env.CI ) { if (solo && process.env.CI) {
throw new Error( 'Forgot to remove `solo: true` from test' ); throw new Error("Forgot to remove `solo: true` from test");
} }
( solo ? it.only : it )( dir, () => { (solo ? it.only : it)(dir, () => {
dir = path.resolve( 'test/server-side-rendering/samples', dir ); dir = path.resolve("test/server-side-rendering/samples", dir);
const component = require( `${dir}/main.html` ); const component = require(`${dir}/main.html`);
const expectedHtml = tryToReadFile( `${dir}/_expected.html` ); const expectedHtml = tryToReadFile(`${dir}/_expected.html`);
const expectedCss = tryToReadFile( `${dir}/_expected.css` ) || ''; const expectedCss = tryToReadFile(`${dir}/_expected.css`) || "";
const data = tryToLoadJson( `${dir}/data.json` ); const data = tryToLoadJson(`${dir}/data.json`);
let html; let html;
let css; let css;
let error; let error;
try { try {
html = component.render( data ); html = component.render(data);
css = component.renderCss().css; css = component.renderCss().css;
} catch ( e ) { } catch (e) {
show = true; show = true;
error = e; error = e;
} }
if ( show ) { if (show) {
fs.readdirSync( dir ).forEach( file => { fs.readdirSync(dir).forEach(file => {
if ( file[0] === '_' ) return; if (file[0] === "_") return;
const source = fs.readFileSync( `${dir}/${file}`, 'utf-8' ); const source = fs.readFileSync(`${dir}/${file}`, "utf-8");
const name = capitalize( file.slice( 0, -path.extname( file ).length ) ); const name = capitalize(file.slice(0, -path.extname(file).length));
const { code } = svelte.compile( source, { generate: 'ssr', name }); const { code } = svelte.compile(source, { generate: "ssr", name });
console.group( file ); console.group(file);
console.log( addLineNumbers( code ) ); console.log(addLineNumbers(code));
console.groupEnd(); console.groupEnd();
}); });
} }
if ( error ) throw error; if (error) throw error;
fs.writeFileSync( `${dir}/_actual.html`, html ); fs.writeFileSync(`${dir}/_actual.html`, html);
if ( css ) fs.writeFileSync( `${dir}/_actual.css`, css ); if (css) fs.writeFileSync(`${dir}/_actual.css`, css);
assert.htmlEqual( html, expectedHtml ); assert.htmlEqual(html, expectedHtml);
assert.equal( css.replace( /^\s+/gm, '' ), expectedCss.replace( /^\s+/gm, '' ) ); assert.equal(
css.replace(/^\s+/gm, ""),
expectedCss.replace(/^\s+/gm, "")
);
}); });
}); });
// duplicate client-side tests, as far as possible // duplicate client-side tests, as far as possible
fs.readdirSync( 'test/runtime/samples' ).forEach( dir => { fs.readdirSync("test/runtime/samples").forEach(dir => {
if ( dir[0] === '.' ) return; if (dir[0] === ".") return;
const config = loadConfig( `./runtime/samples/${dir}/_config.js` ); const config = loadConfig(`./runtime/samples/${dir}/_config.js`);
if ( config.solo && process.env.CI ) { if (config.solo && process.env.CI) {
throw new Error( 'Forgot to remove `solo: true` from test' ); throw new Error("Forgot to remove `solo: true` from test");
} }
if ( config['skip-ssr'] ) return; if (config["skip-ssr"]) return;
( config.skip ? it.skip : config.solo ? it.only : it )( dir, () => { (config.skip ? it.skip : config.solo ? it.only : it)(dir, () => {
let compiled; let compiled;
try { try {
const source = fs.readFileSync( `test/runtime/samples/${dir}/main.html`, 'utf-8' ); const source = fs.readFileSync(
compiled = svelte.compile( source, { generate: 'ssr' }); `test/runtime/samples/${dir}/main.html`,
} catch ( err ) { "utf-8"
if ( config.compileError ) { );
config.compileError( err ); compiled = svelte.compile(source, { generate: "ssr" });
} catch (err) {
if (config.compileError) {
config.compileError(err);
return; return;
} else { } else {
throw err; throw err;
} }
} }
fs.readdirSync( `test/runtime/samples/${dir}` ).forEach( file => { fs.readdirSync(`test/runtime/samples/${dir}`).forEach(file => {
const resolved = require.resolve( `../runtime/samples/${dir}/${file}` ); const resolved = require.resolve(`../runtime/samples/${dir}/${file}`);
delete require.cache[ resolved ]; delete require.cache[resolved];
}); });
const component = require( `../runtime/samples/${dir}/main.html` ); const component = require(`../runtime/samples/${dir}/main.html`);
let html; let html;
try { try {
html = component.render( config.data ); html = component.render(config.data);
if ( config.html ) { if (config.html) {
assert.htmlEqual( html, config.html ); assert.htmlEqual(html, config.html);
} }
} catch ( err ) { } catch (err) {
console.log( addLineNumbers( compiled.code ) ); // eslint-disable-line no-console console.log(addLineNumbers(compiled.code)); // eslint-disable-line no-console
throw err; throw err;
} }
}); });

12
test/setup.js
Unescape View File

@ -1,9 +1,9 @@
const nodeVersionMatch = /^v(\d)/.exec( process.version ); const nodeVersionMatch = /^v(\d)/.exec(process.version);
const legacy = +nodeVersionMatch[1] < 6; const legacy = +nodeVersionMatch[1] < 6;
const babelrc = require( '../package.json' ).babel; const babelrc = require("../package.json").babel;
if ( legacy ) { if (legacy) {
require( 'babel-register' )( babelrc ); require("babel-register")(babelrc);
} else { } else {
require( 'reify' ); require("reify");
} }

58
test/sourcemaps/index.js
Unescape View File

@ -1,41 +1,51 @@
import * as fs from 'fs'; import * as fs from "fs";
import * as path from 'path'; import * as path from "path";
import assert from 'assert'; import assert from "assert";
import { svelte, exists } from '../helpers.js'; import { svelte, exists } from "../helpers.js";
import { SourceMapConsumer } from 'source-map'; import { SourceMapConsumer } from "source-map";
import { getLocator } from 'locate-character'; import { getLocator } from "locate-character";
describe( 'sourcemaps', () => { describe("sourcemaps", () => {
fs.readdirSync( 'test/sourcemaps/samples' ).forEach( dir => { fs.readdirSync("test/sourcemaps/samples").forEach(dir => {
if ( dir[0] === '.' ) return; if (dir[0] === ".") return;
const solo = exists( `test/sourcemaps/samples/${dir}/solo` ); const solo = exists(`test/sourcemaps/samples/${dir}/solo`);
if ( solo && process.env.CI ) { if (solo && process.env.CI) {
throw new Error( 'Forgot to remove `solo: true` from test' ); throw new Error("Forgot to remove `solo: true` from test");
} }
( solo ? it.only : it )( dir, () => { (solo ? it.only : it)(dir, () => {
const filename = path.resolve( `test/sourcemaps/samples/${dir}/input.html` ); const filename = path.resolve(
const outputFilename = path.resolve( `test/sourcemaps/samples/${dir}/output.js` ); `test/sourcemaps/samples/${dir}/input.html`
);
const outputFilename = path.resolve(
`test/sourcemaps/samples/${dir}/output.js`
);
const input = fs.readFileSync( filename, 'utf-8' ).replace( /\s+$/, '' ); const input = fs.readFileSync(filename, "utf-8").replace(/\s+$/, "");
const { code, map } = svelte.compile( input, { const { code, map } = svelte.compile(input, {
filename, filename,
outputFilename outputFilename
}); });
fs.writeFileSync( outputFilename, `${code}\n//# sourceMappingURL=output.js.map` ); fs.writeFileSync(
fs.writeFileSync( `${outputFilename}.map`, JSON.stringify( map, null, ' ' ) ); outputFilename,
`${code}\n//# sourceMappingURL=output.js.map`
);
fs.writeFileSync(
`${outputFilename}.map`,
JSON.stringify(map, null, " ")
);
assert.deepEqual( map.sources, [ 'input.html' ]); assert.deepEqual(map.sources, ["input.html"]);
const { test } = require( `./samples/${dir}/test.js` ); const { test } = require(`./samples/${dir}/test.js`);
const smc = new SourceMapConsumer( map ); const smc = new SourceMapConsumer(map);
const locateInSource = getLocator( input ); const locateInSource = getLocator(input);
const locateInGenerated = getLocator( code ); const locateInGenerated = getLocator(code);
test({ assert, code, map, smc, locateInSource, locateInGenerated }); test({ assert, code, map, smc, locateInSource, locateInGenerated });
}); });

14
test/test.js
Unescape View File

@ -1,11 +1,11 @@
const glob = require( 'glob' ); const glob = require("glob");
require( './setup' ); require("./setup");
glob.sync( '**/__test__.js', { cwd: 'src' }).forEach( function ( file ) { glob.sync("**/__test__.js", { cwd: "src" }).forEach(function(file) {
require( '../src/' + file ); require("../src/" + file);
}); });
glob.sync( '*/index.js', { cwd: 'test' }).forEach( function ( file ) { glob.sync("*/index.js", { cwd: "test" }).forEach(function(file) {
require( './' + file ); require("./" + file);
}); });

82
test/validator/index.js
Unescape View File

@ -1,30 +1,30 @@
import * as fs from 'fs'; import * as fs from "fs";
import assert from 'assert'; import assert from "assert";
import { svelte, tryToLoadJson } from '../helpers.js'; import { svelte, tryToLoadJson } from "../helpers.js";
describe( 'validate', () => { describe("validate", () => {
fs.readdirSync( 'test/validator/samples' ).forEach( dir => { fs.readdirSync("test/validator/samples").forEach(dir => {
if ( dir[0] === '.' ) return; if (dir[0] === ".") return;
// add .solo to a sample directory name to only run that test // add .solo to a sample directory name to only run that test
const solo = /\.solo/.test( dir ); const solo = /\.solo/.test(dir);
if ( solo && process.env.CI ) { if (solo && process.env.CI) {
throw new Error( 'Forgot to remove `solo: true` from test' ); throw new Error("Forgot to remove `solo: true` from test");
} }
( solo ? it.only : it )( dir, () => { (solo ? it.only : it)(dir, () => {
const filename = `test/validator/samples/${dir}/input.html`; const filename = `test/validator/samples/${dir}/input.html`;
const input = fs.readFileSync( filename, 'utf-8' ).replace( /\s+$/, '' ); const input = fs.readFileSync(filename, "utf-8").replace(/\s+$/, "");
try { try {
const parsed = svelte.parse( input ); const parsed = svelte.parse(input);
const errors = []; const errors = [];
const warnings = []; const warnings = [];
svelte.validate( parsed, input, { svelte.validate(parsed, input, {
onerror ( error ) { onerror(error) {
errors.push({ errors.push({
message: error.message, message: error.message,
pos: error.pos, pos: error.pos,
@ -32,7 +32,7 @@ describe( 'validate', () => {
}); });
}, },
onwarn ( warning ) { onwarn(warning) {
warnings.push({ warnings.push({
message: warning.message, message: warning.message,
pos: warning.pos, pos: warning.pos,
@ -41,40 +41,42 @@ describe( 'validate', () => {
} }
}); });
const expectedErrors = tryToLoadJson( `test/validator/samples/${dir}/errors.json` ) || []; const expectedErrors =
const expectedWarnings = tryToLoadJson( `test/validator/samples/${dir}/warnings.json` ) || []; tryToLoadJson(`test/validator/samples/${dir}/errors.json`) || [];
const expectedWarnings =
tryToLoadJson(`test/validator/samples/${dir}/warnings.json`) || [];
assert.deepEqual( errors, expectedErrors ); assert.deepEqual(errors, expectedErrors);
assert.deepEqual( warnings, expectedWarnings ); assert.deepEqual(warnings, expectedWarnings);
} catch ( err ) { } catch (err) {
if ( err.name !== 'ParseError' ) throw err; if (err.name !== "ParseError") throw err;
try { try {
const expected = require( `./samples/${dir}/errors.json` )[0]; const expected = require(`./samples/${dir}/errors.json`)[0];
assert.equal( err.message, expected.message ); assert.equal(err.message, expected.message);
assert.deepEqual( err.loc, expected.loc ); assert.deepEqual(err.loc, expected.loc);
assert.equal( err.pos, expected.pos ); assert.equal(err.pos, expected.pos);
} catch ( err2 ) { } catch (err2) {
throw err2.code === 'MODULE_NOT_FOUND' ? err : err2; throw err2.code === "MODULE_NOT_FOUND" ? err : err2;
} }
} }
}); });
}); });
it( 'errors if options.name is illegal', () => { it("errors if options.name is illegal", () => {
assert.throws( () => { assert.throws(() => {
svelte.compile( '<div></div>', { svelte.compile("<div></div>", {
name: 'not.valid' name: "not.valid"
}); });
}, /options\.name must be a valid identifier/ ); }, /options\.name must be a valid identifier/);
}); });
it( 'warns if options.name is not capitalised', () => { it("warns if options.name is not capitalised", () => {
const warnings = []; const warnings = [];
svelte.compile( '<div></div>', { svelte.compile("<div></div>", {
name: 'lowercase', name: "lowercase",
onwarn ( warning ) { onwarn(warning) {
warnings.push({ warnings.push({
message: warning.message, message: warning.message,
pos: warning.pos, pos: warning.pos,
@ -82,6 +84,12 @@ describe( 'validate', () => {
}); });
} }
}); });
assert.deepEqual( warnings, [ { message: 'options.name should be capitalised', pos: undefined, loc: undefined } ] ); assert.deepEqual(warnings, [
{
message: "options.name should be capitalised",
pos: undefined,
loc: undefined
}
]);
}); });
}); });

Write Preview
Loading…
Cancel
Save