@palladium-ethiopia/esm-billing-app 5.4.2-pre.30

package/src/bill-administration/patient-billing/workspaces/edit-bill/useEditBillFormSchema.tsx

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import { LineItem, MappedBill } from '../../../../types';
+import { useMemo } from 'react';
+import { useBillableServices } from '../../../../bill-administration/service-catalog/billable-service.resource';
+import { useTranslation } from 'react-i18next';
+
+/**
+ * Schema configuration for edit bill form validation
+ * @constant
+ */
+const BILL_FORM_VALIDATION_RULES = {
+  MINIMUM_PRICE: 0,
+  MINIMUM_QUANTITY: 0,
+  MINIMUM_REASON_LENGTH: 1,
+} as const;
+
+/**
+ * Custom hook that returns the Zod schema for edit bill form validation
+ * @returns {z.ZodObject} Zod schema for edit bill form
+ */
+export const useEditBillFormSchema = () => {
+  const { t } = useTranslation();
+  const billFormValidationSchema = z.object({
+    price: z
+      .string({ required_error: 'Price amount is required' })
+      .refine((priceStr) => parseInt(priceStr) > BILL_FORM_VALIDATION_RULES.MINIMUM_PRICE, {
+        message: t('priceShouldBeGreaterThanZero', 'Price should be greater than zero'),
+      }),
+    quantity: z
+      .string({ required_error: 'Quantity amount is required' })
+      .refine((quantityStr) => parseInt(quantityStr) > BILL_FORM_VALIDATION_RULES.MINIMUM_QUANTITY, {
+        message: t('quantityShouldBeGreaterThanZero', 'Quantity should be greater than zero'),
+      }),
+    adjustmentReason: z
+      .string()
+      .min(BILL_FORM_VALIDATION_RULES.MINIMUM_REASON_LENGTH, {
+        message: t('adjustmentReasonIsRequired', 'Adjustment reason is required'),
+      })
+      .trim(),
+  });
+
+  return billFormValidationSchema;
+};
+
+/** Type definition for edit bill form data based on the schema */
+export type EditBillFormData = z.infer<ReturnType<typeof useEditBillFormSchema>>;
+
+/**
+ * Custom hook that returns default values for edit bill form
+ * @param {LineItem} billLineItem - The line item containing price and quantity
+ * @param {MappedBill} existingBill - The bill containing adjustment reason
+ * @returns {EditBillFormData} Default form values
+ */
+export const useDefaultEditBillFormValues = (billLineItem: LineItem, existingBill: MappedBill): EditBillFormData => {
+  return {
+    price: billLineItem?.price.toString(),
+    quantity: billLineItem?.quantity.toString(),
+    adjustmentReason: existingBill?.adjustmentReason,
+  };
+};
+
+/**
+ * Custom hook that provides initial values for the form based on line item and billable services
+ * @param {LineItem} billLineItem - The line item to initialize the form with
+ * @returns {Object} Object containing selected service price, loading state, and selected billable service
+ */
+export const useFormInitialValues = (billLineItem: LineItem) => {
+  const { billableServices, isLoading: isLoadingServices } = useBillableServices();
+
+  const selectedBillableService = useMemo(() => {
+    const billableServiceId = billLineItem?.billableService?.split(':')[0];
+    return billableServiceId ? billableServices.find((service) => service.uuid === billableServiceId) ?? null : null;
+  }, [billableServices, billLineItem.billableService]);
+
+  const selectedServicePrice = useMemo(() => {
+    if (!selectedBillableService?.servicePrices) {
+      return null;
+    }
+
+    return (
+      selectedBillableService.servicePrices.find(
+        (servicePrice) => servicePrice.price.toString() === billLineItem.price.toString(),
+      ) ?? null
+    );
+  }, [selectedBillableService, billLineItem.price]);
+
+  return {
+    selectedServicePrice,
+    isLoadingServices,
+    selectedBillableService,
+  };
+};

package/src/bill-administration/patient-billing/workspaces/waive-bill/waive-bill-form.scss

@@ -0,0 +1,57 @@
+@use '@carbon/layout';
+@use '@carbon/type';
+@use '@carbon/colors';
+
+.buttonContainer {
+  display: flex;
+  justify-content: flex-end;
+  margin-top: -1rem;
+}
+
+.formControlLayer {
+  margin: layout.$spacing-05 0;
+}
+
+.billWaiverDescription {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  column-gap: 1rem;
+  align-items: center;
+  margin-top: 0.125rem;
+  margin-bottom: 0.5rem;
+}
+
+.label {
+  @include type.type-style('heading-compact-01');
+}
+
+.value {
+  @include type.type-style('body-01');
+}
+
+.editFormInput {
+  margin-bottom: layout.$spacing-05;
+}
+.waiverPaymentModeNotFound {
+  margin: layout.$spacing-03;
+}
+
+.form {
+  display: flex;
+  flex-direction: column;
+  justify-content: space-between;
+  height: 100%;
+}
+
+.formContainer {
+  margin: layout.$spacing-05;
+}
+
+.tablet {
+  padding: layout.$spacing-06 layout.$spacing-05;
+  background-color: colors.$white;
+}
+
+.desktop {
+  padding: 0;
+}

package/src/bill-administration/patient-billing/workspaces/waive-bill/waive-bill-form.test.tsx

@@ -0,0 +1,173 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { processBillPayment, usePaymentModes } from '../../../../billing.resource';
+import { WaiveBillForm } from './waive-bill-form.workspace';
+import userEvent from '@testing-library/user-event';
+import { LineItem, MappedBill, PaymentMethod } from '../../../../types';
+import { showSnackbar } from '@openmrs/esm-framework';
+
+const mockedUsePaymentModes = usePaymentModes as jest.MockedFunction<typeof usePaymentModes>;
+const mockProcessBillPayment = processBillPayment as jest.MockedFunction<typeof processBillPayment>;
+const mockShowSnackbar = showSnackbar as jest.MockedFunction<typeof showSnackbar>;
+
+jest.mock('../../../../billing.resource', () => ({
+  processBillPayment: jest.fn(),
+  usePaymentModes: jest.fn(),
+}));
+
+const mockedBill: MappedBill = {
+  id: 1909,
+  uuid: '45143fae-b83d-4768-ada5-621e8dc1229d',
+  patientName: ' Test Patient',
+  identifier: 'MGVDGL ',
+  patientUuid: '03de0a73-67f1-483f-a9e3-b432295c014a',
+  status: 'PENDING',
+  receiptNumber: '1937-2',
+  cashier: {
+    uuid: '48b55692-e061-4ffa-b1f2-fd4aaf506224',
+    display: 'admin - Super User',
+    links: [],
+  },
+  cashPointUuid: '54065383-b4d4-42d2-af4d-d250a1fd2590',
+  cashPointName: 'OPD Cash Point',
+  cashPointLocation: 'Moi Teaching Refferal Hospital',
+  dateCreated: 'Today, 00:33',
+  lineItems: [
+    {
+      uuid: 'e53c5589-e588-4bb9-bb72-6d4d16189679',
+      display: 'BillLineItem',
+      voided: false,
+      voidReason: null,
+      item: '',
+      billableService: '3f5d0684-a280-477e-a67b-2a956a1f6dca:Registration Revist',
+      quantity: 1,
+      price: 50,
+      priceName: 'Default',
+      priceUuid: '',
+      lineItemOrder: 0,
+      paymentStatus: 'PENDING',
+      resourceVersion: '1.8',
+      itemOrServiceConceptUuid: '',
+    } as unknown as LineItem,
+  ],
+  billingService: '3f5d0684-a280-477e-a67b-2a956a1f6dca:Registration Revist',
+  payments: [],
+  display: '1937-2',
+  totalAmount: 50,
+  dateCreatedUnformatted: '',
+};
+
+const mockedPaymentMode = [
+  {
+    uuid: 'eb6173cb-9678-4614-bbe1-0ccf7ed9d1d4',
+    name: 'Waiver',
+    description: 'Waiver payment',
+    retired: false,
+    retireReason: null,
+    auditInfo: null,
+    sortOrder: 0,
+    resourceVersion: '1.8',
+    attributeTypes: [
+      {
+        uuid: 'eb6173cb-9678-4614-bbe1-0ccf7ed9d1d4',
+        name: 'Waiver',
+        description: 'Waiver payment',
+        retired: false,
+      },
+    ],
+  } as unknown as PaymentMethod,
+];
+
+describe('BillWaiverForm', () => {
+  test('Should post waiver correctly', async () => {
+    const user = userEvent.setup();
+    mockedUsePaymentModes.mockReturnValue({
+      paymentModes: mockedPaymentMode,
+      isLoading: false,
+      error: null,
+      mutate: jest.fn(),
+    });
+    render(
+      <WaiveBillForm
+        bill={mockedBill}
+        closeWorkspace={jest.fn()}
+        patientUuid="some-patient-uuid"
+        promptBeforeClosing={jest.fn()}
+        setTitle={jest.fn()}
+        closeWorkspaceWithSavedChanges={jest.fn()}
+      />,
+    );
+    expect(screen.getByText('Bill Items')).toBeInTheDocument();
+
+    // get waiver amount input
+    const waiverAmountInput = screen.getByRole('spinbutton', { name: 'Enter amount to waive' });
+    const waiverReasonInput = screen.getByRole('textbox', { name: 'Waiver reason' });
+
+    // Input waiver amount and reason
+    await user.type(waiverAmountInput, '50');
+    await user.type(waiverReasonInput, 'Test reason');
+
+    // should display error if amount keyed in is greater than total amount
+    expect(screen.queryByText('Amount to waive cannot be greater than total amount')).toBeNull();
+    await user.type(waiverAmountInput, '100');
+    expect(screen.getByText('Amount to waive cannot be greater than total amount')).toBeInTheDocument();
+
+    // should post waiver correctly
+    mockProcessBillPayment.mockResolvedValue({
+      headers: new Headers(),
+      ok: true,
+      redirected: false,
+      status: 200,
+      statusText: 'OK',
+      type: 'basic',
+      url: 'http://example.com',
+      body: null,
+    } as any);
+    await user.clear(waiverAmountInput);
+    await user.type(waiverAmountInput, '50');
+    await user.click(screen.getByRole('button', { name: 'Post waiver' }));
+
+    expect(mockProcessBillPayment).toHaveBeenCalledTimes(1);
+
+    const expectedBill = {
+      cashPoint: mockedBill.cashPointUuid,
+      cashier: mockedBill.cashier.uuid,
+      lineItems: [
+        {
+          uuid: 'e53c5589-e588-4bb9-bb72-6d4d16189679',
+          display: 'BillLineItem',
+          voided: false,
+          voidReason: null,
+          item: '3f5d0684-a280-477e-a67b-2a956a1f6dca',
+          billableService: '3f5d0684-a280-477e-a67b-2a956a1f6dca',
+          quantity: 1,
+          price: 50,
+          priceName: 'Default',
+          priceUuid: '',
+          lineItemOrder: 0,
+          paymentStatus: 'PAID',
+          resourceVersion: '1.8',
+          itemOrServiceConceptUuid: '',
+        },
+      ],
+      payments: [
+        {
+          amount: 50,
+          amountTendered: 50,
+          attributes: [{ attributeType: mockedPaymentMode[0].uuid, value: 'Test reason' }],
+          instanceType: mockedPaymentMode[0].uuid,
+        },
+      ],
+      patient: mockedBill.patientUuid,
+    };
+
+    expect(mockProcessBillPayment).toHaveBeenCalledWith(expectedBill, '45143fae-b83d-4768-ada5-621e8dc1229d');
+    expect(mockShowSnackbar).toHaveBeenCalledWith({
+      title: 'Bill waiver',
+      subtitle: 'Bill waiver successful',
+      kind: 'success',
+      timeoutInMs: 3500,
+      isLowContrast: true,
+    });
+  });
+});

package/src/bill-administration/patient-billing/workspaces/waive-bill/waive-bill-form.workspace.tsx

@@ -0,0 +1,232 @@
+import React, { useEffect } from 'react';
+import {
+  FormGroup,
+  Layer,
+  Button,
+  NumberInput,
+  TextArea,
+  InlineNotification,
+  InlineLoading,
+  ButtonSet,
+} from '@carbon/react';
+import { TaskAdd } from '@carbon/react/icons';
+import { useTranslation } from 'react-i18next';
+import styles from './waive-bill-form.scss';
+import { MappedBill } from '../../../../types';
+import { createBillWaiverPayload, extractErrorMessagesFromResponse } from '../../../../utils';
+import { processBillPayment, usePaymentModes } from '../../../../billing.resource';
+import { restBaseUrl, showSnackbar, useLayoutType } from '@openmrs/esm-framework';
+import { mutate } from 'swr';
+import { z } from 'zod';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { Controller, SubmitHandler, useForm } from 'react-hook-form';
+import first from 'lodash-es/first';
+import classNames from 'classnames';
+import { useCurrencyFormatting } from '../../../../helpers/currency';
+import { extractString } from '../../../../helpers';
+
+type BillWaiverFormProps = {
+  bill: MappedBill;
+  closeWorkspace: () => void;
+  closeWorkspaceWithSavedChanges?: () => void;
+  promptBeforeClosing?: (testFcn: () => boolean) => void;
+};
+
+export const WaiveBillForm: React.FC<BillWaiverFormProps> = ({
+  bill,
+  closeWorkspace,
+  promptBeforeClosing,
+  closeWorkspaceWithSavedChanges,
+}) => {
+  const { lineItems = [], payments = [] } = bill ?? {};
+  const isTablet = useLayoutType() === 'tablet';
+
+  const { t } = useTranslation();
+  const { format: formatCurrency } = useCurrencyFormatting();
+
+  const totalAmount = lineItems.reduce((acc, curr) => acc + curr.price * curr.quantity, 0);
+  const { isLoading, paymentModes = [] } = usePaymentModes(false);
+  const waiverPaymentMode =
+    first(paymentModes.filter((mode) => mode.name.toLowerCase().includes('waiver')))?.attributeTypes ?? [];
+  // calculate amount already waived or paid this is to ensure that the amount to waive is not greater than the total amount
+  const amountAlreadyWaivedOrPaid = payments.reduce((acc, curr) => acc + curr.amountTendered, 0);
+
+  const schema = z.object({
+    waiveAmount: z
+      .string({ required_error: t('waiveAmountRequired', 'Waive amount is required') })
+      .refine((n) => parseInt(n) > 0, {
+        message: t('waiveAmountGreaterThanZero', 'Amount to waive should be greater than zero'),
+      })
+      .refine(
+        (n) =>
+          amountAlreadyWaivedOrPaid > 0
+            ? parseInt(n) < totalAmount - amountAlreadyWaivedOrPaid + 1
+            : parseInt(n) < totalAmount + 1,
+        {
+          message:
+            amountAlreadyWaivedOrPaid > 0
+              ? t(
+                  'waiveAmountCannotBeGreaterThanRemainingAmount',
+                  'Amount to waive cannot be greater than the remaining amount {{remainingAmount}}',
+                  {
+                    remainingAmount: totalAmount - amountAlreadyWaivedOrPaid,
+                  },
+                )
+              : t('waiveAmountCannotBeGreaterThanTotal', 'Amount to waive cannot be greater than total amount'),
+        },
+      ),
+    waiverReason: z
+      .string({ required_error: t('waiverReasonRequired', 'Waiver reason is required') })
+      .min(1, { message: t('waiverReasonRequired', 'Waiver reason is required') }),
+  });
+
+  type FormData = z.infer<typeof schema>;
+
+  const {
+    control,
+    handleSubmit,
+    formState: { errors, isDirty, isSubmitting, isValid },
+  } = useForm<FormData>({
+    mode: 'all',
+    resolver: zodResolver(schema),
+  });
+
+  useEffect(() => {
+    promptBeforeClosing(() => isDirty);
+  }, [isDirty, promptBeforeClosing]);
+
+  if (lineItems?.length === 0) {
+    return null;
+  }
+
+  const onSubmit: SubmitHandler<FormData> = ({ waiveAmount, waiverReason }) => {
+    const waiverEndPointPayload = createBillWaiverPayload(
+      bill,
+      parseInt(waiveAmount),
+      totalAmount,
+      lineItems,
+      paymentModes,
+      waiverReason,
+    );
+
+    processBillPayment(waiverEndPointPayload, bill.uuid).then(
+      (resp) => {
+        showSnackbar({
+          title: t('billWaiver', 'Bill waiver'),
+          subtitle: t('billWaiverSuccess', 'Bill waiver successful'),
+          kind: 'success',
+          timeoutInMs: 3500,
+          isLowContrast: true,
+        });
+        mutate((key) => typeof key === 'string' && key.startsWith(`${restBaseUrl}/cashier/bill?status`), undefined, {
+          revalidate: true,
+        });
+        closeWorkspaceWithSavedChanges();
+      },
+      (error) => {
+        showSnackbar({
+          title: t('billWaiver', 'Bill waiver'),
+          subtitle: t('billWaiverError', 'Bill waiver failed {{error}}', {
+            error: extractErrorMessagesFromResponse(error?.responseBody),
+          }),
+          kind: 'error',
+          timeoutInMs: 3500,
+          isLowContrast: true,
+        });
+      },
+    );
+  };
+
+  if (isLoading) {
+    return <InlineLoading description={t('loading', 'Loading')} />;
+  }
+
+  if (waiverPaymentMode.length === 0) {
+    return (
+      <div className={styles.waiverPaymentModeNotFound}>
+        <InlineNotification
+          title={t('waiverPaymentModeNotFound', 'Waiver payment mode not found')}
+          subtitle={t(
+            'waiverPaymentModeNotFoundSubtitle',
+            'Contact your administrator to create a waiver payment attribute type to waive a bill',
+          )}
+          kind="error"
+          lowContrast
+        />
+      </div>
+    );
+  }
+
+  return (
+    <form className={styles.form} aria-label={t('waiverForm', 'Waiver form')} onSubmit={handleSubmit(onSubmit)}>
+      <div className={styles.formContainer}>
+        <FormGroup legendText={t('billItemsSummary', 'Bill Items Summary')}>
+          <section className={styles.billWaiverDescription}>
+            <label className={styles.label}>{t('waiverBillItems', 'Bill Items')}</label>
+            <p className={styles.value}>
+              {t('billName', ' {{billName}} ', {
+                billName: lineItems.map((item) => extractString(item.item || item.billableService)).join(', ') ?? '--',
+              })}
+            </p>
+          </section>
+          <section className={styles.billWaiverDescription}>
+            <label className={styles.label}>{t('billTotal', 'Bill total')}</label>
+            <p className={styles.value}>{formatCurrency(totalAmount)}</p>
+          </section>
+          {amountAlreadyWaivedOrPaid > 0 && (
+            <section className={styles.billWaiverDescription}>
+              <label className={styles.label}>{t('amountAlreadyWaivedOrPaid', 'Total paid / waived')}</label>
+              <p className={styles.value}>{formatCurrency(amountAlreadyWaivedOrPaid)}</p>
+            </section>
+          )}
+          <Controller
+            control={control}
+            name="waiveAmount"
+            render={({ field }) => (
+              <Layer className={styles.formControlLayer}>
+                <NumberInput
+                  id="waiverAmount"
+                  label={t('amountToWaiveLabel', 'Amount to Waive')}
+                  helperText={t('amountToWaiveHelper', 'Specify the amount to be deducted from the bill')}
+                  aria-label={t('amountToWaiveAriaLabel', 'Enter amount to waive')}
+                  hideSteppers
+                  disableWheel
+                  min={0}
+                  max={totalAmount}
+                  {...field}
+                  invalidText={errors.waiveAmount?.message || 'Invalid'}
+                  invalid={!!errors.waiveAmount}
+                />
+              </Layer>
+            )}
+          />
+          <Controller
+            control={control}
+            name="waiverReason"
+            render={({ field }) => (
+              <TextArea labelText={t('waiverReasonLabel', 'Waiver reason')} rows={4} id="waiverReason" {...field} />
+            )}
+          />
+        </FormGroup>
+      </div>
+      <ButtonSet className={classNames({ [styles.tablet]: isTablet, [styles.desktop]: !isTablet })}>
+        <Button style={{ maxWidth: '50%' }} kind="secondary" onClick={() => closeWorkspace()}>
+          {t('cancel', 'Cancel')}
+        </Button>
+        <Button
+          disabled={isSubmitting || !isDirty || !isValid}
+          style={{ maxWidth: '50%' }}
+          kind="primary"
+          type="submit">
+          {isSubmitting ? (
+            <span style={{ display: 'flex', justifyItems: 'center' }}>
+              {t('submitting', 'Submitting...')} <InlineLoading status="active" iconDescription="Loading" />
+            </span>
+          ) : (
+            t('postWaiver', 'Post waiver')
+          )}
+        </Button>
+      </ButtonSet>
+    </form>
+  );
+};

package/src/bill-administration/payment-history/filters/bill-filter.test.ts

@@ -0,0 +1,124 @@
+import { filterBills } from './bill-filter';
+import { Filter, MappedBill } from '../../../types';
+
+describe('Bill Filter', () => {
+  const mockBills: Array<MappedBill> = [
+    {
+      uuid: '1',
+      payments: [
+        { instanceType: { name: 'Cash' }, amount: 100 },
+        { instanceType: { name: 'MPESA' }, amount: 200 },
+      ],
+      lineItems: [{ serviceTypeUuid: 'service-1' }, { serviceTypeUuid: 'service-2' }],
+      status: 'PAID',
+      cashier: { uuid: 'cashier-1' },
+    },
+    {
+      uuid: '2',
+      payments: [{ instanceType: { name: 'Cash' }, amount: 300 }],
+      lineItems: [{ serviceTypeUuid: 'service-3' }],
+      status: 'PENDING',
+      cashier: { uuid: 'cashier-2' },
+    },
+  ] as Array<MappedBill>;
+
+  it('should return all bills when no filters are applied', () => {
+    const filters: Filter = {};
+    const result = filterBills(mockBills, filters);
+    expect(result).toHaveLength(2);
+    expect(result).toEqual(mockBills);
+  });
+
+  it('should filter bills by payment method', () => {
+    const filters: Filter = {
+      paymentMethods: ['MPESA'],
+    };
+    const result = filterBills(mockBills, filters);
+    expect(result).toHaveLength(1);
+    expect(result[0].payments).toHaveLength(1);
+    expect(result[0].payments[0].instanceType.name).toBe('MPESA');
+  });
+
+  it('should filter bills by multiple payment methods', () => {
+    const filters: Filter = {
+      paymentMethods: ['Cash', 'MPESA'],
+    };
+    const result = filterBills(mockBills, filters);
+    expect(result).toHaveLength(2);
+  });
+
+  it('should filter bills by service type', () => {
+    const filters: Filter = {
+      serviceTypes: ['service-1'],
+    };
+    const result = filterBills(mockBills, filters);
+    expect(result).toHaveLength(1);
+    expect(result[0].uuid).toBe('1');
+  });
+
+  it('should filter bills by cashier', () => {
+    const filters: Filter = {
+      cashiers: ['cashier-1'],
+    };
+    const result = filterBills(mockBills, filters);
+    expect(result).toHaveLength(1);
+    expect(result[0].cashier.uuid).toBe('cashier-1');
+  });
+
+  it('should filter bills by status', () => {
+    const filters: Filter = {
+      status: 'PENDING',
+    };
+    const result = filterBills(mockBills, filters);
+    expect(result).toHaveLength(1);
+    expect(result[0].status).toBe('PENDING');
+  });
+
+  it('should combine multiple filters', () => {
+    const filters: Filter = {
+      paymentMethods: ['Cash'],
+      serviceTypes: ['service-1'],
+      cashiers: ['cashier-1'],
+      status: 'PAID',
+    };
+    const result = filterBills(mockBills, filters);
+    expect(result).toHaveLength(1);
+    expect(result[0].uuid).toBe('1');
+  });
+
+  it('should return empty array when no bills match filters', () => {
+    const filters: Filter = {
+      paymentMethods: ['NonExistentMethod'],
+    };
+    const result = filterBills(mockBills, filters);
+    expect(result).toHaveLength(0);
+  });
+
+  it('should handle case-insensitive payment method matching', () => {
+    const filters: Filter = {
+      paymentMethods: ['cash', 'mpesa'], // lowercase
+    };
+    const result = filterBills(mockBills, filters);
+    expect(result).toHaveLength(2);
+  });
+
+  it('should filter out bills with no payments when payment methods are specified', () => {
+    const billsWithEmptyPayments = [
+      ...mockBills,
+      {
+        uuid: '3',
+        payments: [],
+        lineItems: [],
+        status: 'PENDING',
+        cashier: { uuid: 'cashier-3' },
+      } as MappedBill,
+    ];
+
+    const filters: Filter = {
+      paymentMethods: ['Cash'],
+    };
+    const result = filterBills(billsWithEmptyPayments, filters);
+    expect(result).toHaveLength(2);
+    expect(result.find((bill) => bill.uuid === '3')).toBeUndefined();
+  });
+});