1
0
mirror of https://github.com/laurent22/joplin.git synced 2024-12-12 08:54:00 +02:00
joplin/CliClient/tests/services_rest_Api.js

411 lines
14 KiB
JavaScript
Raw Normal View History

/* eslint-disable no-unused-vars */
require('app-module-path').addPath(__dirname);
const { asyncTest, setupDatabaseAndSynchronizer, switchClient, checkThrowAsync } = require('test-utils.js');
const Api = require('lib/services/rest/Api');
const Folder = require('lib/models/Folder');
const Resource = require('lib/models/Resource');
2018-09-27 20:35:10 +02:00
const Note = require('lib/models/Note');
2018-09-28 20:24:57 +02:00
const Tag = require('lib/models/Tag');
const NoteTag = require('lib/models/NoteTag');
const { shim } = require('lib/shim');
2018-09-30 11:15:46 +02:00
jasmine.DEFAULT_TIMEOUT_INTERVAL = 10000;
2018-09-27 20:35:10 +02:00
process.on('unhandledRejection', (reason, p) => {
console.log('Unhandled Rejection at: Promise', p, 'reason:', reason);
});
let api = null;
describe('services_rest_Api', function() {
beforeEach(async (done) => {
api = new Api();
await setupDatabaseAndSynchronizer(1);
await switchClient(1);
done();
});
it('should ping', asyncTest(async () => {
const response = await api.route('GET', 'ping');
}));
it('should handle Not Found errors', asyncTest(async () => {
const hasThrown = await checkThrowAsync(async () => await api.route('GET', 'pong'));
}));
it('should get folders', asyncTest(async () => {
const f1 = await Folder.save({ title: 'mon carnet' });
const response = await api.route('GET', 'folders');
expect(response.length).toBe(1);
}));
it('should update folders', asyncTest(async () => {
const f1 = await Folder.save({ title: 'mon carnet' });
2019-09-19 23:51:18 +02:00
const response = await api.route('PUT', `folders/${f1.id}`, null, JSON.stringify({
2018-09-28 20:24:57 +02:00
title: 'modifié',
}));
const f1b = await Folder.load(f1.id);
2018-09-28 20:24:57 +02:00
expect(f1b.title).toBe('modifié');
}));
2018-09-28 20:24:57 +02:00
it('should delete folders', asyncTest(async () => {
const f1 = await Folder.save({ title: 'mon carnet' });
2019-09-19 23:51:18 +02:00
await api.route('DELETE', `folders/${f1.id}`);
2018-09-28 20:24:57 +02:00
const f1b = await Folder.load(f1.id);
2018-09-28 20:24:57 +02:00
expect(!f1b).toBe(true);
}));
it('should create folders', asyncTest(async () => {
2018-09-28 20:24:57 +02:00
const response = await api.route('POST', 'folders', null, JSON.stringify({
title: 'from api',
}));
expect(!!response.id).toBe(true);
const f = await Folder.all();
2018-09-28 20:24:57 +02:00
expect(f.length).toBe(1);
expect(f[0].title).toBe('from api');
}));
it('should get one folder', asyncTest(async () => {
const f1 = await Folder.save({ title: 'mon carnet' });
2019-09-19 23:51:18 +02:00
const response = await api.route('GET', `folders/${f1.id}`);
2018-09-28 20:24:57 +02:00
expect(response.id).toBe(f1.id);
const hasThrown = await checkThrowAsync(async () => await api.route('GET', 'folders/doesntexist'));
expect(hasThrown).toBe(true);
}));
2018-09-28 20:24:57 +02:00
it('should get the folder notes', asyncTest(async () => {
const f1 = await Folder.save({ title: 'mon carnet' });
2019-09-19 23:51:18 +02:00
const response2 = await api.route('GET', `folders/${f1.id}/notes`);
2018-09-29 13:54:44 +02:00
expect(response2.length).toBe(0);
const n1 = await Note.save({ title: 'un', parent_id: f1.id });
const n2 = await Note.save({ title: 'deux', parent_id: f1.id });
2019-09-19 23:51:18 +02:00
const response = await api.route('GET', `folders/${f1.id}/notes`);
2018-09-29 13:54:44 +02:00
expect(response.length).toBe(2);
}));
2018-09-29 13:54:44 +02:00
it('should fail on invalid paths', asyncTest(async () => {
2018-09-28 20:24:57 +02:00
const hasThrown = await checkThrowAsync(async () => await api.route('GET', 'schtroumpf'));
expect(hasThrown).toBe(true);
}));
2018-09-28 20:24:57 +02:00
it('should get notes', asyncTest(async () => {
2018-09-27 20:35:10 +02:00
let response = null;
const f1 = await Folder.save({ title: 'mon carnet' });
const f2 = await Folder.save({ title: 'mon deuxième carnet' });
2018-09-27 20:35:10 +02:00
const n1 = await Note.save({ title: 'un', parent_id: f1.id });
const n2 = await Note.save({ title: 'deux', parent_id: f1.id });
const n3 = await Note.save({ title: 'trois', parent_id: f2.id });
2018-09-27 20:35:10 +02:00
response = await api.route('GET', 'notes');
expect(response.length).toBe(3);
2019-09-19 23:51:18 +02:00
response = await api.route('GET', `notes/${n1.id}`);
2018-09-27 20:35:10 +02:00
expect(response.id).toBe(n1.id);
2019-09-19 23:51:18 +02:00
response = await api.route('GET', `notes/${n3.id}`, { fields: 'id,title' });
2018-09-27 20:35:10 +02:00
expect(Object.getOwnPropertyNames(response).length).toBe(3);
expect(response.id).toBe(n3.id);
expect(response.title).toBe('trois');
}));
2018-09-27 20:35:10 +02:00
it('should create notes', asyncTest(async () => {
let response = null;
const f = await Folder.save({ title: 'mon carnet' });
response = await api.route('POST', 'notes', null, JSON.stringify({
title: 'testing',
parent_id: f.id,
}));
expect(response.title).toBe('testing');
expect(!!response.id).toBe(true);
response = await api.route('POST', 'notes', null, JSON.stringify({
title: 'testing',
parent_id: f.id,
}));
expect(response.title).toBe('testing');
expect(!!response.id).toBe(true);
}));
it('should preserve user timestamps when creating notes', asyncTest(async () => {
let response = null;
const f = await Folder.save({ title: 'mon carnet' });
const updatedTime = Date.now() - 1000;
const createdTime = Date.now() - 10000;
response = await api.route('POST', 'notes', null, JSON.stringify({
parent_id: f.id,
user_updated_time: updatedTime,
user_created_time: createdTime,
}));
expect(response.user_updated_time).toBe(updatedTime);
expect(response.user_created_time).toBe(createdTime);
}));
it('should create notes with supplied ID', asyncTest(async () => {
let response = null;
const f = await Folder.save({ title: 'mon carnet' });
response = await api.route('POST', 'notes', null, JSON.stringify({
id: '12345678123456781234567812345678',
title: 'testing',
parent_id: f.id,
}));
expect(response.id).toBe('12345678123456781234567812345678');
}));
it('should create todos', asyncTest(async () => {
let response = null;
const f = await Folder.save({ title: 'stuff to do' });
response = await api.route('POST', 'notes', null, JSON.stringify({
title: 'testing',
parent_id: f.id,
is_todo: 1,
}));
expect(response.is_todo).toBe(1);
response = await api.route('POST', 'notes', null, JSON.stringify({
title: 'testing 2',
parent_id: f.id,
is_todo: 0,
}));
expect(response.is_todo).toBe(0);
response = await api.route('POST', 'notes', null, JSON.stringify({
title: 'testing 3',
parent_id: f.id,
}));
expect(response.is_todo).toBeUndefined();
response = await api.route('POST', 'notes', null, JSON.stringify({
title: 'testing 4',
parent_id: f.id,
is_todo: '1',
}));
}));
it('should create folders with supplied ID', asyncTest(async () => {
const response = await api.route('POST', 'folders', null, JSON.stringify({
id: '12345678123456781234567812345678',
title: 'from api',
}));
expect(response.id).toBe('12345678123456781234567812345678');
}));
it('should create notes with images', asyncTest(async () => {
let response = null;
const f = await Folder.save({ title: 'mon carnet' });
response = await api.route('POST', 'notes', null, JSON.stringify({
title: 'testing image',
parent_id: f.id,
image_data_url: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAIAAABLbSncAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAANZJREFUeNoAyAA3/wFwtO3K6gUB/vz2+Prw9fj/+/r+/wBZKAAExOgF4/MC9ff+MRH6Ui4E+/0Bqc/zutj6AgT+/Pz7+vv7++nu82c4DlMqCvLs8goA/gL8/fz09fb59vXa6vzZ6vjT5fbn6voD/fwC8vX4UiT9Zi//APHyAP8ACgUBAPv5APz7BPj2+DIaC2o3E+3o6ywaC5fT6gD6/QD9/QEVf9kD+/dcLQgJA/7v8vqfwOf18wA1IAIEVycAyt//v9XvAPv7APz8LhoIAPz9Ri4OAgwARgx4W/6fVeEAAAAASUVORK5CYII=',
}));
const resources = await Resource.all();
expect(resources.length).toBe(1);
const resource = resources[0];
expect(response.body.indexOf(resource.id) >= 0).toBe(true);
}));
it('should delete resources', asyncTest(async () => {
let response = null;
const f = await Folder.save({ title: 'mon carnet' });
response = await api.route('POST', 'notes', null, JSON.stringify({
title: 'testing image',
parent_id: f.id,
image_data_url: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAICAIAAABLbSncAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAANZJREFUeNoAyAA3/wFwtO3K6gUB/vz2+Prw9fj/+/r+/wBZKAAExOgF4/MC9ff+MRH6Ui4E+/0Bqc/zutj6AgT+/Pz7+vv7++nu82c4DlMqCvLs8goA/gL8/fz09fb59vXa6vzZ6vjT5fbn6voD/fwC8vX4UiT9Zi//APHyAP8ACgUBAPv5APz7BPj2+DIaC2o3E+3o6ywaC5fT6gD6/QD9/QEVf9kD+/dcLQgJA/7v8vqfwOf18wA1IAIEVycAyt//v9XvAPv7APz8LhoIAPz9Ri4OAgwARgx4W/6fVeEAAAAASUVORK5CYII=',
}));
const resource = (await Resource.all())[0];
const filePath = Resource.fullPath(resource);
expect(await shim.fsDriver().exists(filePath)).toBe(true);
2019-09-19 23:51:18 +02:00
await api.route('DELETE', `resources/${resource.id}`);
expect(await shim.fsDriver().exists(filePath)).toBe(false);
expect(!(await Resource.load(resource.id))).toBe(true);
}));
it('should create notes from HTML', asyncTest(async () => {
let response = null;
const f = await Folder.save({ title: 'mon carnet' });
response = await api.route('POST', 'notes', null, JSON.stringify({
title: 'testing HTML',
parent_id: f.id,
body_html: '<b>Bold text</b>',
}));
expect(response.body).toBe('**Bold text**');
}));
it('should filter fields', asyncTest(async () => {
let f = api.fields_({ query: { fields: 'one,two' } }, []);
expect(f.length).toBe(2);
expect(f[0]).toBe('one');
expect(f[1]).toBe('two');
f = api.fields_({ query: { fields: 'one ,, two ' } }, []);
expect(f.length).toBe(2);
expect(f[0]).toBe('one');
expect(f[1]).toBe('two');
f = api.fields_({ query: { fields: ' ' } }, ['def']);
expect(f.length).toBe(1);
expect(f[0]).toBe('def');
}));
it('should handle tokens', asyncTest(async () => {
2018-09-27 20:35:10 +02:00
api = new Api('mytoken');
2018-09-30 11:15:46 +02:00
let hasThrown = await checkThrowAsync(async () => await api.route('GET', 'notes'));
2018-09-27 20:35:10 +02:00
expect(hasThrown).toBe(true);
const response = await api.route('GET', 'notes', { token: 'mytoken' });
2018-09-27 20:35:10 +02:00
expect(response.length).toBe(0);
hasThrown = await checkThrowAsync(async () => await api.route('POST', 'notes', null, JSON.stringify({ title: 'testing' })));
2018-09-30 11:15:46 +02:00
expect(hasThrown).toBe(true);
}));
2018-09-30 11:15:46 +02:00
it('should add tags to notes', asyncTest(async () => {
const tag = await Tag.save({ title: 'mon étiquette' });
const note = await Note.save({ title: 'ma note' });
2018-09-28 20:24:57 +02:00
2019-09-19 23:51:18 +02:00
const response = await api.route('POST', `tags/${tag.id}/notes`, null, JSON.stringify({
2018-09-28 20:24:57 +02:00
id: note.id,
}));
const noteIds = await Tag.noteIds(tag.id);
2018-09-28 20:24:57 +02:00
expect(noteIds[0]).toBe(note.id);
}));
2018-09-28 20:24:57 +02:00
it('should remove tags from notes', asyncTest(async () => {
const tag = await Tag.save({ title: 'mon étiquette' });
const note = await Note.save({ title: 'ma note' });
2018-09-28 20:24:57 +02:00
await Tag.addNote(tag.id, note.id);
2019-09-19 23:51:18 +02:00
const response = await api.route('DELETE', `tags/${tag.id}/notes/${note.id}`);
2018-09-28 20:24:57 +02:00
const noteIds = await Tag.noteIds(tag.id);
2018-09-28 20:24:57 +02:00
expect(noteIds.length).toBe(0);
}));
2018-09-28 20:24:57 +02:00
it('should list all tag notes', asyncTest(async () => {
const tag = await Tag.save({ title: 'mon étiquette' });
const tag2 = await Tag.save({ title: 'mon étiquette 2' });
const note1 = await Note.save({ title: 'ma note un' });
const note2 = await Note.save({ title: 'ma note deux' });
2018-09-28 20:24:57 +02:00
await Tag.addNote(tag.id, note1.id);
await Tag.addNote(tag.id, note2.id);
2019-09-19 23:51:18 +02:00
const response = await api.route('GET', `tags/${tag.id}/notes`);
2018-09-28 20:24:57 +02:00
expect(response.length).toBe(2);
2018-09-29 13:54:44 +02:00
expect('id' in response[0]).toBe(true);
expect('title' in response[0]).toBe(true);
2019-09-19 23:51:18 +02:00
const response2 = await api.route('GET', `notes/${note1.id}/tags`);
2018-09-29 13:54:44 +02:00
expect(response2.length).toBe(1);
await Tag.addNote(tag2.id, note1.id);
2019-09-19 23:51:18 +02:00
const response3 = await api.route('GET', `notes/${note1.id}/tags`);
2018-09-29 13:54:44 +02:00
expect(response3.length).toBe(2);
}));
2018-09-28 20:24:57 +02:00
it('should update tags when updating notes', asyncTest(async () => {
const tag1 = await Tag.save({ title: 'mon étiquette 1' });
const tag2 = await Tag.save({ title: 'mon étiquette 2' });
const tag3 = await Tag.save({ title: 'mon étiquette 3' });
const note = await Note.save({
title: 'ma note un',
});
Tag.addNote(tag1.id, note.id);
Tag.addNote(tag2.id, note.id);
const response = await api.route('PUT', `notes/${note.id}`, null, JSON.stringify({
tags: `${tag1.title},${tag3.title}`,
}));
const tagIds = await NoteTag.tagIdsByNoteId(note.id);
expect(response.tags === `${tag1.title},${tag3.title}`).toBe(true);
expect(tagIds.length === 2).toBe(true);
expect(tagIds.includes(tag1.id)).toBe(true);
expect(tagIds.includes(tag3.id)).toBe(true);
}));
it('should create and update tags when updating notes', asyncTest(async () => {
const tag1 = await Tag.save({ title: 'mon étiquette 1' });
const tag2 = await Tag.save({ title: 'mon étiquette 2' });
const newTagTitle = 'mon étiquette 3';
const note = await Note.save({
title: 'ma note un',
});
Tag.addNote(tag1.id, note.id);
Tag.addNote(tag2.id, note.id);
const response = await api.route('PUT', `notes/${note.id}`, null, JSON.stringify({
tags: `${tag1.title},${newTagTitle}`,
}));
const newTag = await Tag.loadByTitle(newTagTitle);
const tagIds = await NoteTag.tagIdsByNoteId(note.id);
expect(response.tags === `${tag1.title},${newTag.title}`).toBe(true);
expect(tagIds.length === 2).toBe(true);
expect(tagIds.includes(tag1.id)).toBe(true);
expect(tagIds.includes(newTag.id)).toBe(true);
}));
it('should not update tags if tags is not mentioned when updating', asyncTest(async () => {
const tag1 = await Tag.save({ title: 'mon étiquette 1' });
const tag2 = await Tag.save({ title: 'mon étiquette 2' });
const note = await Note.save({
title: 'ma note un',
});
Tag.addNote(tag1.id, note.id);
Tag.addNote(tag2.id, note.id);
const response = await api.route('PUT', `notes/${note.id}`, null, JSON.stringify({
title: 'Some other title',
}));
const tagIds = await NoteTag.tagIdsByNoteId(note.id);
expect(response.tags === undefined).toBe(true);
expect(tagIds.length === 2).toBe(true);
expect(tagIds.includes(tag1.id)).toBe(true);
expect(tagIds.includes(tag2.id)).toBe(true);
}));
it('should remove tags from note if tags is set to empty string when updating', asyncTest(async () => {
const tag1 = await Tag.save({ title: 'mon étiquette 1' });
const tag2 = await Tag.save({ title: 'mon étiquette 2' });
const note = await Note.save({
title: 'ma note un',
});
Tag.addNote(tag1.id, note.id);
Tag.addNote(tag2.id, note.id);
const response = await api.route('PUT', `notes/${note.id}`, null, JSON.stringify({
tags: '',
}));
const tagIds = await NoteTag.tagIdsByNoteId(note.id);
expect(response.tags === '').toBe(true);
expect(tagIds.length === 0).toBe(true);
}));
});