Dawnline 0.20.0
Build packages / CI (push) Blocked by required conditions
Build packages / Version (push) Waiting to run
CI / Web (format, types, tests, bundles) (push) Blocked by required conditions
CI / ShellCheck (push) Blocked by required conditions
CI / Backend (Go: vet, tests, a real ubusd and uhttpd) (push) Blocked by required conditions
CI / Package files (push) Blocked by required conditions
Build packages / CI (push) Blocked by required conditions
Build packages / Version (push) Waiting to run
CI / Web (format, types, tests, bundles) (push) Blocked by required conditions
CI / ShellCheck (push) Blocked by required conditions
CI / Backend (Go: vet, tests, a real ubusd and uhttpd) (push) Blocked by required conditions
CI / Package files (push) Blocked by required conditions
- **Backend rewritten in Go.** One daemon, `dawnlined`, replaces the whole ucode backend: the rpcd plugin, the agent, the CLI and the updater. The package no longer depends on ucode. - **Per-architecture builds.** The release carries the backend for arm64, ARMv7, mips, mipsle and amd64; the router fetches its own after the package is installed and checks its sha256. Dawnline does not run on other architectures (older ARM, 32-bit x86, RISC-V). - **Faster on the router.** A firewall sync takes 0.06 s instead of 0.9 s; a full apply takes about 300 ms. The portal is served by the daemon itself, without a CGI process per request. - **Live pages.** The admin and the portal follow a live stream from the router instead of re-fetching the whole state every 30 seconds. - **Admin redesigned in the portal's style.** Three sections (Overview · Log · Settings); a server is a page of its own with People, Places and Settings; a device opens as a dialog over its person. - **Changes wait for «Apply».** Every setting, and a person's access, is staged in one dock before it reaches the router. - **Configuration rollout.** After a change that makes devices fetch their configuration again, the admin shows how many have fetched it and who has not. Every setting shows beforehand (⟳N) how many devices it will touch. - **Waiting for a decision.** Overview and People put first the people who need one (access ended, limit reached, a device that does not connect), each with its one action a tap away. - **Bulk actions on people.** «Select» (or a long press on a card) picks several people to extend by a month, pause or resume at once. - **Undo.** An action done from a card or a request is undone from its toast. - **Update dialogs redesigned.** An update is one view from its question to its result; Dawnline's own update runs in it like every other, and the page reloads itself once the new version answers. Other versions are a list, each with its notes and Install on a page of its own. - **Site to site: networks behind a router.** A router connected as a device can have networks behind it (up to eight, /16 to /30): the server routes them and applies the router's access to them. A network that shares addresses with a tunnel, the router's own networks or another site is refused by name. - **Routers from the portal.** People can add a router and name its networks on their own page; the admin accepts or declines with a reason, or lets them through without asking. - **Check access and Health know the networks behind routers.** - **Usage limits reworked.** A monthly limit no longer follows the calendar. A person's month starts with their first traffic and ends a month later; the next one starts only when they connect again, so time away uses up none of it. Before, everyone's limit reset on the 1st. - Extra data lasts until that person's month ends; «Reset usage» starts the month anew. - A limit is for a month or for the whole term; the admin and the portal show when it resets. - Charts that said «this month» show the last 30 days. - After the update nobody loses what was counted: the month that was running becomes the person's first and ends on the 1st. - **Access by time of day removed.** The Hours limit is gone from the admin, the portal and the backend; saved hours are dropped. - **Expiry simplified.** An end date always stops access, with a heads-up three days before; the per-person choice is gone. - **No false disconnects from sleeping phones.** A phone or a tablet stays online through ten minutes of silence. - **Mobile Safari fixes.** Pressing a control no longer sends the page to its top; tab tracks that do not fit scroll; switches animate after a press.
This commit is contained in:
1 parent
f8130e39a8
commit
ac90575b0b
788 files changed
+139244
-41720
No files matched your search
@@ -0,0 +1,485 @@
|
||||
import { describe, expect, it } from 'vitest';
|
||||
import { batch, computed, effect, signal } from '../src/shared/live/signal';
|
||||
import { appended, merge, rows } from '../src/shared/live/patch';
|
||||
import { LiveStore, type LiveEvent } from '../src/shared/live/store';
|
||||
import { Follower, type Answer, type Hello, type StreamMessage, type Transport } from '../src/shared/live/follow';
|
||||
import { share } from '../src/shared/live/share';
|
||||
import { LiveDoc } from '../src/shared/live/doc';
|
||||
|
||||
describe('signals', () => {
|
||||
it('runs an effect again only for what it read', () => {
|
||||
const a = signal(1);
|
||||
const b = signal(10);
|
||||
const seen: number[] = [];
|
||||
const stop = effect(() => void seen.push(a()));
|
||||
b.set(11);
|
||||
a.set(2);
|
||||
a.set(2);
|
||||
stop();
|
||||
a.set(3);
|
||||
expect(seen).toEqual([1, 2]);
|
||||
});
|
||||
|
||||
it('works a computed out again only when read after a change', () => {
|
||||
const a = signal(2);
|
||||
let runs = 0;
|
||||
const double = computed(() => (runs++, a() * 2));
|
||||
expect(runs).toBe(0);
|
||||
expect(double()).toBe(4);
|
||||
expect(double()).toBe(4);
|
||||
a.set(3);
|
||||
expect(runs).toBe(1);
|
||||
expect(double()).toBe(6);
|
||||
expect(runs).toBe(2);
|
||||
});
|
||||
|
||||
it('follows a computed from an effect, and drops what a branch no longer reads', () => {
|
||||
const on = signal(true);
|
||||
const name = signal('Myata');
|
||||
const label = computed(() => (on() ? name() : 'off'));
|
||||
const seen: string[] = [];
|
||||
effect(() => void seen.push(label()));
|
||||
name.set('Guest');
|
||||
on.set(false);
|
||||
name.set('Nobody');
|
||||
expect(seen).toEqual(['Myata', 'Guest', 'off']);
|
||||
});
|
||||
|
||||
it('runs effects once for a batch', () => {
|
||||
const a = signal(1);
|
||||
const b = signal(1);
|
||||
let runs = 0;
|
||||
effect(() => void (a(), b(), runs++));
|
||||
batch(() => {
|
||||
a.set(2);
|
||||
b.set(2);
|
||||
});
|
||||
expect(runs).toBe(2);
|
||||
});
|
||||
|
||||
it('puts an effect off, once, however much changed; a run that did nothing keeps what it read', () => {
|
||||
const a = signal(1);
|
||||
const b = signal(1);
|
||||
const due: (() => void)[] = [];
|
||||
const seen: string[] = [];
|
||||
let skip = false;
|
||||
const stop = effect(
|
||||
() => {
|
||||
if (skip) return false;
|
||||
seen.push(`${a()}/${b()}`);
|
||||
},
|
||||
(run) => void due.push(run),
|
||||
);
|
||||
a.set(2);
|
||||
b.set(2);
|
||||
expect([seen, due.length]).toEqual([['1/1'], 1]);
|
||||
due.splice(0).forEach((run) => run());
|
||||
expect(seen).toEqual(['1/1', '2/2']);
|
||||
// skipped: it read nothing this time, and is still told when `a` changes
|
||||
skip = true;
|
||||
a.set(3);
|
||||
due.splice(0).forEach((run) => run());
|
||||
skip = false;
|
||||
b.set(3);
|
||||
due.splice(0).forEach((run) => run());
|
||||
expect(seen).toEqual(['1/1', '2/2', '3/3']);
|
||||
stop();
|
||||
a.set(4);
|
||||
expect(due.length).toBe(0);
|
||||
});
|
||||
|
||||
it('lets a computed go', () => {
|
||||
const a = signal(1);
|
||||
let runs = 0;
|
||||
const c = computed(() => (runs++, a()));
|
||||
c();
|
||||
c.stop();
|
||||
a.set(2);
|
||||
expect(runs).toBe(1);
|
||||
expect(c()).toBe(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe('an answer laid over the last one', () => {
|
||||
it('keeps every part that did not change the object it was', () => {
|
||||
const old = {
|
||||
people: [
|
||||
{ id: 'a', online: 0, devices: [{ id: 'd1' }] },
|
||||
{ id: 'b', online: 1 },
|
||||
],
|
||||
tz: 'UTC',
|
||||
};
|
||||
const next = {
|
||||
people: [
|
||||
{ id: 'a', online: 1, devices: [{ id: 'd1' }] },
|
||||
{ id: 'b', online: 1 },
|
||||
],
|
||||
tz: 'UTC',
|
||||
};
|
||||
const got = share(old, next);
|
||||
expect(got).toEqual(next);
|
||||
expect(got.people[1]).toBe(old.people[1]);
|
||||
expect(got.people[0]).not.toBe(old.people[0]);
|
||||
expect(got.people[0].devices).toBe(old.people[0].devices);
|
||||
expect(share(old, structuredClone(old))).toBe(old);
|
||||
});
|
||||
|
||||
it('knows a thing by its id wherever it stands, and a list that grew or shrank', () => {
|
||||
const a = { id: 'a', n: 1 };
|
||||
const b = { id: 'b', n: 2 };
|
||||
const got = share(
|
||||
[a, b],
|
||||
[
|
||||
{ id: 'b', n: 2 },
|
||||
{ id: 'c', n: 3 },
|
||||
{ id: 'a', n: 1 },
|
||||
],
|
||||
);
|
||||
expect([got[0], got[2]]).toEqual([b, a]);
|
||||
expect(got[0]).toBe(b);
|
||||
expect(got[2]).toBe(a);
|
||||
expect(share([1, 2], [1, 2, 3])).toEqual([1, 2, 3]);
|
||||
expect(share({ a: 1, b: 2 }, { a: 1 })).toEqual({ a: 1 });
|
||||
expect(share(null, { a: 1 })).toEqual({ a: 1 });
|
||||
expect(share([1], { 0: 1 })).toEqual({ 0: 1 });
|
||||
});
|
||||
|
||||
it("tells a field's readers only when that field changed", () => {
|
||||
const doc = new LiveDoc<{ servers: { id: string; up: boolean }[]; now: number; tz?: string }>();
|
||||
doc.feed({ servers: [{ id: 's1', up: true }], now: 1, tz: 'UTC' });
|
||||
const seen: string[] = [];
|
||||
const stop = effect(() => void seen.push(doc.view.servers.map((s) => `${s.id}:${s.up}`).join()));
|
||||
const first = doc.view.servers[0];
|
||||
doc.feed({ servers: [{ id: 's1', up: true }], now: 2, tz: 'UTC' });
|
||||
expect(seen).toEqual(['s1:true']);
|
||||
expect(doc.view.servers[0]).toBe(first);
|
||||
doc.feed({ servers: [{ id: 's1', up: false }], now: 3 });
|
||||
expect(seen).toEqual(['s1:true', 's1:false']);
|
||||
expect('tz' in doc.view).toBe(false);
|
||||
expect({ ...doc.view }).toEqual({ servers: [{ id: 's1', up: false }], now: 3 });
|
||||
expect(doc.plain()).toEqual({ servers: [{ id: 's1', up: false }], now: 3 });
|
||||
stop();
|
||||
});
|
||||
});
|
||||
|
||||
describe('merge patch', () => {
|
||||
it('applies a patch and shares what it did not touch', () => {
|
||||
const doc = { p1: { name: 'Myata', devices: { d1: { online: false }, d2: { online: true } } }, p2: { name: 'Guest' } };
|
||||
const next = merge(doc, { p1: { devices: { d1: { online: true } } } }) as typeof doc;
|
||||
expect(next.p1.devices.d1.online).toBe(true);
|
||||
expect(doc.p1.devices.d1.online).toBe(false);
|
||||
expect(next.p2).toBe(doc.p2);
|
||||
expect(next.p1.devices.d2).toBe(doc.p1.devices.d2);
|
||||
expect(next.p1).not.toBe(doc.p1);
|
||||
});
|
||||
|
||||
it('removes with null, replaces lists whole, and returns the same object for no change', () => {
|
||||
const doc = { a: 1, l: [1, 2, 3], t: { x: 1 } };
|
||||
expect(merge(doc, { a: null, l: [9] })).toEqual({ l: [9], t: { x: 1 } });
|
||||
expect(merge(doc, { t: { x: 1 }, gone: null })).toBe(doc);
|
||||
expect(merge('text', { a: 1 })).toEqual({ a: 1 });
|
||||
expect(merge(doc, [1])).toEqual([1]);
|
||||
});
|
||||
|
||||
it('keeps the newest entries of a list, and reads a keyed list in order', () => {
|
||||
expect(appended([1, 2], [3, 4], 3)).toEqual([2, 3, 4]);
|
||||
expect(appended(undefined, [1], 0)).toEqual([1]);
|
||||
expect(rows({ order: ['b', 'a', 'gone'], items: { a: 1, b: 2 } })).toEqual([2, 1]);
|
||||
expect(rows(undefined)).toEqual([]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('store', () => {
|
||||
it('tells a place only when that place changed', () => {
|
||||
const store = new LiveStore();
|
||||
const online = store.at<boolean>('people', 'items', 'p1', 'online');
|
||||
const name = store.at<string>('people', 'items', 'p1', 'name');
|
||||
const seen: unknown[] = [];
|
||||
let names = 0;
|
||||
effect(() => void seen.push(online()));
|
||||
effect(() => void (name(), names++));
|
||||
store.apply({ seq: 1, topic: 'people', op: 'put', data: { items: { p1: { name: 'Myata', online: false } } } });
|
||||
store.apply({ seq: 2, topic: 'people', op: 'patch', data: { items: { p1: { online: true } } } });
|
||||
store.apply({ seq: 3, topic: 'people', op: 'patch', data: { items: { p2: { name: 'Guest' } } } });
|
||||
expect(seen).toEqual([undefined, false, true]);
|
||||
expect(names).toBe(2);
|
||||
});
|
||||
|
||||
it('knows pending from ready from stale', () => {
|
||||
const store = new LiveStore();
|
||||
const st = store.state('people');
|
||||
expect(st()).toBe('pending');
|
||||
store.reset({ people: { items: {} } });
|
||||
expect(st()).toBe('ready');
|
||||
store.offline(true);
|
||||
expect(st()).toBe('stale');
|
||||
expect(store.state('meter')()).toBe('pending');
|
||||
store.offline(false);
|
||||
store.reset({});
|
||||
expect(st()).toBe('pending');
|
||||
expect(store.peek('people')).toBeUndefined();
|
||||
});
|
||||
|
||||
it('appends to a list and drops a topic', () => {
|
||||
const store = new LiveStore();
|
||||
store.apply({ seq: 1, topic: 'meter', op: 'append', data: { items: [1, 2], keep: 3 } });
|
||||
store.apply({ seq: 2, topic: 'meter', op: 'append', data: { items: [3, 4], keep: 3 } });
|
||||
expect(store.peek('meter')).toEqual([2, 3, 4]);
|
||||
store.apply({ seq: 3, topic: 'meter', op: 'drop' });
|
||||
expect(store.state('meter')()).toBe('pending');
|
||||
});
|
||||
});
|
||||
|
||||
/** A backend to follow: a hub in a few lines, and a clock the test moves. */
|
||||
function stand(mode: 'sse' | 'poll') {
|
||||
let seq = 0;
|
||||
let epoch = 'run1';
|
||||
let docs: Record<string, unknown> = {};
|
||||
const journal: LiveEvent[] = [];
|
||||
const waiters: (() => void)[] = [];
|
||||
const streams = new Set<(m: StreamMessage) => void>();
|
||||
const calls = { hello: 0, sync: 0, wait: 0, watch: [] as string[][], streams: 0, refresh: 0 };
|
||||
let onRefresh: (() => void) | null = null;
|
||||
const timers: { at: number; f: () => void; id: number }[] = [];
|
||||
let now = 0;
|
||||
let ids = 0;
|
||||
let failing = false;
|
||||
let dropNext = false;
|
||||
|
||||
const answer = (at: { epoch?: string; seq?: number }): Answer => {
|
||||
if (at.epoch === epoch && at.seq != null && at.seq <= seq) return { epoch, seq, events: journal.filter((e) => e.seq > at.seq!) };
|
||||
return { epoch, seq, docs: structuredClone(docs) };
|
||||
};
|
||||
const transport: Transport = {
|
||||
async hello(): Promise<Hello> {
|
||||
calls.hello++;
|
||||
if (failing) throw new Error('down');
|
||||
return { version: '1', stream: mode, epoch, seq, lease: 30 };
|
||||
},
|
||||
async sync(at) {
|
||||
calls.sync++;
|
||||
if (failing) throw new Error('down');
|
||||
return answer(at);
|
||||
},
|
||||
wait(at, stop) {
|
||||
calls.wait++;
|
||||
return new Promise<Answer>((done, fail) => {
|
||||
const settle = (): void => (failing ? fail(new Error('down')) : done(answer(at)));
|
||||
if (answer(at).docs || answer(at).events!.length) return settle();
|
||||
waiters.push(settle);
|
||||
stop.addEventListener('abort', () => fail(new Error('aborted')));
|
||||
});
|
||||
},
|
||||
async watch(topics) {
|
||||
calls.watch.push(topics);
|
||||
},
|
||||
async refresh() {
|
||||
calls.refresh++;
|
||||
onRefresh?.();
|
||||
},
|
||||
stream(on, stop) {
|
||||
calls.streams++;
|
||||
return new Promise<void>((_done, fail) => {
|
||||
if (failing) return fail(new Error('down'));
|
||||
streams.add(on);
|
||||
stop.addEventListener('abort', () => {
|
||||
streams.delete(on);
|
||||
fail(new Error('aborted'));
|
||||
});
|
||||
});
|
||||
},
|
||||
};
|
||||
return {
|
||||
transport,
|
||||
calls,
|
||||
put(topic: string, doc: unknown): void {
|
||||
docs[topic] = doc;
|
||||
const e: LiveEvent = { seq: ++seq, topic, op: 'put', data: structuredClone(doc) };
|
||||
journal.push(e);
|
||||
waiters.splice(0).forEach((w) => w());
|
||||
if (dropNext) dropNext = false;
|
||||
else streams.forEach((s) => s({ kind: 'event', epoch, event: e }));
|
||||
},
|
||||
ping: (): void => streams.forEach((s) => s({ kind: 'ping', epoch, seq })),
|
||||
/** What the backend finds on the router when it is asked to look now. */
|
||||
whenRefreshed: (f: () => void): void => void (onRefresh = f),
|
||||
/** The next event is not sent down the stream. */
|
||||
loseNext: (): void => void (dropNext = true),
|
||||
restart(): void {
|
||||
epoch = 'run2';
|
||||
seq = 0;
|
||||
docs = {};
|
||||
journal.length = 0;
|
||||
},
|
||||
fail(on: boolean): void {
|
||||
failing = on;
|
||||
if (on) waiters.splice(0).forEach((w) => w());
|
||||
},
|
||||
options: {
|
||||
setTimeout: (f: () => void, ms: number): unknown => (timers.push({ at: now + ms, f, id: ++ids }), ids),
|
||||
clearTimeout: (id: unknown): void => {
|
||||
const i = timers.findIndex((t) => t.id === id);
|
||||
if (i >= 0) timers.splice(i, 1);
|
||||
},
|
||||
},
|
||||
/** Let the promises settle, then move the clock and run what is due. */
|
||||
async pass(ms = 0): Promise<void> {
|
||||
for (let i = 0; i < 20; i++) await Promise.resolve();
|
||||
now += ms;
|
||||
for (const t of timers.filter((x) => x.at <= now)) {
|
||||
timers.splice(timers.indexOf(t), 1);
|
||||
t.f();
|
||||
}
|
||||
for (let i = 0; i < 20; i++) await Promise.resolve();
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
describe.each(['poll', 'sse'] as const)('following by %s', (mode) => {
|
||||
it('takes a snapshot, then every change', async () => {
|
||||
const s = stand(mode);
|
||||
s.put('people', { n: 1 });
|
||||
const store = new LiveStore();
|
||||
const f = new Follower(store, s.transport, s.options);
|
||||
f.start();
|
||||
await s.pass();
|
||||
expect(f.link()).toBe('live');
|
||||
expect(store.peek('people')).toEqual({ n: 1 });
|
||||
s.put('people', { n: 2 });
|
||||
s.put('servers', { up: true });
|
||||
await s.pass();
|
||||
expect(store.peek('people')).toEqual({ n: 2 });
|
||||
expect(store.state('servers')()).toBe('ready');
|
||||
f.pause();
|
||||
});
|
||||
|
||||
it('keeps what it shows when the backend goes away, and catches up when it is back', async () => {
|
||||
const s = stand(mode);
|
||||
s.put('people', { n: 1 });
|
||||
const store = new LiveStore();
|
||||
const f = new Follower(store, s.transport, s.options);
|
||||
f.start();
|
||||
await s.pass();
|
||||
s.fail(true);
|
||||
if (mode === 'sse') {
|
||||
f.pause();
|
||||
f.start();
|
||||
}
|
||||
await s.pass();
|
||||
expect(f.link()).toBe('offline');
|
||||
expect(store.state('people')()).toBe('stale');
|
||||
expect(store.peek('people')).toEqual({ n: 1 });
|
||||
s.fail(false);
|
||||
s.put('people', { n: 2 });
|
||||
await s.pass(1000);
|
||||
await s.pass(2000);
|
||||
expect(f.link()).toBe('live');
|
||||
expect(store.peek('people')).toEqual({ n: 2 });
|
||||
expect(store.state('people')()).toBe('ready');
|
||||
f.pause();
|
||||
});
|
||||
|
||||
it('starts over after the backend restarted', async () => {
|
||||
const s = stand(mode);
|
||||
s.put('people', { n: 1 });
|
||||
s.put('old', { x: 1 });
|
||||
const store = new LiveStore();
|
||||
const f = new Follower(store, s.transport, s.options);
|
||||
f.start();
|
||||
await s.pass();
|
||||
f.pause();
|
||||
s.restart();
|
||||
s.put('people', { n: 5 });
|
||||
f.start();
|
||||
await s.pass();
|
||||
expect(store.peek('people')).toEqual({ n: 5 });
|
||||
expect(store.state('old')()).toBe('pending');
|
||||
f.pause();
|
||||
});
|
||||
|
||||
it('follows nothing while paused, and renews what is watched while it runs', async () => {
|
||||
const s = stand(mode);
|
||||
const store = new LiveStore();
|
||||
const f = new Follower(store, s.transport, s.options);
|
||||
const release = f.watch('meter');
|
||||
f.start();
|
||||
await s.pass();
|
||||
expect(s.calls.watch).toEqual([['meter']]);
|
||||
await s.pass(10_000);
|
||||
expect(s.calls.watch.length).toBe(2);
|
||||
release();
|
||||
await s.pass(10_000);
|
||||
expect(s.calls.watch.length).toBe(2);
|
||||
f.pause();
|
||||
s.put('people', { n: 1 });
|
||||
await s.pass();
|
||||
expect(store.peek('people')).toBeUndefined();
|
||||
f.start();
|
||||
await s.pass();
|
||||
expect(store.peek('people')).toEqual({ n: 1 });
|
||||
f.pause();
|
||||
});
|
||||
|
||||
it('reads what was just written: the store holds it when the question returns', async () => {
|
||||
const b = stand(mode);
|
||||
const store = new LiveStore();
|
||||
const f = new Follower(store, b.transport, b.options);
|
||||
b.put('people', { n: 1 });
|
||||
f.start();
|
||||
await b.pass();
|
||||
// the page wrote; the backend sees it on disk only when it looks
|
||||
b.loseNext();
|
||||
b.whenRefreshed(() => b.put('people', { n: 2 }));
|
||||
await f.fresh();
|
||||
expect([b.calls.refresh, store.peek('people')]).toEqual([1, { n: 2 }]);
|
||||
// the answers that crossed it add nothing twice, and the next change is followed as before
|
||||
await b.pass();
|
||||
b.put('people', { n: 3 });
|
||||
await b.pass();
|
||||
expect(store.peek('people')).toEqual({ n: 3 });
|
||||
f.pause();
|
||||
});
|
||||
});
|
||||
|
||||
describe('the event stream', () => {
|
||||
it('asks for what it missed when a number is skipped, or a ping is ahead', async () => {
|
||||
const s = stand('sse');
|
||||
const store = new LiveStore();
|
||||
const f = new Follower(store, s.transport, s.options);
|
||||
f.start();
|
||||
await s.pass();
|
||||
s.loseNext();
|
||||
s.put('a', { n: 1 });
|
||||
s.put('b', { n: 1 });
|
||||
await s.pass();
|
||||
expect(store.peek('a')).toEqual({ n: 1 });
|
||||
expect(store.peek('b')).toEqual({ n: 1 });
|
||||
s.loseNext();
|
||||
s.put('a', { n: 2 });
|
||||
await s.pass();
|
||||
expect(store.peek('a')).toEqual({ n: 1 });
|
||||
s.ping();
|
||||
await s.pass();
|
||||
expect(store.peek('a')).toEqual({ n: 2 });
|
||||
f.pause();
|
||||
});
|
||||
|
||||
it('gives a silent stream up, and the stream itself after two failures', async () => {
|
||||
const s = stand('sse');
|
||||
const store = new LiveStore();
|
||||
const f = new Follower(store, s.transport, s.options);
|
||||
f.start();
|
||||
await s.pass();
|
||||
expect(s.calls.streams).toBe(1);
|
||||
await s.pass(40_000);
|
||||
expect(f.link()).toBe('offline');
|
||||
await s.pass(1000);
|
||||
expect(s.calls.streams).toBe(2);
|
||||
await s.pass(40_000);
|
||||
await s.pass(2000);
|
||||
expect(s.calls.streams).toBe(2);
|
||||
expect(s.calls.wait).toBeGreaterThan(0);
|
||||
expect(f.link()).toBe('live');
|
||||
f.pause();
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user