@atproto/pds 0.4.104 → 0.4.105

package/tests/oauth.test.ts

@@ -1,33 +1,99 @@
 import assert from 'node:assert'
 import { once } from 'node:events'
-import { Server, createServer } from 'node:http'
+import {
+  IncomingMessage,
+  Server,
+  ServerResponse,
+  createServer,
+} from 'node:http'
 import { AddressInfo } from 'node:net'
-import { Browser, Page, launch } from 'puppeteer'
+import { type Browser, type Page, launch } from 'puppeteer'
 import { TestNetworkNoAppView } from '@atproto/dev-env'
 // @ts-expect-error (json file)
 import files from '@atproto/oauth-client-browser-example'
 
-const getVisibleElement = async (page: Page, selector: string) => {
-  const elementHandle = await page.waitForSelector(selector)
+class PageHelper implements AsyncDisposable {
+  constructor(protected readonly page: Page) {}
 
-  expect(elementHandle).not.toBeNull()
-  assert(elementHandle)
+  async goto(url: string) {
+    await this.page.goto(url)
+  }
 
-  await expect(elementHandle.isVisible()).resolves.toBe(true)
+  async waitForNetworkIdle() {
+    await this.page.waitForNetworkIdle()
+  }
 
-  return elementHandle
+  async navigationAction(run: () => Promise<unknown>): Promise<void> {
+    const promise = this.page.waitForNavigation()
+    await run()
+    await promise
+    await this.waitForNetworkIdle()
+  }
+
+  async checkTitle(expected: string) {
+    await this.waitForNetworkIdle()
+    await expect(this.page.title()).resolves.toBe(expected)
+  }
+
+  async clickOn(selector: string) {
+    const elementHandle = await this.getVisibleElement(selector)
+    await elementHandle.click()
+    return elementHandle
+  }
+
+  async clickOnButton(text: string) {
+    return this.clickOn(`button::-p-text(${text})`)
+  }
+
+  async typeIn(selector: string, text: string) {
+    const elementHandle = await this.getVisibleElement(selector)
+    elementHandle.focus()
+    await elementHandle.type(text)
+    return elementHandle
+  }
+
+  async typeInInput(name: string, text: string) {
+    return this.typeIn(`input[name="${name}"]`, text)
+  }
+
+  async ensureTextVisibility(text: string, tag = 'p') {
+    await this.page.waitForSelector(`${tag}::-p-text(${text})`)
+  }
+
+  protected async getVisibleElement(selector: string) {
+    const elementHandle = await this.page.waitForSelector(selector)
+
+    expect(elementHandle).not.toBeNull()
+    assert(elementHandle)
+
+    await expect(elementHandle.isVisible()).resolves.toBe(true)
+
+    return elementHandle
+  }
+
+  async [Symbol.asyncDispose]() {
+    return this.page.close()
+  }
+
+  static async from(browser: Browser) {
+    const page = await browser.newPage()
+    return new PageHelper(page)
+  }
 }
 
 describe('oauth', () => {
   let browser: Browser
   let network: TestNetworkNoAppView
-  let server: Server
+  let client: Server
 
   let appUrl: string
 
   beforeAll(async () => {
     browser = await launch({
       browser: 'chrome',
+      // @NOTE We are using another language than "en" as default language to
+      // test the language negotiation.
+      args: ['--accept-lang=fr-BE,en-GB,en'],
 
       // For debugging:
       // headless: false,
@@ -47,106 +113,255 @@ describe('oauth', () => {
       password: 'alice-pass',
     })
 
-    server = await createClientServer()
+    client = createServer(clientHandler)
+    client.listen(0)
+    await once(client, 'listening')
 
-    const { port } = server.address() as AddressInfo
+    const { port } = client.address() as AddressInfo
 
     appUrl = `http://127.0.0.1:${port}?${new URLSearchParams({
       plc_directory_url: network.plc.url,
       handle_resolver: network.pds.url,
+      sign_up_url: network.pds.url,
       env: 'test',
     })}`
   })
 
   afterAll(async () => {
-    await server?.close()
+    await client?.close()
     await network?.close()
     await browser?.close()
   })
 
-  it('starts', async () => {
-    const page = await browser.newPage()
+  it('Allows to sign-up trough OAuth', async () => {
+    const page = await PageHelper.from(browser)
 
     await page.goto(appUrl)
 
-    await expect(page.title()).resolves.toBe('OAuth Client Example')
+    await page.checkTitle('OAuth Client Example')
 
-    const handleInput = await getVisibleElement(
-      page,
-      'input[placeholder="@handle, DID or PDS url"]',
-    )
+    await page.navigationAction(async () => {
+      await page.clickOnButton('Sign up')
+    })
 
-    await handleInput.focus()
+    await page.checkTitle('Authentification')
 
-    await handleInput.type('alice.test')
+    await page.clickOnButton('Créer un nouveau compte')
 
-    await Promise.all([
-      //
-      handleInput.press('Enter'),
-      page.waitForNavigation(),
-    ])
+    await page.typeInInput('handle', 'bob')
 
-    await expect(page.title()).resolves.toBe('Authorize')
+    await page.clickOnButton('Suivant')
 
-    const passwordInput = await getVisibleElement(
-      page,
-      'input[type="password"]',
-    )
+    await page.typeInInput('email', 'bob@test.com')
+    await page.typeInInput('password', 'bob-pass')
 
-    await passwordInput.focus()
+    await page.clickOnButton("S'inscrire")
 
-    // Make sure the warning is visible
-    await getVisibleElement(page, 'p::-p-text(Warning)')
+    // Make sure the new account is propagated to the PLC directory, allowing
+    // the client to resolve the account's did
+    await network.processAll()
 
-    await passwordInput.type('alice-pass')
+    await page.navigationAction(async () => {
+      await page.clickOnButton("Authoriser l'accès")
+    })
 
-    const rememberCheckbox = await getVisibleElement(
-      page,
-      'label::-p-text(Remember this account on this device)',
-    )
+    await page.checkTitle('OAuth Client Example')
+
+    await page.ensureTextVisibility('Logged in!')
+
+    await page.clickOnButton('Sign-out')
+
+    await page.waitForNetworkIdle()
+
+    // TODO: Find out why we can't use "using" here
+    await page[Symbol.asyncDispose]()
+  })
+
+  it('allows resetting the password', async () => {
+    const sendTemplateMock = await withMokedMailer(network)
+
+    const page = await PageHelper.from(browser)
+
+    await page.goto(appUrl)
+
+    await page.checkTitle('OAuth Client Example')
+
+    await page.navigationAction(async () => {
+      const input = await page.typeIn(
+        'input[placeholder="@handle, DID or PDS url"]',
+        'alice.test',
+      )
+
+      await input.press('Enter')
+    })
+
+    await page.checkTitle('Se connecter')
+
+    await page.clickOnButton('Oublié ?')
+
+    await page.checkTitle('Mot de passe oublié')
+
+    await page.typeInInput('email', 'alice@test.com')
+
+    expect(sendTemplateMock).toHaveBeenCalledTimes(0)
+
+    await page.clickOnButton('Suivant')
+
+    await page.checkTitle('Réinitialiser le mot de passe')
+
+    expect(sendTemplateMock).toHaveBeenCalledTimes(1)
+
+    const [templateName, params] = sendTemplateMock.mock.calls[0]
+
+    expect(templateName).toBe('resetPassword')
+    expect(params).toEqual({
+      handle: 'alice.test',
+      token: expect.any(String),
+    })
+
+    const { token } = params as { token: string }
+
+    await page.typeInInput('code', token)
+
+    await page.typeInInput('password', 'alice-new-pass')
+
+    await page.clickOnButton('Suivant')
+
+    await page.checkTitle('Mot de passe mis à jour')
+
+    await page.ensureTextVisibility('Mot de passe mis à jour !', 'h2')
+
+    // TODO: Find out why we can't use "using" here
+    await page[Symbol.asyncDispose]()
+
+    // TODO: Find out why we can't use "using" here
+    sendTemplateMock[Symbol.dispose]()
+  })
 
-    await rememberCheckbox.click()
+  it('Allows to sign-in trough OAuth', async () => {
+    const page = await PageHelper.from(browser)
 
-    const nextButton = await getVisibleElement(page, 'button::-p-text(Next)')
+    await page.goto(appUrl)
+
+    await page.checkTitle('OAuth Client Example')
+
+    await page.navigationAction(async () => {
+      const input = await page.typeIn(
+        'input[placeholder="@handle, DID or PDS url"]',
+        'alice.test',
+      )
+
+      await input.press('Enter')
+    })
+
+    await page.checkTitle('Se connecter')
 
-    await nextButton.click()
+    await page.typeIn('input[type="password"]', 'alice-new-pass')
 
-    const acceptButton = await getVisibleElement(
-      page,
-      'button::-p-text(Accept)',
+    // Make sure the warning is visible
+    await page.ensureTextVisibility('Avertissement')
+
+    await page.clickOn(
+      'label::-p-text(Se souvenir de ce compte sur cet appareil)',
     )
 
-    await Promise.all([
-      //
-      acceptButton.click(),
-      page.waitForNavigation(),
-    ])
+    await page.clickOnButton('Se connecter')
+
+    await page.checkTitle("Authoriser l'accès")
+
+    await page.navigationAction(async () => {
+      await page.clickOnButton("Authoriser l'accès")
+    })
+
+    await page.checkTitle('OAuth Client Example')
+
+    await page.ensureTextVisibility('Logged in!')
 
-    await expect(page.title()).resolves.toBe('OAuth Client Example')
+    await page.clickOnButton('Sign-out')
 
-    // Check that the "Logged in!" message is visible
-    await getVisibleElement(page, 'p::-p-text(Logged in!)')
+    await page.waitForNetworkIdle()
+
+    // TODO: Find out why we can't use "using" here
+    await page[Symbol.asyncDispose]()
   })
-})
 
-async function createClientServer() {
-  const server = createServer((req, res) => {
-    const path = req.url?.split('?')[0].slice(1) || 'index.html'
-    const file = Object.hasOwn(files, path) ? files[path] : null
-
-    if (file) {
-      res
-        .writeHead(200, 'OK', { 'content-type': file.type })
-        .end(Buffer.from(file.data, 'base64'))
-    } else {
-      res
-        .writeHead(404, 'Not Found', { 'content-type': 'text/plain' })
-        .end('Page not found')
-    }
+  it('remembers the session', async () => {
+    const page = await PageHelper.from(browser)
+
+    await page.goto(appUrl)
+
+    await page.checkTitle('OAuth Client Example')
+
+    await page.navigationAction(async () => {
+      const input = await page.typeIn(
+        'input[placeholder="@handle, DID or PDS url"]',
+        'alice.test',
+      )
+
+      await input.press('Enter')
+    })
+
+    await page.checkTitle("Authoriser l'accès")
+
+    await page.navigationAction(async () => {
+      await page.clickOnButton("Authoriser l'accès")
+    })
+
+    await page.checkTitle('OAuth Client Example')
+
+    await page.ensureTextVisibility('Logged in!')
+
+    await page.clickOnButton('Sign-out')
+
+    await page.waitForNetworkIdle()
+
+    // TODO: Find out why we can't use "using" here
+    await page[Symbol.asyncDispose]()
   })
+})
 
-  server.listen(0)
-  await once(server, 'listening')
+async function withMokedMailer(network: TestNetworkNoAppView) {
+  // @ts-expect-error
+  const sendTemplateOrig = network.pds.ctx.mailer.sendTemplate
+  const sendTemplateMock = jest.fn(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async (templateName: unknown, params: unknown, mailOpts: unknown) => {
+      //
+    },
+  ) as jest.Mock<
+    Promise<void>,
+    [templateName: unknown, params: unknown, mailOpts: unknown]
+  > &
+    Disposable
+
+  sendTemplateMock[Symbol.dispose] = () => {
+    // @ts-expect-error
+    network.pds.ctx.mailer.sendTemplate = sendTemplateOrig
+  }
+
+  // @ts-expect-error
+  network.pds.ctx.mailer.sendTemplate = sendTemplateMock
+
+  return sendTemplateMock
+}
 
-  return server
+function clientHandler(
+  req: IncomingMessage,
+  res: ServerResponse,
+  next?: (err?: unknown) => void,
+): void {
+  const path = req.url?.split('?')[0].slice(1) || 'index.html'
+  const file = Object.hasOwn(files, path) ? files[path] : null
+
+  if (file) {
+    res
+      .writeHead(200, 'OK', { 'content-type': file.type })
+      .end(Buffer.from(file.data, 'base64'))
+  } else if (next) {
+    next()
+  } else {
+    res
+      .writeHead(404, 'Not Found', { 'content-type': 'text/plain' })
+      .end('Page not found')
+  }
 }

package/tests/sequencer.test.ts

@@ -7,9 +7,8 @@ import {
 import { randomStr } from '@atproto/crypto'
 import { SeedClient, TestNetworkNoAppView } from '@atproto/dev-env'
 import { readCarWithRoot } from '@atproto/repo'
-import { repoPrepare, sequencer } from '../../pds'
-import { ids } from '../src/lexicon/lexicons'
-import { SeqEvt, Sequencer, formatSeqCommit } from '../src/sequencer'
+import { sequencer } from '../../pds'
+import { SeqEvt, Sequencer, formatSeqSyncEvt } from '../src/sequencer'
 import { Outbox } from '../src/sequencer/outbox'
 import userSeed from './seeds/users'
 
@@ -220,35 +219,27 @@ describe('sequencer', () => {
     lastSeen = results[0].at(-1)?.seq ?? lastSeen
   })
 
-  it('root block must be returned in tooBig seq commit', async () => {
-    // Create good records to exceed the event limit (the current limit is 200 events)
-    // it creates events completely locally, so it doesn't need to be in the network
-    const eventsToCreate = 250
-    const createPostRecord = () =>
-      repoPrepare.prepareCreate({
-        did: sc.dids.alice,
-        collection: ids.AppBskyFeedPost,
-        record: { text: 'valid', createdAt: new Date().toISOString() },
-      })
-    const writesPromises = Array.from(
-      { length: eventsToCreate },
-      createPostRecord,
-    )
-    const writes = await Promise.all(writesPromises)
-    // just format commit without processing writes
-    const writeCommit = await network.pds.ctx.actorStore.transact(
+  it('root block must be returned in sync event', async () => {
+    const syncData = await network.pds.ctx.actorStore.read(
       sc.dids.alice,
-      (store) => store.repo.formatCommit(writes),
+      async (store) => {
+        const root = await store.repo.storage.getRootDetailed()
+        const { blocks } = await store.repo.storage.getBlocks([root.cid])
+        return {
+          cid: root.cid,
+          rev: root.rev,
+          blocks,
+        }
+      },
     )
 
-    const repoSeqInsert = await formatSeqCommit(sc.dids.alice, writeCommit)
-
-    const evt = cborDecode<sequencer.CommitEvt>(repoSeqInsert.event)
-    expect(evt.tooBig).toBe(true)
-
+    const dbEvt = await formatSeqSyncEvt(sc.dids.alice, syncData)
+    const evt = cborDecode<sequencer.SyncEvt>(dbEvt.event)
+    expect(evt.did).toBe(sc.dids.alice)
     const car = await readCarWithRoot(evt.blocks)
-    expect(car.root.toString()).toBe(writeCommit.cid.toString())
+    expect(car.root.toString()).toBe(syncData.cid.toString())
     // in the case of tooBig, the blocks must contain the root block only
     expect(car.blocks.size).toBe(1)
+    expect(car.blocks.has(syncData.cid)).toBeTruthy()
   })
 })