assert exception

dtc/src/domain.ts

@@ -1,6 +1,11 @@
 export type Loader = (filePath: string) => Promise<TestCase>
 
-export type Runner = (testCases: TestCaseExecution[], plugins: string[], args?: string[], config?: string) => Promise<void>
+export type Runner = (
+  testCases: TestCaseExecution[],
+  plugins: string[],
+  args?: string[],
+  config?: string,
+) => Promise<void>
 
 export type GenericAttributes = {
   [key: string]: string | number | boolean | Record<string, unknown> | Record<string, unknown>[]
@@ -11,11 +16,14 @@ export type TestCase = GenericAttributes & {
   debug?: boolean
   retry?: number
   delay?: number
-  timeout?: number 
+  timeout?: number
   parameters?: Record<string, unknown> | Record<string, unknown>[]
   arrange?: Record<string, unknown>
   act?: Record<string, unknown>
-  assert?: unknown
+  assert?: {
+    exception?: unknown
+    [x: string]: unknown
+  }
   clean?: Record<string, unknown>
 }
 

dtc/src/plugins/function-call-plugin.ts

@@ -1,5 +1,6 @@
 import extraAssert from '@cgauge/assert'
 import {isRecord} from '../utils.js'
+import nodeAssert from 'node:assert'
 
 type FunctionCallAct = {
   import: string
@@ -10,6 +11,7 @@ type FunctionCallAct = {
 const isFunctionCallAct = (v: unknown): v is FunctionCallAct => typeof v === 'object' && v !== null && 'import' in v
 
 let response: any
+let exception: any
 
 export const act = async (args: unknown, basePath: string) => {
   if (!isFunctionCallAct(args)) {
@@ -24,10 +26,18 @@ export const act = async (args: unknown, basePath: string) => {
   }
   /* c8 ignore end */
 
-  response = await module[args.import].apply(null, args.arguments)
+  try {
+    response = await module[args.import].apply(null, args.arguments)
+  } catch (e) {
+    exception = e
+  }
 }
 
-export const assert = (args: unknown) => {
+export const assert = (args: {exception?: {name?: string}; [x: string]: unknown}) => {
+  if (args.exception?.name) {
+    nodeAssert.equal(args?.exception?.name, exception.name)
+  }
+
   if (response && isRecord(args) && args) {
     extraAssert.objectContains(response, args)
   }

dtc/test/fixtures/functions.js

@@ -3,3 +3,7 @@ export const noArgs = () => true
 export const syncFunction = (args) => args
 
 export const asyncFunction = async (args) => args
+
+export const functionWithException = (__args) => {
+    throw new Error()
+}

dtc/test/plugins/function-call-plugin.test.ts

@@ -5,35 +5,47 @@ import {fileURLToPath} from 'node:url'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
-test('It call a sync function without args', async () => {
-  await act({
-    import: 'noArgs',
-    from: '../fixtures/functions.js',
-  }, __dirname)
-
-  assert(true)
-})
-
 test('It call a sync function with args', async () => {
   const args = {a: 'b'}
 
-  await act({
-    import: 'syncFunction',
-    from: '../fixtures/functions.js',
-    arguments: [args],
-  }, __dirname)
+  await act(
+    {
+      import: 'syncFunction',
+      from: '../fixtures/functions.js',
+      arguments: [args],
+    },
+    __dirname,
+  )
 
   assert(args)
 })
 
 test('It call a async function with args', async () => {
   const args = {a: 'b'}
 
-  await act({
-    import: 'asyncFunction',
-    from: '../fixtures/functions.js',
-    arguments: [args],
-  }, __dirname)
+  await act(
+    {
+      import: 'asyncFunction',
+      from: '../fixtures/functions.js',
+      arguments: [args],
+    },
+    __dirname,
+  )
+
+  assert(args)
+})
+
+test('It call a sync function with exception', async () => {
+  const args = {exception: {name: 'Error'}}
+
+  await act(
+    {
+      import: 'functionWithException',
+      from: '../fixtures/functions.js',
+      arguments: [args],
+    },
+    __dirname,
+  )
 
   assert(args)
 })