mirror of
https://github.com/immich-app/immich.git
synced 2026-02-11 19:38:54 +03:00
678 lines
22 KiB
TypeScript
678 lines
22 KiB
TypeScript
import { createHash } from 'node:crypto';
|
|
import { Readable } from 'node:stream';
|
|
import { text } from 'node:stream/consumers';
|
|
import { AssetStatus, IntegrityReportType, JobName, JobStatus } from 'src/enum';
|
|
import { IntegrityService } from 'src/services/integrity.service';
|
|
import { newTestService, ServiceMocks } from 'test/utils';
|
|
|
|
describe(IntegrityService.name, () => {
|
|
let sut: IntegrityService;
|
|
let mocks: ServiceMocks;
|
|
|
|
beforeEach(() => {
|
|
({ sut, mocks } = newTestService(IntegrityService));
|
|
});
|
|
|
|
it('should work', () => {
|
|
expect(sut).toBeDefined();
|
|
});
|
|
|
|
describe('getIntegrityReportSummary', () => {
|
|
it('gets summary', async () => {
|
|
await sut.getIntegrityReportSummary();
|
|
expect(mocks.integrityReport.getIntegrityReportSummary).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('getIntegrityReport', () => {
|
|
it('gets report', async () => {
|
|
mocks.integrityReport.getIntegrityReports.mockResolvedValue({
|
|
items: [],
|
|
nextCursor: undefined,
|
|
});
|
|
|
|
await expect(sut.getIntegrityReport({ type: IntegrityReportType.ChecksumFail })).resolves.toEqual({
|
|
items: [],
|
|
nextCursor: undefined,
|
|
});
|
|
|
|
expect(mocks.integrityReport.getIntegrityReports).toHaveBeenCalledWith(
|
|
{ cursor: undefined, limit: 100 },
|
|
IntegrityReportType.ChecksumFail,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('getIntegrityReportCsv', () => {
|
|
it('gets report as csv', async () => {
|
|
mocks.integrityReport.streamIntegrityReports.mockReturnValue(
|
|
(function* () {
|
|
yield {
|
|
id: 'id',
|
|
createdAt: new Date(0),
|
|
path: '/path/to/file',
|
|
type: IntegrityReportType.ChecksumFail,
|
|
assetId: null,
|
|
fileAssetId: null,
|
|
};
|
|
})() as never,
|
|
);
|
|
|
|
await expect(text(sut.getIntegrityReportCsv(IntegrityReportType.ChecksumFail))).resolves.toMatchInlineSnapshot(`
|
|
"id,type,assetId,fileAssetId,path
|
|
id,checksum_mismatch,null,null,"/path/to/file"
|
|
"
|
|
`);
|
|
|
|
expect(mocks.integrityReport.streamIntegrityReports).toHaveBeenCalledWith(IntegrityReportType.ChecksumFail);
|
|
});
|
|
});
|
|
|
|
describe('getIntegrityReportFile', () => {
|
|
it('gets report file', async () => {
|
|
mocks.integrityReport.getById.mockResolvedValue({
|
|
id: 'id',
|
|
createdAt: new Date(0),
|
|
path: '/path/to/file',
|
|
type: IntegrityReportType.ChecksumFail,
|
|
assetId: null,
|
|
fileAssetId: null,
|
|
});
|
|
|
|
await expect(sut.getIntegrityReportFile('id')).resolves.toEqual({
|
|
path: '/path/to/file',
|
|
fileName: 'file',
|
|
contentType: 'application/octet-stream',
|
|
cacheControl: 'private_without_cache',
|
|
});
|
|
|
|
expect(mocks.integrityReport.getById).toHaveBeenCalledWith('id');
|
|
});
|
|
});
|
|
|
|
describe('deleteIntegrityReport', () => {
|
|
it('deletes asset if one is present', async () => {
|
|
mocks.integrityReport.getById.mockResolvedValue({
|
|
id: 'id',
|
|
createdAt: new Date(0),
|
|
path: '/path/to/file',
|
|
type: IntegrityReportType.ChecksumFail,
|
|
assetId: 'assetId',
|
|
fileAssetId: null,
|
|
});
|
|
|
|
await sut.deleteIntegrityReport(
|
|
{
|
|
user: {
|
|
id: 'userId',
|
|
},
|
|
} as never,
|
|
'id',
|
|
);
|
|
|
|
expect(mocks.asset.updateAll).toHaveBeenCalledWith(['assetId'], {
|
|
deletedAt: expect.any(Date),
|
|
status: AssetStatus.Trashed,
|
|
});
|
|
|
|
expect(mocks.event.emit).toHaveBeenCalledWith('AssetTrashAll', {
|
|
assetIds: ['assetId'],
|
|
userId: 'userId',
|
|
});
|
|
|
|
expect(mocks.integrityReport.deleteById).toHaveBeenCalledWith('id');
|
|
});
|
|
|
|
it('deletes file asset if one is present', async () => {
|
|
mocks.integrityReport.getById.mockResolvedValue({
|
|
id: 'id',
|
|
createdAt: new Date(0),
|
|
path: '/path/to/file',
|
|
type: IntegrityReportType.ChecksumFail,
|
|
assetId: null,
|
|
fileAssetId: 'fileAssetId',
|
|
});
|
|
|
|
await sut.deleteIntegrityReport(
|
|
{
|
|
user: {
|
|
id: 'userId',
|
|
},
|
|
} as never,
|
|
'id',
|
|
);
|
|
|
|
expect(mocks.asset.deleteFiles).toHaveBeenCalledWith([{ id: 'fileAssetId' }]);
|
|
});
|
|
|
|
it('deletes untracked file', async () => {
|
|
mocks.integrityReport.getById.mockResolvedValue({
|
|
id: 'id',
|
|
createdAt: new Date(0),
|
|
path: '/path/to/file',
|
|
type: IntegrityReportType.ChecksumFail,
|
|
assetId: null,
|
|
fileAssetId: null,
|
|
});
|
|
|
|
await sut.deleteIntegrityReport(
|
|
{
|
|
user: {
|
|
id: 'userId',
|
|
},
|
|
} as never,
|
|
'id',
|
|
);
|
|
|
|
expect(mocks.storage.unlink).toHaveBeenCalledWith('/path/to/file');
|
|
expect(mocks.integrityReport.deleteById).toHaveBeenCalledWith('id');
|
|
});
|
|
});
|
|
|
|
describe('handleUntrackedFilesQueueAll', () => {
|
|
beforeEach(() => {
|
|
mocks.integrityReport.streamIntegrityReportsWithAssetChecksum.mockReturnValue((function* () {})() as never);
|
|
});
|
|
|
|
it('queues jobs for all detected files', async () => {
|
|
mocks.storage.walk.mockReturnValueOnce(
|
|
(function* () {
|
|
yield ['/path/to/file', '/path/to/file2'];
|
|
yield ['/path/to/batch2'];
|
|
})() as never,
|
|
);
|
|
|
|
mocks.storage.walk.mockReturnValueOnce(
|
|
(function* () {
|
|
yield ['/path/to/file3', '/path/to/file4'];
|
|
yield ['/path/to/batch4'];
|
|
})() as never,
|
|
);
|
|
|
|
await sut.handleUntrackedFilesQueueAll({ refreshOnly: false });
|
|
|
|
expect(mocks.job.queue).toBeCalledTimes(4);
|
|
expect(mocks.job.queue).toBeCalledWith({
|
|
name: JobName.IntegrityUntrackedFiles,
|
|
data: {
|
|
type: 'asset',
|
|
paths: expect.arrayContaining(['/path/to/file']),
|
|
},
|
|
});
|
|
|
|
expect(mocks.job.queue).toBeCalledWith({
|
|
name: JobName.IntegrityUntrackedFiles,
|
|
data: {
|
|
type: 'asset_file',
|
|
paths: expect.arrayContaining(['/path/to/file3']),
|
|
},
|
|
});
|
|
});
|
|
|
|
it('queues jobs to refresh reports', async () => {
|
|
mocks.integrityReport.streamIntegrityReportsWithAssetChecksum.mockReturnValue(
|
|
(function* () {
|
|
yield 'mockReport';
|
|
})() as never,
|
|
);
|
|
|
|
await sut.handleUntrackedFilesQueueAll({ refreshOnly: false });
|
|
|
|
expect(mocks.job.queue).toBeCalledTimes(1);
|
|
expect(mocks.job.queue).toBeCalledWith({
|
|
name: JobName.IntegrityUntrackedFilesRefresh,
|
|
data: {
|
|
items: expect.arrayContaining(['mockReport']),
|
|
},
|
|
});
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
await expect(sut.handleUntrackedFilesQueueAll({ refreshOnly: false })).resolves.toBe(JobStatus.Success);
|
|
});
|
|
});
|
|
|
|
describe('handleUntrackedFiles', () => {
|
|
it('should detect untracked asset files', async () => {
|
|
mocks.integrityReport.getAssetPathsByPaths.mockResolvedValue([
|
|
{ originalPath: '/path/to/file1', encodedVideoPath: null },
|
|
]);
|
|
|
|
await sut.handleUntrackedFiles({
|
|
type: 'asset',
|
|
paths: ['/path/to/file1', '/path/to/untracked'],
|
|
});
|
|
|
|
expect(mocks.integrityReport.getAssetPathsByPaths).toHaveBeenCalledWith(['/path/to/file1', '/path/to/untracked']);
|
|
expect(mocks.integrityReport.create).toHaveBeenCalledWith([
|
|
{ type: IntegrityReportType.UntrackedFile, path: '/path/to/untracked' },
|
|
]);
|
|
});
|
|
|
|
it('should not create reports when no untracked files found for assets', async () => {
|
|
mocks.integrityReport.getAssetPathsByPaths.mockResolvedValue([
|
|
{ originalPath: '/path/to/file1', encodedVideoPath: '/path/to/encoded' },
|
|
]);
|
|
|
|
await sut.handleUntrackedFiles({
|
|
type: 'asset',
|
|
paths: ['/path/to/file1', '/path/to/encoded'],
|
|
});
|
|
|
|
expect(mocks.integrityReport.create).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should detect untracked asset_file files', async () => {
|
|
mocks.integrityReport.getAssetFilePathsByPaths.mockResolvedValue([{ path: '/path/to/thumb1' }]);
|
|
|
|
await sut.handleUntrackedFiles({
|
|
type: 'asset_file',
|
|
paths: ['/path/to/thumb1', '/path/to/untracked_thumb'],
|
|
});
|
|
|
|
expect(mocks.integrityReport.create).toHaveBeenCalledWith([
|
|
{ type: IntegrityReportType.UntrackedFile, path: '/path/to/untracked_thumb' },
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe('handleUntrackedRefresh', () => {
|
|
it('should delete reports for files that no longer exist', async () => {
|
|
mocks.storage.stat
|
|
.mockRejectedValueOnce(new Error('ENOENT'))
|
|
.mockResolvedValueOnce({} as never)
|
|
.mockRejectedValueOnce(new Error('ENOENT'));
|
|
|
|
await sut.handleUntrackedRefresh({
|
|
items: [
|
|
{ reportId: 'report1', path: '/path/to/missing1' },
|
|
{ reportId: 'report2', path: '/path/to/existing' },
|
|
{ reportId: 'report3', path: '/path/to/missing2' },
|
|
],
|
|
});
|
|
|
|
expect(mocks.integrityReport.deleteByIds).toHaveBeenCalledWith(['report1', 'report3']);
|
|
});
|
|
|
|
it('should not delete reports for files that still exist', async () => {
|
|
mocks.storage.stat.mockResolvedValue({} as never);
|
|
|
|
await sut.handleUntrackedRefresh({
|
|
items: [{ reportId: 'report1', path: '/path/to/existing' }],
|
|
});
|
|
|
|
expect(mocks.integrityReport.deleteByIds).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
await expect(sut.handleUntrackedRefresh({ items: [] })).resolves.toBe(JobStatus.Success);
|
|
});
|
|
});
|
|
|
|
describe('handleMissingFilesQueueAll', () => {
|
|
beforeEach(() => {
|
|
mocks.integrityReport.streamAssetPaths.mockReturnValue((function* () {})() as never);
|
|
});
|
|
|
|
it('should queue jobs', async () => {
|
|
mocks.integrityReport.streamAssetPaths.mockReturnValue(
|
|
(function* () {
|
|
yield { path: '/path/to/file1', assetId: 'asset1', fileAssetId: null };
|
|
yield { path: '/path/to/file2', assetId: 'asset2', fileAssetId: null };
|
|
})() as never,
|
|
);
|
|
|
|
await sut.handleMissingFilesQueueAll({ refreshOnly: false });
|
|
|
|
expect(mocks.integrityReport.streamAssetPaths).toHaveBeenCalled();
|
|
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.IntegrityMissingFiles,
|
|
data: {
|
|
items: expect.arrayContaining([{ path: '/path/to/file1', assetId: 'asset1', fileAssetId: null }]),
|
|
},
|
|
});
|
|
|
|
expect(mocks.job.queue).not.toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
name: JobName.IntegrityMissingFilesRefresh,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should queue refresh jobs when refreshOnly is set', async () => {
|
|
mocks.integrityReport.streamIntegrityReportsWithAssetChecksum.mockReturnValue(
|
|
(function* () {
|
|
yield { reportId: 'report1', path: '/path/to/file1' };
|
|
yield { reportId: 'report2', path: '/path/to/file2' };
|
|
})() as never,
|
|
);
|
|
|
|
await sut.handleMissingFilesQueueAll({ refreshOnly: true });
|
|
|
|
expect(mocks.integrityReport.streamIntegrityReportsWithAssetChecksum).toHaveBeenCalledWith(
|
|
IntegrityReportType.MissingFile,
|
|
);
|
|
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.IntegrityMissingFilesRefresh,
|
|
data: {
|
|
items: expect.arrayContaining([{ reportId: 'report1', path: '/path/to/file1' }]),
|
|
},
|
|
});
|
|
|
|
expect(mocks.job.queue).not.toHaveBeenCalledWith(
|
|
expect.objectContaining({
|
|
name: JobName.IntegrityMissingFiles,
|
|
}),
|
|
);
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
await expect(sut.handleMissingFilesQueueAll()).resolves.toBe(JobStatus.Success);
|
|
});
|
|
});
|
|
|
|
describe('handleMissingFiles', () => {
|
|
it('should detect missing files and remove outdated reports', async () => {
|
|
mocks.storage.stat
|
|
.mockResolvedValueOnce({} as never)
|
|
.mockRejectedValueOnce(new Error('ENOENT'))
|
|
.mockResolvedValueOnce({} as never);
|
|
|
|
await sut.handleMissingFiles({
|
|
items: [
|
|
{ path: '/path/to/existing', assetId: 'asset1', fileAssetId: null, reportId: null },
|
|
{ path: '/path/to/missing', assetId: 'asset2', fileAssetId: null, reportId: null },
|
|
{ path: '/path/to/restored', assetId: 'asset3', fileAssetId: null, reportId: 'report2' },
|
|
],
|
|
});
|
|
|
|
expect(mocks.integrityReport.deleteByIds).toHaveBeenCalledWith(['report2']);
|
|
expect(mocks.integrityReport.create).toHaveBeenCalledWith([
|
|
{ type: IntegrityReportType.MissingFile, path: '/path/to/missing', assetId: 'asset2', fileAssetId: null },
|
|
]);
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
await expect(sut.handleMissingFiles({ items: [] })).resolves.toBe(JobStatus.Success);
|
|
});
|
|
});
|
|
|
|
describe('handleMissingRefresh', () => {
|
|
it('should remove outdated reports', async () => {
|
|
mocks.storage.stat
|
|
.mockResolvedValueOnce({} as never)
|
|
.mockRejectedValueOnce(new Error('ENOENT'))
|
|
.mockResolvedValueOnce({} as never);
|
|
|
|
await sut.handleMissingRefresh({
|
|
items: [
|
|
{ path: '/path/to/existing', reportId: null },
|
|
{ path: '/path/to/missing', reportId: null },
|
|
{ path: '/path/to/restored', reportId: 'report2' },
|
|
],
|
|
});
|
|
|
|
expect(mocks.integrityReport.deleteByIds).toHaveBeenCalledWith(['report2']);
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
await expect(sut.handleMissingFiles({ items: [] })).resolves.toBe(JobStatus.Success);
|
|
});
|
|
});
|
|
|
|
describe('handleChecksumFiles', () => {
|
|
beforeEach(() => {
|
|
mocks.integrityReport.streamIntegrityReportsWithAssetChecksum.mockReturnValue((function* () {})() as never);
|
|
mocks.integrityReport.streamAssetChecksums.mockReturnValue((function* () {})() as never);
|
|
mocks.integrityReport.getAssetCount.mockResolvedValue({ count: 1000 });
|
|
mocks.systemMetadata.get.mockResolvedValue(null);
|
|
});
|
|
|
|
it('should queue refresh jobs when refreshOnly', async () => {
|
|
mocks.integrityReport.streamIntegrityReportsWithAssetChecksum.mockReturnValue(
|
|
(function* () {
|
|
yield { reportId: 'report1', path: '/path/to/file1', checksum: Buffer.from('abc123', 'hex') };
|
|
})() as never,
|
|
);
|
|
|
|
await sut.handleChecksumFiles({ refreshOnly: true });
|
|
|
|
expect(mocks.integrityReport.streamIntegrityReportsWithAssetChecksum).toHaveBeenCalledWith(
|
|
IntegrityReportType.ChecksumFail,
|
|
);
|
|
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.IntegrityChecksumFilesRefresh,
|
|
data: {
|
|
items: [{ reportId: 'report1', path: '/path/to/file1', checksum: 'abc123' }],
|
|
},
|
|
});
|
|
});
|
|
|
|
it('should create report for checksum mismatch and delete when fixed', async () => {
|
|
const fileContent = Buffer.from('test content');
|
|
|
|
mocks.integrityReport.streamAssetChecksums.mockReturnValue(
|
|
(function* () {
|
|
yield {
|
|
originalPath: '/path/to/mismatch',
|
|
checksum: 'mismatched checksum',
|
|
createdAt: new Date(),
|
|
assetId: 'asset1',
|
|
reportId: null,
|
|
};
|
|
yield {
|
|
originalPath: '/path/to/fixed',
|
|
checksum: createHash('sha1').update(fileContent).digest(),
|
|
createdAt: new Date(),
|
|
assetId: 'asset2',
|
|
reportId: 'report1',
|
|
};
|
|
})() as never,
|
|
);
|
|
|
|
mocks.storage.createPlainReadStream.mockImplementation(() => Readable.from(fileContent));
|
|
|
|
await sut.handleChecksumFiles({ refreshOnly: false });
|
|
|
|
expect(mocks.integrityReport.create).toHaveBeenCalledWith({
|
|
path: '/path/to/mismatch',
|
|
type: IntegrityReportType.ChecksumFail,
|
|
assetId: 'asset1',
|
|
});
|
|
|
|
expect(mocks.integrityReport.deleteById).toHaveBeenCalledWith('report1');
|
|
});
|
|
|
|
it('should skip missing files', async () => {
|
|
mocks.integrityReport.streamAssetChecksums.mockReturnValue(
|
|
(function* () {
|
|
yield {
|
|
originalPath: '/path/to/missing',
|
|
checksum: Buffer.from('abc', 'hex'),
|
|
createdAt: new Date(),
|
|
assetId: 'asset1',
|
|
reportId: 'report1',
|
|
};
|
|
})() as never,
|
|
);
|
|
|
|
const error = new Error('ENOENT') as NodeJS.ErrnoException;
|
|
error.code = 'ENOENT';
|
|
mocks.storage.createPlainReadStream.mockImplementation(() => {
|
|
throw error;
|
|
});
|
|
|
|
await sut.handleChecksumFiles({ refreshOnly: false });
|
|
|
|
expect(mocks.integrityReport.deleteById).toHaveBeenCalledWith('report1');
|
|
expect(mocks.integrityReport.create).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
await expect(sut.handleChecksumFiles({ refreshOnly: false })).resolves.toBe(JobStatus.Success);
|
|
});
|
|
});
|
|
|
|
describe('handleChecksumRefresh', () => {
|
|
it('should delete reports when checksum now matches, file is missing, or asset is now missing', async () => {
|
|
const fileContent = Buffer.from('test content');
|
|
const correctChecksum = createHash('sha1').update(fileContent).digest().toString('hex');
|
|
|
|
const error = new Error('ENOENT') as NodeJS.ErrnoException;
|
|
error.code = 'ENOENT';
|
|
|
|
mocks.storage.createPlainReadStream
|
|
.mockImplementationOnce(() => Readable.from(fileContent))
|
|
.mockImplementationOnce(() => {
|
|
throw error;
|
|
})
|
|
.mockImplementationOnce(() => Readable.from(fileContent))
|
|
.mockImplementationOnce(() => Readable.from(fileContent));
|
|
|
|
await sut.handleChecksumRefresh({
|
|
items: [
|
|
{ reportId: 'report1', path: '/path/to/fixed', checksum: correctChecksum },
|
|
{ reportId: 'report2', path: '/path/to/missing', checksum: 'abc123' },
|
|
{ reportId: 'report3', path: '/path/to/bad', checksum: 'wrongchecksum' },
|
|
{ reportId: 'report4', path: '/path/to/missing-asset', checksum: null },
|
|
],
|
|
});
|
|
|
|
expect(mocks.integrityReport.deleteByIds).toHaveBeenCalledWith(['report1', 'report2', 'report4']);
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
await expect(sut.handleChecksumRefresh({ items: [] })).resolves.toBe(JobStatus.Success);
|
|
});
|
|
});
|
|
|
|
describe('handleDeleteAllIntegrityReports', () => {
|
|
beforeEach(() => {
|
|
mocks.integrityReport.streamIntegrityReportsByProperty.mockReturnValue((function* () {})() as never);
|
|
});
|
|
|
|
it('should queue delete jobs for checksum fail reports', async () => {
|
|
mocks.integrityReport.streamIntegrityReportsByProperty.mockReturnValue(
|
|
(function* () {
|
|
yield { id: 'report1', assetId: 'asset1', path: '/path/to/file1' };
|
|
})() as never,
|
|
);
|
|
|
|
await sut.handleDeleteAllIntegrityReports({ type: IntegrityReportType.ChecksumFail });
|
|
|
|
expect(mocks.integrityReport.streamIntegrityReportsByProperty).toHaveBeenCalledWith(
|
|
'assetId',
|
|
IntegrityReportType.ChecksumFail,
|
|
);
|
|
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.IntegrityDeleteReports,
|
|
data: {
|
|
reports: [{ id: 'report1', assetId: 'asset1', path: '/path/to/file1' }],
|
|
},
|
|
});
|
|
});
|
|
|
|
it('should queue delete jobs for missing file reports by assetId and fileAssetId', async () => {
|
|
mocks.integrityReport.streamIntegrityReportsByProperty
|
|
.mockReturnValueOnce(
|
|
(function* () {
|
|
yield { id: 'report1', assetId: 'asset1', path: '/path/to/file1' };
|
|
})() as never,
|
|
)
|
|
.mockReturnValueOnce(
|
|
(function* () {
|
|
yield { id: 'report2', fileAssetId: 'fileAsset1', path: '/path/to/file2' };
|
|
})() as never,
|
|
);
|
|
|
|
await sut.handleDeleteAllIntegrityReports({ type: IntegrityReportType.MissingFile });
|
|
|
|
expect(mocks.integrityReport.streamIntegrityReportsByProperty).toHaveBeenCalledWith(
|
|
'assetId',
|
|
IntegrityReportType.MissingFile,
|
|
);
|
|
|
|
expect(mocks.integrityReport.streamIntegrityReportsByProperty).toHaveBeenCalledWith(
|
|
'fileAssetId',
|
|
IntegrityReportType.MissingFile,
|
|
);
|
|
|
|
expect(mocks.job.queue).toHaveBeenCalledTimes(2);
|
|
});
|
|
|
|
it('should queue delete jobs for untracked file reports', async () => {
|
|
mocks.integrityReport.streamIntegrityReportsByProperty.mockReturnValue(
|
|
(function* () {
|
|
yield { id: 'report1', path: '/path/to/untracked' };
|
|
})() as never,
|
|
);
|
|
|
|
await sut.handleDeleteAllIntegrityReports({ type: IntegrityReportType.UntrackedFile });
|
|
|
|
expect(mocks.integrityReport.streamIntegrityReportsByProperty).toHaveBeenCalledWith(
|
|
undefined,
|
|
IntegrityReportType.UntrackedFile,
|
|
);
|
|
|
|
expect(mocks.job.queue).toHaveBeenCalledWith({
|
|
name: JobName.IntegrityDeleteReports,
|
|
data: {
|
|
reports: [{ id: 'report1', path: '/path/to/untracked' }],
|
|
},
|
|
});
|
|
});
|
|
|
|
it('should query all property types when no type specified', async () => {
|
|
await sut.handleDeleteAllIntegrityReports({});
|
|
|
|
expect(mocks.integrityReport.streamIntegrityReportsByProperty).toHaveBeenCalledWith(undefined, undefined);
|
|
expect(mocks.integrityReport.streamIntegrityReportsByProperty).toHaveBeenCalledWith('assetId', undefined);
|
|
expect(mocks.integrityReport.streamIntegrityReportsByProperty).toHaveBeenCalledWith('fileAssetId', undefined);
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
await expect(sut.handleDeleteAllIntegrityReports({})).resolves.toBe(JobStatus.Success);
|
|
});
|
|
});
|
|
|
|
describe('handleDeleteIntegrityReports', () => {
|
|
it('should handle all report types', async () => {
|
|
mocks.storage.unlink.mockResolvedValue(void 0);
|
|
|
|
await sut.handleDeleteIntegrityReports({
|
|
reports: [
|
|
{ id: 'report1', assetId: 'asset1', fileAssetId: null, path: '/path/to/file1' },
|
|
{ id: 'report2', assetId: 'asset2', fileAssetId: null, path: '/path/to/file2' },
|
|
{ id: 'report3', assetId: null, fileAssetId: 'fileAsset1', path: '/path/to/file3' },
|
|
{ id: 'report4', assetId: null, fileAssetId: null, path: '/path/to/untracked' },
|
|
],
|
|
});
|
|
|
|
expect(mocks.asset.updateAll).toHaveBeenCalledWith(['asset1', 'asset2'], {
|
|
deletedAt: expect.any(Date),
|
|
status: AssetStatus.Trashed,
|
|
});
|
|
|
|
expect(mocks.event.emit).toHaveBeenCalledWith('AssetTrashAll', {
|
|
assetIds: ['asset1', 'asset2'],
|
|
userId: '',
|
|
});
|
|
|
|
expect(mocks.integrityReport.deleteByIds).toHaveBeenCalledWith(['report1', 'report2']);
|
|
|
|
expect(mocks.asset.deleteFiles).toHaveBeenCalledWith([{ id: 'fileAsset1' }]);
|
|
|
|
expect(mocks.storage.unlink).toHaveBeenCalledWith('/path/to/untracked');
|
|
expect(mocks.integrityReport.deleteByIds).toHaveBeenCalledWith(['report4']);
|
|
});
|
|
|
|
it('should succeed', async () => {
|
|
await expect(sut.handleDeleteIntegrityReports({ reports: [] })).resolves.toBe(JobStatus.Success);
|
|
});
|
|
});
|
|
});
|