import { FetusPresentation, ObservationTable, SaveUltrasoundObservationsRequest, ScanningObservationTable } from '@nspop/gm-web-facade-api';
import ObservationTableUtil from './observation-table.util';
import FlowEnum = SaveUltrasoundObservationsRequest.FlowEnum;

function createGenericObservationTable(args: {
  motherIds?: string[] | undefined;
  fetusesIds?: string[] | undefined;
} | undefined): any {
  const mother = { rows: args?.motherIds?.map(id => ({ activityId: id })) };

  const fetuses = [
    {
      name: 'Banan1',
      id: 'B1',
      rows: args?.fetusesIds?.map(id => ({ activityId: id }))
    },
    {
      name: 'Banan2',
      id: 'B2',
      rows: args?.fetusesIds?.map(id => ({ activityId: id }))
    }
  ];

  return { mother, fetuses };
}

describe('ObservationTableUtil', () => {
  describe('ClinicalTable', () => {
    const clinicalId = 'clinical-id';
    const otherIds = [ '1', '2', '3' ];

    describe('getClinicalObservationsForActivityId', () => {
      it('returns mother observations for the specific activityId', () => {
        const clinicalTable = createGenericObservationTable({ motherIds: [ clinicalId, ...otherIds ] }) as ObservationTable;

        const { motherRow } = ObservationTableUtil.getClinicalObservationsForActivityId({
          activityId: clinicalId,
          table: clinicalTable
        });

        expect(motherRow?.activityId).toEqual(clinicalId);
      });

      it('returns fetus observations for the specific activityId', () => {
        const clinicalTable = createGenericObservationTable({ fetusesIds: [ clinicalId, ...otherIds ] }) as ObservationTable;

        const { fetusesRows } = ObservationTableUtil.getClinicalObservationsForActivityId({
          activityId: clinicalId,
          table: clinicalTable
        });

        const firstFetusRows = fetusesRows?.[0]?.rows;
        const secondFetusRows = fetusesRows?.[1]?.rows;

        expect(firstFetusRows?.length).toBe(1);
        expect(firstFetusRows?.[0]?.activityId).toEqual(clinicalId);

        expect(secondFetusRows?.length).toBe(1);
        expect(secondFetusRows?.[0]?.activityId).toEqual(clinicalId);
      });

      it('returns undefined for mother if there is no mother observations for the specific activityId', () => {
        const clinicalTable = createGenericObservationTable({ motherIds: otherIds }) as ObservationTable;

        const { motherRow } = ObservationTableUtil.getClinicalObservationsForActivityId({
          activityId: clinicalId,
          table: clinicalTable
        });

        expect(motherRow).toBe(undefined);
      });

      it('returns an empty list for a fetus if there is no observations for the fetus with the specific activityId', () => {
        const clinicalTable = createGenericObservationTable({ fetusesIds: otherIds }) as ObservationTable;

        const { fetusesRows } = ObservationTableUtil.getClinicalObservationsForActivityId({
          activityId: clinicalId,
          table: clinicalTable
        });

        const firstFetusRows = fetusesRows?.[0]?.rows;
        const secondFetusRows = fetusesRows?.[1]?.rows;

        expect(firstFetusRows?.length).toBe(0);
        expect(secondFetusRows?.length).toBe(0);
      });
    });

    describe('hasClinicalObservationsForActivityId', () => {
      it('returns true if there are clinical observations related to the activity', () => {
        const clinicalTableMother = createGenericObservationTable({ motherIds: [ clinicalId, ...otherIds ] }) as ObservationTable;
        const hasClinicalMother = ObservationTableUtil.hasClinicalObservationsForActivityId({
          activityId: clinicalId,
          table: clinicalTableMother
        });
        expect(hasClinicalMother).toBe(true);

        const clinicalTableFetus = createGenericObservationTable({ fetusesIds: [ clinicalId, ...otherIds ] }) as ObservationTable;
        const hasClinicalFetus = ObservationTableUtil.hasClinicalObservationsForActivityId({
          activityId: clinicalId,
          table: clinicalTableFetus
        });
        expect(hasClinicalFetus).toBe(true);
      });

      it('returns false if there are no clinical observations related to the activity', () => {
        const clinicalTableOtherIds = createGenericObservationTable({ motherIds: otherIds, fetusesIds: otherIds }) as ObservationTable;
        const hasClinicalWithOtherIdsTable = ObservationTableUtil.hasClinicalObservationsForActivityId({
          activityId: clinicalId,
          table: clinicalTableOtherIds
        });
        expect(hasClinicalWithOtherIdsTable).toBe(false);

        const clinicalTableMotherFetusUndefined = createGenericObservationTable({
          motherIds: undefined,
          fetusesIds: undefined
        }) as ObservationTable;
        const hasClinicalWithTableMotherFetusUndefined = ObservationTableUtil.hasClinicalObservationsForActivityId({
          activityId: clinicalId,
          table: clinicalTableMotherFetusUndefined
        });
        expect(hasClinicalWithTableMotherFetusUndefined).toBe(false);

        const hasClinicalWithUndefinedTable = ObservationTableUtil.hasClinicalObservationsForActivityId({
          activityId: clinicalId,
          table: undefined
        });
        expect(hasClinicalWithUndefinedTable).toBe(false);
      });
    });

    describe('getObservationDataRegularForActivity', () => {
      it('retrieves mother data related to activity', () => {
        const clinicalDocumentId = 'clinical-mother-document-id';
        const clinicalWeight = 69;
        const clinicalEdema = '++';
        const clinicalPubisMeasurement = 42;
        const clinicalUrine = [ 'yellow', 'snow' ];

        const clinicalTable: ObservationTable = {
          mother: {
            rows: [
              {
                id: 'the-first-ever-clinical-mother-document-id-you-could-say-its-the-mother-mother-document-id',
                activityId: 'activity-1',
                weight: { value: 1 },
                bloodPressure: '11 / 111',
                edema: '-',
                pubismeasurement: { value: 1111 },
                urine: '-A'
              },
              {
                id: clinicalDocumentId,
                activityId: clinicalId,
                weight: { value: clinicalWeight },
                bloodPressure: '5 / 7',
                edema: clinicalEdema,
                pubismeasurement: { value: clinicalPubisMeasurement },
                urine: clinicalUrine.join(', ')
              },
              {
                id: 'the-last-ever-clinical-mother-document-id',
                activityId: 'activity-2',
                weight: { value: 2 },
                bloodPressure: '22 / 222',
                edema: '-',
                pubismeasurement: { value: 2222 },
                urine: '-A'
              }
            ]
          }
        };

        const observationDataRegular = ObservationTableUtil.getObservationDataRegularForActivity({
          activityId: clinicalId,
          table: clinicalTable
        });

        expect(observationDataRegular?.documentUniqueId).toEqual(clinicalDocumentId);
        expect(observationDataRegular?.activityId).toEqual(clinicalId);
        expect(observationDataRegular?.weight).toBe(clinicalWeight);
        expect(observationDataRegular?.bloodPressure).toEqual({ systolic: 5, diastolic: 7 });
        expect(observationDataRegular?.edema).toEqual(clinicalEdema);
        expect(observationDataRegular?.pubismeasurement).toBe(clinicalPubisMeasurement);
        expect(observationDataRegular?.urine).toEqual(clinicalUrine);
      });

      it('retrieves fetus data related to activity', () => {
        const clinicalDocumentId = 'document-id';
        const fetusOne = {
          name: 'fetusOne',
          id: 'ImNotOldEnoughToHaveADriversLicense',
          presentation: FetusPresentation.Tv,
          weight: 1234,
          activity: [ '+liv', '+sang' ]
        };

        const fetusTwo = {
          name: 'fetusTwo',
          id: 'LicenseToKill',
          presentation: FetusPresentation.H,
          weight: 4321,
          activity: [ '+liv', '+trommer' ]
        };

        const clinicalTable: ObservationTable = {
          fetuses: [
            {
              name: fetusOne.name,
              id: fetusOne.id,
              rows: [
                { activityId: 'not-this-one' },
                {
                  activityId: clinicalId,
                  id: clinicalDocumentId,
                  fetusPresentation: fetusOne.presentation,
                  fetusWeightEstimate: { value: fetusOne.weight },
                  fetusActivity: fetusOne.activity
                },
                { activityId: 'neither-is-it-this-one' }
              ]
            },
            {
              name: fetusTwo.name,
              id: fetusTwo.id,
              rows: [
                { activityId: 'not-this-one' },
                {
                  activityId: clinicalId,
                  id: clinicalDocumentId,
                  fetusPresentation: fetusTwo.presentation,
                  fetusWeightEstimate: { value: fetusTwo.weight },
                  fetusActivity: fetusTwo.activity
                },
                { activityId: 'neither-is-it-this-one' }
              ]
            }
          ]
        };

        const observationDataRegular = ObservationTableUtil.getObservationDataRegularForActivity({
          activityId: clinicalId,
          table: clinicalTable
        });

        expect(observationDataRegular?.documentUniqueId).toEqual(clinicalDocumentId);
        expect(observationDataRegular?.activityId).toEqual(clinicalId);

        const [ firstFetus, secondFetus ] = observationDataRegular.fetuses || [];

        expect(firstFetus.id).toBe(fetusOne.id);
        expect(firstFetus.fetusPresentation).toEqual(fetusOne.presentation);
        expect(firstFetus.fetusWeightEstimate).toBe(fetusOne.weight);
        expect(firstFetus.fetusActivity).toEqual(fetusOne.activity);

        expect(secondFetus.id).toBe(fetusTwo.id);
        expect(secondFetus.fetusPresentation).toEqual(fetusTwo.presentation);
        expect(secondFetus.fetusWeightEstimate).toBe(fetusTwo.weight);
        expect(secondFetus.fetusActivity).toEqual(fetusTwo.activity);
      });

      it('returns undefined for fields if there is no data related to activity', () => {
        const clinicalTable: ObservationTable = {
          mother: {
            rows: [
              {
                id: 'the-first-ever-clinical-mother-document-id-you-could-say-its-the-mother-mother-document-id',
                activityId: 'activity-1',
                weight: { value: 1 },
                bloodPressure: '11 / 111',
                edema: '-',
                pubismeasurement: { value: 1111 },
                urine: '-A'
              },
              {
                activityId: 'activity-2'
              }
            ]
          },
          fetuses: [
            {
              name: 'fetusOne',
              id: '1',
              rows: [
                { activityId: 'not-this-one' },
                {
                  activityId: 'activity-2',
                  id: 'some-document-id',
                  fetusPresentation: FetusPresentation.Uk,
                  fetusWeightEstimate: { value: 99 },
                  fetusActivity: [ '+liv' ]
                },
                { activityId: 'neither-is-it-this-one' }
              ]
            },
            {
              name: 'fetusTwo',
              id: '2',
              rows: [
                { activityId: 'not-this-one' },
                {
                  activityId: 'activity-2',
                  id: 'some-document-id',
                  fetusPresentation: FetusPresentation.H,
                  fetusWeightEstimate: { value: 777 },
                  fetusActivity: [ '+liv' ]
                },
                { activityId: 'neither-is-it-this-one' }
              ]
            }
          ]
        };

        const observationDataRegular = ObservationTableUtil.getObservationDataRegularForActivity({
          activityId: clinicalId,
          table: clinicalTable
        });

        // Mother
        expect(observationDataRegular?.documentUniqueId).toBe(undefined);
        expect(observationDataRegular?.activityId).toBe(clinicalId);
        expect(observationDataRegular?.weight).toBe(undefined);
        expect(observationDataRegular?.bloodPressure).toBe(undefined);
        expect(observationDataRegular?.edema).toBe(undefined);
        expect(observationDataRegular?.pubismeasurement).toBe(undefined);
        expect(observationDataRegular?.urine).toBe(undefined);

        // Fetuses
        const [ firstFetus, secondFetus ] = observationDataRegular.fetuses || [];

        expect(firstFetus.id).toBe('1');
        expect(firstFetus.fetusPresentation).toBe(undefined);
        expect(firstFetus.fetusWeightEstimate).toBe(undefined);
        expect(firstFetus.fetusActivity).toBe(undefined);

        expect(secondFetus.id).toBe('2');
        expect(secondFetus.fetusPresentation).toBe(undefined);
        expect(secondFetus.fetusWeightEstimate).toBe(undefined);
        expect(secondFetus.fetusActivity).toBe(undefined);
      });

      it('returns undefined for fields if table or id is undefined', () => {
        const observationDataRegularUndefinedTable = ObservationTableUtil.getObservationDataRegularForActivity({
          activityId: clinicalId,
          table: undefined
        });
        expect(observationDataRegularUndefinedTable.documentUniqueId).toBe(undefined);

        const observationDataRegularUndefinedActivityId = ObservationTableUtil.getObservationDataRegularForActivity({
          activityId: undefined,
          table: { mother: { rows: [ { id: 'this-is-a-document-id', activityId: clinicalId } ] } }
        });
        expect(observationDataRegularUndefinedActivityId.documentUniqueId).toBe(undefined);
      });

      it('returns as many fetuses as the clinical table holds', () => {
        const observationDataRegular = ObservationTableUtil.getObservationDataRegularForActivity({
          activityId: clinicalId,
          table: { fetuses: [ { id: 'fetusOne' }, { id: 'fetusTwo' }, { id: 'fetusThree' } ] }
        });
        expect(observationDataRegular.fetuses?.length).toBe(3);
      });
    });
  });

  describe('ScanningObservations', () => {
    const scanningId = 'scanning-id';
    const otherIds = [ '1', '2', '3' ];

    describe('getScanningObservationsForActivityId', () => {
      it('returns mother observations for the specific activityId', () => {
        const uSoundTable = createGenericObservationTable({ motherIds: [ scanningId, ...otherIds ] }) as ScanningObservationTable;

        const { motherRow } = ObservationTableUtil.getScanningObservationsForActivityId({
          activityId: scanningId,
          table: uSoundTable
        });

        expect(motherRow?.activityId).toEqual(scanningId);
      });

      it('returns fetus observations for the specific activityId', () => {
        const uSoundTable = createGenericObservationTable({ fetusesIds: [ scanningId, ...otherIds ] }) as ScanningObservationTable;

        const { fetusesRows } = ObservationTableUtil.getScanningObservationsForActivityId({
          activityId: scanningId,
          table: uSoundTable
        });

        const firstFetusRows = fetusesRows?.[0]?.rows;
        const secondFetusRows = fetusesRows?.[1]?.rows;

        expect(firstFetusRows?.length).toBe(1);
        expect(firstFetusRows?.[0]?.activityId).toEqual(scanningId);

        expect(secondFetusRows?.length).toBe(1);
        expect(secondFetusRows?.[0]?.activityId).toEqual(scanningId);
      });

      it('returns undefined for mother if there is no mother observations for the specific activityId', () => {
        const uSoundTable = createGenericObservationTable({ motherIds: otherIds }) as ScanningObservationTable;

        const { motherRow } = ObservationTableUtil.getScanningObservationsForActivityId({
          activityId: scanningId,
          table: uSoundTable
        });

        expect(motherRow).toBe(undefined);
      });

      it('returns an empty list for a fetus if there is no observations for the fetus with the specific activityId', () => {
        const uSoundTable = createGenericObservationTable({ fetusesIds: otherIds }) as ScanningObservationTable;

        const { fetusesRows } = ObservationTableUtil.getScanningObservationsForActivityId({
          activityId: scanningId,
          table: uSoundTable
        });

        const firstFetusRows = fetusesRows?.[0]?.rows;
        const secondFetusRows = fetusesRows?.[1]?.rows;

        expect(firstFetusRows?.length).toBe(0);
        expect(secondFetusRows?.length).toBe(0);
      });
    });

    describe('hasScanningObservationsForActivityId', () => {
      it('returns true if there are clinical observations related to the activity', () => {
        const uSoundTableMother = createGenericObservationTable({ motherIds: [ scanningId, ...otherIds ] }) as ScanningObservationTable;
        const hasScanningMother = ObservationTableUtil.hasScanningObservationsForActivityId({
          activityId: scanningId,
          table: uSoundTableMother
        });
        expect(hasScanningMother).toBe(true);

        const uSoundTableFetus = createGenericObservationTable({ fetusesIds: [ scanningId, ...otherIds ] }) as ScanningObservationTable;
        const hasScanningFetus = ObservationTableUtil.hasScanningObservationsForActivityId({
          activityId: scanningId,
          table: uSoundTableFetus
        });
        expect(hasScanningFetus).toBe(true);
      });

      it('returns false if there are no clinical observations related to the activity', () => {
        const uSoundTableOtherIds = createGenericObservationTable({ motherIds: otherIds, fetusesIds: otherIds }) as ScanningObservationTable;
        const hasScanningWithOtherIdsTable = ObservationTableUtil.hasScanningObservationsForActivityId({
          activityId: scanningId,
          table: uSoundTableOtherIds
        });
        expect(hasScanningWithOtherIdsTable).toBe(false);

        const uSoundTableMotherFetusUndefined = createGenericObservationTable({
          motherIds: undefined,
          fetusesIds: undefined
        }) as ScanningObservationTable;
        const hasScanningWithTableMotherFetusUndefined = ObservationTableUtil.hasScanningObservationsForActivityId({
          activityId: scanningId,
          table: uSoundTableMotherFetusUndefined
        });
        expect(hasScanningWithTableMotherFetusUndefined).toBe(false);

        const hasScanningWithUndefinedTable = ObservationTableUtil.hasScanningObservationsForActivityId({
          activityId: scanningId,
          table: undefined
        });
        expect(hasScanningWithUndefinedTable).toBe(false);
      });
    });

    describe('getObservationDataUltrasoundForActivity', () => {
      it('retrieves mother data related to activity', () => {
        const scanningDocumentId = 'scanning-mother-document-id';
        const scanningFluid = 69;
        const scanningCervix = 777;
        const scanningDvp = 42;
        const scanningFlow = FlowEnum.Normal;

        const uSoundTable: ScanningObservationTable = {
          mother: {
            rows: [
              {
                id: 'the-first-ever-scanning-mother-document-id-you-could-say-its-the-mother-mother-document-id',
                activityId: 'activity-1',
                amnioticFluid: { value: 1 },
                cervix: { value: 11 },
                dvp: { value: 111 },
                flow: FlowEnum.Abnormal
              },
              {
                id: scanningDocumentId,
                activityId: scanningId,
                amnioticFluid: { value: scanningFluid },
                cervix: { value: scanningCervix },
                dvp: { value: scanningDvp },
                flow: scanningFlow
              },
              {
                id: 'the-last-ever-scanning-mother-document-id',
                activityId: 'activity-2',
                amnioticFluid: { value: 2 },
                cervix: { value: 22 },
                dvp: { value: 222 },
                flow: FlowEnum.Tobecontinued
              }
            ]
          }
        };

        const observationDataUltrasound = ObservationTableUtil.getObservationDataUltrasoundForActivity({
          activityId: scanningId,
          table: uSoundTable
        });

        expect(observationDataUltrasound?.documentUniqueId).toEqual(scanningDocumentId);
        expect(observationDataUltrasound?.activityId).toEqual(scanningId);
        expect(observationDataUltrasound?.amnioticFluid).toBe(scanningFluid);
        expect(observationDataUltrasound?.cervix).toEqual(scanningCervix);
        expect(observationDataUltrasound?.dvp).toEqual(scanningDvp);
        expect(observationDataUltrasound?.flow).toBe(scanningFlow);
      });

      it('retrieves fetus data related to activity', () => {
        const scanningDocumentId = 'document-id';
        const fetusOne = {
          name: 'fetusOne',
          id: 'ImNotOldEnoughToHaveADriversLicense',
          presentation: FetusPresentation.H,
          weight: 1234,
          deviation: '0 - 15'
        };

        const fetusTwo = {
          name: 'fetusTwo',
          id: 'LicenseToKill',
          presentation: FetusPresentation.Tv,
          weight: 4321,
          deviation: '15 - 22'
        };

        const uSoundTable: ScanningObservationTable = {
          fetuses: [
            {
              name: fetusOne.name,
              id: fetusOne.id,
              rows: [
                { activityId: 'not-this-one' },
                {
                  activityId: scanningId,
                  id: scanningDocumentId,
                  fetusPresentation: fetusOne.presentation,
                  ulWeight: { value: fetusOne.weight },
                  weightDeviation: { value: fetusOne.deviation }
                },
                { activityId: 'neither-is-it-this-one' }
              ]
            },
            {
              name: fetusTwo.name,
              id: fetusTwo.id,
              rows: [
                { activityId: 'not-this-one' },
                {
                  activityId: scanningId,
                  id: scanningDocumentId,
                  fetusPresentation: fetusTwo.presentation,
                  ulWeight: { value: fetusTwo.weight },
                  weightDeviation: { value: fetusTwo.deviation }
                },
                { activityId: 'neither-is-it-this-one' }
              ]
            }
          ]
        };

        const observationDataUltrasound = ObservationTableUtil.getObservationDataUltrasoundForActivity({
          activityId: scanningId,
          table: uSoundTable
        });

        expect(observationDataUltrasound?.documentUniqueId).toEqual(scanningDocumentId);
        expect(observationDataUltrasound?.activityId).toEqual(scanningId);

        const [ firstFetus, secondFetus ] = observationDataUltrasound.fetuses || [];

        expect(firstFetus.id).toBe(fetusOne.id);
        expect(firstFetus.fetusPresentation).toEqual(fetusOne.presentation);
        expect(firstFetus.ulWeight).toBe(fetusOne.weight);
        expect(firstFetus.weightDeviation).toEqual(fetusOne.deviation);

        expect(secondFetus.id).toBe(fetusTwo.id);
        expect(secondFetus.fetusPresentation).toEqual(fetusTwo.presentation);
        expect(secondFetus.ulWeight).toBe(fetusTwo.weight);
        expect(secondFetus.weightDeviation).toEqual(fetusTwo.deviation);
      });

      it('returns undefined for fields if there is no data related to activity', () => {
        const uSoundTable: ScanningObservationTable = {
          mother: {
            rows: [
              {
                id: 'the-first-ever-scanning-mother-document-id-you-could-say-its-the-mother-mother-document-id',
                activityId: 'activity-1',
                amnioticFluid: { value: 1 },
                cervix: { value: 11 },
                dvp: { value: 111 },
                flow: FlowEnum.Abnormal
              },
              {
                activityId: 'activity-2'
              }
            ]
          },
          fetuses: [
            {
              name: 'fetusOne',
              id: '1',
              rows: [
                { activityId: 'not-this-one' },
                {
                  activityId: 'activity-2',
                  id: 'some-document-id',
                  fetusPresentation: FetusPresentation.Uk,
                  ulWeight: { value: 99 },
                  weightDeviation: { value: '> 22' }
                },
                { activityId: 'neither-is-it-this-one' }
              ]
            },
            {
              name: 'fetusTwo',
              id: '2',
              rows: [
                { activityId: 'not-this-one' },
                {
                  activityId: 'activity-2',
                  id: 'some-document-id',
                  fetusPresentation: FetusPresentation.H,
                  ulWeight: { value: 777 },
                  weightDeviation: { value: '0 - 15' }
                },
                { activityId: 'neither-is-it-this-one' }
              ]
            }
          ]
        };

        const observationDataUltrasound = ObservationTableUtil.getObservationDataUltrasoundForActivity({
          activityId: scanningId,
          table: uSoundTable
        });

        // Mother
        expect(observationDataUltrasound?.documentUniqueId).toBe(undefined);
        expect(observationDataUltrasound?.activityId).toBe(scanningId);
        expect(observationDataUltrasound?.amnioticFluid).toBe(undefined);
        expect(observationDataUltrasound?.cervix).toBe(undefined);
        expect(observationDataUltrasound?.dvp).toBe(undefined);
        expect(observationDataUltrasound?.flow).toBe(undefined);

        // Fetuses
        const [ firstFetus, secondFetus ] = observationDataUltrasound.fetuses || [];

        expect(firstFetus.id).toBe('1');
        expect(firstFetus.fetusPresentation).toBe(undefined);
        expect(firstFetus.ulWeight).toBe(undefined);
        expect(firstFetus.weightDeviation).toBe(undefined);

        expect(secondFetus.id).toBe('2');
        expect(secondFetus.fetusPresentation).toBe(undefined);
        expect(secondFetus.ulWeight).toBe(undefined);
        expect(secondFetus.weightDeviation).toBe(undefined);
      });

      it('returns undefined for fields if table or id is undefined', () => {
        const observationDataUltrasoundUndefinedTable = ObservationTableUtil.getObservationDataUltrasoundForActivity({
          activityId: scanningId,
          table: undefined
        });
        expect(observationDataUltrasoundUndefinedTable.documentUniqueId).toBe(undefined);

        const observationDataUltrasoundUndefinedActivityId = ObservationTableUtil.getObservationDataUltrasoundForActivity({
          activityId: undefined,
          table: { mother: { rows: [ { id: 'this-is-a-document-id', activityId: scanningId } ] } }
        });
        expect(observationDataUltrasoundUndefinedActivityId.documentUniqueId).toBe(undefined);
      });

      it('returns as many fetuses as the scanning table holds', () => {
        const observationDataUltrasound = ObservationTableUtil.getObservationDataUltrasoundForActivity({
          activityId: scanningId,
          table: { fetuses: [ { id: 'fetusOne' }, { id: 'fetusTwo' }, { id: 'fetusThree' } ] }
        });
        expect(observationDataUltrasound.fetuses?.length).toBe(3);
      });
    });
  });
});