first commit

packages/cli/test/integration/workflow-history-manager.test.ts

@@ -0,0 +1,248 @@
+import {
+	createWorkflow,
+	testDb,
+	mockInstance,
+	createActiveWorkflow,
+} from '@n8n/backend-test-utils';
+import { GlobalConfig } from '@n8n/config';
+import { WorkflowHistoryRepository, WorkflowRepository } from '@n8n/db';
+import { Container } from '@n8n/di';
+import { In } from '@n8n/typeorm';
+import { DateTime } from 'luxon';
+
+import { License } from '@/license';
+import { WorkflowHistoryManager } from '@/workflows/workflow-history/workflow-history-manager';
+
+import { createManyWorkflowHistoryItems } from './shared/db/workflow-history';
+
+describe('Workflow History Manager', () => {
+	const license = mockInstance(License);
+	let repo: WorkflowHistoryRepository;
+	let manager: WorkflowHistoryManager;
+	let globalConfig: GlobalConfig;
+
+	beforeAll(async () => {
+		await testDb.init();
+		repo = Container.get(WorkflowHistoryRepository);
+		manager = Container.get(WorkflowHistoryManager);
+		globalConfig = Container.get(GlobalConfig);
+	});
+
+	beforeEach(async () => {
+		await testDb.truncate(['WorkflowEntity', 'WorkflowHistory', 'WorkflowPublishHistory']);
+		jest.clearAllMocks();
+
+		globalConfig.workflowHistory.pruneTime = -1;
+
+		license.getWorkflowHistoryPruneLimit.mockReturnValue(-1);
+	});
+
+	afterAll(async () => {
+		await testDb.terminate();
+	});
+
+	test('should prune on interval', () => {
+		const pruneSpy = jest.spyOn(manager, 'prune');
+		const currentCount = pruneSpy.mock.calls.length;
+
+		jest.useFakeTimers();
+		manager.init();
+
+		jest.runOnlyPendingTimers();
+		expect(pruneSpy).toBeCalledTimes(currentCount + 1);
+
+		jest.runOnlyPendingTimers();
+		expect(pruneSpy).toBeCalledTimes(currentCount + 2);
+
+		manager.shutdown();
+		jest.clearAllTimers();
+		jest.useRealTimers();
+		pruneSpy.mockRestore();
+	});
+
+	test('should not prune when both prune times are -1 (infinite)', async () => {
+		await createWorkflowHistory();
+		await pruneAndAssertCount();
+	});
+
+	test('should prune when config prune time is not -1 (infinite)', async () => {
+		globalConfig.workflowHistory.pruneTime = 24;
+		await createWorkflowHistory();
+		await pruneAndAssertCount(0);
+	});
+
+	test('should prune when license prune time is not -1 (infinite)', async () => {
+		license.getWorkflowHistoryPruneLimit.mockReturnValue(24);
+
+		await createWorkflowHistory();
+		await pruneAndAssertCount(0);
+	});
+
+	test('should only prune versions older than prune time', async () => {
+		globalConfig.workflowHistory.pruneTime = 24;
+
+		const recentVersions = await createWorkflowHistory(0);
+		const oldVersions = await createWorkflowHistory();
+
+		await pruneAndAssertCount(10, 20);
+
+		expect(
+			await repo.count({ where: { versionId: In(recentVersions.map((i) => i.versionId)) } }),
+		).toBe(10);
+		expect(
+			await repo.count({ where: { versionId: In(oldVersions.map((i) => i.versionId)) } }),
+		).toBe(0);
+	});
+
+	test('should not prune current versions', async () => {
+		globalConfig.workflowHistory.pruneTime = 24;
+
+		const activeWorkflow = await createActiveWorkflow();
+		const inactiveWorkflow = await createWorkflow();
+
+		// Create old history versions for the active workflow
+		const activeWorkflowVersions = await createManyWorkflowHistoryItems(
+			activeWorkflow.id,
+			5,
+			DateTime.now().minus({ days: 2 }).toJSDate(),
+		);
+
+		// Create old history versions for the inactive workflow
+		const inactiveWorkflowVersions = await createManyWorkflowHistoryItems(
+			inactiveWorkflow.id,
+			5,
+			DateTime.now().minus({ days: 2 }).toJSDate(),
+		);
+
+		// Set the current version for each workflow
+		activeWorkflow.versionId = activeWorkflowVersions[0].versionId;
+		inactiveWorkflow.versionId = inactiveWorkflowVersions[0].versionId;
+
+		const workflowRepo = Container.get(WorkflowRepository);
+		await workflowRepo.save([activeWorkflow, inactiveWorkflow]);
+
+		await manager.prune();
+
+		// Both workflows' current versions should still exist even though they are old
+		expect(await repo.count({ where: { versionId: activeWorkflow.versionId } })).toBe(1);
+		expect(await repo.count({ where: { versionId: inactiveWorkflow.versionId } })).toBe(1);
+
+		// Other old versions should be deleted
+		const otherVersionIds = [
+			...activeWorkflowVersions.slice(1).map((i) => i.versionId),
+			...inactiveWorkflowVersions.slice(1).map((i) => i.versionId),
+		];
+		expect(await repo.count({ where: { versionId: In(otherVersionIds) } })).toBe(0);
+	});
+
+	test('should not prune current or active versions when they differ', async () => {
+		globalConfig.workflowHistory.pruneTime = 24;
+
+		const workflow = await createActiveWorkflow();
+
+		// Create old history versions
+		const workflowVersions = await createManyWorkflowHistoryItems(
+			workflow.id,
+			5,
+			DateTime.now().minus({ days: 2 }).toJSDate(),
+		);
+
+		// Set current version to one version and active version to a different version
+		workflow.versionId = workflowVersions[0].versionId;
+		workflow.activeVersionId = workflowVersions[1].versionId;
+
+		const workflowRepo = Container.get(WorkflowRepository);
+		await workflowRepo.save(workflow);
+
+		await manager.prune();
+
+		// Both current and active versions should still exist even though they are old
+		expect(await repo.count({ where: { versionId: workflow.versionId } })).toBe(1);
+		expect(await repo.count({ where: { versionId: workflow.activeVersionId } })).toBe(1);
+
+		// Other old versions should be deleted
+		const otherVersionIds = workflowVersions.slice(2).map((i) => i.versionId);
+		expect(await repo.count({ where: { versionId: In(otherVersionIds) } })).toBe(0);
+	});
+
+	test('should not prune named versions when license feature is enabled', async () => {
+		globalConfig.workflowHistory.pruneTime = 24;
+		license.isLicensed.mockImplementation((feature: string) => feature === 'feat:namedVersions');
+
+		const workflow = await createWorkflow();
+		const oldDate = DateTime.now().minus({ days: 2 }).toJSDate();
+
+		const versions = await createManyWorkflowHistoryItems(workflow.id, 5, oldDate);
+
+		await repo.update({ versionId: versions[0].versionId }, { name: 'Named Version 1' });
+		await repo.update(
+			{ versionId: versions[1].versionId },
+			{ name: 'Named Version 2', description: 'Version with description' },
+		);
+		await repo.update(
+			{ versionId: versions[2].versionId },
+			{ name: 'Named Version 3', description: 'Also has description' },
+		);
+		// versions[3] and versions[4] remain unnamed
+
+		await manager.prune();
+
+		expect(license.isLicensed).toHaveBeenCalledWith('feat:namedVersions');
+
+		// Named versions should be preserved
+		expect(await repo.count({ where: { versionId: versions[0].versionId } })).toBe(1);
+		expect(await repo.count({ where: { versionId: versions[1].versionId } })).toBe(1);
+		expect(await repo.count({ where: { versionId: versions[2].versionId } })).toBe(1);
+
+		// Unnamed versions should be deleted
+		expect(await repo.count({ where: { versionId: versions[3].versionId } })).toBe(0);
+		expect(await repo.count({ where: { versionId: versions[4].versionId } })).toBe(0);
+	});
+
+	test('should prune named versions when license feature is disabled', async () => {
+		globalConfig.workflowHistory.pruneTime = 24;
+		license.isLicensed.mockReturnValue(false);
+
+		const workflow = await createWorkflow();
+		const oldDate = DateTime.now().minus({ days: 2 }).toJSDate();
+
+		const versions = await createManyWorkflowHistoryItems(workflow.id, 3, oldDate);
+
+		// Set names on versions
+		await repo.update({ versionId: versions[0].versionId }, { name: 'Named Version 1' });
+		await repo.update({ versionId: versions[1].versionId }, { name: 'Named Version 2' });
+		await repo.update(
+			{ versionId: versions[2].versionId },
+			{ name: 'Named Version 3', description: 'Version with description' },
+		);
+
+		await manager.prune();
+
+		// All versions should be deleted
+		expect(await repo.count({ where: { versionId: In(versions.map((v) => v.versionId)) } })).toBe(
+			0,
+		);
+	});
+
+	const createWorkflowHistory = async (ageInDays = 2) => {
+		const workflow = await createWorkflow();
+		const time = DateTime.now().minus({ days: ageInDays }).toJSDate();
+		return await createManyWorkflowHistoryItems(workflow.id, 10, time);
+	};
+
+	const pruneAndAssertCount = async (finalCount = 10, initialCount = 10) => {
+		expect(await repo.count()).toBe(initialCount);
+
+		const deleteSpy = jest.spyOn(repo, 'deleteEarlierThanExceptCurrentAndActive');
+		await manager.prune();
+
+		if (initialCount === finalCount) {
+			expect(deleteSpy).not.toBeCalled();
+		} else {
+			expect(deleteSpy).toBeCalled();
+		}
+		deleteSpy.mockRestore();
+
+		expect(await repo.count()).toBe(finalCount);
+	};
+});