When applying unit testing, you need to focus on the main logic of a component without affecting external dependencies or causing side effects—unintended changes that occur outside a function's scope, like database queries or network requests.

Jest is a popular testing framework that offers powerful capabilities to help in effective testing. Mocking in Jest helps you test and manage external dependencies and handle side effects.

In this guide, you will learn about unit testing essentials, focusing on Jest mocks. Whether you're just starting or looking to enhance your testing strategy, this guide will equip you with the knowledge to write effective and efficient tests.

Here's what we'll cover:

• What is Unit Testing?

• What are External Dependencies?

• What are Side Effects?

• What is Mocking?

• Use Case: Login Express Controller

• Summary

What is Unit Testing?

Unit testing is a software testing technique used to test a single component of your application in isolation. This component may be a class, a method, or a module.

Why You Should Use Unit Testing

1. You will be able to detect bugs earlier, it helps you to detect if a component behaves as expected.

2. Enables you to modify your component safely. If you update your component and, by mistake, add or modify something you should not, the test will fail if these changes introduce a new bug.

3. It can serve as a documentation that shows how individual units of your app work.

4. Encourages you to write cleaner code. The cleaner your component is, the easier and simpler your test will be.

5. It helps you to easily integrate different parts of your application, as you will be sure that every single component works correctly.

6. In the long term, you can maintain your application faster.

Let us dive-deep into some practical usages:

Let’s assume that you have a multiplication function that should take two arguments and return the result.

Here’s the code:

function multiply(a,b) {
    return a*b
}
export default multiply

Note: To use Jest with Node.js ECMAScript modules, check out this article for configuration.

So how can you test this function using Jest?

1. Create __tests__ folder in the root folder.

2. Create file multiply.test.js inside __tests__ .

   Note that any file ending with .test.js will be executed by Jest.

3. Start writing your tests by calling the it("",()=>{}) Jest method.

Let's understand what `it("",()=>{})` does:

The it method is a Jest function used to test certain behaviors in your function.
The first argument should be the test name, which can be an assertion text for what you expect from this test.

For example, if you need to test whether the multiply function returns the right result using the arguments and if they are numbers, you can write it("should return the multiplication of inputs of type number",()=>{}).

The second argument is a function for your test logic. It gets invoked once you run your test.

To effectively write your tests, you should apply the AAA (Arrange-Act-Assert) Pattern.

1. Arrange: Setup the data or configure any dependencies you will use in this test.

2. Act: Call the function you are testing.

3. Assert: Write your expectations—how you are expecting the function you are testing to behave. For assertion, you will always use the expect Jest method.

Think of every it("",()=>{}) statement as a different scenario of your function.

Here’s an example:

import multiply from './../multiply.js'

it("should return the multiplication of inputs of type number", () => {
  // Arrange
  const testArg1 = 5;
  const testArg2 = 2;
  // Act
  const result = multiply(testArg1, testArg2);
  // Assert
  expect(result).toBe(10);
});

it("should returns NaN if no arguments are passed", () => {
  // Arrange
  // Act
  const result = multiply();
  // Assert
  expect(result).toBeNaN();
});

it("should returns NaN if only one argument is passed", () => {
  // Arrange
  const arg = 5;
  // Act
  const result = multiply(arg);
  // Assert
  expect(result).toBeNaN();
});

it("should returns Zero if one of the arguments is empty string", () => {
  // Arrange
  const testArg1 = "";
  const testArg2 = 5;
  // Act
  const result = multiply(testArg1, testArg2);
  // Assert
  expect(result).toBe(0);
});

These tests are some of the tests you can add to your file. You can add more tests or eliminate some depending on the different scenarios of the function you are testing.

What are External Dependencies?

External dependencies are modules or functions that your code relies on, which originates outside your own codebase. These can include libraries, APIs, databases, functions or any service that your application interacts with.

Testing with external dependencies can be challenging because:

• They can slow down tests due to network or processing delays.

• They might not be available during the testing, which in turn causes failures.

As shown in the following function, what if your function calls another function? Most of the functions you write daily actually call other functions.

That is:

function processNumbers(numbers, callback) {
    // numbers: array
    // callback: function
  return numbers.map(callback);
}

export default processNumbers;

When applying unit testing, units should be tested in isolation. processNumbers function depends on another function callback.

So what should you do in this case? Mocking is the solution and we’ll talk about it later in a different section.

What are Side Effects?

Side effects occur when a function modifies some state outside its own scope or has observable interactions with the outside world apart from returning a value.

Examples include modifying a global variable, changing a file system, or sending an HTTP request.

Side effects can make tests unpredictable and difficult to manage because they:

• Might interact with other systems, causing alteration of external states.

• Can lead to flaky tests if not isolated properly.

Here’s an example that returns a user from a database using their id:

async function getUserFromDatabase(userId) {
  // Simulates fetching from a database
  return { id: userId, name: 'John' };
}

export {getUserFromDatabase}

Here’s another function that makes use of getUserFromDatabase in the code above:

async function getProfile(userId) {
  return await getUserFromDatabase(userId);
}

export default getProfile

While testing this function, you should not actually send a real request, all you need is to test the behavior of the getProfile function without hitting any external system.

You can also use mocking to solve this situation.

What is Mocking?

Mocking is about simulation—you need to isolate a function that you are testing. If the function relies on any external dependency or may cause any side effect, you should simulate the behavior of those aspects.

Mocking involves creating a fake version of a function, object, or module to control its behavior during testing. This allows you to simulate different scenarios and verify interactions without relying on actual implementations.

We will focus on two approaches to mocking:

1. Function Mocks (also called Spies):
   You can use jest.fn() to create a mock function that can be used to track a function or replace real implementations. Or use jest.spyOn(object, methodName) to track the calls of object[methodName].

2. Module Mocks: You can use jest.mock(“path-of-your-module”) to mock entire modules or specific imports. By using it, all functions inside this module become mock functions. In addition, during testing, modules you are testing will receive a fake mocked version of this module.

Any mock function has methods that you can use to simulate the behavior of the function. Some of the most used methods are:

• mockFn.mockImplementation(fn) : Used to replace the actual implementation of a function. fn is the replacement implementation.

• mockFn.mockReturnValue(value) : You can use this if all you care about is the return value of a function.

• mockFn.mockResolvedValue(value): You can use this if the mock function returns a promise.

Example Usage 1

Let’s test processNumbers by using function mocks. The challenge here is that processNumbers takes a callback function as an argument. What if you need to test if this callback function get invoked inside processNumbers?

Here’s the code:

import processNumbers from 'file-path';

test('processNumbers applies callback and return the right result', () => {
    // Arrange
    const arr = [2, 3]
    const mockedCallback = jest.fn().mockImplementation(x => x + 2);
    // Act
    const result = processNumbers(arr, mockedCallback);
    // Assert
    expect(result).toEqual([4, 5]);
    expect(mockedCallback).toHaveBeenCalledTimes(arr.length);
});

We started by arranging the arguments:

• arr variable is an array of numbers. We assigned it an array with random numbers in the test.

• The callback variable is a callback function. This function should be mocked in the test.

You may ask yourself why you should mock callback, why not assign it as a normal function?

The answer is that, without mocking the callback argument, you will not be able to track it inside processNumbers while you are testing it. Because mocking creates a fake version of the function, it creates a spy that has a tracker through which you can assert any action taken in this mocked function, whether it gets called or any arguments are passed to it.

The jest.fn() creates a mock function. You can pass a function to fn in place of the real function.

Next, we “act” by calling the function we are testing: processNumbers.

Finally, we wrote the assertions, which are expectations about how processNumbers should behave and if processNumbers applied callback and returned the result.

Example Usage 2

Side effects are another aspect you need to handle in testing. In the getProfile function, an external system is called, which calls a database to retrieve data, and this is a side effect.

In another scenario, a function may connect a database to create a user, and through testing you will not need to add or change actual data in the database.

To simulate the behavior of getUserFromDatabase without actually hitting the database, you should mock its module, and by default, getUserFromDatabase will be an empty mock function that can be tracked during your test.

Here’s the code:

import getProfile from 'file-path';
import { getUserFromDatabase } from 'file-path';

// Mock the module of getUserFromDatabase method
jest.mock('./../DB/databaseMethods.js');

describe('getProfile', () => {
  it('should call getUserFromDatabase with the correct userId and return the result', async () => {
    // Arrange    
    const userId = '123';
    const dummyUser = { id: userId, name: 'John' };
    getUserFromDatabase.mockResolvedValue(dummyUser);
    // Act
    const result = await getProfile(userId);
    // Assert
    expect(result).toEqual(dummyUser);
    expect(getUserFromDatabase).toHaveBeenCalledWith(userId);
    expect(getUserFromDatabase).toHaveBeenCalledTimes(1);
  });
});

We started by arranging the arguments:

• userId is just a number.

• dummyUser is an object that simulates a fake user data.

• We returned dummyUser from getUserFromDatabas by using mockResolvedValue.

Similar to the last example, we “act” by calling the function being tested: getProfile.

Finally, we wrote the assertions, you expectations about how getProfile should behave and if the getUserFromDatabase got called correctly and the result returned as expected.

Use Case: Login Express Controller

Here is a login controller that receives the email and password of a user through the req object, and then searches for the user in the database. It does some checks, then returns a res if everything is ok, or call next with an error object.

import User from "file-path";

export const login = async (req, res, next) => {
  const { email, password } = req.body;

  const user = await User.findOne({ email });
  if (!user) return next(new Error("Invalid Email!"));

  const checkPassword = user.checkPassword(password);
  if (!checkPassword) return next(new Error("Invalid Password!"));

  const token = user.generateToken();

  return res.status(200).json({ success: true, results: { token } });
};

Think about the steps you can use to test the login function. You can ask some questions that’ll help you come up with ideas:

What are the scenarios of login function workflow?

1. The user is not found.

2. Password is incorrect.

3. Everything is ok, and a response is returned with a token.

So you may assert login to do the following:

• login should call next if user not found.

• login should call next if password doesn't match.

• login should call res.json with the token and call res.status with 200 if everything is ok.

What are the arguments that login method should receive?

1. req object with body property.

2. res object with status and json property.

3. next function.

res.json() or res.status() or next() all are functions that login needs to do its work. During testing, you have no access to these arguments so you should mock them.

• req can be defined as {body: { email: "test@foo.com", password: "bar" }}

• res can be defined as {json: jest.fn().mockReturnThis(), status: jest.fn().mockReturnThis()}

• next can be defined as jest.fn()

Are there any interactions with external systems or any dependencies?

1. User.findOne()

2. user.checkPassword()

3. user.generateToken()

Thus, mocking is the solution:

• For User.findOne(), you should mock the entire User module and set up the fake findOne() to return a fake user. The challenge here is that findOne is an object method. How can you track it? jest.spyOn(object, methodName) is the soultion.
  The spyOn method is used to track the calls of object[methodName], which, in our case, is User.findOne

• user.checkPassword() and user.generateToken() should be mock functions.

To apply all of these concepts and put blocks with each other, the final test should be:

import User from "file-path";
import { login } from "file-path";

jest.mock("../DB/models/user.model.js");

let mockReq, mockRes, mockNext, dummyUser;
describe("login controller", () => {
  beforeEach(() => {
    mockReq = { body: { email: "test@foo.com", password: "bar" } };
    mockRes = {
      json: jest.fn().mockReturnThis(),
      status: jest.fn().mockReturnThis(),
    };
    mockNext = jest.fn();

    dummyUser = {
      checkPassword: jest.fn(() => true),
      generateToken: jest.fn(() => "token"),
    };
  });

  it("should call next if user not found", async () => {
    // Arrange
    jest.spyOn(User, "findOne").mockResolvedValueOnce(null);
    // Act
    await login(mockReq, mockRes, mockNext);
    // Assert
    expect(mockNext).toHaveBeenCalledWith(new Error("Invalid Email!"));
    expect(mockRes.json).not.toHaveBeenCalled();
  });

  it("should call next if password doesn't match", async () => {
    // Arrange
    dummyUser.checkPassword.mockReturnValueOnce(false);
    jest.spyOn(User, "findOne").mockResolvedValue(dummyUser);
    // Act
    await login(mockReq, mockRes, mockNext);
    // Assert
    expect(mockNext).toHaveBeenCalledWith(new Error("Invalid Password!"));
    expect(dummyUser.generateToken).not.toHaveBeenCalled();
    expect(mockRes.json).not.toHaveBeenCalled();
  });

  it("should call res.json with the token and call res.status with 200 if everything is ok", async () => {
    // Arrange
    jest.spyOn(User, "findOne").mockResolvedValue(dummyUser);
    // Act
    await login(mockReq, mockRes, mockNext);
    // Assert
    expect(mockNext).not.toHaveBeenCalled();
    expect(User.findOne).toHaveBeenCalledWith({ email: mockReq.body.email });

    expect(dummyUser.checkPassword).toHaveBeenCalledWith(mockReq.body.password);
    expect(dummyUser.generateToken).toHaveBeenCalled();

    expect(mockRes.status).toHaveBeenCalledWith(200);
    expect(mockRes.json).toHaveBeenCalledWith({
      success: true,
      results: { token: "token" },
    });
  });
});

Final note: beforeEach is a Jest hook, you can use it to implement some code before each test. Inside beforeEach function, you can write any common variables your tests may need instead of writing them independently for each test.

Summary

In this tutorial you learned the basics of unit testing with Jest, focusing on how to use mocks. Unit testing helps ensure that individual parts of your code work correctly by testing them in isolation.

Handling external dependencies, managing side effects, and utilizing mocking are essential skills for robust testing. Jest provides powerful tools to address these challenges, making your tests more reliable, faster, and easier to maintain.

Understanding these concepts will help you write better tests and produce more resilient applications.

This tutorial explained how to use Jest’s mocking features to simulate external dependencies and manage side effects. It includes a practical example of testing an Express.js login controller, showing how to mock functions and control test scenarios.

This approach helps you create reliable tests and maintain code quality by isolating and managing dependencies effectively.

To get the most out of this guide, you should have a background in JavaScript, understand how Mongoose works, and know Object-Oriented Programming basics.

Here's what we'll cover:

1. What is a Mongoose Schema?

2. Discriminator

3. Statics

4. Methods

5. Query Builder

6. Hooks

7. Summary

What is a Mongoose Schema?

Mongoose schemas provide a structured way to model data in a MongoDB database, allowing you to define the properties and behavior of the documents. Schemas serve as a blueprint for a document that gets saved in the database. They enables developers to enforce data integrity and work with MongoDB in a more intuitive and organized manner.

Within a MongoDB collection, a schema outlines the fields of the documents, their data types, validation rules, default values, constraints, and more.

Programmatically, a Mongoose schema is a JavaScript object. Actually, it is an instance of a built-in class called Schema inside the mongoose module. For this reason, you can add more methods to its prototype. This will help you implement many features as middleware, methods, statics, and more. You will learn about some of them in this tutorial.

Features you'll learn how to implement:

• Discriminator

• Statics

• Methods

• Query Builder

• Hooks

Discriminator

A discriminator is a feature that enables you to create multiple models (subtypes) that inherit from a base model (parent). This happens by defining a base schema and then extending it with extra fields specific to each subtype or each child schema.

All documents, regardless of their specific model, are stored in the same MongoDB collection. This keeps your data organized in a single collection while allowing for flexible querying and data management. Also, each document includes a special field that indicates its specific model type, allowing Mongoose to distinguish between the different subtypes.

How to use discriminator:

1. Start by defining a base schema, which will have the common fields among the subtypes. After that, create a model from it.

    import mongoose from 'mongoose';
   
    const baseSchema = new mongoose.Schema({
        name: { type: String, required: true },
    }, { discriminatorKey: 'kind' }; // defaults to '__t');
   
    const BaseModel = mongoose.model('Base', baseSchema);
   

2. Create the subtypes that extend the base schema by defining the discriminator for each one.

    const catSchema = new mongoose.Schema({
        meow: { type: Boolean, default: true }
    });
    // subtype
    const Cat = BaseModel.discriminator('Cat', catSchema);
   
    const dogSchema = new mongoose.Schema({
        bark: { type: Boolean, default: true }
    });
    // subtype
    const Dog = BaseModel.discriminator('Dog', dogSchema);
   

3. You can then create documents in the regular way. All the documents will be stored in the same collection, but each has its own type depending on its subtype model.

    const fluffy = await Cat.create({ name: 'Fluffy' });
    const rover = await Dog.create({ name: 'Rover' });
   

discriminator use case:

Let's say that you're building a multi-user Ecommerce web application which accommodates three main user roles: admins, clients, and sellers. Each of these roles plays a crucial part in the ecosystem of online shopping.

If you try to build a class for each role, you'll find that all the three have common fields and methods. You may decide to create a parent schema (user) and some other children schemas (client, seller, admin) that inherit from it.

You can use the discriminator to achieve this.

In your user.model.js file, add the following code:

import mongoose from "mongoose";

const userSchema = mongoose.Schema(
  {
    name: String,
    profilePic: String,
    email: String,
    password: String,
    birthDate: Date,
    accountAcctivated: { type: Boolean, default: false },
  },
  {
    timestamps: true,
    discriminatorKey: "role",
  }
);

const User = mongoose.model("User", userSchema);
export default User;

Now you have the base model (User) from which other subtypes will inherit. In this parent schema, you define the common fields that all users will share regardless of their roles.

In your client.model.js file:

import mongoose from "mongoose";
import User from "./user.model.js";

const clientSchema = mongoose.Schema(
  {
    products: Array,
    address: String,
    phone: String,
  }
);

const Client = User.discriminator("Client", clientSchema);
export default Client;

In your seller.model.js file:

import mongoose from "mongoose";
import User from "./user.model.js";

export const sellerSchema = mongoose.Schema(
  {
    rating: Number,
    businessType: { type: String, enum: ["individual", "corporation"] },
  }
);

const Seller = User.discriminator("Seller", sellerSchema);
export default Seller;

In your admin.model.js file:

import mongoose from "mongoose";
import User from "./user.model.js";

export const adminSchema = mongoose.Schema(
  {
    permissions: Array,
    assignedTasks: Array,
    department: String,
  }
);

const Admin = User.discriminator("Admin", adminSchema);
export default Admin;

The subtypes or children will be the Client, Seller, and Admin. In each subtype schema, you should add any extra fields or behaviors specific to this subtype only. By creating the child model using the discriminator, the child model will inherit all the fields and methods of its parent model User.

So the previous code will create a user collection in the database with each document having a role field either Client, or Seller, or Admin. All documents are now sharing the parent (user) fields, and depending on the role of each document, each has another extra field.

Although all the documents will be saved in one single collection, models are fully separated while coding. What does this mean?

For instance, If you need to retrieve all clients from the User collection, you should write Client.find({}). This statement uses the discriminator key to find all documents whose role is Client. This way, any operations or queries that refer to one of the child models will still be written separately from the parent model.

Note: Before diving into the next sections, just keep in mind that any statics, methods, query builders, or hooks should be defined before creating the model itself (that is, before const User = mongoose.model("User", userSchema);).

Statics

Statics are useful for defining functions that operate on the model level. They allow you to define reusable functions for operations related to the entire model. They help encapsulate logic that applies to the model rather than individual documents, making your code cleaner, more organized and maintainable

Methods like find, findOne, findById and others all are methods attached to the model. By using the statics property of Mongoose schemas, you will be able to build your own model method.

Statics are powerful. By using them, you can encapsulate complex queries that you might want to reuse. Also, you can create statics for operations that modify or aggregate data, such as counting documents or finding documents based on specific criteria.

statics use case

Statics are easy to build. You define a static method on your schema using the statics object.

In your user.model.js file, add these static methods, countUsers and findByEmail:

// model method
userSchema.statics.countUsers = function () {
    return this.countDocuments({});
};

// model method
userSchema.statics.findByEmail = async function (email) {
  return await this.findOne({ email });
};

Inside any static method, this refers to the model itself. In this example, this in this.findOne({ email }) refers to the User model.

Example usage:

const user = await User.findByEmail("foo@bar.com");
//or
const client = await Client.findByEmail("foo@bar.com");
//or
const seller = await Seller.findByEmail("foo@bar.com");
//or
const admin = await Admin.findByEmail("foo@bar.com");

When you call the static method on your model, the method gets called and this is replaced by the model you called the statics on. This line performs a query to find a single document in the MongoDB collection where the email field matches the provided email argument.

Methods

Methods are functions that you can define on a schema and that can be called on instances of documents created from this schema. They help encapsulate logic within the document itself, making your code cleaner and more modular.

By using instance methods, you can easily interact with and manipulate the data associated with specific documents.

methods use case

You can define methods on the schema using the methods object.

In your user.model.js file, add a document method through which you can check the password of a user:

// instance or document method
userSchema.methods.getProfile = function () {
    return `${this.name} (${this.email})`;
};

// instance or document method
userSchema.methods.checkPassword = function (password) {
    return password === this.password ? true : false;
};

Inside any document method, this refers to the document itself. In this example, this in this.password refers to the user document at which the method will get called on. This means that you can access all the fields of this document. This is so valuable because you can retrieve, modify, and check for anything related to this document.

Example usage:

const client = await Client.findById(...)
client.checkPassword("12345")
//or
const seller = await Seller.findById(...)
seller.checkPassword("12345")
//or
const admin = await Admin.findById(...)
admin.checkPassword("12345")

Since methods are instance-level functions, they are called on the documents. await Client.findById(...) will return a document that has all the built-in methods as well as your own predefined methods checkPassword and getProfile. So by calling, for example client.checkPassword("12345"), the this keyword in the checkPassword function definition will get replaced with the client document. This in turn will compare the user password with the password saved earlier in the database.

Query Builder

A query builder in Mongoose is a custom method that you can define on the query object to simplify and encapsulate common query patterns. These query builders allow you to create reusable and readable query logic, making it easier to work with your data.

One of the most valuable usages of query builders is chaining. They can be chained with other query builders that you've built or with standard query methods like find, sort, and so on.

Query builder use case

You define query builders by adding them to the query property of a Mongoose schema.

In your user.model.js file, add a query helper method that lets you implement pagination.

// query helper
userSchema.query.paginate = function ({ page, limit }) {
    // some code
    const skip = limit * (page - 1);
    return this.skip(skip).limit(limit);
};

To implement pagination, you need two important variables: first, the page number, and second, the number of items you will retrieve per page.

To query the database for a specific count of documents, you will always use the skip and limit built-in query methods in mongoose. skip is used to set a cursor after a certain number of documents, after which the query will get implemented. limit is used to retrieve a specific number of documents.

Inside any query builder method, this refers to the query itself. And since query builders are chainable, you can call any of them after each other.

Finally, any query builder method should return a mongoose query object, which is why you must write return this.skip(skip).limit(limit).

Example usage:

const results = await Client.find().paginate({ page: 2, limit: 5 });
//or
const results = await Seller.find().paginate({ page: 2, limit: 5 });
//or
const results = await Admin.find().paginate({ page: 2, limit: 5 });

You can then call it on any query, and await Client.find().paginate({ page: 2, limit: 5 }) will invoke the paginate function and replace the this keyword with Client.find() using the query builder.

You can implement pagination with certain conditions, but you'll always call skip and limit. By defining the paginate query builder you won't repeat yourself and you'll be able to encapsulate the logic in one single function.

Hooks

Hooks (also known as middleware) are functions that are executed at specific points in the lifecycle of a document. They allow you to add custom behavior before or after certain operations, such as saving, updating, or removing documents.

Types of Hooks

• Pre Hooks: Executed before an operation.

• Post Hooks: Executed after an operation.

Hooks use case

In your user.model.js file, add a post save middleware through which you can send an email for account activation once the user document is saved in the database.

// post hook
userSchema.post("save", async function (doc, next) {
  // send email logic
  // if succeeded
  return next();
  // if failed
  return next(new Error("Failed to send email!"));
});

The callback function will get invoked once you create a user through model.create() or any time you call save() method on the user document.

In this this example, if you need to avoid sending emails on save, you should write a condition to be sure that this save is for a new user only. You can write something like if (doc.createdAt.getTime() === doc.updatedAt.getTime()).

Summary

In this overview of Mongoose features, we've explored four key concepts: discriminators, statics, methods, and hooks.

Discriminators allow you to create multiple models that share a common schema enabling different document types to be stored in a single collection. This facilitates data management and querying.

Statics are model-level methods that provide reusable functionality applicable to the entire model. They encapsulate complex queries and data manipulation logic, helping to keep your codebase clean and maintainable.

Methods are instance-level functions that operate on individual document instances. They allow for custom behaviors and data manipulations specific to each document, so you can modify the document’s data in a specific way, such as formatting or calculating values based on its fields.

Hooks (or middleware) enable you to run functions at specific points in the document lifecycle, such as before or after saving, updating or deleting a document. This is useful for implementing validation, logging, or any other side effects related to database operations.

Together, these features enhance the versatility and organization of your Mongoose models, making it easier to build robust and maintainable applications with MongoDB.

Here can will find a repository where you can learn more about Mongoose schemas and use cases.