@omega.js/backend 0.1.0

package/test/routes/user/signup-emails.test.js

@@ -0,0 +1,113 @@
+/**
+ * Test: signup actually sends its onboarding emails
+ * ([#774](https://github.com/Omega-JS-Stack/omega/issues/774)).
+ *
+ * The route used to gate itself — `shouldSend = !ctx.isTesting() || TEST_EXTENDED_MODE`
+ * — and returned before the mailer, so every offline run proved nothing about the
+ * four emails a new account is owed. That gate moved into `Transactional.send()`,
+ * which now RECORDS a testing send instead of delivering it, so the route runs its
+ * real sends here and this suite reads them back.
+ *
+ * The four split two ways, by the mailer's own scheduling limit (`SEND_AT_LIMIT`,
+ * 71 hours):
+ *   - welcome (immediate) and the 24-hour discount nudge are built, rendered and
+ *     CAPTURED — a broken template or an unconfigured signoff fails right here,
+ *     which is exactly how the [#640](https://github.com/Omega-JS-Stack/omega/issues/640)
+ *     signoff crash reached production unnoticed,
+ *   - the 5-day checkup and the 10-day feedback request are past the limit, so they
+ *     land in `emails-queue` for the frequent cron to send later.
+ *
+ * Emulator-backed: the route is real, the user doc it emails is real, and the queue
+ * is real Firestore.
+ *
+ * Run: npx omega test framework:routes/user/signup-emails
+ */
+const capture = require('../../../dist/test/utils/email-capture.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+const ACCOUNT = 'signup-emails';
+
+/**
+ * The queued emails addressed to one uid.
+ *
+ * @param {object} admin - The admin SDK handle
+ * @param {string} uid - The recipient
+ * @returns {Promise<object[]>} The queue documents' data
+ */
+async function queuedFor(admin, uid) {
+  const snapshot = await admin.firestore().collection('emails-queue').get();
+
+  return snapshot.docs
+    .map((doc) => doc.data())
+    .filter((data) => data?.settings?.to === uid);
+}
+
+module.exports = defineCases({
+  description: 'Signup sends the welcome email and schedules the follow-ups (#774)',
+  type: 'suite',
+  timeout: 60000,
+
+  tests: [
+    {
+      name: 'signup-captures-the-welcome-and-the-nudge-and-queues-the-follow-ups',
+
+      async run({ http, assert, accounts, admin, Manager }) {
+        const account = accounts[ACCOUNT];
+
+        // Clear first, so everything read back below is this signup's own.
+        capture.clearCaptured(Manager);
+
+        const response = await http.as(ACCOUNT).post('backend-manager/user/signup', {});
+
+        assert.isSuccess(response, 'Signup should succeed');
+
+        // --- The two that go out now ---
+        // Addressed to THIS persona: the store is one file per project, and a
+        // fire-and-forget send another suite left in flight would otherwise land in
+        // the middle of this count.
+        const captured = capture.readCaptured(Manager).filter((record) => record.to.includes(account.email));
+
+        assert.equal(captured.length, 2, `Signup owes two immediate emails, got ${captured.length}: ${captured.map((r) => r.subject).join(' | ')}`);
+
+        for (const record of captured) {
+          assert.deepEqual(record.to, [account.email], 'Every onboarding email goes to the new account, and to nobody else');
+          assert.equal(record.template, 'card', 'Both ride the card template');
+        }
+
+        const brandName = Manager.config.brand.name;
+        const welcome = captured.find((record) => record.subject === `Welcome to ${brandName}!`);
+
+        assert.ok(welcome, `The welcome email is sent, got: ${captured.map((r) => r.subject).join(' | ')}`);
+        assert.equal(welcome.sendAt, null, 'The welcome email goes out immediately');
+        assert.match(welcome.summary, new RegExp(`Welcome to ${brandName}`), `Its body is the rendered welcome, got: ${welcome.summary}`);
+
+        const nudge = captured.find((record) => record !== welcome);
+
+        assert.match(nudge.subject, /something for you/, `The discount nudge is scheduled, got: ${nudge.subject}`);
+        assert.ok(nudge.sendAt > 0, 'The nudge carries a send time rather than going out now');
+        assert.inRange(
+          nudge.sendAt - Math.floor(Date.now() / 1000),
+          23 * 3600,
+          25 * 3600,
+          'The nudge is due about 24 hours out',
+        );
+
+        // --- The two the mailer queues, being past its scheduling limit ---
+        const queued = await queuedFor(admin, account.uid);
+
+        assert.equal(queued.length, 2, `Two follow-ups are queued, got ${queued.length}`);
+
+        const checkup = queued.find((data) => data.settings.categories?.includes('account/checkup'));
+        const feedback = queued.find((data) => data.settings.categories?.includes('engagement/feedback'));
+
+        assert.ok(checkup, `The checkup is queued, got: ${queued.map((d) => (d.settings.categories || []).join('+')).join(' | ')}`);
+        assert.ok(feedback, 'The feedback request is queued');
+        assert.equal(feedback.settings.template, 'feedback', 'The feedback request rides its own template');
+        assert.ok(checkup.sendAt > Math.floor(Date.now() / 1000), 'Both carry the second they are due');
+        assert.ok(feedback.sendAt > checkup.sendAt, 'And the feedback request comes after the checkup');
+
+        capture.clearCaptured(Manager);
+      },
+    },
+  ],
+});

package/test/routes/user/signup-location.test.js

@@ -0,0 +1,84 @@
+/**
+ * Test: routes/user/signup/post.locationFromGeolocation
+ * Unit tests for the `personal.location` fill signup derives from the request's
+ * geolocation ([#638](https://github.com/Omega-JS-Stack/omega/issues/638)).
+ *
+ * Run (from the framework repo): npm test routes/user/signup-location
+ *
+ * Contract:
+ *   - The request's country/region/city fill the matching `personal.location`
+ *     fields, which nothing else ever wrote — so the ad-platform match keys
+ *     (`libraries/analytics/match-data.js`) stopped shipping empty ct/st/country.
+ *   - A value the user set (in the incoming settings or in the existing doc)
+ *     ALWAYS wins: an IP guess never overwrites a self-reported location.
+ *   - Nothing to fill returns an EMPTY object, so the write carries no
+ *     `personal.location` key at all rather than a map of nulls.
+ */
+const post = require('../../../dist/manager/routes/user/signup/post.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+const { locationFromGeolocation } = post;
+
+// The shape RouteContext resolves from the request headers (cf-ipcountry /
+// x-country-code / x-appengine-*) — the extra fields are ignored by the fill.
+const GEOLOCATION = {
+  ip: '203.0.113.7',
+  continent: 'NA',
+  country: 'US',
+  region: 'CA',
+  city: 'San Francisco',
+  latitude: 37.7749,
+  longitude: -122.4194,
+};
+
+module.exports = defineCases({
+  description: 'routes/user/signup/post.locationFromGeolocation',
+  type: 'group',
+
+  tests: [
+    {
+      name: 'fills-an-empty-location-from-the-request-geolocation',
+      async run({ assert }) {
+        // A doc resolved from the account schema carries the location leaves as nulls
+        assert.deepEqual(
+          locationFromGeolocation(GEOLOCATION, { country: null, region: null, city: null }),
+          { country: 'US', region: 'CA', city: 'San Francisco' },
+          'country/region/city come from the request geolocation',
+        );
+      },
+    },
+
+    {
+      name: 'never-overwrites-a-location-the-user-set',
+      async run({ assert }) {
+        assert.deepEqual(
+          locationFromGeolocation(GEOLOCATION, { country: 'FR', region: 'IDF', city: 'Paris' }),
+          {},
+          'a self-reported location is left entirely alone',
+        );
+      },
+    },
+
+    {
+      name: 'fills-only-the-fields-the-user-left-empty',
+      async run({ assert }) {
+        assert.deepEqual(
+          locationFromGeolocation(GEOLOCATION, { country: null, region: null, city: 'Oakland' }),
+          { country: 'US', region: 'CA' },
+          'the fill is per-field — the city the user set survives',
+        );
+      },
+    },
+
+    {
+      name: 'writes-nothing-when-the-request-carries-no-geolocation',
+      async run({ assert }) {
+        assert.deepEqual(
+          locationFromGeolocation({ ip: '203.0.113.7', country: null, region: null, city: null }, {}),
+          {},
+          'no geolocation means no personal.location key in the write',
+        );
+      },
+    },
+  ],
+});

package/test/routes/user/signup-log-privacy.test.js

@@ -0,0 +1,112 @@
+/**
+ * Test: routes/user/signup/post log privacy
+ * The two signup log lines name the account and the SHAPE of what moved, never the
+ * payload itself ([#632](https://github.com/Omega-JS-Stack/omega/issues/632)).
+ *
+ * Run (from the framework repo): npm test routes/user/signup-log-privacy
+ *
+ * Contract:
+ *   - `signup(): Starting` logs the uid and the settings' top-level key names — not the
+ *     consent records, the request IP, or the attribution the payload carries.
+ *   - `signup(): Writing user record` logs the uid and the record's top-level key names.
+ *     buildUserRecord() deliberately preserves the existing doc's `api` keys, so
+ *     serializing that record wrote a live private key into Cloud Logging.
+ *
+ * Pure: keyNames has no I/O, and the `Starting` line is written before the route touches
+ * Firestore — the call is allowed to reject at that seam and the assertions read the
+ * captured ctx output.
+ */
+const post = require('../../../dist/manager/routes/user/signup/post.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+const { keyNames } = post;
+
+const LEAKED_KEY = 'sk_test_fake_leak';
+const LEAKED_IP = '203.0.113.7';
+
+// The merged shape buildUserRecord() writes: the existing doc's api keys survive into it.
+const USER_RECORD = {
+  auth: { uid: 'user-632', email: 'recipient@test.dev' },
+  api: { clientId: 'client-632', privateKey: LEAKED_KEY },
+  consent: { marketing: { status: 'granted', ip: LEAKED_IP } },
+  attribution: { source: 'newsletter' },
+  flags: { signupProcessed: true },
+};
+
+// A signup request payload carrying the same kind of material.
+const SETTINGS = {
+  uid: 'user-632',
+  api: { privateKey: LEAKED_KEY },
+  consent: { marketing: { granted: true, ip: LEAKED_IP } },
+  attribution: { source: 'newsletter' },
+  context: { client: { ip: LEAKED_IP } },
+};
+
+async function captureStartingLine() {
+  const captured = [];
+  const record = (...args) => captured.push(args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '));
+
+  // No Firestore here — the route rejects at the first poll, long after the line under
+  // test was written. The assertions are on the log, not the result.
+  const ctx = {
+    Manager: { libraries: { admin: {} } },
+    log: record,
+    warn: record,
+    error: record,
+    respond: () => null,
+  };
+  const user = { authenticated: true, auth: { uid: SETTINGS.uid, email: 'recipient@test.dev' }, roles: {} };
+
+  await post({ ctx, user, settings: SETTINGS, libraries: { admin: {} } }).catch(() => {});
+
+  return captured.find((line) => line.includes('signup(): Starting'));
+}
+
+module.exports = defineCases({
+  description: 'routes/user/signup/post log privacy',
+  type: 'group',
+
+  tests: [
+    {
+      name: 'starting-line-names-the-uid-and-the-shape-only',
+      async run({ assert }) {
+        const line = await captureStartingLine();
+
+        assert.ok(line, 'no signup(): Starting line was logged');
+        assert.ok(line.includes('user-632'), `line does not name the account: ${line}`);
+        assert.ok(line.includes('consent'), `line lost the payload shape: ${line}`);
+      },
+    },
+
+    {
+      name: 'starting-line-never-serializes-the-settings-payload',
+      async run({ assert }) {
+        const line = await captureStartingLine();
+
+        assert.ok(!line.includes('privateKey'), `nested payload serialized into the line: ${line}`);
+        assert.ok(!line.includes(LEAKED_KEY), `private key written to the line: ${line}`);
+        assert.ok(!line.includes(LEAKED_IP), `request IP written to the line: ${line}`);
+      },
+    },
+
+    {
+      name: 'user-record-renders-as-key-names-never-values',
+      async run({ assert }) {
+        const rendered = keyNames(USER_RECORD);
+
+        assert.ok(rendered.includes('api'), `the record shape is gone: ${rendered}`);
+        assert.ok(!rendered.includes('privateKey'), `a nested key leaked: ${rendered}`);
+        assert.ok(!rendered.includes(LEAKED_KEY), `the private key leaked: ${rendered}`);
+        assert.ok(!rendered.includes(LEAKED_IP), `the request IP leaked: ${rendered}`);
+      },
+    },
+
+    {
+      name: 'nothing-to-render-says-none',
+      async run({ assert }) {
+        assert.equal(keyNames({}), '(none)', 'an empty payload renders as (none)');
+        assert.equal(keyNames(null), '(none)', 'a missing payload renders as (none)');
+      },
+    },
+  ],
+});