PostgreSQL backup tool with Point-In-Time-Recovery and restore verification
TypeScript backupbackupsdatabasedatabase-backupdevopsdockergolangkubernetesmariadbmongodbmysqlpgpostgrespostgresqls3self-hostedsystem-administrationtoolsweb-ui
import { describe, expect, it, vi } from 'vitest';
import type { PagedListPage } from './pagedList';
import { PagedListController } from './PagedListController';
interface Row {
id: string;
}
type RowPage = PagedListPage<Row, string>;
const rows = (...ids: string[]): Row[] => ids.map((id) => ({ id }));
const createDeferredPage = () => {
let resolvePage: (page: RowPage) => void = () => {};
const promise = new Promise<RowPage>((resolve) => {
resolvePage = resolve;
});
return { promise, resolvePage };
};
const createController = (fetchPage: (cursor: string | undefined) => Promise<RowPage>) => {
const onError = vi.fn();
const controller = new PagedListController<Row, string>(
{ fetchPage, getItemKey: (row) => row.id, onError },
() => {},
);
return { controller, onError };
};
const getLoadedIds = (controller: PagedListController<Row, string>) =>
controller.getState().list.items.map((row) => row.id);
describe('PagedListController', () => {
it('loads the first page on reload', async () => {
const fetchPage = vi.fn().mockResolvedValue({ items: rows('a', 'b'), nextCursor: 'after-b' });
const { controller } = createController(fetchPage);
await controller.reload();
expect(fetchPage).toHaveBeenCalledWith(undefined);
expect(getLoadedIds(controller)).toEqual(['a', 'b']);
expect(controller.getState().isLoading).toBe(false);
});
it('requests the next page with the stored cursor and appends it', async () => {
const fetchPage = vi
.fn()
.mockResolvedValueOnce({ items: rows('a', 'b'), nextCursor: 'after-b' })
.mockResolvedValueOnce({ items: rows('c'), nextCursor: undefined });
const { controller } = createController(fetchPage);
await controller.reload();
await controller.loadNextPage();
expect(fetchPage).toHaveBeenLastCalledWith('after-b');
expect(getLoadedIds(controller)).toEqual(['a', 'b', 'c']);
expect(controller.getState().list.nextCursor).toBeUndefined();
});
it('requests nothing more once the last page is loaded', async () => {
const fetchPage = vi.fn().mockResolvedValue({ items: rows('a'), nextCursor: undefined });
const { controller } = createController(fetchPage);
await controller.reload();
await controller.loadNextPage();
expect(fetchPage).toHaveBeenCalledTimes(1);
});
it('refreshes with the first page only and keeps the scrolled tail', async () => {
const fetchPage = vi
.fn()
.mockResolvedValueOnce({ items: rows('a', 'b'), nextCursor: 'after-b' })
.mockResolvedValueOnce({ items: rows('c', 'd'), nextCursor: 'after-d' })
.mockResolvedValueOnce({ items: rows('new', 'a'), nextCursor: 'after-a' });
const { controller } = createController(fetchPage);
await controller.reload();
await controller.loadNextPage();
await controller.refreshFirstPage();
expect(fetchPage).toHaveBeenLastCalledWith(undefined);
expect(getLoadedIds(controller)).toEqual(['new', 'a', 'b', 'c', 'd']);
expect(controller.getState().list.nextCursor).toBe('after-d');
});
it('skips a refresh while the previous one is in flight', async () => {
const pendingRefresh = createDeferredPage();
const fetchPage = vi
.fn()
.mockResolvedValueOnce({ items: rows('a'), nextCursor: undefined })
.mockReturnValueOnce(pendingRefresh.promise);
const { controller } = createController(fetchPage);
await controller.reload();
const firstRefresh = controller.refreshFirstPage();
await controller.refreshFirstPage();
pendingRefresh.resolvePage({ items: rows('new', 'a'), nextCursor: undefined });
await firstRefresh;
expect(fetchPage).toHaveBeenCalledTimes(2);
expect(getLoadedIds(controller)).toEqual(['new', 'a']);
});
it('skips a next-page request while the previous one is in flight', async () => {
const pendingNextPage = createDeferredPage();
const fetchPage = vi
.fn()
.mockResolvedValueOnce({ items: rows('a'), nextCursor: 'after-a' })
.mockReturnValueOnce(pendingNextPage.promise);
const { controller } = createController(fetchPage);
await controller.reload();
const firstLoad = controller.loadNextPage();
await controller.loadNextPage();
pendingNextPage.resolvePage({ items: rows('b'), nextCursor: undefined });
await firstLoad;
expect(fetchPage).toHaveBeenCalledTimes(2);
expect(getLoadedIds(controller)).toEqual(['a', 'b']);
});
it('drops a refresh that answers after a reload', async () => {
const staleRefresh = createDeferredPage();
const fetchPage = vi
.fn()
.mockResolvedValueOnce({ items: rows('old'), nextCursor: undefined })
.mockReturnValueOnce(staleRefresh.promise)
.mockResolvedValueOnce({ items: rows('filtered'), nextCursor: undefined });
const { controller } = createController(fetchPage);
await controller.reload();
const refresh = controller.refreshFirstPage();
await controller.reload();
staleRefresh.resolvePage({ items: rows('old', 'stale'), nextCursor: undefined });
await refresh;
expect(getLoadedIds(controller)).toEqual(['filtered']);
});
it('drops a next page that answers after a reload', async () => {
const staleNextPage = createDeferredPage();
const fetchPage = vi
.fn()
.mockResolvedValueOnce({ items: rows('old'), nextCursor: 'after-old' })
.mockReturnValueOnce(staleNextPage.promise)
.mockResolvedValueOnce({ items: rows('filtered'), nextCursor: undefined });
const { controller } = createController(fetchPage);
await controller.reload();
const nextPageLoad = controller.loadNextPage();
await controller.reload();
staleNextPage.resolvePage({ items: rows('stale'), nextCursor: undefined });
await nextPageLoad;
expect(getLoadedIds(controller)).toEqual(['filtered']);
expect(controller.getState().isLoadingMore).toBe(false);
});
it('reports an error from the current list and ignores one from a replaced list', async () => {
const staleRefresh = createDeferredPage();
const fetchPage = vi
.fn()
.mockResolvedValueOnce({ items: rows('a'), nextCursor: undefined })
.mockReturnValueOnce(staleRefresh.promise.then(() => Promise.reject(new Error('stale'))))
.mockResolvedValueOnce({ items: rows('b'), nextCursor: undefined })
.mockRejectedValueOnce(new Error('current'));
const { controller, onError } = createController(fetchPage);
await controller.reload();
const refresh = controller.refreshFirstPage();
await controller.reload();
staleRefresh.resolvePage({ items: [], nextCursor: undefined });
await refresh;
await controller.refreshFirstPage();
expect(onError).toHaveBeenCalledTimes(1);
expect(onError).toHaveBeenCalledWith(new Error('current'));
});
});