import {

ReplicacheTest,

httpStatusUnauthorized,

MutatorDefs,

} from './replicache.js';

import type {ReplicacheOptions} from './replicache.js';

import {Replicache, TransactionClosedError} from './mod.js';

import type {ReadTransaction, WriteTransaction} from './mod.js';

import {deepEqual, JSONValue} from './json.js';

import {assert, expect} from '@esm-bundle/chai';

import * as sinon from 'sinon';

import type {SinonSpy} from 'sinon';

// fetch-mock has invalid d.ts file so we removed that on npm install.

// eslint-disable-next-line @typescript-eslint/ban-ts-comment

// @ts-expect-error

import fetchMock from 'fetch-mock/esm/client.js';

import {Invoke, RPC} from './repm-invoker.js';

import type {ScanOptions} from './scan-options.js';

import {SinonFakeTimers, useFakeTimers} from 'sinon';

import {asyncIterableToArray} from './async-iterable-to-array.js';

let clock: SinonFakeTimers;

setup(function () {

clock = useFakeTimers(0);

});

teardown(function () {

clock.restore();

});

async function tickAFewTimes(n = 10, time = 10) {

for (let i = 0; i < n; i++) {

await clock.tickAsync(time);

}

}

fetchMock.config.overwriteRoutes = true;

const {fail} = assert;

const reps: Set<ReplicacheTest> = new Set();

let overrideUseMemstore = false;

// eslint-disable-next-line @typescript-eslint/ban-types

async function replicacheForTesting<MD extends MutatorDefs = {}>(

name: string,

{

pullURL = 'https://pull.com/?name=' + name,

pushDelay = 60_000, // Large to prevent interfering

pushURL = 'https://push.com/?name=' + name,

useMemstore = overrideUseMemstore,

...rest

}: ReplicacheOptions<MD> = {},

): Promise<ReplicacheTest<MD>> {

dbsToDrop.add(name);

const rep = new ReplicacheTest<MD>({

pullURL,

pushDelay,

pushURL,

name,

useMemstore,

...rest,

});

reps.add(rep);

fetchMock.post(pullURL, {lastMutationID: 0, patch: []});

fetchMock.post(pushURL, {});

await tickAFewTimes();

return rep;

}

const dbsToDrop = new Set<string>();

async function addData(tx: WriteTransaction, data: {[key: string]: JSONValue}) {

for (const [key, value] of Object.entries(data)) {

await tx.put(key, value);

}

}

const emptyHash = '';

function spyInvoke(

rep: Replicache,

): SinonSpy<Parameters<Invoke>, ReturnType<Invoke>> {

// eslint-disable-next-line @typescript-eslint/ban-ts-comment

// @ts-ignore

return sinon.spy(rep, '_invoke');

}

teardown(async () => {

fetchMock.restore();

sinon.restore();

for (const rep of reps) {

if (!rep.closed) {

await rep.close();

}

reps.delete(rep);

}

for (const name of dbsToDrop) {

indexedDB.deleteDatabase(name);

}

dbsToDrop.clear();

});

async function expectPromiseToReject(p: unknown): Promise<Chai.Assertion> {

let e;

try {

await p;

} catch (ex) {

e = ex;

}

return expect(e);

}

async function expectAsyncFuncToThrow(f: () => unknown, c: unknown) {

(await expectPromiseToReject(f())).to.be.instanceof(c);

}

function testWithBothStores(name: string, func: () => Promise<void>) {

for (const useMemstore of [false, true]) {

test(`${name} {useMemstore: ${useMemstore}}`, async () => {

try {

overrideUseMemstore = useMemstore;

await func();

} finally {

overrideUseMemstore = false;

}

});

}

}

testWithBothStores('get, has, scan on empty db', async () => {

const rep = await replicacheForTesting('test2');

async function t(tx: ReadTransaction) {

expect(await tx.get('key')).to.equal(undefined);

expect(await tx.has('key')).to.be.false;

const scanItems = await asyncIterableToArray(tx.scan());

expect(scanItems).to.have.length(0);

}

await t(rep);

});

testWithBothStores('put, get, has, del inside tx', async () => {

const rep = await replicacheForTesting('test3', {

mutators: {

testMut: async (

tx: WriteTransaction,

args: {key: string; value: JSONValue},

) => {

const key = args['key'];

const value = args['value'];

await tx.put(key, value);

expect(await tx.has(key)).to.equal(true);

const v = await tx.get(key);

expect(v).to.deep.equal(value);

expect(await tx.del(key)).to.equal(true);

expect(await tx.has(key)).to.be.false;

},

},

});

const {testMut} = rep.mutate;

for (const [key, value] of Object.entries({

a: true,

b: false,

c: null,

d: 'string',

e: 12,

f: {},

g: [],

h: {h1: true},

i: [0, 1],

})) {

await testMut({key, value: value as JSONValue});

}

});

async function testScanResult<K, V>(

rep: Replicache,

options: ScanOptions | undefined,

entries: [K, V][],

) {

await rep.query(async tx => {

expect(

await asyncIterableToArray(tx.scan(options).entries()),

).to.deep.equal(entries);

});

await rep.query(async tx => {

expect(await asyncIterableToArray(tx.scan(options))).to.deep.equal(

entries.map(([, v]) => v),

);

});

await rep.query(async tx => {

expect(await asyncIterableToArray(tx.scan(options).values())).to.deep.equal(

entries.map(([, v]) => v),

);

});

await rep.query(async tx => {

expect(await asyncIterableToArray(tx.scan(options).keys())).to.deep.equal(

entries.map(([k]) => k),

);

});

await rep.query(async tx => {

expect(await tx.scanAll(options)).to.deep.equal(entries);

});

await rep.query(async tx => {

expect(await tx.scan(options).toArray()).to.deep.equal(

entries.map(([, v]) => v),

);

});

// scan().xxx().toArray()

await rep.query(async tx => {

expect(await tx.scan(options).entries().toArray()).to.deep.equal(entries);

});

await rep.query(async tx => {

expect(await tx.scan(options).values().toArray()).to.deep.equal(

entries.map(([, v]) => v),

);

});

await rep.query(async tx => {

expect(await tx.scan(options).keys().toArray()).to.deep.equal(

entries.map(([k]) => k),

);

});

}

testWithBothStores('scan', async () => {

const rep = await replicacheForTesting('test4', {

mutators: {

addData,

},

});

const add = rep.mutate.addData;

await add({

'a/0': 0,

'a/1': 1,

'a/2': 2,

'a/3': 3,

'a/4': 4,

'b/0': 5,

'b/1': 6,

'b/2': 7,

'c/0': 8,

});

await testScanResult(rep, undefined, [

['a/0', 0],

['a/1', 1],

['a/2', 2],

['a/3', 3],

['a/4', 4],

['b/0', 5],

['b/1', 6],

['b/2', 7],

['c/0', 8],

]);

await testScanResult(rep, {prefix: 'a'}, [

['a/0', 0],

['a/1', 1],

['a/2', 2],

['a/3', 3],

['a/4', 4],

]);

await testScanResult(rep, {prefix: 'b'}, [

['b/0', 5],

['b/1', 6],

['b/2', 7],

]);

await testScanResult(rep, {prefix: 'c/'}, [['c/0', 8]]);

await testScanResult(

rep,

{

start: {key: 'b/1', exclusive: false},

},

[

['b/1', 6],

['b/2', 7],

['c/0', 8],

],

);

await testScanResult(

rep,

{

start: {key: 'b/1'},

},

[

['b/1', 6],

['b/2', 7],

['c/0', 8],

],

);

await testScanResult(

rep,

{

start: {key: 'b/1', exclusive: true},

},

[

['b/2', 7],

['c/0', 8],

],

);

await testScanResult(

rep,

{

limit: 3,

},

[

['a/0', 0],

['a/1', 1],

['a/2', 2],

],

);

await testScanResult(

rep,

{

limit: 10,

prefix: 'a/',

},

[

['a/0', 0],

['a/1', 1],

['a/2', 2],

['a/3', 3],

['a/4', 4],

],

);

await testScanResult(

rep,

{

limit: 1,

prefix: 'b/',

},

[['b/0', 5]],

);

});

testWithBothStores('subscribe', async () => {

const log: [string, JSONValue][] = [];

const rep = await replicacheForTesting('subscribe', {

mutators: {

addData,

},

});

let queryCallCount = 0;

const cancel = rep.subscribe(

async (tx: ReadTransaction) => {

queryCallCount++;

const rv = [];

for await (const entry of tx.scan({prefix: 'a/'}).entries()) {

rv.push(entry);

}

return rv;

},

{

onData: (values: Iterable<[string, JSONValue]>) => {

for (const entry of values) {

log.push(entry);

}

},

},

);

expect(log).to.have.length(0);

expect(queryCallCount).to.equal(0);

const add = rep.mutate.addData;

await add({'a/0': 0});

expect(log).to.deep.equal([['a/0', 0]]);

expect(queryCallCount).to.equal(2); // One for initial subscribe and one for the add.

// The body returns the same JSON value in the following case.

log.length = 0;

await add({'a/0': 0});

expect(log).to.deep.equal([]);

expect(queryCallCount).to.equal(3);

log.length = 0;

await add({'a/1': 1});

expect(log).to.deep.equal([

['a/0', 0],

['a/1', 1],

]);

expect(queryCallCount).to.equal(4);

log.length = 0;

log.length = 0;

await add({'a/1': 11});

expect(log).to.deep.equal([

['a/0', 0],

['a/1', 11],

]);

expect(queryCallCount).to.equal(5);

log.length = 0;

cancel();

await add({'a/1': 11});

await Promise.resolve();

expect(log).to.have.length(0);

expect(queryCallCount).to.equal(5);

});

testWithBothStores('subscribe close', async () => {

const rep = await replicacheForTesting('subscribe-close', {

mutators: {addData},

});

const log: (JSONValue | undefined)[] = [];

const cancel = rep.subscribe((tx: ReadTransaction) => tx.get('k'), {

onData: value => log.push(value),

onDone: () => (done = true),

});

expect(log).to.have.length(0);

const add = rep.mutate.addData;

await add({k: 0});

await Promise.resolve();

expect(log).to.deep.equal([undefined, 0]);

let done = false;

await rep.close();

expect(done).to.equal(true);

cancel();

});

testWithBothStores('name', async () => {

const repA = await replicacheForTesting('a', {mutators: {addData}});

const repB = await replicacheForTesting('b', {mutators: {addData}});

const addA = repA.mutate.addData;

const addB = repB.mutate.addData;

await addA({key: 'A'});

await addB({key: 'B'});

expect(await repA.get('key')).to.equal('A');

expect(await repB.get('key')).to.equal('B');

await repA.close();

await repB.close();

indexedDB.deleteDatabase('a');

indexedDB.deleteDatabase('b');

});

testWithBothStores('register with error', async () => {

const rep = await replicacheForTesting('regerr', {

mutators: {

err: async (_: WriteTransaction, args: number) => {

throw args;

},

},

});

const doErr = rep.mutate.err;

try {

await doErr(42);

fail('Should have thrown');

} catch (ex) {

expect(ex).to.equal(42);

}

});

testWithBothStores('subscribe with error', async () => {

const rep = await replicacheForTesting('suberr', {mutators: {addData}});

const add = rep.mutate.addData;

let gottenValue = 0;

let error;

const cancel = rep.subscribe(

async tx => {

const v = await tx.get('k');

if (v !== undefined && v !== null) {

throw v;

}

return null;

},

{

onData: () => {

gottenValue++;

},

onError: e => {

error = e;

},

},

);

await Promise.resolve();

expect(error).to.equal(undefined);

expect(gottenValue).to.equal(0);

await add({k: 'throw'});

expect(gottenValue).to.equal(1);

await Promise.resolve();

expect(error).to.equal('throw');

cancel();

});

testWithBothStores('overlapping writes', async () => {

async function dbWait(tx: ReadTransaction, dur: number) {

// Try to take setTimeout away from me???

const t0 = Date.now();

while (Date.now() - t0 > dur) {

await tx.get('foo');

}

}

const pushURL = 'https://push.com';

// writes wait on writes

const rep = await replicacheForTesting('conflict', {

pushURL,

mutators: {

'wait-then-return': async <T extends JSONValue>(

tx: ReadTransaction,

{duration, ret}: {duration: number; ret: T},

) => {

await dbWait(tx, duration);

return ret;

},

},

});

fetchMock.post(pushURL, {});

const mut = rep.mutate['wait-then-return'];

let resA = mut({duration: 250, ret: 'a'});

// create a gap to make sure resA starts first (our rwlock isn't fair).

await clock.tickAsync(100);

let resB = mut({duration: 0, ret: 'b'});

// race them, a should complete first, indicating that b waited

expect(await Promise.race([resA, resB])).to.equal('a');

// wait for the other to finish so that we're starting from null state for next one.

await Promise.all([resA, resB]);

// reads wait on writes

resA = mut({duration: 250, ret: 'a'});

await clock.tickAsync(100);

resB = rep.query(() => 'b');

await tickAFewTimes();

expect(await Promise.race([resA, resB])).to.equal('a');

await tickAFewTimes();

await resA;

await tickAFewTimes();

await resB;

});

testWithBothStores('push', async () => {

const pushURL = 'https://push.com';

const rep = await replicacheForTesting('push', {

pushAuth: '1',

pushURL,

pushDelay: 10,

mutators: {

createTodo: async <A extends {id: number}>(

tx: WriteTransaction,

args: A,

) => {

createCount++;

await tx.put(`/todo/${args.id}`, args);

},

deleteTodo: async <A extends {id: number}>(

tx: WriteTransaction,

args: A,

) => {

deleteCount++;

await tx.del(`/todo/${args.id}`);

},

},

});

let createCount = 0;

let deleteCount = 0;

const {createTodo, deleteTodo} = rep.mutate;

const id1 = 14323534;

const id2 = 22354345;

await deleteTodo({id: id1});

await deleteTodo({id: id2});

expect(deleteCount).to.equal(2);

fetchMock.postOnce(pushURL, {

mutationInfos: [

{id: 1, error: 'deleteTodo: todo not found'},

{id: 2, error: 'deleteTodo: todo not found'},

],

});

await tickAFewTimes();

expect(deleteCount).to.equal(2);

const {mutations} = await fetchMock.lastCall().request.json();

expect(mutations).to.deep.equal([

{id: 1, name: 'deleteTodo', args: {id: id1}},

{id: 2, name: 'deleteTodo', args: {id: id2}},

]);

await createTodo({

id: id1,

text: 'Test',

});

expect(createCount).to.equal(1);

expect(((await rep?.get(`/todo/${id1}`)) as {text: string}).text).to.equal(

'Test',

);

fetchMock.postOnce(pushURL, {

mutationInfos: [{id: 3, error: 'mutation has already been processed'}],

});

await tickAFewTimes();

{

const {mutations} = await fetchMock.lastCall().request.json();

expect(mutations).to.deep.equal([

{id: 1, name: 'deleteTodo', args: {id: id1}},

{id: 2, name: 'deleteTodo', args: {id: id2}},

{id: 3, name: 'createTodo', args: {id: id1, text: 'Test'}},

]);

}

await createTodo({

id: id2,

text: 'Test 2',

});

expect(createCount).to.equal(2);

expect(((await rep?.get(`/todo/${id2}`)) as {text: string}).text).to.equal(

'Test 2',

);

// Clean up

await deleteTodo({id: id1});

await deleteTodo({id: id2});

expect(deleteCount).to.equal(4);

expect(createCount).to.equal(2);

fetchMock.postOnce(pushURL, {

mutationInfos: [],

});

await tickAFewTimes();

{

const {mutations} = await fetchMock.lastCall().request.json();

expect(mutations).to.deep.equal([

{id: 1, name: 'deleteTodo', args: {id: id1}},

{id: 2, name: 'deleteTodo', args: {id: id2}},

{id: 3, name: 'createTodo', args: {id: id1, text: 'Test'}},

{id: 4, name: 'createTodo', args: {id: id2, text: 'Test 2'}},

{id: 5, name: 'deleteTodo', args: {id: id1}},

{id: 6, name: 'deleteTodo', args: {id: id2}},

]);

}

expect(deleteCount).to.equal(4);

expect(createCount).to.equal(2);

});

testWithBothStores('push delay', async () => {

const pushURL = 'https://push.com';

const rep = await replicacheForTesting('push', {

pushAuth: '1',

pushURL,

pushDelay: 1,

mutators: {

createTodo: async <A extends {id: number}>(

tx: WriteTransaction,

args: A,

) => {

await tx.put(`/todo/${args.id}`, args);

},

},

});

const {createTodo} = rep.mutate;

const id1 = 14323534;

await tickAFewTimes();

fetchMock.reset();

fetchMock.postOnce(pushURL, {

mutationInfos: [],

});

expect(fetchMock.calls()).to.have.length(0);

await createTodo({id: id1});

expect(fetchMock.calls()).to.have.length(0);

await tickAFewTimes();

expect(fetchMock.calls()).to.have.length(1);

});

testWithBothStores('pull', async () => {

const pullURL = 'https://diff.com/pull';

const rep = await replicacheForTesting('pull', {

pullAuth: '1',

pullURL,

mutators: {

createTodo: async <A extends {id: number}>(

tx: WriteTransaction,

args: A,

) => {

createCount++;

await tx.put(`/todo/${args.id}`, args);

},

deleteTodo: async <A extends {id: number}>(

tx: WriteTransaction,

args: A,

) => {

deleteCount++;

await tx.del(`/todo/${args.id}`);

},

},

});

let createCount = 0;

let deleteCount = 0;

let syncHead: string;

let beginPullResult: {

requestID: string;

syncHead: string;

ok: boolean;

};

const {createTodo, deleteTodo} = rep.mutate;

const id1 = 14323534;

const id2 = 22354345;

await deleteTodo({id: id1});

await deleteTodo({id: id2});

expect(deleteCount).to.equal(2);

fetchMock.postOnce(pullURL, {

cookie: '',

lastMutationID: 2,

patch: [

{op: 'del', key: ''},

{

op: 'put',

key: '/list/1',

value: {id: 1, ownerUserID: 1},

},

],

});

rep.pull();

await tickAFewTimes();

expect(deleteCount).to.equal(2);

fetchMock.postOnce(pullURL, {

cookie: '',

lastMutationID: 2,

patch: [],

});

beginPullResult = await rep.beginPull();

({syncHead} = beginPullResult);

expect(syncHead).to.equal(emptyHash);

expect(deleteCount).to.equal(2);

await createTodo({

id: id1,

text: 'Test',

});

expect(createCount).to.equal(1);

expect(((await rep?.get(`/todo/${id1}`)) as {text: string}).text).to.equal(

'Test',

);

fetchMock.postOnce(pullURL, {

cookie: '',

lastMutationID: 3,

patch: [

{

op: 'put',

key: '/todo/14323534',

value: {id: 14323534, text: 'Test'},

},

],

});

beginPullResult = await rep.beginPull();

({syncHead} = beginPullResult);

expect(syncHead).equal('vadlsm00t0h5n05204h6srdjama32lft');

await createTodo({

id: id2,

text: 'Test 2',

});

expect(createCount).to.equal(2);

expect(((await rep?.get(`/todo/${id2}`)) as {text: string}).text).to.equal(

'Test 2',

);

fetchMock.postOnce(pullURL, {

cookie: '',

lastMutationID: 3,

patch: [],

});

await rep.maybeEndPull(beginPullResult);

expect(createCount).to.equal(3);

// Clean up

await deleteTodo({id: id1});

await deleteTodo({id: id2});

expect(deleteCount).to.equal(4);

expect(createCount).to.equal(3);

fetchMock.postOnce(pullURL, {

cookie: '',

lastMutationID: 6,

patch: [{op: 'del', key: '/todo/14323534'}],

});

rep.pull();

await tickAFewTimes();

expect(deleteCount).to.equal(4);

expect(createCount).to.equal(3);

});

testWithBothStores('reauth', async () => {

const pullURL = 'https://diff.com/pull';

const rep = await replicacheForTesting('reauth', {

pullURL,

pullAuth: 'wrong',

});

fetchMock.post(pullURL, {body: 'xxx', status: httpStatusUnauthorized});

const consoleErrorStub = sinon.stub(console, 'error');

const getPullAuthFake = sinon.fake.returns(null);

rep.getPullAuth = getPullAuthFake;

await rep.beginPull();

expect(getPullAuthFake.callCount).to.equal(1);

expect(consoleErrorStub.firstCall.args[0]).to.equal(

'Got error response from server (https://diff.com/pull) doing pull: 401: xxx',

);

{

const consoleInfoStub = sinon.stub(console, 'log');

const getPullAuthFake = sinon.fake(() => 'boo');

rep.getPullAuth = getPullAuthFake;

expect((await rep.beginPull()).syncHead).to.equal('');

expect(getPullAuthFake.callCount).to.equal(8);

expect(consoleInfoStub.firstCall.args[0]).to.equal(

'Tried to reauthenticate too many times',

);

}

});

testWithBothStores('HTTP status pull', async () => {

const pullURL = 'https://diff.com/pull';

const rep = await replicacheForTesting('http-status-pull', {

pullURL,

});

let okCalled = false;

let i = 0;

fetchMock.post(pullURL, () => {

switch (i++) {

case 0:

return {body: 'internal error', status: 500};

case 1:

return {body: 'not found', status: 404};

default:

okCalled = true;

return {body: {lastMutationID: 0, patch: []}, status: 200};

}

});

const consoleErrorStub = sinon.stub(console, 'error');

rep.pull();

await tickAFewTimes(20, 10);

expect(consoleErrorStub.getCalls().map(o => o.args[0])).to.deep.equal([

'Got error response from server (https://diff.com/pull) doing pull: 500: internal error',

'Got error response from server (https://diff.com/pull) doing pull: 404: not found',

]);

expect(okCalled).to.equal(true);

});

testWithBothStores('HTTP status push', async () => {

const pushURL = 'https://diff.com/push';

const rep = await replicacheForTesting('http-status-push', {

pushURL,

pushDelay: 1,

mutators: {addData},

});

const add = rep.mutate.addData;

let okCalled = false;

let i = 0;

fetchMock.post(pushURL, () => {

switch (i++) {

case 0:

return {body: 'internal error', status: 500};

case 1:

return {body: 'not found', status: 404};

default:

okCalled = true;

return {body: {}, status: 200};

}

});

const consoleErrorStub = sinon.stub(console, 'error');

await add({

a: 0,

});

await tickAFewTimes(20, 10);

expect(consoleErrorStub.getCalls().map(o => o.args[0])).to.deep.equal([

'Got error response from server (https://diff.com/push) doing push: 500: internal error',

'Got error response from server (https://diff.com/push) doing push: 404: not found',

]);

expect(okCalled).to.equal(true);

});

testWithBothStores('closed tx', async () => {

const rep = await replicacheForTesting('reauth', {

mutators: {

mut: async tx => {

wtx = tx;

},

},

});

let rtx: ReadTransaction;

await rep.query(tx => (rtx = tx));

await expectAsyncFuncToThrow(() => rtx.get('x'), TransactionClosedError);

await expectAsyncFuncToThrow(() => rtx.has('y'), TransactionClosedError);

await expectAsyncFuncToThrow(

() => rtx.scan().values().next(),

TransactionClosedError,

);

let wtx: WriteTransaction | undefined;

await rep.mutate.mut();

expect(wtx).to.not.be.undefined;

await expectAsyncFuncToThrow(() => wtx?.put('z', 1), TransactionClosedError);

await expectAsyncFuncToThrow(() => wtx?.del('w'), TransactionClosedError);

});

testWithBothStores('pullInterval in constructor', async () => {

const rep = await replicacheForTesting('pullInterval', {

pullInterval: 12.34,

});

expect(rep.pullInterval).to.equal(12.34);

await rep.close();

});