racejar 1.1.3 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [1.2.0](https://github.com/portabletext/editor/compare/racejar-v1.1.3...racejar-v1.2.0) (2025-02-10)
+
+
+### Features
+
+* add support for `Before` and `After` hooks ([#784](https://github.com/portabletext/editor/issues/784)) ([0cee059](https://github.com/portabletext/editor/commit/0cee059aff7bb799ed51b608d8068490bc379d12))
+* Add support for Data Tables and Doc Strings ([#783](https://github.com/portabletext/editor/issues/783)) ([2083aab](https://github.com/portabletext/editor/commit/2083aab7637ef5c5f95e25b5b4373b63869dde74))
+
 ## [1.1.3](https://github.com/portabletext/editor/compare/racejar-v1.1.2...racejar-v1.1.3) (2025-02-05)
 
 

package/example/hello-herman.test.ts

@@ -2,11 +2,12 @@ import {expect} from 'vitest'
 import {Given, Then, When} from '../src/step-definitions'
 import {Feature} from '../src/vitest'
 
-function greet(name: string) {
-  return `Hello, ${name}!`
+function greet(name: string, greeting: string) {
+  return `Hello ${name}, ${greeting}`
 }
 
 type Context = {
+  greetingPrefix: string
   person: string
   greeting: string
 }
@@ -16,15 +17,19 @@ Feature({
     Feature: Greeting
       Scenario: Greeting a person
         Given the person "Herman"
-        When greeting the person
-        Then the greeting is "Hello, Herman!"`,
+        When greeting the person with:
+          | how are you? |
+        Then the greeting is "Hello Herman, how are you?"`,
   stepDefinitions: [
     Given('the person {string}', (context: Context, person: string) => {
       context.person = person
     }),
-    When('greeting the person', (context: Context) => {
-      context.greeting = greet(context.person)
-    }),
+    When(
+      'greeting the person with:',
+      (context: Context, greeting: string[][]) => {
+        context.greeting = greet(context.person, greeting[0][0])
+      },
+    ),
     Then('the greeting is {string}', (context: Context, greeting: string) => {
       expect(context.greeting).toBe(greeting)
     }),

package/example/hooks.test.ts

@@ -0,0 +1,42 @@
+import {expect} from 'vitest'
+import {After, Before} from '../src/hooks'
+import {Given, Then, When} from '../src/step-definitions'
+import {Feature} from '../src/vitest'
+
+function greet(prefix: string, name: string) {
+  return `${prefix} ${name}`
+}
+
+type Context = {
+  greetingPrefix: string
+  person: string
+  greeting: string
+}
+
+Feature({
+  featureText: `
+    Feature: Greeting
+      Scenario: Greeting a person
+        Given the person "Herman"
+        When greeting the person
+        Then the greeting is "Hello Herman"`,
+  hooks: [
+    Before((context: Context) => {
+      context.greetingPrefix = 'Hello'
+    }),
+    After((context: Context) => {
+      expect(context.greeting).toBe('Hello Herman')
+    }),
+  ],
+  stepDefinitions: [
+    Given('the person {string}', (context: Context, person: string) => {
+      context.person = person
+    }),
+    When('greeting the person', (context: Context) => {
+      context.greeting = greet(context.greetingPrefix, context.person)
+    }),
+    Then('the greeting is {string}', (context: Context, greeting: string) => {
+      expect(context.greeting).toBe(greeting)
+    }),
+  ],
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "racejar",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "A testing framework agnostic Gherkin driver",
   "keywords": [
     "cucumber",

package/src/compile-feature.ts

@@ -5,6 +5,7 @@ import {
 } from '@cucumber/cucumber-expressions'
 import * as Gherkin from '@cucumber/gherkin'
 import * as Messages from '@cucumber/messages'
+import type {Hook} from './hooks'
 import type {StepDefinition} from './step-definitions'
 
 /**
@@ -18,6 +19,8 @@ export type CompiledFeature<TStepContext extends Record<string, any> = object> =
       name: string
       tag?: 'only' | 'skip'
       steps: Array<(stepContext?: TStepContext) => Promise<void> | void>
+      beforeHooks: Array<(stepContext?: TStepContext) => Promise<void> | void>
+      afterHooks: Array<(stepContext?: TStepContext) => Promise<void> | void>
     }>
   }
 
@@ -29,10 +32,12 @@ export function compileFeature<
   TStepContext extends Record<string, any> = object,
 >({
   featureText,
+  hooks,
   stepDefinitions,
   parameterTypes,
 }: {
   featureText: string
+  hooks?: Array<Hook<TStepContext>>
   stepDefinitions: Array<StepDefinition<TContext, any, any, any>>
   parameterTypes?: Array<ParameterType<unknown>>
 }): CompiledFeature<TStepContext> {
@@ -118,6 +123,16 @@ export function compileFeature<
       }
 
       const args = matchingStep.args.map((arg) => arg.getValue(matchingStep))
+      if (step.argument?.dataTable) {
+        args.push(
+          step.argument.dataTable.rows.map((row) =>
+            row.cells.map((cell) => cell.value),
+          ),
+        )
+      }
+      if (step.argument?.docString) {
+        args.push(step.argument.docString.content)
+      }
 
       return (stepContext: TStepContext | undefined) =>
         matchingStep.callback(
@@ -138,6 +153,18 @@ export function compileFeature<
             ? ('only' as const)
             : undefined,
       steps,
+      beforeHooks: (hooks ?? [])
+        .filter((hook) => hook.type === 'Before')
+        .map(
+          (hook) => (stepContext: TStepContext | undefined) =>
+            hook.callback(Object.assign(context, stepContext)),
+        ),
+      afterHooks: (hooks ?? [])
+        .filter((hook) => hook.type === 'After')
+        .map(
+          (hook) => (stepContext: TStepContext | undefined) =>
+            hook.callback(Object.assign(context, stepContext)),
+        ),
     }
   })
 

package/src/hooks.ts

@@ -0,0 +1,32 @@
+/**
+ * @public
+ */
+export type Hook<TContext extends Record<string, any> = object> = {
+  type: 'Before' | 'After'
+  callback: HookCallback<TContext>
+}
+
+/**
+ * @public
+ */
+export type HookCallback<TContext extends Record<string, any> = object> = (
+  context: TContext,
+) => Promise<void> | void
+
+/**
+ * @public
+ */
+export function Before<TContext extends Record<string, any> = object>(
+  callback: HookCallback<TContext>,
+): Hook<TContext> {
+  return {type: 'Before', callback}
+}
+
+/**
+ * @public
+ */
+export function After<TContext extends Record<string, any> = object>(
+  callback: HookCallback<TContext>,
+): Hook<TContext> {
+  return {type: 'After', callback}
+}

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from './compile-feature'
 export * from './create-parameter-type'
 export * from './step-definitions'
+export * from './hooks'

package/src/jest/jest-gherkin-driver.ts

@@ -1,6 +1,7 @@
 import type {ParameterType} from '@cucumber/cucumber-expressions'
-import {describe, test} from '@jest/globals'
+import {afterEach, beforeEach, describe, test} from '@jest/globals'
 import {compileFeature} from '../compile-feature'
+import type {Hook} from '../hooks'
 import type {StepDefinition} from '../step-definitions'
 
 /**
@@ -8,15 +9,18 @@ import type {StepDefinition} from '../step-definitions'
  */
 export function Feature<TContext extends Record<string, any> = object>({
   featureText,
+  hooks,
   stepDefinitions,
   parameterTypes,
 }: {
   featureText: string
+  hooks: Array<Hook<TContext>>
   stepDefinitions: Array<StepDefinition<TContext, any, any, any>>
   parameterTypes?: Array<ParameterType<unknown>>
 }) {
   const feature = compileFeature({
     featureText,
+    hooks,
     stepDefinitions,
     parameterTypes,
   })
@@ -30,6 +34,13 @@ export function Feature<TContext extends Record<string, any> = object>({
 
   describeFn(feature.name, () => {
     for (const scenario of feature.scenarios) {
+      for (const before of scenario.beforeHooks) {
+        beforeEach(before)
+      }
+
+      for (const after of scenario.afterHooks) {
+        afterEach(after)
+      }
       const testFn =
         scenario.tag === 'only'
           ? test.only
@@ -38,6 +49,9 @@ export function Feature<TContext extends Record<string, any> = object>({
             : test
 
       testFn(scenario.name, async () => {
+        for (const before of scenario.beforeHooks) {
+          await before()
+        }
         for (const step of scenario.steps) {
           await step()
         }

package/src/playwright/playwright-gherkin-driver.ts

@@ -1,16 +1,25 @@
 import type {ParameterType} from '@cucumber/cucumber-expressions'
-import {test, type BrowserContext, type Page} from '@playwright/test'
+import {
+  test,
+  type PlaywrightTestArgs,
+  type PlaywrightTestOptions,
+  type PlaywrightWorkerArgs,
+  type PlaywrightWorkerOptions,
+} from '@playwright/test'
 import {compileFeature} from '../compile-feature'
+import type {Hook} from '../hooks'
 import type {StepDefinition} from '../step-definitions'
 
+type PlaywrightOptions = PlaywrightTestArgs &
+  PlaywrightTestOptions &
+  PlaywrightWorkerArgs &
+  PlaywrightWorkerOptions
+
 /**
  * @public
  */
-export type PlaywrightContext = {
-  playwright: {
-    page: Page
-    context: BrowserContext
-  }
+export type PlaywrightContext = Record<'string', any> & {
+  playwright: PlaywrightOptions
 }
 
 /**
@@ -20,15 +29,18 @@ export function Feature<
   TContext extends PlaywrightContext = PlaywrightContext,
 >({
   featureText,
+  hooks,
   stepDefinitions,
   parameterTypes,
 }: {
   featureText: string
+  hooks: Array<Hook<TContext>>
   stepDefinitions: Array<StepDefinition<TContext, any, any, any>>
   parameterTypes?: Array<ParameterType<unknown>>
 }) {
   const feature = compileFeature({
     featureText,
+    hooks,
     stepDefinitions,
     parameterTypes,
   })
@@ -42,6 +54,22 @@ export function Feature<
 
   describeFn(feature.name, () => {
     for (const scenario of feature.scenarios) {
+      for (const before of scenario.beforeHooks) {
+        test.beforeEach(async (playwrightOptions) => {
+          await before({
+            playwright: playwrightOptions,
+          } as TContext)
+        })
+      }
+
+      for (const after of scenario.afterHooks) {
+        test.afterEach(async (playwrightOptions) => {
+          await after({
+            playwright: playwrightOptions,
+          } as TContext)
+        })
+      }
+
       const testFn =
         scenario.tag === 'only'
           ? test.only
@@ -49,14 +77,11 @@ export function Feature<
             ? test.skip
             : test
 
-      testFn(scenario.name, async ({page, context}) => {
+      testFn(scenario.name, async (playwrightOptions) => {
         for (const step of scenario.steps) {
           await step({
-            playwright: {
-              page,
-              context,
-            },
-          })
+            playwright: playwrightOptions,
+          } as TContext)
         }
       })
     }

package/src/vitest/vitest-gherkin-driver.ts

@@ -1,6 +1,7 @@
 import type {ParameterType} from '@cucumber/cucumber-expressions'
-import {describe, test} from 'vitest'
+import {afterEach, beforeEach, describe, test} from 'vitest'
 import {compileFeature} from '../compile-feature'
+import type {Hook} from '../hooks'
 import type {StepDefinition} from '../step-definitions'
 
 /**
@@ -8,15 +9,18 @@ import type {StepDefinition} from '../step-definitions'
  */
 export function Feature<TContext extends Record<string, any> = object>({
   featureText,
+  hooks,
   stepDefinitions,
   parameterTypes,
 }: {
   featureText: string
+  hooks?: Array<Hook<TContext>>
   stepDefinitions: Array<StepDefinition<TContext, any, any, any>>
   parameterTypes?: Array<ParameterType<unknown>>
 }) {
   const feature = compileFeature({
     featureText,
+    hooks,
     stepDefinitions,
     parameterTypes,
   })
@@ -30,6 +34,14 @@ export function Feature<TContext extends Record<string, any> = object>({
 
   describeFn(feature.name, () => {
     for (const scenario of feature.scenarios) {
+      for (const before of scenario.beforeHooks) {
+        beforeEach(before)
+      }
+
+      for (const after of scenario.afterHooks) {
+        afterEach(after)
+      }
+
       const testFn =
         scenario.tag === 'only'
           ? test.only