mirror of
https://github.com/fsolla/teqo.git
synced 2026-11-16 20:13:04 +00:00
Collection actionPlan -> activity (labels "Atividade"/"Atividades"), campo
campaignDemand.actionPlan -> activity, rota /campanha/planos ->
/campanha/atividades (criacao em atividades/nova), sidebar "Atividades" e
rotulos alinhados a entidade ("Tipo de atividade", "Origem da atividade",
"Resultado da atividade"). Valores de enum kind/status/origin inalterados.
Schema movido por migration data-preserving escrita a mao
(20260725_213000_rename_action_plan_to_activity): 4 tabelas, 3 enums, 2
colunas, 39 indices (4 pkeys inclusos), 14 FKs e 2 sequences, cada statement
guardado na existencia do objeto de origem, com down() simetrico. O gerador do
Payload emitiria DROP+CREATE e nao ve o indice parcial escrito a mao
action_plan_upcoming_start_at_idx, entao a lista veio de
pg_indexes/pg_constraint/pg_type/pg_sequences e o snapshot .json foi derivado
do anterior por transformacao textual -- validado por migrate:create __probe
sem mudanca de schema. A mesma migration alinha os 8 indices fosseis %plaza%
que a remodelagem de municipios deixou (renomeou as colunas plaza_id, nao os
indices).
Guard: o describe "banned campaign terminology" de
codebaseConventions.unit.spec.ts virou tabela de termos varrendo src+tests+
scripts (migrations fora -- historia congelada), banindo os compostos
actionPlan, a copy "plano de acao" e a rota antiga, mas nao plan/plano isolado
(colidiria com os planos de assinatura da Fase 2). Allowlist: o proprio spec,
scripts/generate-remodel-municipalities-migration.mjs e o comentario historico
em campaignMigrationReconciliation.int.spec.ts.
Plano: docs/plans/renomear-plano-acao-para-atividade.md
407 lines
13 KiB
TypeScript
407 lines
13 KiB
TypeScript
import { randomUUID } from 'node:crypto'
|
|
|
|
import { sql } from '@payloadcms/db-postgres'
|
|
import type { Page } from '@playwright/test'
|
|
import { getPayload, type CollectionSlug, type Payload, type PayloadRequest } from 'payload'
|
|
|
|
import { municipalityCatalog } from '../../../src/lib/municipalityCatalog.js'
|
|
import config from '../../../src/payload.config.js'
|
|
import { withPayloadTransaction } from '../../../src/utilities/payloadTransaction.js'
|
|
import { assertTestDatabase } from '../../helpers/assertTestDatabase.js'
|
|
import { withInviteConsent } from '../../helpers/testDatabaseLease.js'
|
|
import { test as base, expect } from './e2eTest.js'
|
|
|
|
const defaultBaseURL = 'http://localhost:3000'
|
|
type TransactionRequest = Pick<PayloadRequest, 'transactionID'>
|
|
type OwnedCollection =
|
|
| 'users'
|
|
| 'campaignUser'
|
|
| 'organization'
|
|
| 'contact'
|
|
| 'leadership'
|
|
| 'votePledge'
|
|
| 'campaignDemand'
|
|
| 'allocationDecision'
|
|
| 'municipalityUpdate'
|
|
| 'activity'
|
|
| 'campaignInvite'
|
|
| 'consent'
|
|
| 'supporter'
|
|
|
|
const deletionOrder: OwnedCollection[] = [
|
|
'campaignInvite',
|
|
'votePledge',
|
|
'campaignDemand',
|
|
'allocationDecision',
|
|
'municipalityUpdate',
|
|
'activity',
|
|
'leadership',
|
|
'supporter',
|
|
'organization',
|
|
'contact',
|
|
'campaignUser',
|
|
'consent',
|
|
'users',
|
|
]
|
|
|
|
/**
|
|
* Municipalities are SEEDED reference rows (435 from the static catalog): E2E tests
|
|
* never create/delete them. `claimMunicipality` hands out a globally unique seeded
|
|
* municipality per call (Postgres sequence — safe across parallel workers) and
|
|
* cleanup resets the operational fields the test may have touched.
|
|
*/
|
|
class CampaignE2EOwnership {
|
|
readonly payload: Payload
|
|
readonly runID = randomUUID()
|
|
private counter = 0
|
|
private readonly touchedMunicipalities = new Set<number>()
|
|
private readonly owned = new Map<OwnedCollection, Set<number>>(
|
|
deletionOrder.map((collection) => [collection, new Set<number>()]),
|
|
)
|
|
|
|
constructor(private readonly rootPayload: Payload) {
|
|
this.payload = new Proxy(Object.create(rootPayload) as Payload, {
|
|
get: (_target, property) => {
|
|
if (property === 'create') {
|
|
return async (args: Parameters<Payload['create']>[0]) => {
|
|
const document = await rootPayload.create(args)
|
|
if (this.isOwnedCollection(args.collection) && typeof document.id === 'number') {
|
|
this.own(args.collection, document.id)
|
|
}
|
|
return document
|
|
}
|
|
}
|
|
const value = Reflect.get(rootPayload, property)
|
|
return typeof value === 'function' ? value.bind(rootPayload) : value
|
|
},
|
|
}) as Payload
|
|
}
|
|
|
|
value(prefix: string): string {
|
|
this.counter += 1
|
|
return `${prefix}-${this.runID}-${this.counter}`
|
|
}
|
|
|
|
phone(): string {
|
|
this.counter += 1
|
|
const seed = BigInt(`0x${this.runID.replaceAll('-', '').slice(0, 12)}`)
|
|
const suffix = ((seed + BigInt(this.counter)) % 90_000_000n) + 10_000_000n
|
|
return `719${suffix}`
|
|
}
|
|
|
|
async claimMunicipality(): Promise<{ id: number; name: string; slug: string }> {
|
|
await this.rootPayload.db.drizzle
|
|
.execute(sql.raw(`CREATE SEQUENCE IF NOT EXISTS "campaign_fixture_municipality_alloc"`))
|
|
.catch((error: unknown) => {
|
|
if ((error as { code?: string }).code === '23505') return
|
|
throw error
|
|
})
|
|
const result = await this.rootPayload.db.drizzle.execute(
|
|
sql.raw(`SELECT nextval('"campaign_fixture_municipality_alloc"') AS "value"`),
|
|
)
|
|
const index =
|
|
Number((result.rows[0] as { value: string | number }).value) % municipalityCatalog.length
|
|
const slug = municipalityCatalog[index]!.slug
|
|
const found = await this.rootPayload.find({
|
|
collection: 'municipality',
|
|
where: { slug: { equals: slug } },
|
|
depth: 0,
|
|
limit: 1,
|
|
pagination: false,
|
|
})
|
|
const municipality = found.docs[0]
|
|
if (!municipality)
|
|
throw new Error(`Seeded municipality "${slug}" not found — run migrations first.`)
|
|
this.touchedMunicipalities.add(municipality.id)
|
|
return { id: municipality.id, name: municipality.name, slug: municipality.slug }
|
|
}
|
|
|
|
touchMunicipality(id: number): void {
|
|
this.touchedMunicipalities.add(id)
|
|
}
|
|
|
|
private isOwnedCollection(collection: CollectionSlug): collection is OwnedCollection {
|
|
return this.owned.has(collection as OwnedCollection)
|
|
}
|
|
|
|
private own(collection: OwnedCollection, id: number): void {
|
|
this.owned.get(collection)!.add(id)
|
|
}
|
|
|
|
private ids(collection: OwnedCollection): number[] {
|
|
return [...this.owned.get(collection)!]
|
|
}
|
|
|
|
private async discoverOwnedRows(): Promise<void> {
|
|
const [users, campaignUsers, contacts, organizations, activities, consents] = await Promise.all(
|
|
[
|
|
this.rootPayload.find({
|
|
collection: 'users',
|
|
where: { email: { contains: this.runID } },
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
this.rootPayload.find({
|
|
collection: 'campaignUser',
|
|
where: {
|
|
or: [
|
|
{ name: { contains: this.runID } },
|
|
{ email: { contains: this.runID } },
|
|
{ username: { contains: this.runID } },
|
|
],
|
|
},
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
this.rootPayload.find({
|
|
collection: 'contact',
|
|
where: {
|
|
or: [{ name: { contains: this.runID } }, { email: { contains: this.runID } }],
|
|
},
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
this.rootPayload.find({
|
|
collection: 'organization',
|
|
where: {
|
|
or: [{ name: { contains: this.runID } }, { slug: { contains: this.runID } }],
|
|
},
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
this.rootPayload.find({
|
|
collection: 'activity',
|
|
where: {
|
|
or: [{ title: { contains: this.runID } }, { slug: { contains: this.runID } }],
|
|
},
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
this.rootPayload.find({
|
|
collection: 'consent',
|
|
where: { key: { contains: this.runID } },
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
],
|
|
)
|
|
for (const user of users.docs) this.own('users', user.id)
|
|
for (const user of campaignUsers.docs) this.own('campaignUser', user.id)
|
|
for (const contact of contacts.docs) this.own('contact', contact.id)
|
|
for (const organization of organizations.docs) this.own('organization', organization.id)
|
|
for (const activity of activities.docs) this.own('activity', activity.id)
|
|
for (const consent of consents.docs) this.own('consent', consent.id)
|
|
|
|
const userIDs = this.ids('campaignUser')
|
|
const contactIDs = this.ids('contact')
|
|
const leaderships = await this.rootPayload.find({
|
|
collection: 'leadership',
|
|
where: {
|
|
or: [
|
|
...(userIDs.length ? [{ createdBy: { in: userIDs } }] : []),
|
|
...(userIDs.length ? [{ user: { in: userIDs } }] : []),
|
|
...(contactIDs.length ? [{ contact: { in: contactIDs } }] : []),
|
|
],
|
|
},
|
|
depth: 0,
|
|
pagination: false,
|
|
})
|
|
for (const leadership of leaderships.docs) this.own('leadership', leadership.id)
|
|
|
|
const leadershipIDs = this.ids('leadership')
|
|
if (leadershipIDs.length) {
|
|
const [invites, pledges, demands] = await Promise.all([
|
|
this.rootPayload.find({
|
|
collection: 'campaignInvite',
|
|
where: { leadership: { in: leadershipIDs } },
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
this.rootPayload.find({
|
|
collection: 'votePledge',
|
|
where: { leadership: { in: leadershipIDs } },
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
this.rootPayload.find({
|
|
collection: 'campaignDemand',
|
|
where: { leadership: { in: leadershipIDs } },
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
])
|
|
for (const invite of invites.docs) this.own('campaignInvite', invite.id)
|
|
for (const pledge of pledges.docs) this.own('votePledge', pledge.id)
|
|
for (const demand of demands.docs) this.own('campaignDemand', demand.id)
|
|
}
|
|
if (userIDs.length) {
|
|
const [updates, demands] = await Promise.all([
|
|
this.rootPayload.find({
|
|
collection: 'municipalityUpdate',
|
|
where: { author: { in: userIDs } },
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
this.rootPayload.find({
|
|
collection: 'campaignDemand',
|
|
where: { createdBy: { in: userIDs } },
|
|
depth: 0,
|
|
pagination: false,
|
|
}),
|
|
])
|
|
for (const update of updates.docs) this.own('municipalityUpdate', update.id)
|
|
for (const demand of demands.docs) this.own('campaignDemand', demand.id)
|
|
}
|
|
if (contactIDs.length || userIDs.length) {
|
|
const supporters = await this.rootPayload.find({
|
|
collection: 'supporter',
|
|
where: {
|
|
or: [
|
|
...(contactIDs.length ? [{ contact: { in: contactIDs } }] : []),
|
|
...(userIDs.length ? [{ createdBy: { in: userIDs } }] : []),
|
|
],
|
|
},
|
|
depth: 0,
|
|
pagination: false,
|
|
})
|
|
for (const supporter of supporters.docs) this.own('supporter', supporter.id)
|
|
}
|
|
}
|
|
|
|
async cleanup(): Promise<void> {
|
|
await this.discoverOwnedRows()
|
|
await withPayloadTransaction(this.rootPayload, async ({ req, transactionID }) => {
|
|
const transaction = this.rootPayload.db.sessions?.[String(transactionID)]?.db as
|
|
| { execute: (query: ReturnType<typeof sql>) => Promise<unknown> }
|
|
| undefined
|
|
if (!transaction) throw new Error('Campaign E2E cleanup transaction is unavailable.')
|
|
const userIDs = this.ids('campaignUser')
|
|
if (userIDs.length) {
|
|
await transaction.execute(sql`
|
|
DELETE FROM "payload_preferences"
|
|
WHERE "id" IN (
|
|
SELECT "parent_id"
|
|
FROM "payload_preferences_rels"
|
|
WHERE "campaign_user_id" IN (${sql.join(
|
|
userIDs.map((id) => sql`${id}`),
|
|
sql`, `,
|
|
)})
|
|
)
|
|
`)
|
|
}
|
|
for (const collection of deletionOrder) {
|
|
const ids = this.ids(collection)
|
|
if (!ids.length) continue
|
|
const result = await this.rootPayload.delete({
|
|
collection,
|
|
where: { id: { in: ids } },
|
|
depth: 0,
|
|
req,
|
|
})
|
|
if (result.errors.length) {
|
|
throw new AggregateError(result.errors, `Failed to clean owned ${collection} rows.`)
|
|
}
|
|
}
|
|
for (const municipalityID of this.touchedMunicipalities) {
|
|
await this.rootPayload.update({
|
|
collection: 'municipality',
|
|
id: municipalityID,
|
|
data: {
|
|
advisors: [],
|
|
priority: 'normal',
|
|
expectedVotes: { pessimistic: null, central: null, optimistic: null },
|
|
politicalTrend: { status: null, note: null, recordedBy: null, recordedAt: null },
|
|
strengths: [],
|
|
risks: [],
|
|
dobradinhaNotes: null,
|
|
nextSteps: null,
|
|
lastUpdateAt: null,
|
|
},
|
|
depth: 0,
|
|
req,
|
|
})
|
|
}
|
|
})
|
|
}
|
|
|
|
async expectNoOwnedRows(): Promise<void> {
|
|
for (const collection of deletionOrder) {
|
|
const ids = this.ids(collection)
|
|
if (!ids.length) continue
|
|
const remaining = await this.rootPayload.find({
|
|
collection,
|
|
where: { id: { in: ids } },
|
|
depth: 0,
|
|
limit: 1,
|
|
})
|
|
expect(remaining.totalDocs, `Owned ${collection} rows remain`).toBe(0)
|
|
}
|
|
}
|
|
}
|
|
|
|
type CampaignE2EFixture = {
|
|
baseURL: string
|
|
fixtures: CampaignE2EOwnership
|
|
login: (page: Page, identifier: string, password: string) => Promise<void>
|
|
payload: Payload
|
|
transaction: <Result>(
|
|
operation: (payload: Payload, req: TransactionRequest) => Promise<Result>,
|
|
) => Promise<Result>
|
|
withInviteConsent: typeof withInviteConsent
|
|
}
|
|
|
|
type CampaignE2ETestFixtures = {
|
|
campaign: CampaignE2EFixture
|
|
}
|
|
|
|
export const test = base.extend<CampaignE2ETestFixtures>({
|
|
campaign: async ({}, runFixture) => {
|
|
assertTestDatabase(process.env.DATABASE_URL)
|
|
const payload = await getPayload({ config })
|
|
const fixtures = new CampaignE2EOwnership(payload)
|
|
const baseURL = process.env.PLAYWRIGHT_BASE_URL ?? defaultBaseURL
|
|
|
|
let testFailure: unknown
|
|
try {
|
|
await runFixture({
|
|
baseURL,
|
|
fixtures,
|
|
login: async (page, identifier, password) => {
|
|
await page.context().clearCookies()
|
|
await page.goto(`${baseURL}/campanha/login`)
|
|
await page.getByLabel('E-mail ou celular').fill(identifier)
|
|
await page.getByLabel('Senha').fill(password)
|
|
await page.getByRole('button', { name: 'Entrar' }).click()
|
|
await page.waitForURL(`${baseURL}/campanha`)
|
|
},
|
|
payload: fixtures.payload,
|
|
transaction: (operation) =>
|
|
withPayloadTransaction(payload, ({ req }) => operation(fixtures.payload, req)),
|
|
withInviteConsent,
|
|
})
|
|
} catch (error) {
|
|
testFailure = error
|
|
throw error
|
|
} finally {
|
|
let cleanupFailure: unknown
|
|
try {
|
|
assertTestDatabase(process.env.DATABASE_URL)
|
|
await fixtures.cleanup()
|
|
await fixtures.expectNoOwnedRows()
|
|
} catch (error) {
|
|
cleanupFailure = error
|
|
}
|
|
if (cleanupFailure !== undefined) {
|
|
if (testFailure !== undefined) {
|
|
throw new AggregateError(
|
|
[testFailure, cleanupFailure],
|
|
'Campaign E2E test and ownership cleanup both failed.',
|
|
)
|
|
}
|
|
throw cleanupFailure
|
|
}
|
|
}
|
|
},
|
|
})
|
|
|
|
export { expect }
|