test: add a syntactic error, refactor a bit

- add a file to `errors` with a syntax error in it
  - apparently this does throw syntax err, but does not cause `emitSkipped: true`... odd...
    - so may need another test for that...
    - `abortOnError: false` / `check: false` both cause Rollup to error out instead
  - rename `errors/index` -> `errors/semantic` since we have different kinds now
  - change the `include` to only take a single file, so that we don't unnecessarily generate declarations or type-check other error files

- refactor(test): rewrite `genBundle` in both files to take a relative path to a file
  - simplifies the `emitDeclarationOnly` test as we can now just reuse the local `genBundle` instead of calling `helpers.genBundle` directly
  - use the same structure for `errors`'s different files as well

- add a slightly hacky workaround to get `fs.remove` to not error
  - seems to be a race condition due to the thrown errors and file handles not being closed immediately on throw (seems like they close during garbage collection instead?)
  - see linked issue in the comment; workaround is to just give it some more time
    - not sure that there is a true fix for this, since an improper close may cause indeterminate behavior

Author: agilgur5

__tests__/integration/errors.spec.ts

@@ -13,38 +13,53 @@ const local = (x: string) => path.resolve(__dirname, x);
 const cacheRoot = local("__temp/errors/rpt2-cache"); // don't use the one in node_modules
 const onwarn = jest.fn();
 
-afterAll(() => fs.remove(cacheRoot));
+afterAll(async () => {
+  // workaround: there seems to be some race condition causing fs.remove to fail, so give it a sec first (c.f. https://github.com/jprichardson/node-fs-extra/issues/532)
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  await fs.remove(cacheRoot);
+});
 
-async function genBundle(extraOpts?: RPT2Options) {
+async function genBundle(relInput: string, extraOpts?: RPT2Options) {
+  const input = local(`fixtures/errors/${relInput}`)
   return helpers.genBundle({
-    input: local("fixtures/errors/index.ts"),
+    input,
     tsconfig: local("fixtures/errors/tsconfig.json"),
     cacheRoot,
-    extraOpts,
+    extraOpts: { include: [input], ...extraOpts }, // only include the input itself, not other error files (to only generate types and type-check the one file)
     onwarn,
   });
 }
 
-test("integration - errors", async () => {
+test("integration - tsconfig errors", async () => {
   // TODO: move to parse-tsconfig unit tests?
-  expect(genBundle({
-    tsconfig: 'non-existent-tsconfig',
+  expect(genBundle("semantic.ts", {
+    tsconfig: "non-existent-tsconfig",
   })).rejects.toThrow("rpt2: failed to open 'undefined'"); // FIXME: bug: this should be "non-existent-tsconfig", not "undefined"
+});
 
-  expect(genBundle()).rejects.toThrow(`semantic error TS2322: ${red("Type 'string' is not assignable to type 'number'.")}`);
+test("integration - semantic error", async () => {
+  expect(genBundle("semantic.ts")).rejects.toThrow(`semantic error TS2322: ${red("Type 'string' is not assignable to type 'number'.")}`);
 });
 
-test("integration - errors - abortOnError: false / check: false", async () => {
+test("integration - semantic error - abortOnError: false / check: false", async () => {
   // either warning or not type-checking should result in the same bundle
-  const { output } = await genBundle({ abortOnError: false });
-  const { output: output2 } = await genBundle({ check: false });
+  const { output } = await genBundle("semantic.ts", { abortOnError: false });
+  const { output: output2 } = await genBundle("semantic.ts", { check: false });
   expect(output).toEqual(output2);
 
   expect(output[0].fileName).toEqual("index.js");
-  expect(output[1].fileName).toEqual("index.d.ts");
-  expect(output[2].fileName).toEqual("index.d.ts.map");
+  expect(output[1].fileName).toEqual("semantic.d.ts");
+  expect(output[2].fileName).toEqual("semantic.d.ts.map");
   expect(output.length).toEqual(3); // no other files
   expect(onwarn).toBeCalledTimes(1);
 });
 
+test("integration - syntax error", () => {
+  expect(genBundle("syntax.ts")).rejects.toThrow(`syntax error TS1005: ${red("';' expected.")}`);
+});
 
+test("integration - syntax error - abortOnError: false / check: false", () => {
+  const err = "Unexpected token (Note that you need plugins to import files that are not JavaScript)";
+  expect(genBundle("syntax.ts", { abortOnError: false })).rejects.toThrow(err);
+  expect(genBundle("syntax.ts", { check: false })).rejects.toThrow(err);
+});

__tests__/integration/fixtures/errors/index.ts renamed to __tests__/integration/fixtures/errors/semantic.ts

@@ -0,0 +1,3 @@
+export const incorrectSyntax => {
+  return "a + b";
+}

__tests__/integration/fixtures/errors/syntax.ts

@@ -13,21 +13,21 @@ const cacheRoot = local("__temp/no-errors/rpt2-cache"); // don't use the one in
 
 afterAll(() => fs.remove(cacheRoot));
 
-async function genBundle(extraOpts?: RPT2Options) {
+async function genBundle(relInput: string, extraOpts?: RPT2Options) {
   return helpers.genBundle({
-    input: local("fixtures/no-errors/index.ts"),
+    input: local(`fixtures/no-errors/${relInput}`),
     tsconfig: local("fixtures/no-errors/tsconfig.json"),
     cacheRoot,
     extraOpts,
   });
 }
 
 test("integration - no errors", async () => {
-  const { output } = await genBundle({ clean: true });
+  const { output } = await genBundle("index.ts", { clean: true });
 
   // populate the cache
-  await genBundle();
-  const { output: outputWithCache } = await genBundle();
+  await genBundle("index.ts");
+  const { output: outputWithCache } = await genBundle("index.ts");
   expect(output).toEqual(outputWithCache);
 
   expect(output[0].fileName).toEqual("index.js");
@@ -45,7 +45,7 @@ test("integration - no errors", async () => {
 
 test("integration - no errors - no declaration maps", async () => {
   const noDeclarationMaps = { compilerOptions: { declarationMap: false } };
-  const { output } = await genBundle({
+  const { output } = await genBundle("index.ts", {
     tsconfigOverride: noDeclarationMaps,
     clean: true,
   });
@@ -60,7 +60,7 @@ test("integration - no errors - no declaration maps", async () => {
 
 test("integration - no errors - no declarations", async () => {
   const noDeclarations = { compilerOptions: { declaration: false, declarationMap: false } };
-  const { output } = await genBundle({
+  const { output } = await genBundle("index.ts", {
     tsconfigOverride: noDeclarations,
     clean: true,
   });
@@ -70,17 +70,12 @@ test("integration - no errors - no declarations", async () => {
 });
 
 test("integration - no errors - allowJs + emitDeclarationOnly", async () => {
-  const { output } = await helpers.genBundle({
-    input: local("fixtures/no-errors/some-js-import.js"),
-    tsconfig: local("fixtures/no-errors/tsconfig.json"),
-    cacheRoot,
-    extraOpts: {
-      include: ["**/*.js"],
-      tsconfigOverride: {
-        compilerOptions: {
-          allowJs: true,
-          emitDeclarationOnly: true,
-        },
+  const { output } = await genBundle("some-js-import.js", {
+    include: ["**/*.js"],
+    tsconfigOverride: {
+      compilerOptions: {
+        allowJs: true,
+        emitDeclarationOnly: true,
       },
     },
   });