AI-native design editor. Open-source Figma alternative.
import { describe, expect, test } from 'bun:test'
import { createCloudTestDatabase } from '#cloud-tests/helpers/database'
import { CLOUD_PROTOCOL_VERSION } from '#cloud/contract'
import {
createCloudApp,
createBetterAuthAdapter,
createEnrollmentService,
parseCloudServerConfig,
type CloudDatabase
} from '#cloud/server'
import {
DummyDriver,
Kysely,
PostgresAdapter,
PostgresIntrospector,
PostgresQueryCompiler,
type CompiledQuery,
type DatabaseConnection,
type Dialect,
type QueryResult
} from 'kysely'
function dummyPostgresDialect(): Dialect {
return {
createAdapter: () => new PostgresAdapter(),
createDriver: () => new DummyDriver(),
createIntrospector: (database) => new PostgresIntrospector(database),
createQueryCompiler: () => new PostgresQueryCompiler()
}
}
const completed = Promise.resolve()
const noOperation = () => completed
function failingPostgresDialect(): Dialect {
const dialect = dummyPostgresDialect()
return {
...dialect,
createDriver: () => ({
init: noOperation,
async acquireConnection(): Promise<DatabaseConnection> {
return {
executeQuery<R>(_query: CompiledQuery): Promise<QueryResult<R>> {
return Promise.reject(new Error('database unavailable'))
},
streamQuery<R>(): AsyncIterableIterator<QueryResult<R>> {
throw new Error('database unavailable')
}
}
},
beginTransaction: noOperation,
commitTransaction: noOperation,
rollbackTransaction: noOperation,
releaseConnection: noOperation,
destroy: noOperation
})
}
}
const config = parseCloudServerConfig({
deployment: 'self-hosted',
publicURL: 'https://pencil.example.com',
databaseURL: 'postgresql://openpencil:secret@database/openpencil',
authSecret: 'a-secure-auth-secret-with-at-least-32-characters',
googleClientId: 'google-client',
googleClientSecret: 'google-secret',
trustedOrigins: ['https://app.example.com'],
s3Endpoint: 'https://objects.example.com',
s3Region: 'us-east-1',
s3Bucket: 'openpencil',
s3AccessKeyId: 'access-key',
s3SecretAccessKey: 'secret-key'
})
function services() {
const database = new Kysely<CloudDatabase>({ dialect: dummyPostgresDialect() })
return {
config,
database,
auth: createBetterAuthAdapter(config, database),
objects: {
capabilities: {
nativeSHA256: true,
multipartUpload: false,
conditionalWrites: false
},
async checkReadiness() {
return { ok: true, checksumVerification: 'native' as const }
},
async createDownload() {
throw new Error('not used')
},
async createUpload() {
throw new Error('not used')
},
completeUpload: noOperation,
abortUpload: noOperation,
async head() {
return null
},
delete: noOperation
}
}
}
describe('createCloudApp', () => {
test('materializes enrollment from an authenticated identity and protects admin routes', async () => {
const runtime = await createCloudTestDatabase()
try {
const approvalConfig = parseCloudServerConfig({ ...config, enrollmentMode: 'approval' })
const app = createCloudApp({
...services(),
config: approvalConfig,
database: runtime.database,
auth: createBetterAuthAdapter(approvalConfig, runtime.database),
resolveIdentity: async () => ({
userId: 'pending-user',
email: '[email protected]',
name: 'Pending User'
})
})
expect((await app.request('/api/enrollment/request', { method: 'POST' })).status).toBe(401)
expect(await (await app.request('/api/account/status')).json()).toEqual({
user: {
userId: 'pending-user',
email: '[email protected]',
name: 'Pending User'
},
state: 'pending'
})
expect(
await runtime.database
.selectFrom('enrollment')
.select(['emailNormalized', 'status'])
.executeTakeFirstOrThrow()
).toEqual({ emailNormalized: '[email protected]', status: 'pending' })
expect((await app.request('/api/admin/enrollments')).status).toBe(401)
} finally {
await runtime.close()
}
})
test('requires MFA assurance only for deployment administration', async () => {
const runtime = await createCloudTestDatabase()
try {
const enforcedConfig = parseCloudServerConfig({
...config,
deploymentAdminMFARequired: true,
totpEnabled: true
})
const auth = createBetterAuthAdapter(enforcedConfig, runtime.database)
const app = createCloudApp({
...services(),
config: enforcedConfig,
database: runtime.database,
auth,
resolveSession: async () => ({
userId: 'admin-user',
email: '[email protected]',
name: 'Admin',
deploymentRole: 'admin'
})
})
expect((await app.request('/api/session')).status).toBe(200)
expect((await app.request('/api/admin/operations')).status).toBe(403)
expect(await (await app.request('/api/admin/operations')).json()).toEqual({
error: { code: 'mfa_required' }
})
} finally {
await runtime.close()
}
})
test('allows only deployment administrators to use admin routes', async () => {
const runtime = await createCloudTestDatabase()
try {
const adminApp = createCloudApp({
...services(),
database: runtime.database,
auth: createBetterAuthAdapter(config, runtime.database),
resolveSession: async () => ({
userId: 'admin-user',
email: '[email protected]',
name: 'Admin',
deploymentRole: 'admin'
})
})
const userApp = createCloudApp({
...services(),
database: runtime.database,
auth: createBetterAuthAdapter(config, runtime.database),
resolveSession: async () => ({
userId: 'ordinary-user',
email: '[email protected]',
name: 'User',
deploymentRole: 'user'
})
})
expect(
(
await userApp.request('/api/admin/operations', {
headers: { Origin: 'https://pencil.example.com' }
})
).status
).toBe(403)
expect(
(
await adminApp.request('/api/admin/enrollments/missing/approve', {
method: 'POST',
headers: {
Origin: 'https://untrusted.example.com',
'Content-Type': 'application/json'
},
body: '{}'
})
).status
).toBe(403)
const response = await adminApp.request('/api/admin/operations')
expect(response.status).toBe(200)
expect(await response.json()).toMatchObject({
enrollmentMode: 'open',
pendingEnrollment: 0
})
} finally {
await runtime.close()
}
})
test('answers malformed admin input and unknown IDs with client errors', async () => {
const runtime = await createCloudTestDatabase()
try {
const adminApp = createCloudApp({
...services(),
database: runtime.database,
auth: createBetterAuthAdapter(config, runtime.database),
resolveSession: async () => ({
userId: 'admin-user',
email: '[email protected]',
name: 'Admin',
deploymentRole: 'admin'
})
})
for (const path of [
'/api/admin/audit?limit=many',
'/api/admin/email?limit=-1',
'/api/admin/users?offset=1.5',
'/api/admin/users?offset=99999999999999999999',
'/api/admin/enrollments?filter=sideways',
'/api/admin/email?filter=bounced'
]) {
const response = await adminApp.request(path)
expect(response.status).toBe(400)
expect(await response.json()).toEqual({ error: { code: 'invalid_request' } })
}
const review = await adminApp.request(
`/api/admin/enrollments/${crypto.randomUUID()}/approve`,
{
method: 'POST',
headers: { Origin: 'https://pencil.example.com', 'Content-Type': 'application/json' },
body: '{}'
}
)
expect(review.status).toBe(404)
expect(await review.json()).toEqual({ error: { code: 'not_found' } })
} finally {
await runtime.close()
}
})
test('exposes restricted account state without authorizing product APIs', async () => {
const runtime = await createCloudTestDatabase()
try {
const approvalConfig = parseCloudServerConfig({ ...config, enrollmentMode: 'approval' })
const pendingIdentity = {
userId: 'pending-user',
email: '[email protected]',
name: 'Pending User',
deploymentRole: 'user' as const
}
const app = createCloudApp({
...services(),
config: approvalConfig,
database: runtime.database,
auth: createBetterAuthAdapter(approvalConfig, runtime.database),
resolveIdentity: async () => pendingIdentity,
resolveSession: async () => null
})
await createEnrollmentService(runtime.database).request({
email: pendingIdentity.email,
name: pendingIdentity.name
})
expect(await (await app.request('/api/account/status')).json()).toEqual({
user: pendingIdentity,
state: 'pending'
})
expect((await app.request('/api/session')).status).toBe(401)
expect((await app.request('/api/admin/enrollments')).status).toBe(401)
} finally {
await runtime.close()
}
})
test('keeps Better Auth routes outside the OpenPencil rate limiter', async () => {
const runtime = await createCloudTestDatabase()
let authCalls = 0
try {
const base = services()
const app = createCloudApp({
...base,
database: runtime.database,
auth: {
...base.auth,
async handler() {
authCalls++
return Response.json({ ok: true })
}
}
})
for (let index = 0; index < 8; index++) {
expect((await app.request('/api/auth/test', { method: 'POST' })).status).toBe(200)
}
expect(authCalls).toBe(8)
expect(
await runtime.database
.selectFrom('apiRateLimit')
.select(({ fn }) => fn.countAll<number>().as('count'))
.executeTakeFirstOrThrow()
).toEqual({ count: 0 })
} finally {
await runtime.close()
}
})
test('serves indexing policy through robots and response headers', async () => {
const denied = createCloudApp(services())
const robots = await denied.request('/robots.txt')
expect(await robots.text()).toBe('User-agent: *\nDisallow: /\n')
expect((await denied.request('/health')).headers.get('X-Robots-Tag')).toBe(
'noindex, nofollow, noarchive'
)
const allowedServices = services()
allowedServices.config = { ...allowedServices.config, indexingPolicy: 'allow' }
const allowed = createCloudApp(allowedServices)
expect(await (await allowed.request('/robots.txt')).text()).toContain('Disallow: /admin')
expect((await allowed.request('/health')).headers.get('X-Robots-Tag')).toBeNull()
expect((await allowed.request('/api/session')).headers.get('X-Robots-Tag')).toBe(
'noindex, nofollow, noarchive'
)
})
test('serves a health response without starting a listener', async () => {
const response = await createCloudApp(services()).request('/health')
expect(response.status).toBe(200)
expect(await response.json()).toEqual({
status: 'ok',
protocolVersion: CLOUD_PROTOCOL_VERSION
})
})
test('derives discovery from validated server capabilities', async () => {
const response = await createCloudApp(services()).request('/.well-known/openpencil')
expect(response.status).toBe(200)
expect(await response.json()).toEqual({
protocolVersion: CLOUD_PROTOCOL_VERSION,
deployment: 'self-hosted',
apiURL: 'https://pencil.example.com/api',
authURL: 'https://pencil.example.com/api/auth',
localEditor: true,
authentication: {
socialProviders: ['google'],
enterpriseSSO: false,
enrollmentMode: 'open'
},
capabilities: {
documents: true,
workspaces: true,
collaboration: true
}
})
})
test('allows credentialed CORS for trusted origins only', async () => {
const cloud = createCloudApp(services())
const trustedDiscovery = await cloud.request('/.well-known/openpencil', {
headers: { Origin: 'https://app.example.com' }
})
expect(trustedDiscovery.headers.get('access-control-allow-origin')).toBe(
'https://app.example.com'
)
const trusted = await createCloudApp(services()).request('/api/session', {
method: 'OPTIONS',
headers: {
Origin: 'https://app.example.com',
'Access-Control-Request-Method': 'GET',
'Access-Control-Request-Headers': 'authorization'
}
})
expect(trusted.status).toBe(204)
expect(trusted.headers.get('access-control-allow-origin')).toBe('https://app.example.com')
expect(trusted.headers.get('access-control-allow-credentials')).toBe('true')
// Editors signed in with a device code send its token as a bearer header.
expect(trusted.headers.get('access-control-allow-headers')).toContain('Authorization')
const untrusted = await createCloudApp(services()).request('/api/session', {
method: 'OPTIONS',
headers: {
Origin: 'https://malicious.example.com',
'Access-Control-Request-Method': 'GET'
}
})
expect(untrusted.headers.get('access-control-allow-origin')).toBeNull()
})
test('reports object storage capabilities when ready', async () => {
const runtime = await createCloudTestDatabase()
try {
const available = services()
available.database = runtime.database
const response = await createCloudApp(available).request('/ready')
expect(response.status).toBe(200)
expect(await response.json()).toEqual({
status: 'ready',
objectStorage: { checksumVerification: 'native', multipartUpload: false }
})
} finally {
await runtime.close()
}
})
test('reports unavailable readiness when the database cannot execute', async () => {
const unavailable = services()
unavailable.database = new Kysely<CloudDatabase>({ dialect: failingPostgresDialect() })
const response = await createCloudApp(unavailable).request('/ready')
expect(response.status).toBe(503)
expect(await response.json()).toEqual({ status: 'unavailable' })
})
test('limits guest collaboration tickets on their own budget', async () => {
const runtime = await createCloudTestDatabase()
try {
const proxied = parseCloudServerConfig({
...config,
authTrustedIPHeaders: ['x-forwarded-for']
})
const app = createCloudApp({
...services(),
config: proxied,
database: runtime.database,
auth: createBetterAuthAdapter(proxied, runtime.database)
})
const shareId = crypto.randomUUID()
const headers = { 'content-type': 'application/json', 'x-forwarded-for': '203.0.113.7' }
const ticket = await app.request(`/api/shares/${shareId}/collaboration-ticket`, {
method: 'POST',
headers,
body: JSON.stringify({ secret: 'a'.repeat(64) })
})
const share = await app.request(`/api/shares/${shareId}`, {
method: 'POST',
headers,
body: JSON.stringify({ secret: 'a'.repeat(64) })
})
expect(ticket.headers.get('ratelimit-policy')).toContain('60;w=60')
expect(share.headers.get('ratelimit-policy')).toContain('30;w=60')
} finally {
await runtime.close()
}
})
})