mirror of
https://github.com/danog/dart-sass.git
synced 2024-12-04 10:37:52 +01:00
3b3a43a8f9
The automatic @charset adding is useful in general, but there are consistently cases where it trips up naïve downstream tools. This option makes it easier for users to control when it occurs.
480 lines
14 KiB
Dart
480 lines
14 KiB
Dart
// Copyright 2016 Google Inc. Use of this source code is governed by an
|
|
// MIT-style license that can be found in the LICENSE file or at
|
|
// https://opensource.org/licenses/MIT.
|
|
|
|
import 'dart:async';
|
|
import 'dart:convert';
|
|
import 'dart:io';
|
|
|
|
import 'package:path/path.dart' as p;
|
|
import 'package:test/test.dart';
|
|
import 'package:test_descriptor/test_descriptor.dart' as d;
|
|
import 'package:test_process/test_process.dart';
|
|
|
|
/// Defines test that are shared between the Dart and Node.js CLI test suites.
|
|
void sharedTests(
|
|
Future<TestProcess> runSass(Iterable<String> arguments,
|
|
{Map<String, String> environment})) {
|
|
/// Runs the executable on [arguments] plus an output file, then verifies that
|
|
/// the contents of the output file match [expected].
|
|
Future expectCompiles(List<String> arguments, expected,
|
|
{Map<String, String> environment}) async {
|
|
var sass = await runSass(
|
|
arguments.toList()..add("out.css")..add("--no-source-map"),
|
|
environment: environment);
|
|
await sass.shouldExit(0);
|
|
await d.file("out.css", expected).validate();
|
|
}
|
|
|
|
test("--help prints the usage documentation", () async {
|
|
// Checking the entire output is brittle, so just do a sanity check to make
|
|
// sure it's not totally busted.
|
|
var sass = await runSass(["--help"]);
|
|
expect(sass.stdout, emits("Compile Sass to CSS."));
|
|
expect(
|
|
sass.stdout, emitsThrough(contains("Print this usage information.")));
|
|
await sass.shouldExit(64);
|
|
});
|
|
|
|
test("compiles a Sass file to CSS", () async {
|
|
await d.file("test.scss", "a {b: 1 + 2}").create();
|
|
|
|
var sass = await runSass(["test.scss"]);
|
|
expect(
|
|
sass.stdout,
|
|
emitsInOrder([
|
|
"a {",
|
|
" b: 3;",
|
|
"}",
|
|
]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
// Regression test for #437.
|
|
test("compiles a Sass file with a BOM to CSS", () async {
|
|
await d.file("test.scss", "\uFEFF\$color: red;").create();
|
|
|
|
var sass = await runSass(["test.scss"]);
|
|
expect(sass.stdout, emitsDone);
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
// On Windows, this verifies that we don't consider the colon after a drive
|
|
// letter to be an `input:output` separator.
|
|
test("compiles an absolute Sass file to CSS", () async {
|
|
await d.file("test.scss", "a {b: 1 + 2}").create();
|
|
|
|
var sass = await runSass([p.absolute(d.path("test.scss"))]);
|
|
expect(
|
|
sass.stdout,
|
|
emitsInOrder([
|
|
"a {",
|
|
" b: 3;",
|
|
"}",
|
|
]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
test("writes a CSS file to disk", () async {
|
|
await d.file("test.scss", "a {b: 1 + 2}").create();
|
|
|
|
var sass = await runSass(["--no-source-map", "test.scss", "out.css"]);
|
|
expect(sass.stdout, emitsDone);
|
|
await sass.shouldExit(0);
|
|
await d.file("out.css", equalsIgnoringWhitespace("a { b: 3; }")).validate();
|
|
});
|
|
|
|
test("creates directories if necessary", () async {
|
|
await d.file("test.scss", "a {b: 1 + 2}").create();
|
|
|
|
var sass =
|
|
await runSass(["--no-source-map", "test.scss", "some/new/dir/out.css"]);
|
|
expect(sass.stdout, emitsDone);
|
|
await sass.shouldExit(0);
|
|
await d
|
|
.file("some/new/dir/out.css", equalsIgnoringWhitespace("a { b: 3; }"))
|
|
.validate();
|
|
});
|
|
|
|
test("compiles from stdin with the magic path -", () async {
|
|
var sass = await runSass(["-"]);
|
|
sass.stdin.writeln("a {b: 1 + 2}");
|
|
sass.stdin.close();
|
|
expect(
|
|
sass.stdout,
|
|
emitsInOrder([
|
|
"a {",
|
|
" b: 3;",
|
|
"}",
|
|
]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
group("can import files", () {
|
|
test("relative to the entrypoint", () async {
|
|
await d.file("test.scss", "@import 'dir/test'").create();
|
|
|
|
await d.dir("dir", [d.file("test.scss", "a {b: 1 + 2}")]).create();
|
|
|
|
await expectCompiles(
|
|
["test.scss"], equalsIgnoringWhitespace("a { b: 3; }"));
|
|
});
|
|
|
|
test("from the load path", () async {
|
|
await d.file("test.scss", "@import 'test2'").create();
|
|
|
|
await d.dir("dir", [d.file("test2.scss", "a {b: c}")]).create();
|
|
|
|
await expectCompiles(["--load-path", "dir", "test.scss"],
|
|
equalsIgnoringWhitespace("a { b: c; }"));
|
|
});
|
|
|
|
test("from SASS_PATH", () async {
|
|
await d.file("test.scss", """
|
|
@import 'test2';
|
|
@import 'test3';
|
|
""").create();
|
|
|
|
await d.dir("dir2", [d.file("test2.scss", "a {b: c}")]).create();
|
|
await d.dir("dir3", [d.file("test3.scss", "x {y: z}")]).create();
|
|
|
|
var separator = Platform.isWindows ? ';' : ':';
|
|
await expectCompiles(
|
|
["test.scss"], equalsIgnoringWhitespace("a { b: c; } x { y: z; }"),
|
|
environment: {"SASS_PATH": "dir2${separator}dir3"});
|
|
});
|
|
|
|
// Regression test for #369
|
|
test("from within a directory, relative to a file on the load path",
|
|
() async {
|
|
await d.dir(
|
|
"dir1", [d.file("test.scss", "@import 'subdir/test2'")]).create();
|
|
|
|
await d.dir("dir2", [
|
|
d.dir("subdir", [
|
|
d.file("test2.scss", "@import 'test3'"),
|
|
d.file("test3.scss", "a {b: c}")
|
|
])
|
|
]).create();
|
|
|
|
await expectCompiles(["--load-path", "dir2", "dir1/test.scss"],
|
|
equalsIgnoringWhitespace("a { b: c; }"));
|
|
});
|
|
|
|
test("relative in preference to from the load path", () async {
|
|
await d.file("test.scss", "@import 'test2'").create();
|
|
await d.file("test2.scss", "x {y: z}").create();
|
|
|
|
await d.dir("dir", [d.file("test2.scss", "a {b: c}")]).create();
|
|
|
|
await expectCompiles(["--load-path", "dir", "test.scss"],
|
|
equalsIgnoringWhitespace("x { y: z; }"));
|
|
});
|
|
|
|
test("in load path order", () async {
|
|
await d.file("test.scss", "@import 'test2'").create();
|
|
|
|
await d.dir("dir1", [d.file("test2.scss", "a {b: c}")]).create();
|
|
await d.dir("dir2", [d.file("test2.scss", "x {y: z}")]).create();
|
|
|
|
await expectCompiles(
|
|
["--load-path", "dir2", "--load-path", "dir1", "test.scss"],
|
|
equalsIgnoringWhitespace("x { y: z; }"));
|
|
});
|
|
|
|
test("from the load path in preference to from SASS_PATH", () async {
|
|
await d.file("test.scss", "@import 'test2'").create();
|
|
|
|
await d.dir("dir1", [d.file("test2.scss", "a {b: c}")]).create();
|
|
await d.dir("dir2", [d.file("test2.scss", "x {y: z}")]).create();
|
|
|
|
await expectCompiles(["--load-path", "dir2", "test.scss"],
|
|
equalsIgnoringWhitespace("x { y: z; }"),
|
|
environment: {"SASS_PATH": "dir1"});
|
|
});
|
|
|
|
test("in SASS_PATH order", () async {
|
|
await d.file("test.scss", "@import 'test2'").create();
|
|
|
|
await d.dir("dir1", [d.file("test2.scss", "a {b: c}")]).create();
|
|
await d.dir("dir2", [d.file("test2.scss", "x {y: z}")]).create();
|
|
|
|
var separator = Platform.isWindows ? ';' : ':';
|
|
await expectCompiles(
|
|
["test.scss"], equalsIgnoringWhitespace("x { y: z; }"),
|
|
environment: {"SASS_PATH": "dir2${separator}dir3"});
|
|
});
|
|
|
|
// Regression test for an internal Google issue.
|
|
test("multiple times from different load paths", () async {
|
|
await d.file("test.scss", """
|
|
@import 'parent/child/test2';
|
|
@import 'child/test2';
|
|
""").create();
|
|
|
|
await d.dir("grandparent", [
|
|
d.dir("parent", [
|
|
d.dir("child", [
|
|
d.file("test2.scss", "@import 'test3';"),
|
|
d.file("test3.scss", "a {b: c};")
|
|
])
|
|
])
|
|
]).create();
|
|
|
|
await expectCompiles([
|
|
"--load-path",
|
|
"grandparent",
|
|
"--load-path",
|
|
"grandparent/parent",
|
|
"test.scss"
|
|
], equalsIgnoringWhitespace("a { b: c; } a { b: c; }"));
|
|
});
|
|
});
|
|
|
|
group("with --stdin", () {
|
|
test("compiles from stdin", () async {
|
|
var sass = await runSass(["--stdin"]);
|
|
sass.stdin.writeln("a {b: 1 + 2}");
|
|
sass.stdin.close();
|
|
expect(
|
|
sass.stdout,
|
|
emitsInOrder([
|
|
"a {",
|
|
" b: 3;",
|
|
"}",
|
|
]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
test("writes a CSS file to disk", () async {
|
|
var sass = await runSass(["--no-source-map", "--stdin", "out.css"]);
|
|
sass.stdin.writeln("a {b: 1 + 2}");
|
|
sass.stdin.close();
|
|
expect(sass.stdout, emitsDone);
|
|
|
|
await sass.shouldExit(0);
|
|
await d
|
|
.file("out.css", equalsIgnoringWhitespace("a { b: 3; }"))
|
|
.validate();
|
|
});
|
|
|
|
test("uses the indented syntax with --indented", () async {
|
|
var sass = await runSass(["--no-source-map", "--stdin", "--indented"]);
|
|
sass.stdin.writeln("a\n b: 1 + 2");
|
|
sass.stdin.close();
|
|
expect(
|
|
sass.stdout,
|
|
emitsInOrder([
|
|
"a {",
|
|
" b: 3;",
|
|
"}",
|
|
]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
// Regression test.
|
|
test("supports @debug", () async {
|
|
var sass = await runSass(["--no-source-map", "--stdin"]);
|
|
sass.stdin.writeln("@debug foo");
|
|
sass.stdin.close();
|
|
expect(sass.stderr, emitsInOrder(["-:1 DEBUG: foo"]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
});
|
|
|
|
test("gracefully reports errors from stdin", () async {
|
|
var sass = await runSass(["--no-unicode", "-"]);
|
|
sass.stdin.writeln("a {b: 1 + }");
|
|
sass.stdin.close();
|
|
expect(
|
|
sass.stderr,
|
|
emitsInOrder([
|
|
"Error: Expected expression.",
|
|
" ,",
|
|
"1 | a {b: 1 + }",
|
|
" | ^",
|
|
" '",
|
|
" - 1:11 root stylesheet",
|
|
]));
|
|
await sass.shouldExit(65);
|
|
});
|
|
|
|
// Regression test for an issue mentioned in sass/linter#15
|
|
test(
|
|
"gracefully reports errors for binary operations with parentheized "
|
|
"operands", () async {
|
|
var sass = await runSass(["--no-unicode", "-"]);
|
|
sass.stdin.writeln("a {b: (#123) + (#456)}");
|
|
sass.stdin.close();
|
|
expect(
|
|
sass.stderr,
|
|
emitsInOrder([
|
|
'Error: Undefined operation "#123 + #456".',
|
|
" ,",
|
|
"1 | a {b: (#123) + (#456)}",
|
|
" | ^^^^^^^^^^^^^^^",
|
|
" '",
|
|
" - 1:7 root stylesheet",
|
|
]));
|
|
await sass.shouldExit(65);
|
|
});
|
|
|
|
test("gracefully handles a non-partial next to a partial", () async {
|
|
await d.file("test.scss", "a {b: c}").create();
|
|
await d.file("_test.scss", "x {y: z}").create();
|
|
|
|
var sass = await runSass(["test.scss"]);
|
|
expect(
|
|
sass.stdout,
|
|
emitsInOrder([
|
|
"a {",
|
|
" b: c;",
|
|
"}",
|
|
]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
test("emits warnings on standard error", () async {
|
|
await d.file("test.scss", "@warn 'aw beans'").create();
|
|
|
|
var sass = await runSass(["test.scss"]);
|
|
expect(sass.stdout, emitsDone);
|
|
expect(
|
|
sass.stderr,
|
|
emitsInOrder([
|
|
"WARNING: aw beans",
|
|
" test.scss 1:1 root stylesheet",
|
|
]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
test("emits debug messages on standard error", () async {
|
|
await d.file("test.scss", "@debug 'what the heck'").create();
|
|
|
|
var sass = await runSass(["test.scss"]);
|
|
expect(sass.stdout, emitsDone);
|
|
expect(sass.stderr, emits("test.scss:1 DEBUG: what the heck"));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
group("with --quiet", () {
|
|
test("doesn't emit @warn", () async {
|
|
await d.file("test.scss", "@warn heck").create();
|
|
|
|
var sass = await runSass(["--quiet", "test.scss"]);
|
|
expect(sass.stderr, emitsDone);
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
test("doesn't emit @debug", () async {
|
|
await d.file("test.scss", "@debug heck").create();
|
|
|
|
var sass = await runSass(["--quiet", "test.scss"]);
|
|
expect(sass.stderr, emitsDone);
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
test("doesn't emit parser warnings", () async {
|
|
await d.file("test.scss", "a {b: c && d}").create();
|
|
|
|
var sass = await runSass(["--quiet", "test.scss"]);
|
|
expect(sass.stderr, emitsDone);
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
test("doesn't emit runner warnings", () async {
|
|
await d.file("test.scss", "#{blue} {x: y}").create();
|
|
|
|
var sass = await runSass(["--quiet", "test.scss"]);
|
|
expect(sass.stderr, emitsDone);
|
|
await sass.shouldExit(0);
|
|
});
|
|
});
|
|
|
|
group("with --charset", () {
|
|
test("doesn't emit @charset for a pure-ASCII stylesheet", () async {
|
|
await d.file("test.scss", "a {b: c}").create();
|
|
|
|
var sass = await runSass(["test.scss"]);
|
|
expect(
|
|
sass.stdout,
|
|
emitsInOrder([
|
|
"a {",
|
|
" b: c;",
|
|
"}",
|
|
]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
test("emits @charset with expanded output", () async {
|
|
await d.file("test.scss", "a {b: 👭}").create();
|
|
|
|
var sass = await runSass(["test.scss"]);
|
|
expect(
|
|
sass.stdout,
|
|
emitsInOrder([
|
|
"@charset \"UTF-8\";",
|
|
"a {",
|
|
" b: 👭;",
|
|
"}",
|
|
]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
test("emits a BOM with compressed output", () async {
|
|
await d.file("test.scss", "a {b: 👭}").create();
|
|
|
|
var sass = await runSass(
|
|
["--no-source-map", "--style=compressed", "test.scss", "test.css"]);
|
|
await sass.shouldExit(0);
|
|
|
|
// We can't verify this as a string because `dart:io` automatically trims
|
|
// the BOM.
|
|
var bomBytes = utf8.encode("\uFEFF");
|
|
expect(
|
|
File(p.join(d.sandbox, "test.css"))
|
|
.readAsBytesSync()
|
|
.sublist(0, bomBytes.length),
|
|
equals(bomBytes));
|
|
});
|
|
});
|
|
|
|
group("with --no-charset", () {
|
|
test("doesn't emit @charset with expanded output", () async {
|
|
await d.file("test.scss", "a {b: 👭}").create();
|
|
|
|
var sass = await runSass(["--no-charset", "test.scss"]);
|
|
expect(
|
|
sass.stdout,
|
|
emitsInOrder([
|
|
"a {",
|
|
" b: 👭;",
|
|
"}",
|
|
]));
|
|
await sass.shouldExit(0);
|
|
});
|
|
|
|
test("doesn't emit a BOM with compressed output", () async {
|
|
await d.file("test.scss", "a {b: 👭}").create();
|
|
|
|
var sass = await runSass([
|
|
"--no-charset",
|
|
"--no-source-map",
|
|
"--style=compressed",
|
|
"test.scss",
|
|
"test.css"
|
|
]);
|
|
await sass.shouldExit(0);
|
|
|
|
// We can't verify this as a string because `dart:io` automatically trims
|
|
// the BOM.
|
|
var bomBytes = utf8.encode("\uFEFF");
|
|
expect(
|
|
File(p.join(d.sandbox, "test.css"))
|
|
.readAsBytesSync()
|
|
.sublist(0, bomBytes.length),
|
|
isNot(equals(bomBytes)));
|
|
});
|
|
});
|
|
}
|