backend-manager 5.0.203 → 5.1.1

package/test/helpers/slugify.js

@@ -0,0 +1,394 @@
+/**
+ * Test: helpers/utilities.slugify()
+ * Unit tests for the canonical URL slug builder.
+ *
+ * Run: npx mgr test helpers/slugify
+ *
+ * slugify is the SSOT used by:
+ *   - BEM admin/post (legacy + modern) for URL + image filenames
+ *   - Sponsorship platform validator.buildFormatted()
+ *
+ * Contract:
+ *   - Strip all non-alphanumeric characters → replace with `-`
+ *   - Collapse runs of `-` into a single `-`
+ *   - Trim leading/trailing `-`
+ *   - Lowercase the result
+ *   - Non-string input → empty string
+ */
+const Utilities = require('../../src/manager/helpers/utilities.js');
+
+const Manager = { libraries: {} };
+const utilities = new Utilities(Manager);
+
+module.exports = {
+  description: 'Utilities.slugify()',
+  type: 'group',
+
+  tests: [
+    // ─── Basic happy path ───
+
+    {
+      name: 'lowercases-simple-string',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('Hello World'), 'hello-world');
+      },
+    },
+
+    {
+      name: 'preserves-numbers',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('Top 10 Products 2025'), 'top-10-products-2025');
+      },
+    },
+
+    {
+      name: 'already-a-slug-passes-through',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('already-a-slug'), 'already-a-slug');
+      },
+    },
+
+    {
+      name: 'single-word-unchanged',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('hello'), 'hello');
+      },
+    },
+
+    // ─── The bug that drove this: collapse runs of `-` ───
+
+    {
+      name: 'collapses-double-dashes-from-literal-hyphen-space',
+      async run({ assert }) {
+        // The real-world example: "Copy- Paste" produced "copy--paste" before the fix
+        assert.equal(
+          utilities.slugify('AI Study Prompts That Work: Copy- Paste Questions for Every Subject'),
+          'ai-study-prompts-that-work-copy-paste-questions-for-every-subject',
+        );
+      },
+    },
+
+    {
+      name: 'collapses-many-consecutive-dashes',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('foo---bar'), 'foo-bar');
+        assert.equal(utilities.slugify('foo-----bar'), 'foo-bar');
+      },
+    },
+
+    {
+      name: 'collapses-mixed-runs-of-special-chars',
+      async run({ assert }) {
+        // " / - / " → multiple non-alphanum → all become one `-`
+        assert.equal(utilities.slugify('foo / - / bar'), 'foo-bar');
+      },
+    },
+
+    // ─── Leading/trailing trim ───
+
+    {
+      name: 'strips-leading-and-trailing-spaces',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('  hello world  '), 'hello-world');
+      },
+    },
+
+    {
+      name: 'strips-leading-and-trailing-dashes',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('---hello---'), 'hello');
+      },
+    },
+
+    {
+      name: 'strips-leading-slash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('/foo/bar'), 'foo-bar');
+      },
+    },
+
+    {
+      name: 'strips-trailing-slash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('foo/bar/'), 'foo-bar');
+      },
+    },
+
+    {
+      name: 'strips-both-slashes',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('/foo/bar/'), 'foo-bar');
+      },
+    },
+
+    // ─── Punctuation ───
+
+    {
+      name: 'colon-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('Title: Subtitle'), 'title-subtitle');
+      },
+    },
+
+    {
+      name: 'comma-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('one, two, three'), 'one-two-three');
+      },
+    },
+
+    {
+      name: 'question-mark-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('What is AI?'), 'what-is-ai');
+      },
+    },
+
+    {
+      name: 'exclamation-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('Hello World!'), 'hello-world');
+      },
+    },
+
+    {
+      name: 'period-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('v1.2.3'), 'v1-2-3');
+      },
+    },
+
+    {
+      name: 'apostrophe-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify("don't stop"), 'don-t-stop');
+      },
+    },
+
+    {
+      name: 'quotes-become-dashes',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('"Hello" said the dog'), 'hello-said-the-dog');
+      },
+    },
+
+    {
+      name: 'parens-become-dashes',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('Function (advanced)'), 'function-advanced');
+      },
+    },
+
+    {
+      name: 'brackets-become-dashes',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('Array[0] access'), 'array-0-access');
+      },
+    },
+
+    {
+      name: 'ampersand-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('Salt & Pepper'), 'salt-pepper');
+      },
+    },
+
+    {
+      name: 'hash-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('issue #42'), 'issue-42');
+      },
+    },
+
+    {
+      name: 'at-sign-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('user@example.com'), 'user-example-com');
+      },
+    },
+
+    // ─── Unicode / non-ASCII ───
+
+    {
+      name: 'em-dash-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('Title — Subtitle'), 'title-subtitle');
+      },
+    },
+
+    {
+      name: 'curly-quotes-become-dashes',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('“Hello”'), 'hello');
+      },
+    },
+
+    {
+      name: 'emoji-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('Rocket 🚀 launch'), 'rocket-launch');
+      },
+    },
+
+    {
+      name: 'accented-chars-become-dashes',
+      async run({ assert }) {
+        // Slugify is ASCII-only by design — accents get stripped to dashes
+        // (Future improvement could be to transliterate, but current behavior is documented here)
+        assert.equal(utilities.slugify('café'), 'caf');
+      },
+    },
+
+    // ─── Whitespace variants ───
+
+    {
+      name: 'tab-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('foo\tbar'), 'foo-bar');
+      },
+    },
+
+    {
+      name: 'newline-becomes-dash',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('foo\nbar'), 'foo-bar');
+      },
+    },
+
+    {
+      name: 'multiple-spaces-collapse',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('foo    bar'), 'foo-bar');
+      },
+    },
+
+    {
+      name: 'mixed-whitespace-collapses',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('foo \t \n bar'), 'foo-bar');
+      },
+    },
+
+    // ─── Edge cases / non-string input ───
+
+    {
+      name: 'empty-string-returns-empty',
+      async run({ assert }) {
+        assert.equal(utilities.slugify(''), '');
+      },
+    },
+
+    {
+      name: 'all-punctuation-returns-empty',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('!@#$%^&*()'), '');
+      },
+    },
+
+    {
+      name: 'only-dashes-returns-empty',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('-----'), '');
+      },
+    },
+
+    {
+      name: 'only-whitespace-returns-empty',
+      async run({ assert }) {
+        assert.equal(utilities.slugify('   '), '');
+      },
+    },
+
+    {
+      name: 'null-returns-empty-string',
+      async run({ assert }) {
+        assert.equal(utilities.slugify(null), '');
+      },
+    },
+
+    {
+      name: 'undefined-returns-empty-string',
+      async run({ assert }) {
+        assert.equal(utilities.slugify(undefined), '');
+      },
+    },
+
+    {
+      name: 'number-returns-empty-string',
+      async run({ assert }) {
+        // Non-string input → empty string (caller is responsible for stringifying)
+        assert.equal(utilities.slugify(42), '');
+      },
+    },
+
+    {
+      name: 'object-returns-empty-string',
+      async run({ assert }) {
+        assert.equal(utilities.slugify({ foo: 'bar' }), '');
+      },
+    },
+
+    {
+      name: 'array-returns-empty-string',
+      async run({ assert }) {
+        assert.equal(utilities.slugify(['hello']), '');
+      },
+    },
+
+    // ─── Real-world examples ───
+
+    {
+      name: 'real-blog-post-title',
+      async run({ assert }) {
+        assert.equal(
+          utilities.slugify('10 Best Productivity Apps for Students in 2025'),
+          '10-best-productivity-apps-for-students-in-2025',
+        );
+      },
+    },
+
+    {
+      name: 'real-blog-post-with-colon-and-slash',
+      async run({ assert }) {
+        assert.equal(
+          utilities.slugify('Beginner\'s Guide: Python vs JavaScript'),
+          'beginner-s-guide-python-vs-javascript',
+        );
+      },
+    },
+
+    {
+      name: 'real-image-alt-text',
+      async run({ assert }) {
+        // The downloadImage() caller uses slugify(alt) to build a tmp filename
+        assert.equal(
+          utilities.slugify('Diagram showing the user flow (v2)'),
+          'diagram-showing-the-user-flow-v2',
+        );
+      },
+    },
+
+    {
+      name: 'real-url-with-blog-prefix-removed-first',
+      async run({ assert }) {
+        // Mimics how callers strip "blog/" before slugifying
+        const url = 'blog/some-existing-post';
+        assert.equal(
+          utilities.slugify(url.replace(/blog\//ig, '')),
+          'some-existing-post',
+        );
+      },
+    },
+
+    // ─── Idempotency ───
+
+    {
+      name: 'idempotent-double-slugify',
+      async run({ assert }) {
+        const once = utilities.slugify('Hello World: Foo & Bar!');
+        const twice = utilities.slugify(once);
+        assert.equal(twice, once, 'Applying slugify twice should equal applying it once');
+      },
+    },
+  ],
+};

package/test/marketing/fixtures/clean.json

@@ -0,0 +1,31 @@
+{
+  "_comment": "Predefined fixture for the `clean` template. Loaded via NEWSLETTER_FIXTURE=clean. Edit freely — no AI involved. Classic content shape: intro + sections[{title, body, cta, image_prompt}].",
+  "subject": "Identity is the new growth lever",
+  "preheader": "Three platform shifts to lock in this week.",
+  "intro": "Identity matters because trust is the new growth lever. Teams that handle this well will spend less time cleaning up later.",
+  "sections": [
+    {
+      "title": "LinkedIn ships verified-profile gates for business accounts",
+      "body": "LinkedIn now requires verified identity attestations on any business profile claiming more than 500 followers. Accounts with documented attribution histories sail through verification in under twelve hours. The practical implication is to lock down your attribution log this week, not next.",
+      "cta": { "label": "Read the brief", "url": "https://somiibo.com/blog/linkedin-verification" },
+      "image_prompt": "Abstract geometric illustration of a verification checkmark inside a layered profile card."
+    },
+    {
+      "title": "Documentation is the new operator moat",
+      "body": "Operator playbooks are now the difference between an account that recovers from a flag and one that gets permanently restricted. Teams running documented processes recover in days. The ones without burn weeks negotiating with support queues.",
+      "cta": { "label": "See the playbook", "url": "https://somiibo.com/blog/operator-playbook" },
+      "image_prompt": "Stack of geometric document layers casting clean shadows on a flat surface."
+    },
+    {
+      "title": "YouTube tests creator-attribution metadata on uploads",
+      "body": "A subset of channels saw a new upload checkbox this week asking whether content was assisted by automation. The checkbox is optional today. Reading the room: it will not stay optional. Creators with clear internal workflows will adapt in an afternoon.",
+      "cta": null,
+      "image_prompt": "Minimalist play button morphing into a label tag, flat geometric style."
+    }
+  ],
+  "signoff": "Best,\nThe Somiibo Team",
+  "citations": [
+    { "note": "LinkedIn flagged 12,000 impersonation attempts in the verified-profile beta.", "source": "Reported by LinkedIn product team, May 2026" },
+    { "note": "Operator playbook adoption up 38% week-over-week in Q2.", "source": "Per platform analytics, May 2026" }
+  ]
+}

package/test/marketing/fixtures/editorial.json

@@ -0,0 +1,31 @@
+{
+  "_comment": "Predefined fixture for the `editorial` template. Loaded via NEWSLETTER_FIXTURE=editorial. Same classic content shape as clean.json — both templates render the same data.",
+  "subject": "Identity is the new growth lever",
+  "preheader": "Three platform shifts to lock in this week.",
+  "intro": "Identity matters because trust is the new growth lever. Teams that handle this well will spend less time cleaning up later, and the patterns emerging this week tell you exactly where to focus.",
+  "sections": [
+    {
+      "title": "LinkedIn ships verified-profile gates for business accounts",
+      "body": "LinkedIn now requires verified identity attestations on any business profile claiming more than 500 followers. The rollout is fast and uneven — some accounts hit the gate inside two days of profile activity, others sit unchallenged for weeks. The pattern that matters is this: accounts with documented attribution histories sail through verification in under twelve hours. Accounts without get queued. The practical implication is to lock down your attribution log this week, not next.",
+      "cta": { "label": "Read the brief", "url": "https://somiibo.com/blog/linkedin-verification" },
+      "image_prompt": "Abstract geometric illustration of a verification checkmark inside a layered profile card."
+    },
+    {
+      "title": "Documentation is the new operator moat",
+      "body": "Operator playbooks — once dismissed as overhead — are now the difference between an account that recovers from a flag and one that gets permanently restricted. The teams already running on documented processes recover in days. The ones without burn weeks negotiating with support queues. Treat your playbook as a compliance artifact, not a knowledge-management nice-to-have.",
+      "cta": { "label": "See the playbook", "url": "https://somiibo.com/blog/operator-playbook" },
+      "image_prompt": "Stack of geometric document layers casting clean shadows on a flat surface."
+    },
+    {
+      "title": "YouTube tests creator-attribution metadata on uploads",
+      "body": "A subset of channels saw a new upload checkbox this week asking whether content was assisted by automation. The checkbox is optional today. Reading the room: it will not stay optional. Creators with clear internal workflows already labeled will adapt in an afternoon. Everyone else will spend a quarter retrofitting.",
+      "cta": null,
+      "image_prompt": "Minimalist play button morphing into a label tag, flat geometric style."
+    }
+  ],
+  "signoff": "Best,\nThe Somiibo Team",
+  "citations": [
+    { "note": "LinkedIn flagged 12,000 impersonation attempts in the verified-profile beta.", "source": "Reported by LinkedIn product team, May 2026" },
+    { "note": "Operator playbook adoption up 38% week-over-week in Q2.", "source": "Per platform analytics, May 2026" }
+  ]
+}

package/test/marketing/fixtures/field-report.json

@@ -0,0 +1,54 @@
+{
+  "_comment": "Predefined fixture for the `field-report` template. Loaded via NEWSLETTER_FIXTURE=field-report. Wire-service content shape: tldr + dateline + dispatches[{kicker, headline, byline, location, lede, dispatch, dataPoints, cta, image_prompt}].",
+  "subject": "LinkedIn tightens identity — operators document everything",
+  "preheader": "Three filings from this week's platform front lines.",
+  "tldr": "LinkedIn is rolling out verified-account scrutiny across every business profile. Operators with paper trails will outrun the rest. Documentation is the new growth lever.",
+  "dateline": "OAKLAND",
+  "signoff": "— Stay sharp,\nThe Somiibo Desk",
+  "citations": [
+    { "note": "LinkedIn flagged 12,000 impersonation attempts in the verified-profile beta.", "source": "Reported by LinkedIn product team, May 2026" },
+    { "note": "Operator playbook adoption up 38% week-over-week in Q2.", "source": "Per platform analytics, May 2026" }
+  ],
+  "dispatches": [
+    {
+      "kicker": "LEAD DISPATCH",
+      "headline": "LinkedIn ships verified-profile gates for every business account",
+      "byline": "Filed by The Somiibo platform desk",
+      "location": "OAKLAND",
+      "lede": "A wave of identity-verification gates is rolling out across LinkedIn business profiles this week — and the platform is not asking politely.",
+      "dispatch": "LinkedIn now requires verified identity attestations on any business profile claiming more than 500 followers. The rollout is fast and uneven: some accounts hit the gate inside two days of profile activity, others sit unchallenged for weeks. The pattern that matters is this — accounts with documented attribution histories sail through verification in under twelve hours. Accounts without get queued. The practical implication is to lock down your attribution log this week, not next.",
+      "dataPoints": [
+        { "label": "PROFILES FLAGGED", "value": "12.4K" },
+        { "label": "AVG REVIEW TIME", "value": "14HR" },
+        { "label": "WoW APPROVAL", "value": "+38%" }
+      ],
+      "cta": { "label": "READ THE BRIEF", "url": "https://somiibo.com/blog/linkedin-verification" },
+      "image_prompt": "Abstract geometric illustration of a verification checkmark inside a layered profile card."
+    },
+    {
+      "kicker": "FIELD NOTES",
+      "headline": "Documentation is the new operator moat",
+      "byline": "Filed by The Somiibo growth desk",
+      "location": "REMOTE",
+      "lede": "The teams surviving this round of platform scrutiny share one habit: they write everything down.",
+      "dispatch": "Operator playbooks — once dismissed as overhead — are now the difference between an account that recovers from a flag and one that gets permanently restricted. The teams already running on documented processes recover in days. The ones without burn weeks negotiating with support queues. Treat your playbook as a compliance artifact, not a knowledge-management nice-to-have.",
+      "dataPoints": [
+        { "label": "RECOVERY (DOCUMENTED)", "value": "4D" },
+        { "label": "RECOVERY (UNDOC)", "value": "21D" }
+      ],
+      "cta": { "label": "SEE THE PLAYBOOK", "url": "https://somiibo.com/blog/operator-playbook" },
+      "image_prompt": "Stack of geometric document layers casting clean shadows on a flat surface."
+    },
+    {
+      "kicker": "WATCH",
+      "headline": "YouTube tests creator-attribution metadata on uploads",
+      "byline": "Filed by The Somiibo signals desk",
+      "location": "NEW YORK",
+      "lede": "A small pilot suggests YouTube will soon ask creators to declare automated tooling and cross-posting workflows at upload time.",
+      "dispatch": "A subset of channels saw a new upload checkbox this week asking whether content was assisted by automation. The checkbox is optional today. Reading the room: it will not stay optional. Creators with clear internal workflows already labeled will adapt in an afternoon. Everyone else will spend a quarter retrofitting.",
+      "dataPoints": [],
+      "cta": null,
+      "image_prompt": "Minimalist play button morphing into a label tag, flat geometric style."
+    }
+  ]
+}