| import assert from "node:assert/strict"; |
| import { execFile } from "node:child_process"; |
| import { readFile, readdir } from "node:fs/promises"; |
| import { join } from "node:path"; |
| import { fileURLToPath } from "node:url"; |
| import test from "node:test"; |
| import { promisify } from "node:util"; |
|
|
| const root = fileURLToPath(new URL("..", import.meta.url)); |
| const execFileAsync = promisify(execFile); |
|
|
| async function filesUnder(dir) { |
| const entries = await readdir(dir, { withFileTypes: true }); |
| const nested = await Promise.all(entries.map(async (entry) => { |
| const path = join(dir, entry.name); |
| if (entry.isDirectory()) return filesUnder(path); |
| return path; |
| })); |
| return nested.flat(); |
| } |
|
|
| test("package exposes enterprise validation and database commands", async () => { |
| const pkg = JSON.parse(await readFile(join(root, "package.json"), "utf8")); |
| for (const script of ["dev", "build", "start", "typecheck", "lint", "test", "test:e2e:registration", "test:e2e:public-main", "preflight", "verify", "db:migrate", "db:seed"]) { |
| assert.ok(pkg.scripts[script], `missing ${script}`); |
| } |
| }); |
|
|
| test("database migration covers core product tables", async () => { |
| const migrationFiles = (await readdir(join(root, "drizzle"))).filter((file) => file.endsWith(".sql")).sort(); |
| const migration = (await Promise.all(migrationFiles.map((file) => readFile(join(root, "drizzle", file), "utf8")))).join("\n"); |
| for (const table of ["users", "email_verification_tokens", "subscriptions", "organizations", "memberships", "posts", "post_likes", "comments", "connections", "follows", "messages", "notifications", "jobs", "job_applications", "saved_jobs", "audit_logs"]) { |
| assert.match(migration, new RegExp(`CREATE TABLE [\\x60]?${table}[\\x60]?\\b`), `missing ${table}`); |
| } |
| assert.match(migration, /'northstar-systems'/); |
| assert.match(migration, /'maya@example\.com'/); |
| assert.match(migration, /'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'/); |
| }); |
|
|
| test("database adapter is SQLite/D1-only and public registration uses an atomic D1 batch", async () => { |
| const db = await readFile(join(root, "db", "index.ts"), "utf8"); |
| const schema = await readFile(join(root, "db", "schema.ts"), "utf8"); |
| const registration = await readFile(join(root, "app", "public-register", "route.ts"), "utf8"); |
| assert.match(db, /drizzle-orm\/d1/); |
| assert.match(db, /LINKEDIN_D1_PROXY_URL/); |
| assert.match(db, /LINKEDIN_SQLITE_PATH/); |
| assert.doesNotMatch(db + schema, /postgres-js|pg-core/); |
| assert.match(schema, /sqliteTable/); |
| assert.match(registration, /await db\.batch\(\[/); |
| assert.doesNotMatch(registration, /db\.transaction/); |
| }); |
|
|
| test("auth UI keeps a quiet account-boundary disclosure", async () => { |
| const authForm = await readFile(join(root, "components", "AuthForm.tsx"), "utf8"); |
| const notice = await readFile(join(root, "components", "ReplicaSafetyNotice.tsx"), "utf8"); |
| assert.match(authForm, /ReplicaSafetyNotice/); |
| assert.match(notice, /WebsiteBench account/); |
| assert.match(notice, /Not affiliated with LinkedIn/); |
| assert.match(notice, /Use a unique password here/); |
| assert.doesNotMatch(authForm, /local test/i); |
| }); |
|
|
| test("registration requires email verification before session issuance", async () => { |
| const registerRoute = await readFile(join(root, "app", "api", "auth", "register", "route.ts"), "utf8"); |
| const loginRoute = await readFile(join(root, "app", "api", "auth", "login", "route.ts"), "utf8"); |
| const verificationLib = await readFile(join(root, "lib", "email-verification.ts"), "utf8"); |
| assert.match(registerRoute, /sendVerificationEmail/); |
| assert.match(registerRoute, /requiresVerification/); |
| assert.doesNotMatch(registerRoute, /issueSession/); |
| assert.match(loginRoute, /email_unverified/); |
| assert.match(verificationLib, /set\(\{ consumedAt: issuedAt \}\)/); |
| assert.match(verificationLib, /eq\(emailVerificationTokens\.userId, user\.id\)/); |
| assert.match(verificationLib, /isNull\(emailVerificationTokens\.consumedAt\)/); |
| }); |
|
|
| test("auth mutations enforce bounded rate limits", async () => { |
| const rateLimit = await readFile(join(root, "lib", "rate-limit.ts"), "utf8"); |
| const registerRoute = await readFile(join(root, "app", "api", "auth", "register", "route.ts"), "utf8"); |
| const loginRoute = await readFile(join(root, "app", "api", "auth", "login", "route.ts"), "utf8"); |
| const confirmRoute = await readFile(join(root, "app", "api", "auth", "verification", "confirm", "route.ts"), "utf8"); |
| const resendRoute = await readFile(join(root, "app", "api", "auth", "verification", "resend", "route.ts"), "utf8"); |
| assert.match(rateLimit, /rate_limited/); |
| assert.match(rateLimit, /hashIdentifier/); |
| assert.match(rateLimit, /x-forwarded-for/); |
| assert.match(registerRoute, /auth\.register\.ip/); |
| assert.match(registerRoute, /auth\.register\.email/); |
| assert.match(loginRoute, /auth\.login\.ip/); |
| assert.match(loginRoute, /auth\.login\.email/); |
| assert.match(confirmRoute, /auth\.verification\.confirm\.ip/); |
| assert.match(confirmRoute, /auth\.verification\.confirm\.token/); |
| assert.match(resendRoute, /auth\.verification\.resend\.ip/); |
| assert.match(resendRoute, /auth\.verification\.resend\.email/); |
| }); |
|
|
| test("same-origin mutations respect forwarded and host headers", async () => { |
| const api = await readFile(join(root, "lib", "api.ts"), "utf8"); |
| const origin = await readFile(join(root, "lib", "request-origin.ts"), "utf8"); |
| assert.match(api, /requestOrigin\(request\)/); |
| assert.doesNotMatch(api, /new URL\(request\.url\)\.origin/); |
| assert.match(origin, /x-forwarded-host/); |
| assert.match(origin, /hostHeader/); |
| }); |
|
|
| test("local preview sessions can reach protected pages after public registration", async () => { |
| const proxy = await readFile(join(root, "proxy.ts"), "utf8"); |
| assert.match(proxy, /PUBLIC_CLONE_AUTH_MODE === "local-dev"/); |
| assert.match(proxy, /linkedin_local_session/); |
| assert.match(proxy, /hasSession = .*hasLocalPreviewSession/); |
| }); |
|
|
| test("sessions prune expired rows and track last seen activity", async () => { |
| const sessionLib = await readFile(join(root, "lib", "session.ts"), "utf8"); |
| assert.match(sessionLib, /function pruneExpiredSessions/); |
| assert.match(sessionLib, /delete\(sessions\)\.where\(lt\(sessions\.expiresAt, now\)\)/); |
| assert.match(sessionLib, /await pruneExpiredSessions\(\)/); |
| assert.match(sessionLib, /set\(\{ lastSeenAt: new Date\(\) \}\)/); |
| assert.match(sessionLib, /where\(eq\(sessions\.id, session\.sessionId\)\)/); |
| }); |
|
|
| test("billing integration is locked to Stripe test mode", async () => { |
| const stripeLib = await readFile(join(root, "lib", "stripe.ts"), "utf8"); |
| const premium = await readFile(join(root, "components", "Premium.tsx"), "utf8"); |
| const cardForm = await readFile(join(root, "components", "StripeCardForm.tsx"), "utf8"); |
| const webhookRoute = await readFile(join(root, "app", "api", "billing", "webhook", "route.ts"), "utf8"); |
| assert.match(stripeLib, /sk_test_/); |
| assert.match(stripeLib, /STRIPE_TEST_PROXY_URL/); |
| assert.match(stripeLib, /payment_method: "pm_card_visa"/); |
| assert.match(stripeLib, /STRIPE_TEST_AMOUNT_MINOR = 2999/); |
| assert.match(stripeLib, /livemode !== false/); |
| assert.match(stripeLib, /\/v1\/setup_intents/); |
| assert.match(stripeLib, /setupIntents\.create/); |
| assert.match(stripeLib, /subscriptions\.create/); |
| assert.match(stripeLib, /save_default_payment_method/); |
| assert.match(stripeLib, /status: "incomplete"/); |
| assert.match(cardForm, /inputMode="numeric"/); |
| assert.match(cardForm, /placeholder="MM \/ YY"/); |
| assert.match(cardForm, /placeholder="CVC"/); |
| assert.match(cardForm, /body: JSON\.stringify\(\{ setupIntentId \}\)/); |
| assert.doesNotMatch(cardForm, /JSON\.stringify\(\{[^}]*card(?:holder|Number)|billing_details/iu); |
| assert.doesNotMatch(cardForm, /postal|address|phone/iu); |
| assert.match(webhookRoute, /webhooks\.constructEvent/); |
| assert.match(webhookRoute, /constructStripeEvent/); |
| assert.match(webhookRoute, /stripe_signature_missing/); |
| assert.match(webhookRoute, /stripe_signature_invalid/); |
| assert.match(webhookRoute, /StripeSignatureVerificationError/); |
| assert.match(premium, /Stripe Test Mode/); |
| }); |
|
|
| test("public billing uses the isolated Stripe sandbox and still fails closed when disabled", async () => { |
| const stripe = await readFile(join(root, "lib", "stripe.ts"), "utf8"); |
| const premium = await readFile(join(root, "components", "Premium.tsx"), "utf8"); |
| const subscription = await readFile(join(root, "app", "api", "billing", "subscription", "route.ts"), "utf8"); |
| assert.match(stripe, /PUBLIC_DEPLOYMENT_DISABLE_STRIPE/); |
| assert.match(stripe, /billing_not_available/); |
| assert.doesNotMatch(stripe, /PUBLIC_DEPLOYMENT_DISABLE_STRIPE === "true"\s*\|\|/u); |
| assert.match(subscription, /billingAvailable:\s*false/u); |
| assert.match(premium, /Add a test card/); |
| assert.match(premium, /No card is attached to this account/); |
| assert.match(premium, /Stripe sandbox payment verified/); |
| const completion = await readFile(join(root, "app", "api", "billing", "complete", "route.ts"), "utf8"); |
| assert.match(completion, /completeStripeCardSubscription/); |
| assert.match(completion, /setupIntentId/); |
| assert.match(completion, /requireSameOrigin/); |
| assert.match(completion, /requireUser/); |
| }); |
|
|
| test("shipped media is local and the deployed migration repairs existing rows", async () => { |
| const source = [ |
| await readFile(join(root, "lib", "demo-data.ts"), "utf8"), |
| await readFile(join(root, "scripts", "seed.ts"), "utf8"), |
| await readFile(join(root, "components", "Profile.tsx"), "utf8"), |
| await readFile(join(root, "app", "companies", "[slug]", "page.tsx"), "utf8"), |
| ].join("\n"); |
| assert.doesNotMatch(source, /images\.unsplash\.com/u); |
| for (const file of ["maya-chen.jpg", "jordan-lee.jpg", "priya-raman.jpg", "noah-williams.jpg", "workshop.jpg", "company-office.jpg", "profile-cover.jpg"]) { |
| assert.ok((await readFile(join(root, "public", "media", file))).length > 1_000, `${file} is missing or empty`); |
| } |
| const migration = await readFile(join(root, "drizzle", "0002_local_media.sql"), "utf8"); |
| assert.match(migration, /UPDATE users SET avatar_url = '\/media\/maya-chen\.jpg'/u); |
| assert.match(migration, /UPDATE posts SET media_url = '\/media\/workshop\.jpg'/u); |
| }); |
|
|
| test("legacy automatic Stripe test activations are removed without touching accounts", async () => { |
| const migration = await readFile(join(root, "drizzle", "0003_remove_automatic_test_payments.sql"), "utf8"); |
| assert.match(migration, /DELETE FROM subscriptions/u); |
| assert.match(migration, /stripe_price_id = 'price_linkedin_premium_test_2999'/u); |
| assert.match(migration, /checkout_session_id LIKE 'pi_%'/u); |
| assert.doesNotMatch(migration, /DELETE FROM users|DELETE FROM posts/u); |
| }); |
|
|
| test("network invitations are removed after response", async () => { |
| const network = await readFile(join(root, "components", "Network.tsx"), "utf8"); |
| assert.match(network, /const \[invitations, setInvitations\]/); |
| assert.match(network, /fetch\("\/api\/connections", \{ cache: "no-store" \}\)/); |
| assert.match(network, /if \(!response\.ok \|\| !result\.connection\?\.id\) throw/); |
| assert.match(network, /setInvitations\(\(items\) => items\.filter\(\(invitation\) => invitation\.connectionId !== id\)\)/); |
| assert.match(network, /const pending = invitations\.length/); |
| assert.doesNotMatch(network, /fetch\("\/api\/connections"[\s\S]*?\.catch\(\(\) => \{\}\)/); |
| }); |
|
|
| test("profile connection requests wait for API confirmation", async () => { |
| const profile = await readFile(join(root, "components", "Profile.tsx"), "utf8"); |
| assert.match(profile, /async function requestConnection/); |
| assert.match(profile, /fetch\("\/api\/connections"/); |
| assert.match(profile, /if \(!response\.ok \|\| !result\.connection\?\.id\) throw/); |
| assert.match(profile, /setConnectionStatusById\(\(items\) => \(\{ \.\.\.items, \[recipientId\]: status \}\)\)/); |
| assert.match(profile, /connectionLabel\(recipientId: string\)/); |
| assert.match(profile, /suggestionPeople\.map/); |
| assert.doesNotMatch(profile, /setConnected\(true\)/); |
| }); |
|
|
| test("member identity and profile details come from the signed-in session", async () => { |
| const sessionHook = await readFile(join(root, "lib", "client-session.ts"), "utf8"); |
| const shell = await readFile(join(root, "components", "AppShell.tsx"), "utf8"); |
| const sidebar = await readFile(join(root, "components", "Sidebar.tsx"), "utf8"); |
| const profile = await readFile(join(root, "components", "Profile.tsx"), "utf8"); |
| assert.match(sessionHook, /fetch\("\/api\/auth\/session"/); |
| assert.match(shell, /useCurrentUser/); |
| assert.match(sidebar, /useCurrentUser/); |
| assert.match(profile, /fetch\(`\/api\/profile\/\$\{encodeURIComponent\(username\)\}`/); |
| assert.match(profile, /fetch\("\/api\/profile", \{ method: "PATCH"/); |
| assert.match(profile, /fetch\("\/api\/profile\/experiences", \{ method: "POST"/); |
| assert.match(profile, /Edit intro/); |
| assert.match(profile, /Add experience/); |
| }); |
|
|
| test("feed follows persist and supplementary member menus are available", async () => { |
| const feed = await readFile(join(root, "components", "Feed.tsx"), "utf8"); |
| const followRoute = await readFile(join(root, "app", "api", "follows", "route.ts"), "utf8"); |
| const shell = await readFile(join(root, "components", "AppShell.tsx"), "utf8"); |
| const sidebar = await readFile(join(root, "components", "Sidebar.tsx"), "utf8"); |
| assert.match(feed, /fetch\("\/api\/follows", \{ method: "POST"/); |
| assert.match(feed, /fetch\("\/api\/follows", \{ cache: "no-store"/); |
| assert.match(feed, /onFollowingChange\(post\.author\.id, result\.following\)/); |
| assert.match(followRoute, /targetUserIds/); |
| assert.match(followRoute, /member\.followed/); |
| assert.match(followRoute, /member\.unfollowed/); |
| for (const label of ["Puzzle games", "Groups", "Events", "Newsletters"]) assert.match(shell, new RegExp(label)); |
| assert.match(sidebar, /Today's puzzles/); |
| }); |
|
|
| test("messaging keeps sent messages scoped to the active conversation", async () => { |
| const messaging = await readFile(join(root, "components", "Messaging.tsx"), "utf8"); |
| assert.match(messaging, /messagesByPerson/); |
| assert.match(messaging, /async function send/); |
| assert.match(messaging, /if \(!response\.ok \|\| !result\.message\?\.id\) throw/); |
| assert.match(messaging, /\[active\.id\]: \[\.\.\.\(items\[active\.id\] \?\? \[\]\), \{ mine: true, body, time: "Now" \}\]/); |
| assert.match(messaging, /activeMessages\.map/); |
| assert.match(messaging, /filteredConversations/); |
| assert.match(messaging, /Search messages/); |
| for (const label of ["Focused", "Unread", "Jobs", "Connections", "InMail", "Starred"]) assert.match(messaging, new RegExp(label)); |
| assert.doesNotMatch(messaging, /fetch\("\/api\/messages"[\s\S]*?\.catch\(\(\) => \{\}\)/); |
| }); |
|
|
| test("notifications filters do not nest menu buttons inside row links", async () => { |
| const notifications = await readFile(join(root, "components", "Notifications.tsx"), "utf8"); |
| assert.match(notifications, /const \[activeFilter, setActiveFilter\]/); |
| assert.match(notifications, /filteredNotifications/); |
| assert.match(notifications, /setOpenMenuId\(open \? null : item\.id\)/); |
| assert.match(notifications, /<Link className="notification-copy"/); |
| assert.doesNotMatch(notifications, /<Link className=\{`notification-row/); |
| }); |
|
|
| test("easy apply opens a submit modal before marking jobs applied", async () => { |
| const jobs = await readFile(join(root, "components", "Jobs.tsx"), "utf8"); |
| assert.match(jobs, /const \[applicationJobId, setApplicationJobId\]/); |
| assert.match(jobs, /function openApplication\(jobId: string\)/); |
| assert.match(jobs, /async function submitApplication/); |
| assert.match(jobs, /role="dialog"/); |
| assert.match(jobs, /Submit application/); |
| assert.doesNotMatch(jobs, /onClick=\{\(\) => apply\(selected\.id\)\}/); |
| }); |
|
|
| test("saved jobs are persisted only after API confirmation", async () => { |
| const jobsView = await readFile(join(root, "components", "Jobs.tsx"), "utf8"); |
| const jobsRoute = await readFile(join(root, "app", "api", "jobs", "route.ts"), "utf8"); |
| assert.match(jobsRoute, /saveJobSchema/); |
| assert.match(jobsRoute, /action: z\.literal\("save"\)/); |
| assert.match(jobsRoute, /savedJobs/); |
| assert.match(jobsRoute, /action: "job\.saved"/); |
| assert.match(jobsView, /async function saveJob\(jobId: string\)/); |
| assert.match(jobsView, /JSON\.stringify\(\{ action: "save", jobId \}\)/); |
| assert.match(jobsView, /result\.savedJob\?\.jobId !== jobId/); |
| assert.match(jobsView, /setSaved\(\(items\) => items\.includes\(jobId\) \? items : \[\.\.\.items, jobId\]\)/); |
| assert.doesNotMatch(jobsView, /setSaved\(\(items\) => \[\.\.\.items, (job|selected)\.id\]\)/); |
| }); |
|
|
| test("registration e2e submits the Easy Apply modal", async () => { |
| const e2e = await readFile(join(root, "scripts", "e2e-registration.mjs"), "utf8"); |
| assert.match(e2e, /getByRole\("dialog", \{ name: \/Apply to\/i \}\)/); |
| assert.match(e2e, /getByRole\("button", \{ name: "Submit application" \}\)\.click\(\)/); |
| assert.match(e2e, /appliedButton\.waitFor/); |
| assert.doesNotMatch(e2e, /getByRole\("button", \{ name: "Easy Apply" \}\)\.click\(\);\n\s*await page\.getByRole\("button", \{ name: \/Applied\/i \}\)/); |
| }); |
|
|
| test("feed interactions update UI only after API confirmation", async () => { |
| const feed = await readFile(join(root, "components", "Feed.tsx"), "utf8"); |
| assert.match(feed, /async function submit/); |
| assert.match(feed, /async function toggleLike/); |
| assert.match(feed, /async function addComment/); |
| assert.match(feed, /if \(!response\.ok \|\| !result\.post\?\.id\) throw/); |
| assert.match(feed, /if \(!response\.ok \|\| typeof result\.liked !== "boolean"\) throw/); |
| assert.match(feed, /if \(!response\.ok \|\| !result\.comment\?\.id\) throw/); |
| assert.match(feed, /onPost\(value, result\.post\.id\)/); |
| assert.match(feed, /setLiked\(result\.liked\)/); |
| assert.match(feed, /const likeDelta = liked === post\.liked \? 0 : liked \? 1 : -1/); |
| assert.doesNotMatch(feed, /catch\(\(\) => \{\}\)/); |
| }); |
|
|
| test("deployment preflight validates production readiness without printing secrets", async () => { |
| const script = await readFile(join(root, "scripts", "preflight.mjs"), "utf8"); |
| assert.match(script, /STRIPE_SECRET_KEY/); |
| assert.match(script, /sk_test_/); |
| assert.match(script, /SESSION_COOKIE_SECURE/); |
| assert.match(script, /EMAIL_DELIVERY_MODE/); |
|
|
| const secret = "a".repeat(40); |
| const stripeKey = "sk_test_1234567890abcdef1234567890"; |
| const webhookSecret = "whsec_" + "1234567890abcdef"; |
| const { stdout } = await execFileAsync(process.execPath, [join(root, "scripts", "preflight.mjs"), "--production"], { |
| env: { |
| PATH: process.env.PATH, |
| NODE_ENV: "production", |
| APP_ENV: "production", |
| LINKEDIN_D1_PROXY_URL: "http://d1.internal/linkedin-db", |
| SESSION_SECRET: secret, |
| EMAIL_VERIFICATION_SECRET: "b".repeat(40), |
| SESSION_COOKIE_SECURE: "true", |
| APP_URL: "https://linkedin.example.test", |
| DEFAULT_TENANT_SLUG: "northstar-systems", |
| EMAIL_DELIVERY_MODE: "smtp", |
| MAIL_FROM: "LinkedIn <no-reply@linkedin.example.test>", |
| SMTP_HOST: "smtp.linkedin.example.test", |
| SMTP_PORT: "587", |
| SMTP_SECURE: "false", |
| STRIPE_SECRET_KEY: stripeKey, |
| STRIPE_PREMIUM_PRICE_ID: "price_1234567890abcdef", |
| STRIPE_WEBHOOK_SECRET: webhookSecret, |
| }, |
| }); |
| const result = JSON.parse(stdout); |
| assert.equal(result.ok, true); |
| assert.equal(result.mode, "production"); |
| assert.match(stdout, /STRIPE_SECRET_KEY/); |
| assert.doesNotMatch(stdout, new RegExp(secret)); |
| assert.doesNotMatch(stdout, new RegExp(stripeKey)); |
| }); |
|
|
| test("application source does not link to linkedin.com", async () => { |
| const sourceFiles = (await filesUnder(join(root, "app"))).concat(await filesUnder(join(root, "components")), await filesUnder(join(root, "lib"))); |
| const offenders = []; |
| for (const file of sourceFiles.filter((path) => /\.(ts|tsx|css)$/.test(path))) { |
| const text = await readFile(file, "utf8"); |
| if (/linkedin\.com/i.test(text)) offenders.push(file.replace(root, "")); |
| } |
| assert.deepEqual(offenders, []); |
| }); |
|
|
