ad2app-lib 1.47.0 → 1.50.0

package/src/types/agency-pots.test.ts

@@ -0,0 +1,255 @@
+import { test } from "node:test";
+import { validateSync } from "class-validator";
+import assert from "node:assert/strict";
+
+import {
+  ApplyToPotDto,
+  POT_CURRENCIES,
+  CREATOR_POT_FORBIDDEN_KEY,
+  DISCLOSURE_VISIBLE_CHARS,
+  POT_STEPS,
+  checkDisclosure,
+  creatorPotForbiddenKeys,
+  POT_REMOVAL_DECISIONS,
+  potBonusMinor,
+  potEarnings,
+  potViewsAtMax,
+  potCostPer1000Minor,
+  type I_CreatorPotView,
+} from "./agency-pots";
+import { AGENCY_CAMPAIGN_EVENT_KINDS, CreateAgencyCampaignDto } from "./agency-campaigns";
+import { EVENTS } from "../analytics";
+
+// ── checkDisclosure (FR-040) ────────────────────────────────────────────────
+
+test("every UOKiK wording passes, with or without #, in any case", () => {
+  const passing = [
+    "reklama",
+    "#reklama Poranny bieg",
+    "REKLAMA: nowa kolekcja",
+    "materiał reklamowy",
+    "#materiałreklamowy",
+    "Materiał reklamowy marki X",
+    "współpraca reklamowa z @northlight",
+    "#współpracareklamowa",
+    "płatna współpraca",
+    "#płatnawspółpraca",
+    "post sponsorowany",
+    "#postsponsorowany",
+    // Without Polish diacritics, as people type on a phone.
+    "material reklamowy",
+    "wspolpraca reklamowa",
+    "platna wspolpraca",
+  ];
+  for (const caption of passing) {
+    assert.equal(checkDisclosure(caption).result, "pass", caption);
+  }
+});
+
+test("the four bare tags are weak, never accepted silently", () => {
+  for (const tag of ["#współpraca", "#ad", "#spons", "#promo", "#wspolpraca", "#AD"]) {
+    const check = checkDisclosure(`Nowa kolekcja jest super ${tag}`);
+    assert.equal(check.result, "weak", tag);
+    assert.equal(check.found, tag);
+  }
+});
+
+test("a caption with no disclosure at all is missing", () => {
+  assert.deepEqual(checkDisclosure("Poranny bieg w nowej kurtce"), { result: "missing", found: null, at: null });
+  assert.equal(checkDisclosure("").result, "missing");
+});
+
+test("a wording past the first 125 characters is not visible and does not pass", () => {
+  assert.equal(DISCLOSURE_VISIBLE_CHARS, 125, "FR-040: visible without expanding the caption");
+  const filler = "x".repeat(DISCLOSURE_VISIBLE_CHARS);
+  const check = checkDisclosure(`${filler} #reklama`);
+  assert.equal(check.result, "weak");
+  assert.equal(check.found, "#reklama");
+  assert.equal(check.at, DISCLOSURE_VISIBLE_CHARS + 1);
+  // The last visible position still passes.
+  const edge = `${"x".repeat(DISCLOSURE_VISIBLE_CHARS - "reklama".length)}reklama`;
+  assert.equal(edge.length, DISCLOSURE_VISIBLE_CHARS);
+  assert.equal(checkDisclosure(edge).result, "missing", "glued to a word is not the word");
+  assert.equal(checkDisclosure(`${"x ".repeat(59)}reklama`).result, "pass");
+});
+
+test("a wording inside another word is not a disclosure", () => {
+  for (const caption of ["reklamacja przyjęta", "antyreklama", "#reklamacja", "#adidas", "#promocja", "#sponsor"]) {
+    assert.notEqual(checkDisclosure(caption).result, "pass", caption);
+  }
+  assert.equal(checkDisclosure("#adidas").result, "missing");
+});
+
+test("a strong wording wins over a weak tag anywhere in the caption", () => {
+  assert.equal(checkDisclosure("#współpraca #reklama nowa kurtka").result, "pass");
+});
+
+// ── potEarnings (FR-030, FR-032, FR-035) ───────────────────────────────────
+
+test("earnings are the guarantee plus the rate times views, exact to the minor unit", () => {
+  // 15 000,00 zł + 70,00 zł per 1000 × 1 000 views = 15 070,00 zł
+  assert.equal(potEarnings({ guaranteeMinor: 1_500_000, ratePer1000Minor: 7_000, views: 1_000, maxMinor: 9_000_000 }), 1_507_000);
+  // 55,00 zł per 1000 × 845 300 views = 46 491,50 zł; plus 20 000,00 zł
+  assert.equal(potEarnings({ guaranteeMinor: 2_000_000, ratePer1000Minor: 5_500, views: 845_300, maxMinor: 9_000_000 }), 6_649_150);
+  // A fraction of a grosz is never paid: rounded down.
+  assert.equal(potBonusMinor(3_333, 1), 3);
+  assert.equal(potBonusMinor(1, 999), 0);
+});
+
+test("earnings never exceed the maximum", () => {
+  assert.equal(potEarnings({ guaranteeMinor: 1_500_000, ratePer1000Minor: 7_000, views: 1_420_000, maxMinor: 9_000_000 }), 9_000_000);
+  for (let i = 0; i < 2_000; i++) {
+    const maxMinor = 1 + Math.floor(Math.random() * 20_000_000);
+    const guaranteeMinor = Math.floor(Math.random() * maxMinor);
+    const ratePer1000Minor = Math.floor(Math.random() * 100_000);
+    const views = Math.floor(Math.random() * 50_000_000);
+    const earned = potEarnings({ guaranteeMinor, ratePer1000Minor, views, maxMinor });
+    assert.ok(Number.isInteger(earned));
+    assert.ok(earned <= maxMinor, `${earned} > ${maxMinor}`);
+    assert.ok(earned >= guaranteeMinor);
+  }
+});
+
+test("views at the maximum are the exact count, rounded up", () => {
+  // (90 000 − 15 000) / 70 × 1000 = 1 071 428.57… → 1 071 429
+  const terms = { guaranteeMinor: 1_500_000, ratePer1000Minor: 7_000, maxMinor: 9_000_000 };
+  const atMax = potViewsAtMax(terms);
+  assert.equal(atMax, 1_071_429);
+  assert.equal(potEarnings({ ...terms, views: atMax }), 9_000_000);
+  assert.ok(potEarnings({ ...terms, views: atMax - 1 }) < 9_000_000);
+  assert.equal(potViewsAtMax({ ...terms, ratePer1000Minor: 0 }), null, "a zero rate never reaches the maximum");
+});
+
+// ── The creator's view carries nothing pot-level (SC-016) ───────────────────
+
+test("I_CreatorPotView has no key matching a pot-level word", () => {
+  // A full sample of the type: every key the creator receives. Adding a key to
+  // the interface without adding it here fails to compile (the satisfies check).
+  const sample = {
+    campaignId: "c",
+    currency: "PLN",
+    maxPerCreatorMinor: 1,
+    bonusWindowDays: 30,
+    keepUpMonths: 12,
+    coverUrl: null,
+    applicationDeadlineAt: null,
+    availability: "full_max_available",
+    approx: { currency: "EUR", maxPerCreatorMinor: 1, rateDate: "2026-09-30" },
+    schedule: { materialsDueAt: null, publicationDueAt: null, bonusEndsAt: null, keepUpEndsAt: null },
+    publishing: { paidPartnershipLabel: true, sponsorHandle: null, collabHandle: null, firstComment: null, commentsEnabled: true },
+    entry: {
+      state: "accepted",
+      terms: { guaranteeMinor: 1, ratePer1000Minor: 1 },
+      appliedAt: "x",
+      decidedAt: null,
+      publishAt: null,
+      publishConfirmedAt: null,
+      publishedAt: null,
+      postUrl: null,
+      bonusEndsAt: null,
+      keepUpEndsAt: null,
+      outcome: null,
+      mayTakeDown: false,
+      earnings: { guaranteeMinor: 1, bonusMinor: 0, heldBonusMinor: 0, totalMinor: 1, views: 0, lastCountAt: null, frozen: false },
+    },
+    canApply: false,
+    canWithdraw: false,
+    canConfirmPublishAt: false,
+    medianViews: null,
+  } satisfies Required<I_CreatorPotView>;
+  assert.deepEqual(creatorPotForbiddenKeys(sample), []);
+});
+
+test("the fence catches a pot-level key at any depth", () => {
+  assert.deepEqual(creatorPotForbiddenKeys({ a: { b: [{ potBudgetMinor: 1 }] } }), ["a.b.0.potBudgetMinor"]);
+  for (const key of ["budgetMinor", "remainderMinor", "reservedMinor", "fundedMinor", "max_budget", "maxBudgetMinor", "goalViews", "unreserved", "creatorsCoveredAtFullMax", "maxCommitmentMinor", "acceptedCreators"]) {
+    assert.ok(CREATOR_POT_FORBIDDEN_KEY.test(key), key);
+  }
+  // SC-016 names the earned amount; views and the blended cost are pot-level too (review 2026-10-06 M9).
+  for (const key of ["earnedMinor", "blendedCostPer1000Minor", "resultViews", "heldViews", "countedViews"]) {
+    assert.ok(CREATOR_POT_FORBIDDEN_KEY.test(key), key);
+  }
+  for (const key of ["maxPerCreatorMinor", "guaranteeMinor", "keepUpMonths", "availability", "acceptedAt", "decidedAt", "earnings", "bonusMinor", "totalMinor", "views", "medianViews"]) {
+    assert.ok(!CREATOR_POT_FORBIDDEN_KEY.test(key), key);
+  }
+});
+
+test("a decomposed Polish letter, a double space or a no-break space still pass (review 2026-10-06 L9)", () => {
+  assert.equal(checkDisclosure("współpraca reklamowa".normalize("NFD")).result, "pass");
+  assert.equal(checkDisclosure("materiał  reklamowy").result, "pass");
+  assert.equal(checkDisclosure("płatna\u00a0współpraca").result, "pass");
+});
+
+test("a tag glued to the word before it starts at its #, so the fold is judged from there", () => {
+  const caption = "x".repeat(DISCLOSURE_VISIBLE_CHARS - 2) + "x#reklama";
+  const check = checkDisclosure(caption);
+  assert.equal(check.at, DISCLOSURE_VISIBLE_CHARS - 1);
+  assert.equal(check.result, "pass");
+  assert.equal(check.found, "#reklama");
+});
+
+test("the money helpers never throw on a non-whole input", () => {
+  assert.equal(potBonusMinor(Number.NaN, 1000), 0);
+  assert.equal(potBonusMinor(100, Number.POSITIVE_INFINITY), 0);
+  assert.equal(potViewsAtMax({ guaranteeMinor: 0, ratePer1000Minor: 0.5, maxMinor: 100 }), null);
+  assert.equal(potCostPer1000Minor(10.5, 1000), 10);
+  assert.equal(potCostPer1000Minor(100, Number.NaN), null);
+});
+
+// ── States, events, DTOs ─────────────────────────────────────────────────────
+
+test("the pot board columns are the approved design's, in order", () => {
+  assert.deepEqual([...POT_STEPS], ["invited", "applied", "accepted", "material_in", "scheduled", "counting", "final", "done"]);
+});
+
+test("every pot act is an event kind, recorded with actor and amount (FR-021, FR-033)", () => {
+  for (const kind of [
+    "pot_applied",
+    "pot_application_withdrawn",
+    "pot_accepted",
+    "pot_declined",
+    "pot_released",
+    "pot_refilled",
+    "pot_moved",
+    "pot_deadline_moved",
+    "pot_publish_time_set",
+    "pot_publish_time_confirmed",
+    "pot_publish_refused",
+    "pot_published",
+    "pot_counted",
+    "pot_frozen",
+    "pot_bonus_held",
+    "pot_bonus_approved",
+    "pot_bonus_capped",
+    "pot_bonus_message",
+    "pot_kept",
+    "pot_broken",
+    "caption_edited",
+    "file_uploaded",
+    "file_removed",
+  ]) {
+    assert.ok((AGENCY_CAMPAIGN_EVENT_KINDS as readonly string[]).includes(kind), kind);
+  }
+});
+
+test("the pot analytics events are snake_case and carry the agency prefix", () => {
+  const pot = Object.entries(EVENTS).filter(([name]) => name.startsWith("AGENCY_POT_"));
+  assert.ok(pot.length >= 6);
+  for (const [, value] of pot) assert.match(value, /^agency_pot_[a-z_]+$/);
+});
+
+test("an application constructs empty, as the validation pipe does", () => {
+  assert.doesNotThrow(() => new ApplyToPotDto());
+  assert.equal(new ApplyToPotDto({ guaranteeMinor: 5, ratePer1000Minor: 7 }).ratePer1000Minor, 7);
+});
+
+test("the agency's decision on a removal after the bonus window is keep or withhold, nothing else", () => {
+  assert.deepEqual([...POT_REMOVAL_DECISIONS], ["keep_base", "withhold_base"]);
+});
+
+test("a pot is kept in a two-decimal currency only", () => {
+  const errors = (potCurrency: string) =>
+    validateSync(new CreateAgencyCampaignDto({ name: "x", kind: "pot", potCurrency })).filter((e) => e.property === "potCurrency");
+  for (const c of POT_CURRENCIES) assert.deepEqual(errors(c), [], c);
+  for (const c of ["JPY", "KWD", "pln", "XXX"]) assert.equal(errors(c).length, 1, c);
+});