import 'reflect-metadata';
import { expect } from 'chai';
import { DataSource } from '../../../src';
import { User } from './entity/User';
import { Role } from './entity/Role';
import {
	createTestingConnections,
	reloadTestingDatabases,
	closeTestingConnections,
} from '../../utils/test-utils';

describe('github issues > #6265 `fix: resolve issue with find with relations returns soft-deleted entities', () => {
	let connections: DataSource[];

	before(async () => {
		connections = await createTestingConnections({
			entities: [User, Role],
			schemaCreate: true,
			dropSchema: true,
		});
	});
	beforeEach(() => reloadTestingDatabases(connections));
	after(() => closeTestingConnections(connections));

	it('should soft delete one record in relation table', () =>
		Promise.all(
			connections.map(async (connection) => {
				const role = new Role();
				role.title = 'Manager';
				await connection.manager.save(role);

				const firstUser = new User();
				firstUser.name = 'Alex Messer';
				firstUser.role = role;
				await connection.manager.save(firstUser);

				const secondUser = new User();
				secondUser.name = 'Timber Saw';
				secondUser.role = role;
				await connection.manager.save(secondUser);

				const roleWithAllUser = await connection.manager
					.createQueryBuilder(Role, 'role')
					.leftJoinAndSelect('role.users', 'users')
					.getMany();
				expect(roleWithAllUser[0].users.length).eq(2);
				expect(
					roleWithAllUser.should.be.eql([
						{
							id: 1,
							title: 'Manager',
							deleteDate: null,
							users: [
								{ id: 1, name: 'Alex Messer', deleteAt: null },
								{ id: 2, name: 'Timber Saw', deleteAt: null },
							],
						},
					]),
				);

				await connection.manager
					.createQueryBuilder(User, 'user')
					.softDelete()
					.where({ name: 'Timber Saw' })
					.execute();

				const roleWithUserIsNotSoftDelete = await connection.manager
					.createQueryBuilder(Role, 'role')
					.leftJoinAndSelect('role.users', 'users')
					.getMany();

				expect(roleWithUserIsNotSoftDelete[0].users.length).eq(1);

				expect(
					roleWithUserIsNotSoftDelete.should.be.eql([
						{
							id: 1,
							title: 'Manager',
							deleteDate: null,
							users: [{ id: 1, name: 'Alex Messer', deleteAt: null }],
						},
					]),
				);
				const roleWithUserSoftDelete = await connection.manager
					.createQueryBuilder(Role, 'role')
					.withDeleted()
					.leftJoinAndSelect('role.users', 'users')
					.getMany();

				expect(roleWithUserSoftDelete[0].users.length).eq(2);
				expect(roleWithUserSoftDelete[0].users[1].deleteAt).to.be.not.null;
			}),
		));
});