mirror of
https://github.com/hedgedoc/hedgedoc.git
synced 2025-05-29 06:15:29 -04:00
413 lines
14 KiB
TypeScript
413 lines
14 KiB
TypeScript
/*
|
|
* SPDX-FileCopyrightText: 2022 The HedgeDoc developers (see AUTHORS file)
|
|
*
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
*/
|
|
import { ConfigModule } from '@nestjs/config';
|
|
import { EventEmitterModule } from '@nestjs/event-emitter';
|
|
import { Test, TestingModule } from '@nestjs/testing';
|
|
import { getRepositoryToken } from '@nestjs/typeorm';
|
|
import { Mock } from 'ts-mockery';
|
|
import { Repository } from 'typeorm';
|
|
|
|
import { AuthToken } from '../auth/auth-token.entity';
|
|
import { Author } from '../authors/author.entity';
|
|
import appConfigMock from '../config/mock/app.config.mock';
|
|
import authConfigMock from '../config/mock/auth.config.mock';
|
|
import databaseConfigMock from '../config/mock/database.config.mock';
|
|
import noteConfigMock from '../config/mock/note.config.mock';
|
|
import { NotInDBError } from '../errors/errors';
|
|
import { eventModuleConfig } from '../events';
|
|
import { Group } from '../groups/group.entity';
|
|
import { Identity } from '../identity/identity.entity';
|
|
import { LoggerModule } from '../logger/logger.module';
|
|
import { Alias } from '../notes/alias.entity';
|
|
import { Note } from '../notes/note.entity';
|
|
import { NotesModule } from '../notes/notes.module';
|
|
import { Tag } from '../notes/tag.entity';
|
|
import { NoteGroupPermission } from '../permissions/note-group-permission.entity';
|
|
import { NoteUserPermission } from '../permissions/note-user-permission.entity';
|
|
import { Session } from '../sessions/session.entity';
|
|
import { User } from '../users/user.entity';
|
|
import { Edit } from './edit.entity';
|
|
import { EditService } from './edit.service';
|
|
import { Revision } from './revision.entity';
|
|
import { RevisionsService } from './revisions.service';
|
|
|
|
describe('RevisionsService', () => {
|
|
let service: RevisionsService;
|
|
let revisionRepo: Repository<Revision>;
|
|
|
|
beforeEach(async () => {
|
|
const module: TestingModule = await Test.createTestingModule({
|
|
providers: [
|
|
RevisionsService,
|
|
EditService,
|
|
{
|
|
provide: getRepositoryToken(Revision),
|
|
useClass: Repository,
|
|
},
|
|
],
|
|
imports: [
|
|
NotesModule,
|
|
LoggerModule,
|
|
ConfigModule.forRoot({
|
|
isGlobal: true,
|
|
load: [
|
|
appConfigMock,
|
|
databaseConfigMock,
|
|
authConfigMock,
|
|
noteConfigMock,
|
|
],
|
|
}),
|
|
EventEmitterModule.forRoot(eventModuleConfig),
|
|
],
|
|
})
|
|
.overrideProvider(getRepositoryToken(Edit))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(User))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(AuthToken))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(Identity))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(Note))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(Revision))
|
|
.useClass(Repository)
|
|
.overrideProvider(getRepositoryToken(Tag))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(NoteGroupPermission))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(NoteUserPermission))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(Group))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(Alias))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(Session))
|
|
.useValue({})
|
|
.overrideProvider(getRepositoryToken(Author))
|
|
.useValue({})
|
|
.compile();
|
|
|
|
service = module.get<RevisionsService>(RevisionsService);
|
|
revisionRepo = module.get<Repository<Revision>>(
|
|
getRepositoryToken(Revision),
|
|
);
|
|
});
|
|
|
|
it('should be defined', () => {
|
|
expect(service).toBeDefined();
|
|
});
|
|
|
|
describe('getRevision', () => {
|
|
it('returns a revision', async () => {
|
|
const note = Mock.of<Note>({});
|
|
const revision = Mock.of<Revision>({});
|
|
jest.spyOn(revisionRepo, 'findOne').mockResolvedValueOnce(revision);
|
|
expect(await service.getRevision(note, 1)).toBe(revision);
|
|
});
|
|
it('throws if the revision is not in the databse', async () => {
|
|
jest.spyOn(revisionRepo, 'findOne').mockResolvedValueOnce(null);
|
|
await expect(service.getRevision({} as Note, 1)).rejects.toThrow(
|
|
NotInDBError,
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('purgeRevisions', () => {
|
|
let revisions: Revision[];
|
|
let note: Note;
|
|
|
|
beforeEach(() => {
|
|
note = Mock.of<Note>({});
|
|
revisions = [];
|
|
|
|
jest
|
|
.spyOn(revisionRepo, 'remove')
|
|
.mockImplementation(
|
|
<T extends Revision | Revision[]>(deleteEntities: T): Promise<T> => {
|
|
const newRevisions = revisions.filter((item: Revision) =>
|
|
Array.isArray(deleteEntities)
|
|
? !deleteEntities.includes(item)
|
|
: deleteEntities !== item,
|
|
);
|
|
revisions = newRevisions;
|
|
note.revisions = Promise.resolve(newRevisions);
|
|
return Promise.resolve(deleteEntities);
|
|
},
|
|
);
|
|
});
|
|
|
|
it('purges the revision history', async () => {
|
|
const revision1 = Mock.of<Revision>({ id: 1 });
|
|
const revision2 = Mock.of<Revision>({ id: 2 });
|
|
const revision3 = Mock.of<Revision>({ id: 3 });
|
|
revisions = [revision1, revision2, revision3];
|
|
note.revisions = Promise.resolve(revisions);
|
|
|
|
jest.spyOn(revisionRepo, 'find').mockResolvedValueOnce(revisions);
|
|
jest.spyOn(service, 'getLatestRevision').mockResolvedValueOnce(revision3);
|
|
|
|
// expected to return all the purged revisions
|
|
expect(await service.purgeRevisions(note)).toStrictEqual([
|
|
revision1,
|
|
revision2,
|
|
]);
|
|
|
|
// expected to have only the latest revision
|
|
expect(revisions).toStrictEqual([revision3]);
|
|
});
|
|
it('has no effect on revision history when a single revision is present', async () => {
|
|
const revision1 = Mock.of<Revision>({ id: 1 });
|
|
revisions = [revision1];
|
|
note.revisions = Promise.resolve(revisions);
|
|
|
|
jest.spyOn(revisionRepo, 'find').mockResolvedValueOnce(revisions);
|
|
jest.spyOn(service, 'getLatestRevision').mockResolvedValueOnce(revision1);
|
|
|
|
// expected to return all the purged revisions
|
|
expect(await service.purgeRevisions(note)).toHaveLength(0);
|
|
|
|
// expected to have only the latest revision
|
|
const updatedRevisions: Revision[] = [revision1];
|
|
expect(revisions).toEqual(updatedRevisions);
|
|
});
|
|
});
|
|
|
|
describe('getRevisionUserInfo', () => {
|
|
it('counts users correctly', async () => {
|
|
const user = User.create('test', 'test') as User;
|
|
const author = Author.create(123) as Author;
|
|
author.user = Promise.resolve(user);
|
|
const anonAuthor = Author.create(123) as Author;
|
|
const anonAuthor2 = Author.create(123) as Author;
|
|
const edits = [Edit.create(author, 12, 15) as Edit];
|
|
edits.push(Edit.create(author, 16, 18) as Edit);
|
|
edits.push(Edit.create(author, 29, 20) as Edit);
|
|
edits.push(Edit.create(anonAuthor, 29, 20) as Edit);
|
|
edits.push(Edit.create(anonAuthor, 29, 20) as Edit);
|
|
edits.push(Edit.create(anonAuthor2, 29, 20) as Edit);
|
|
const revision = Mock.of<Revision>({});
|
|
revision.edits = Promise.resolve(edits);
|
|
|
|
const userInfo = await service.getRevisionUserInfo(revision);
|
|
expect(userInfo.usernames.length).toEqual(1);
|
|
expect(userInfo.anonymousUserCount).toEqual(2);
|
|
});
|
|
});
|
|
|
|
describe('toRevisionMetadataDto', () => {
|
|
it('converts a revision', async () => {
|
|
const revision = Mock.of<Revision>({
|
|
id: 3246,
|
|
content: 'mockContent',
|
|
length: 1854,
|
|
createdAt: new Date('2020-05-20T09:58:00.000Z'),
|
|
title: 'mockTitle',
|
|
tags: Promise.resolve([Mock.of<Tag>({ name: 'mockTag' })]),
|
|
description: 'mockDescription',
|
|
patch: 'mockPatch',
|
|
edits: Promise.resolve([
|
|
Mock.of<Edit>({
|
|
endPos: 93,
|
|
startPos: 34,
|
|
createdAt: new Date('2020-03-04T20:12:00.000Z'),
|
|
updatedAt: new Date('2021-12-10T09:45:00.000Z'),
|
|
author: Promise.resolve(
|
|
Mock.of<Author>({
|
|
user: Promise.resolve(
|
|
Mock.of<User>({
|
|
username: 'mockusername',
|
|
}),
|
|
),
|
|
}),
|
|
),
|
|
}),
|
|
]),
|
|
});
|
|
expect(await service.toRevisionMetadataDto(revision))
|
|
.toMatchInlineSnapshot(`
|
|
{
|
|
"anonymousAuthorCount": 0,
|
|
"authorUsernames": [
|
|
"mockusername",
|
|
],
|
|
"createdAt": 2020-05-20T09:58:00.000Z,
|
|
"description": "mockDescription",
|
|
"id": 3246,
|
|
"length": 1854,
|
|
"tags": [
|
|
"mockTag",
|
|
],
|
|
"title": "mockTitle",
|
|
}
|
|
`);
|
|
});
|
|
});
|
|
|
|
describe('toRevisionDto', () => {
|
|
it('converts a revision', async () => {
|
|
const revision = Mock.of<Revision>({
|
|
id: 3246,
|
|
content: 'mockContent',
|
|
length: 1854,
|
|
createdAt: new Date('2020-05-20T09:58:00.000Z'),
|
|
title: 'mockTitle',
|
|
tags: Promise.resolve([Mock.of<Tag>({ name: 'mockTag' })]),
|
|
description: 'mockDescription',
|
|
patch: 'mockPatch',
|
|
edits: Promise.resolve([
|
|
Mock.of<Edit>({
|
|
endPos: 93,
|
|
startPos: 34,
|
|
createdAt: new Date('2020-03-04T22:32:00.000Z'),
|
|
updatedAt: new Date('2021-02-10T12:23:00.000Z'),
|
|
author: Promise.resolve(
|
|
Mock.of<Author>({
|
|
user: Promise.resolve(
|
|
Mock.of<User>({
|
|
username: 'mockusername',
|
|
}),
|
|
),
|
|
}),
|
|
),
|
|
}),
|
|
]),
|
|
});
|
|
expect(await service.toRevisionDto(revision)).toMatchInlineSnapshot(`
|
|
{
|
|
"anonymousAuthorCount": 0,
|
|
"authorUsernames": [
|
|
"mockusername",
|
|
],
|
|
"content": "mockContent",
|
|
"createdAt": 2020-05-20T09:58:00.000Z,
|
|
"description": "mockDescription",
|
|
"edits": [
|
|
{
|
|
"createdAt": 2020-03-04T22:32:00.000Z,
|
|
"endPos": 93,
|
|
"startPos": 34,
|
|
"updatedAt": 2021-02-10T12:23:00.000Z,
|
|
"username": "mockusername",
|
|
},
|
|
],
|
|
"id": 3246,
|
|
"length": 1854,
|
|
"patch": "mockPatch",
|
|
"tags": [
|
|
"mockTag",
|
|
],
|
|
"title": "mockTitle",
|
|
}
|
|
`);
|
|
});
|
|
});
|
|
|
|
describe('createRevision', () => {
|
|
it('creates a new revision', async () => {
|
|
const note = Mock.of<Note>({ publicId: 'test-note', id: 1 });
|
|
const oldContent = 'old content\n';
|
|
const newContent =
|
|
'---\ntitle: new title\ndescription: new description\ntags: [ "tag1" ]\n---\nnew content\n';
|
|
|
|
const oldRevision = Mock.of<Revision>({ content: oldContent, id: 1 });
|
|
jest.spyOn(revisionRepo, 'findOne').mockResolvedValueOnce(oldRevision);
|
|
jest
|
|
.spyOn(revisionRepo, 'save')
|
|
.mockImplementation((revision) =>
|
|
Promise.resolve(revision as Revision),
|
|
);
|
|
|
|
const createdRevision = await service.createRevision(note, newContent);
|
|
expect(createdRevision).not.toBeUndefined();
|
|
expect(createdRevision?.content).toBe(newContent);
|
|
await expect(createdRevision?.tags).resolves.toMatchInlineSnapshot(`
|
|
[
|
|
Tag {
|
|
"name": "tag1",
|
|
},
|
|
]
|
|
`);
|
|
expect(createdRevision?.title).toBe('new title');
|
|
expect(createdRevision?.description).toBe('new description');
|
|
await expect(createdRevision?.note).resolves.toBe(note);
|
|
expect(createdRevision?.patch).toMatchInlineSnapshot(`
|
|
"Index: test-note
|
|
===================================================================
|
|
--- test-note
|
|
+++ test-note
|
|
@@ -1,1 +1,6 @@
|
|
-old content
|
|
+---
|
|
+title: new title
|
|
+description: new description
|
|
+tags: [ "tag1" ]
|
|
+---
|
|
+new content
|
|
"
|
|
`);
|
|
});
|
|
|
|
it("won't create a revision if content is unchanged", async () => {
|
|
const note = Mock.of<Note>({ id: 1 });
|
|
const oldContent = 'old content\n';
|
|
|
|
const oldRevision = Mock.of<Revision>({ content: oldContent, id: 1 });
|
|
jest.spyOn(revisionRepo, 'findOne').mockResolvedValueOnce(oldRevision);
|
|
const saveSpy = jest.spyOn(revisionRepo, 'save').mockImplementation();
|
|
|
|
const createdRevision = await service.createRevision(note, oldContent);
|
|
expect(createdRevision).toBeUndefined();
|
|
expect(saveSpy).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('createAndSaveRevision', () => {
|
|
it('creates and saves a new revision', async () => {
|
|
const newRevision = Mock.of<Revision>();
|
|
const createRevisionSpy = jest
|
|
.spyOn(service, 'createRevision')
|
|
.mockResolvedValue(newRevision);
|
|
const repoSaveSpy = jest
|
|
.spyOn(revisionRepo, 'save')
|
|
.mockResolvedValue(newRevision);
|
|
|
|
const note = Mock.of<Note>({});
|
|
const newContent = 'MockContent';
|
|
|
|
const yjsState = [0, 1, 2, 3, 4, 5];
|
|
|
|
await service.createAndSaveRevision(note, newContent, yjsState);
|
|
expect(createRevisionSpy).toHaveBeenCalledWith(
|
|
note,
|
|
newContent,
|
|
yjsState,
|
|
);
|
|
expect(repoSaveSpy).toHaveBeenCalledWith(newRevision);
|
|
});
|
|
|
|
it("doesn't save if no revision has been created", async () => {
|
|
const createRevisionSpy = jest
|
|
.spyOn(service, 'createRevision')
|
|
.mockResolvedValue(undefined);
|
|
const repoSaveSpy = jest
|
|
.spyOn(revisionRepo, 'save')
|
|
.mockRejectedValue(new Error("shouldn't have been called"));
|
|
|
|
const note = Mock.of<Note>({});
|
|
const newContent = 'MockContent';
|
|
const yjsState = [0, 1, 2, 3, 4, 5];
|
|
|
|
await service.createAndSaveRevision(note, newContent, yjsState);
|
|
expect(createRevisionSpy).toHaveBeenCalledWith(
|
|
note,
|
|
newContent,
|
|
yjsState,
|
|
);
|
|
expect(repoSaveSpy).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
});
|