Пошаговое введение в конечное тестирование

Автор оригинала: FreeCodeCamp Community Member.

Я играю с тестированием в последнее время. Одна вещь, которую я пытался сделать, это проверить конечные точки моей экспресс-приложения.

Настройка теста была тяжелой частью. Люди, которые пишут о тестах, на самом деле не учат вас, как они настраивают. Я не мог найти никакой полезной информации об этом, и мне пришлось попытаться понять это.

Итак, сегодня я хочу поделиться настроек, которую я создал для себя. Надеюсь, это может помочь вам, когда вы создаете свои собственные тесты.

Оглавление

1. Настройка шума и превосходных
2. Подключение шума и мангуста
3. Посевная база данных

Настройка шума и превосходных

Во-первых, давайте поговорим о стеке.

Стек

• Я создал свое приложение с Express.
• Я использовал Mongoose для подключения к MongoDB
• Я использовал jest как мою тестовую структуру.

Возможно, вы ожидали, что Express и Mongoose, потому что все остальные, кажется, используют эти две рамки. Я использовал их тоже.

Но почему шутки и не другие тестовые рамки?

Почему шума

Мне не нравится Facebook, поэтому я не хотел попробовать все, что было создано командой Facebook. Я знаю, что это звучит глупо, но это была правда.

Перед шумом я опробовал всевозможные тестовые рамки. Я попробовал нажать, ленту, мокко, жасмин и ава. Каждая тестовая структура имеет свои собственные плюсы и минусы. Я почти закончил Ава, но я не пошел с AVA, потому что мне было трудно настроить. В конце концов, я пробовал шутить, потому что Кент C. Dodds порекомендовал это.

Я влюбился в шутку после пробования этого. Я люблю это, потому что:

1. Это легко настроить
2. Режим часов удивительно
3. Когда ты console.log Что-то, он на самом деле проявляется без каких-либо сложных (это была сука с AVA).

Настройка шума

Во-первых, вам нужно установить шутку.

npm install jest --save-dev

Далее вы хотите добавить тесты сценариев для вашего Package.json файл. Это помогает добавить Тест и Тест: Смотреть Сценарии (для одноквартирующей тестирования и режима часов соответственно).

"scripts": {
  "test": "jest",
  "test:watch": "jest --watch"
},

Вы можете написать тестовые файлы в одном из следующих форматов. Чрезмерный выбирает их для вас автоматически.

1. JS Файлы в __tests__ папка
2. Файлы с именем test.js (Мне нравится user.test.js )
3. Файлы с именем spec.js (Мне нравится user.spec.js )

Вы можете разместить свои файлы, однако, как вам нравится. Когда я протестировал конечные точки, я вкладываю тестовые файлы вместе с моими конечными точками. Я нашел это проще для управления.

- routes
  |- users/
    |- index.js
    |- users.test.js

Написание вашего первого теста

Jest включает в себя Опишите , Это и ожидать для вас в каждом тестовом файле. Вам не нужно требуется их.

• Опишите Позволяет обернуть много тестов вместе под одним зонтиком. (Используется для организации ваших тестов).
• Это Позволяет запустить тест.
• ожидать Позволяет выполнять утверждения. Тест проходит, если все утверждения пропускают.

Вот пример теста, который терпит неудачу. В этом примере я ожидать что 1 должен быть строго равен 2 Отказ С 1 тест терпит неудачу.

// This test fails because 1 !== 2
it("Testing to see if Jest works", () => {
  expect(1).toBe(2);
});

Вы увидите неудачное сообщение от шума, если вы запустите шутку.

npm run test:watch

Вы можете сделать пропуск теста, ожидая 1 Отказ

// This passes because 1 === 1
it("Testing to see if Jest works", () => {
  expect(1).toBe(1);
});

Это самые основные испытания. Это вообще не полезно, потому что мы еще не тестировали ничего настоящего.

Асинхронные тесты

Вам нужно отправить запрос на проверку конечной точки. Запросы асинхронные, что означает, что вы должны иметь возможность проводить асинхронные тесты.

Это легко с шумом. Есть два шага:

1. Добавьте async ключевое слово
2. Позвоните сделано Когда вы закончите с вашими тестами

Вот что это может выглядеть так:

it("Async test", async done => {
  // Do your async tests here

  done();
});

Примечание: Вот статья На async/ждут в JavaScript, если вы не знаете, как его использовать.

Тестирование конечных точек

Вы можете использовать Supertest для тестирования конечных точек. Во-первых, вам нужно установить сверхтест.

npm install supertest --save-dev

Прежде чем вы сможете проверить конечные точки, вам необходимо настроить сервер, чтобы Supertest можно использовать его в своих тестах.

Большинство учебных пособий учат вас слушать В приложение Express в файле сервера, как это:

const express = require("express");
const app = express();

// Middlewares...
// Routes...

app.listen(3000);

Это не работает, потому что он начинает слушать один порт. Если вы попытаетесь написать много тестовых файлов, вы получите ошибку, которая написана «Порт в использовании».

Вы хотите разрешить каждому тестовым файлам запустить сервер самостоятельно. Для этого вам нужно экспортировать приложение не слушая к этому.

// server.js
const express = require("express");
const app = express();

// Middlewares...
// Routes...

module.exports = app;

Для развития или производства вы можете слушать ваше приложение Как обычно в другом файле, как start.js Отказ

// start.js
const app = require("./server.js");
app.listen(3000);

Используя сверхтест

Чтобы использовать Supertest, вам требуется ваше приложение и превосходнее в тестовом файле.

const app = require("./server"); // Link to your server file
const supertest = require("supertest");
const request = supertest(app);

Как только вы сделаете это, вы получаете возможность отправлять запросы Get, Post, Put, Patch и Delete. Прежде чем отправить запрос, нам нужно иметь конечную точку. Скажем, у нас есть /test конечная точка.

app.get("/test", async (req, res) => {
  res.json({ message: "pass!" });
});

Отправить запрос на получение /test , вы используете .get метод от превосходного.

it("Gets the test endpoint", async done => {
  // Sends GET Request to /test endpoint
  const res = await request.get("/test");

  // ...
  done();
});

Supertest дает вам ответ с конечной точки. Вы можете проверить состояние HTTP, так и тело (все, что вы отправляете через res.json ), как это:

it("gets the test endpoint", async done => {
  const response = await request.get("/test");

  expect(response.status).toBe(200);
  expect(response.body.message).toBe("pass!");
  done();
});

Подключение шума и мангуста

Тяжелая часть о тестировании приложения Backend устанавливает тестовую базу данных. Это может быть сложно.

Сегодня я хочу поделиться, как я настроил шутку и мангусты.

Настройка мангуста с шумом

Quest дает вам предупреждение, если вы пытаетесь использовать мангуст с шумом.

Если вы не хотите видеть эту ошибку, вам нужно установить TestenVironment к Узел В вашем Package.json файл.

"jest": {
  "testEnvironment": "node"
}

Настройка мангуста в тестовом файле

Вы хотите подключиться к базе данных, прежде чем начать какие-либо тесты. Вы можете использовать BeForall крючок, чтобы сделать это.

beforeAll(async () => {
  // Connect to a Mongo DB
});

Для подключения к MongoDB вы можете использовать Mongoose’s соединить команда.

const mongoose = require("mongoose");
const databaseName = "test";

beforeAll(async () => {
  const url = `mongodb://127.0.0.1/${databaseName}`;
  await mongoose.connect(url, { useNewUrlParser: true });
});

Это создает соединение с базой данных с именем Тест Отказ Вы можете назвать вашу базу данных что-нибудь. Вы узнаете, как очистить их позже.

Примечание. Убедитесь, что у вас есть активное локальное соединение MongoDB перед тестом. Ваши тесты потерпят неудачу, если у вас нет активного локального подключения MongoDB. Прочитайте это Чтобы узнать, как создать локальное соединение MongoDB.

Создание баз данных для каждого тестового файла

Когда вы тестируете, вы хотите подключиться к другой базе данных для каждого тестового файла, потому что:

1. Jest запускает каждый тестовый файл асинхронно. Вы не узнаете, какой файл начнется первым.
2. Вы не хотите тесты, чтобы поделиться одной и той же базой данных. Вы не хотите данные из одного тестового файла, чтобы пролить следующий тестовый файл.

Для подключения к другой базе данных вы изменяете имя базы данных.

// Connects to database called avengers
beforeAll(async () => {
  const url = `mongodb://127.0.0.1/avengers`;
  await mongoose.connect(url, { useNewUrlParser: true });
});

// Connects to database power-rangers
beforeAll(async () => {
  const url = `mongodb://127.0.0.1/power-rangers`;
  await mongoose.connect(url, { useNewUrlParser: true });
});

Отправка почтового запроса

Допустим, вы хотите создать пользователя для вашего приложения. У пользователя есть имя и адрес электронной почты. Ваша схема Mongoose может выглядеть так:

const mongoose = require("mongoose");
const Schema = mongoose.Schema;

const userSchema = new Schema({
  name: String,
  email: {
    type: String,
    require: true,
    unique: true
  }
});

module.exports = mongoose.model("User", userSchema);

Чтобы создать пользователя, вам нужно сохранить Имя и Email в Монгодб. Ваш маршрут и контроллер могут выглядеть так:

const User = require("../model/User"); // Link to your user model

app.post("/signup", async (req, res) => {
  const { name, email } = req.body;
  const user = new User({ name, email });
  const ret = await user.save();
  res.json(ret);
});

Чтобы сохранить пользователь в базу данных, вы можете отправить почтовый запрос на Регистрация Отказ Чтобы отправить запрос на почту, вы используете пост метод. Для отправки данных вместе с запросом Post вы используете Отправить метод. В ваших тестах это будет выглядеть так.

it("Should save user to database", async done => {
  const res = await request.post("/signup").send({
    name: "Zell",
    email: "testing@gmail.com"
  });
  done();
});

Примечание. Если вы запустите этот код два раза, вы получите E1100 Дубликата ключевой ошибки Отказ Эта ошибка произошла, потому что:

1. Мы сказали Email должно быть Уникальный в схеме выше.
2. Мы пытались создать другой пользователь с testing@gmail.com Отказ Хотя один уже существует в базе данных. (Первый был создан, когда вы отправили первый запрос).

Очистка базы данных между тестами

Вы хотите удалить записи из базы данных между каждым тестом. Это гарантирует, что вы всегда начинаете с пустой базы данных.

Вы можете сделать это с ДОПОЛЮЧЕНИЕ крюк.

// Cleans up database between each test
afterEach(async () => {
  await User.deleteMany();
});

В этом коде выше мы только очистили Пользователь Коллекция в базе данных. В реальном сценарии вы хотите очистить все коллекции. Вы можете использовать следующий код, чтобы сделать это:

async function removeAllCollections() {
  const collections = Object.keys(mongoose.connection.collections);
  for (const collectionName of collections) {
    const collection = mongoose.connection.collections[collectionName];
    await collection.deleteMany();
  }
}

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

Тестирование конечной точки

Давайте начнем наши тесты. В этом тесте мы вышлем почтовый запрос на /Регистрация конечная точка. Мы хотим убедиться:

1. Пользователь сохраняется в базе данных
2. Возвращенный объект содержит информацию о пользователе

Проверка, если пользователь был сохранен в базе данных

Чтобы проверить, сохраняется ли пользователь в базу данных, вы ищете базу данных для пользователя.

const User = require("../model/User"); // Link to your user model

it("Should save user to database", async done => {
  const res = await request.post("/signup").send({
    name: "Zell",
    email: "testing@gmail.com"
  });

  // Searches the user in the database
  const user = await User.findOne({ email: "testing@gmail.com" });

  done();
});

Если вы console.log Пользователь, вы должны увидеть что-то вроде этого:

Это означает, что наш пользователь сохранился в базе данных. Если мы хотим подтвердить, что у пользователя есть имя и электронное письмо, мы можем сделать ожидать их быть правдой.

it("Should save user to database", async done => {
  // Sends request...

  // Searches the user in the database
  const user = await User.findOne({ email: "testing@gmail.com" });
  expect(user.name).toBeTruthy();
  expect(user.email).toBeTruthy();

  done();
});

Проверка, если возвращенный объект содержит информацию о пользователе

Мы хотим убедиться, что возвращенный объект содержит имя пользователя и адрес электронной почты. Для этого мы проверяем ответ от почтового запроса.

it("Should save user to database", async done => {
  // Sends request...

  // Searches the user in the database...

  // Ensures response contains name and email
  expect(res.body.name).toBeTruthy();
  expect(res.body.email).toBeTruthy();
  done();
});

Теперь мы закончили с нашими тестами. Мы хотим удалить базу данных из MongoDB.

Удаление базы данных

Чтобы удалить базу данных, вам необходимо убедиться, что в базе данных есть 0 коллекций. Мы можем сделать это, бросая каждую коллекцию, которую мы использовали.

Мы сделаем после всех наших тестов, в Послеобеда крюк.

afterAll(async () => {
  // Removes the User collection
  await User.drop();
});

Чтобы отбросить все ваши коллекции, вы можете использовать это:

async function dropAllCollections() {
  const collections = Object.keys(mongoose.connection.collections);
  for (const collectionName of collections) {
    const collection = mongoose.connection.collections[collectionName];
    try {
      await collection.drop();
    } catch (error) {
      // This error happens when you try to drop a collection that's already dropped. Happens infrequently.
      // Safe to ignore.
      if (error.message === "ns not found") return;

      // This error happens when you use it.todo.
      // Safe to ignore.
      if (error.message.includes("a background operation is currently running"))
        return;

      console.log(error.message);
    }
  }
}

// Disconnect Mongoose
afterAll(async () => {
  await dropAllCollections();
});

Наконец, вы хотите закрыть монгустную связь, чтобы завершить тест. Вот как вы можете сделать это:

afterAll(async () => {
  await dropAllCollections();
  // Closes the Mongoose connection
  await mongoose.connection.close();
});

Это все, что вам нужно сделать, чтобы настроить мангуст с шумом!

Рефакторинг

Есть много кода, который входит в Rebedeach , ДОПОЛЮЧЕНИЕ и Послеобеда крючки. Мы будем использовать их для каждого тестового файла. Имеет смысл создать файл установки для этих крюков.

// test-setup.js
const mongoose = require("mongoose");
mongoose.set("useCreateIndex", true);
mongoose.promise = global.Promise;

async function removeAllCollections() {
  const collections = Object.keys(mongoose.connection.collections);
  for (const collectionName of collections) {
    const collection = mongoose.connection.collections[collectionName];
    await collection.deleteMany();
  }
}

async function dropAllCollections() {
  const collections = Object.keys(mongoose.connection.collections);
  for (const collectionName of collections) {
    const collection = mongoose.connection.collections[collectionName];
    try {
      await collection.drop();
    } catch (error) {
      // Sometimes this error happens, but you can safely ignore it
      if (error.message === "ns not found") return;
      // This error occurs when you use it.todo. You can
      // safely ignore this error too
      if (error.message.includes("a background operation is currently running"))
        return;
      console.log(error.message);
    }
  }
}

module.exports = {
  setupDB(databaseName) {
    // Connect to Mongoose
    beforeAll(async () => {
      const url = `mongodb://127.0.0.1/${databaseName}`;
      await mongoose.connect(url, { useNewUrlParser: true });
    });

    // Cleans up database between each test
    afterEach(async () => {
      await removeAllCollections();
    });

    // Disconnect Mongoose
    afterAll(async () => {
      await dropAllCollections();
      await mongoose.connection.close();
    });
  }
};

Вы можете импортировать файл установки для каждого теста, как это:

const { setupDB } = require("../test-setup");

// Setup a Test Database
setupDB("endpoint-testing");

// Continue with your tests...

Я хочу показать вам еще одну вещь.

Когда вы создаете тесты, вы хотите осевать базу данных с поддельными данными.

Посевная база данных

Когда вы пишете тесты на бэкэнду, вам нужно проверить на четырех различных видах операций:

1. Создать (для добавления вещей в базу данных)
2. Читать (для получения вещей из базы данных)
3. Обновление (для изменения базы данных)
4. Удалить (для удаления вещей из базы данных)

Самый простой тип для тестирования для создания операций. Вы положите что-то в базу данных и проверите, будь то там.

Для других трех типов операций вам нужно что-то поставить в базу данных до Вы пишете тест.

Положить вещи в базу данных

Процесс, в котором вы добавляете вещи в базу данных, называется Осевание базы данных Отказ

Допустим, вы хотите добавить трех пользователей в базу данных. Эти пользователи содержат имя и адрес электронной почты.

const users = [
  {
    name: "Zell",
    email: "testing1@gmail.com"
  },
  {
    name: "Vincy",
    email: "testing2@gmail.com"
  },
  {
    name: "Shion",
    email: "testing3@gmail.com"
  }
];

Вы можете использовать ваши модели для семян базы данных в начале теста.

const User = require("../model/User"); // Link to User model

it("does something", async done => {
  // Add users to the database
  for (const u of users) {
    const user = new User(u);
    await user.save();
  }

  // Create the rest of your test here
});

Если вам нужны эти пользователи для каждого теста, лучший способ – добавить их через Rebedeach крюк. Rebedeach Крюк пробегает перед каждым Это Декларация.

// Seed the database with users
beforeEach(async () => {
  for (u of users) {
    const user = new User(u);
    await user.save();
  }
});

Вы также можете использовать Mongoose создать Функция делать то же самое. Он работает Новая модель () и Сохранить () Итак, код ниже и тот выше, делает то же самое.

// Seed the database with users
beforeEach(async () => {
  await User.create(users);
});

Создать VS insermany

Mongoose имеет второй метод, чтобы помочь вам сеять базу данных. Этот метод называется insermany Отказ insermany быстрее, чем создать , так как:

• insermany Отправляет одну операцию на сервер
• создать Отправляет одну операцию для каждого документа

Тем не менее, insermany не работает Сохранить промежуточное ПО.

Запускает эмоциональное промежуточное программное обеспечение?

Это зависит от данных ваших семян. Если ваши данные семян необходимо пройти через Сохранить промежуточное ПО, нужно использовать создать Отказ Например, скажем, вы хотите сохранить пароль пользователя в базу данных. У вас есть эти данные:

const users = [
  {
    name: "Zell",
    email: "testing1@gmail.com",
    password: "12345678"
  },
  {
    name: "Vincy",
    email: "testing2@gmail.com",
    password: "12345678"
  },
  {
    name: "Shion",
    email: "testing3@gmail.com",
    password: "12345678"
  }
];

Когда мы сохраняем пароль пользователя в базу данных, мы хотим использовать пароль для соображений безопасности. Обычно мы используем пароль через Сохранить промежуточное ПО.

// Hashes password automatically
userSchema.pre("save", async function(next) {
  if (!this.isModified("password")) return next();
  const salt = bcrypt.genSaltSync(10);
  const hashedPassword = bcrypt.hashSync(password, salt);
  this.password = hashedPassword;
});

Если вы используете создать Вы получите пользователей с Haved Passwords:

Если вы используете insermany , вы получите пользователей без Hashed пароли:

Когда использовать создание, когда использовать Issermany

С insermany быстрее, чем создать , вы хотите использовать insermany когда вы сможете.

Вот как я это делаю:

1. Если данные семян не требуют Сохранить промежуточное ПО, используйте insermany Отказ
2. Если данные семян требуются Сохранить промежуточное ПО, используйте создать Отказ Затем перезаписать данные семян, чтобы он больше не требует Сохранить промежуточное ПО.

Для приведенного выше пример пароля я бы запустил создать первый. Затем я копирую – вставьте хешированные данные семян пароля. Тогда я бегу insermany С этого момента награды.

Если вы хотите перезаписать сложные данные семян, вы можете получить JSON прямо с MongoDB. Для этого вы можете использовать MongoExport :

mongoexport --db  --collection  --jsonArray --pretty --out output.json

Это говорит:

1. Экспорт <Коллекция> от <База данных имени>
2. Создает вывод как массив JSON, преобразован, в файле под названием вывод .json Отказ Этот файл будет размещен в папке, где вы запускаете команду.

Осевание нескольких тестовых файлов и коллекций

Вы хотите, чтобы место для хранения данных вашего семян, чтобы вы могли использовать их на всех ваших тестах и коллекциях. Вот система, которую я использую:

1. Я называю свои файлы семян в соответствии с их моделями. Я семяюсь Пользователь Модель с user.seed.js файл.
2. Я положил свои файлы семян в Семена папка
3. Я петлю через каждый файл семян для семян базы данных.

Чтобы включить каждый файл семян, вам нужно использовать ФС модуль. ФС обозначает файловую систему.

Самый простой способ петли через файлы – создать index.js Файл в то же самое Семена папка. Как только у вас есть index.js Файл, вы можете использовать следующий код для поиска всех файлов с * .Eed.js.

const fs = require("fs");
const util = require("util");

// fs.readdir is written with callbacks.
// This line converts fs.readdir into a promise
const readDir = util.promisify(fs.readdir);

async function seedDatabase() {
  // Gets list of files in the directory
  // `__dirname` points to the `seeds/` folder
  const dir = await readDir(__dirname);

  // Gets a list of files that matches *.seed.js
  const seedFiles = dir.filter(f => f.endsWith(".seed.js"));
}

После того, как у вас есть список файлов семян, вы можете включить каждый файл семян для семян базы данных. Вот, я использую для ... из петля, чтобы держать вещи простыми.

async function seedDatabase() {
  for (const file of seedFiles) {
    // Seed the database
  }
}

Для семян базы данных нам нужно найти правильную модель Mongoose от имени файла семян. Файл под названием user.seed.js Должен сеять Пользователь модель. Это означает:

1. Мы должны найти Пользователь от user.seed.js.
2. Мы должны управлять капитализировать Пользователь в Пользователь

Вот неочищенная версия, которая делает то, что требуется. (Если вы хотите, вы можете сделать код более прочным Regex вместо Split ).

for (const file of seedFiles) {
  const fileName = file.split(".seed.js")[0];
  const modelName = toTitleCase(fileName);
  const model = mongoose.models[modelName];
}

Далее мы хотим убедиться, что каждый файл имеет модель, которая соответствует этому. Если модель не может быть найдена, мы хотим бросить ошибку.

for (const file of seedFiles) {
  //...
  if (!model) throw new Error(`Cannot find Model '${modelName}'`);
}

Если есть соответствующая модель, мы хотим селить базу данных с содержимым в файле семян. Для этого нам нужно сначала прочитать файл семян. Вот, так как я использовал .js Расширение, я могу просто требовать файла.

for (const file of seedFiles) {
  //...
  const fileContents = require(path.join(__dirname, file));
}

Для этого на работе мои файлы семян должны экспортировать массив данных.

module.exports = [
  {
    name: "Zell",
    email: "testing1@gmail.com",
    password: "12345678"
  },
  {
    name: "Vincy",
    email: "testing2@gmail.com",
    password: "12345678"
  },
  {
    name: "Shion",
    email: "testing3@gmail.com",
    password: "12345678"
  }
];

Как только у меня есть содержимое файла семян, я могу запустить создать или insermany Отказ

async function seedDatabase(runSaveMiddleware = false) {
  // ...
  for (const file of seedFiles) {
    // ...

    runSaveMiddleware
      ? model.create(fileContents)
      : model.insertMany(fileContents);
  }
}

Вот целый Sedwdatabase код:

const fs = require("fs");
const util = require("util");
const readDir = util.promisify(fs.readdir).bind(fs);
const path = require("path");
const mongoose = require("mongoose");

function toTitleCase(str) {
  return str.replace(/\w\S*/g, txt => {
    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
  });
}

async function seedDatabase(runSaveMiddleware = false) {
  const dir = await readDir(__dirname);
  const seedFiles = dir.filter(f => f.endsWith(".seed.js"));

  for (const file of seedFiles) {
    const fileName = file.split(".seed.js")[0];
    const modelName = toTitleCase(fileName);
    const model = mongoose.models[modelName];

    if (!model) throw new Error(`Cannot find Model '${modelName}'`);
    const fileContents = require(path.join(__dirname, file));

    runSaveMiddleware
      ? await model.create(fileContents)
      : await model.insertMany(fileContents);
  }
}

Почему JS, а не JSON?

Это отраслевая норма для использования данных JSON для хранения данных. В этом случае мне легче использовать объекты JavaScript, потому что:

1. Мне не нужно писать открытие и закрытие двойных кавычек для каждого свойства.
2. Мне не нужно вообще использовать двойные цитаты! (Легче писать однозначные цитаты, потому что нет необходимости нажать клавишу Shift).

// Which is easier to write. JavaScript objects or JSON?

// JavaScript objects
module.exports = [
  {
    objectName: "property"
  }
][
  // JSON
  {
    objectName: "property"
  }
];

Если вы хотите использовать JSON, убедитесь, что вы меняете Sedwdatabase работать с JSON. (Я позволю вам работать через код самостоятельно).

Регулировка функции setupdb

Раньше я создал setupdb Функция, чтобы помочь настроить базы данных для моих тестов. Sedwdatabase идет в setupdb Функция с момента посева является частью процесса настройки.

async function seedDatabase(runSaveMiddleware = false) {
  // ...
}

module.exports = {
  setupDB(databaseName, runSaveMiddleware = false) {
    // Connect to Mongoose
    beforeAll(/*...*/);

    // Seed Data
    beforeEach(async () => {
      await seedDatabase(runSaveMiddleware);
    });

    // Cleans up database between each test
    afterEach(/*...*/);

    // Disconnect Mongoose
    afterAll(/*...*/);
  }
};

Репозиторий Github

Я создал Github Repository идти с этой статьей. Я надеюсь, что этот демо-код поможет вам начать тестировать ваши приложения.

Спасибо за прочтение. Эта статья была первоначально опубликована на мой блог Отказ Подпишитесь на Моя рассылка Если вы хотите больше статей, чтобы помочь вам стать лучшим разработчиком Frontend.