@atproto/pds 0.5.12 → 0.5.15

package/tests/db.test.ts

@@ -1,170 +0,0 @@
-import { TestNetworkNoAppView } from '@atproto/dev-env'
-// Importing from `dist` to circumvent circular dependency typing issues
-import { AccountDb } from '../dist/account-manager/db/index.js'
-
-describe('db', () => {
-  let network: TestNetworkNoAppView
-  let db: AccountDb
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'db',
-    })
-    db = network.pds.ctx.accountManager.db
-  })
-
-  afterAll(async () => {
-    await network?.close()
-  })
-
-  it('commits changes', async () => {
-    const result = await db.transaction(async (dbTxn) => {
-      return await dbTxn.db
-        .insertInto('repo_root')
-        // @ts-expect-error invalid date is intentional for testing purposes
-        .values({
-          did: 'x',
-          cid: 'x',
-          rev: 'x',
-          indexedAt: 'bad-date',
-        })
-        .returning('did')
-        .executeTakeFirst()
-    })
-
-    if (!result) {
-      return expect(result).toBeTruthy()
-    }
-
-    expect(result.did).toEqual('x')
-
-    const row = await db.db
-      .selectFrom('repo_root')
-      .selectAll()
-      .where('did', '=', 'x')
-      .executeTakeFirst()
-
-    expect(row).toEqual({
-      did: 'x',
-      cid: 'x',
-      rev: 'x',
-      indexedAt: 'bad-date',
-    })
-  })
-
-  it('rolls-back changes on failure', async () => {
-    const promise = db.transaction(async (dbTxn) => {
-      await dbTxn.db
-        .insertInto('repo_root')
-        // @ts-expect-error invalid date is intentional for testing purposes
-        .values({
-          did: 'y',
-          cid: 'y',
-          rev: 'y',
-          indexedAt: 'bad-date',
-        })
-        .returning('did')
-        .executeTakeFirst()
-
-      throw new Error('Oops!')
-    })
-
-    await expect(promise).rejects.toThrow('Oops!')
-
-    const row = await db.db
-      .selectFrom('repo_root')
-      .selectAll()
-      .where('did', '=', 'y')
-      .executeTakeFirst()
-
-    expect(row).toBeUndefined()
-  })
-
-  it('indicates isTransaction', async () => {
-    expect(db.isTransaction).toEqual(false)
-
-    await db.transaction(async (dbTxn) => {
-      expect(db.isTransaction).toEqual(false)
-      expect(dbTxn.isTransaction).toEqual(true)
-    })
-
-    expect(db.isTransaction).toEqual(false)
-  })
-
-  it('asserts transaction', async () => {
-    expect(() => db.assertTransaction()).toThrow('Transaction required')
-
-    await db.transaction(async (dbTxn) => {
-      expect(() => dbTxn.assertTransaction()).not.toThrow()
-    })
-  })
-
-  it('does not allow leaky transactions', async () => {
-    let leakedTx: AccountDb | undefined
-
-    const tx = db.transaction(async (dbTxn) => {
-      leakedTx = dbTxn
-      await dbTxn.db
-        .insertInto('repo_root')
-        // @ts-expect-error invalid date is intentional for testing purposes
-        .values({ cid: 'a', did: 'a', rev: 'a', indexedAt: 'bad-date' })
-        .execute()
-      throw new Error('test tx failed')
-    })
-    await expect(tx).rejects.toThrow('test tx failed')
-
-    const attempt = leakedTx?.db
-      .insertInto('repo_root')
-      // @ts-expect-error invalid date is intentional for testing purposes
-      .values({ cid: 'b', did: 'b', rev: 'b', indexedAt: 'bad-date' })
-      .execute()
-    await expect(attempt).rejects.toThrow('tx already failed')
-
-    const res = await db.db
-      .selectFrom('repo_root')
-      .selectAll()
-      .where('did', 'in', ['a', 'b'])
-      .execute()
-
-    expect(res.length).toBe(0)
-  })
-
-  it('ensures all inflight queries are rolled back', async () => {
-    let promise: Promise<unknown> | undefined = undefined
-    const names: string[] = []
-    try {
-      await db.transaction(async (dbTxn) => {
-        const queries: Promise<unknown>[] = []
-        for (let i = 0; i < 20; i++) {
-          const name = `user${i}`
-          const query = dbTxn.db
-            .insertInto('repo_root')
-            // @ts-expect-error invalid date is intentional for testing purposes
-            .values({
-              cid: name,
-              did: name,
-              rev: name,
-              indexedAt: 'bad-date',
-            })
-            .execute()
-          names.push(name)
-          queries.push(query)
-        }
-        promise = Promise.allSettled(queries)
-        throw new Error()
-      })
-    } catch (err) {
-      expect(err).toBeDefined()
-    }
-    if (promise) {
-      await promise
-    }
-
-    const res = await db.db
-      .selectFrom('repo_root')
-      .selectAll()
-      .where('did', 'in', names)
-      .execute()
-    expect(res.length).toBe(0)
-  })
-})

package/tests/email-confirmation.test.ts

@@ -1,227 +0,0 @@
-import { EventEmitter, once } from 'node:events'
-import { SendMailOptions } from 'nodemailer'
-import {
-  AtpAgent,
-  ComAtprotoServerConfirmEmail,
-  ComAtprotoServerUpdateEmail,
-} from '@atproto/api'
-import { SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
-import { ServerMailer } from '../src/mailer/index.js'
-import userSeed from './seeds/users.js'
-
-describe('email confirmation', () => {
-  let network: TestNetworkNoAppView
-  let agent: AtpAgent
-  let sc: SeedClient
-
-  let mailer: ServerMailer
-  const mailCatcher = new EventEmitter()
-  let _origSendMail
-
-  let alice
-
-  beforeAll(async () => {
-    network = await TestNetworkNoAppView.create({
-      dbPostgresSchema: 'email_confirmation',
-    })
-    // @ts-expect-error Error due to circular dependency with the dev-env package
-    mailer = network.pds.ctx.mailer
-    agent = network.pds.getAgent()
-    sc = network.getSeedClient()
-    await userSeed(sc)
-    alice = sc.accounts[sc.dids.alice]
-
-    // Catch emails for use in tests
-    _origSendMail = mailer.transporter.sendMail
-    mailer.transporter.sendMail = async (opts) => {
-      const result = await _origSendMail.call(mailer.transporter, opts)
-      mailCatcher.emit('mail', opts)
-      return result
-    }
-  })
-
-  afterAll(async () => {
-    mailer.transporter.sendMail = _origSendMail
-    await network?.close()
-  })
-
-  const getMailFrom = async (promise): Promise<SendMailOptions> => {
-    const result = await Promise.all([once(mailCatcher, 'mail'), promise])
-    return result[0][0]
-  }
-
-  const getTokenFromMail = (mail: SendMailOptions) =>
-    mail.html?.toString().match(/>([a-z0-9]{5}-[a-z0-9]{5})</i)?.[1]
-
-  it('starts a user out unverified', async () => {
-    const session = await agent.api.com.atproto.server.getSession(
-      {},
-      { headers: sc.getHeaders(alice.did) },
-    )
-    expect(session.data.emailConfirmed).toEqual(false)
-  })
-
-  it('allows email update without token when unverified', async () => {
-    const res = await agent.api.com.atproto.server.requestEmailUpdate(
-      undefined,
-      { headers: sc.getHeaders(alice.did) },
-    )
-    expect(res.data.tokenRequired).toBe(false)
-
-    await agent.api.com.atproto.server.updateEmail(
-      {
-        email: 'new-alice@example.com',
-      },
-      { headers: sc.getHeaders(alice.did), encoding: 'application/json' },
-    )
-    const session = await agent.api.com.atproto.server.getSession(
-      {},
-      { headers: sc.getHeaders(alice.did) },
-    )
-    expect(session.data.email).toEqual('new-alice@example.com')
-    expect(session.data.emailConfirmed).toEqual(false)
-    alice.email = session.data.email
-  })
-
-  let confirmToken
-
-  it('requests email confirmation', async () => {
-    const mail = await getMailFrom(
-      agent.api.com.atproto.server.requestEmailConfirmation(undefined, {
-        headers: sc.getHeaders(alice.did),
-      }),
-    )
-    expect(mail.to).toEqual(alice.email)
-    expect(mail.html).toContain('Confirm your email')
-    confirmToken = getTokenFromMail(mail)
-    expect(confirmToken).toBeDefined()
-  })
-
-  it('fails email confirmation with a bad token', async () => {
-    const attempt = agent.api.com.atproto.server.confirmEmail(
-      {
-        email: alice.email,
-        token: '123456',
-      },
-      { headers: sc.getHeaders(alice.did), encoding: 'application/json' },
-    )
-    await expect(attempt).rejects.toThrow(
-      ComAtprotoServerConfirmEmail.InvalidTokenError,
-    )
-  })
-
-  it('fails email confirmation with a bad token', async () => {
-    const attempt = agent.api.com.atproto.server.confirmEmail(
-      {
-        email: 'fake-alice@example.com',
-        token: confirmToken,
-      },
-      { headers: sc.getHeaders(alice.did), encoding: 'application/json' },
-    )
-    await expect(attempt).rejects.toThrow(
-      ComAtprotoServerConfirmEmail.InvalidEmailError,
-    )
-  })
-
-  it('confirms email', async () => {
-    await agent.api.com.atproto.server.confirmEmail(
-      {
-        email: alice.email,
-        token: confirmToken,
-      },
-      { headers: sc.getHeaders(alice.did), encoding: 'application/json' },
-    )
-    const session = await agent.api.com.atproto.server.getSession(
-      {},
-      { headers: sc.getHeaders(alice.did) },
-    )
-    expect(session.data.emailConfirmed).toBe(true)
-  })
-
-  it('disallows email update without token when verified', async () => {
-    const attempt = agent.api.com.atproto.server.updateEmail(
-      {
-        email: 'new-alice-2@example.com',
-      },
-      { headers: sc.getHeaders(alice.did), encoding: 'application/json' },
-    )
-    await expect(attempt).rejects.toThrow(
-      ComAtprotoServerUpdateEmail.TokenRequiredError,
-    )
-  })
-
-  let updateToken
-
-  it('requests email update', async () => {
-    const reqUpdate = async () => {
-      const res = await agent.api.com.atproto.server.requestEmailUpdate(
-        undefined,
-        {
-          headers: sc.getHeaders(alice.did),
-        },
-      )
-      expect(res.data.tokenRequired).toBe(true)
-    }
-    const mail = await getMailFrom(reqUpdate())
-    expect(mail.to).toEqual(alice.email)
-    expect(mail.html).toContain('Update your email')
-    updateToken = getTokenFromMail(mail)
-    expect(updateToken).toBeDefined()
-  })
-
-  it('fails email update with a bad token', async () => {
-    const attempt = agent.api.com.atproto.server.updateEmail(
-      {
-        email: 'new-alice-2@example.com',
-        token: '123456',
-      },
-      { headers: sc.getHeaders(alice.did), encoding: 'application/json' },
-    )
-    await expect(attempt).rejects.toThrow(
-      ComAtprotoServerUpdateEmail.InvalidTokenError,
-    )
-  })
-
-  it('fails email update with a badly formatted email', async () => {
-    const attempt = agent.api.com.atproto.server.updateEmail(
-      {
-        email: 'bad-email@disposeamail.com',
-        token: updateToken,
-      },
-      { headers: sc.getHeaders(alice.did), encoding: 'application/json' },
-    )
-    await expect(attempt).rejects.toThrow(
-      'This email address is not supported, please use a different email.',
-    )
-  })
-
-  it('fails email update with in-use email', async () => {
-    const attempt = agent.api.com.atproto.server.updateEmail(
-      {
-        email: 'bob@test.com',
-        token: updateToken,
-      },
-      { headers: sc.getHeaders(alice.did), encoding: 'application/json' },
-    )
-    await expect(attempt).rejects.toThrow(
-      'This email address is already in use, please use a different email.',
-    )
-  })
-
-  it('updates email', async () => {
-    await agent.api.com.atproto.server.updateEmail(
-      {
-        email: 'new-alice-2@example.com',
-        token: updateToken,
-      },
-      { headers: sc.getHeaders(alice.did), encoding: 'application/json' },
-    )
-
-    const session = await agent.api.com.atproto.server.getSession(
-      {},
-      { headers: sc.getHeaders(alice.did) },
-    )
-    expect(session.data.email).toBe('new-alice-2@example.com')
-    expect(session.data.emailConfirmed).toBe(false)
-  })
-})