Clean up tests

test/css-syntax-error.test.ts

@@ -11,6 +11,16 @@ import postcss, {
   Rule
 } from '../lib/postcss.js'
 
+async function catchError(cb: () => Promise<any>): Promise<CssSyntaxError> {
+  try {
+    await cb()
+  } catch (e) {
+    if (e.name !== 'CssSyntaxError') throw e
+    return e
+  }
+  throw new Error('Error was not thrown')
+}
+
 function parseError(
   css: string,
   opts?: Pick<ProcessOptions, 'map' | 'from'>
@@ -219,7 +229,7 @@ it('set source plugin', () => {
   )
 })
 
-it('set source plugin automatically', () => {
+it('set source plugin automatically', async () => {
   let plugin: Plugin = {
     postcssPlugin: 'test-plugin',
     Once(css) {
@@ -229,16 +239,14 @@ it('set source plugin automatically', () => {
     }
   }
 
-  return postcss([plugin])
-    .process('a{}')
-    .catch(error => {
-      if (error.name !== 'CssSyntaxError') throw error
-      expect(error.plugin).toEqual('test-plugin')
-      expect(error.toString()).toMatch(/test-plugin/)
-    })
+  let error = await catchError(() =>
+    postcss([plugin]).process('a{}', { from: undefined })
+  )
+  expect(error.plugin).toEqual('test-plugin')
+  expect(error.toString()).toMatch(/test-plugin/)
 })
 
-it('set plugin automatically in async', () => {
+it('set plugin automatically in async', async () => {
   let plugin: Plugin = {
     postcssPlugin: 'async-plugin',
     Once(css) {
@@ -250,10 +258,8 @@ it('set plugin automatically in async', () => {
     }
   }
 
-  return postcss([plugin])
-    .process('a{}')
-    .catch(error => {
-      if (error.name !== 'CssSyntaxError') throw error
-      expect(error.plugin).toEqual('async-plugin')
-    })
+  let error = await catchError(() =>
+    postcss([plugin]).process('a{}', { from: undefined })
+  )
+  expect(error.plugin).toEqual('async-plugin')
 })

test/processor.test.ts

@@ -1,4 +1,5 @@
 import { resolve as pathResolve } from 'path'
+import { delay } from 'nanodelay'
 
 import postcss, {
   Plugin,
@@ -27,6 +28,15 @@ function getCalls(func: any): any {
   return func.mock.calls
 }
 
+async function catchError(cb: () => Promise<any>): Promise<Error> {
+  try {
+    await cb()
+  } catch (e) {
+    return e
+  }
+  throw new Error('Error was not thrown')
+}
+
 let beforeFix = new Processor([
   (root: Root) => {
     root.walkRules(rule => {
@@ -277,54 +287,40 @@ it('runs async plugin only once', async () => {
   expect(calls).toEqual(1)
 })
 
-it('supports async errors', () => {
+it('supports async errors', async () => {
   let error = new Error('Async')
   let async = (): Promise<void> => {
     return new Promise<void>((resolve, reject) => {
       reject(error)
     })
   }
-  return new Promise<void>((resolve, reject) => {
-    let result = new Processor([async]).process('', { from: undefined })
-    result
-      .then(() => {
-        reject(new Error('Called .then in failed processing'))
-      })
-      .catch(err => {
-        expect(err).toEqual(error)
-        return result.catch(err2 => {
-          expect(err2).toEqual(error)
-          resolve()
-        })
-      })
+  let result = new Processor([async]).process('', { from: undefined })
+  let err1 = await catchError(async () => await result)
+  expect(err1).toEqual(error)
+
+  let err2: Error | undefined
+  result.catch(catched => {
+    err2 = catched
   })
+  await delay(10)
+  expect(err2).toEqual(error)
 })
 
-it('supports sync errors in async mode', () => {
+it('supports sync errors in async mode', async () => {
   let error = new Error('Async')
   let async = (): void => {
     throw error
   }
-  return new Promise<void>((resolve, reject) => {
-    new Processor([async])
-      .process('', { from: undefined })
-      .then(() => {
-        reject(new Error('Called .then in failed processing'))
-      })
-      .catch(err => {
-        expect(err).toEqual(error)
-        resolve()
-      })
-  })
+  let err = await catchError(() =>
+    new Processor([async]).process('', { from: undefined })
+  )
+  expect(err).toEqual(error)
 })
 
 it('throws parse error in async', async () => {
-  let err
-  try {
-    await new Processor([() => {}]).process('a{', { from: undefined })
-  } catch (e) {
-    err = e
-  }
+  let err = await catchError(() =>
+    new Processor([() => {}]).process('a{', { from: undefined })
+  )
   expect(err.message).toEqual('<css input>:1:1: Unclosed block')
 })