DEV Community: PURISTA

PURISTA - Tests with Jest, Sinon.js and Testcontainers

Sebastian Wessel — Tue, 12 Sep 2023 08:48:46 +0000

In the journey of crafting the PURISTA TypeScript backend framework, the need for automated software testing became increasingly apparent.
PURISTA's extensive amount of adapters and integrations with third-party solutions makes it impractical to conduct manual testing repeatedly.
In this article, we dive into the pivotal role of automated testing in ensuring the reliability and stability of PURISTA's offerings.

Moreover, enabling developers to effortlessly test their code built on top of PURISTA stands as a pivotal aspect of the framework.

Jest

Jest offers a comprehensive test suite where you can efficiently organize, implement, and execute your tests. With approximately 1490 contributors, Jest has played a pivotal role in simplifying the process of writing tests, as demonstrated below:

import { asyncOperation, syncOperation } mytestfile.test.js

describe('My testfile works', ()=>{
  it('is exected to be ok', () => {
    const result = syncOperation()
    expect(result).toBe('OK')
  })

  it('works with async await', async ()=>{
    const result = asyncOperation()
    await expect(result).resolves.toBe('OK')
  })
})

As the number on GitHub shows: This awesome tool is used by 10.4 millions!
This unbelievable number shows, how important it is.

A massive shout-out to Jest and all its dedicated contributors! Consider starring it on GitHub, giving a shout-out on social media, or mentioning it in your readme file to show your appreciation. 🌟👏

We use Jest together with @swc/jest, which speeds up our test runs dramatically.
They don't lie with "Super-fast alternative for babel-jest or ts-jest without type checking".
It's the second great tool by Vercel we use at PURISTA.

Sinon.js

When writing tests, you probably will come to the point where you need to mock, fake or spy on something. Even if the test framework is providing some helpers for it, you should have a look at Sinon.js.

At PURISTA, we primarily leverage Sinon.js to deliver a seamless testing experience for developers.
We provide for example the getLoggerMock function, which returns an easy way to test logging, without poluting the test runner output.

This function looks like this:

export const getLoggerMock = (sandbox?: SinonSandbox) => {
  const info = sandbox?.stub() || stub()
  const error = sandbox?.stub() || stub()
  const warn = sandbox?.stub() || stub()
  const debug = sandbox?.stub() || stub()
  const trace = sandbox?.stub() || stub()
  const fatal = sandbox?.stub() || stub()

  const mock: Logger = {
    info,
    error,
    warn,
    debug,
    trace,
    fatal,
    getChildLogger: () => mock,
  }

  return {
    stubs: {
      info,
      error,
      warn,
      debug,
      trace,
      fatal,
    },
    mock,
  }
}

As you can see, we've created stubs, which are a form of mock implementations. You can use them to check whether a stub is called, how many times it's called, if it's called with specific parameters, and more. Additionally, Sinon.js offers sandboxing, a highly recommended feature. It prevents your tests from interfering with each other, ensuring clean and reliable results.

As an example on how it might look:

import { Logger } from '@purista/core'
import { createSandbox } from 'sinon'

function syncOperation(logger: Logger) {
   logger.info('info log')
   return 'OK'
}

describe('My testfile works', ()=>{
  const sandbox = createSandbox()

  afterEach(() => {
    sandbox.reset()
  })

  it('is exected to be ok', () => {
    const loggerMock = getLoggerMock()

    const result = syncOperation(loggerMock.mock)
    expect(result).toBe('OK')
    expect(loggerMock.stub.info.calledOnceWith('info log')).toBeTruthy()
  })

})

Sinon.js is unbelievably helpful, and the 328 contributors are doing an incredible job. It's no surprise that Sinon.js is trusted by over 574k developers. Show them some love with a big shout-out and a star on GitHub!

If you haven't used Sinon.js before, it's definitely worth giving it a try.

Testcontainers

To be honest, Testcontainers wasn't on our radar initially.
However, we soon realized the need for a viable solution to conduct integration tests for:

Testcontainers was the gamechanger here.
It is super easy to spin up a docker container and run tests against a real running system.

To show you, how simple it is:

Here is the example, on how start a full RabbitMQ before we run our tests:

import { GenericContainer, StartedTestContainer } from 'testcontainers'

const AMQP_PORT = 5672

describe('@purista/amqpbridge', () => {
  let container: StartedTestContainer

  beforeAll(async () => {
    container = await new GenericContainer('rabbitmq:alpine')
      .withExposedPorts({ host: AMQP_PORT, container: AMQP_PORT })
      .start()
  })

  afterAll(async () => {
    await container.stop()
  })

It significantly enhanced our local testing process. Furthermore, Testcontainers is a versatile tool available for multiple programming languages.

A heartfelt thank you to all the contributors of Testcontainers for this incredible project! We deeply appreciate the outstanding work you've put into it.

If you're searching for content ideas for the next article, consider crafting a cool piece about Testcontainers and its practical applications. Dive into how to harness its power effectively.

Now that we've explored the powerful tooling required to build PURISTA itself, let's shift our focus to the components under the hood that make PURISTA tick.

Be sure to check out the upcoming article in this series!

PURISTA: Build with rimraf, esbuild, Turbo & git-cliff

Sebastian Wessel — Mon, 11 Sep 2023 21:15:26 +0000

In our previous article, we laid the foundation with a glimpse of our coding setup.

It's now time to spotlight the indispensable build tools that power its development.

rimraf

Huge thanks to Isaacs!
Rimraf comes to the rescue, providing a reliable solution for deep, recursive removal of folders and files.
At PURISTA, we rely on rimraf to maintain pristine build output directories.

Turbo

PURISTA is organized in a monorepo.
During the development and build process, Turbo is used to execute different tasks and steps on multiple packages with one command.

We aren't harnessing the full potential and capabilities of Turbo at the moment since PURISTA currently requires only a few straightforward build tasks.

If you have more complex tasks, especially those with interdependencies between steps, it's worth exploring https://turbo.build

Esbuild

In its early stages, PURISTA was built using the standard TypeScript compiler.
However, this approach excelled in creating CommonJS packages but turned into a nightmare when it came to generating ESM builds.

esbuild - the rescue!
No longer struggling with configs, file extensions or similar.

With esbuild, it was becoming simple and fast.

We created a small script:

const esbuild = require('esbuild')

esbuild
  .build({
    entryPoints: ['./src/index.ts'],
    outfile: './lib/esm/index.mjs',
    bundle: true,
    format: 'esm',
    splitting: false,
    platform: 'node',
    sourcemap: false,
    target: 'node18',
    minify: true,
    packages: 'external',
  })
  .catch(() => process.exit(1))

esbuild
  .build({
    entryPoints: ['./src/index.ts'],
    outfile: './lib/cjs/index.cjs',
    bundle: true,
    format: 'cjs',
    splitting: false,
    platform: 'node',
    sourcemap: false,
    target: 'node18',
    minify: true,
    packages: 'external',
  })
  .catch(() => process.exit(1))

Since this approach only generates JavaScript files, and we aim to provide proper TypeScript types to PURISTA users, we utilize the TypeScript compiler specifically for building types.

tsc --emitDeclarationOnly --declarationMap false --declaration --outDir lib/types

In package.json, only these additions were necessary:

{
  "directories": {
      "lib": "lib/index.js"
  },
  "main": "./lib/cjs/index.cjs",
  "module": "./lib/esm/index.mjs",
  "exports": {
      ".": {
          "import": "./lib/esm/index.mjs",
          "require": "./lib/cjs/index.cjs",
          "types": "./lib/types/index.d.ts"
      }
  },
  "typings": "lib/types/index.d.ts",
  "files": [
      "lib"
  ]
}

A big thank you ❤️ to all contributors and maintainers of esbuild!
It solved the issue with CommonJS/ESM for us and produces size optimized outputs for all PURISTA packages.

git-cliff

Changelogs are nice and everybody likes them, but nobody wants to maintain them 😜.
Here, git-cliff by Orhun Parmaksız is one simple to use solution.

One simple command:

git-cliff > CHANGELOG.md

And your changelog gets generated from your git history.

Undoubtedly one of the time-saving tools, you should check out at https://git-cliff.org

In the upcoming article of this series, we will delve deeper into the test setup. Stay tuned!

PURISTA - Thanks to amazing open-source software

Sebastian Wessel — Mon, 11 Sep 2023 20:17:57 +0000

Welcome to our series on the unsung heroes behind PURISTA!

Ever wondered about PURISTA?
It's not just another Typescript backend framework for simply building HTTP-endpoints.
It's a versatile solution that embraces diverse techniques for highly distributed deployments, taking inspiration from event-driven architecture.
If you're interested, you're invited to take a look at the official website http://purista.dev.

But hold on, this series isn't about the framework itself. Instead, we're here to shine a spotlight on the incredible libraries, tools, software, and passionate contributors that make PURISTA possible.

In this series, we will introduce all the tools, explain how we use them, why we find them essential, and endeavor to illustrate why they might also be a suitable solution for you.

General setup

Most developers should be more or less familiar with the basic setup.

VSCode as a code editor with ESLint plugin.

GitHub is uses as repository, issue & project tracker, and also for hosting the official website.

Coding Setup

In addition to Node.js and TypeScript, we rely on two indispensable tools available as npm modules:

ESLint and Prettier

Maintaining a clean, readable, and consistent codebase is essential, and ESLint and Prettier are the perfect tools for the job.
Just enable "lint on save" in VSCode, and you won't have to worry about it. They're a "must-have," even for small personal projects.

See https://eslint.org and https://prettier.io

ESLint is extended by some awesome plugins and extensions:

eslint-plugin-simple-import-sort by Simon Lydell @SimonLydell
eslint-plugin-node by Toru Nagashima - Dev.to: @mysticatea & Twitter: @mysticatea
eslint-plugin-json by Azeem Bande-Ali
eslint-plugin-import
eslint-config-standard

In our upcoming article, we'll delve deep into the inner workings of PURISTA's build pipeline. Stay tuned for an in-depth exploration!

The power of PURISTA TypeScript Framework v1.7

Sebastian Wessel — Thu, 01 Jun 2023 14:09:29 +0000

Are you looking for a robust and versatile framework to streamline your application development process?
Look no further than PURISTA TypeScript Framework v1.7!

With its latest release, PURISTA introduces a range of exciting features and improvements that empower developers to build efficient and scalable applications.
Let's explore how PURISTA v1.7 can revolutionize your development workflow.

Seamless Messaging with NATS

Communication between microservices is essential for building complex applications.

PURISTA v1.7 integrates NATS, a lightweight and high-performance messaging system, as a message broker option.

This integration simplifies message transmission and enhances the overall messaging capabilities of your application.

Say goodbye to communication bottlenecks and hello to seamless microservice interactions.

Enhanced State and Configuration Management

PURISTA v1.7 introduces two powerful features for state and configuration management.

The NATS State Store allows you to store and retrieve application-specific data within the JetStream enabled NATS server.

This feature enables efficient state management and simplifies data access, resulting in improved performance and scalability.

In addition, the NATS Config Store provides a centralized solution for managing configuration data in your JetStream enabled NATS server.

Store and retrieve application configurations effortlessly, ensuring consistency and flexibility across your deployment environments.

But that's not all!

PURISTA v1.7 also offers Redis Config Store integration, leveraging the robustness and speed of Redis to manage your application configurations effectively.

With multiple options for configuration storage, you have the freedom to choose the solution that best fits your needs.

Enhanced Security with Infisical Secret Store

Data security is paramount in modern applications.

PURISTA v1.7 introduces the Infisical Secret Store feature, providing a secure vault for storing and accessing sensitive information.

Safeguard your API keys, authentication tokens, and other confidential data with ease.

Rest easy knowing your application's secrets are protected by PURISTA's robust security measures.

Breaking Changes for Enhanced Messaging

PURISTA v1.7 brings significant improvements to the messaging structure.

Previously, messages only contained the instanceId of the sender.

However, with the latest release, PURISTA enhances the messaging architecture by moving the instanceId of the sender to the sender property.

Additionally, the instanceId of the receiver (if available) is now included in the receiver property.

This change simplifies subscription targeting and eliminates the need for redundant message publications, resulting in a more efficient and streamlined messaging experience.

Improved Stability and Documentation

PURISTA v1.7 focuses on improving stability and usability.

The framework comes with a slew of bug fixes, ensuring a smoother development experience.

Additionally, the documentation has been extensively enhanced, providing comprehensive guidance and examples to help you make the most of PURISTA's features. Whether you're a seasoned PURISTA user or new to the framework, the updated documentation serves as a valuable resource for mastering the framework's capabilities.

Embrace PURISTA TypeScript Framework v1.7 Today

If you're looking to build robust, scalable, and efficient applications, PURISTA TypeScript Framework v1.7 is your ultimate solution.

Harness the power of NATS as a message broker, leverage state and configuration management features, ensure data security with the Infisical Secret Store, and benefit from the enhanced messaging structure.

Take advantage of the improved stability and comprehensive documentation to accelerate your development process.

Visit the official PURISTA website purista.dev to learn more about PURISTA v1.7 and embark on a new era of application development.
Unleash your creativity, enhance collaboration, and deliver exceptional software solutions with PURISTA TypeScript Framework v1.7.