dyomedea/src/db/rte.test.ts

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]);
  // });
});