Sinon.JS VS Playwright

Mocha is a simple and flexible JavaScript testing framework for browser and Node.js applications. Unlike other testing frameworks, it takes a minimalist approach and relies on external libraries for key tasks. It uses Sinon for handling spies, stubs, and mocks, and Chai as the assertion engine. Mocha is extensible through many plugins and can integrate with most test runners.

As Obsidian code is not available; we must provide some alternate implementation. If you're familiar with sinon, you might think we can create a stubbed instance like this:

If you are using a mocking library, such as sinon, jest-mock, or ts-mockito, make sure that it is compatible with Jest. You may need to install additional packages or configure them in your configuration file. For example, to use sinon with Jest, you can install the sinon-jest package and add the following to your configuration file:

Mocha is a test runner, Chai is an assertion library, Sinon is a mocking library, this normally the combination you would need to use if you choose mocha, but there are others.

Instead, use pure functions + dependency inject your stubs (e.g. parameter to function). Also note, no need for Sinon or some other test double library. JavaScript is so good nowadays to easily make objects/classes/functions or any combination thereof on the fly that are terse.

I've had some good experiences with Ava + Sinon. I've personally disliked Jest because it seemed to do some weird trickery in the background that prevented me from using ES modules.

🤖 You can use the Mocha testing framework with the Chai assertion library to write tests for your Express controller. You can also use the Sinon library to mock the database calls. This will allow you to test the controller without actually making a call to the database. You can also use the SuperTest library to make HTTP requests to the controller and test the response.

You can use sinon js to create a mock version of your http library (axios) that responds with the data you’re expecting.

Assertions are the checkpoints of our test block that confirm if an automated test has passed or failed. Cypress bundles the Chai, jQuery, and Sinon.JS libraries for assertions. They check the desired, expected application in which the test is running. A complete listing of assertions can be found in the documentation here.

ES module is basically a "class" that you inject dependencies into through imports. And for tests you just use something like sinon to swap module dependencies for mocks.

3/3 4min 4min

The optimization of the sharding algorithm is considered in E2E testing tools where test execution time is a more critical issue. In Playwright, this is being discussed in https://github.com/microsoft/playwright/issues/17969.

When working with end-to-end testing frameworks like Playwright, handling network requests is often a complex task. Tests that rely on external APIs can be slow and inconsistent, introducing unnecessary flakiness. Network calls that succeed in one test run might fail in the next due to a slow or unreliable server, resulting in inconsistent results. To address this, developers often resort to mocking network requests, which introduces another challenge: managing mocks.

import { test } from '@playwright/test'; test.describe('Annotated tests group', { annotations: [{ type: 'category', description: 'report' }], }, () => { test('test report header', async ({ page }) => { // Test implementation }); test('test full report', { annotations: [ { type: 'issue', description: 'https://github.com/microsoft/playwright/issues/23180' }, { type: 'performance', description: 'very slow test!' }, ], }, async ({ page }) => { // Test implementation }); });

Playwright - functional tests

Both testing frameworks support TypeScript. Cypress handles asynchronous events with a wrapper that looks similar to Promises, while Playwright uses native Promises and supports async/await syntax. It's important to note that Cypress code is executed in the browser, whereas Playwright runs in a 'Node' environment and communicates with the browser through the DevTools protocol. As a result, environment variables can be accessed directly at runtime, which might be useful for passing test-user credentials or other test-related data.

Link

Microsoft recently announced (July 2024) support for certificate-based authentication (CBA) for Microsoft Entra. CBA is a phishing-resistant, passwordless, and convenient way to authenticate users with X.509 certificates without relying on passwords. With the recent v1.46 release of Playwright, you can now use this method to authenticate with Entra.

Link to Playwright repository - https://github.com/microsoft/playwright

Playwright v1.46 ships with a nifty new feature for local development. By specifying the --only-changed option, Playwright looks at uncommited changes and runs all affected test files.