import 'reflect-metadata';
import '../../utils/test-setup';
import {
	closeTestingConnections,
	createTestingConnections,
	reloadTestingDatabases,
} from '../../utils/test-utils';
import { DataSource } from '../../../src';
import { Person } from './entity/person';
import { Note } from './entity/note';

describe('github issues > #2965 Reuse preloaded lazy relations', () => {
	let connections: DataSource[];
	before(
		async () =>
			(connections = await createTestingConnections({
				entities: [__dirname + '/entity/*{.js,.ts}'],
				// use for manual validation
				// logging: true,
			})),
	);
	beforeEach(() => reloadTestingDatabases(connections));
	after(() => closeTestingConnections(connections));

	it('should resuse preloaded lazy relations', () =>
		Promise.all(
			connections.map(async (connection) => {
				const repoPerson = connection.getRepository(Person);
				const repoNote = connection.getRepository(Note);

				const personA = await repoPerson.create({ name: 'personA' });
				const personB = await repoPerson.create({ name: 'personB' });

				await repoPerson.save([personA, personB]);

				await repoNote.insert({ label: 'note1', owner: personA });
				await repoNote.insert({ label: 'note2', owner: personB });

				const res1 = await repoPerson.find({
					relations: { notes: true },
				});

				const originalLoad: (...args: any[]) => Promise<any[]> = connection.relationLoader.load;
				let loadCalledCounter = 0;
				connection.relationLoader.load = (...args: any[]): Promise<any[]> => {
					loadCalledCounter++;
					return originalLoad.call(connection.relationLoader, ...args);
				};

				const personANotes = await res1[0].notes;
				loadCalledCounter.should.be.equal(0);
				personANotes[0].label.should.be.equal('note1');

				const res2 = await repoPerson.find({ order: { id: 'asc' } });
				const personBNotes = await res2[1].notes;
				loadCalledCounter.should.be.equal(1);
				personBNotes[0].label.should.be.equal('note2');
			}),
		));
});