Serenity/JS

Visit Website

Introduction

Serenity/JS is a TypeScript-native framework that gives Playwright Test, WebdriverIO or Cucumber suites, in the README’s words, ‘the architecture it needs to scale’. It does not replace your runner or browser driver. It adds a way of structuring tests and a reporting layer on top of them.

The structure is the Screenplay Pattern. Tests are written in terms of actors who perform tasks, such as Authenticate.withCredentials(...) or Checkout.complete(), and ask questions about the system. Each task is built from smaller interactions, so the same task can be reused across scenarios, runners and even interfaces. The README frames this as a fix for duplicated selectors and test logic.

Serenity/JS modules cover web testing (with Playwright or WebdriverIO), REST API testing (built on Axios), assertions and local servers. Because an actor can use several abilities at once, a single scenario can call an API to set up data, then drive the browser, then verify the result through the API again.

Reporting is the other half. Serenity/JS records every interaction with timing and screenshots and can produce living documentation through Serenity BDD reports, as well as console output for each runner. These reports show what a test did in business language, which is useful for audits and for explaining failures to non-developers.

In the quality loop, Serenity/JS fits the acceptance and end-to-end stage, and the API stage when tests combine both. It suits teams with large, long-lived suites where design and reuse matter more than getting started in five minutes.

The source code is at serenity-js/serenity-js on GitHub under the Apache-2.0 licence, with about 624 stars; the most recent commit was on 10 November 2026.

The main reason to choose Serenity/JS is structure rather than raw speed. The Screenplay Pattern asks you to model actors, their abilities, and the tasks and questions they use, which takes more design effort up front than writing page objects. In return, large suites tend to stay readable, because business-level tasks are reused across web, API and mobile tests, and the reports explain what each actor did in plain language. It suits teams with several squads sharing one acceptance suite, or teams that want living documentation for stakeholders. Small projects with a few smoke tests may find the abstraction heavier than they need.

A practical way to evaluate it is to port one existing end-to-end scenario, keep the same runner your team already uses, and compare readability and failure diagnosis with the current version.

Features

1. Screenplay Pattern: Actors, abilities, tasks, interactions and questions give suites a reusable structure.
2. Runner integrations: Works with Playwright Test, WebdriverIO, Cucumber, Mocha and Jasmine.
3. Web testing: Browser interactions through Playwright or WebdriverIO modules.
4. REST API testing: An API module lets actors call HTTP endpoints in the same scenario.
5. Assertions: A dedicated assertions module with Ensure and readable expectations.
6. Living documentation: Detailed reports, including Serenity BDD reports, that show every step.
7. Screenshots and timing: Interactions are recorded with timing data and optional screenshots.
8. TypeScript-first: Strong typing for tasks and questions.

Pros

1. Scales with suite size: Reusable tasks keep large suites maintainable.
2. Business-readable reports: Reports explain what happened in domain language.
3. Free to use: Open source under the Apache-2.0 licence, so the core tool costs nothing to use.
4. Actively maintained: The repository had commits as recent as 10 November 2026.

Cons

1. Learning curve: The Screenplay Pattern takes time to learn and can feel heavy for small suites.
2. More code up front: Defining tasks and questions is extra work compared with inline test steps.
3. Smaller community: About 600 GitHub stars; most help comes from the official docs and community chat.

Usage and Links (Example)

Add Serenity/JS to a Playwright Test project:

npm install --save-dev @serenity-js/core @serenity-js/playwright-test @serenity-js/web @serenity-js/assertions

import { describe, it } from '@serenity-js/playwright-test'
import { Ensure, equals } from '@serenity-js/assertions'
import { Navigate, Text, PageElement, By } from '@serenity-js/web'

const heading = () => PageElement.located(By.css('h1')).describedAs('heading')

describe('home page', () => {
  it('shows the product name', async ({ actor }) => {
    await actor.attemptsTo(
      Navigate.to('/'),
      Ensure.that(Text.of(heading()), equals('CheckOps')),
    )
  })
})

Practical tips:

1. Start by wrapping a few common flows (login, checkout) as tasks.
2. Generate Serenity BDD reports in CI and publish them as artifacts.

Resources:

• Serenity/JS website
• GitHub repository

Pricing

Serenity/JS is free and open source under the Apache-2.0 licence.

Recommended for?

1. Teams with large acceptance suites that suffer from duplicated steps and selectors.
2. BDD teams using Cucumber who want structured, reusable step code.
3. Organisations that need detailed, readable test reports.
4. Not a fit for small projects or teams that want minimal abstraction.

Conclusion

Serenity/JS brings the Screenplay Pattern and living documentation to modern JavaScript test runners. It is actively released and well documented.

It asks for more design work up front, but pays it back on suites that need to stay readable and reusable for years.

On CheckOps, Serenity/JS is filed under the End-to-end & functional and API & contract testing stages. Related tools listed here include Serenity BDD, Playwright, WebDriverIO, Cucumber, CodeceptJS and Playwright-BDD. Before choosing, compare them on licence, supported languages and platforms, hosting model, and how well each fits your existing CI pipeline. Facts on this page were checked against the official website, documentation and repository on 11 November 2026; statements the vendor makes about its own product are marked as vendor claims.