dyomedea/src/db/rte.test.ts

170 lines
4.5 KiB
TypeScript

import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import shell from 'shelljs';
import PouchDB from 'pouchdb';
import { getRte, putNewRte, putRte } from './rte';
import { put } from './lib';
import { emptyWpt } from './wpt';
import { sleep } from '../lib/async-wait';
import { debounce, memoize, property, wrap } from 'lodash';
import memoizee from 'memoizee';
const test = it;
const jest = vi;
declare global {
var db: any;
var dbReady: boolean;
}
const originalDb = globalThis.db;
const originalDateNow = globalThis.Date.now;
describe('The rte module', () => {
beforeEach(() => {
globalThis.db = { put: jest.fn() };
globalThis.Date.now = () => 0;
});
afterEach(() => {
globalThis.db = originalDb;
globalThis.Date.now = originalDateNow;
});
test('db.put() a new rte when required', async () => {
putNewRte({ gpx: 4320000000000000, rte: 25 });
await expect(globalThis.db.put).toBeCalledWith({
_id: 'gpx/4320000000000000/2rte/000025',
_rev: undefined,
doc: {
cmt: undefined,
desc: undefined,
extensions: undefined,
link: undefined,
name: undefined,
number: 0,
rtept: undefined,
src: undefined,
type: undefined,
},
type: 'rte',
});
});
test('db.put() generates an id for the trk if needed', async () => {
const id = await putNewRte({ gpx: 0 });
expect(id).toEqual({ gpx: 0, rte: 0 });
});
test('db.put() generates ids for both gpx and trk if needed', async () => {
const id = await putNewRte();
expect(id).toEqual({ gpx: 4320000000000000, rte: 0 });
});
});
describe('The rte module with a real db', () => {
beforeEach(async () => {
globalThis.db = new PouchDB('dyomedea', {
auto_compaction: false,
});
globalThis.Date.now = () => 0;
});
afterEach(async () => {
try {
await db.destroy();
} catch (err) {
// console.error(err);
await shell.exec('rm -rf $*$');
}
globalThis.db = undefined;
globalThis.dbReady = false;
globalThis.Date.now = originalDateNow;
});
it('can write and read a rte', async () => {
const id = 'whatever';
const rte: Rte = {
name: 'A new route',
};
const rtePut = await putRte({ id, rte });
expect(rtePut).toEqual(rte);
const rteGet = await getRte({ id });
expect(rteGet).toEqual(rte);
});
it('can write and read a rte with rtepts', async () => {
const id = 'whatever';
const rte: Rte = {
name: 'A new route',
rtept: [
{
$: { lat: 0, lon: 0 },
},
{
$: { lat: 1, lon: 1 },
},
],
};
const rtePut = await putRte({ id, rte });
expect(rtePut).toEqual(rte);
const rteGet = await getRte({ id });
expect(rteGet).toEqual(rte);
});
it('can read external rtepts ', async () => {
const idRte = 'gpx/4320836410265485/2rte/000034';
const idRtept = 'gpx/4320836410265485/2rte/000034/000035';
const rtept3: Wpt = {
$: { lat: 3, lon: 3 },
};
const rte0: Rte = {
name: 'A new route',
rtept: [
{
$: { lat: 1, lon: 1 },
},
{
$: { lat: 2, lon: 2 },
},
],
};
const rte1: Rte = {
name: 'A new route',
rtept: [
{
$: { lat: 1, lon: 1 },
},
{
$: { lat: 2, lon: 2 },
},
rtept3,
],
};
const rtePut = await putRte({ id: idRte, rte: rte0 });
expect(rtePut).toEqual(rte0);
await put(idRtept, 'rtept', () => rtept3, emptyWpt);
expect(await getRte({ id: idRte })).toEqual(rte1);
});
// it('debounces correctly by param ', async () => {
// let values = [0, 1, 2, 3, 4, 5];
// const decrement = (params: any) => {
// const { id } = params;
// //await sleep(1);
// values[2] = values[2] - 1;
// };
// const debounceByParam = (targetFunc, resolver, ...debounceParams) =>
// wrap(
// memoize(() => debounce(targetFunc, ...debounceParams), resolver),
// (getMemoizedFunc, ...params) => getMemoizedFunc(...params)(...params)
// );
// const debouncedDecrement = debounce(decrement, 100);
// debouncedDecrement({ id: 2 });
// debouncedDecrement({ id: 2 });
// debouncedDecrement({ id: 5 });
// debouncedDecrement({ id: 2 });
// debouncedDecrement({ id: 5 });
// debouncedDecrement({ id: 2 });
// debouncedDecrement({ id: 2 });
// debouncedDecrement({ id: 2 });
// await sleep(2000);
// expect(values).toEqual([0, 1, 1, 3, 4, 4]);
// });
});