node.js - TypeORM-Verbindung in Test nicht gefunden

Ich studiere saubere Architektur mit TDD, indem ich eine einfache Anwendung erstelle, und versuche, das UserRepository in meiner Infrastrukturschicht zu implementieren, aber ich erhalte diesen Fehler ConnectionNotFoundError: Connection "default" was not found., selbst nachdem ich eine Verbindung hergestellt habe, bevor ich den Test selbst ausführe.

Dies ist meine UserEntity-Klasse.

import { PrimaryColumn, Column, CreateDateColumn, UpdateDateColumn, Entity } from 'typeorm'

@Entity('users')
export class UserEntity {
  @PrimaryColumn('uuid')
  id: string

  @Column()
  name: string

  @Column({ unique: true })
  email: string

  @Column()
  password: string

  @CreateDateColumn()
  created_at: Date

  @UpdateDateColumn()
  updated_at: Date
}

In diesem UserRepository implementiere ich ein CreateUserRepository, das die unten stehenden create-Methoden hat. Um auf das TypeORM-Repository zuzugreifen, verwende ich die getRepository-Methode von TypeORM.

import { getRepository, Repository } from 'typeorm'

import { CreateUserRepositoryDTO, CreateUserRepository } from '../../../../data/protocols/db/user/CreateUserRepository'
import { UserModel } from '../../../../domain/models/UserModel'
import { UserEntity } from '../entities/UserEntity'

export class UserRepository implements CreateUserRepository {
  private ormRepository: Repository<UserEntity>

  constructor () {
    this.ormRepository = getRepository(UserEntity)
  }

  async create (userData: CreateUserRepositoryDTO): Promise<UserModel> {
    const user = await this.ormRepository.create(userData)
    const result = await this.ormRepository.save(user)
    return result
  }
}

import { mockCreateUserRepositoryDTO } from '../../test/mockCreateUserRepositoryDTO'
import { createTestConnection } from '../helpers/TypeORMHelper'
import { UserRepository } from './UserRepository'

describe('UserRepository', () => {
  it('Should return User on create Success', async () => {
    await createTestConnection()
    const userData = mockCreateUserRepositoryDTO()
    const sut = new UserRepository()
    const user = await sut.create(userData)
    console.log(user)
  })
})

import { createConnection, Connection, ConnectionOptions } from 'typeorm'

import { postgresCreds, schemaConfig } from '../../../../../ormconfig'

async function createDbConnection (options: ConnectionOptions): Promise<Connection> {
  try {
    const connection: Connection = await createConnection(options)
    console.log(`TypeORM Connected to ${options.database}`)
    return connection
  } catch (err) {
    console.log('Problem with TypeORM connection')
    throw err.message
  }
}

export async function createTestConnection () {
  return createDbConnection({
    name: 'testConnection',
    type: 'postgres',
    database: 'market-list-test',
    synchronize: false,
    ...postgresCreds,
    ...schemaConfig,
    logging: ['error']
  })
}