mirror of
https://github.com/outline/outline.git
synced 2026-11-22 22:02:35 +03:00
973 lines
34 KiB
TypeScript
973 lines
34 KiB
TypeScript
import {
|
|
CollectionPermission,
|
|
CommentingAccess,
|
|
DocumentPermission,
|
|
TeamPreference,
|
|
UserRole,
|
|
} from "@shared/types";
|
|
import { Document, UserMembership } from "@server/models";
|
|
import {
|
|
buildUser,
|
|
buildTeam,
|
|
buildDocument,
|
|
buildDraftDocument,
|
|
buildCollection,
|
|
buildAdmin,
|
|
buildPersonalCollection,
|
|
} from "@server/test/factories";
|
|
import { serialize } from "./index";
|
|
|
|
describe("read_write collection", () => {
|
|
it("should allow read write permissions for member", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: CollectionPermission.ReadWrite,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.download).toBeTruthy();
|
|
expect(abilities.update).toBeTruthy();
|
|
expect(abilities.createChildDocument).toBeTruthy();
|
|
expect(abilities.manageUsers).toEqual(false);
|
|
expect(abilities.archive).toBeTruthy();
|
|
expect(abilities.delete).toBeTruthy();
|
|
expect(abilities.share).toBeTruthy();
|
|
expect(abilities.move).toBeTruthy();
|
|
expect(abilities.comment).toBeTruthy();
|
|
});
|
|
|
|
it("should allow user management for collection admins", async () => {
|
|
const team = await buildTeam();
|
|
const admin = await buildAdmin({ teamId: team.id });
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
await collection.$add("user", user, {
|
|
through: {
|
|
permission: CollectionPermission.Admin,
|
|
createdById: admin.id,
|
|
},
|
|
});
|
|
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.update).toBeTruthy();
|
|
expect(abilities.manageUsers).toBeTruthy();
|
|
});
|
|
|
|
it("should allow user management for workspace admins with read access", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildAdmin({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: CollectionPermission.Read,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.manageUsers).toBeTruthy();
|
|
});
|
|
|
|
it("should allow read permissions for viewer", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({
|
|
teamId: team.id,
|
|
role: UserRole.Viewer,
|
|
});
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: CollectionPermission.ReadWrite,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.download).toBeTruthy();
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.manageUsers).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.delete).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toEqual(false);
|
|
expect(abilities.subscribe).toBeTruthy();
|
|
expect(abilities.unsubscribe).toBeTruthy();
|
|
expect(abilities.comment).toBeTruthy();
|
|
});
|
|
|
|
it("should allow no permissions for guest", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({
|
|
teamId: team.id,
|
|
role: UserRole.Guest,
|
|
});
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: CollectionPermission.ReadWrite,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toEqual(false);
|
|
expect(abilities.download).toEqual(false);
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.manageUsers).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.delete).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toEqual(false);
|
|
expect(abilities.subscribe).toEqual(false);
|
|
expect(abilities.unsubscribe).toEqual(false);
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
});
|
|
|
|
describe("read collection", () => {
|
|
it("should allow read permissions for team member", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: CollectionPermission.Read,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.download).toBeTruthy();
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.delete).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toEqual(false);
|
|
expect(abilities.subscribe).toBeTruthy();
|
|
expect(abilities.unsubscribe).toBeTruthy();
|
|
expect(abilities.comment).toBeTruthy();
|
|
});
|
|
|
|
it("should allow no permissions for guest", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({
|
|
teamId: team.id,
|
|
role: UserRole.Guest,
|
|
});
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: CollectionPermission.Read,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toEqual(false);
|
|
expect(abilities.download).toEqual(false);
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.manageUsers).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.delete).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toEqual(false);
|
|
expect(abilities.subscribe).toEqual(false);
|
|
expect(abilities.unsubscribe).toEqual(false);
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
});
|
|
|
|
describe("private collection", () => {
|
|
it("should allow no permissions for team member", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const document = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toEqual(false);
|
|
expect(abilities.download).toEqual(false);
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.manageUsers).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.delete).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toEqual(false);
|
|
expect(abilities.subscribe).toEqual(false);
|
|
expect(abilities.unsubscribe).toEqual(false);
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
|
|
it("should allow no permissions for guest", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({
|
|
teamId: team.id,
|
|
role: UserRole.Guest,
|
|
});
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const document = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toEqual(false);
|
|
expect(abilities.download).toEqual(false);
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.manageUsers).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.delete).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toEqual(false);
|
|
expect(abilities.subscribe).toEqual(false);
|
|
expect(abilities.unsubscribe).toEqual(false);
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
});
|
|
|
|
describe("membership ids", () => {
|
|
it("should return the collection membership that grants access", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const membership = await UserMembership.create({
|
|
collectionId: collection.id,
|
|
userId: user.id,
|
|
createdById: user.id,
|
|
permission: CollectionPermission.ReadWrite,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toEqual([membership.id]);
|
|
expect(abilities.update).toEqual([membership.id]);
|
|
});
|
|
|
|
it("should return the document membership that grants access", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
const membership = await UserMembership.create({
|
|
documentId: doc.id,
|
|
userId: user.id,
|
|
createdById: user.id,
|
|
permission: DocumentPermission.Read,
|
|
});
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toEqual([membership.id]);
|
|
});
|
|
});
|
|
|
|
describe("duplicate", () => {
|
|
it("should allow members to duplicate from a read-write collection", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: CollectionPermission.ReadWrite,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.duplicate).toBeTruthy();
|
|
});
|
|
|
|
it("should allow members to duplicate from a read-only collection", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: CollectionPermission.Read,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.duplicate).toBeTruthy();
|
|
});
|
|
|
|
it("should allow guests to duplicate documents they can update", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({
|
|
teamId: team.id,
|
|
role: UserRole.Guest,
|
|
});
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
await UserMembership.create({
|
|
documentId: doc.id,
|
|
userId: user.id,
|
|
createdById: user.id,
|
|
permission: DocumentPermission.ReadWrite,
|
|
});
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.update).toBeTruthy();
|
|
expect(abilities.duplicate).toBeTruthy();
|
|
});
|
|
|
|
it("should not allow guests to duplicate read-only documents", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({
|
|
teamId: team.id,
|
|
role: UserRole.Guest,
|
|
});
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
await UserMembership.create({
|
|
documentId: doc.id,
|
|
userId: user.id,
|
|
createdById: user.id,
|
|
permission: DocumentPermission.Read,
|
|
});
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.duplicate).toEqual(false);
|
|
});
|
|
});
|
|
|
|
describe("no collection", () => {
|
|
it("should allow no permissions for team member", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const document = await buildDraftDocument({
|
|
teamId: team.id,
|
|
});
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toEqual(false);
|
|
expect(abilities.download).toEqual(false);
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.delete).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toEqual(false);
|
|
expect(abilities.subscribe).toEqual(false);
|
|
expect(abilities.unsubscribe).toEqual(false);
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
|
|
it("should allow no permissions for guest", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({
|
|
teamId: team.id,
|
|
role: UserRole.Guest,
|
|
});
|
|
const document = await buildDraftDocument({
|
|
teamId: team.id,
|
|
});
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toEqual(false);
|
|
expect(abilities.download).toEqual(false);
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.delete).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toEqual(false);
|
|
expect(abilities.subscribe).toEqual(false);
|
|
expect(abilities.unsubscribe).toEqual(false);
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
|
|
it("should allow edit permissions for creator", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const doc = await buildDraftDocument({
|
|
teamId: team.id,
|
|
userId: user.id,
|
|
});
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.download).toBeTruthy();
|
|
expect(abilities.update).toBeTruthy();
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.delete).toBeTruthy();
|
|
expect(abilities.share).toBeTruthy();
|
|
expect(abilities.move).toBeTruthy();
|
|
expect(abilities.subscribe).toBeTruthy();
|
|
expect(abilities.unsubscribe).toBeTruthy();
|
|
expect(abilities.comment).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe("archived document", () => {
|
|
it("should have correct permissions", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
userId: user.id,
|
|
archivedAt: new Date(),
|
|
});
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.download).toBeTruthy();
|
|
expect(abilities.delete).toBeTruthy();
|
|
expect(abilities.unsubscribe).toBeTruthy();
|
|
expect(abilities.unarchive).toBeTruthy();
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.manageUsers).toBeTruthy();
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toEqual(false);
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
|
|
for (const role of [UserRole.Viewer, UserRole.Guest]) {
|
|
it(`should not allow ${role} with read_write membership to restore`, async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id, role });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const archived = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
archivedAt: new Date(),
|
|
});
|
|
const deleted = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
for (const doc of [archived, deleted]) {
|
|
await UserMembership.create({
|
|
userId: user.id,
|
|
documentId: doc.id,
|
|
permission: DocumentPermission.ReadWrite,
|
|
createdById: user.id,
|
|
});
|
|
}
|
|
await deleted.destroy();
|
|
|
|
const archivedDocument = await Document.findByPk(archived.id, {
|
|
userId: user.id,
|
|
});
|
|
const deletedDocument = await Document.findByPk(deleted.id, {
|
|
userId: user.id,
|
|
paranoid: false,
|
|
});
|
|
expect(serialize(user, archivedDocument).unarchive).toEqual(false);
|
|
expect(serialize(user, deletedDocument).restore).toEqual(false);
|
|
});
|
|
}
|
|
});
|
|
|
|
describe("read document", () => {
|
|
for (const role of Object.values(UserRole)) {
|
|
it(`should allow read permissions for ${role}`, async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
await UserMembership.create({
|
|
userId: user.id,
|
|
documentId: doc.id,
|
|
permission: DocumentPermission.Read,
|
|
createdById: user.id,
|
|
});
|
|
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.download).toBeTruthy();
|
|
expect(abilities.subscribe).toBeTruthy();
|
|
expect(abilities.unsubscribe).toBeTruthy();
|
|
expect(abilities.comment).toBeTruthy();
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.manageUsers).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.delete).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toEqual(false);
|
|
});
|
|
}
|
|
});
|
|
|
|
describe("read_write document", () => {
|
|
const nonAdminRoles = Object.values(UserRole).filter(
|
|
(role) => role !== UserRole.Admin
|
|
);
|
|
for (const role of nonAdminRoles) {
|
|
it(`should allow write permissions for ${role}`, async () => {
|
|
const team = await buildTeam();
|
|
team.setPreference(TeamPreference.Commenting, CommentingAccess.Everyone);
|
|
await team.save();
|
|
const user = await buildUser({ teamId: team.id, role });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
await UserMembership.create({
|
|
userId: user.id,
|
|
documentId: doc.id,
|
|
permission: DocumentPermission.ReadWrite,
|
|
createdById: user.id,
|
|
});
|
|
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.download).toBeTruthy();
|
|
expect(abilities.update).toBeTruthy();
|
|
expect(abilities.delete).toBeTruthy();
|
|
expect(abilities.subscribe).toBeTruthy();
|
|
expect(abilities.unsubscribe).toBeTruthy();
|
|
expect(abilities.comment).toBeTruthy();
|
|
expect(abilities.createChildDocument).toBeTruthy();
|
|
expect(abilities.manageUsers).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toBeTruthy();
|
|
});
|
|
}
|
|
|
|
it(`should allow write permissions for admin`, async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildAdmin({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
await UserMembership.create({
|
|
userId: user.id,
|
|
documentId: doc.id,
|
|
permission: DocumentPermission.ReadWrite,
|
|
createdById: user.id,
|
|
});
|
|
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.download).toBeTruthy();
|
|
expect(abilities.update).toBeTruthy();
|
|
expect(abilities.delete).toBeTruthy();
|
|
expect(abilities.subscribe).toBeTruthy();
|
|
expect(abilities.unsubscribe).toBeTruthy();
|
|
expect(abilities.comment).toBeTruthy();
|
|
expect(abilities.createChildDocument).toBeTruthy();
|
|
expect(abilities.manageUsers).toBeTruthy();
|
|
expect(abilities.archive).toBeTruthy();
|
|
expect(abilities.share).toEqual(false);
|
|
expect(abilities.move).toBeTruthy();
|
|
});
|
|
});
|
|
|
|
describe("commenting access", () => {
|
|
const buildGuestWithRead = async (commenting: CommentingAccess) => {
|
|
const team = await buildTeam();
|
|
team.setPreference(TeamPreference.Commenting, commenting);
|
|
await team.save();
|
|
const user = await buildUser({ teamId: team.id, role: UserRole.Guest });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
await UserMembership.create({
|
|
userId: user.id,
|
|
documentId: doc.id,
|
|
permission: DocumentPermission.Read,
|
|
createdById: user.id,
|
|
});
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
return { user, document };
|
|
};
|
|
|
|
it("should allow guest with read access to comment when members and guests", async () => {
|
|
const { user, document } = await buildGuestWithRead(
|
|
CommentingAccess.Everyone
|
|
);
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.comment).toBeTruthy();
|
|
// proves commenting no longer requires write access
|
|
expect(abilities.update).toEqual(false);
|
|
});
|
|
|
|
it("should not allow guest with read access to comment when members only", async () => {
|
|
const { user, document } = await buildGuestWithRead(
|
|
CommentingAccess.Members
|
|
);
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
|
|
it("should not allow guest with read access to comment when disabled", async () => {
|
|
const { user, document } = await buildGuestWithRead(CommentingAccess.None);
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
|
|
it("should not allow guest without document access to comment when members and guests", async () => {
|
|
const team = await buildTeam();
|
|
team.setPreference(TeamPreference.Commenting, CommentingAccess.Everyone);
|
|
await team.save();
|
|
const user = await buildUser({ teamId: team.id, role: UserRole.Guest });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toEqual(false);
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
|
|
it("should allow member with read access to comment when members only (default)", async () => {
|
|
const team = await buildTeam();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
await UserMembership.create({
|
|
userId: user.id,
|
|
documentId: doc.id,
|
|
permission: DocumentPermission.Read,
|
|
createdById: user.id,
|
|
});
|
|
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.comment).toBeTruthy();
|
|
});
|
|
|
|
it("should not allow member with read access to comment when disabled", async () => {
|
|
const team = await buildTeam();
|
|
team.setPreference(TeamPreference.Commenting, CommentingAccess.None);
|
|
await team.save();
|
|
const user = await buildUser({ teamId: team.id });
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
await UserMembership.create({
|
|
userId: user.id,
|
|
documentId: doc.id,
|
|
permission: DocumentPermission.Read,
|
|
createdById: user.id,
|
|
});
|
|
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.comment).toEqual(false);
|
|
});
|
|
});
|
|
|
|
describe("manage document", () => {
|
|
for (const role of Object.values(UserRole)) {
|
|
it(`should allow write permissions, user management, and sub-document creation for ${role}`, async () => {
|
|
const team = await buildTeam();
|
|
team.setPreference(TeamPreference.Commenting, CommentingAccess.Everyone);
|
|
await team.save();
|
|
const user = await buildUser({
|
|
teamId: team.id,
|
|
role,
|
|
});
|
|
const collection = await buildCollection({
|
|
teamId: team.id,
|
|
permission: null,
|
|
});
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
collectionId: collection.id,
|
|
});
|
|
await UserMembership.create({
|
|
userId: user.id,
|
|
documentId: doc.id,
|
|
permission: DocumentPermission.Admin,
|
|
createdById: user.id,
|
|
});
|
|
|
|
// reload to get membership
|
|
const document = await Document.findByPk(doc.id, { userId: user.id });
|
|
const abilities = serialize(user, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.download).toBeTruthy();
|
|
expect(abilities.update).toBeTruthy();
|
|
expect(abilities.delete).toBeTruthy();
|
|
expect(abilities.subscribe).toBeTruthy();
|
|
expect(abilities.unsubscribe).toBeTruthy();
|
|
expect(abilities.comment).toBeTruthy();
|
|
expect(abilities.createChildDocument).toBeTruthy();
|
|
expect(abilities.manageUsers).toBeTruthy();
|
|
expect(abilities.archive).toBeTruthy();
|
|
expect(abilities.move).toBeTruthy();
|
|
expect(abilities.share).toEqual(false);
|
|
});
|
|
}
|
|
});
|
|
|
|
describe("personal collection", () => {
|
|
const buildPersonal = async () => {
|
|
const team = await buildTeam();
|
|
team.setPreference(TeamPreference.PersonalDocs, true);
|
|
await team.save();
|
|
const owner = await buildUser({ teamId: team.id });
|
|
owner.team = team;
|
|
const collection = await buildPersonalCollection(owner);
|
|
const doc = await buildDocument({
|
|
teamId: team.id,
|
|
userId: owner.id,
|
|
collectionId: collection.id,
|
|
});
|
|
return { team, owner, collection, doc };
|
|
};
|
|
|
|
it("should allow the owner full access", async () => {
|
|
const { owner, doc } = await buildPersonal();
|
|
const document = await Document.findByPk(doc.id, { userId: owner.id });
|
|
const abilities = serialize(owner, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.update).toBeTruthy();
|
|
expect(abilities.move).toBeTruthy();
|
|
expect(abilities.archive).toBeTruthy();
|
|
expect(abilities.delete).toBeTruthy();
|
|
expect(abilities.share).toBeTruthy();
|
|
expect(abilities.manageUsers).toBeTruthy();
|
|
expect(abilities.unpublish).toEqual(false);
|
|
expect(abilities.updateInsights).toEqual(false);
|
|
expect(abilities.pin).toEqual(false);
|
|
expect(abilities.unpin).toEqual(false);
|
|
expect(abilities.pinToHome).toEqual(false);
|
|
});
|
|
|
|
it("should allow nothing for a workspace admin", async () => {
|
|
const { team, doc } = await buildPersonal();
|
|
const admin = await buildAdmin({ teamId: team.id });
|
|
const document = await Document.findByPk(doc.id, { userId: admin.id });
|
|
const abilities = serialize(admin, document);
|
|
for (const [ability, value] of Object.entries(abilities)) {
|
|
expect({ ability, value }).toEqual({ ability, value: false });
|
|
}
|
|
});
|
|
|
|
it("should not allow a workspace admin to permanently delete", async () => {
|
|
const { team, owner, doc } = await buildPersonal();
|
|
const admin = await buildAdmin({ teamId: team.id });
|
|
await doc.destroy({ hooks: false });
|
|
const ownerDocument = await Document.findByPk(doc.id, {
|
|
userId: owner.id,
|
|
paranoid: false,
|
|
});
|
|
const adminDocument = await Document.findByPk(doc.id, {
|
|
userId: admin.id,
|
|
paranoid: false,
|
|
});
|
|
expect(serialize(admin, adminDocument).permanentDelete).toEqual(false);
|
|
expect(serialize(owner, ownerDocument).restore).toBeTruthy();
|
|
});
|
|
|
|
it("should allow a collaborator through a document membership", async () => {
|
|
const { team, owner, doc } = await buildPersonal();
|
|
const collaborator = await buildUser({ teamId: team.id });
|
|
collaborator.team = team;
|
|
await UserMembership.create({
|
|
documentId: doc.id,
|
|
userId: collaborator.id,
|
|
permission: DocumentPermission.ReadWrite,
|
|
createdById: owner.id,
|
|
});
|
|
const document = await Document.findByPk(doc.id, {
|
|
userId: collaborator.id,
|
|
});
|
|
const abilities = serialize(collaborator, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.update).toBeTruthy();
|
|
expect(abilities.manageUsers).toEqual(false);
|
|
});
|
|
|
|
for (const permission of [
|
|
DocumentPermission.Read,
|
|
DocumentPermission.ReadWrite,
|
|
]) {
|
|
it(`should not allow a workspace admin with ${permission} membership to manage users`, async () => {
|
|
const { team, owner, doc } = await buildPersonal();
|
|
const admin = await buildAdmin({ teamId: team.id });
|
|
admin.team = team;
|
|
await UserMembership.create({
|
|
documentId: doc.id,
|
|
userId: admin.id,
|
|
permission,
|
|
createdById: owner.id,
|
|
});
|
|
const document = await Document.findByPk(doc.id, { userId: admin.id });
|
|
const abilities = serialize(admin, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.manageUsers).toEqual(false);
|
|
expect(abilities.archive).toEqual(false);
|
|
});
|
|
}
|
|
|
|
it("should allow a workspace admin with admin membership to manage users", async () => {
|
|
const { team, owner, doc } = await buildPersonal();
|
|
const admin = await buildAdmin({ teamId: team.id });
|
|
admin.team = team;
|
|
await UserMembership.create({
|
|
documentId: doc.id,
|
|
userId: admin.id,
|
|
permission: DocumentPermission.Admin,
|
|
createdById: owner.id,
|
|
});
|
|
const document = await Document.findByPk(doc.id, { userId: admin.id });
|
|
expect(serialize(admin, document).manageUsers).toBeTruthy();
|
|
});
|
|
|
|
it("should be read-only when personal documents are turned off", async () => {
|
|
const { team, owner, doc } = await buildPersonal();
|
|
const collaborator = await buildUser({ teamId: team.id });
|
|
await UserMembership.create({
|
|
documentId: doc.id,
|
|
userId: collaborator.id,
|
|
permission: DocumentPermission.ReadWrite,
|
|
createdById: owner.id,
|
|
});
|
|
team.setPreference(TeamPreference.PersonalDocs, false);
|
|
await team.save();
|
|
owner.team = team;
|
|
collaborator.team = team;
|
|
|
|
const document = await Document.findByPk(doc.id, { userId: owner.id });
|
|
const abilities = serialize(owner, document);
|
|
expect(abilities.read).toBeTruthy();
|
|
expect(abilities.update).toEqual(false);
|
|
expect(abilities.createChildDocument).toEqual(false);
|
|
expect(abilities.move).toBeTruthy();
|
|
expect(abilities.archive).toBeTruthy();
|
|
expect(abilities.delete).toBeTruthy();
|
|
|
|
const collaboratorDocument = await Document.findByPk(doc.id, {
|
|
userId: collaborator.id,
|
|
});
|
|
const collaboratorAbilities = serialize(collaborator, collaboratorDocument);
|
|
expect(collaboratorAbilities.read).toBeTruthy();
|
|
expect(collaboratorAbilities.update).toEqual(false);
|
|
expect(collaboratorAbilities.move).toEqual(false);
|
|
});
|
|
});
|