dart-sass/test/cli/shared.dart

527 lines
16 KiB
Dart
Raw Normal View History

// 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);
});
2018-10-11 00:05:23 +02:00
// 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)));
});
});
group("with --error-css", () {
var message = "Error: Expected expression.";
setUp(() => d.file("test.scss", "a {b: 1 + }").create());
group("not explicitly set", () {
test("doesn't emit error CSS when compiling to stdout", () async {
var sass = await runSass(["test.scss"]);
expect(sass.stdout, emitsDone);
await sass.shouldExit(65);
});
test("emits error CSS when compiling to a file", () async {
var sass = await runSass(["test.scss", "test.css"]);
await sass.shouldExit(65);
await d.file("test.css", contains(message)).validate();
});
});
group("explicitly set", () {
test("emits error CSS when compiling to stdout", () async {
var sass = await runSass(["--error-css", "test.scss"]);
expect(sass.stdout, emitsThrough(contains(message)));
await sass.shouldExit(65);
});
test("emits error CSS when compiling to a file", () async {
var sass = await runSass(["--error-css", "test.scss", "test.css"]);
await sass.shouldExit(65);
await d.file("test.css", contains(message)).validate();
});
});
group("explicitly unset", () {
test("doesn't emit error CSS when compiling to stdout", () async {
var sass = await runSass(["--no-error-css", "test.scss"]);
expect(sass.stdout, emitsDone);
await sass.shouldExit(65);
});
test("emits error CSS when compiling to a file", () async {
var sass = await runSass(["--no-error-css", "test.scss", "test.css"]);
await sass.shouldExit(65);
await d.nothing("test.css").validate();
});
});
});
}