Forem: Poitier Stringer

A chatGPT conversation about test frameworks

Poitier Stringer — Thu, 16 Feb 2023 21:40:13 +0000

Me: Can you describe tools for adding scripts within an application built on nest.js for the purpose of adding dummy data to a connected database?

GPT:
Sure! Nest.js is a popular framework for building server-side applications using Node.js. To add dummy data to a connected database in a Nest.js application, you can use a combination of Nest.js built-in functionality and third-party packages.

Here are some tools you can use:

Nest.js CLI: The Nest.js CLI is a command-line interface that allows you to generate Nest.js modules, controllers, and services. You can use the CLI to generate a script that will populate your database with dummy data. To do this, run the command nest generate script and provide a name for your script.
TypeORM: TypeORM is an Object Relational Mapping (ORM) library for TypeScript and JavaScript. It provides a way to interact with your database using TypeScript classes, making it easier to work with your data in a type-safe way. TypeORM includes a powerful data seeding feature that allows you to populate your database with dummy data. You can use TypeORM's data seeding feature in your Nest.js application to add dummy data to your connected database.
Faker.js: Faker.js is a JavaScript library for generating fake data. It provides a wide range of functions that can generate realistic data such as names, addresses, and dates. You can use Faker.js in your Nest.js application to generate dummy data for your database.

To use these tools together, you can create a script that uses Faker.js to generate fake data, and then use TypeORM to insert that data into your database. Here's an example script that uses these tools:

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import * as faker from 'faker';
import { User } from './user.entity';

@Injectable()
export class DummyDataService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
  ) {}

  async createDummyData() {
    for (let i = 0; i < 10; i++) {
      const user = new User();
      user.name = faker.name.findName();
      user.email = faker.internet.email();
      user.password = faker.internet.password();
      await this.userRepository.save(user);
    }
  }
}

In this example, the script generates ten fake users using Faker.js, and then saves them to the database using TypeORM's save method. You can then run this script using the Nest.js CLI by running the command nest run <script-name>.

ME:
Is it possible to do this using the test frameworks nest.js makes available?

GPT:
Yes, it is possible to use Nest.js testing framework to add dummy data to a connected database. In fact, using the testing framework can make it easier to write and run tests that require dummy data.

Here are the steps to add dummy data to a connected database using Nest.js testing framework:

Create a Nest.js testing module: Create a Nest.js testing module that imports the necessary modules, controllers, and services to work with your database. You can use the @nestjs/testing module to create a testing module.

import { Test, TestingModule } from '@nestjs/testing';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';
import { UserService } from './user.service';

describe('UserModule', () => {
  let module: TestingModule;

  beforeAll(async () => {
    module = await Test.createTestingModule({
      imports: [TypeOrmModule.forRoot(), TypeOrmModule.forFeature([User])],
      providers: [UserService],
      controllers: [UserController],
    }).compile();
  });

  afterAll(async () => {
    await module.close();
  });

  it('should be defined', () => {
    const controller: UserController = module.get<UserController>(UserController);
    expect(controller).toBeDefined();
  });
});

Use TypeORM to add dummy data: Once you have created a testing module, you can use TypeORM to add dummy data to your connected database. You can use the getRepository method to get access to the repository for the entity you want to add data to, and then use the save method to save the data to the database.

import { Test, TestingModule } from '@nestjs/testing';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';
import { UserService } from './user.service';

describe('UserModule', () => {
  let module: TestingModule;

  beforeAll(async () => {
    module = await Test.createTestingModule({
      imports: [TypeOrmModule.forRoot(), TypeOrmModule.forFeature([User])],
      providers: [UserService],
      controllers: [UserController],
    }).compile();

    const userRepository = module.get('UserRepository');
    await userRepository.save({ name: 'John Doe', email: 'johndoe@example.com' });
  });

  afterAll(async () => {
    await module.close();
  });

  it('should be defined', () => {
    const controller: UserController = module.get<UserController>(UserController);
    expect(controller).toBeDefined();
  });
});

In this example, the beforeAll hook is used to add a new user to the database using TypeORM's save method. The afterAll hook is used to close the testing module after the tests have run.

Note that you can also use other third-party libraries, such as Faker.js, to generate dummy data to use in your tests. Once you have generated the data, you can use TypeORM to save it to the database in a similar way to the example above.

In summary, Nest.js testing framework provides you with a way to add dummy data to a connected database in your tests. You can use TypeORM or other third-party libraries to generate the data, and then use the repository's save method to save it to the database.

ME: Can we implement something similar using the mongoose module?

GPT:
Yes, you can implement something similar using the Mongoose module in Nest.js.

Here's an example of how you can create a test module in Nest.js that uses Mongoose to connect to a MongoDB database and add dummy data:

import { Test, TestingModule } from '@nestjs/testing';
import { MongooseModule } from '@nestjs/mongoose';
import { UserController } from './user.controller';
import { UserService } from './user.service';
import { UserSchema } from './user.schema';
import { getModelToken } from '@nestjs/mongoose';

describe('User Module', () => {
  let app: TestingModule;
  let userService: UserService;
  let userModel: any;

  beforeAll(async () => {
    app = await Test.createTestingModule({
      imports: [MongooseModule.forRoot('mongodb://localhost/nest-test'), MongooseModule.forFeature([{ name: 'User', schema: UserSchema }])],
      controllers: [UserController],
      providers: [UserService],
    }).compile();

    userService = app.get<UserService>(UserService);
    userModel = app.get(getModelToken('User'));
  });

  afterAll(async () => {
    await userModel.deleteMany({});
    await app.close();
  });

  describe('dummy data', () => {
    it('should create a new user', async () => {
      const userData = { name: 'John Doe', email: 'johndoe@example.com' };
      const createdUser = await userService.createUser(userData);

      expect(createdUser.name).toEqual(userData.name);
      expect(createdUser.email).toEqual(userData.email);
    });
  });
});

In this example, we use the MongooseModule to connect to a MongoDB database and provide the UserSchema to MongooseModule.forFeature. We then use getModelToken to get access to the User model, and use it to create a new user by calling the createUser method of the UserService.

Note that in the afterAll hook, we use userModel.deleteMany({}) to delete all documents in the User collection after running the tests.

In summary, you can use the Mongoose module in Nest.js to add dummy data to a MongoDB database. You can create a test module that imports the necessary modules, controllers, and services to work with your database, and then use the Mongoose model to create and save dummy data.

ME: Is it possible to test the frontend application connected to the API while these tests are running?

GPT:
Yes, it is possible to test a frontend application that is connected to an API being tested in Nest.js. You can use tools like Cypress or Jest to write end-to-end (E2E) tests that simulate user interactions with the frontend application and verify the responses from the API.

Here is an example of how you can write an E2E test in Cypress that tests a frontend application connected to a Nest.js API:

describe('User API', () => {
  it('should create a new user', () => {
    cy.request('POST', '/users', {
      name: 'John Doe',
      email: 'johndoe@example.com',
    }).then((response) => {
      expect(response.status).to.eq(201);
      expect(response.body.name).to.eq('John Doe');
      expect(response.body.email).to.eq('johndoe@example.com');
    });

    cy.visit('/users');

    cy.get('table tbody tr').should('have.length', 1);
    cy.get('table tbody tr td:nth-child(1)').should('contain', 'John Doe');
    cy.get('table tbody tr td:nth-child(2)').should('contain', 'johndoe@example.com');
  });
});

In this example, we use cy.request to make a POST request to create a new user in the Nest.js API. We then use cy.visit to load the frontend application, and use cy.get to select elements on the page and verify that the new user is displayed correctly.

Note that the Nest.js API and the frontend application must be running during the test for this to work. You can use tools like concurrently or npm-run-all to run both the Nest.js server and the frontend application together during development and testing.

In summary, it is possible to test a frontend application connected to a Nest.js API using E2E tests in tools like Cypress or Jest. You can simulate user interactions with the frontend application and verify the responses from the API to ensure that both the frontend and backend are working correctly.

ME: Am I to understand that cypress is used in conjunction with jest?

GPT:
No, Cypress and Jest are two different testing frameworks that can be used independently of each other. Both tools have their own unique features and capabilities that make them suitable for different types of testing.

Jest is a JavaScript testing framework that is primarily used for unit testing, integration testing, and snapshot testing. It is designed to be simple and easy to use, and it provides features like test runners, assertions, mocking, and coverage reporting.

Cypress, on the other hand, is an end-to-end (E2E) testing framework that is used for testing the entire application stack, including the frontend and backend. It provides a range of features for simulating user interactions, testing UI components, and verifying API responses.

While you can use Jest to write E2E tests using tools like Puppeteer or Playwright, Cypress is specifically designed for this type of testing and offers many advantages, such as fast test execution, built-in debugging, and a user-friendly interface.

In summary, Cypress and Jest are two different testing frameworks that can be used independently of each other, depending on the testing needs of your application.

ME:
Can you show me how you would generate tests for the following module using cypress:

import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  Query,
} from '@nestjs/common'
import { PaginationParams } from '../utils/entities/paginationParams'
import { CreatePatientDto } from './dto/create-patient.dto'
import { UpdatePatientDto } from './dto/update-patient.dto'
import { PatientsService } from './patients.service'

@Controller('patients')
export class PatientsController {
  constructor(private readonly patientsService: PatientsService) {}

  @Post()
  create(@Body() createPatientDto: CreatePatientDto) {
    return this.patientsService.create(createPatientDto)
  }

  @Get()
  findAll(@Query() {skip, limit}: PaginationParams, @Query() params?: any) {
    return this.patientsService.findAll(skip, limit, params);
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.patientsService.findOne(id)
  }

  @Get('/provider/:provider_id')
  findByProviderId(@Param('provider_id') id: string, @Query() {skip, limit}: PaginationParams, @Query() filters?: any, @Query() sorts?: any) {
    return this.patientsService.findByProviderId(id, skip, limit, filters);
  }

  // search for patients by name
  @Get('/search/:name')
  search(@Param('name') name, @Query() {skip, limit}: PaginationParams, @Query() filters?: any) {
    return this.patientsService.search(name, skip, limit, filters);
  } 

  @Patch(':id')
  update(@Param('id') id: string, @Body() updatePatientDto: UpdatePatientDto) {
    return this.patientsService.update(id, updatePatientDto)
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.patientsService.remove(+id)
  }
}

GPT:
Certainly! Here's an example of how you could write Cypress tests for this PatientsController module:

describe('PatientsController', () => {
  beforeEach(() => {
    cy.visit('http://localhost:3000/patients')
  })

  it('should create a new patient', () => {
    const patient = {
      name: 'John Doe',
      age: 30,
      gender: 'Male',
      email: 'johndoe@example.com',
    }

    cy.get('button#add-patient').click()
    cy.get('input#name').type(patient.name)
    cy.get('input#age').type(patient.age)
    cy.get('select#gender').select(patient.gender)
    cy.get('input#email').type(patient.email)
    cy.get('button#save-patient').click()

    cy.get('table tbody tr').should('have.length', 1)
    cy.get('table tbody tr td:nth-child(1)').should('contain', patient.name)
    cy.get('table tbody tr td:nth-child(2)').should('contain', patient.age)
    cy.get('table tbody tr td:nth-child(3)').should('contain', patient.gender)
    cy.get('table tbody tr td:nth-child(4)').should('contain', patient.email)
  })

  it('should update an existing patient', () => {
    const patient = {
      name: 'Jane Doe',
      age: 35,
      gender: 'Female',
      email: 'janedoe@example.com',
    }

    cy.get('table tbody tr td:nth-child(1)').should('contain', 'John Doe')
    cy.get('table tbody tr td:nth-child(2)').should('contain', '30')
    cy.get('table tbody tr td:nth-child(3)').should('contain', 'Male')
    cy.get('table tbody tr td:nth-child(4)').should('contain', 'johndoe@example.com')
    cy.get('table tbody tr td:nth-child(5) button#edit-patient').click()

    cy.get('input#name').clear().type(patient.name)
    cy.get('input#age').clear().type(patient.age)
    cy.get('select#gender').select(patient.gender)
    cy.get('input#email').clear().type(patient.email)
    cy.get('button#save-patient').click()

    cy.get('table tbody tr td:nth-child(1)').should('contain', patient.name)
    cy.get('table tbody tr td:nth-child(2)').should('contain', patient.age)
    cy.get('table tbody tr td:nth-child(3)').should('contain', patient.gender)
    cy.get('table tbody tr td:nth-child(

[ stopped generating in the middle ]

ME: I'm getting the idea. So cypress can submit requests, and interact with UI elements.

GPT: Yes, that's correct! Cypress can simulate user interactions and submit requests, as well as assert on the state of the UI and the responses received from the API. This allows you to test your frontend and backend together in an end-to-end fashion, and verify that they are working together correctly to deliver the expected functionality to the user.

ME: Wow, it seems to make more sense to learn this than jest and puppeteer. Any thoughts?

GPT: It really depends on what you're trying to achieve and what you're most comfortable with. Jest and Puppeteer are also great tools for testing, and they have their own strengths and weaknesses.

Jest is a popular testing framework that is used for writing unit and integration tests. It has a large and active community, and provides a lot of features out of the box, such as mocking, coverage reporting, and snapshot testing. If you're primarily interested in testing your backend logic and APIs, Jest might be a good fit for you.

Puppeteer, on the other hand, is a Node.js library that provides a high-level API for controlling a headless Chrome or Chromium browser. It's great for testing web applications, as it allows you to simulate user interactions, take screenshots, and test the UI in a way that is very similar to how a user would interact with the app. If you're interested in testing the front-end part of your application, Puppeteer might be a better fit for you.

Cypress is also a great tool for testing web applications, and it has some advantages over Jest and Puppeteer. It's designed to make end-to-end testing easy and intuitive, and provides a lot of useful features out of the box, such as time travel debugging, automatic waiting, and network stubbing. It also has a very simple and easy-to-use API, and provides a lot of built-in assertions that make it easy to write expressive and readable tests. If you're looking for a tool that can help you test your full-stack application in a user-centric way, Cypress might be a good fit for you.

Ultimately, the choice of tool will depend on your specific requirements, and what you're most comfortable with. You might want to experiment with all three tools and see which one works best for you and your team.

Deploying a Saas Platform with Multi-Tenant Architecture Part 1: Running the Applications

Poitier Stringer — Sun, 12 Feb 2023 20:22:33 +0000

I recently received permission to deploy a version of an assessment platform I architected and developed for my old company Prairie Health. The company has since been acquired and this platform is no longer in use. This was the first application of this complexity I had ever shipped to production and I learned a lot while building it. I'm taking this opportunity to document the process of re-familiarizing myself with this platform and deploying it for anybody who may be curious about this sort of thing.

It's been a while since I even looked at it so I'll start by just running the applications. The product development and UX was done by my product manager Jinwoo Yu. I had the help of one other engineer building the physician's dashboard, Aleks Petrovic.

You can find the code for it here:
https://github.com/pstringe/mindvitals

Overview

The platform consists of 3 applications:

An API written in typescript using nest.js
An interface for taking assessments
A dashboard for administering and reviewing assessments as well as managing PHI.

Assessments can be administered via, email, text, or QR code. Each clinic stores assessment data and PHI in a separate database. There is a central auth database that associates users with the correct clinic.

Starting the API

The api may be started using the command:

nest start --watch

When we run that command, we see this output:

Currently we are unable to connect to the database. I'll have to set up a new one since the last one was set up on the company's mongoDB account.

Starting up the dashboard

We start the dashboard using the following commands:

yarn install
yarn start

Here's the login screen which can be accessed at localhost:3000 when we start up the application. We won't be able to start that up until the API is working.

Creating a new mongoDB instance

This is just for demonstration purposes, so I'll start with the free cluster.

I'm just going to use user name and password authentication

We need to change the credentials in our config.staging.env file

For now, I'll add my IP. When I deploy the API, I will need to to add the IP address associated with the APP Engine instance.

Next, I'll grab the connection string that would be used for mongoDB compass, and update it with the password we just created

Now I'm going to restart the API and see what that does
It appears we've successfully connected to the new database.

Creating a new user and organization

Next, I want to try logging in. Currently, there should be no users in the auth database which should be accessible under test. I'm going to try to find the postman collection that I made for this API. I think there is an endpoint for adding a user.

Here is an example payload for adding a user. There is a property, organization which corresponds to the clinic of the user. The data for each clinic is stored in a different database and this key is used to associate users with the correct one. Its presence here means I should add an organization before adding a user. I'll call it Test Clinic.

Our test clinic has been created with the following ID

Now that we have a clinic, we can use this ID to create a user:

We receive the following error:

It looks like the default route in the users controller is a get endpoint:

import {
  Body,
  Controller,
  Delete,
  Get,
  Param,
  Patch,
  Post,
} from '@nestjs/common'

import { CreateUserDto } from './dto/create-user.dto'
import { User } from './user.model'
import { UsersService } from './users.service'

@Controller('users')
export class UsersController {
  constructor(private readonly userService: UsersService) {}

  @Get()
  async getUsers(): Promise<User[]> {
    const users = await this.userService.getUsers()
    return users
  }

  @Get(':id')
  async getUserById(@Param('id') id: string): Promise<User> {
    const user = await this.userService.getUserById(id)
    return user
  }

  @Post('add')
  async addUser(@Body() userDto: CreateUserDto): Promise<User> {
    console.log('addUser')
    const user = await this.userService.addUser(userDto)
    return user
  }

  @Patch(':id')
  updateUser(@Param('id') id: string, @Body() userDto: CreateUserDto): any {
    const user = this.userService.updateUser(id, userDto)
    return user
  }

  @Delete('/:id')
  deleteUser(@Param('id') id: string): any {
    return this.userService.deleteUser(id)
  }
}

We need to update the endpoint in the postman collection and rerun.

Now we have a user entity and an associated personnel entity. The difference between user an personnel is, a user exists in the auth database and is only used for authentication. The personnel entity exists within the clinic's database and is used for all other operations.

Now that we have a user record, we can try logging in.

Now we have access to the dashboard. As you can see, this user does not have access to any patient records. In the next article we will address this. Once we have some patient data, then we will work on sending out assessments and reviewing results.