DB_Address

Discover how to build secure RESTful APIs using NestJS, TypeScript, and various technologies. Delve into authentication, data modeling, error handling, testing, and deployment for scalable, real-world applications.

Yan Sun - Building Real-World Restful APIs with NestJS and TypeScript-02.png

address-book-api.tar.gz

region

access_key_id

secret_access_key

output

nestjs-new

nestjs-2.1-module

nestjs-2-install-start

nestjs-typeorm-2

nestjs-base

nestjs-playground

nestjs-install-hmr-start

nestjs-orm-migration

nestjs-typeorm-2-e2e

nestjs-typeorm-docker

nestjs-2.1-test-auto

nestjs-2.1-module-AWSCLI

Testing Example

NestJS is built on top of the popular Express.js library and provides a modular and structured approach to building server-side applications.

You will take a hands-on approach to constructing a practical RESTful API from the ground up. By leveraging NestJS, TypeScript, and other technologies, you will delve into various topics, such as data modeling with TypeORM and MySQL, authentication and authorization mechanisms, request validation, error handling strategies, testing methodologies, deployment practices, and more.

By the end of this course, you will have gained the essential skills, knowledge, and hands-on experience necessary to build a real-world RESTful API. You will have learned how to scale your application using a public cloud, such as AWS, where your application can serve thousands and millions of customers cost-effectively. This comprehensive learning journey equips you to confidently navigate the intricacies of RESTful API development, ensuring you are well-prepared for NestJS development.

Building Secure RESTful APIs with NestJS: A Practical Guide

It specifies the frequency at which unit tests should be written.

It promotes maintainability by structuring the test into three sections: setting up initial conditions, performing the action, and asserting outcomes.

It defines the order in which tests are executed to ensure consistency.

It enforces the use of asynchronous code in all unit tests.

What is the purpose of the AAA pattern in unit testing?

What is the purpose of the AAA pattern in unit testing?

```
it('should check the values correctly', () => {
  ...
  expect(stringValue).toBeTruthy();
  expect(empty).toBeFalsy();
  expect(undefinedValue).toBeTruthy();
  expect(nullValue).toBeTruthy();
  expect(numberValue).toBeTruthy();
  expect(zeroValue).toBeFalsy();
});
```

```
it('should check the values correctly', () => {
  ...
  expect(stringValue).toBeFalsy();
  expect(empty).toBeFalsy();
  expect(undefinedValue).toBeFalsy();
  expect(nullValue).toBeTruthy();
  expect(numberValue).toBeTruthy();
  expect(zeroValue). toBeFalsy();
});
```

```
  it('should check the values correctly', () => {
    ...
    expect(stringValue).toBeTruthy();
    expect(empty).toBeFalsy();
    expect(undefinedValue).toBeFalsy();
    expect(nullValue).toBeFalsy();
    expect(numberValue).toBeTruthy();
    expect(zeroValue).toBeFalsy();
  });
```

```
  it('should check the values correctly', () => {
    ...
    expect(stringValue).toBeTruthy();
    expect(empty).toBeFalsy();
    expect(undefinedValue).toBeFalsy();
    expect(nullValue).toBeFalsy();
    expect(numberValue).toBeTruthy();
    expect(zeroValue).toBeTruthy();
  });
```

Which option will pass the test from the following code snippets?
```
it('should check the values correctly', () => {
  const stringValue = 'NestJS';
  const empty = '';
  const undefinedValue = undefined;
  const nullValue = null;
  const numberValue = 42;
  const zeroValue = 0;

  // assertions
   ...
}
```

Which option will pass the test from the following code snippets?
<pre><code>it('should check the values correctly', () =&gt; {
 const stringValue = 'NestJS';
 const empty = '';
 const undefinedValue = undefined;
 const nullValue = null;
 const numberValue = 42;
 const zeroValue = 0;

 // assertions
 ...
}
</code></pre>

```
it('should all the values pass the check', () => {
    ...
    expect(stringVal).toBe("hello");
    expect(userObj).toStrictEqual({ name: "John", age: 25 });
    expect(response).toEqual({ success: true, data: { id: 1, name: "Alice" }});
});
```

```
it('should check the values correctly', () => {
    ...
    expect(stringVal).toEqual("hello");
    expect(userObj).toBe({ name: "John", age: 25 });
    expect(response).toStrictEqual({ success: true, data: { id: 1, name: "Alice" } });
  });
```

``` 
it('should check the values correctly', () => {
    ...
    expect(stringVal).toStrictEqual("hello");
    expect(userObj).toEqual({ name: "John", age: 25 });
    expect(response).toBe({ success: true, data: { id: 1, name: "Alice" } });
  });
```

```
it('should check the values correctly', () => {
    ...
    expect(stringVal).toBe("hello");
    expect(userObj).toEqual({ name: "John", age: 25 });
    expect(response).toStrictEqual({ success: true, data: { id: 1, name: "Alice" } });
  });
```

Consider the following code snippets for Jest matchers: `toBe`, `toEqual`, and `toStrictEqual`. Which test will pass?
```
it('should all the values pass the check', () => {
    const stringVal = 'hello';
    const userObj = { name: "John", age: 25, password: undefined };
    const response = { success: true, data: { id: 1, name: "Alice" } }; 
    // assertions
    ...
});
```

Consider the following code snippets for Jest matchers: <code>toBe</code>, <code>toEqual</code>, and <code>toStrictEqual</code>. Which test will pass?
<pre><code>it('should all the values pass the check', () =&gt; {
 const stringVal = 'hello';
 const userObj = { name: &quot;John&quot;, age: 25, password: undefined };
 const response = { success: true, data: { id: 1, name: &quot;Alice&quot; } }; 
 // assertions
 ...
});
</code></pre>

Unit tests focus on isolated components, while E2E tests examine the integration of the entire system.

Unit tests primarily cover user interface interactions, whereas E2E tests exclusively address back-end logic.

Unit tests and E2E tests are interchangeable terms in NestJS, referring to the same testing level.

Unit tests are limited to front-end validation, while E2E tests exclusively validate back-end functionalities.



What distinguishes a unit test from an E2E test?

What distinguishes a unit test from an E2E test?

```
beforeAll(async () => {
  
});

beforeEach(async () => {
  await setupDatabase();
  await prepareTestData();
});

it('should perform E2E test', async () => {
  // E2E test logic
});

afterEach(async () => {
  await cleanupTestData();
});

afterAll(async () => {
  await cleanupDatabase();
});

```

```
beforeAll(async () => {
  await setupDatabase(); 
});

beforeEach(async () => {
  await cleanupTestData();
});

it('should perform E2E test', async () => {
  // E2E test logic
});

afterEach(async () => {
  await prepareTestData();
});

afterAll(async () => {
  await cleanupDatabase();
});
```

```
beforeAll(async () => {
  await setupDatabase(); 
});

beforeEach(async () => {
  await prepareTestData();
});

it('should perform E2E test', async () => {
  // E2E test logic
});

afterEach(async () => {
  await cleanupTestData();
});

afterAll(async () => {
  await cleanupDatabase();
});
```

```
beforeAll(async () => {
  await prepareTestData();
});

beforeEach(async () => {
  await setupDatabase();
});

it('should perform E2E test', async () => {
  // E2E test logic
});

afterEach(async () => {
  await cleanupTestData();
});

afterAll(async () => {
  await cleanupDatabase();
});
```

Which code snippet correctly demonstrates the usage of Jest hooks (`beforeAll`, `beforeEach`, `afterEach`, and `afterAll`) in an E2E test for a NestJS application?

Which code snippet correctly demonstrates the usage of Jest hooks (<code>beforeAll</code>, <code>beforeEach</code>, <code>afterEach</code>, and <code>afterAll</code>) in an E2E test for a NestJS application?

Test your knowledge of unit tests and E2E tests.

Introduction

NestJS Fundamentals

Connecting with REST: Building the Address Book App with NestJS

Understand the Basics of NestJS and RESTful APIs

Validation, Exception Handling, and Logging

Persist Data with TypeORM and MySQL

Serialization and Interceptors

Authentication and Authorization

Persist Data, Authentication, Validation, and Serialization

Testing

Deployment

Testing and Deployment

Conclusion

Appendix

Quiz: Unit Tests and E2E Tests