= ({
{t('recurrence.expense_for_the_amount_of', {
name: item.expense.name,
- amount: toUIString(item.expense.amount),
- currency: item.expense.currency,
+ amount: toUIString(item.expense.amount, false, true),
+ currency:
+ formatter.formatToParts(0).find(({ type }) => 'currency' === type)?.value ?? '',
})}
@@ -97,7 +97,7 @@ const RecurringExpenseItem: React.FC = ({
};
const RecurringPage: NextPageWithUser = () => {
- const { t, toUIDate, getCurrencyHelpersCached } = useTranslationWithUtils();
+ const { t, toUIDate } = useTranslationWithUtils();
const recurringExpensesQuery = api.expense.getRecurringExpenses.useQuery();
const deleteRecurrenceMutation = api.expense.deleteRecurrence.useMutation();
@@ -105,10 +105,6 @@ const RecurringPage: NextPageWithUser = () => {
const { cronParser, i18nReady } = useIntlCronParser();
- const { toUIString } = getCurrencyHelpersCached(
- recurringExpensesQuery.data?.[0]?.expense.currency ?? 'USD',
- );
-
const handleDelete = useCallback(
async (recurrenceId: number) => {
try {
@@ -151,7 +147,6 @@ const RecurringPage: NextPageWithUser = () => {
item={e}
onDelete={handleDelete}
isDeleting={deleteRecurrenceMutation.isPending}
- toUIString={toUIString}
toUIDate={toUIDate}
cronParser={cronParser}
i18nReady={i18nReady}
diff --git a/src/tests/editRecurrenceDialog.test.tsx b/src/tests/editRecurrenceDialog.test.tsx
new file mode 100644
index 000000000..b14a60c9a
--- /dev/null
+++ b/src/tests/editRecurrenceDialog.test.tsx
@@ -0,0 +1,78 @@
+import { act, createElement } from 'react';
+import { createRoot } from 'react-dom/client';
+
+import { EditRecurrenceDialog } from '~/components/Expense/EditRecurrenceDialog';
+import { cronToBackend } from '~/lib/cron';
+
+const mockUpdate = jest.fn().mockResolvedValue(undefined);
+const mockInvalidate = jest.fn().mockResolvedValue(undefined);
+
+jest.mock('next-i18next', () => ({ useTranslation: () => ({ t: (key: string) => key }) }));
+jest.mock('~/utils/api', () => ({
+ api: {
+ expense: {
+ updateRecurrence: {
+ useMutation: () => ({ mutateAsync: mockUpdate, isPending: false }),
+ },
+ },
+ useUtils: () => ({ expense: { getRecurringExpenses: { invalidate: mockInvalidate } } }),
+ },
+}));
+jest.mock('~/components/ui/drawer', () => ({
+ AppDrawer: ({
+ open,
+ onOpenChange,
+ actionOnClick,
+ }: {
+ open: boolean;
+ onOpenChange: (open: boolean) => void;
+ actionOnClick: () => void;
+ }) =>
+ createElement(
+ 'div',
+ null,
+ createElement('button', { onClick: () => onOpenChange(true) }, 'Edit schedule'),
+ open && createElement('button', { onClick: actionOnClick }, 'Next'),
+ ),
+}));
+jest.mock('~/components/ui/cron-builder', () => ({ CronBuilder: () => null }));
+
+Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+
+describe('EditRecurrenceDialog', () => {
+ it('saves and closes its controlled confirmation dialog without a runtime error', async () => {
+ const container = document.createElement('div');
+ document.body.append(container);
+ const root = createRoot(container);
+ const click = async (label: string) => {
+ const button = Array.from(document.querySelectorAll('button')).find(
+ (element) => element.textContent === label,
+ );
+ expect(button).toBeDefined();
+ await act(async () => button!.click());
+ };
+
+ try {
+ await act(async () => {
+ root.render(
+
+
+ ,
+ );
+ });
+ await click('Edit schedule');
+ await click('Next');
+ expect(document.querySelector('[role="alertdialog"]')).not.toBeNull();
+ await click('actions.confirm');
+ expect(mockUpdate).toHaveBeenCalledWith({
+ recurrenceId: 42,
+ cronExpression: cronToBackend('0 0 * * 0'),
+ });
+ expect(mockInvalidate).toHaveBeenCalledTimes(1);
+ expect(document.querySelector('[role="alertdialog"]')).toBeNull();
+ } finally {
+ await act(async () => root.unmount());
+ container.remove();
+ }
+ });
+});
diff --git a/src/tests/i18n.test.ts b/src/tests/i18n.test.ts
new file mode 100644
index 000000000..0e04f8095
--- /dev/null
+++ b/src/tests/i18n.test.ts
@@ -0,0 +1,341 @@
+/** @jest-environment node */
+
+import { readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { type Resource, createInstance } from 'i18next';
+import { IntlMessageFormat } from 'intl-messageformat';
+import { Trans } from 'next-i18next';
+import { createElement } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { serverSideTranslations } from 'next-i18next/serverSideTranslations';
+import config from '../../next-i18next.config.js';
+import { getCurrencyHelpers } from '~/utils/numbers';
+
+const localePath = join(process.cwd(), 'public/locales');
+const locales = readdirSync(localePath).sort();
+const resources: Resource = Object.fromEntries(
+ locales.map((locale) => [
+ locale,
+ Object.fromEntries(
+ readdirSync(join(localePath, locale)).map((file) => [
+ file.replace(/\.json$/, ''),
+ JSON.parse(readFileSync(join(localePath, locale, file), 'utf8')),
+ ]),
+ ),
+ ]),
+);
+
+const messages = (value: unknown, prefix = ''): [string, string][] => {
+ if ('string' === typeof value) {
+ return [[prefix, value]];
+ }
+ if (!value || 'object' !== typeof value) {
+ throw new Error('Translation messages must be strings or objects');
+ }
+ return Object.entries(value).flatMap(([key, child]) =>
+ messages(child, prefix ? `${prefix}.${key}` : key),
+ );
+};
+
+const createTranslator = async (lng: string, data: Resource = resources) => {
+ const instance = createInstance();
+ config.onPreInitI18next!(instance);
+ await instance.init({
+ lng,
+ ns: ['common', 'home', 'categories', 'currencies'],
+ defaultNS: 'common',
+ fallbackLng: config.fallbackLng,
+ resources: data,
+ i18nFormat: {
+ ...config.i18nFormat,
+ parseErrorHandler: (error: Error) => {
+ throw error;
+ },
+ },
+ });
+ return instance;
+};
+
+describe('ICU migration', () => {
+ it.each(locales)('formats every message in %s without changing its text', async (locale) => {
+ const instance = await createTranslator(locale);
+ for (const [namespace, catalog] of Object.entries(resources[locale]!)) {
+ for (const [key, message] of messages(catalog)) {
+ const formatter = new IntlMessageFormat(
+ message,
+ 'ca@valencia' === locale ? 'ca-ES-valencia' : locale,
+ undefined,
+ { ignoreTag: true },
+ );
+ const values: Record = {};
+ const collectValues = (elements: ReturnType) => {
+ elements.forEach((element) => {
+ if (0 === element.type || 7 === element.type) {
+ return;
+ }
+ if (8 === element.type) {
+ throw new Error('Translation markup requires a component-specific test');
+ }
+ values[element.value] =
+ 6 === element.type
+ ? 2
+ : 5 === element.type
+ ? 'other'
+ : `<${element.value} & 'value'>`;
+ if ('options' in element) {
+ Object.values(element.options).forEach((option) => collectValues(option.value));
+ }
+ });
+ };
+ collectValues(formatter.getAst());
+ expect(instance.t(key, { ns: namespace, ...values })).toBe(formatter.format(values));
+ }
+ }
+ });
+
+ it.each([
+ ['expense_details.balance_list.settled', 'You are settled up', 'Marco is settled up'],
+ ['expense_details.balance_list.lent', 'You lent', 'Marco lent'],
+ ['expense_details.balance_list.owes', 'You owe', 'Marco owes'],
+ ['activity.user_deleted_expense', 'You deleted Dinner', 'Marco deleted Dinner'],
+ ['expense_list.user_paid', 'You paid €10', 'Marco paid €10'],
+ ['expense_list.user_received', 'You received €10', 'Marco received €10'],
+ ['expense_metadata.added_by', 'Added by you on 12 October', 'Added by Marco on 12 October'],
+ ['expense_metadata.edited_by', 'Edited by you on 12 October', 'Edited by Marco on 12 October'],
+ [
+ 'expense_metadata.deleted_by',
+ 'Deleted by you on 12 October',
+ 'Deleted by Marco on 12 October',
+ ],
+ ])('restores both actor forms for %s', async (key, currentUser, otherUser) => {
+ const instance = await createTranslator('en');
+ const values = {
+ person: 'Marco',
+ user: 'Marco',
+ expense: 'Dinner',
+ amount: '€10',
+ date: '12 October',
+ };
+ expect(instance.t(key, { ...values, actor: 'you' })).toBe(currentUser);
+ expect(instance.t(key, { ...values, actor: 'other' })).toBe(otherUser);
+ });
+
+ it.each([
+ [
+ 'you',
+ 'other',
+ 'You pay €10 to Anna',
+ 'Anna gets €10 from you',
+ 'You paid €10 to Anna',
+ 'You pay Anna',
+ ],
+ [
+ 'other',
+ 'you',
+ 'Marco pays €10 to you',
+ 'You get €10 from Marco',
+ 'Marco paid you €10',
+ 'Marco pays you',
+ ],
+ [
+ 'other',
+ 'other',
+ 'Marco pays €10 to Anna',
+ 'Anna gets €10 from Marco',
+ 'Marco paid €10 to Anna',
+ 'Marco pays Anna',
+ ],
+ ])(
+ 'restores nested roles for payer=%s and receiver=%s',
+ async (payerRole, receiverRole, pays, gets, settlement, transfer) => {
+ const instance = await createTranslator('en');
+ const values = {
+ payerRole,
+ receiverRole,
+ senderRole: payerRole,
+ payer: 'Marco',
+ sender: 'Marco',
+ receiver: 'Anna',
+ amount: '€10',
+ };
+ expect(instance.t('balance_list.pays', values)).toBe(pays);
+ expect(instance.t('balance_list.gets', values)).toBe(gets);
+ expect(instance.t('expense_list.settlement', values)).toBe(settlement);
+ expect(instance.t('ui.transfer', values)).toBe(transfer);
+ expect(instance.t('expense_list.conversion_for_users', values)).toBe(
+ `Currency conversion for ${'you' === payerRole ? 'you' : 'Marco'} and ${'you' === receiverRole ? 'you' : 'Anna'}`,
+ );
+ },
+ );
+
+ it.each(['en', 'it', 'fr', 'default'])(
+ 'restores real catalog plurals and fallback for %s',
+ async (locale) => {
+ const instance = await createTranslator(locale);
+ expect(
+ instance.t(
+ 'expense_details.add_expense_details.split_type_section.split_equally_with_count',
+ { count: 1 },
+ ),
+ ).toBe('split equally among 1 person');
+ expect(
+ instance.t(
+ 'expense_details.add_expense_details.split_type_section.split_equally_with_count',
+ { count: 3 },
+ ),
+ ).toBe('split equally among 3 people');
+ expect(instance.t('balance_summary.more', { count: 1 })).toBe('1 more balance');
+ expect(instance.t('balance_summary.more', { count: 2 })).toBe('2 more balances');
+ },
+ );
+
+ it.each(config.i18n.locales)('includes the sign-in error argument in %s', async (locale) => {
+ const instance = await createTranslator(locale);
+ expect(instance.t('errors.signin_error', { error: 'OAuthCallback' })).toContain(
+ 'OAuthCallback',
+ );
+ });
+
+ it('rejects old double-brace interpolation', async () => {
+ const instance = await createTranslator('en', {
+ en: { common: { message: 'Hello {{name}}' } },
+ });
+ expect(() => instance.t('message', { name: 'Marco' })).toThrow();
+ });
+
+ it.each([
+ ['expense_participant.gets', 'you', 'You', 'You get €10'],
+ ['expense_participant.gets', 'other', 'Marco', 'Marco gets €10'],
+ ['expense_participant.owes', 'you', 'You', 'You owe €10'],
+ ['expense_participant.owes', 'other', 'Marco', 'Marco owes €10'],
+ ['expense_participant.paid', 'you', 'You', 'You paid €10'],
+ ['expense_participant.received', 'other', 'Marco', 'Marco received €10'],
+ ])('renders %s with one clickable user component', async (key, actor, name, expected) => {
+ const instance = await createTranslator('en');
+ const html = renderToStaticMarkup(
+ createElement(Trans, {
+ i18n: instance,
+ i18nKey: key,
+ values: { actor },
+ components: {
+ person: createElement('a', { href: '/balances/42' }, name),
+ amount: createElement('span', { className: 'amount' }, '€10'),
+ },
+ }),
+ );
+ expect(html.replace(/<[^>]+>/g, '')).toBe(expected);
+ expect(html.match(/href="\/balances\/42"/g)).toHaveLength(1);
+ expect(html.match(new RegExp(name, 'g'))).toHaveLength(1);
+ expect(html).toContain('€10');
+ });
+
+ it('lets the translation reorder the user and amount components', async () => {
+ const instance = await createTranslator('en', {
+ en: { common: { reordered: ' is owed by ' } },
+ });
+ const html = renderToStaticMarkup(
+ createElement(Trans, {
+ i18n: instance,
+ i18nKey: 'reordered',
+ components: {
+ person: createElement('a', { href: '/balances/42' }, 'Marco'),
+ amount: createElement('span', null, '€10'),
+ },
+ }),
+ );
+ expect(html.replace(/<[^>]+>/g, '')).toBe('€10 is owed by Marco');
+ expect(html).toContain('Marco');
+ });
+
+ it('keeps user-supplied markup inside the component as escaped text', async () => {
+ const instance = await createTranslator('en');
+ const html = renderToStaticMarkup(
+ createElement(Trans, {
+ i18n: instance,
+ i18nKey: 'expense_participant.owes',
+ values: { actor: 'other' },
+ components: {
+ person: createElement(
+ 'a',
+ { href: '/balances/42' },
+ '',
+ ),
+ amount: createElement('span', null, '€10'),
+ },
+ }),
+ );
+ expect(html).toContain('<person href=');
+ expect(html.match(/ {
+ const instance = await createTranslator(locale);
+ const { toUIString, formatter } = getCurrencyHelpers({ locale, currency });
+ const description = instance.t('recurrence.expense_for_the_amount_of', {
+ name: 'QA expense',
+ amount: toUIString(2000n, false, true),
+ currency: formatter.formatToParts(0).find(({ type }) => 'currency' === type)?.value ?? '',
+ });
+ expect(description.split(symbol)).toHaveLength(2);
+ expect(description).not.toContain(currency);
+ });
+
+ it.each(['default', 'zz', 'fr-CA'])('keeps English fallback for %s', async (locale) => {
+ const instance = await createTranslator(locale, {
+ en: { common: { message: 'Hello {name}' } },
+ fr: { common: {} },
+ });
+ expect(instance.t('message', { name: 'Marco' })).toBe('Hello Marco');
+ expect(instance.t('missing.key')).toBe('missing.key');
+ });
+
+ it.each(['en', 'fr', 'default'])('loads serializable SSR resources for %s', async (locale) => {
+ const props = await serverSideTranslations(locale, ['common', 'home'], config);
+ const state = props._nextI18Next!;
+ expect(state.initialLocale).toBe(locale);
+ expect(state.userConfig).toBeNull();
+ expect(state.initialI18nStore.en).toEqual({
+ common: resources.en!.common,
+ home: resources.en!.home,
+ });
+ const hydrated = await createTranslator(
+ locale,
+ JSON.parse(JSON.stringify(state.initialI18nStore)),
+ );
+ const catalogLocale = 'default' === locale ? 'en' : locale;
+ const message = messages(resources[catalogLocale]!.common).find(
+ ([key]) => 'auth.continue_with' === key,
+ )![1];
+ expect(hydrated.t('auth.continue_with', { provider: 'GitHub' })).toBe(
+ message.replace('{provider}', 'GitHub'),
+ );
+ expect(hydrated.t('missing.key')).toBe('missing.key');
+ });
+
+ it('uses ICU plural rules, including exact zero and language-specific categories', async () => {
+ const instance = await createTranslator('en', {
+ en: { common: { items: '{count, plural, =0 {No items} one {# item} other {# items}}' } },
+ pl: {
+ common: {
+ items: '{count, plural, one {# rzecz} few {# rzeczy} many {# rzeczy} other {# rzeczy}}',
+ },
+ },
+ });
+ expect(instance.t('items', { count: 0 })).toBe('No items');
+ expect(instance.t('items', { count: 1 })).toBe('1 item');
+ expect(instance.t('items', { count: 2 })).toBe('2 items');
+ await instance.changeLanguage('pl');
+ expect(instance.t('items', { count: 1 })).toBe('1 rzecz');
+ expect(instance.t('items', { count: 2 })).toBe('2 rzeczy');
+ expect(instance.t('items', { count: 5 })).toBe('5 rzeczy');
+ expect(instance.t('items', { count: 1.5 })).toBe('1,5 rzeczy');
+ });
+});
diff --git a/src/tests/recurring.test.tsx b/src/tests/recurring.test.tsx
new file mode 100644
index 000000000..e90199009
--- /dev/null
+++ b/src/tests/recurring.test.tsx
@@ -0,0 +1,75 @@
+/** @jest-environment node */
+
+import { renderToStaticMarkup } from 'react-dom/server';
+import type { User } from 'next-auth';
+
+import RecurringPage from '~/pages/recurring';
+
+const user: User = {
+ id: 1,
+ name: 'Marco',
+ email: 'marco@example.com',
+ image: '',
+ currency: 'EUR',
+ preferredLanguage: 'en',
+ hiddenFriendIds: [],
+};
+
+const mockRecurrences = ['EUR', 'JPY', 'KWD'].map((currency, id) => ({
+ id,
+ job: { schedule: '0 0 * * *' },
+ expense: {
+ id: String(id),
+ name: currency,
+ currency,
+ amount: 2000n,
+ expenseDate: new Date('2026-10-12T00:00:00Z'),
+ addedByUser: { id: 1, name: 'Marco' },
+ },
+}));
+
+jest.mock('~/utils/api', () => ({
+ api: {
+ expense: {
+ getRecurringExpenses: { useQuery: () => ({ data: mockRecurrences, isPending: false }) },
+ deleteRecurrence: { useMutation: () => ({ isPending: false }) },
+ },
+ useUtils: () => ({ expense: { getRecurringExpenses: {} } }),
+ },
+}));
+jest.mock('~/hooks/useTranslationWithUtils', () => ({
+ useTranslationWithUtils: () => ({
+ t: (key: string, values?: { name: string; amount: string; currency: string }) =>
+ values ? `${values.name}: ${values.amount.trim()} ${values.currency}` : key,
+ toUIDate: () => '12 October',
+ getCurrencyHelpersCached: (currency: string) =>
+ jest.requireActual('~/utils/numbers').getCurrencyHelpers({ locale: 'en', currency }),
+ }),
+}));
+jest.mock('~/hooks/useIntlCronParser', () => ({
+ useIntlCronParser: () => ({ cronParser: () => '', i18nReady: false }),
+}));
+jest.mock('~/components/Layout/MainLayout', () => ({
+ __esModule: true,
+ default: ({ children }: { children: React.ReactNode }) => children,
+}));
+jest.mock('~/components/Expense/EditRecurrenceDialog', () => ({
+ EditRecurrenceDialog: () => null,
+}));
+jest.mock('~/components/SimpleConfirmationDialog', () => ({
+ SimpleConfirmationDialog: () => null,
+}));
+jest.mock('~/components/ui/avatar', () => ({ EntityAvatar: () => null }));
+jest.mock('~/utils/i18n/server', () => ({ withI18nStaticProps: () => () => ({ props: {} }) }));
+
+describe('RecurringPage currencies', () => {
+ it('formats every row in its own currency when decimal places differ', () => {
+ const html = renderToStaticMarkup();
+
+ expect(html).toContain('EUR: 20 €');
+ expect(html).toContain('JPY: 2,000 ¥');
+ expect(html).toContain('KWD: 2 KWD');
+ expect(html).not.toContain('JPY: 20 ¥');
+ expect(html).not.toContain('KWD: 20 KWD');
+ });
+});
diff --git a/src/tests/splitDescription.test.ts b/src/tests/splitDescription.test.ts
new file mode 100644
index 000000000..35c8ef038
--- /dev/null
+++ b/src/tests/splitDescription.test.ts
@@ -0,0 +1,98 @@
+/** @jest-environment node */
+
+import { SplitType, type User } from '@prisma/client';
+import { createInstance } from 'i18next';
+import { readFileSync } from 'node:fs';
+
+import config from '../../next-i18next.config.js';
+import { generateSplitDescription } from '~/utils/strings';
+import { initSplitShares } from '~/store/addStore';
+
+const user = (id: number, name: string): User => ({
+ id,
+ name,
+ email: `qa${id}@example.com`,
+ currency: 'EUR',
+ defaultCurrency: null,
+ emailVerified: null,
+ image: null,
+ preferredLanguage: 'en',
+ obapiProviderId: null,
+ bankingId: null,
+ hiddenFriendIds: [],
+});
+
+const you = user(0, 'Ava');
+const friend = user(1, 'Stanley');
+const thirdPerson = user(2, 'Anna');
+
+const createTranslator = async (locale = 'en') => {
+ const instance = createInstance();
+ config.onPreInitI18next!(instance);
+ await instance.init({
+ lng: locale,
+ defaultNS: 'common',
+ fallbackLng: 'en',
+ resources: Object.fromEntries(
+ ['en', 'fr', 'pt-PT', 'sv'].map((language) => [
+ language,
+ { common: JSON.parse(readFileSync(`public/locales/${language}/common.json`, 'utf8')) },
+ ]),
+ ),
+ i18nFormat: config.i18nFormat,
+ });
+ return instance.t;
+};
+
+describe('generateSplitDescription', () => {
+ it('uses the real ICU plural message for initially selected participants', async () => {
+ const t = await createTranslator();
+ expect(generateSplitDescription(t, SplitType.EQUAL, [you, friend], {}, you, you)).toBe(
+ 'split equally among 2 people',
+ );
+ });
+
+ it.each([
+ [you, friend, false, 'Stanley owes you'],
+ [you, friend, true, 'You owe Stanley'],
+ [friend, you, false, 'You owe Stanley'],
+ [friend, you, true, 'Stanley owes you'],
+ [friend, thirdPerson, false, 'Anna owes Stanley'],
+ [friend, thirdPerson, true, 'Stanley owes Anna'],
+ [you, you, false, 'No one else owes anything'],
+ [you, you, true, 'No one else owes anything'],
+ ])(
+ 'handles payer %j, beneficiary %j, negative=%s',
+ async (payer, beneficiary, negative, expected) => {
+ const t = await createTranslator();
+ const participants = [you, friend, thirdPerson];
+ const shares = Object.fromEntries(
+ participants.map((participant) => [
+ participant.id,
+ { ...initSplitShares(), [SplitType.EQUAL]: participant.id === beneficiary.id ? 1n : 0n },
+ ]),
+ );
+ expect(
+ generateSplitDescription(t, SplitType.EQUAL, participants, shares, payer, you, negative),
+ ).toBe(expected);
+ },
+ );
+
+ it.each([
+ ['fr', 'Stanley te doit'],
+ ['pt-PT', 'Stanley deve-te'],
+ ['sv', 'Stanley är skyldig dig'],
+ ])('interpolates debtor names in %s after the upstream merge', async (locale, expected) => {
+ const t = await createTranslator(locale);
+ expect(
+ generateSplitDescription(
+ t,
+ SplitType.EQUAL,
+ [you, friend],
+ { [you.id]: { ...initSplitShares(), [SplitType.EQUAL]: 0n } },
+ you,
+ you,
+ ),
+ ).toBe(expected);
+ });
+});
diff --git a/src/tests/splitGenerator.test.ts b/src/tests/splitGenerator.test.ts
new file mode 100644
index 000000000..db3b2bd5f
--- /dev/null
+++ b/src/tests/splitGenerator.test.ts
@@ -0,0 +1,51 @@
+/** @jest-environment node */
+
+import { faker } from '@faker-js/faker';
+import { SplitType } from '@prisma/client';
+
+import { generateSplitShares } from '~/dummies/splitGenerator';
+
+jest.mock('@faker-js/faker', () => ({
+ faker: { number: { int: jest.fn() } },
+}));
+
+const mockRandomInt = jest.spyOn(faker.number, 'int');
+
+describe('generateSplitShares percentage seed data', () => {
+ beforeEach(() => jest.clearAllMocks());
+
+ it('returns no shares for no participants', () => {
+ expect(generateSplitShares(SplitType.PERCENTAGE, [])).toEqual({});
+ });
+
+ it('assigns 100% to a single participant', () => {
+ expect(generateSplitShares(SplitType.PERCENTAGE, [{ id: 1 }])[1]?.PERCENTAGE).toBe(10000n);
+ expect(mockRandomInt).not.toHaveBeenCalled();
+ });
+
+ it.each([2, 3, 6, 20])(
+ 'never exceeds 100%% for %i participants even with maximum draws',
+ (count) => {
+ mockRandomInt.mockImplementation((options) => {
+ if (
+ 'object' !== typeof options ||
+ 'number' !== typeof options.min ||
+ 'number' !== typeof options.max
+ ) {
+ throw new Error('Expected explicit random bounds');
+ }
+ expect(options.min).toBeGreaterThanOrEqual(0);
+ expect(options.max).toBeGreaterThanOrEqual(options.min);
+ return options.max;
+ });
+ const participants = Array.from({ length: count }, (_, id) => ({ id }));
+ const shares = generateSplitShares(SplitType.PERCENTAGE, participants);
+ const percentages = participants.map(({ id }) => shares[id]!.PERCENTAGE!);
+ expect(percentages.reduce((total, share) => total + share, 0n)).toBe(10000n);
+ percentages.forEach((share) => {
+ expect(share).toBeGreaterThanOrEqual(0n);
+ expect(share).toBeLessThanOrEqual(10000n);
+ });
+ },
+ );
+});
diff --git a/src/utils/strings.ts b/src/utils/strings.ts
index bd6adcc51..ea01f49d2 100644
--- a/src/utils/strings.ts
+++ b/src/utils/strings.ts
@@ -12,10 +12,9 @@ export const displayName = (
t: TFunction,
user?: Partial | null,
currentUserId?: number,
- useCase?: 'dativus' | 'accusativus',
): string => {
if (currentUserId === user?.id) {
- return t(`actors.you${useCase ? `_${useCase}` : ''}`);
+ return t('actors.you');
}
return user?.name ?? user?.email ?? '';
};
@@ -76,7 +75,9 @@ export function generateSplitDescription(
}
if (1 !== selectedParticipants.length) {
- return `${splitEquallyText} (${selectedParticipants.length})`;
+ return t('expense_details.add_expense_details.split_type_section.split_equally_with_count', {
+ count: selectedParticipants.length,
+ });
}
if (splitParticipant.id === paidBy.id) {