abmp-npm 2.0.76 → 2.0.78

package/backend/__tests__/ensure-unique-urls-in-batch.test.js

@@ -1,129 +0,0 @@
-const { ensureUniqueUrlsInBatch } = require('../daily-pull/bulk-process-methods');
-const membersDataMethods = require('../members-data-methods');
-jest.mock('../members-data-methods');
-
-describe('ensureUniqueUrlsInBatch', () => {
-  beforeEach(() => {
-    membersDataMethods.getMemberBySlug.mockReset();
-  });
-
-  describe('case-insensitivity (regression: avoid creating John-12 AND john-12)', () => {
-    test('merges John-11 and john-11 into one group and assigns unique sequential URLs', async () => {
-      membersDataMethods.getMemberBySlug.mockResolvedValue({ url: 'John-11', memberId: 1 });
-
-      const members = [
-        { memberId: 101, url: 'John-11', fullName: 'John Doe' },
-        { memberId: 102, url: 'john-11', fullName: 'John Doe' },
-      ];
-
-      const result = await ensureUniqueUrlsInBatch(members);
-
-      const urls = result.map(m => m.url);
-
-      expect(urls).toHaveLength(2);
-      expect(new Set(urls).size).toBe(2);
-      expect(urls.some(u => u.endsWith('-12'))).toBe(true);
-      expect(urls.some(u => u.endsWith('-13'))).toBe(true);
-    });
-
-    test('does NOT create both John-12 and john-12 (case duplicate)', async () => {
-      membersDataMethods.getMemberBySlug.mockResolvedValue({ url: 'John-11', memberId: 1 });
-
-      const members = [
-        { memberId: 101, url: 'John-11' },
-        { memberId: 102, url: 'john-11' },
-      ];
-
-      const result = await ensureUniqueUrlsInBatch(members);
-      const urls = result.map(m => m.url);
-
-      const hasJohn12 = urls.some(u => u === 'John-12');
-      const hasjohn12 = urls.some(u => u === 'john-12');
-      expect(hasJohn12 && hasjohn12).toBe(false);
-    });
-
-    test('handles JOHN, John, john variants - all merge into single group', async () => {
-      membersDataMethods.getMemberBySlug.mockResolvedValue(null);
-
-      const members = [
-        { memberId: 101, url: 'JOHN-5' },
-        { memberId: 102, url: 'John-5' },
-        { memberId: 103, url: 'john-5' },
-      ];
-
-      const result = await ensureUniqueUrlsInBatch(members);
-      const urls = result.map(m => m.url);
-
-      expect(urls).toHaveLength(3);
-      expect(new Set(urls).size).toBe(3);
-      const bases = urls.map(u => u.replace(/-\d+$/, '').toLowerCase());
-      expect(new Set(bases).size).toBe(1);
-    });
-  });
-
-  describe('multiple members with same base URL', () => {
-    test('assigns sequential counters starting after batch max and DB max', async () => {
-      membersDataMethods.getMemberBySlug.mockResolvedValue({
-        url: 'firstNameLastName-11',
-        memberId: 1,
-      });
-
-      const members = [
-        { memberId: 201, url: 'firstNameLastName-11' },
-        { memberId: 202, url: 'firstNameLastName-11' },
-        { memberId: 203, url: 'firstNameLastName-11' },
-      ];
-
-      const result = await ensureUniqueUrlsInBatch(members);
-      const urls = result.map(m => m.url).sort();
-
-      expect(urls).toEqual([
-        'firstNameLastName-12',
-        'firstNameLastName-13',
-        'firstNameLastName-14',
-      ]);
-    });
-
-    test('uses batch max when DB has no matches', async () => {
-      membersDataMethods.getMemberBySlug.mockResolvedValue(null);
-
-      const members = [
-        { memberId: 301, url: 'testUser-5' },
-        { memberId: 302, url: 'testUser-5' },
-      ];
-
-      const result = await ensureUniqueUrlsInBatch(members);
-      const urls = result.map(m => m.url).sort();
-
-      expect(urls).toEqual(['testUser-6', 'testUser-7']);
-    });
-  });
-
-  describe('edge cases', () => {
-    test('returns empty array unchanged', async () => {
-      const result = await ensureUniqueUrlsInBatch([]);
-      expect(result).toEqual([]);
-    });
-
-    test('returns non-array unchanged', async () => {
-      const input = { not: 'array' };
-      const result = await ensureUniqueUrlsInBatch(input);
-      expect(result).toBe(input);
-    });
-
-    test('skips members without url', async () => {
-      membersDataMethods.getMemberBySlug.mockResolvedValue(null);
-
-      const members = [
-        { memberId: 401, url: 'validUrl' },
-        { memberId: 402, url: null },
-        { memberId: 403 },
-      ];
-
-      const result = await ensureUniqueUrlsInBatch(members);
-      expect(result).toHaveLength(3);
-      expect(result[0].url).toBe('validUrl');
-      expect(result[1].url).toBeNull();
-    });
-  });
-});

package/backend/__tests__/login-email-sync.test.js

@@ -1,49 +0,0 @@
-const { LOGIN_EMAIL_SYNC_STATUS } = require('../consts');
-const { summarizeLoginEmailOutcomes } = require('../daily-pull/utils');
-
-const { UPDATED, FAILED, SKIPPED } = LOGIN_EMAIL_SYNC_STATUS;
-
-describe('summarizeLoginEmailOutcomes', () => {
-  test('collects only FAILED outcomes as failures and failed ids', () => {
-    const outcomes = [
-      { memberId: 1, wixMemberId: 'w1', desiredEmail: 'a@x.com', status: UPDATED },
-      {
-        memberId: 2,
-        wixMemberId: 'w2',
-        desiredEmail: 'b@x.com',
-        status: FAILED,
-        error: 'duplicate',
-      },
-      { memberId: 3, status: SKIPPED, desiredEmail: 'c@x.com' },
-    ];
-
-    const { failedMemberIds, failures } = summarizeLoginEmailOutcomes(outcomes);
-
-    expect([...failedMemberIds]).toEqual([2]);
-    expect(failures).toEqual([
-      { memberId: 2, wixMemberId: 'w2', desiredEmail: 'b@x.com', error: 'duplicate' },
-    ]);
-  });
-
-  test('UPDATED and SKIPPED never produce failures (CMS email is left to advance/no-op)', () => {
-    const outcomes = [
-      { memberId: 1, status: UPDATED, desiredEmail: 'a@x.com' },
-      { memberId: 2, status: SKIPPED, desiredEmail: 'b@x.com' },
-    ];
-    const { failedMemberIds, failures } = summarizeLoginEmailOutcomes(outcomes);
-    expect(failedMemberIds.size).toBe(0);
-    expect(failures).toEqual([]);
-  });
-
-  test('defaults a missing error message', () => {
-    const { failures } = summarizeLoginEmailOutcomes([
-      { memberId: 9, wixMemberId: 'w9', desiredEmail: 'z@x.com', status: FAILED },
-    ]);
-    expect(failures[0].error).toBe('unknown error');
-  });
-
-  test('handles empty / missing input', () => {
-    expect(summarizeLoginEmailOutcomes([]).failures).toEqual([]);
-    expect(summarizeLoginEmailOutcomes().failures).toEqual([]);
-  });
-});

package/backend/__tests__/transient-retry-and-bulk-lookup.test.js

@@ -1,129 +0,0 @@
-jest.mock('../elevated-modules', () => ({
-  wixData: { query: jest.fn() },
-}));
-
-const { wixData } = require('../elevated-modules');
-const { findMembersByIds } = require('../members-data-methods');
-const { withTransientErrorRetry, isTransientNetworkError } = require('../utils');
-
-const makeQueryResult = items => ({ items, hasNext: () => false });
-
-const mockQueryReturning = find => {
-  const query = {
-    hasSome: jest.fn().mockReturnThis(),
-    limit: jest.fn().mockReturnThis(),
-    find,
-  };
-  wixData.query.mockReturnValue(query);
-  return query;
-};
-
-describe('isTransientNetworkError', () => {
-  test('matches undici "fetch failed" and common network error codes', () => {
-    expect(isTransientNetworkError(new Error('fetch failed'))).toBe(true);
-    expect(isTransientNetworkError({ message: 'request failed', code: 'ECONNRESET' })).toBe(true);
-    expect(
-      isTransientNetworkError({ message: 'fetch failed', cause: { code: 'UND_ERR_SOCKET' } })
-    ).toBe(true);
-  });
-
-  test('does not match application errors', () => {
-    expect(isTransientNetworkError(new Error('Multiple members found with memberId 1'))).toBe(
-      false
-    );
-    expect(isTransientNetworkError(new Error('WDE0025: validation failed'))).toBe(false);
-  });
-});
-
-describe('withTransientErrorRetry', () => {
-  test('retries transient failures and resolves with the eventual result', async () => {
-    const operation = jest
-      .fn()
-      .mockRejectedValueOnce(new Error('fetch failed'))
-      .mockResolvedValueOnce('ok');
-
-    await expect(withTransientErrorRetry(operation, { baseDelayMs: 1 })).resolves.toBe('ok');
-    expect(operation).toHaveBeenCalledTimes(2);
-  });
-
-  test('rethrows immediately on non-transient errors', async () => {
-    const operation = jest.fn().mockRejectedValue(new Error('validation failed'));
-
-    await expect(withTransientErrorRetry(operation, { baseDelayMs: 1 })).rejects.toThrow(
-      'validation failed'
-    );
-    expect(operation).toHaveBeenCalledTimes(1);
-  });
-
-  test('gives up after the configured number of retries', async () => {
-    const operation = jest.fn().mockRejectedValue(new Error('fetch failed'));
-
-    await expect(
-      withTransientErrorRetry(operation, { retries: 2, baseDelayMs: 1 })
-    ).rejects.toThrow('fetch failed');
-    expect(operation).toHaveBeenCalledTimes(3);
-  });
-});
-
-describe('findMembersByIds', () => {
-  beforeEach(() => {
-    wixData.query.mockReset();
-  });
-
-  test('returns a map of String(memberId) to member record', async () => {
-    mockQueryReturning(
-      jest.fn().mockResolvedValue(
-        makeQueryResult([
-          { _id: 'a', memberId: 1 },
-          { _id: 'b', memberId: 2 },
-        ])
-      )
-    );
-
-    const membersById = await findMembersByIds([1, 2, 3]);
-
-    expect(membersById.get('1')).toEqual({ _id: 'a', memberId: 1 });
-    expect(membersById.get('2')).toEqual({ _id: 'b', memberId: 2 });
-    expect(membersById.has('3')).toBe(false);
-  });
-
-  test('deduplicates input IDs and skips null/undefined before querying', async () => {
-    const query = mockQueryReturning(jest.fn().mockResolvedValue(makeQueryResult([])));
-
-    await findMembersByIds([1, 1, null, undefined, 2]);
-
-    expect(query.hasSome).toHaveBeenCalledWith('memberId', [1, 2]);
-  });
-
-  test('returns an empty map without querying when there are no IDs', async () => {
-    const membersById = await findMembersByIds([]);
-
-    expect(membersById.size).toBe(0);
-    expect(wixData.query).not.toHaveBeenCalled();
-  });
-
-  test('chunks large ID lists into multiple queries', async () => {
-    const query = mockQueryReturning(jest.fn().mockResolvedValue(makeQueryResult([])));
-    const ids = Array.from({ length: 250 }, (_, i) => i + 1);
-
-    await findMembersByIds(ids);
-
-    expect(query.hasSome).toHaveBeenCalledTimes(3);
-    expect(query.hasSome.mock.calls.map(call => call[1].length)).toEqual([100, 100, 50]);
-  });
-
-  test('throws when multiple records share the same memberId', async () => {
-    mockQueryReturning(
-      jest.fn().mockResolvedValue(
-        makeQueryResult([
-          { _id: 'a', memberId: 1 },
-          { _id: 'b', memberId: 1 },
-        ])
-      )
-    );
-
-    await expect(findMembersByIds([1])).rejects.toThrow(
-      'Multiple members found with memberId(s): [1]'
-    );
-  });
-});

package/backend/__tests__/url-uniqueness.test.js

@@ -1,194 +0,0 @@
-const { incrementUrlCounter, extractBaseUrl } = require('../daily-pull/utils');
-const {
-  normalizeUrlForComparison,
-  sortByUrlCounterDescending,
-  extractUrlCounter,
-} = require('../utils');
-
-// ─── Helpers ─────────────────────────────────────────────────────────
-
-/**
- * Simulates getMemberBySlug's normalized-comparison branch using
- * the ACTUAL production sort comparator imported from utils.js.
- */
-function simulateGetHighestMember(allMembers, slug) {
-  const matching = allMembers.filter(
-    m => m.url && normalizeUrlForComparison(m.url) === slug.toLowerCase()
-  );
-  matching.sort(sortByUrlCounterDescending);
-  return matching[0] || null;
-}
-
-/**
- * Simulates ensureUniqueUrl's counter-increment logic given the
- * "highest" member returned by getMemberBySlug.
- */
-function simulateEnsureUniqueUrl(baseSlug, highestMember) {
-  if (!highestMember || !highestMember.url) return baseSlug;
-  return incrementUrlCounter(highestMember?.url, baseSlug);
-}
-
-// ─── Test data ───────────────────────────────────────────────────────
-
-function buildMembersInDb() {
-  return [
-    { memberId: 1, url: 'firstNameLastName' },
-    { memberId: 2, url: 'firstNameLastName-1' },
-    { memberId: 3, url: 'firstNameLastName-2' },
-    { memberId: 4, url: 'firstNameLastName-3' },
-    { memberId: 5, url: 'firstNameLastName-4' },
-    { memberId: 6, url: 'firstNameLastName-5' },
-    { memberId: 7, url: 'firstNameLastName-6' },
-    { memberId: 8, url: 'firstNameLastName-7' },
-    { memberId: 9, url: 'firstNameLastName-8' },
-    { memberId: 10, url: 'firstNameLastName-9' },
-    { memberId: 11, url: 'firstNameLastName-10' },
-    { memberId: 12, url: 'firstNameLastName-11' },
-    { memberId: 13, url: 'firstNameLastName-12' },
-  ];
-}
-
-function buildLargeCounterMembers() {
-  const members = [];
-  for (let i = 0; i <= 105; i++) {
-    members.push({ memberId: i, url: i === 0 ? 'testUser' : `testUser-${i}` });
-  }
-  return members;
-}
-
-// ─── Tests ───────────────────────────────────────────────────────────
-
-describe('Production sort: getMemberBySlug must return the HIGHEST counter', () => {
-  test('should return -12 as the highest URL (not -9)', () => {
-    const members = buildMembersInDb();
-    const highest = simulateGetHighestMember(members, 'firstnamelastname');
-
-    expect(highest.url).toBe('firstNameLastName-12');
-  });
-
-  test('should sort -12 above -9 in descending order', () => {
-    const members = buildMembersInDb();
-    const sorted = [...members]
-      .filter(m => normalizeUrlForComparison(m.url) === 'firstnamelastname')
-      .sort(sortByUrlCounterDescending);
-    const sortedUrls = sorted.map(m => m.url);
-
-    const indexOf9 = sortedUrls.indexOf('firstNameLastName-9');
-    const indexOf12 = sortedUrls.indexOf('firstNameLastName-12');
-
-    expect(indexOf12).toBeLessThan(indexOf9);
-  });
-
-  test('should handle large counters (100+) correctly', () => {
-    const members = buildLargeCounterMembers();
-    const highest = simulateGetHighestMember(members, 'testuser');
-
-    expect(highest.url).toBe('testUser-105');
-  });
-
-  test('should handle hyphenated names (mary-jane) correctly', () => {
-    const members = [
-      { memberId: 1, url: 'mary-jane' },
-      { memberId: 2, url: 'mary-jane-1' },
-      { memberId: 3, url: 'mary-jane-2' },
-      { memberId: 4, url: 'mary-jane-10' },
-    ];
-
-    const highest = simulateGetHighestMember(members, 'mary-jane');
-    expect(highest.url).toBe('mary-jane-10');
-  });
-});
-
-describe('Production sort: ensureUniqueUrl must generate a truly unique URL', () => {
-  test('should generate -13 (not -10) when DB has URLs up to -12', () => {
-    const members = buildMembersInDb();
-    const highest = simulateGetHighestMember(members, 'firstnamelastname');
-    const newUrl = simulateEnsureUniqueUrl('firstNameLastName', highest);
-
-    expect(newUrl).toBe('firstNameLastName-13');
-
-    const existingUrls = members.map(m => m.url);
-    expect(existingUrls).not.toContain(newUrl);
-  });
-
-  test('repeated daily pulls should produce sequential unique URLs', () => {
-    const members = buildMembersInDb();
-    const generatedUrls = [];
-
-    for (let day = 0; day < 5; day++) {
-      const highest = simulateGetHighestMember(members, 'firstnamelastname');
-      const newUrl = simulateEnsureUniqueUrl('firstNameLastName', highest);
-      generatedUrls.push(newUrl);
-      members.push({ memberId: 100 + day, url: newUrl });
-    }
-
-    expect(new Set(generatedUrls).size).toBe(5);
-    expect(generatedUrls).toEqual([
-      'firstNameLastName-13',
-      'firstNameLastName-14',
-      'firstNameLastName-15',
-      'firstNameLastName-16',
-      'firstNameLastName-17',
-    ]);
-  });
-
-  test('should NOT produce duplicates (the -10 bug)', () => {
-    const members = buildMembersInDb();
-    const highest = simulateGetHighestMember(members, 'firstnamelastname');
-    const newUrl = simulateEnsureUniqueUrl('firstNameLastName', highest);
-
-    expect(newUrl).not.toBe('firstNameLastName-10');
-  });
-});
-
-describe('Production sort: ensureUniqueUrlsInBatch single-member path', () => {
-  test('incrementUrlCounter should produce a unique URL from highest DB member', () => {
-    const members = buildMembersInDb();
-    const dbMember = simulateGetHighestMember(members, 'firstnamelastname');
-    const result = incrementUrlCounter(dbMember.url, 'firstNameLastName');
-
-    expect(result).toBe('firstNameLastName-13');
-
-    const existingUrls = members.map(m => m.url);
-    expect(existingUrls).not.toContain(result);
-  });
-});
-
-describe('Utility functions', () => {
-  test('normalizeUrlForComparison strips trailing counter', () => {
-    expect(normalizeUrlForComparison('firstNameLastName')).toBe('firstnamelastname');
-    expect(normalizeUrlForComparison('firstNameLastName-1')).toBe('firstnamelastname');
-    expect(normalizeUrlForComparison('firstNameLastName-9')).toBe('firstnamelastname');
-    expect(normalizeUrlForComparison('firstNameLastName-10')).toBe('firstnamelastname');
-    expect(normalizeUrlForComparison('firstNameLastName-100')).toBe('firstnamelastname');
-  });
-
-  test('extractUrlCounter returns numeric counter', () => {
-    expect(extractUrlCounter('firstNameLastName')).toBe(-1);
-    expect(extractUrlCounter('firstNameLastName-1')).toBe(1);
-    expect(extractUrlCounter('firstNameLastName-9')).toBe(9);
-    expect(extractUrlCounter('firstNameLastName-10')).toBe(10);
-    expect(extractUrlCounter('firstNameLastName-100')).toBe(100);
-    expect(extractUrlCounter(null)).toBe(-1);
-    expect(extractUrlCounter('')).toBe(-1);
-  });
-
-  test('extractBaseUrl strips numeric counter', () => {
-    expect(extractBaseUrl('firstNameLastName-10')).toBe('firstNameLastName');
-    expect(extractBaseUrl('firstNameLastName-1')).toBe('firstNameLastName');
-    expect(extractBaseUrl('firstNameLastName')).toBe('firstNameLastName');
-    expect(extractBaseUrl('john-doe-3')).toBe('john-doe');
-  });
-
-  test('incrementUrlCounter increments correctly', () => {
-    expect(incrementUrlCounter('firstNameLastName-9', 'firstNameLastName')).toBe(
-      'firstNameLastName-10'
-    );
-    expect(incrementUrlCounter('firstNameLastName-10', 'firstNameLastName')).toBe(
-      'firstNameLastName-11'
-    );
-    expect(incrementUrlCounter('firstNameLastName', 'firstNameLastName')).toBe(
-      'firstNameLastName-1'
-    );
-  });
-});