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.
360 lines
12 KiB
TypeScript
360 lines
12 KiB
TypeScript
import { describe, expect, it } from 'vitest';
|
||
import { byAttention, cardParts, groupOf, ofLimit, type CardFacts, type CardParts, type Ranked } from '../src/admin/people/card';
|
||
import { byPerson, midnight, presence, timeIn } from '../src/admin/people/presence';
|
||
import type { Device, LogEvent, Person, Server } from '../src/shared/types';
|
||
|
||
// The matrix of a person's card (the concept's docs/ia2/10-people-cards.md with its amendments), a row a state:
|
||
// what the card must have. The router at 2026-11-07 14:00 UTC+3.
|
||
const NOW = Date.UTC(2026, 10, 7, 11, 0) / 1000;
|
||
const T = { today: '2026-11-07', now: NOW };
|
||
const H = 3600;
|
||
const DAY = 86400;
|
||
const GB = 2 ** 30;
|
||
|
||
const dev = (o: Partial<Device> = {}): Device =>
|
||
({
|
||
id: 'd1',
|
||
name: 'iPhone',
|
||
kind: 'phone',
|
||
address: '10.8.0.2',
|
||
disabled: false,
|
||
online: false,
|
||
handshake: NOW - 3 * H,
|
||
endpoint: '91.1.2.3:51820',
|
||
config_stale: false,
|
||
lan_bypass: false,
|
||
link: null,
|
||
spark: [],
|
||
month: [0, 0],
|
||
total: [0, 0],
|
||
...o,
|
||
}) as Device;
|
||
const person = (o: Partial<Person> = {}): Person =>
|
||
({
|
||
id: 'p',
|
||
name: 'Test',
|
||
server: 's',
|
||
access: 'internet',
|
||
device_limit: 3,
|
||
expires: '',
|
||
quota_gb: 0,
|
||
quota_period: 'month',
|
||
quota_used: 0,
|
||
quota_limit: 0,
|
||
// their limit month began on 19 Oct with their first traffic: it ends on 19 Nov, not on the 1st
|
||
quota_month: [0, 0],
|
||
quota_resets: NOW + 12 * DAY,
|
||
quota_reset_day: '2026-11-19',
|
||
bonus_gb: 0,
|
||
dns_mode: 'device',
|
||
paused: false,
|
||
state: 'active',
|
||
month: [1 * GB, 9 * GB],
|
||
total: [0, 0],
|
||
online: 0,
|
||
last_seen: NOW - 3 * H,
|
||
devices: [dev()],
|
||
has_link: true,
|
||
...o,
|
||
}) as Person;
|
||
const on = { id: 's', name: 'Home', enabled: true } as Server;
|
||
const off = { id: 's', name: 'Dacha', enabled: false } as Server;
|
||
|
||
interface Row {
|
||
name: string;
|
||
p: Person;
|
||
srv?: Server;
|
||
facts?: CardFacts;
|
||
want: Partial<Pick<CardParts, 'state' | 'group' | 'presence' | 'traffic' | 'meter' | 'tiles' | 'quiet'>> & {
|
||
line: RegExp | null;
|
||
action: RegExp | null;
|
||
};
|
||
}
|
||
|
||
const rows: Row[] = [
|
||
{
|
||
name: 'no server',
|
||
p: person({ state: 'no_server', server: '' }),
|
||
want: {
|
||
state: 'no_server',
|
||
group: 'need',
|
||
line: /^No server$/,
|
||
presence: null,
|
||
traffic: false,
|
||
tiles: false,
|
||
action: /^Choose a server$/,
|
||
quiet: false,
|
||
},
|
||
},
|
||
{
|
||
name: 'server turned off',
|
||
p: person({ state: 'server_off' }),
|
||
srv: off,
|
||
want: {
|
||
state: 'server_off',
|
||
group: 'rest',
|
||
line: /^Server Dacha is turned off$/,
|
||
presence: null,
|
||
traffic: false,
|
||
tiles: true,
|
||
action: null,
|
||
},
|
||
},
|
||
{
|
||
name: 'paused',
|
||
p: person({ state: 'paused', paused: true }),
|
||
srv: on,
|
||
facts: { pausedAt: '2026-11-03' },
|
||
want: {
|
||
state: 'paused',
|
||
group: 'paused',
|
||
line: /^Paused since 3 Nov$/,
|
||
presence: null,
|
||
traffic: false,
|
||
tiles: true,
|
||
action: /^Resume$/,
|
||
quiet: true,
|
||
},
|
||
},
|
||
{
|
||
name: 'access ended',
|
||
p: person({ state: 'expired', expires: '2026-11-03' }),
|
||
srv: on,
|
||
want: { state: 'expired', group: 'need', line: /^Access ended 3 Nov$/, presence: null, traffic: false, action: /^Extend to 7 Dec$/ },
|
||
},
|
||
{
|
||
name: 'limit reached',
|
||
p: person({ state: 'quota', quota_gb: 50, quota_limit: 50 * GB, quota_used: 50.3 * GB }),
|
||
srv: on,
|
||
want: {
|
||
state: 'quota',
|
||
group: 'need',
|
||
line: /^Limit reached · 50\.3 of 50 GB$/,
|
||
presence: null,
|
||
traffic: false,
|
||
action: /^\+20 GB until 19 Nov$/,
|
||
},
|
||
},
|
||
{
|
||
name: 'a term limit reached',
|
||
p: person({ state: 'quota', quota_period: 'total', quota_gb: 5, quota_limit: 5 * GB, quota_used: 9 * GB }),
|
||
srv: on,
|
||
want: { state: 'quota', group: 'need', line: /^Term limit reached · 9 of 5 GB$/, action: /^Change the limit$/ },
|
||
},
|
||
{
|
||
name: 'a device fails',
|
||
p: person({ devices: [dev({ name: 'ThinkPad', link: { state: 'trying', since: NOW - H } as Device['link'] })] }),
|
||
srv: on,
|
||
want: {
|
||
state: 'device',
|
||
group: 'need',
|
||
line: /^ThinkPad does not connect$/,
|
||
presence: null,
|
||
traffic: false,
|
||
tiles: true,
|
||
action: /^Advice · ThinkPad$/,
|
||
},
|
||
},
|
||
{
|
||
name: 'a new configuration (a rollout, not a decision)',
|
||
p: person({ devices: [dev({ name: 'Laptop', config_stale: true })] }),
|
||
srv: on,
|
||
want: { state: 'offline', group: 'rest', line: null, presence: 'offline', traffic: true, tiles: true, action: null },
|
||
},
|
||
{
|
||
name: 'a new configuration and the end near',
|
||
p: person({ expires: '2026-11-09', devices: [dev({ name: 'Laptop', config_stale: true })] }),
|
||
srv: on,
|
||
want: { state: 'soon', group: 'need', line: /^Access until 9 Nov · 3 days$/, action: /^Extend to 9 Dec$/ },
|
||
},
|
||
{
|
||
name: 'the end near',
|
||
p: person({ expires: '2026-11-09' }),
|
||
srv: on,
|
||
want: {
|
||
state: 'soon',
|
||
group: 'need',
|
||
line: /^Access until 9 Nov · 3 days$/,
|
||
presence: null,
|
||
traffic: false,
|
||
action: /^Extend to 9 Dec$/,
|
||
},
|
||
},
|
||
{
|
||
name: 'the last day',
|
||
p: person({ expires: '2026-11-07' }),
|
||
srv: on,
|
||
want: { state: 'soon', group: 'need', line: /^Access until 7 Nov · last day$/, action: /^Extend to 7 Dec$/ },
|
||
},
|
||
{
|
||
name: 'the limit nearly reached',
|
||
p: person({ quota_gb: 50, quota_limit: 50 * GB, quota_used: 46 * GB }),
|
||
srv: on,
|
||
want: {
|
||
state: 'almost',
|
||
group: 'need',
|
||
line: /^Limit nearly reached · 46 of 50 GB$/,
|
||
presence: null,
|
||
traffic: false,
|
||
action: /^\+10 GB until 19 Nov$/,
|
||
},
|
||
},
|
||
{
|
||
name: 'no devices',
|
||
p: person({ devices: [], last_seen: 0, month: [0, 0] }),
|
||
srv: on,
|
||
want: {
|
||
state: 'no_devices',
|
||
group: 'rest',
|
||
line: /^No devices yet$/,
|
||
presence: null,
|
||
traffic: false,
|
||
tiles: false,
|
||
action: /^Invite$/,
|
||
},
|
||
},
|
||
{
|
||
name: 'online',
|
||
p: person({ online: 1, last_seen: NOW - 20, devices: [dev({ online: true })] }),
|
||
srv: on,
|
||
want: { state: 'online', group: 'online', line: null, presence: 'online', traffic: true, meter: null, tiles: true, action: null },
|
||
},
|
||
{
|
||
name: 'online, a limit used 9 %',
|
||
p: person({ online: 1, devices: [dev({ online: true })], quota_gb: 100, quota_limit: 100 * GB, quota_used: 9 * GB }),
|
||
srv: on,
|
||
want: { state: 'online', group: 'online', line: null, presence: 'online', traffic: true, meter: 'of', action: null },
|
||
},
|
||
{
|
||
name: 'offline, a limit used 60 %',
|
||
p: person({ quota_gb: 100, quota_limit: 100 * GB, quota_used: 60 * GB }),
|
||
srv: on,
|
||
want: { state: 'offline', group: 'rest', line: null, presence: 'offline', traffic: true, meter: 'bar', action: null },
|
||
},
|
||
{
|
||
name: 'offline for up to 7 days',
|
||
p: person(),
|
||
srv: on,
|
||
want: { state: 'offline', group: 'rest', line: null, presence: 'offline', traffic: true, meter: null, action: null },
|
||
},
|
||
{
|
||
name: 'long away, traffic in the last 30 days',
|
||
p: person({ last_seen: NOW - 12 * DAY }),
|
||
srv: on,
|
||
facts: { city: 'Moscow' },
|
||
want: {
|
||
state: 'away',
|
||
group: 'rest',
|
||
line: /^Not connected for 12 days · Moscow$/,
|
||
presence: null,
|
||
traffic: true,
|
||
action: null,
|
||
},
|
||
},
|
||
{
|
||
name: 'long away, nothing this month',
|
||
p: person({ last_seen: NOW - 21 * DAY, month: [0, 0] }),
|
||
srv: on,
|
||
facts: { city: 'Moscow' },
|
||
want: { state: 'away', group: 'rest', line: /^Not connected for 21 days · Moscow$/, presence: null, traffic: true, action: null },
|
||
},
|
||
{
|
||
name: 'never connected, a link',
|
||
p: person({ last_seen: 0, month: [0, 0], devices: [dev({ handshake: 0 })] }),
|
||
srv: on,
|
||
want: { state: 'never', group: 'rest', line: /^Not connected yet$/, presence: null, traffic: false, action: /^Link$/, quiet: true },
|
||
},
|
||
{
|
||
name: 'never connected, no link',
|
||
p: person({ last_seen: 0, has_link: false, month: [0, 0], devices: [dev({ handshake: 0 })] }),
|
||
srv: on,
|
||
want: { state: 'never', group: 'rest', line: /^Not connected yet$/, action: /^Invite$/, quiet: false },
|
||
},
|
||
];
|
||
|
||
describe('the card matrix', () => {
|
||
it.each(rows.map((r) => [r.name, r] as const))('%s', (_n, r) => {
|
||
const c = cardParts(r.p, r.srv, T, r.facts);
|
||
// the line keeps its «·» with the word before it (a no-break space): read with plain spaces
|
||
const line = c.line?.replace(/ /g, ' ') ?? null;
|
||
const { line: wantLine, action, ...rest } = r.want;
|
||
expect(c).toMatchObject(rest);
|
||
if (wantLine) expect(line).toMatch(wantLine);
|
||
else expect(line).toBeNull();
|
||
if (action) expect(c.action?.label ?? '').toMatch(action);
|
||
else expect(c.action).toBeNull();
|
||
});
|
||
|
||
it('says the first problem, counts the others, and keeps a rollout out of it', () => {
|
||
const p = person({
|
||
expires: '2026-11-09',
|
||
devices: [
|
||
dev({ name: 'ThinkPad', link: { state: 'trying', since: NOW - H } as Device['link'] }),
|
||
dev({ id: 'd2', config_stale: true }),
|
||
],
|
||
});
|
||
const c = cardParts(p, on, T);
|
||
expect(c.state).toBe('device');
|
||
expect(c.more).toEqual(['Access until 9 Nov · 3 days']);
|
||
expect(c.title).toContain('ThinkPad does not connect');
|
||
expect(c.stale).toEqual(['d2']);
|
||
});
|
||
|
||
it('keeps a dot with the word before it', () => {
|
||
expect(cardParts(person({ expires: '2026-11-09' }), on, T).line).toBe('Access until 9 Nov · 3 days');
|
||
});
|
||
|
||
it('says a limit with its unit once', () => {
|
||
expect(ofLimit(50.3 * GB, 50 * GB)).toBe('50.3 of 50 GB');
|
||
expect(ofLimit(512 * 2 ** 20, 50 * GB)).toBe('512 MB of 50 GB');
|
||
});
|
||
|
||
it('groups by the matrix: the chip, the heads and Overview count one way', () => {
|
||
expect(groupOf(person({ devices: [dev({ config_stale: true })] }), T)).toBe('rest');
|
||
expect(groupOf(person({ state: 'server_off' }), T)).toBe('rest');
|
||
expect(groupOf(person({ state: 'paused', paused: true }), T)).toBe('paused');
|
||
expect(groupOf(person({ expires: '2026-11-09' }), T)).toBe('need');
|
||
});
|
||
});
|
||
|
||
describe('the order of attention', () => {
|
||
const ranked = (p: Person, o: Partial<Ranked> = {}): Ranked => ({ p, parts: cardParts(p, on, T), speed: 0, week: 0, pausedAt: '', ...o });
|
||
it('puts the groups in order, and each in its own', () => {
|
||
const list = [
|
||
ranked(person({ id: 'away', last_seen: NOW - 20 * DAY })),
|
||
ranked(person({ id: 'slow', online: 1, devices: [dev({ online: true })] }), { speed: 10 }),
|
||
ranked(person({ id: 'soon', expires: '2026-11-09' })),
|
||
ranked(person({ id: 'off', last_seen: NOW - 2 * H })),
|
||
ranked(person({ id: 'p2', state: 'paused', paused: true }), { pausedAt: '2026-11-05' }),
|
||
ranked(person({ id: 'p1', state: 'paused', paused: true }), { pausedAt: '2026-11-01' }),
|
||
ranked(person({ id: 'fast', online: 1, devices: [dev({ online: true })] }), { speed: 99 }),
|
||
ranked(person({ id: 'ended', state: 'expired', expires: '2026-11-01' })),
|
||
ranked(person({ id: 'never', last_seen: 0, devices: [dev({ handshake: 0 })] })),
|
||
];
|
||
expect(byAttention(list, T.today).map((x) => x.p.id)).toEqual(['ended', 'soon', 'fast', 'slow', 'off', 'away', 'never', 'p1', 'p2']);
|
||
});
|
||
});
|
||
|
||
describe('presence from the log', () => {
|
||
const ev = (ts: number, type: string, device = 'd1'): LogEvent => ({ ts, type, person: 'p', device, where: 'Krasnodar · MTS' });
|
||
it('says since when they are online and their hours this week', () => {
|
||
const p = person({ online: 1, devices: [dev({ online: true, handshake: NOW - 10 })] });
|
||
const log = [ev(NOW - 2 * DAY, 'connect'), ev(NOW - 2 * DAY + 5 * H, 'disconnect'), ev(NOW - 3 * H, 'connect')];
|
||
const pr = presence(p, on, log, NOW, 180);
|
||
expect(pr.since).toBe(NOW - 3 * H);
|
||
expect(Math.round(pr.week / H)).toBe(8);
|
||
expect(pr.devices.map((x) => x.d.id)).toEqual(['d1']);
|
||
});
|
||
it('is offline without an open stretch', () => {
|
||
const pr = presence(person(), on, [ev(NOW - 5 * H, 'connect'), ev(NOW - 3 * H, 'disconnect')], NOW, 180);
|
||
expect(pr.since).toBe(0);
|
||
expect(Math.round(pr.week / H)).toBe(2);
|
||
});
|
||
it('sorts the log by person and counts time in a window', () => {
|
||
const m = byPerson([ev(1, 'connect'), { ts: 2, type: 'x' }, { ...ev(3, 'connect'), person: 'q' }]);
|
||
expect([...m.keys()]).toEqual(['p', 'q']);
|
||
expect(timeIn([{ a: 0, b: 10 }], 5, 20)).toBe(5);
|
||
expect(midnight(Date.UTC(2026, 10, 7, 23, 0) / 1000, 180)).toBe(Date.UTC(2026, 10, 7, 21, 0) / 1000);
|
||
});
|
||
});
|