End-to-end testing with Playwright

Playwright (opens in a new tab) is a testing framework that allows you to write reliable end-to-end tests in JavaScript. Great work by the OpenMRS QA team means that we now have Playwright set up across most of our key repositories.

This means that we can now write e2e tests for key user journeys in the OpenMRS frontend. These tests are setup to run both on commit and merge. Developers are encouraged to keep the tests passing, and wherever possible, consider extending them to fit any new use cases. Ideally, each pull request ought to be accompanied by the tests that assert that the logic presented works as expected.

To get started, you’ll typically need to install playwright:

npx playwright install

We recommend installing the official Playwright VS Code plugin (opens in a new tab). This will give you access to the Playwright test runner, which you can use to run your tests. You can also use the npx playwright test command to run your tests. We also recommend following the best practices (opens in a new tab) outlined in the Playwright documentation. This will help you write tests that are reliable and easy to maintain.

Writing tests

In general, it is recommended to read through the official Playwright docs (opens in a new tab) before writing new test cases. The project uses the official Playwright test runner and, generally, follows a very simple project structure:

e2e
|__ commands
|   ^ Contains "commands" (simple reusable functions) that can be used in test cases/specs,
|     e.g. generate a random patient.
|__ core
|   ^ Contains code related to the test runner itself, e.g. setting up the custom fixtures.
|     You probably need to touch this infrequently.
|__ fixtures
|   ^ Contains fixtures (https://playwright.dev/docs/test-fixtures) which are used
|     to run reusable setup/teardown tasks
|__ pages
|   ^ Contains page object model classes for interacting with the frontend.
|     See https://playwright.dev/docs/test-pom for details.
|__ specs
|   ^ Contains the actual test cases/specs. New tests should be placed in this folder.
|__ support
    ^ Contains support files that requires to run e2e tests, e.g. docker compose files.

When you want to write a new test case, start by creating a new spec in ./specs. Depending on what you want to achieve, you might want to create new fixtures and/or page object models. To see examples, have a look at the existing code to see how these different concepts play together.

The spec files contain scenarios written in a BDD-like syntax. In this syntax, we utilize Playwright's test.step calls and emphasize a user-centric focus by using the "I" keyword. For more information on BDD-like syntax, you can refer to the documentation at https://cucumber.io/docs/gherkin/reference/ (opens in a new tab). This resource provides detailed information on Gherkin, the language used for writing BDD specifications. The code snippet below demonstrates how this BDD-like syntax is employed to write a test case:

test("Search patient by patient identifier", async ({ page, api }) => {
  // extract details from the created patient
  const openmrsIdentifier = patient.identifiers[0].display.split("=")[1].trim();
  const firstName = patient.person.display.split(" ")[0];
  const lastName = patient.person.display.split(" ")[1];
  const homePage = new HomePage(page);
 
  await test.step("When I visit the home page", async () => {
    await homePage.goto();
  });
 
  await test.step("And I enter a valid patient identifier into the search field", async () => {
    await homePage.searchPatient(openmrsIdentifier);
  });
 
  await test.step("Then I should see only the patient with the entered identifier", async () => {
    await expect(homePage.floatingSearchResultsContainer()).toHaveText(/1 search result/);
    await expect(homePage.floatingSearchResultsContainer()).toHaveText(new RegExp(firstName));
    await expect(homePage.floatingSearchResultsContainer()).toHaveText(new RegExp(lastName));
    await expect(homePage.floatingSearchResultsContainer()).toHaveText(new RegExp(openmrsIdentifier));
  });
 
  await test.step("When I click on the patient", async () => {
    await homePage.clickOnPatientResult(firstName);
  });
 
  await test.step("Then I should be in the patient's chart page", async () => {
    await expect(homePage.page).toHaveURL(
      `${process.env.E2E_BASE_URL}/spa/patient/${patient.uuid}/chart/Patient Summary`
    );
  });
});

Running tests locally

To run e2e tests locally, you'd need to fire up a dev server running the frontend module whose tests you want to run.

yarn start --sources "packages/esm-patient-conditions-app"

# 8080 is the default port for the dev server
export E2E_BASE_URL=http://localhost:8080

yarn test-e2e ---headed --ui

yarn test-e2e conditions-form.spec.ts

yarn test-e2e specs/conditions specs/programs

yarn test-e2e conditions

yarn test-e2e conditions -g "Record and edit a condition"

Demo data usage in E2E tests

To ensure that the test contains the necessary metadata, you may follow the procedures outlined below:

1. Utilize the user interface - Suppose the test scenario involves editing patient information. In this case, you can use the UI to create a new patient record for testing purposes.
2. Leverage demo data - If the test case only requires data viewing, the demo data available in the RefApp can suffice. Check the demo data module to know more.
3. Generate the required data - In case the above solutions are inadequate, you can use the API to create the necessary data ahead of the test.

Debugging Tests

Refer to this documentation (opens in a new tab) on how to debug a test.

View test reports from GitHub Actions / Bamboo

To download the report from the GitHub action/Bamboo plan, follow these steps:

1. Go to the artifact section of the action/plan and locate the report file.
2. Download the report file and unzip it using a tool of your choice.
3. Follow the steps mentioned in this guide on how to view the HTML report (opens in a new tab)

The report will show you a full summary of your tests, including information on which tests passed, failed, were skipped, or were flaky. You can explore the details of individual tests, including any errors or failures, video recordings, traces and the steps involved in each test. Simply click on a test to view its details.

Do's and Don'ts

• Do ensure that all test cases are written clearly and concisely, with step-by-step instructions that can be easily understood.
• Do use a variety of test cases to cover all possible scenarios, including best-case scenarios, worst-case scenarios, and edge cases.
• Do ensure that all tests are executed in a timely and efficient manner to save time and resources.
• Don't assume that a feature is working just because it seems to be functioning correctly. Test it thoroughly to ensure that all its features and functionalities are working as expected.
• Don't ignore any errors or issues that arise during testing, even if they seem minor. Report them to the development team so that they can be addressed promptly.
• Don't skip any critical paths or scenarios. Ensure that all scenarios are tested thoroughly to identify any potential issues or defects.

Best Practices

• Start testing early in the development process to identify and address issues before they become more challenging and expensive to fix.
• Utilize automated testing whenever possible to save time and increase efficiency.
• Use real-world data and scenarios to create accurate and relevant test cases.
• Ensure that all test cases are repeatable and easily reproducible to ensure that results can be verified and tested again if necessary.
• Continuously review and update the testing plan to ensure that it covers all relevant features and scenarios.
• Work collaboratively with the O3 team to ensure that any issues or defects are identified and resolved quickly.

Automating the E2E tests with GitHub Actions

Automating end-to-end (E2E) tests through GitHub Actions provides an efficient way to ensure the reliability of software changes.

Dockerized test environment

Our E2E tests are executed in a dockerized environment for each pull request and commit to the O3 repositories. This approach offers several advantages over traditional methods:

• Reduced Dependency on Dev3 Server: By utilizing a dockerized environment, the E2E tests are not reliant on the status or availability of the dev3 server. This independence ensures that testing can proceed even if the dev3 server is experiencing issues.

• Isolated Test Runs: Running tests on PRs and commits within isolated docker containers eliminates conflicts between data. This isolation prevents scenarios where testing data conflicts with other ongoing tests or development activities.

• Minimized Impact of Failures: Failures within the E2E tests do not impact the status or stability of the dev3 server. This separation ensures that the main development environment remains unaffected by testing failures.

Optimization of Testing Process

To enhance the efficiency of the E2E testing process, we have implemented several optimization methods:

1. Pre-filled Docker Images: The backend and database docker images used for automated e2e testing are pre-filled with necessary data and configurations. This eliminates the need to generate data during the initial setup of the testing environment. Consequently, the setup time is significantly reduced, enabling quick creation of the test instance.

2. Dynamic Lightweight Frontend: To execute automated tests, a dynamic lightweight version of the frontend is used. This version exclusively includes apps and changes present in the current repository, along with essential esm-apps like the primary navigation app. This frontend image is built during the E2E tests' GitHub Actions workflow.

The pre-filled backend and database docker images, along with the dynamically built lightweight frontend image, are combined within the same docker-compose stack and used for setting up the e2e test environment.

Additional Implementation Details

Docker Image Generation: The pre-filled docker images are created and pushed to the Docker Hub through a dedicated bamboo stage within the REFAPP-D3X (opens in a new tab) bamboo job. This stage involves a script that retrieves the latest versions of both the frontend and backend. It then runs and waits for data generation before building the :nightly-with-data docker images of the backend and database. These images are subsequently pushed to the Docker Hub. More details on this can be found here (opens in a new tab).

Troubleshooting

If you can't debug tests in UI mode (opens in a new tab) because your local web server reloads due to static file changes, use the Playwright Inspector (opens in a new tab) instead. Run the following command:

yarn test-e2e --headed --debug

This approach should avoid issues caused by Webpack and static file changes.