mirror of
https://github.com/laurent22/joplin.git
synced 2024-12-21 09:38:01 +02:00
195 lines
7.8 KiB
TypeScript
195 lines
7.8 KiB
TypeScript
import { supportDir, setupDatabaseAndSynchronizer, switchClient, simulateReadOnlyShareEnv, expectThrow, createTempFile, msleep } from '../testing/test-utils';
|
|
import Folder from '../models/Folder';
|
|
import Note from '../models/Note';
|
|
import Resource from '../models/Resource';
|
|
import shim from '../shim';
|
|
import { ErrorCode } from '../errors';
|
|
import { remove, pathExists } from 'fs-extra';
|
|
import { ResourceEntity, ResourceOcrStatus } from '../services/database/types';
|
|
|
|
const testImagePath = `${supportDir}/photo.jpg`;
|
|
|
|
const setupFolderNoteResourceReadOnly = async (shareId: string) => {
|
|
const cleanup = simulateReadOnlyShareEnv(shareId);
|
|
|
|
let folder = await Folder.save({ });
|
|
let note = await Note.save({ parent_id: folder.id });
|
|
await shim.attachFileToNote(note, testImagePath);
|
|
let resource = (await Resource.all())[0];
|
|
|
|
folder = await Folder.save({ id: folder.id, share_id: shareId });
|
|
note = await Note.save({ id: note.id, share_id: shareId });
|
|
resource = await Resource.save({ id: resource.id, share_id: shareId });
|
|
|
|
resource = await Resource.load(resource.id); // reload to get all properties
|
|
|
|
return { cleanup, folder, note, resource };
|
|
};
|
|
|
|
describe('models/Resource', () => {
|
|
|
|
beforeEach(async () => {
|
|
await setupDatabaseAndSynchronizer(1);
|
|
await switchClient(1);
|
|
});
|
|
|
|
it('should have a "done" fetch_status when created locally', (async () => {
|
|
const folder1 = await Folder.save({ title: 'folder1' });
|
|
const note1 = await Note.save({ title: 'ma note', parent_id: folder1.id });
|
|
await shim.attachFileToNote(note1, testImagePath);
|
|
const resource1 = (await Resource.all())[0];
|
|
const ls = await Resource.localState(resource1);
|
|
expect(ls.fetch_status).toBe(Resource.FETCH_STATUS_DONE);
|
|
}));
|
|
|
|
it('should have a default local state', (async () => {
|
|
const folder1 = await Folder.save({ title: 'folder1' });
|
|
const note1 = await Note.save({ title: 'ma note', parent_id: folder1.id });
|
|
await shim.attachFileToNote(note1, testImagePath);
|
|
const resource1 = (await Resource.all())[0];
|
|
const ls = await Resource.localState(resource1);
|
|
expect(!ls.id).toBe(true);
|
|
expect(ls.resource_id).toBe(resource1.id);
|
|
expect(ls.fetch_status).toBe(Resource.FETCH_STATUS_DONE);
|
|
}));
|
|
|
|
it('should save and delete local state', (async () => {
|
|
const folder1 = await Folder.save({ title: 'folder1' });
|
|
const note1 = await Note.save({ title: 'ma note', parent_id: folder1.id });
|
|
await shim.attachFileToNote(note1, testImagePath);
|
|
const resource1 = (await Resource.all())[0];
|
|
await Resource.setLocalState(resource1, { fetch_status: Resource.FETCH_STATUS_IDLE });
|
|
|
|
let ls = await Resource.localState(resource1);
|
|
expect(!!ls.id).toBe(true);
|
|
expect(ls.fetch_status).toBe(Resource.FETCH_STATUS_IDLE);
|
|
|
|
await Resource.delete(resource1.id);
|
|
ls = await Resource.localState(resource1);
|
|
expect(!ls.id).toBe(true);
|
|
}));
|
|
|
|
it('should resize the resource if the image is below the required dimensions', (async () => {
|
|
const folder1 = await Folder.save({ title: 'folder1' });
|
|
const note1 = await Note.save({ title: 'ma note', parent_id: folder1.id });
|
|
const previousMax = Resource.IMAGE_MAX_DIMENSION;
|
|
Resource.IMAGE_MAX_DIMENSION = 5;
|
|
await shim.attachFileToNote(note1, testImagePath);
|
|
Resource.IMAGE_MAX_DIMENSION = previousMax;
|
|
const resource1 = (await Resource.all())[0];
|
|
|
|
const originalStat = await shim.fsDriver().stat(testImagePath);
|
|
const newStat = await shim.fsDriver().stat(Resource.fullPath(resource1));
|
|
|
|
expect(newStat.size < originalStat.size).toBe(true);
|
|
}));
|
|
|
|
it('should not resize the resource if the image is below the required dimensions', (async () => {
|
|
const folder1 = await Folder.save({ title: 'folder1' });
|
|
const note1 = await Note.save({ title: 'ma note', parent_id: folder1.id });
|
|
await shim.attachFileToNote(note1, testImagePath);
|
|
const resource1 = (await Resource.all())[0];
|
|
|
|
const originalStat = await shim.fsDriver().stat(testImagePath);
|
|
const newStat = await shim.fsDriver().stat(Resource.fullPath(resource1));
|
|
|
|
expect(originalStat.size).toBe(newStat.size);
|
|
}));
|
|
|
|
it('should set the blob_updated_time property if the blob is updated', (async () => {
|
|
const note = await Note.save({});
|
|
await shim.attachFileToNote(note, testImagePath);
|
|
|
|
const resourceA: ResourceEntity = (await Resource.all())[0];
|
|
expect(resourceA.updated_time).toBe(resourceA.blob_updated_time);
|
|
|
|
await msleep(1);
|
|
|
|
await Resource.updateResourceBlobContent(resourceA.id, testImagePath);
|
|
|
|
const resourceB: ResourceEntity = (await Resource.all())[0];
|
|
expect(resourceB.updated_time).toBeGreaterThan(resourceA.updated_time);
|
|
expect(resourceB.blob_updated_time).toBeGreaterThan(resourceA.blob_updated_time);
|
|
}));
|
|
|
|
it('should NOT set the blob_updated_time property if the blob is NOT updated', (async () => {
|
|
const note = await Note.save({});
|
|
await shim.attachFileToNote(note, testImagePath);
|
|
|
|
const resourceA: ResourceEntity = (await Resource.all())[0];
|
|
|
|
await msleep(1);
|
|
|
|
// We only update the resource metadata - so the blob timestamp should
|
|
// not change
|
|
await Resource.save({ id: resourceA.id, title: 'new title' });
|
|
|
|
const resourceB: ResourceEntity = (await Resource.all())[0];
|
|
expect(resourceB.updated_time).toBeGreaterThan(resourceA.updated_time);
|
|
expect(resourceB.blob_updated_time).toBe(resourceA.blob_updated_time);
|
|
}));
|
|
|
|
it('should not allow modifying a read-only resource', async () => {
|
|
const { cleanup, resource } = await setupFolderNoteResourceReadOnly('123456789');
|
|
await expectThrow(async () => Resource.save({ id: resource.id, share_id: '123456789', title: 'cannot do this!' }), ErrorCode.IsReadOnly);
|
|
cleanup();
|
|
});
|
|
|
|
it('should not allow modifying a read-only resource content', async () => {
|
|
const { cleanup, resource } = await setupFolderNoteResourceReadOnly('123456789');
|
|
const tempFilePath = await createTempFile('something');
|
|
await expectThrow(async () => Resource.updateResourceBlobContent(resource.id, tempFilePath), ErrorCode.IsReadOnly);
|
|
await remove(tempFilePath);
|
|
cleanup();
|
|
});
|
|
|
|
it('should not allow deleting a read-only resource', async () => {
|
|
const { cleanup, resource } = await setupFolderNoteResourceReadOnly('123456789');
|
|
expect(await pathExists(Resource.fullPath(resource))).toBe(true);
|
|
await expectThrow(async () => Resource.delete(resource.id), ErrorCode.IsReadOnly);
|
|
// Also check that the resource blob has not been deleted
|
|
expect(await pathExists(Resource.fullPath(resource))).toBe(true);
|
|
cleanup();
|
|
});
|
|
|
|
it('should return resources since a certain time and ID', async () => {
|
|
expect((await Resource.allForNormalization(0, '')).length).toBe(0);
|
|
|
|
const testData: [string, number][] = [
|
|
['00000000000000000000000000000001', 1536700000000],
|
|
['ddddddddddddddddddddddddddddddd1', 1536700000001],
|
|
['ddddddddddddddddddddddddddddddd3', 1536700000001],
|
|
['ddddddddddddddddddddddddddddddd2', 1536700000001],
|
|
['bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb1', 1536700000002],
|
|
];
|
|
|
|
for (const [id, updatedTime] of testData) {
|
|
await Resource.save({
|
|
id,
|
|
created_time: updatedTime,
|
|
updated_time: updatedTime,
|
|
user_updated_time: updatedTime,
|
|
user_created_time: updatedTime,
|
|
mime: 'application/octet-stream',
|
|
ocr_text: 'test',
|
|
ocr_status: ResourceOcrStatus.Done,
|
|
}, { isNew: true, autoTimestamp: false });
|
|
}
|
|
|
|
expect((await Resource.allForNormalization(0, '')).length).toBe(testData.length);
|
|
|
|
{
|
|
const resources = await Resource.allForNormalization(1536700000001, 'ddddddddddddddddddddddddddddddd2');
|
|
expect(resources.length).toBe(2);
|
|
expect(resources.map(r => r.id)).toEqual(['ddddddddddddddddddddddddddddddd3', 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb1']);
|
|
}
|
|
|
|
{
|
|
const resources = await Resource.allForNormalization(1536700000000, '00000000000000000000000000000001');
|
|
expect(resources.length).toBe(4);
|
|
expect(resources.map(r => r.id)).toEqual(['ddddddddddddddddddddddddddddddd1', 'ddddddddddddddddddddddddddddddd2', 'ddddddddddddddddddddddddddddddd3', 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb1']);
|
|
}
|
|
});
|
|
|
|
});
|