Add resetPage and resetBrowser (#184)

* Add resetPage

* Add resetBrowser

* Add Readme

* Update README.md

* Add resetContext

* Add resetContext to readme

Co-authored-by: Max Schmitt <max@schmitt.mx>

Author: mmarkelov

README.md

@@ -148,6 +148,38 @@ Debugging tests can be hard sometimes and it is very useful to be able to pause
 await jestPlaywright.debug()
 ```
 
+## Reset helper functions
+
+### Reset current page
+
+```js
+beforeEach(async () => {
+  await jestPlaywright.resetPage()
+})
+```
+
+To create a new page for each test, you can use this snippet to have a new page object for each individual test.
+
+### Reset current context
+
+```js
+beforeEach(async () => {
+  await jestPlaywright.resetContext()
+})
+```
+
+To create a new context for each test, you can use this snippet to have a new context object for each individual test.
+
+### Reset current browser
+
+```js
+beforeEach(async () => {
+  await jestPlaywright.resetBrowser()
+})
+```
+
+You can use this snippet to reset current browser for each individual test. It will reset browser, context and page.
+
 ## Tracking the coverage
 
 It's possible to track the coverage of the end-to-end tests with the [babel-plugin-istanbul](https://github.com/istanbuljs/babel-plugin-istanbul) Babel plugin configured. It needs to be included in the web application which you are gonna test otherwise it won't work. To use it, you have to set `collectCoverage` in the `jest-playwright.config.js` to `true`. Per default the test coverage will be automatically saved after each navigation change (`beforeunload` event). If a certain code path is not covered, you can manually call and add the corresponding `saveCoverage(page)` call to your tests like that:

src/PlaywrightEnvironment.ts

@@ -153,6 +153,48 @@ export const getPlaywrightEnv = (basicEnv = 'node'): unknown => {
           this.global.it = it
           this.global.test = test
         },
+        resetPage: async (): Promise<void> => {
+          const { context, page } = this.global
+          if (page) {
+            page.removeListener('pageerror', handleError)
+            await page.close()
+          }
+
+          this.global.page = await context.newPage()
+          if (exitOnPageError) {
+            this.global.page.addListener('pageerror', handleError)
+          }
+        },
+        resetContext: async (): Promise<void> => {
+          const { browser, context } = this.global
+
+          if (context) {
+            await context.close()
+          }
+
+          this.global.context = await browser.newContext(contextOptions)
+
+          await this.global.jestPlaywright.resetPage()
+        },
+        resetBrowser: async (): Promise<void> => {
+          const { browser } = this.global
+
+          if (browser) {
+            await browser.close()
+          }
+
+          this.global.browser = await getBrowserPerProcess(
+            playwrightInstance,
+            browserType,
+            this._jestPlaywrightConfig,
+          )
+
+          this.global.context = await this.global.browser.newContext(
+            contextOptions,
+          )
+
+          await this.global.jestPlaywright.resetPage()
+        },
         debug: async (): Promise<void> => {
           // Run a debugger (in case Playwright has been launched with `{ devtools: true }`)
           await this.global.page.evaluate(() => {

types/global.d.ts

@@ -3,6 +3,36 @@ import type { SkipOption } from '../src/types'
 
 interface JestPlaywright {
   skip: (skipOptions: SkipOption, callback: Function) => void
+  /**
+   * Reset global.page
+   *
+   * ```ts
+   * it('should reset page', async () => {
+   *   await jestPlaywright.resetPage()
+   * })
+   * ```
+   */
+  resetPage: () => Promise<void>
+  /**
+   * Reset global.context
+   *
+   * ```ts
+   * it('should reset context', async () => {
+   *   await jestPlaywright.resetContext()
+   * })
+   * ```
+   */
+  resetContext: () => Promise<void>
+  /**
+   * Reset global.browser, global.context, and global.page
+   *
+   * ```ts
+   * it('should reset page', async () => {
+   *   await jestPlaywright.resetBrowser()
+   * })
+   * ```
+   */
+  resetBrowser: () => Promise<void>
   /**
    * Suspends test execution and gives you opportunity to see what's going on in the browser
    * - Jest is suspended (no timeout)