Files
outline/server/queues/processors/DocumentMovedProcessor.test.ts

938 lines
30 KiB
TypeScript

import { UserMembership, GroupMembership } from "@server/models";
import {
buildDocument,
buildCollection,
buildUser,
buildTeam,
buildAdmin,
buildGroup,
} from "@server/test/factories";
import DocumentMovedProcessor from "./DocumentMovedProcessor";
const ip = "127.0.0.1";
describe("DocumentMovedProcessor", () => {
it("should add sourced permissions from the top document when a document is moved into a new parent", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const topDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const childDocument = await buildDocument({
teamId: team.id,
parentDocumentId: topDocument.id,
});
const sourceUserMembership = await UserMembership.create({
userId: user2.id,
documentId: topDocument.id,
createdById: user.id,
});
const sourceGroupMembership = await GroupMembership.create({
groupId: group.id,
documentId: topDocument.id,
createdById: user.id,
});
// remove sourced permissions from childDocument
await UserMembership.destroy({
where: { documentId: childDocument.id, userId: user2.id },
});
await GroupMembership.destroy({
where: { documentId: childDocument.id, groupId: group.id },
});
// trigger move event on childDocument
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: childDocument.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
// doc2 should have sourced permissions from topDocument
const memberships = await UserMembership.findAll({
where: { documentId: childDocument.id, userId: user2.id },
});
const groupMemberships = await GroupMembership.findAll({
where: { documentId: childDocument.id, groupId: group.id },
});
expect(memberships.length).toBe(1);
expect(groupMemberships.length).toBe(1);
expect(memberships[0].sourceId).toBe(sourceUserMembership.id);
expect(groupMemberships[0].sourceId).toBe(sourceGroupMembership.id);
});
it("should not reapply sourced permissions to sibling documents when a document is moved into a new parent", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const topDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const doc1 = await buildDocument({
teamId: team.id,
parentDocumentId: topDocument.id,
});
const doc2 = await buildDocument({
teamId: team.id,
parentDocumentId: topDocument.id,
});
await UserMembership.create({
userId: user2.id,
documentId: topDocument.id,
createdById: user.id,
});
await GroupMembership.create({
groupId: group.id,
documentId: topDocument.id,
createdById: user.id,
});
// Remove source permissions from doc2
await UserMembership.destroy({
where: { documentId: doc2.id, userId: user2.id },
});
await GroupMembership.destroy({
where: { documentId: doc2.id, groupId: group.id },
});
// trigger move event on doc1
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: doc1.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
// sourced permission from user2 remains removed
const userMemberships = await UserMembership.findAll({
where: { documentId: doc2.id, userId: user2.id },
});
const groupMemberships = await GroupMembership.findAll({
where: { documentId: doc2.id, groupId: group.id },
});
expect(userMemberships.length).toBe(0);
expect(groupMemberships.length).toBe(0);
});
it("should not create duplicate sourced permissions when a document is moved", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const topDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const doc1 = await buildDocument({
teamId: team.id,
parentDocumentId: topDocument.id,
});
const doc2 = await buildDocument({
teamId: team.id,
parentDocumentId: topDocument.id,
});
await UserMembership.create({
userId: user2.id,
documentId: topDocument.id,
createdById: user.id,
});
await GroupMembership.create({
groupId: group.id,
documentId: topDocument.id,
createdById: user.id,
});
// Trigger move event on doc1
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: doc1.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
// there should be no duplicate permissions are created for doc1 and doc2
const doc1UserMemberships = await UserMembership.findAll({
where: { documentId: doc1.id, userId: user2.id },
});
const doc2UserMemberships = await UserMembership.findAll({
where: { documentId: doc2.id, userId: user2.id },
});
const doc1GroupMemberships = await GroupMembership.findAll({
where: { documentId: doc1.id, groupId: group.id },
});
const doc2GroupMemberships = await GroupMembership.findAll({
where: { documentId: doc2.id, groupId: group.id },
});
expect(doc1UserMemberships.length).toBe(1);
expect(doc2UserMemberships.length).toBe(1);
expect(doc1GroupMemberships.length).toBe(1);
expect(doc2GroupMemberships.length).toBe(1);
});
it("should propagate sourced permissions to direct child documents of the moved document", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const topDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const childDocument = await buildDocument({
teamId: team.id,
parentDocumentId: topDocument.id,
});
const sourceUserMembership = await UserMembership.create({
userId: user2.id,
documentId: topDocument.id,
createdById: user.id,
});
const sourceGroupMembership = await GroupMembership.create({
groupId: group.id,
documentId: topDocument.id,
createdById: user.id,
});
// Remove sourced permissions from childDocument
await UserMembership.destroy({
where: { documentId: childDocument.id, userId: user2.id },
});
await GroupMembership.destroy({
where: { documentId: childDocument.id, groupId: group.id },
});
// Trigger move event on childDocument
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: childDocument.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
// Verify permissions for childDocument
const childUserMemberships = await UserMembership.findAll({
where: { documentId: childDocument.id, userId: user2.id },
});
const childGroupMemberships = await GroupMembership.findAll({
where: { documentId: childDocument.id, groupId: group.id },
});
expect(childUserMemberships.length).toBe(1);
expect(childGroupMemberships.length).toBe(1);
expect(childUserMemberships[0].sourceId).toBe(sourceUserMembership.id);
expect(childGroupMemberships[0].sourceId).toBe(sourceGroupMembership.id);
});
it("should propagate sourced permissions to all deep child documents of the moved document", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const topDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const childDocument = await buildDocument({
teamId: team.id,
parentDocumentId: topDocument.id,
});
const grandChildDocument = await buildDocument({
teamId: team.id,
parentDocumentId: childDocument.id,
});
const greatGrandChildDocument = await buildDocument({
teamId: team.id,
parentDocumentId: grandChildDocument.id,
});
const sourceUserMembership = await UserMembership.create({
userId: user2.id,
documentId: topDocument.id,
createdById: user.id,
});
const sourceGroupMembership = await GroupMembership.create({
groupId: group.id,
documentId: topDocument.id,
createdById: user.id,
});
// Remove sourced permissions from grandChildDocument and greatGrandChildDocument
await UserMembership.destroy({
where: { documentId: grandChildDocument.id, userId: user2.id },
});
await GroupMembership.destroy({
where: { documentId: grandChildDocument.id, groupId: group.id },
});
await UserMembership.destroy({
where: { documentId: greatGrandChildDocument.id, userId: user2.id },
});
await GroupMembership.destroy({
where: { documentId: greatGrandChildDocument.id, groupId: group.id },
});
// Trigger move event on childDocument
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: childDocument.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
// Verify permissions for grandChildDocument
const grandChildUserMemberships = await UserMembership.findAll({
where: { documentId: grandChildDocument.id, userId: user2.id },
});
const grandChildGroupMemberships = await GroupMembership.findAll({
where: { documentId: grandChildDocument.id, groupId: group.id },
});
expect(grandChildUserMemberships.length).toBe(1);
expect(grandChildGroupMemberships.length).toBe(1);
expect(grandChildUserMemberships[0].sourceId).toBe(sourceUserMembership.id);
expect(grandChildGroupMemberships[0].sourceId).toBe(
sourceGroupMembership.id
);
// Verify permissions for greatGrandChildDocument
const greatGrandChildUserMemberships = await UserMembership.findAll({
where: { documentId: greatGrandChildDocument.id, userId: user2.id },
});
const greatGrandChildGroupMemberships = await GroupMembership.findAll({
where: { documentId: greatGrandChildDocument.id, groupId: group.id },
});
expect(greatGrandChildUserMemberships.length).toBe(1);
expect(greatGrandChildGroupMemberships.length).toBe(1);
expect(greatGrandChildUserMemberships[0].sourceId).toBe(
sourceUserMembership.id
);
expect(greatGrandChildGroupMemberships[0].sourceId).toBe(
sourceGroupMembership.id
);
});
it("should not carry over sourced permissions from previous parent", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const parentDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const childDocument = await buildDocument({
teamId: team.id,
parentDocumentId: parentDocument.id,
});
const newParentDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
// Add user and group to parent document
await UserMembership.create({
userId: user2.id,
documentId: parentDocument.id,
createdById: user.id,
});
await GroupMembership.create({
groupId: group.id,
documentId: parentDocument.id,
createdById: user.id,
});
// Add different permissions to the new parent document
const user3 = await buildUser({ teamId: team.id });
const group2 = await buildGroup({ teamId: team.id });
await UserMembership.create({
userId: user3.id,
documentId: newParentDocument.id,
createdById: user.id,
});
await GroupMembership.create({
groupId: group2.id,
documentId: newParentDocument.id,
createdById: user.id,
});
// Verify inherited permissions exist on child from the original parent
let childUserMemberships = await UserMembership.findAll({
where: { documentId: childDocument.id, userId: user2.id },
});
let childGroupMemberships = await GroupMembership.findAll({
where: { documentId: childDocument.id, groupId: group.id },
});
expect(childUserMemberships.length).toBe(1);
expect(childGroupMemberships.length).toBe(1);
expect(childUserMemberships[0].sourceId).toBeTruthy();
expect(childGroupMemberships[0].sourceId).toBeTruthy();
// Move child to a new parent document
childDocument.parentDocumentId = newParentDocument.id;
await childDocument.save();
// Trigger move event
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: childDocument.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
// Verify inherited permissions from the original parent are removed
childUserMemberships = await UserMembership.findAll({
where: { documentId: childDocument.id, userId: user2.id },
});
childGroupMemberships = await GroupMembership.findAll({
where: { documentId: childDocument.id, groupId: group.id },
});
expect(childUserMemberships.length).toBe(0);
expect(childGroupMemberships.length).toBe(0);
// Verify inherited permissions from the new parent are applied
const newChildUserMemberships = await UserMembership.findAll({
where: { documentId: childDocument.id, userId: user3.id },
});
const newChildGroupMemberships = await GroupMembership.findAll({
where: { documentId: childDocument.id, groupId: group2.id },
});
expect(newChildUserMemberships.length).toBe(1);
expect(newChildGroupMemberships.length).toBe(1);
expect(newChildUserMemberships[0].sourceId).toBeTruthy();
expect(newChildGroupMemberships[0].sourceId).toBeTruthy();
});
it("should remove all sourced permissions when a document is moved to root level", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const parentDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const childDocument = await buildDocument({
teamId: team.id,
parentDocumentId: parentDocument.id,
});
await UserMembership.create({
userId: user2.id,
documentId: parentDocument.id,
createdById: user.id,
});
await GroupMembership.create({
groupId: group.id,
documentId: parentDocument.id,
createdById: user.id,
});
// Verify sourced permissions exist on child
let childUserMemberships = await UserMembership.findAll({
where: { documentId: childDocument.id, userId: user2.id },
});
let childGroupMemberships = await GroupMembership.findAll({
where: { documentId: childDocument.id, groupId: group.id },
});
expect(childUserMemberships.length).toBe(1);
expect(childGroupMemberships.length).toBe(1);
// Move child to root level (no parent)
childDocument.parentDocumentId = null;
await childDocument.save();
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: childDocument.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
// Sourced permissions should be removed
childUserMemberships = await UserMembership.findAll({
where: { documentId: childDocument.id, userId: user2.id },
});
childGroupMemberships = await GroupMembership.findAll({
where: { documentId: childDocument.id, groupId: group.id },
});
expect(childUserMemberships.length).toBe(0);
expect(childGroupMemberships.length).toBe(0);
});
it("should preserve direct (non-sourced) permissions when a document is moved", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const user3 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const group2 = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const parentDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const childDocument = await buildDocument({
teamId: team.id,
parentDocumentId: parentDocument.id,
});
// Add sourced permissions via parent
await UserMembership.create({
userId: user2.id,
documentId: parentDocument.id,
createdById: user.id,
});
await GroupMembership.create({
groupId: group.id,
documentId: parentDocument.id,
createdById: user.id,
});
// Add direct permissions to the child document
await UserMembership.create({
userId: user3.id,
documentId: childDocument.id,
createdById: user.id,
});
await GroupMembership.create({
groupId: group2.id,
documentId: childDocument.id,
createdById: user.id,
});
// Move child to root level
childDocument.parentDocumentId = null;
await childDocument.save();
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: childDocument.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
// Sourced permissions should be removed
const sourcedUserMemberships = await UserMembership.findAll({
where: { documentId: childDocument.id, userId: user2.id },
});
const sourcedGroupMemberships = await GroupMembership.findAll({
where: { documentId: childDocument.id, groupId: group.id },
});
expect(sourcedUserMemberships.length).toBe(0);
expect(sourcedGroupMemberships.length).toBe(0);
// Direct permissions should be preserved
const directUserMemberships = await UserMembership.findAll({
where: { documentId: childDocument.id, userId: user3.id },
});
const directGroupMemberships = await GroupMembership.findAll({
where: { documentId: childDocument.id, groupId: group2.id },
});
expect(directUserMemberships.length).toBe(1);
expect(directGroupMemberships.length).toBe(1);
expect(directUserMemberships[0].sourceId).toBeNull();
expect(directGroupMemberships[0].sourceId).toBeNull();
});
it("should recreate sourced permissions from memberships on the moved document", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const childDocument = await buildDocument({
teamId: team.id,
parentDocumentId: document.id,
});
const grandChildDocument = await buildDocument({
teamId: team.id,
parentDocumentId: childDocument.id,
});
// Add user and group directly to the document that will be moved
const sourceUserMembership = await UserMembership.create({
userId: user2.id,
documentId: document.id,
createdById: user.id,
});
const sourceGroupMembership = await GroupMembership.create({
groupId: group.id,
documentId: document.id,
createdById: user.id,
});
// Trigger move event on the document itself
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: document.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
// Direct memberships on the moved document are untouched
expect(
await UserMembership.count({ where: { documentId: document.id } })
).toBe(1);
expect(
await GroupMembership.count({ where: { documentId: document.id } })
).toBe(1);
// Children keep the permissions sourced from the moved document
for (const doc of [childDocument, grandChildDocument]) {
const userMemberships = await UserMembership.findAll({
where: { documentId: doc.id, userId: user2.id },
});
const groupMemberships = await GroupMembership.findAll({
where: { documentId: doc.id, groupId: group.id },
});
expect(userMemberships.length).toBe(1);
expect(groupMemberships.length).toBe(1);
expect(userMemberships[0].sourceId).toBe(sourceUserMembership.id);
expect(groupMemberships[0].sourceId).toBe(sourceGroupMembership.id);
}
});
it("should recreate sourced permissions from memberships on children of the moved document", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const document = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const childDocument = await buildDocument({
teamId: team.id,
parentDocumentId: document.id,
});
const grandChildDocument = await buildDocument({
teamId: team.id,
parentDocumentId: childDocument.id,
});
// Add user and group directly to a child of the document that will be moved
const sourceUserMembership = await UserMembership.create({
userId: user2.id,
documentId: childDocument.id,
createdById: user.id,
});
const sourceGroupMembership = await GroupMembership.create({
groupId: group.id,
documentId: childDocument.id,
createdById: user.id,
});
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: document.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
const userMemberships = await UserMembership.findAll({
where: { documentId: grandChildDocument.id, userId: user2.id },
});
const groupMemberships = await GroupMembership.findAll({
where: { documentId: grandChildDocument.id, groupId: group.id },
});
expect(userMemberships.length).toBe(1);
expect(groupMemberships.length).toBe(1);
expect(userMemberships[0].sourceId).toBe(sourceUserMembership.id);
expect(groupMemberships[0].sourceId).toBe(sourceGroupMembership.id);
});
it("should apply both new parent and own memberships when a document is moved into a new parent", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const user3 = await buildUser({ teamId: team.id });
const group = await buildGroup({ teamId: team.id });
const group2 = await buildGroup({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const newParentDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const document = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const childDocument = await buildDocument({
teamId: team.id,
parentDocumentId: document.id,
});
// Add user and group directly to the document that will be moved
const ownUserMembership = await UserMembership.create({
userId: user2.id,
documentId: document.id,
createdById: user.id,
});
const ownGroupMembership = await GroupMembership.create({
groupId: group.id,
documentId: document.id,
createdById: user.id,
});
// Add different user and group to the new parent document
const parentUserMembership = await UserMembership.create({
userId: user3.id,
documentId: newParentDocument.id,
createdById: user.id,
});
const parentGroupMembership = await GroupMembership.create({
groupId: group2.id,
documentId: newParentDocument.id,
createdById: user.id,
});
// Move the document into the new parent
document.parentDocumentId = newParentDocument.id;
await document.save();
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: document.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
// The moved document and its child inherit from the new parent
for (const doc of [document, childDocument]) {
const userMemberships = await UserMembership.findAll({
where: { documentId: doc.id, userId: user3.id },
});
const groupMemberships = await GroupMembership.findAll({
where: { documentId: doc.id, groupId: group2.id },
});
expect(userMemberships.length).toBe(1);
expect(groupMemberships.length).toBe(1);
expect(userMemberships[0].sourceId).toBe(parentUserMembership.id);
expect(groupMemberships[0].sourceId).toBe(parentGroupMembership.id);
}
// The child still inherits from the moved document's own memberships
const childUserMemberships = await UserMembership.findAll({
where: { documentId: childDocument.id, userId: user2.id },
});
const childGroupMemberships = await GroupMembership.findAll({
where: { documentId: childDocument.id, groupId: group.id },
});
expect(childUserMemberships.length).toBe(1);
expect(childGroupMemberships.length).toBe(1);
expect(childUserMemberships[0].sourceId).toBe(ownUserMembership.id);
expect(childGroupMemberships[0].sourceId).toBe(ownGroupMembership.id);
});
it("should not propagate sourced permissions to drafts or their children", async () => {
const team = await buildTeam();
const user = await buildAdmin({ teamId: team.id });
const user2 = await buildUser({ teamId: team.id });
const collection = await buildCollection({
userId: user.id,
teamId: team.id,
});
const topDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
});
const sourceUserMembership = await UserMembership.create({
userId: user2.id,
documentId: topDocument.id,
createdById: user.id,
});
const movedDocument = await buildDocument({
collectionId: collection.id,
teamId: team.id,
parentDocumentId: topDocument.id,
});
const publishedChild = await buildDocument({
collectionId: collection.id,
teamId: team.id,
parentDocumentId: movedDocument.id,
});
const draftChild = await buildDocument({
collectionId: collection.id,
teamId: team.id,
parentDocumentId: movedDocument.id,
publishedAt: null,
});
const childOfDraft = await buildDocument({
collectionId: collection.id,
teamId: team.id,
parentDocumentId: draftChild.id,
});
const processor = new DocumentMovedProcessor();
await processor.perform({
name: "documents.move",
documentId: movedDocument.id,
collectionId: collection.id,
teamId: team.id,
actorId: user.id,
ip,
data: {
collectionIds: [],
documentIds: [],
},
});
const memberships = await UserMembership.findAll({
where: { userId: user2.id, sourceId: sourceUserMembership.id },
});
const documentIds = memberships.map((membership) => membership.documentId);
expect(documentIds).toHaveLength(2);
expect(documentIds).toEqual(
expect.arrayContaining([movedDocument.id, publishedChild.id])
);
expect(documentIds).not.toContain(draftChild.id);
expect(documentIds).not.toContain(childOfDraft.id);
});
});