import 'reflect-metadata';

import { expect } from 'chai';

import { DataSource } from '../../../src/data-source/DataSource';
import {
	closeTestingConnections,
	createTestingConnections,
	reloadTestingDatabases,
} from '../../utils/test-utils';
import { Bar } from './entity/Bar';
import { Foo } from './entity/Foo';

describe('github issues > #2251 - Unexpected behavior when passing duplicate entities to repository.save()', () => {
	let connections: DataSource[];
	before(
		async () =>
			(connections = await createTestingConnections({
				entities: [__dirname + '/entity/*{.js,.ts}'],
				schemaCreate: true,
				dropSchema: true,
			})),
	);

	beforeEach(() => reloadTestingDatabases(connections));
	after(() => closeTestingConnections(connections));

	it('should update all entities', () =>
		Promise.all(
			connections.map(async (connection) => {
				const repo = connection.getRepository(Bar);

				await repo.save([{ description: 'test1' }, { description: 'test2' }]);

				let bars = await repo.find();
				await repo.save([
					{ id: 1, description: 'test1a' },
					{ id: 2, description: 'test2a' },
					{ id: 1, description: 'test1a' },
					{ id: 2, description: 'test2a' },
				]);

				bars = await repo.find();

				expect(bars.length).to.equal(2);
			}),
		));

	it('should handle cascade updates', () =>
		Promise.all(
			connections.map(async (connection) => {
				const barRepo = connection.getRepository(Bar);
				const fooRepo = connection.getRepository(Foo);

				await fooRepo.save({
					bars: [{ description: 'test2a' }, { description: 'test2b' }],
				});

				await fooRepo.save({
					id: 1,
					bars: [
						{ id: 1, description: 'test2a-1' },
						{ description: 'test2c' },
						{ id: 1, description: 'test2a-2' },
					],
				});

				const bars = await barRepo.find();

				// We saved two bars originally. The above save should update the description of one,
				// remove the reference of another and insert a 3rd.
				expect(bars.length).to.equal(3);

				const bar = await barRepo.findOneBy({ id: 1 });

				expect(bar).not.to.be.null;

				// Did not observe the same behavior with unwanted inserts. Current behavior is
				// that the first duplicate goes through and the rest are ignored.
				expect(bar!.description).to.equal('test2a-1');
			}),
		));
});