TaskView is a self-hosted project and task management platform focused on clarity, ownership, and control. TaskView is built for teams that want a transparent, self-hosted alternative to SaaS task managers.
TypeScript graphviewkanban-boardnodejsproductivityproject-managementself-hostedtasktask-managementtask-managertodoapp
import type { TvApi } from '@/tv'
import { describe, it, expect, beforeAll, afterAll } from 'vitest'
import { initApi } from './init-api'
import { openTestDb } from './test-db'
import { createSessionUser } from './auth-test-helpers'
import type { AuthTestContext } from './auth-test-helpers.types'
import { clientFor } from './start-test-helpers'
import { createWebhookReceiver } from './webhook-receiver'
import type {
AddMemberArgs,
MemberTokenArgs,
WebhooksMember,
WebhooksPermissionsFixture,
} from './webhooks-permissions.test.types'
/**
* Webhooks are governed by two independent project permissions: webhooks_can_view
* lists the webhooks and their delivery history, webhooks_can_manage changes them —
* managing does not include viewing. Both work for any project member whose role
* grants them, not only for the owner, and a token narrows them like everywhere else. Every write is verified through the
* owner session, not only by the status code.
*/
const ctx = {} as AuthTestContext
const fx = {} as WebhooksPermissionsFixture
const receiver = createWebhookReceiver()
const tokenIds: { member: WebhooksMember; id: number }[] = []
let permissionIds: Record<string, number> = {}
const statusOf = async (call: Promise<unknown>) =>
call.then(() => 200).catch((err) => err.status ?? err.response?.status)
async function freshUser(prefix: string): Promise<WebhooksMember> {
const user = await createSessionUser({ ctx, prefix })
return { user, api: clientFor(user.access) }
}
async function addMember(member: WebhooksMember, args: AddMemberArgs): Promise<void> {
const collab = await fx.owner.api.collaboration.inviteUserToGoal({ goalId: args.goalId, email: member.user.email })
const role = await fx.owner.api.collaboration.createRoleForGoal({
goalId: args.goalId,
roleName: `webhooks-${Date.now()}-${Math.random()}`,
})
for (const name of args.permissions) {
const permissionId = permissionIds[name]
if (!permissionId) throw new Error(`Permission ${name} is not in the catalogue`)
const toggled = await fx.owner.api.collaboration.toggleRolePermission({ roleId: role!.id, permissionId })
expect(toggled!.add).toBe(true)
}
await fx.owner.api.collaboration.toggleUserRoles({ goalId: args.goalId, userId: collab!.id, roles: [role!.id] })
}
async function memberToken(args: MemberTokenArgs): Promise<TvApi> {
const created = await args.member.api.apiTokens.create({
name: `webhooks-perm-${Date.now()}-${Math.random()}`,
allowedPermissions: args.allowedPermissions,
allowedGoalIds: args.allowedGoalIds,
})
tokenIds.push({ member: args.member, id: created!.item.id })
return clientFor(created!.token)
}
async function ownerWebhooks(goalId: number) {
return (await fx.owner.api.webhooks.fetch(goalId))!
}
beforeAll(async () => {
const init = await initApi()
ctx.ownerApi = init.$tvApi
ctx.db = await openTestDb()
const org = await ctx.ownerApi.organizations.create({ name: `Webhooks permissions org ${Date.now()}` })
ctx.orgId = org.id
await receiver.start()
fx.owner = await freshUser('whown')
fx.viewer = await freshUser('whview')
fx.manager = await freshUser('whman')
fx.member = await freshUser('whmem')
fx.fullManager = await freshUser('whfull')
const catalogue = await fx.owner.api.collaboration.fetchAllPermissions()
permissionIds = Object.fromEntries(catalogue!.map((p) => [p.name, p.id]))
const goal = await fx.owner.api.goals.createGoal({ name: `webhooks-permissions-${Date.now()}` })
fx.goalId = goal!.id!
const privateGoal = await fx.owner.api.goals.createGoal({ name: `webhooks-private-${Date.now()}` })
fx.privateGoalId = privateGoal!.id!
fx.webhookUrl = receiver.getUrl()
const hook = await fx.owner.api.webhooks.create({ goalId: fx.goalId, url: fx.webhookUrl, events: ['task.created'] })
fx.webhookId = hook!.webhook.id
const privateHook = await fx.owner.api.webhooks.create({ goalId: fx.privateGoalId, url: fx.webhookUrl, events: ['task.created'] })
fx.privateWebhookId = privateHook!.webhook.id
await fx.owner.api.tasks.createTask({ goalId: fx.goalId, description: `webhooks-permissions-task-${Date.now()}` })
await receiver.waitForDelivery('task.created', 5000)
const deliveries = await fx.owner.api.webhooks.fetchDeliveries(fx.webhookId)
fx.deliveryId = deliveries![0].id
await addMember(fx.viewer, { goalId: fx.goalId, permissions: ['goal_can_watch_content', 'webhooks_can_view'] })
await addMember(fx.manager, { goalId: fx.goalId, permissions: ['goal_can_watch_content', 'webhooks_can_manage'] })
await addMember(fx.member, { goalId: fx.goalId, permissions: ['goal_can_watch_content'] })
await addMember(fx.fullManager, { goalId: fx.goalId, permissions: ['goal_can_watch_content', 'webhooks_can_view', 'webhooks_can_manage'] })
}, 30000)
afterAll(async () => {
for (const token of tokenIds) {
await token.member.api.apiTokens.delete(token.id).catch(() => {})
}
for (const goalId of [fx.goalId, fx.privateGoalId]) {
if (goalId) await fx.owner.api.goals.deleteGoal(goalId).catch(() => {})
}
await ctx.ownerApi.organizations.delete(ctx.orgId).catch(() => {})
await ctx.db.end()
await receiver.stop()
})
describe('permission catalogue', () => {
it('offers webhooks_can_view and webhooks_can_manage in a webhooks group of their own', async () => {
const catalogue = await fx.owner.api.collaboration.fetchAllPermissions()
const view = catalogue!.find((p) => p.name === 'webhooks_can_view')
const manage = catalogue!.find((p) => p.name === 'webhooks_can_manage')
expect(view?.permissionGroup).toBe(9)
expect(manage?.permissionGroup).toBe(9)
})
it('carries localized descriptions for webhooks_can_view', async () => {
const catalogue = await fx.owner.api.apiTokens.fetchPermissions()
const view = catalogue!.find((p) => p.name === 'webhooks_can_view')
expect(view?.descriptionLocales?.en).toBeTruthy()
expect(view?.descriptionLocales?.ru).toBeTruthy()
})
it('grants both to the project owner', async () => {
const goal = (await fx.owner.api.goals.fetchGoals())!.find((g) => g.id === fx.goalId)
expect(goal!.permissions.webhooks_can_view).toBe(true)
expect(goal!.permissions.webhooks_can_manage).toBe(true)
})
})
describe('member with webhooks_can_view', () => {
it('lists the webhooks of the project with the full URL', async () => {
const hooks = await fx.viewer.api.webhooks.fetch(fx.goalId)
expect(hooks!.find((h) => h.id === fx.webhookId)?.url).toBe(fx.webhookUrl)
})
it('reads the delivery history with payloads', async () => {
const deliveries = await fx.viewer.api.webhooks.fetchDeliveries(fx.webhookId)
const delivery = deliveries!.find((d) => d.id === fx.deliveryId)
expect(delivery?.event).toBe('task.created')
expect(delivery?.payload).toBeTruthy()
})
it('cannot create a webhook', async () => {
const before = (await ownerWebhooks(fx.goalId)).map((h) => h.id)
const status = await statusOf(fx.viewer.api.webhooks.create({
goalId: fx.goalId,
url: `https://viewer.test/${Date.now()}`,
events: ['task.created'],
}))
expect(status).toBe(403)
expect((await ownerWebhooks(fx.goalId)).map((h) => h.id)).toEqual(before)
})
it('cannot update, rotate, test or delete a webhook, or retry a delivery', async () => {
const results = await Promise.all([
statusOf(fx.viewer.api.webhooks.update({ id: fx.webhookId, url: `https://viewer.test/${Date.now()}` })),
statusOf(fx.viewer.api.webhooks.rotateSecret(fx.webhookId)),
statusOf(fx.viewer.api.webhooks.testDelivery(fx.webhookId)),
statusOf(fx.viewer.api.webhooks.retryDelivery(fx.deliveryId)),
statusOf(fx.viewer.api.webhooks.delete({ id: fx.webhookId })),
])
expect(results).toEqual([403, 403, 403, 403, 403])
const hook = (await ownerWebhooks(fx.goalId)).find((h) => h.id === fx.webhookId)
expect(hook!.url).toBe(fx.webhookUrl)
})
})
describe('member with webhooks_can_manage', () => {
it('cannot list webhooks or read deliveries without webhooks_can_view', async () => {
const results = await Promise.all([
statusOf(fx.manager.api.webhooks.fetch(fx.goalId)),
statusOf(fx.manager.api.webhooks.fetchDeliveries(fx.webhookId)),
])
expect(results).toEqual([403, 403])
})
it('creates, updates, rotates, tests and deletes a webhook', async () => {
const created = await fx.manager.api.webhooks.create({
goalId: fx.goalId,
url: `https://manager.test/${Date.now()}`,
events: ['task.created'],
})
const id = created!.webhook.id
const newUrl = `https://manager.test/renamed-${Date.now()}`
await fx.manager.api.webhooks.update({ id, url: newUrl })
const rotated = await fx.manager.api.webhooks.rotateSecret(id)
const testStatus = await statusOf(fx.manager.api.webhooks.testDelivery(id))
expect((await ownerWebhooks(fx.goalId)).find((h) => h.id === id)?.url).toBe(newUrl)
expect(rotated!.secret).toBeTruthy()
expect(testStatus).toBe(200)
await fx.manager.api.webhooks.delete({ id })
expect((await ownerWebhooks(fx.goalId)).map((h) => h.id)).not.toContain(id)
})
it('retries a delivery of the project', async () => {
const status = await statusOf(fx.manager.api.webhooks.retryDelivery(fx.deliveryId))
expect(status).toBe(200)
})
it('cannot touch a webhook of a project it is not a member of', async () => {
const results = await Promise.all([
statusOf(fx.manager.api.webhooks.fetch(fx.privateGoalId)),
statusOf(fx.manager.api.webhooks.fetchDeliveries(fx.privateWebhookId)),
statusOf(fx.manager.api.webhooks.update({ id: fx.privateWebhookId, url: `https://manager.test/${Date.now()}` })),
statusOf(fx.manager.api.webhooks.delete({ id: fx.privateWebhookId })),
])
expect(results).toEqual([403, 403, 403, 403])
expect((await ownerWebhooks(fx.privateGoalId)).map((h) => h.id)).toContain(fx.privateWebhookId)
})
})
describe('member with both webhooks_can_view and webhooks_can_manage', () => {
it('lists webhooks, reads deliveries and creates a webhook', async () => {
const hooks = await fx.fullManager.api.webhooks.fetch(fx.goalId)
const deliveries = await fx.fullManager.api.webhooks.fetchDeliveries(fx.webhookId)
const created = await fx.fullManager.api.webhooks.create({
goalId: fx.goalId,
url: `https://full.test/${Date.now()}`,
events: ['task.created'],
})
expect(hooks!.map((h) => h.id)).toContain(fx.webhookId)
expect(deliveries!.map((d) => d.id)).toContain(fx.deliveryId)
expect((await ownerWebhooks(fx.goalId)).map((h) => h.id)).toContain(created!.webhook.id)
await fx.fullManager.api.webhooks.delete({ id: created!.webhook.id })
})
})
describe('member without webhook permissions', () => {
it('cannot list webhooks or read deliveries', async () => {
const results = await Promise.all([
statusOf(fx.member.api.webhooks.fetch(fx.goalId)),
statusOf(fx.member.api.webhooks.fetchDeliveries(fx.webhookId)),
])
expect(results).toEqual([403, 403])
})
it('cannot create a webhook or retry a delivery', async () => {
const results = await Promise.all([
statusOf(fx.member.api.webhooks.create({
goalId: fx.goalId,
url: `https://member.test/${Date.now()}`,
events: ['task.created'],
})),
statusOf(fx.member.api.webhooks.retryDelivery(fx.deliveryId)),
])
expect(results).toEqual([403, 403])
})
})
describe('owner', () => {
it('retries a delivery of its own webhook', async () => {
const status = await statusOf(fx.owner.api.webhooks.retryDelivery(fx.deliveryId))
expect(status).toBe(200)
})
it('cannot retry a delivery id of another project through its own webhook', async () => {
const outsider = await freshUser('whout')
const outsiderGoal = await outsider.api.goals.createGoal({ name: `webhooks-outsider-${Date.now()}` })
await outsider.api.webhooks.create({ goalId: outsiderGoal!.id!, url: `https://outsider.test/${Date.now()}`, events: ['task.created'] })
const status = await statusOf(outsider.api.webhooks.retryDelivery(fx.deliveryId))
expect(status).toBe(403)
await outsider.api.goals.deleteGoal(outsiderGoal!.id!).catch(() => {})
})
})
describe('tokens narrow webhook permissions', () => {
it('an owner token holding only webhooks_can_view lists but cannot create', async () => {
const client = await memberToken({ member: fx.owner, allowedPermissions: ['webhooks_can_view'], allowedGoalIds: [fx.goalId] })
const fetchStatus = await statusOf(client.webhooks.fetch(fx.goalId))
const createStatus = await statusOf(client.webhooks.create({
goalId: fx.goalId,
url: `https://token.test/${Date.now()}`,
events: ['task.created'],
}))
expect(fetchStatus).toBe(200)
expect(createStatus).toBe(403)
})
it('a viewer token asking for webhooks_can_manage still cannot create', async () => {
const client = await memberToken({ member: fx.viewer, allowedPermissions: ['webhooks_can_manage'], allowedGoalIds: [fx.goalId] })
const status = await statusOf(client.webhooks.create({
goalId: fx.goalId,
url: `https://token.test/${Date.now()}`,
events: ['task.created'],
}))
expect(status).toBe(403)
})
})