shlink-web-client/test/visits/reducers/visitsOverview.test.ts

166 lines
6.5 KiB
TypeScript
Raw Normal View History

import { fromPartial } from '@total-typescript/shoehorn';
import { createNewVisits } from '../../../shlink-web-component/src/visits/reducers/visitCreation';
2023-02-18 12:40:37 +03:00
import type {
PartialVisitsSummary,
VisitsOverview,
} from '../../../shlink-web-component/src/visits/reducers/visitsOverview';
2023-02-18 12:40:37 +03:00
import {
2022-11-11 22:23:19 +03:00
loadVisitsOverview as loadVisitsOverviewCreator,
visitsOverviewReducerCreator,
} from '../../../shlink-web-component/src/visits/reducers/visitsOverview';
import type { OrphanVisit } from '../../../shlink-web-component/src/visits/types';
import type { ShlinkApiClient } from '../../../src/api/services/ShlinkApiClient';
import type { ShlinkVisitsOverview } from '../../../src/api/types';
import type { ShlinkState } from '../../../src/container/types';
2020-12-07 21:19:37 +03:00
describe('visitsOverviewReducer', () => {
2023-05-27 12:57:26 +03:00
const getVisitsOverview = vi.fn();
const buildApiClientMock = () => fromPartial<ShlinkApiClient>({ getVisitsOverview });
2022-11-11 22:23:19 +03:00
const loadVisitsOverview = loadVisitsOverviewCreator(buildApiClientMock);
const { reducer } = visitsOverviewReducerCreator(loadVisitsOverview);
2020-12-07 21:19:37 +03:00
describe('reducer', () => {
const state = (payload: Partial<VisitsOverview> = {}) => fromPartial<VisitsOverview>(payload);
2020-12-07 21:19:37 +03:00
it('returns loading on GET_OVERVIEW_START', () => {
2022-11-11 22:23:19 +03:00
const { loading } = reducer(
state({ loading: false, error: false }),
loadVisitsOverview.pending(''),
2022-11-11 22:23:19 +03:00
);
2020-12-07 21:19:37 +03:00
expect(loading).toEqual(true);
});
it('stops loading and returns error on GET_OVERVIEW_ERROR', () => {
2022-11-11 22:23:19 +03:00
const { loading, error } = reducer(
state({ loading: true, error: false }),
loadVisitsOverview.rejected(null, ''),
2022-11-11 22:23:19 +03:00
);
2020-12-07 21:19:37 +03:00
expect(loading).toEqual(false);
expect(error).toEqual(true);
});
it('return visits overview on GET_OVERVIEW', () => {
const action = loadVisitsOverview.fulfilled(fromPartial({
nonOrphanVisits: { total: 100 },
}), 'requestId');
const { loading, error, nonOrphanVisits } = reducer(state({ loading: true, error: false }), action);
2020-12-07 21:19:37 +03:00
expect(loading).toEqual(false);
expect(error).toEqual(false);
expect(nonOrphanVisits.total).toEqual(100);
2020-12-07 21:19:37 +03:00
});
it.each([
2022-03-26 14:17:42 +03:00
[50, 53],
[0, 3],
])('returns updated amounts on CREATE_VISITS', (providedOrphanVisitsCount, expectedOrphanVisitsCount) => {
const { nonOrphanVisits, orphanVisits } = reducer(
state({
nonOrphanVisits: { total: 100 },
orphanVisits: { total: providedOrphanVisitsCount },
}),
createNewVisits([
fromPartial({ visit: {} }),
fromPartial({ visit: {} }),
fromPartial({ visit: fromPartial<OrphanVisit>({ visitedUrl: '' }) }),
fromPartial({ visit: fromPartial<OrphanVisit>({ visitedUrl: '' }) }),
fromPartial({ visit: fromPartial<OrphanVisit>({ visitedUrl: '' }) }),
]),
);
expect(nonOrphanVisits.total).toEqual(102);
expect(orphanVisits.total).toEqual(expectedOrphanVisitsCount);
});
it.each([
[
{} satisfies Omit<PartialVisitsSummary, 'total'>,
{} satisfies Omit<PartialVisitsSummary, 'total'>,
{ total: 103 } satisfies PartialVisitsSummary,
{ total: 203 } satisfies PartialVisitsSummary,
],
[
{ bots: 35 } satisfies Omit<PartialVisitsSummary, 'total'>,
{ bots: 35 } satisfies Omit<PartialVisitsSummary, 'total'>,
{ total: 103, bots: 37 } satisfies PartialVisitsSummary,
{ total: 203, bots: 36 } satisfies PartialVisitsSummary,
],
[
{ nonBots: 41, bots: 85 } satisfies Omit<PartialVisitsSummary, 'total'>,
{ nonBots: 63, bots: 27 } satisfies Omit<PartialVisitsSummary, 'total'>,
{ total: 103, nonBots: 42, bots: 87 } satisfies PartialVisitsSummary,
{ total: 203, nonBots: 65, bots: 28 } satisfies PartialVisitsSummary,
],
[
{ nonBots: 56 } satisfies Omit<PartialVisitsSummary, 'total'>,
{ nonBots: 99 } satisfies Omit<PartialVisitsSummary, 'total'>,
{ total: 103, nonBots: 57 } satisfies PartialVisitsSummary,
{ total: 203, nonBots: 101 } satisfies PartialVisitsSummary,
],
])('takes bots and non-bots into consideration when creating visits', (
initialNonOrphanVisits,
initialOrphanVisits,
expectedNonOrphanVisits,
expectedOrphanVisits,
) => {
const { nonOrphanVisits, orphanVisits } = reducer(
state({
nonOrphanVisits: { total: 100, ...initialNonOrphanVisits },
orphanVisits: { total: 200, ...initialOrphanVisits },
}),
createNewVisits([
fromPartial({ visit: {} }),
fromPartial({ visit: { potentialBot: true } }),
fromPartial({ visit: { potentialBot: true } }),
fromPartial({ visit: fromPartial<OrphanVisit>({ visitedUrl: '' }) }),
fromPartial({ visit: fromPartial<OrphanVisit>({ visitedUrl: '' }) }),
fromPartial({ visit: fromPartial<OrphanVisit>({ visitedUrl: '', potentialBot: true }) }),
]),
);
expect(nonOrphanVisits).toEqual(expectedNonOrphanVisits);
expect(orphanVisits).toEqual(expectedOrphanVisits);
});
2020-12-07 21:19:37 +03:00
});
describe('loadVisitsOverview', () => {
2023-05-27 12:57:26 +03:00
const dispatchMock = vi.fn();
const getState = () => fromPartial<ShlinkState>({});
2020-12-07 21:19:37 +03:00
it.each([
[
// Shlink <3.5.0
{ visitsCount: 50, orphanVisitsCount: 20 } satisfies ShlinkVisitsOverview,
{
nonOrphanVisits: { total: 50, nonBots: undefined, bots: undefined },
orphanVisits: { total: 20, nonBots: undefined, bots: undefined },
},
],
[
// Shlink >=3.5.0
{
nonOrphanVisits: { total: 50, nonBots: 20, bots: 30 },
orphanVisits: { total: 50, nonBots: 20, bots: 30 },
visitsCount: 3,
orphanVisitsCount: 3,
} satisfies ShlinkVisitsOverview,
{
nonOrphanVisits: { total: 50, nonBots: 20, bots: 30 },
orphanVisits: { total: 50, nonBots: 20, bots: 30 },
},
],
])('dispatches start and success when promise is resolved', async (serverResult, dispatchedPayload) => {
const resolvedOverview = fromPartial<ShlinkVisitsOverview>(serverResult);
2022-11-11 22:23:19 +03:00
getVisitsOverview.mockResolvedValue(resolvedOverview);
2020-12-07 21:19:37 +03:00
2022-11-11 22:23:19 +03:00
await loadVisitsOverview()(dispatchMock, getState, {});
2020-12-07 21:19:37 +03:00
expect(dispatchMock).toHaveBeenCalledTimes(2);
expect(dispatchMock).toHaveBeenNthCalledWith(2, expect.objectContaining({ payload: dispatchedPayload }));
2022-11-11 22:23:19 +03:00
expect(getVisitsOverview).toHaveBeenCalledTimes(1);
2020-12-07 21:19:37 +03:00
});
});
});