snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-utils/crowdin-normalizer/utils/__tests__/evaluate-rules.util.spec.ts

@@ -0,0 +1,49 @@
+import { NORMALIZATION_RULES } from '../../constants/normalization-rules.constant';
+import { evaluateRules } from '../evaluate-rules.util';
+
+describe('evaluateRules', () => {
+  it('reports every rule that fired and applies them in sequence', () => {
+    const result = evaluateRules({
+      rules: NORMALIZATION_RULES,
+      sourceText: 'Replace `<path>` with your path',
+      translationText: '\\u62db `&lt;path&gt;`',
+    });
+
+    expect(result.fixedText).toBe('招 `<path>`');
+    expect(result.ruleNames).toEqual([
+      'escaped-unicode',
+      'escaped-inline-code-tags',
+    ]);
+  });
+
+  it('skips source-filtered rules when the source string is unknown', () => {
+    const result = evaluateRules({
+      rules: NORMALIZATION_RULES,
+      sourceText: undefined,
+      translationText: 'Remplacez `&lt;path&gt;` par votre chemin',
+    });
+
+    expect(result.ruleNames).toEqual([]);
+  });
+
+  it('skips source-filtered rules when the source does not match', () => {
+    const result = evaluateRules({
+      rules: NORMALIZATION_RULES,
+      sourceText: 'Escape a literal &lt; in prose',
+      translationText: 'Échappez un &lt; littéral dans le texte',
+    });
+
+    expect(result.ruleNames).toEqual([]);
+  });
+
+  it('returns the translation untouched when no rule fires', () => {
+    const result = evaluateRules({
+      rules: NORMALIZATION_RULES,
+      sourceText: 'Replace `<path>` with your path',
+      translationText: 'Remplacez `<path>` par votre chemin',
+    });
+
+    expect(result.fixedText).toBe('Remplacez `<path>` par votre chemin');
+    expect(result.ruleNames).toEqual([]);
+  });
+});

packages/twenty-utils/crowdin-normalizer/utils/__tests__/is-translation-already-present-error.util.spec.ts

@@ -0,0 +1,67 @@
+import { CrowdinApiError } from '../../errors/crowdin-api.error';
+import { isTranslationAlreadyPresentError } from '../is-translation-already-present-error.util';
+
+const buildError = (body: string) => new CrowdinApiError(400, body);
+
+const buildDetailError = (detail: { code: string; message: string }) =>
+  buildError(
+    JSON.stringify({
+      errors: [{ error: { key: 'translation', errors: [detail] } }],
+    }),
+  );
+
+describe('isTranslationAlreadyPresentError', () => {
+  it('recognises the identical-translation error code', () => {
+    expect(
+      isTranslationAlreadyPresentError(
+        buildDetailError({
+          code: 'identicalTranslation',
+          message: 'Identical translation already saved',
+        }),
+      ),
+    ).toBe(true);
+  });
+
+  it('recognises the duplicate-translation validation error', () => {
+    expect(
+      isTranslationAlreadyPresentError(
+        buildDetailError({
+          code: 'validationError',
+          message:
+            'Duplicate translation. Please vote or approve the original.',
+        }),
+      ),
+    ).toBe(true);
+  });
+
+  it('does not swallow an unrelated validation error', () => {
+    expect(
+      isTranslationAlreadyPresentError(
+        buildDetailError({
+          code: 'validationError',
+          message: 'Translation is too long',
+        }),
+      ),
+    ).toBe(false);
+  });
+
+  it('does not treat another failure as present because of its wording', () => {
+    expect(
+      isTranslationAlreadyPresentError(
+        buildDetailError({
+          code: 'notFound',
+          message: 'String is identical to a deleted one',
+        }),
+      ),
+    ).toBe(false);
+  });
+
+  it('rejects a non-JSON body and any non-Crowdin error', () => {
+    expect(
+      isTranslationAlreadyPresentError(buildError('<html>502</html>')),
+    ).toBe(false);
+    expect(isTranslationAlreadyPresentError(new Error('identical'))).toBe(
+      false,
+    );
+  });
+});

packages/twenty-utils/crowdin-normalizer/utils/__tests__/map-with-concurrency.util.spec.ts

@@ -0,0 +1,51 @@
+import { mapWithConcurrency } from '../map-with-concurrency.util';
+
+describe('mapWithConcurrency', () => {
+  it('keeps results in input order regardless of completion order', async () => {
+    const results = await mapWithConcurrency({
+      items: [30, 10, 20],
+      limit: 3,
+      handler: (delay) =>
+        new Promise<number>((resolve) =>
+          setTimeout(() => resolve(delay), delay),
+        ),
+    });
+
+    expect(results).toEqual([30, 10, 20]);
+  });
+
+  it('never runs more than `limit` handlers at once', async () => {
+    let running = 0;
+    let peak = 0;
+
+    await mapWithConcurrency({
+      items: Array.from({ length: 20 }, (_, index) => index),
+      limit: 3,
+      handler: async (item) => {
+        running++;
+        peak = Math.max(peak, running);
+        await new Promise((resolve) => setTimeout(resolve, 1));
+        running--;
+
+        return item;
+      },
+    });
+
+    expect(peak).toBe(3);
+  });
+
+  it('rejects a limit that would leave every item unhandled', async () => {
+    await expect(
+      mapWithConcurrency({ items: [1], limit: 0, handler: jest.fn() }),
+    ).rejects.toThrow('at least 1');
+  });
+
+  it('returns an empty array without spawning workers', async () => {
+    const handler = jest.fn();
+
+    expect(await mapWithConcurrency({ items: [], limit: 5, handler })).toEqual(
+      [],
+    );
+    expect(handler).not.toHaveBeenCalled();
+  });
+});