fix: use dynamic fixtures instead of hardcoded

README.md

@@ -24,15 +24,36 @@ class MyTestSuite {
 ```
 
 ## 📝 Documentation
-### `@suite()`, `@suite(options)` => `describe()`
-Mark class as a test suite.
-Runs all class methods decorated by `@test` inside `options.name` context (`describe(options.name, all_methods_decorated_by_@test`).
+### Creating a test suite: `@suite(options?)`
+Decorate a class with `@suite()` or `@suite(options)` to create a test suite.
+Under the hood, decorator creates a `describe` block and runs all methods decorated by `@test` inside it.
+
+```ts
+import { suite } from 'playwright-decorators';
+
+@suite() // <-- Decorate class with @suite() or @suite(options)
+class MyTestSuite {
+  // ...
+}
+```
 
 #### Options
 - `name` (optional) - name of the test suite. By default, name of the class.
 
-### `@test()`, `@test(options)` => `test()`
-Mark method as a test. Run method using `test(option.name, method)`.
+### Creating a test: `@test(options?)`
+You can create a test by decorating a method with `@test()` or `@test(options)` decorator.
+
+```ts
+import { suite, test } from 'playwright-decorators';
+
+@suite()
+class MyTestSuite {
+  @test() // <-- Decorate test method with @test() or @test(options)
+  async myTest({ page }) {
+    // ...
+  }
+}
+```
 
 #### Options
 - `name` (optional) - name of the test. By default, name of the method.

dts-bundle-generator.config.ts

@@ -5,7 +5,11 @@ const config = {
     entries: [
         {
             filePath: './lib/index.ts',
-            outFile: './dist/index.d.ts'
+            outFile: './dist/index.d.ts',
+            output: {
+                exportReferencedTypes: false,
+                noBanner: true
+            }
         }
     ]
 };

lib/helpers.ts

@@ -0,0 +1,17 @@
+import {TestInfo} from "@playwright/test";
+
+export type PlaywrightTestFunction = (args: any, testInfo: TestInfo ) => Promise<void> | void;
+export type TestDecoratorFunction = (testFunction: PlaywrightTestFunction) => PlaywrightTestFunction;
+
+/**
+ * Wrap a playwright test function with class method, and make it visible externally as original one (function description).
+ * It is required, as @playwright/test function do not accept rest parameters.
+ */
+export const decoratePlaywrightTest = (testFunction: PlaywrightTestFunction, decorationFunction: TestDecoratorFunction) => {
+  const decoratedTestFunction = decorationFunction(testFunction);
+
+  // expose original function description
+  decoratedTestFunction.toString = () => testFunction.toString();
+
+  return decoratedTestFunction;
+}

lib/index.ts

@@ -1,2 +1,2 @@
-export * from './suite.decorator';
-export * from './test.decorator';
+export { suite } from './suite.decorator';
+export { test } from './test.decorator';

lib/suite.decorator.ts

@@ -1,6 +1,6 @@
 import playwright from '@playwright/test';
 
 type Constructor = { new (...args: any[]): any };
 
 interface SuiteDecoratorOptions {
   /**
@@ -18,10 +18,13 @@
     Object.assign(this, options);
   }
 
   private runSuite(userSuiteCode: () => Promise<any>) {
     return userSuiteCode();
   }
-
+
+  /**
+   * Run playwright.describe function using all collected data.
+   */
   run() {
     playwright.describe(this.name, () => {
       return this.runSuite(() => new this.suiteClass())
@@ -33,10 +36,16 @@
 
 /**
  * Mark class as test suite.
+ * Decorator creates a `describe` block and runs all methods decorated by `@test` inside it.
+ *
+ * Behaviour of decorator can be modified by other decorators using injected `suiteDecorator` property.
  */
 export const suite = (options: SuiteDecoratorOptions = {}) => function<T extends Constructor>(constructor: T, context?: ClassMethodDecoratorContext) {
   const suiteDecorator = new SuiteDecorator(constructor, options);
-
+
+  /**
+   * Decorate class by `suiteDecorator` property, to allow other decorators to modify suite behaviour / options.
+   */
   Object.assign(constructor, { suiteDecorator });
 
   context?.addInitializer(() => {

lib/test.decorator.ts

@@ -1,4 +1,5 @@
 import playwright from '@playwright/test';
+import {decoratePlaywrightTest, TestDecoratorFunction} from "./helpers";
 
 interface TestDecoratorOptions {
   /**
@@ -10,28 +11,40 @@
 class TestDecorator implements TestDecoratorOptions {
   name: string;
 
   constructor(private testMethod: any, options: TestDecoratorOptions) {
     this.name = testMethod.name;
 
     Object.assign(this, options);
   }
-
+
+  /**
+   * Run playwright.test function using all collected data.
+   */
   run(executionContext: any) {
-    // playwright function do not accept ...rest arguments, so we need to request all of them and pass to the testMethod manually
-    playwright(this.name, ({playwright, context, browserName, browser, contextOptions, connectOptions, page, testIdAttribute, launchOptions, defaultBrowserType, baseURL, channel, acceptDownloads, bypassCSP, deviceScaleFactor, extraHTTPHeaders, httpCredentials, ignoreHTTPSErrors, geolocation, hasTouch, headless, isMobile, javaScriptEnabled, locale, navigationTimeout, actionTimeout, offline, permissions, proxy, request, serviceWorkers, screenshot, trace, storageState, timezoneId, video, viewport, userAgent, colorScheme
-                           }, ...args) => {
-      return this.testMethod.call(executionContext, {playwright, context, browserName, browser, contextOptions, connectOptions, page, testIdAttribute, launchOptions, defaultBrowserType, baseURL, channel, acceptDownloads, bypassCSP, deviceScaleFactor, extraHTTPHeaders, httpCredentials, ignoreHTTPSErrors, geolocation, hasTouch, headless, isMobile, javaScriptEnabled, locale, navigationTimeout, actionTimeout, offline, permissions, proxy, request, serviceWorkers, screenshot, trace, storageState, timezoneId, video, viewport, userAgent, colorScheme}, ...args);
-    })
+    const decoratedTest: TestDecoratorFunction = (testFunction) => (...args) => {
+      // set correct executionContext (test class)
+      return testFunction.call(executionContext, ...args);
+    };
+
+    const decoratedTestMethod = decoratePlaywrightTest(
+      this.testMethod,
+      decoratedTest
+    );
+
+    playwright(this.name, decoratedTestMethod);
   }
 }
 
 export type TestDecoratedMethod = { testDecorator: TestDecorator };
 
 /**
  * Mark method as test.
- * Method class should be marked with @suite decorator
+ * Decorator creates a `test` block and runs method inside it.
+ * Target class should be marked by @suite decorator.
+ *
+ * Behaviour of decorator can be modified by other decorators using injected `testDecorator` property.
  */
 export const test = (options: TestDecoratorOptions = {}) => function(originalMethod: any, context: any) {
   const testDecorator = new TestDecorator(originalMethod, options);
 
   Object.assign(originalMethod, { testDecorator });