Блог

Я новичок в Jest и TypeORM и хочу разработать платформу проверки базы данных с использованием typeorm и Jest. Как вызвать три экземпляра соединений с БД в beforeAll().

Это для новой платформы для проверки базы данных с использованием TypeORM и Jest Ormconfig.json содержит сведения о трех базах данных и имеет класс .ts для подключения к базе данных и тестовый класс.

ormconfig.json

 [{
  "name": "default",
  "type": "mysql",
  "host": "127.0.01",
  "port": 3306,
  "username": "sdf",
  "password": "uuehfldjskh",
  "database": "ifsdjh",
  "synchronize": true,
  "logging": false,
  "entities": [
    "src/entity/**/*.ts"
  ],
  "migrations": [
    "src/migration/**/*.ts"
  ],
  "subscribers": [
    "src/subscriber/**/*.ts"
  ],
  "cli": {
    "entitiesDir": "src/entity",
    "migrationsDir": "src/migration",
    "subscribersDir": "src/subscriber"
  }
},
  {
    "name": "hello",
    "type": "mysql",
    "host": "127.0.01",
    "port": 3306,
    "username": "weqwe",
    "password": "das",
    "database": "dsfds",
    "synchronize": true,
    "logging": false,
    "entities": [
      "src/entity/**/*.ts"
    ],
    "migrations": [
      "src/migration/**/*.ts"
    ],
    "subscribers": [
      "src/subscriber/**/*.ts"
    ],
    "cli": {
      "entitiesDir": "src/entity",
      "migrationsDir": "src/migration",
      "subscribersDir": "src/subscriber"
    }
  }
]
  

createConnection.ts

 import {createConnection, getConnectionOptions} from "typeorm";

export const createConnection = async  () => {
    const createConnectionOptions = await getConnectionOptions(process.env.NODE_ENV);
    return createConnection({...createConnectionOptions,name:"default"});
}
  

TestClass.ts

 import {Patches} from "../entity/Patches";
import {createConnection} from "../utils/createConnection";

test('Query with getRepository()', async () => {
    jest.setTimeout(100000);
    const connection = await createConnection();
    const Count = await connection.getRepository(User).count();
    console.log(Count);
    expect(Count).toEqual(32);
    await connection.close();
})
  

Как я могу перемещать соединение с базой данных перед каждым тестом —

 beforeAll(){
connectionDB();
}

test()
{
   connection(db1) //connect to DB1
   /** Do operation on DB1 **/
   connection(db2) //connect to DB2
   /** Do operation on DB2 **/
   Compare both result of DB1 and DB2
}

afterAll()
{
connectionDB().close();
}
  

псевдокод:

 let connection;

beforeAll(){
  connection = connectionDB();
}

test() {
  //...
}

afterAll() {
  connection.close();
}
  

Вы смешиваете шаблоны. если вы используете n соединений. Не создавайте соединение по умолчанию, а скорее три именованных соединения в файле ormconfig.json.

как только вы это сделаете — в конфигурации вы используете name (привет в вашем примере), чтобы найти и загрузить конфигурацию.

 
beforeEach(async () => {
  await TypeORM.createConnection('connection1Name')
  await TypeORM.createConnection('connection2Name')
  await TypeORM.createConnection('connection3Name')

})

afterEach(async () => {
  await getConnection('connection1Name').close()
  await getConnection('connection2Name').close()
  await getConnection('connection3Name').close()

})

// in your tests you can find use getConnection('name') to use the specific connection

  

Если вы хотите переместить код соединения перед каждым тестом, вы можете использовать beforeEach и afterEach . Вы также можете структурировать свои тесты таким образом, чтобы каждый из них применялся к тестам внутри области describe видимости.

 // Applies to all tests in this file
beforeEach(() => {
  return initializeCityDatabase();
});

test('city database has Vienna', () => {
  expect(isCity('Vienna')).toBeTruthy();
});

describe('matching cities to foods', () => {
  // Applies only to tests in this describe block
  beforeEach(() => {
    return initializeFoodDatabase();
  });

  test('Vienna <3 sausage', () => {
    expect(isValidCityFoodPair('Vienna', 'Wiener Schnitzel')).toBe(true);
  });
});
  

Источник: https://jestjs.io/docs/en/setup-teardown.html

• Мы переместили тестовую настройку в другой файл, в котором мы инициализируем и экспортируем соединение Apollo-server и db (как асинхронную функцию, вызываемую немедленно).

• В beforeEach / afterEach внутри наших тестов мы ждем соединения и закрываем его по завершении.

Что вы думаете?

resolvers.test.ts :

 process.env.NODE_ENV = 'test';
import { gql } from 'apollo-server-express';
import { connection } from '../../utils/testEnv';
import { server } from '../../utils/testEnv';
import mongoose from 'mongoose';

let db: typeof mongoose;

beforeAll(async () => {
   db = await connection;
})
   
afterAll(async () => {
   await db.connection.close();
})
   
describe("Resolvers tests", () => {
   it("Throw user with no context",  async () => {
      
      const expectedErrorMessage = 'Not logged in';

      const query = gql`{ 
                           user {
                              firstName
                           } 
                        }
                     `;

      const result = await server.executeOperation({
         query: query,
      })
  expect(result.errors[0].message).toEqual(expectedErrorMessage);
})  

testEnv.ts :

 import  mongoose from "mongoose";
import typeDefs from '../schemas/typeDefs';
import resolvers from '../schemas/resolvers';
const { ApolloServer } = require('apollo-server-express');
const {authMiddleware} = require('../utils/auth');

export const server: typeof ApolloServer = new ApolloServer(
   {
      resolvers, 
      typeDefs, 
      context: authMiddleware}, 
   {  
      stopGracePeriodMillis: Infinity
   }
);

export const connection = (async function connect() {

   return await mongoose.connect(process.env.MONGO_TEST_CONNECTION, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
      useCreateIndex: true,
      useFindAndModify: false,
    })})();