@genspectrum/dashboard-components 0.12.1 → 0.13.1

package/src/preact/wastewater/mutationsOverTime/__mockData__/details.json

@@ -0,0 +1,88 @@
+{
+    "data": [
+        {
+            "aminoAcidMutationFrequency": null,
+            "date": "2024-11-13",
+            "location": "Lugano",
+            "nucleotideMutationFrequency": "{\"A12183T\": null, \"C2554T\": null, \"C3422A\": 0.9598659873008728, \"A966C\": null, \"G6661A\": 0.5527499914169312, \"G7731A\": 0.9832900166511536, \"T4026G\": 0.9991809725761414, \"T5260C\": null, \"T5287C\": null}",
+            "reference": "RSV-B"
+        },
+        {
+            "aminoAcidMutationFrequency": null,
+            "date": "2024-11-17",
+            "location": "Genève",
+            "nucleotideMutationFrequency": "{\"A12183T\": 1.0, \"C2554T\": null, \"C3422A\": 0.0, \"A966C\": null, \"G6661A\": 0.8785049915313721, \"G7731A\": 0.9855599999427795, \"T4026G\": null, \"T5260C\": 1.0, \"T5287C\": 0.9932659864425659}",
+            "reference": "RSV-B"
+        },
+        {
+            "aminoAcidMutationFrequency": "{\"ORF1a:S4286C\": null, \"S:R346T\": 0.25, \"S:Q493E\": 0.60, \"N:G204P\": null}",
+            "date": "2024-11-17",
+            "location": "Lugano",
+            "nucleotideMutationFrequency": "{\"A12183T\": 0.998993992805481, \"C2554T\": null, \"C3422A\": null, \"A966C\": null, \"G6661A\": 0.8917459845542908, \"G7731A\": 0.9770470261573792, \"T4026G\": 0.0, \"T5260C\": null, \"T5287C\": null}",
+            "reference": "RSV-B"
+        },
+        {
+            "aminoAcidMutationFrequency": "{\"ORF1a:S4286C\": 0.42, \"S:R346T\": 0.22, \"S:Q493E\": 0.66, \"N:G204P\": null}",
+            "date": "2024-11-16",
+            "location": "Lugano",
+            "nucleotideMutationFrequency": "{\"A12183T\": null, \"C2554T\": null, \"C3422A\": null, \"A966C\": null, \"G6661A\": 0.9476320147514343, \"G7731A\": 0.9809200167655945, \"T4026G\": 0.9992259740829468, \"T5260C\": null, \"T5287C\": null}",
+            "reference": "RSV-B"
+        },
+        {
+            "aminoAcidMutationFrequency": null,
+            "date": "2024-11-18",
+            "location": "Genève",
+            "nucleotideMutationFrequency": "{\"A12183T\": null, \"C2554T\": 0.9978219866752625, \"C3422A\": null, \"A966C\": 1.0, \"G6661A\": null, \"G7731A\": null, \"T4026G\": null, \"T5260C\": null, \"T5287C\": null}",
+            "reference": "RSV-B"
+        },
+        {
+            "aminoAcidMutationFrequency": null,
+            "date": "2024-11-14",
+            "location": "Genève",
+            "nucleotideMutationFrequency": "{\"A12183T\": null, \"C2554T\": 0.9994590282440186, \"C3422A\": 0.05333299934864044, \"A966C\": 1.0, \"G6661A\": 0.9282640218734741, \"G7731A\": 0.9803630113601685, \"T4026G\": 0.0, \"T5260C\": 0.9970409870147705, \"T5287C\": 0.996694028377533}",
+            "reference": "RSV-B"
+        },
+        {
+            "aminoAcidMutationFrequency": null,
+            "date": "2024-11-13",
+            "location": "Laupen",
+            "nucleotideMutationFrequency": "{\"A12668G\": null, \"A3564G\": null, \"C10862T\": null, \"C12710T\": null, \"C3624T\": null, \"G11123A\": null, \"G3616A\": null, \"G7379A\": 0.9470750093460083, \"T11034A\": null, \"T3483C\": null}",
+            "reference": "RSV-A"
+        },
+        {
+            "aminoAcidMutationFrequency": null,
+            "date": "2024-11-13",
+            "location": "Zürich",
+            "nucleotideMutationFrequency": "{\"A12668G\": 0.9988809823989868, \"A3564G\": null, \"C10862T\": 1.0, \"C12710T\": 0.9991809725761414, \"C3624T\": null, \"G11123A\": 1.0, \"G3616A\": null, \"G7379A\": 0.9414680004119873, \"T11034A\": 0.9988250136375427, \"T3483C\": null}",
+            "reference": "RSV-A"
+        },
+        {
+            "aminoAcidMutationFrequency": null,
+            "date": "2024-11-16",
+            "location": "Zürich",
+            "nucleotideMutationFrequency": "{\"A12668G\": 0.999222993850708, \"A3564G\": 0.9998199939727783, \"C10862T\": 1.0, \"C12710T\": 0.9996299743652344, \"C3624T\": 0.9999099969863892, \"G11123A\": 1.0, \"G3616A\": 0.08799900114536285, \"G7379A\": null, \"T11034A\": 0.9970099925994873, \"T3483C\": 0.9993579983711243}",
+            "reference": "RSV-A"
+        },
+        {
+            "aminoAcidMutationFrequency": null,
+            "date": "2024-11-16",
+            "location": "Chur",
+            "nucleotideMutationFrequency": "{\"A12668G\": null, \"A3564G\": null, \"C10862T\": null, \"C12710T\": null, \"C3624T\": null, \"G11123A\": null, \"G3616A\": null, \"G7379A\": 0.6464089751243591, \"T11034A\": null, \"T3483C\": null}",
+            "reference": "RSV-A"
+        },
+        {
+            "aminoAcidMutationFrequency": null,
+            "date": "2024-11-18",
+            "location": "Basel",
+            "nucleotideMutationFrequency": "{\"A12668G\": null, \"A3564G\": 1.0, \"C10862T\": null, \"C12710T\": null, \"C3624T\": 1.0, \"G11123A\": null, \"G3616A\": 0.08222199976444244, \"G7379A\": null, \"T11034A\": null, \"T3483C\": 0.9998080134391785}",
+            "reference": "RSV-A"
+        }
+    ],
+    "info": {
+        "dataVersion": "1737327031",
+        "requestId": "5591b455-3d84-438c-8434-2e57ee2ad569",
+        "requestInfo": "RSV on api.wise-loculus.genspectrum.org at 2025-01-20T11:58:03.498206810",
+        "reportTo": "Please report to https://github.com/GenSpectrum/LAPIS/issues in case you encounter any unexpected issues. Please include the request ID and the requestInfo in your report.",
+        "lapisVersion": "0.3.10"
+    }
+}

package/src/preact/wastewater/mutationsOverTime/computeWastewaterMutationsOverTimeDataPerLocation.spec.ts

@@ -0,0 +1,159 @@
+import { describe, expect, test } from 'vitest';
+
+import { groupMutationDataByLocation } from './computeWastewaterMutationsOverTimeDataPerLocation';
+import type { WastewaterData } from '../../../query/queryWastewaterMutationsOverTime';
+import { SubstitutionClass } from '../../../utils/mutations';
+import { TemporalCache } from '../../../utils/temporalClass';
+
+const temporalCache = TemporalCache.getInstance();
+
+const mutation1 = SubstitutionClass.parse('1T')!;
+const mutation2 = SubstitutionClass.parse('2G')!;
+const mutation3 = SubstitutionClass.parse('3C')!;
+
+const location1 = 'location1';
+const location2 = 'location2';
+
+describe('groupMutationDataByLocation', () => {
+    test('should group nucleotide mutations by location', () => {
+        const input: WastewaterData = [
+            {
+                location: location1,
+                date: temporalCache.getYearMonthDay('2025-01-01'),
+                nucleotideMutationFrequency: [
+                    { mutation: mutation1, proportion: 0.1 },
+                    { mutation: mutation2, proportion: 0.2 },
+                ],
+                aminoAcidMutationFrequency: [],
+            },
+            {
+                location: location1,
+                date: temporalCache.getYearMonthDay('2025-01-02'),
+                nucleotideMutationFrequency: [
+                    { mutation: mutation1, proportion: null },
+                    { mutation: mutation2, proportion: 0.3 },
+                ],
+                aminoAcidMutationFrequency: [],
+            },
+            {
+                location: location2,
+                date: temporalCache.getYearMonthDay('2025-01-01'),
+                nucleotideMutationFrequency: [
+                    { mutation: mutation1, proportion: 0.1 },
+                    { mutation: mutation3, proportion: 0.2 },
+                ],
+                aminoAcidMutationFrequency: [],
+            },
+        ];
+
+        const result = groupMutationDataByLocation(input, 'nucleotide');
+
+        expect(result).to.have.length(2);
+        expect(result[0].location).to.equal(location1);
+        expect(result[1].location).to.equal(location2);
+
+        const location1Data = result[0].data;
+        expect(location1Data.getFirstAxisKeys()).to.deep.equal([mutation1, mutation2]);
+        expect(location1Data.getSecondAxisKeys()).to.deep.equal([
+            temporalCache.getYearMonthDay('2025-01-01'),
+            temporalCache.getYearMonthDay('2025-01-02'),
+        ]);
+        expect(location1Data.getAsArray()).to.deep.equal([
+            [{ count: null, proportion: 0.1, totalCount: null }, null],
+            [
+                { count: null, proportion: 0.2, totalCount: null },
+                { count: null, proportion: 0.3, totalCount: null },
+            ],
+        ]);
+    });
+
+    test('should group amino acid mutations by location', () => {
+        const input: WastewaterData = [
+            {
+                location: location1,
+                date: temporalCache.getYearMonthDay('2025-01-01'),
+                nucleotideMutationFrequency: [{ mutation: mutation1, proportion: 0.1 }],
+                aminoAcidMutationFrequency: [
+                    { mutation: mutation2, proportion: 0.2 },
+                    { mutation: mutation3, proportion: 0.3 },
+                ],
+            },
+            {
+                location: location2,
+                date: temporalCache.getYearMonthDay('2025-01-01'),
+                nucleotideMutationFrequency: [],
+                aminoAcidMutationFrequency: [{ mutation: mutation3, proportion: 0.3 }],
+            },
+        ];
+
+        const result = groupMutationDataByLocation(input, 'amino acid');
+
+        expect(result).to.have.length(2);
+        expect(result[0].location).to.equal(location1);
+        expect(result[1].location).to.equal(location2);
+
+        const location1Data = result[0].data;
+        expect(location1Data.getFirstAxisKeys()).to.deep.equal([mutation2, mutation3]);
+        expect(location1Data.getSecondAxisKeys()).to.deep.equal([temporalCache.getYearMonthDay('2025-01-01')]);
+        expect(location1Data.getAsArray()).to.deep.equal([
+            [{ count: null, proportion: 0.2, totalCount: null }],
+            [{ count: null, proportion: 0.3, totalCount: null }],
+        ]);
+    });
+
+    test('should sort date axis correctly', () => {
+        const input: WastewaterData = [
+            {
+                location: location1,
+                date: temporalCache.getYearMonthDay('2025-01-02'),
+                nucleotideMutationFrequency: [{ mutation: mutation1, proportion: 0.2 }],
+                aminoAcidMutationFrequency: [],
+            },
+            {
+                location: location1,
+                date: temporalCache.getYearMonthDay('2025-01-01'),
+                nucleotideMutationFrequency: [{ mutation: mutation1, proportion: 0.1 }],
+                aminoAcidMutationFrequency: [],
+            },
+            {
+                location: location1,
+                date: temporalCache.getYearMonthDay('2025-01-03'),
+                nucleotideMutationFrequency: [{ mutation: mutation1, proportion: 0.3 }],
+                aminoAcidMutationFrequency: [],
+            },
+        ];
+
+        const result = groupMutationDataByLocation(input, 'nucleotide');
+
+        expect(result).to.have.length(1);
+        const location1Data = result[0].data;
+
+        expect(location1Data.getSecondAxisKeys()).to.deep.equal([
+            temporalCache.getYearMonthDay('2025-01-01'),
+            temporalCache.getYearMonthDay('2025-01-02'),
+            temporalCache.getYearMonthDay('2025-01-03'),
+        ]);
+    });
+
+    test('should sort mutations correctly', () => {
+        const input: WastewaterData = [
+            {
+                location: location1,
+                date: temporalCache.getYearMonthDay('2025-01-01'),
+                nucleotideMutationFrequency: [
+                    { mutation: mutation3, proportion: 0.3 },
+                    { mutation: mutation1, proportion: 0.1 },
+                    { mutation: mutation2, proportion: 0.2 },
+                ],
+                aminoAcidMutationFrequency: [],
+            },
+        ];
+
+        const result = groupMutationDataByLocation(input, 'nucleotide');
+
+        expect(result).to.have.length(1);
+        const location1Data = result[0].data;
+
+        expect(location1Data.getFirstAxisKeys()).to.deep.equal([mutation1, mutation2, mutation3]);
+    });
+});

package/src/preact/wastewater/mutationsOverTime/computeWastewaterMutationsOverTimeDataPerLocation.ts

@@ -0,0 +1,51 @@
+import { queryWastewaterMutationsOverTime, type WastewaterData } from '../../../query/queryWastewaterMutationsOverTime';
+import type { LapisFilter, SequenceType } from '../../../types';
+import { SortedMap2d } from '../../../utils/map2d';
+import { compareTemporal, type TemporalClass } from '../../../utils/temporalClass';
+import {
+    BaseMutationOverTimeDataMap,
+    type MutationOverTimeDataMap,
+} from '../../mutationsOverTime/MutationOverTimeData';
+import { sortSubstitutionsAndDeletions } from '../../shared/sort/sortSubstitutionsAndDeletions';
+
+export async function computeWastewaterMutationsOverTimeDataPerLocation(
+    lapis: string,
+    lapisFilter: LapisFilter,
+    sequenceType: SequenceType,
+    signal?: AbortSignal,
+) {
+    const data = await queryWastewaterMutationsOverTime(lapis, lapisFilter, signal);
+
+    return groupMutationDataByLocation(data, sequenceType);
+}
+
+export function groupMutationDataByLocation(data: WastewaterData, sequenceType: 'nucleotide' | 'amino acid') {
+    const locationMap = new Map<string, MutationOverTimeDataMap<TemporalClass>>();
+    for (const row of data) {
+        if (!locationMap.has(row.location)) {
+            locationMap.set(row.location, new BaseMutationOverTimeDataMap<TemporalClass>());
+        }
+        const map = locationMap.get(row.location)!;
+
+        const mutationFrequencies =
+            sequenceType === 'nucleotide' ? row.nucleotideMutationFrequency : row.aminoAcidMutationFrequency;
+        for (const mutation of mutationFrequencies) {
+            map.set(
+                mutation.mutation,
+                row.date,
+                mutation.proportion !== null
+                    ? { proportion: mutation.proportion, count: null, totalCount: null }
+                    : null,
+            );
+        }
+    }
+
+    return [...locationMap.entries()].map(([location, data]) => ({
+        location,
+        data: new SortedMap2d(
+            data,
+            (a, b) => sortSubstitutionsAndDeletions(a, b),
+            (a, b) => compareTemporal(a, b),
+        ),
+    }));
+}

package/src/preact/wastewater/mutationsOverTime/wastewater-mutations-over-time.stories.tsx

@@ -0,0 +1,71 @@
+import { type Meta, type StoryObj } from '@storybook/preact';
+
+import { WastewaterMutationsOverTime, type WastewaterMutationsOverTimeProps } from './wastewater-mutations-over-time';
+import { WISE_DETAILS_ENDPOINT, WISE_LAPIS_URL } from '../../../constants';
+import referenceGenome from '../../../lapisApi/__mockData__/referenceGenome.json';
+import { LapisUrlContext } from '../../LapisUrlContext';
+import { ReferenceGenomeContext } from '../../ReferenceGenomeContext';
+import details from './__mockData__/details.json';
+
+const meta: Meta<WastewaterMutationsOverTimeProps> = {
+    title: 'Wastewater visualization/Wastewater mutations over time',
+    component: WastewaterMutationsOverTime,
+    argTypes: {
+        width: { control: 'text' },
+        height: { control: 'text' },
+        lapisFilter: { control: 'object' },
+        sequenceType: {
+            options: ['nucleotide', 'amino acid'],
+            control: { type: 'radio' },
+        },
+    },
+    parameters: {
+        fetchMock: {},
+    },
+};
+
+export default meta;
+
+const Template = {
+    render: (args: WastewaterMutationsOverTimeProps) => (
+        <LapisUrlContext.Provider value={WISE_LAPIS_URL}>
+            <ReferenceGenomeContext.Provider value={referenceGenome}>
+                <WastewaterMutationsOverTime
+                    width={args.width}
+                    height={args.height}
+                    lapisFilter={args.lapisFilter}
+                    sequenceType={args.sequenceType}
+                />
+            </ReferenceGenomeContext.Provider>
+        </LapisUrlContext.Provider>
+    ),
+};
+
+export const Default: StoryObj<WastewaterMutationsOverTimeProps> = {
+    ...Template,
+    args: {
+        width: '100%',
+        height: '700px',
+        lapisFilter: {},
+        sequenceType: 'nucleotide',
+    },
+    parameters: {
+        fetchMock: {
+            mocks: [
+                {
+                    matcher: {
+                        name: 'details',
+                        url: WISE_DETAILS_ENDPOINT,
+                        body: {
+                            fields: ['date', 'location', 'nucleotideMutationFrequency', 'aminoAcidMutationFrequency'],
+                        },
+                    },
+                    response: {
+                        status: 200,
+                        body: details,
+                    },
+                },
+            ],
+        },
+    },
+};

package/src/preact/wastewater/mutationsOverTime/wastewater-mutations-over-time.tsx

@@ -0,0 +1,151 @@
+import { type FunctionComponent } from 'preact';
+import { type Dispatch, type StateUpdater, useContext, useState } from 'preact/hooks';
+import z from 'zod';
+
+import { computeWastewaterMutationsOverTimeDataPerLocation } from './computeWastewaterMutationsOverTimeDataPerLocation';
+import { lapisFilterSchema, sequenceTypeSchema } from '../../../types';
+import { LapisUrlContext } from '../../LapisUrlContext';
+import { type ColorScale } from '../../components/color-scale-selector';
+import { ColorScaleSelectorDropdown } from '../../components/color-scale-selector-dropdown';
+import { ErrorBoundary } from '../../components/error-boundary';
+import { Fullscreen } from '../../components/fullscreen';
+import Info, { InfoComponentCode, InfoHeadline1, InfoParagraph } from '../../components/info';
+import { LoadingDisplay } from '../../components/loading-display';
+import { NoDataDisplay } from '../../components/no-data-display';
+import { ResizeContainer } from '../../components/resize-container';
+import Tabs from '../../components/tabs';
+import { type MutationOverTimeDataMap } from '../../mutationsOverTime/MutationOverTimeData';
+import MutationsOverTimeGrid from '../../mutationsOverTime/mutations-over-time-grid';
+import { useQuery } from '../../useQuery';
+
+const wastewaterMutationOverTimeSchema = z.object({
+    lapisFilter: lapisFilterSchema,
+    sequenceType: sequenceTypeSchema,
+    width: z.string(),
+    height: z.string(),
+});
+
+export type WastewaterMutationsOverTimeProps = z.infer<typeof wastewaterMutationOverTimeSchema>;
+
+export const WastewaterMutationsOverTime: FunctionComponent<WastewaterMutationsOverTimeProps> = (componentProps) => {
+    const { width, height } = componentProps;
+    const size = { height, width };
+
+    return (
+        <ErrorBoundary size={size} schema={wastewaterMutationOverTimeSchema} componentProps={componentProps}>
+            <ResizeContainer size={size}>
+                <WastewaterMutationsOverTimeInner {...componentProps} />
+            </ResizeContainer>
+        </ErrorBoundary>
+    );
+};
+
+export const WastewaterMutationsOverTimeInner: FunctionComponent<WastewaterMutationsOverTimeProps> = (
+    componentProps,
+) => {
+    const lapis = useContext(LapisUrlContext);
+
+    const {
+        data: mutationOverTimeDataPerLocation,
+        error,
+        isLoading,
+    } = useQuery(
+        () =>
+            computeWastewaterMutationsOverTimeDataPerLocation(
+                lapis,
+                componentProps.lapisFilter,
+                componentProps.sequenceType,
+            ),
+        [],
+    );
+
+    if (isLoading) {
+        return <LoadingDisplay />;
+    }
+
+    if (error !== null) {
+        throw error;
+    }
+
+    if (mutationOverTimeDataPerLocation.length === 0) {
+        return <NoDataDisplay />;
+    }
+
+    return (
+        <MutationsOverTimeTabs
+            mutationOverTimeDataPerLocation={mutationOverTimeDataPerLocation}
+            originalComponentProps={componentProps}
+        />
+    );
+};
+
+type MutationOverTimeDataPerLocation = {
+    location: string;
+    data: MutationOverTimeDataMap;
+}[];
+
+type MutationOverTimeTabsProps = {
+    mutationOverTimeDataPerLocation: MutationOverTimeDataPerLocation;
+    originalComponentProps: WastewaterMutationsOverTimeProps;
+};
+
+const MutationsOverTimeTabs: FunctionComponent<MutationOverTimeTabsProps> = ({
+    mutationOverTimeDataPerLocation,
+    originalComponentProps,
+}) => {
+    const [colorScale, setColorScale] = useState<ColorScale>({ min: 0, max: 1, color: 'indigo' });
+
+    const tabs = mutationOverTimeDataPerLocation.map(({ location, data }) => ({
+        title: location,
+        content: <MutationsOverTimeGrid data={data} colorScale={colorScale} />,
+    }));
+
+    const toolbar = (
+        <Toolbar
+            colorScale={colorScale}
+            setColorScale={setColorScale}
+            originalComponentProps={originalComponentProps}
+            data={mutationOverTimeDataPerLocation}
+        />
+    );
+
+    return <Tabs tabs={tabs} toolbar={toolbar} />;
+};
+
+type ToolbarProps = {
+    colorScale: ColorScale;
+    setColorScale: Dispatch<StateUpdater<ColorScale>>;
+    originalComponentProps: WastewaterMutationsOverTimeProps;
+    data: MutationOverTimeDataPerLocation;
+};
+
+const Toolbar: FunctionComponent<ToolbarProps> = ({ colorScale, setColorScale, originalComponentProps }) => {
+    return (
+        <>
+            <ColorScaleSelectorDropdown colorScale={colorScale} setColorScale={setColorScale} />
+            <WastewaterMutationsOverTimeInfo originalComponentProps={originalComponentProps} />
+            <Fullscreen />
+        </>
+    );
+};
+
+type WastewaterMutationsOverTimeInfoProps = {
+    originalComponentProps: WastewaterMutationsOverTimeProps;
+};
+
+const WastewaterMutationsOverTimeInfo: FunctionComponent<WastewaterMutationsOverTimeInfoProps> = ({
+    originalComponentProps,
+}) => {
+    const lapis = useContext(LapisUrlContext);
+    return (
+        <Info>
+            <InfoHeadline1>Info for mutations over time</InfoHeadline1>
+            <InfoParagraph> </InfoParagraph>
+            <InfoComponentCode
+                componentName='wastewater-mutations-over-time'
+                params={originalComponentProps}
+                lapisUrl={lapis}
+            />
+        </Info>
+    );
+};

package/src/query/queryMutationsOverTime.ts

@@ -16,14 +16,7 @@ import {
     type SubstitutionOrDeletionEntry,
     type TemporalGranularity,
 } from '../types';
-import { type Map2d } from '../utils/map2d';
-import {
-    type Deletion,
-    type DeletionClass,
-    type Substitution,
-    type SubstitutionClass,
-    toSubstitutionOrDeletion,
-} from '../utils/mutations';
+import { type Deletion, type Substitution, toSubstitutionOrDeletion } from '../utils/mutations';
 import {
     compareTemporal,
     dateRangeCompare,
@@ -41,12 +34,11 @@ export type MutationOverTimeData = {
     totalCount: number;
 };
 
-export type MutationOverTimeMutationValue = { proportion: number; count: number; totalCount: number } | null;
-export type MutationOverTimeDataGroupedByMutation = Map2d<
-    SubstitutionClass | DeletionClass,
-    TemporalClass,
-    MutationOverTimeMutationValue
->;
+export type MutationOverTimeMutationValue = {
+    proportion: number;
+    count: number | null;
+    totalCount: number | null;
+} | null;
 
 const MAX_NUMBER_OF_GRID_COLUMNS = 200;
 

package/src/query/queryWastewaterMutationsOverTime.spec.ts

@@ -0,0 +1,94 @@
+import { describe, expect, it } from 'vitest';
+
+import { queryWastewaterMutationsOverTime } from './queryWastewaterMutationsOverTime';
+import { DUMMY_LAPIS_URL, lapisRequestMocks } from '../../vitest.setup';
+import { SubstitutionClass } from '../utils/mutations';
+import { TemporalCache } from '../utils/temporalClass';
+
+const temporalCache = TemporalCache.getInstance();
+
+describe('queryWastewaterMutationsOverTime', () => {
+    it('should fetch data', async () => {
+        const lapisFilter = { country: 'Germany' };
+
+        lapisRequestMocks.details(
+            {
+                country: 'Germany',
+                fields: ['date', 'location', 'nucleotideMutationFrequency', 'aminoAcidMutationFrequency'],
+            },
+            {
+                data: [
+                    {
+                        date: '2021-01-01',
+                        location: 'Germany',
+                        reference: 'organismA',
+                        nucleotideMutationFrequency: JSON.stringify({
+                            A123T: 0.4,
+                            '123G': null,
+                        }),
+                        aminoAcidMutationFrequency: null,
+                    },
+                    {
+                        date: '2021-01-02',
+                        location: 'Germany',
+                        reference: 'organismA',
+                        nucleotideMutationFrequency: null,
+                        aminoAcidMutationFrequency: JSON.stringify({
+                            'S:A123T': 0.4,
+                            'S:123G': 0.1,
+                        }),
+                    },
+                ],
+            },
+        );
+
+        const result = await queryWastewaterMutationsOverTime(DUMMY_LAPIS_URL, lapisFilter);
+
+        expect(result).to.deep.equal([
+            {
+                location: 'Germany',
+                date: temporalCache.getYearMonthDay('2021-01-01'),
+                nucleotideMutationFrequency: [
+                    { mutation: SubstitutionClass.parse('A123T'), proportion: 0.4 },
+                    { mutation: SubstitutionClass.parse('123G'), proportion: null },
+                ],
+                aminoAcidMutationFrequency: [],
+            },
+            {
+                location: 'Germany',
+                date: temporalCache.getYearMonthDay('2021-01-02'),
+                nucleotideMutationFrequency: [],
+                aminoAcidMutationFrequency: [
+                    { mutation: SubstitutionClass.parse('S:A123T'), proportion: 0.4 },
+                    { mutation: SubstitutionClass.parse('S:123G'), proportion: 0.1 },
+                ],
+            },
+        ]);
+    });
+
+    it('should error when the mutation frequency object is invalid', async () => {
+        const lapisFilter = { country: 'Germany' };
+
+        lapisRequestMocks.details(
+            {
+                country: 'Germany',
+                fields: ['date', 'location', 'nucleotideMutationFrequency', 'aminoAcidMutationFrequency'],
+            },
+            {
+                data: [
+                    {
+                        date: '2021-01-01',
+                        location: 'Germany',
+                        reference: 'organismA',
+                        nucleotideMutationFrequency: JSON.stringify({ key: 'not an object of the expected type' }),
+                        aminoAcidMutationFrequency: null,
+                    },
+                ],
+            },
+        );
+
+        await expect(queryWastewaterMutationsOverTime(DUMMY_LAPIS_URL, lapisFilter)).rejects.toThrowError(
+            /^Failed to parse mutation frequency/,
+        );
+    });
+});