julian.kiedaischandClaude Opus 5.5
eff9433673
Measured first: SheetRun now types into FILIUS' router and home router
panels, records five forwarding tables (holeTabelle) and steps in the
panel's table. Java turns a card address that passes the pattern but not
IP.ipCheck (".0.0.1") into null and the router panel throws; an empty
gateway is marked red yet taken; a refused table cell is stored as null;
a home router's DHCP client leaves its DHCP server running. None of the
nulls is adopted. The core's routeTableRows matches all five tables.
- doc: card addresses (the first card mirrored in the device's settings),
router gateway, RIP, manual routes (a new row once all four cells pass,
a cell, removal); the sheet reads cards with what their cable joins and
the whole table
- editor: Java's tabs (general, each card titled by its address, the
forwarding table greyed out under RIP; general, LAN, WAN on a home
router); the open card's cable drawn active in Java's green
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
709 lines
34 KiB
TypeScript
709 lines
34 KiB
TypeScript
// The device sheet: what a field takes, measured against FILIUS' own settings
|
||
// panels (tools/java-oracle's SheetRun typed the texts of sheet.cases.txt
|
||
// into them, sheet.java.json), and what its changes do to the document — the
|
||
// wireless connections moved as Java moves them, each change one step of
|
||
// the person's undo, and everything kept through a saved file.
|
||
|
||
import { readFileSync } from 'node:fs';
|
||
import { dirname, join } from 'node:path';
|
||
import { fileURLToPath } from 'node:url';
|
||
import { describe, expect, it } from 'vitest';
|
||
import * as Y from 'yjs';
|
||
import { openProjectArchive, saveProjectArchive } from '@mdg-filius/fls';
|
||
import {
|
||
addDevice,
|
||
checkField,
|
||
connect,
|
||
createUndoManager,
|
||
deviceSheet,
|
||
readProject,
|
||
renameDevice,
|
||
ROOTS,
|
||
setDhcpClient,
|
||
setHostAddress,
|
||
setHostLabels,
|
||
setHostWireless,
|
||
setIpForwarding,
|
||
setModemPort,
|
||
setSwitchCloud,
|
||
setSwitchRetention,
|
||
setSwitchSsid,
|
||
addRoute,
|
||
removeRoute,
|
||
setInterfaceAddress,
|
||
setRip,
|
||
setRouteCell,
|
||
setRouterGateway,
|
||
topologyView,
|
||
type FieldRule,
|
||
type HomeRouterSheet,
|
||
type HostSheet,
|
||
type NewDevice,
|
||
type RouterSheet,
|
||
} from '../src/index.js';
|
||
|
||
interface JavaCase {
|
||
readonly device: 'host' | 'switch' | 'modem' | 'router' | 'homeRouter';
|
||
readonly field: string;
|
||
readonly input: string;
|
||
readonly start: string;
|
||
readonly marked: boolean;
|
||
/** null: Java's card lost its address. */
|
||
readonly stored: string | null;
|
||
readonly shown: string;
|
||
/** What Java's panel threw, if it did. */
|
||
readonly error?: string;
|
||
}
|
||
|
||
interface JavaRow {
|
||
readonly cells: readonly (string | null)[];
|
||
readonly manual: boolean;
|
||
}
|
||
|
||
const java = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), 'sheet.java.json'), 'utf8')) as {
|
||
readonly cases: readonly JavaCase[];
|
||
readonly flows: {
|
||
readonly useMacAsNameThenOff: string;
|
||
readonly useIpAsNameThenOff: string;
|
||
readonly dhcpClientStopsServer: boolean;
|
||
readonly dhcpClient: boolean;
|
||
readonly homeRouterDhcpClientStopsServer: boolean;
|
||
readonly homeRouterDhcpClient: boolean;
|
||
};
|
||
readonly tables: Readonly<Record<string, readonly JavaRow[]>>;
|
||
readonly edits: Readonly<Record<string, { readonly manual: readonly (readonly (string | null)[])[]; readonly rowsShown?: number }>>;
|
||
};
|
||
|
||
const RULES: Readonly<Record<string, FieldRule>> = {
|
||
'host name': 'name',
|
||
'host ip': 'ipAddress',
|
||
'host mask': 'subnetMask',
|
||
'host gateway': 'ipAddressOrEmpty',
|
||
'host dns': 'ipAddressOrEmpty',
|
||
'switch name': 'name',
|
||
'switch ssid': 'ssid',
|
||
'switch retention': 'seconds',
|
||
'modem name': 'name',
|
||
'modem port': 'port',
|
||
'router name': 'name',
|
||
'router ip': 'ipAddress',
|
||
'router mask': 'subnetMask',
|
||
'router gateway': 'ipAddressOrEmpty',
|
||
'homeRouter name': 'name',
|
||
'homeRouter gateway': 'ipAddressOrEmpty',
|
||
'homeRouter wanIp': 'ipAddress',
|
||
'homeRouter wanMask': 'subnetMask',
|
||
'homeRouter lanIp': 'ipAddress',
|
||
'homeRouter lanMask': 'subnetMask',
|
||
};
|
||
|
||
/** Fields whose text is judged without the spaces around it. */
|
||
const TRIMMED = new Set(
|
||
Object.entries(RULES)
|
||
.filter(([key, rule]) => rule !== 'name' && rule !== 'ssid')
|
||
.map(([key]) => key),
|
||
);
|
||
|
||
/** Whether Java's device took the text: its value changed (to an address: null is a card that lost its own), or was the text already. */
|
||
const tookIt = (each: JavaCase) => each.stored !== null && (each.stored !== each.start || each.input === each.start);
|
||
|
||
/** What Java's model holds in the units of the sheet's value: seconds for the retention time. */
|
||
const javaValue = (each: JavaCase) => (each.field === 'retention' ? String(Number(each.stored) / 1000) : each.stored);
|
||
|
||
/** The case Java judged for a text: the trimmed text's own case where spaces are left out. */
|
||
function judged(each: JavaCase): JavaCase {
|
||
const key = `${each.device} ${each.field}`;
|
||
if (!TRIMMED.has(key) || each.input.trim() === each.input) return each;
|
||
const twin = java.cases.find((other) => other.device === each.device && other.field === each.field && other.input === each.input.trim());
|
||
if (twin === undefined) throw new Error(`no case for ${JSON.stringify(each.input.trim())} (${key})`);
|
||
return twin;
|
||
}
|
||
|
||
describe("a field's rule, against FILIUS' settings panels", () => {
|
||
it('has a case for every field the sheet checks', () => {
|
||
expect(new Set(java.cases.map((each) => `${each.device} ${each.field}`))).toEqual(new Set(Object.keys(RULES)));
|
||
expect(java.cases.length).toBeGreaterThan(70);
|
||
});
|
||
|
||
it('takes a text exactly when Java neither marks nor refuses it, as the value Java keeps', () => {
|
||
for (const each of java.cases) {
|
||
const key = `${each.device} ${each.field}`;
|
||
const verdict = judged(each);
|
||
// Taken: the value changed, or the text was the value already.
|
||
const took = tookIt(verdict);
|
||
// An empty gateway Java's setter takes as "none", though a router's panel marks it (its key listener checks musterIpAdresse).
|
||
const emptyTaken = RULES[key] === 'ipAddressOrEmpty' && verdict.input.trim() === '' && took;
|
||
// A name is taken as typed. A modem's port Java never marks: it takes any int; here Java's own rule for ports.
|
||
const expected =
|
||
RULES[key] === 'name' ? true : key === 'modem port' ? took && /^([1-9][0-9]{0,4})$/.test(verdict.input) && Number(verdict.input) <= 65_535 : emptyTaken || (!verdict.marked && took);
|
||
const checked = checkField(RULES[key]!, each.input);
|
||
expect('value' in checked, `${key} ${JSON.stringify(each.input)}`).toBe(expected);
|
||
if ('value' in checked) expect(checked.value, `${key} ${JSON.stringify(each.input)}`).toBe(RULES[key] === 'name' ? each.input : javaValue(verdict));
|
||
}
|
||
});
|
||
|
||
it("names where Java's two judgements disagree, which here are one", () => {
|
||
const disagreeing = java.cases.filter((each) => RULES[`${each.device} ${each.field}`] !== 'name' && each.field !== 'port' && each.marked === tookIt(each));
|
||
// Marked red, yet taken; or black, yet refused (the gateway's spaces Java trims to empty) — or lost: a card without its address.
|
||
const verdictOf = (each: JavaCase) => (each.marked ? 'marked, taken' : each.stored === null ? `lost${each.error === undefined ? '' : `, ${each.error}`}` : 'refused');
|
||
expect(disagreeing.map((each) => `${each.device} ${each.field} ${JSON.stringify(each.input)} ${verdictOf(each)}`)).toEqual([
|
||
'host ip "10..0.0.1" marked, taken',
|
||
'host ip ".0.0.1" refused',
|
||
'host ip "+10.0.0.1" marked, taken',
|
||
'host ip "10.0.0.1." marked, taken',
|
||
'host ip "١٠.0.0.1" marked, taken',
|
||
'host ip "-0.0.0.1" marked, taken',
|
||
'host mask "255..255.0.0" marked, taken',
|
||
'host gateway " " marked, taken',
|
||
'host gateway "192.168..1.1" marked, taken',
|
||
'host dns " " marked, taken',
|
||
'switch retention "" refused',
|
||
'switch retention "-5" marked, taken',
|
||
'switch retention "99999999999999999999" refused',
|
||
'switch retention "٣" marked, taken',
|
||
'router ip ".0.0.1" lost, NullPointerException',
|
||
'router gateway "" marked, taken',
|
||
'router gateway " " marked, taken',
|
||
'router gateway "192.168..0.1" marked, taken',
|
||
'homeRouter gateway "" marked, taken',
|
||
'homeRouter wanIp ".1.2.3" lost',
|
||
]);
|
||
const ports = java.cases.filter((each) => each.field === 'port' && each.stored !== each.start);
|
||
expect(ports.map((each) => each.input)).toEqual(['0', '65535', '65536', '-1', '080', '80']);
|
||
});
|
||
|
||
it("shows what the device holds once a field is left, as Java's field does", () => {
|
||
for (const each of java.cases) if (each.field !== 'retention') expect(each.shown, each.input).toBe(each.stored ?? '');
|
||
});
|
||
});
|
||
|
||
let ids = 0;
|
||
const newId = () => `20000000-0000-0000-0000-${(++ids).toString(16).padStart(12, '0')}`;
|
||
|
||
function add(doc: Y.Doc, kind: NewDevice['kind'], name: string = kind, interfaces?: number): string {
|
||
const id = newId();
|
||
addDevice(doc, { kind, id, name, x: 100, y: 100, newId, ...(interfaces === undefined ? {} : { interfaces }) }, 'me');
|
||
return id;
|
||
}
|
||
|
||
const host = (doc: Y.Doc, id: string) => deviceSheet(doc, id) as HostSheet;
|
||
|
||
describe("a PC's sheet", () => {
|
||
it("shows a new PC as Java's panel does", () => {
|
||
const doc = new Y.Doc();
|
||
const pc = add(doc, 'pc', 'Rechner');
|
||
const sheet = host(doc, pc);
|
||
expect({ ...sheet, macAddress: undefined }).toEqual({
|
||
kind: 'pc',
|
||
name: 'Rechner',
|
||
labels: { ipAddress: false, macAddress: false },
|
||
macAddress: undefined,
|
||
ipAddress: '192.168.0.10',
|
||
subnetMask: '255.255.255.0',
|
||
defaultGateway: '',
|
||
dnsServer: '',
|
||
dhcpClient: false,
|
||
ipForwarding: false,
|
||
wireless: false,
|
||
ssid: '',
|
||
wirelessPossible: true,
|
||
networks: [],
|
||
});
|
||
expect(sheet.macAddress).toMatch(/^([0-9A-F]{2}:){5}[0-9A-F]{2}$/);
|
||
expect(deviceSheet(doc, 'nobody')).toBeUndefined();
|
||
});
|
||
|
||
it('takes an address as Java keeps it, keeps the old one for a marked text, and says which', () => {
|
||
const doc = new Y.Doc();
|
||
const pc = add(doc, 'pc');
|
||
expect(setHostAddress(doc, pc, 'ipAddress', ' 010.000.000.001 ', 'me')).toEqual({ value: '10.0.0.1' });
|
||
expect(setHostAddress(doc, pc, 'ipAddress', '10.0.0.256', 'me')).toEqual({ invalid: true });
|
||
expect(setHostAddress(doc, pc, 'subnetMask', '255.0.255.0', 'me')).toEqual({ value: '255.0.255.0' });
|
||
expect(setHostAddress(doc, pc, 'defaultGateway', '10.0.0.254', 'me')).toEqual({ value: '10.0.0.254' });
|
||
expect(setHostAddress(doc, pc, 'dnsServer', '8.8.8', 'me')).toEqual({ invalid: true });
|
||
expect(setHostAddress(doc, pc, 'dnsServer', '8.8.8.8', 'me')).toEqual({ value: '8.8.8.8' });
|
||
expect(readProject(doc).deviceConfigurations.get(pc)).toEqual({ ipAddress: '10.0.0.1', subnetMask: '255.0.255.0', defaultGateway: '10.0.0.254', dnsServer: '8.8.8.8' });
|
||
expect(setHostAddress(doc, pc, 'defaultGateway', '', 'me')).toEqual({ value: '' });
|
||
expect(host(doc, pc).defaultGateway).toBe('');
|
||
expect(setHostAddress(doc, 'nobody', 'ipAddress', '10.0.0.1', 'me')).toEqual({ value: '10.0.0.1' });
|
||
});
|
||
|
||
it('is renamed, and shows its address, its MAC address or both as its name', () => {
|
||
const doc = new Y.Doc();
|
||
const pc = add(doc, 'pc');
|
||
renameDevice(doc, pc, 'PC-A', 'me');
|
||
setHostLabels(doc, pc, { ipAddress: true, macAddress: false }, 'me');
|
||
expect(topologyView(doc).nodes[0]!.label).toBe('192.168.0.10');
|
||
setHostLabels(doc, pc, { ipAddress: false, macAddress: true }, 'me');
|
||
expect(topologyView(doc).nodes[0]!.label).toBe(host(doc, pc).macAddress);
|
||
setHostLabels(doc, pc, { ipAddress: true, macAddress: true }, 'me');
|
||
expect(host(doc, pc).labels).toEqual({ ipAddress: true, macAddress: true });
|
||
expect(topologyView(doc).nodes[0]!.label).toBe(`192.168.0.10 (${host(doc, pc).macAddress})`);
|
||
setHostLabels(doc, pc, { ipAddress: false, macAddress: false }, 'me');
|
||
expect(topologyView(doc).nodes[0]!.label).toBe('PC-A');
|
||
});
|
||
|
||
it("keeps its name while it shows its MAC address and another field is taken (Java's panel overwrites it)", () => {
|
||
// Java: the name became the MAC address; with the address shown instead, it stayed.
|
||
expect(java.flows.useMacAsNameThenOff).toMatch(/^([0-9A-F]{2}:){5}[0-9A-F]{2}$/);
|
||
expect(java.flows.useIpAsNameThenOff).toBe('PC-A');
|
||
const doc = new Y.Doc();
|
||
const pc = add(doc, 'pc', 'PC-A');
|
||
setHostLabels(doc, pc, { ipAddress: false, macAddress: true }, 'me');
|
||
setHostAddress(doc, pc, 'defaultGateway', '192.168.0.1', 'me');
|
||
setHostLabels(doc, pc, { ipAddress: false, macAddress: false }, 'me');
|
||
expect(host(doc, pc).name).toBe('PC-A');
|
||
});
|
||
|
||
it("keeps IP forwarding only where it differs from the kind's", () => {
|
||
const doc = new Y.Doc();
|
||
const pc = add(doc, 'pc');
|
||
const router = add(doc, 'router');
|
||
setIpForwarding(doc, pc, true, 'me');
|
||
setIpForwarding(doc, router, false, 'me');
|
||
expect(host(doc, pc).ipForwarding).toBe(true);
|
||
expect(readProject(doc).ipForwardingByNodeId).toEqual(
|
||
new Map([
|
||
[pc, true],
|
||
[router, false],
|
||
]),
|
||
);
|
||
setIpForwarding(doc, pc, false, 'me');
|
||
setIpForwarding(doc, router, true, 'me');
|
||
expect(readProject(doc).ipForwardingByNodeId).toEqual(new Map());
|
||
});
|
||
|
||
it("uses DHCP, which stops its own DHCP server, as Java's panel does", () => {
|
||
expect(java.flows).toMatchObject({ dhcpClient: true, dhcpClientStopsServer: true });
|
||
const doc = new Y.Doc();
|
||
const pc = add(doc, 'pc');
|
||
const settings = doc.getMap<Y.Map<unknown>>(ROOTS.nodes).get(pc)!.get('settings') as Y.Map<unknown>;
|
||
const server = new Y.Map<unknown>();
|
||
server.set('isActive', true);
|
||
settings.set('dhcpServer', server);
|
||
setDhcpClient(doc, pc, true, 'me');
|
||
expect(host(doc, pc).dhcpClient).toBe(true);
|
||
expect(readProject(doc).dhcpClientConfigurations.get(pc)).toEqual({ isEnabled: true });
|
||
expect(server.get('isActive')).toBe(false);
|
||
setDhcpClient(doc, pc, false, 'me');
|
||
expect(host(doc, pc).dhcpClient).toBe(false);
|
||
expect(readProject(doc).dhcpClientConfigurations.has(pc)).toBe(false);
|
||
});
|
||
});
|
||
|
||
describe('a wireless card', () => {
|
||
/** Two switches with their SSIDs and a notebook. */
|
||
function wlan() {
|
||
const doc = new Y.Doc();
|
||
const first = add(doc, 'networkSwitch');
|
||
const second = add(doc, 'networkSwitch');
|
||
const notebook = add(doc, 'notebook');
|
||
setSwitchSsid(doc, first, 'Schule', 'me');
|
||
setSwitchSsid(doc, second, 'Gast', 'me');
|
||
const ends = () => readProject(doc).graph.links.map((link) => [link.sourceNodeId, link.targetNodeId]);
|
||
return { doc, first, second, notebook, ends };
|
||
}
|
||
|
||
it('offers the switches’ networks, each once', () => {
|
||
const { doc, notebook } = wlan();
|
||
const third = add(doc, 'networkSwitch');
|
||
setSwitchSsid(doc, third, 'Schule', 'me');
|
||
expect(host(doc, notebook).networks).toEqual(['Schule', 'Gast']);
|
||
});
|
||
|
||
it('joins the first switch with its SSID, moves with the SSID and leaves on the cable', () => {
|
||
const { doc, first, second, notebook, ends } = wlan();
|
||
expect(setHostWireless(doc, notebook, true, 'Schule', 'link-1', 'me')).toEqual({ link: 'link-1' });
|
||
expect(ends()).toEqual([[notebook, first]]);
|
||
expect(topologyView(doc).links[0]!.wireless).toBe(true);
|
||
expect(host(doc, notebook)).toMatchObject({ wireless: true, ssid: 'Schule', wirelessPossible: true });
|
||
expect(setHostWireless(doc, notebook, true, 'Gast', 'link-2', 'me')).toEqual({ link: 'link-2' });
|
||
expect(ends()).toEqual([[notebook, second]]);
|
||
// The same again changes nothing.
|
||
expect(setHostWireless(doc, notebook, true, 'Gast', 'link-3', 'me')).toEqual({});
|
||
expect(ends()).toEqual([[notebook, second]]);
|
||
expect(setHostWireless(doc, notebook, false, 'Gast', 'link-4', 'me')).toEqual({});
|
||
expect(ends()).toEqual([]);
|
||
// Java keeps the SSID with the cable.
|
||
expect(readProject(doc).hostWirelessConfigurations.get(notebook)).toEqual({ isEnabled: false, ssid: 'Gast' });
|
||
expect(setHostWireless(doc, notebook, false, '', 'link-5', 'me')).toEqual({});
|
||
expect(readProject(doc).hostWirelessConfigurations.has(notebook)).toBe(false);
|
||
});
|
||
|
||
it('joins the first of two switches with its SSID', () => {
|
||
const { doc, second, notebook, ends } = wlan();
|
||
const third = add(doc, 'networkSwitch');
|
||
setSwitchSsid(doc, third, 'Gast', 'me');
|
||
expect(setHostWireless(doc, notebook, true, 'Gast', 'link-1', 'me')).toEqual({ link: 'link-1' });
|
||
expect(ends()).toEqual([[notebook, second]]);
|
||
});
|
||
|
||
it('joins no network without an SSID or without a switch that has it', () => {
|
||
const { doc, notebook, ends } = wlan();
|
||
expect(setHostWireless(doc, notebook, true, '', 'link-1', 'me')).toEqual({});
|
||
expect(setHostWireless(doc, notebook, true, 'Nirgends', 'link-2', 'me')).toEqual({});
|
||
expect(ends()).toEqual([]);
|
||
expect(host(doc, notebook)).toMatchObject({ wireless: true, ssid: 'Nirgends' });
|
||
});
|
||
|
||
it('cannot be chosen while its cable is plugged, and says why a full switch refuses it', () => {
|
||
const { doc, first, notebook } = wlan();
|
||
const pc = add(doc, 'pc');
|
||
connect(doc, { node: notebook }, { node: pc }, 'cable', 'me');
|
||
expect(host(doc, notebook).wirelessPossible).toBe(false);
|
||
expect(setHostWireless(doc, notebook, true, 'Schule', 'link-1', 'me')).toEqual({ error: 'cablePlugged' });
|
||
expect(host(doc, notebook).wireless).toBe(false);
|
||
const other = add(doc, 'notebook');
|
||
const full = doc.getMap<Y.Map<unknown>>(ROOTS.nodes).get(first)!;
|
||
(full.get('ports') as Y.Array<Y.Map<unknown>>).delete(1, 23);
|
||
expect(connect(doc, { node: add(doc, 'pc') }, { node: first }, 'filled', 'me')).toEqual({ link: 'filled' });
|
||
expect(setHostWireless(doc, other, true, 'Schule', 'link-2', 'me')).toEqual({ error: 'noFreePort' });
|
||
expect(setHostWireless(doc, 'nobody', true, 'Schule', 'link-3', 'me')).toEqual({ error: 'unknownDevice' });
|
||
});
|
||
|
||
it("is dropped by a switch that changes its SSID, a cable to it staying (Java's panel)", () => {
|
||
const { doc, first, notebook, ends } = wlan();
|
||
const pc = add(doc, 'pc');
|
||
setHostWireless(doc, notebook, true, 'Schule', 'link-1', 'me');
|
||
connect(doc, { node: pc }, { node: first }, 'cable', 'me');
|
||
expect(setSwitchSsid(doc, first, 'Schule', 'me')).toEqual({ value: 'Schule' });
|
||
expect(ends()).toHaveLength(2);
|
||
expect(setSwitchSsid(doc, first, 'Ä', 'me')).toEqual({ invalid: true });
|
||
expect(ends()).toHaveLength(2);
|
||
expect(setSwitchSsid(doc, first, 'Neu', 'me')).toEqual({ value: 'Neu' });
|
||
expect(ends()).toEqual([[pc, first]]);
|
||
});
|
||
});
|
||
|
||
describe("a switch's and a modem's sheet", () => {
|
||
it('shows and keeps the SSID, the retention time in seconds and the cloud', () => {
|
||
const doc = new Y.Doc();
|
||
const hub = add(doc, 'networkSwitch', 'Switch');
|
||
expect(deviceSheet(doc, hub)).toEqual({ kind: 'networkSwitch', name: 'Switch', ssid: hub.replaceAll('-', '').slice(0, 6), retentionSeconds: 300, cloud: false });
|
||
expect(setSwitchRetention(doc, hub, ' 007 ', 'me')).toEqual({ value: '7' });
|
||
expect(setSwitchRetention(doc, hub, '-5', 'me')).toEqual({ invalid: true });
|
||
setSwitchCloud(doc, hub, true, 'me');
|
||
expect(deviceSheet(doc, hub)).toMatchObject({ retentionSeconds: 7, cloud: true });
|
||
expect(topologyView(doc).nodes[0]!.cloud).toBe(true);
|
||
expect(readProject(doc).switchConfigurations.get(hub)).toEqual({ ssid: hub.replaceAll('-', '').slice(0, 6), retentionTimeMilliseconds: 7000, showsAsCloud: true });
|
||
setSwitchCloud(doc, hub, false, 'me');
|
||
expect(readProject(doc).switchConfigurations.get(hub)).toEqual({ ssid: hub.replaceAll('-', '').slice(0, 6), retentionTimeMilliseconds: 7000 });
|
||
});
|
||
|
||
it('shows whole seconds of a retention time a file brings in milliseconds', () => {
|
||
const doc = new Y.Doc();
|
||
const hub = add(doc, 'networkSwitch');
|
||
(doc.getMap<Y.Map<unknown>>(ROOTS.nodes).get(hub)!.get('settings') as Y.Map<Y.Map<unknown>>).get('switch')!.set('retentionTimeMilliseconds', 1999);
|
||
expect(deviceSheet(doc, hub)).toMatchObject({ retentionSeconds: 1 });
|
||
});
|
||
|
||
it('pairs a modem by its port, and renames a router', () => {
|
||
const doc = new Y.Doc();
|
||
const modem = add(doc, 'remoteLink', 'Modem');
|
||
expect(deviceSheet(doc, modem)).toEqual({ kind: 'remoteLink', name: 'Modem', port: 12_345 });
|
||
expect(setModemPort(doc, modem, '65536', 'me')).toEqual({ invalid: true });
|
||
expect(setModemPort(doc, modem, ' 80', 'me')).toEqual({ value: '80' });
|
||
expect(readProject(doc).remoteLinkConfigurations.get(modem)).toEqual({ pairIdentifier: 'java-modem-port-80', latencyMilliseconds: 20, isEnabled: true });
|
||
expect(deviceSheet(doc, modem)).toMatchObject({ port: 80 });
|
||
const router = add(doc, 'router', 'R1');
|
||
renameDevice(doc, router, 'R2', 'me');
|
||
expect(deviceSheet(doc, router)).toMatchObject({ kind: 'router', name: 'R2' });
|
||
expect(deviceSheet(doc, add(doc, 'gateway', 'Heim'))).toMatchObject({ kind: 'gateway', name: 'Heim' });
|
||
});
|
||
});
|
||
|
||
describe("the sheet's changes", () => {
|
||
it('are each one step of the person’s undo, the wireless join with its connection', () => {
|
||
const doc = new Y.Doc();
|
||
const hub = add(doc, 'networkSwitch');
|
||
const notebook = add(doc, 'notebook');
|
||
setSwitchSsid(doc, hub, 'Schule', 'setup');
|
||
const undo = createUndoManager(doc, 'me');
|
||
setHostAddress(doc, notebook, 'ipAddress', '10.0.0.1', 'me');
|
||
undo.stopCapturing();
|
||
setHostWireless(doc, notebook, true, 'Schule', 'link-1', 'me');
|
||
undo.stopCapturing();
|
||
renameDevice(doc, notebook, 'NB', 'me');
|
||
undo.stopCapturing();
|
||
undo.undo();
|
||
expect(host(doc, notebook).name).toBe('notebook');
|
||
undo.undo();
|
||
expect(host(doc, notebook).wireless).toBe(false);
|
||
expect(readProject(doc).graph.links).toEqual([]);
|
||
undo.undo();
|
||
expect(host(doc, notebook).ipAddress).toBe('192.168.0.10');
|
||
undo.redo();
|
||
undo.redo();
|
||
expect(host(doc, notebook)).toMatchObject({ ipAddress: '10.0.0.1', wireless: true });
|
||
expect(readProject(doc).graph.links).toHaveLength(1);
|
||
});
|
||
|
||
it('are kept through a saved file', () => {
|
||
const doc = new Y.Doc();
|
||
const pc = add(doc, 'pc', 'PC-A');
|
||
const hub = add(doc, 'networkSwitch', 'S');
|
||
const modem = add(doc, 'remoteLink', 'M');
|
||
setHostAddress(doc, pc, 'ipAddress', '10.1.2.3', 'me');
|
||
setHostAddress(doc, pc, 'subnetMask', '255.255.0.0', 'me');
|
||
setHostAddress(doc, pc, 'defaultGateway', '10.1.0.1', 'me');
|
||
setHostAddress(doc, pc, 'dnsServer', '10.1.0.2', 'me');
|
||
setHostLabels(doc, pc, { ipAddress: true, macAddress: false }, 'me');
|
||
setIpForwarding(doc, pc, true, 'me');
|
||
setDhcpClient(doc, pc, true, 'me');
|
||
setSwitchSsid(doc, hub, 'Schule', 'me');
|
||
setSwitchRetention(doc, hub, '42', 'me');
|
||
setSwitchCloud(doc, hub, true, 'me');
|
||
setModemPort(doc, modem, '4242', 'me');
|
||
let counter = 0;
|
||
const reopened = openProjectArchive(saveProjectArchive(readProject(doc)).archive, () => `30000000-0000-0000-0000-${(++counter).toString(16).padStart(12, '0')}`);
|
||
const [pcAgain, hubAgain, modemAgain] = reopened.graph.nodes;
|
||
expect(pcAgain!.hostLabelPolicy).toBe('ipAddress');
|
||
expect(reopened.deviceConfigurations.get(pcAgain!.id)).toEqual({ ipAddress: '10.1.2.3', subnetMask: '255.255.0.0', defaultGateway: '10.1.0.1', dnsServer: '10.1.0.2' });
|
||
expect(reopened.ipForwardingByNodeId.get(pcAgain!.id)).toBe(true);
|
||
expect(reopened.dhcpClientConfigurations.get(pcAgain!.id)).toEqual({ isEnabled: true });
|
||
expect(reopened.switchConfigurations.get(hubAgain!.id)).toEqual({ ssid: 'Schule', retentionTimeMilliseconds: 42_000, showsAsCloud: true });
|
||
expect(reopened.remoteLinkConfigurations.get(modemAgain!.id)?.pairIdentifier).toBe('java-modem-port-4242');
|
||
});
|
||
});
|
||
|
||
const router = (doc: Y.Doc, id: string) => deviceSheet(doc, id) as RouterSheet;
|
||
const home = (doc: Y.Doc, id: string) => deviceSheet(doc, id) as HomeRouterSheet;
|
||
|
||
/** Java's manual rows of the measured tables, as SheetRun added them. */
|
||
const JAVA_MANUAL = [
|
||
{ destinationNetwork: '172.16.0.0', subnetMask: '255.255.0.0', gateway: '192.168.1.2', interfaceIPAddress: '192.168.1.1' },
|
||
{ destinationNetwork: '010.020.0.0', subnetMask: '255.255.0.0', gateway: '10.0.0.2', interfaceIPAddress: '10.0.0.1' },
|
||
];
|
||
|
||
/** The measured tables' routers: their cards (address, mask), gateway and manual rows. */
|
||
const TABLES: Readonly<Record<string, { readonly cards: readonly (readonly [string, string])[]; readonly gateway: string; readonly manual: boolean }>> = {
|
||
gatewayInSecondNetwork: {
|
||
cards: [
|
||
['10.0.0.1', '255.0.0.0'],
|
||
['192.168.1.1', '255.255.255.0'],
|
||
],
|
||
gateway: '192.168.1.254',
|
||
manual: true,
|
||
},
|
||
gatewayInNoNetwork: {
|
||
cards: [
|
||
['10.0.0.1', '255.0.0.0'],
|
||
['192.168.1.1', '255.255.255.0'],
|
||
],
|
||
gateway: '172.30.0.1',
|
||
manual: true,
|
||
},
|
||
gatewayInBothNetworks: {
|
||
cards: [
|
||
['10.0.0.1', '255.0.0.0'],
|
||
['10.1.0.1', '255.255.0.0'],
|
||
],
|
||
gateway: '10.1.0.254',
|
||
manual: false,
|
||
},
|
||
noGateway: {
|
||
cards: [
|
||
['10.0.0.1', '255.0.0.0'],
|
||
['192.168.1.1', '255.255.255.0'],
|
||
],
|
||
gateway: '',
|
||
manual: true,
|
||
},
|
||
threeInterfaces: {
|
||
cards: [
|
||
['10.0.0.1', '255.0.0.0'],
|
||
['192.168.1.1', '255.255.255.0'],
|
||
['172.16.5.1', '255.255.0.0'],
|
||
],
|
||
gateway: '10.0.0.254',
|
||
manual: false,
|
||
},
|
||
};
|
||
|
||
describe("a router's sheet", () => {
|
||
it("shows the forwarding table Java shows, in Java's order, its manual rows editable", () => {
|
||
expect(Object.keys(java.tables).sort()).toEqual(Object.keys(TABLES).sort());
|
||
for (const [name, setup] of Object.entries(TABLES)) {
|
||
const doc = new Y.Doc();
|
||
const id = add(doc, 'router', 'R', setup.cards.length);
|
||
router(doc, id).interfaces.forEach((card, index) => {
|
||
expect(setInterfaceAddress(doc, id, card.portId, 'ipAddress', setup.cards[index]![0], 'me')).toEqual({ value: setup.cards[index]![0] });
|
||
expect(setInterfaceAddress(doc, id, card.portId, 'subnetMask', setup.cards[index]![1], 'me')).toEqual({ value: setup.cards[index]![1] });
|
||
});
|
||
setRouterGateway(doc, id, setup.gateway, 'me');
|
||
if (setup.manual) for (const row of JAVA_MANUAL) expect('route' in addRoute(doc, id, row, 'me')).toBe(true);
|
||
const table = router(doc, id).table.map((row) => ({ cells: [row.destinationNetwork, row.subnetMask, row.nextHop, row.interfaceIPAddress], manual: row.isEditable }));
|
||
expect(table, name).toEqual(java.tables[name]);
|
||
}
|
||
});
|
||
|
||
it('takes a card’s address as Java keeps it and keeps the old one for a refused text, the first card mirrored in the device', () => {
|
||
const doc = new Y.Doc();
|
||
const id = add(doc, 'router');
|
||
const [first, second] = router(doc, id).interfaces;
|
||
expect(setInterfaceAddress(doc, id, first!.portId, 'ipAddress', ' 010.0.0.1 ', 'me')).toEqual({ value: '10.0.0.1' });
|
||
expect(setInterfaceAddress(doc, id, first!.portId, 'ipAddress', '.0.0.1', 'me')).toEqual({ invalid: true });
|
||
expect(setInterfaceAddress(doc, id, second!.portId, 'subnetMask', '255.255', 'me')).toEqual({ invalid: true });
|
||
expect(setInterfaceAddress(doc, id, second!.portId, 'subnetMask', '255.0.255.0', 'me')).toEqual({ value: '255.0.255.0' });
|
||
expect(setInterfaceAddress(doc, id, 'no-port', 'ipAddress', '10.0.0.1', 'me')).toEqual({ value: '10.0.0.1' });
|
||
expect(router(doc, id).interfaces.map((card) => [card.ipAddress, card.subnetMask])).toEqual([
|
||
['10.0.0.1', '255.255.255.0'],
|
||
['192.168.0.10', '255.0.255.0'],
|
||
]);
|
||
// A router keeps its own settings only with a gateway; then they follow its first card.
|
||
expect(readProject(doc).deviceConfigurations.has(id)).toBe(false);
|
||
expect(setRouterGateway(doc, id, '10.0.0.254', 'me')).toEqual({ value: '10.0.0.254' });
|
||
expect(readProject(doc).deviceConfigurations.get(id)).toEqual({ ipAddress: '10.0.0.1', subnetMask: '255.255.255.0', defaultGateway: '10.0.0.254', dnsServer: '' });
|
||
setInterfaceAddress(doc, id, first!.portId, 'ipAddress', '10.0.0.2', 'me');
|
||
setInterfaceAddress(doc, id, first!.portId, 'subnetMask', '255.0.0.0', 'me');
|
||
expect(readProject(doc).deviceConfigurations.get(id)).toMatchObject({ ipAddress: '10.0.0.2', subnetMask: '255.0.0.0' });
|
||
expect(setRouterGateway(doc, id, 'abc', 'me')).toEqual({ invalid: true });
|
||
expect(router(doc, id).gateway).toBe('10.0.0.254');
|
||
expect(setRouterGateway(doc, id, ' ', 'me')).toEqual({ value: '' });
|
||
expect(readProject(doc).deviceConfigurations.has(id)).toBe(false);
|
||
});
|
||
|
||
it('switches RIP, and shows IP forwarding on', () => {
|
||
const doc = new Y.Doc();
|
||
const id = add(doc, 'router');
|
||
expect(router(doc, id)).toMatchObject({ rip: false, ipForwarding: true, gateway: '' });
|
||
setRip(doc, id, true, 'me');
|
||
expect(router(doc, id).rip).toBe(true);
|
||
expect(readProject(doc).ripEnabledByNodeId.get(id)).toBe(true);
|
||
setRip(doc, id, false, 'me');
|
||
expect(readProject(doc).ripEnabledByNodeId.has(id)).toBe(false);
|
||
});
|
||
|
||
it('names what each card is plugged into, by its label', () => {
|
||
const doc = new Y.Doc();
|
||
const id = add(doc, 'router');
|
||
const pc = add(doc, 'pc', 'PC-A');
|
||
setHostLabels(doc, pc, { ipAddress: true, macAddress: false }, 'me');
|
||
connect(doc, { node: pc }, { node: id }, 'cable', 'me');
|
||
expect(router(doc, id).interfaces.map((card) => card.connected)).toEqual([{ device: '192.168.0.10', link: 'cable' }, null]);
|
||
expect(router(doc, id).interfaces[0]!.macAddress).toMatch(/^([0-9A-F]{2}:){5}[0-9A-F]{2}$/);
|
||
});
|
||
});
|
||
|
||
describe("a router's manual rows", () => {
|
||
/** A router with Java's one manual row of SheetRun's edits. */
|
||
function edited() {
|
||
const doc = new Y.Doc();
|
||
const id = add(doc, 'router');
|
||
addRoute(doc, id, { destinationNetwork: '172.16.0.0', subnetMask: '255.255.0.0', gateway: '192.168.0.2', interfaceIPAddress: '192.168.0.10' }, 'me');
|
||
const rows = () =>
|
||
readProject(doc)
|
||
.manualRoutesByNodeId.get(id)
|
||
?.map((row) => [row.destinationNetwork, row.subnetMask, row.gateway, row.interfaceIPAddress]) ?? [];
|
||
return { doc, id, rows };
|
||
}
|
||
|
||
it('take a cell as Java does where Java takes it, and keep it where Java stores null', () => {
|
||
for (const [name, column, text] of [
|
||
['leadingZeros', 'destinationNetwork', '010.0.0.0'],
|
||
['maskCell', 'subnetMask', '255.0.255.0'],
|
||
] as const) {
|
||
const { doc, id, rows } = edited();
|
||
expect('value' in setRouteCell(doc, id, 0, column, text, 'me'), name).toBe(true);
|
||
expect(rows(), name).toEqual(java.edits[name]!.manual);
|
||
}
|
||
for (const [name, text] of [
|
||
['invalidCell', 'abc'],
|
||
['emptyCell', ''],
|
||
['dottedTwice', '10..0.0'],
|
||
] as const) {
|
||
// Java: the cell becomes null.
|
||
expect(java.edits[name]!.manual[0]![0], name).toBeNull();
|
||
const { doc, id, rows } = edited();
|
||
expect(setRouteCell(doc, id, 0, 'destinationNetwork', text, 'me'), name).toEqual({ invalid: true });
|
||
expect(rows()[0]![0], name).toBe('172.16.0.0');
|
||
}
|
||
});
|
||
|
||
it('edit and lose the row they are asked for', () => {
|
||
const { doc, id, rows } = edited();
|
||
addRoute(doc, id, JAVA_MANUAL[0]!, 'me');
|
||
expect(setRouteCell(doc, id, 1, 'gateway', '192.168.1.3', 'me')).toEqual({ value: '192.168.1.3' });
|
||
expect(rows()).toEqual([
|
||
['172.16.0.0', '255.255.0.0', '192.168.0.2', '192.168.0.10'],
|
||
['172.16.0.0', '255.255.0.0', '192.168.1.3', '192.168.1.1'],
|
||
]);
|
||
removeRoute(doc, id, 1, 'me');
|
||
expect(rows()).toEqual([['172.16.0.0', '255.255.0.0', '192.168.0.2', '192.168.0.10']]);
|
||
});
|
||
|
||
it('take a new row once all four cells pass, as Java does, and lose a row', () => {
|
||
const cells = { destinationNetwork: '10.9.0.0', subnetMask: '255.255.0.0', gateway: '10.0.0.9', interfaceIPAddress: '' };
|
||
let { doc, id, rows } = edited();
|
||
expect(addRoute(doc, id, cells, 'me')).toEqual({ invalid: ['interfaceIPAddress'] });
|
||
expect(rows()).toEqual(java.edits.newRowThreeCells!.manual);
|
||
expect(addRoute(doc, id, { ...cells, interfaceIPAddress: '10..0.0.1' }, 'me')).toEqual({ invalid: ['interfaceIPAddress'] });
|
||
expect(rows()).toEqual(java.edits.newRowInvalidCell!.manual);
|
||
expect(addRoute(doc, id, { ...cells, interfaceIPAddress: '10.0.0.1' }, 'me')).toEqual({ route: { ...cells, interfaceIPAddress: '10.0.0.1' } });
|
||
expect(rows()).toEqual(java.edits.newRowFourCells!.manual);
|
||
expect(addRoute(doc, 'nobody', { ...cells, interfaceIPAddress: '10.0.0.1' }, 'me')).toEqual({ invalid: [] });
|
||
({ doc, id, rows } = edited());
|
||
removeRoute(doc, id, 5, 'me');
|
||
removeRoute(doc, id, 0, 'me');
|
||
expect(rows()).toEqual(java.edits.removeRow!.manual);
|
||
expect((doc.getMap<Y.Map<unknown>>(ROOTS.nodes).get(id)!.get('settings') as Y.Map<unknown>).has('routes')).toBe(false);
|
||
// Java keeps one new row at a time; the sheet's draft is one row too.
|
||
expect(java.edits.newRowTwice!.rowsShown).toBe(2);
|
||
});
|
||
});
|
||
|
||
describe("a home router's sheet", () => {
|
||
it("shows its WAN and LAN cards, keeps the WAN card in the device's settings, and leaves its DHCP server running", () => {
|
||
expect(java.flows).toMatchObject({ homeRouterDhcpClient: true, homeRouterDhcpClientStopsServer: false });
|
||
const doc = new Y.Doc();
|
||
const id = add(doc, 'gateway', 'Heim');
|
||
const sheet = home(doc, id);
|
||
expect([sheet.wan.ipAddress, sheet.wan.subnetMask, sheet.lan.ipAddress, sheet.lan.subnetMask, sheet.gateway, sheet.ipForwarding, sheet.dhcpClient]).toEqual([
|
||
'42.0.0.10',
|
||
'255.0.0.0',
|
||
'192.168.0.10',
|
||
'255.255.255.0',
|
||
'',
|
||
true,
|
||
false,
|
||
]);
|
||
expect(setInterfaceAddress(doc, id, sheet.wan.portId, 'ipAddress', '042.1.2.3', 'me')).toEqual({ value: '42.1.2.3' });
|
||
expect(setInterfaceAddress(doc, id, sheet.lan.portId, 'subnetMask', '255.255.255.128', 'me')).toEqual({ value: '255.255.255.128' });
|
||
expect(setRouterGateway(doc, id, '42.0.0.1', 'me')).toEqual({ value: '42.0.0.1' });
|
||
expect(readProject(doc).deviceConfigurations.get(id)).toEqual({ ipAddress: '42.1.2.3', subnetMask: '255.0.0.0', defaultGateway: '42.0.0.1', dnsServer: '' });
|
||
// Unlike a router, a home router keeps its own settings without a gateway.
|
||
setRouterGateway(doc, id, '', 'me');
|
||
expect(readProject(doc).deviceConfigurations.get(id)).toMatchObject({ defaultGateway: '' });
|
||
const settings = doc.getMap<Y.Map<unknown>>(ROOTS.nodes).get(id)!.get('settings') as Y.Map<unknown>;
|
||
const server = new Y.Map<unknown>();
|
||
server.set('isActive', true);
|
||
settings.set('dhcpServer', server);
|
||
setDhcpClient(doc, id, true, 'me');
|
||
expect(home(doc, id).dhcpClient).toBe(true);
|
||
expect(server.get('isActive')).toBe(true);
|
||
});
|
||
|
||
it('keeps everything through a saved file, with the router’s rows and RIP', () => {
|
||
const doc = new Y.Doc();
|
||
const id = add(doc, 'router', 'R', 3);
|
||
const homeId = add(doc, 'gateway', 'Heim');
|
||
const cards = router(doc, id).interfaces;
|
||
setInterfaceAddress(doc, id, cards[2]!.portId, 'ipAddress', '172.16.5.1', 'me');
|
||
setRouterGateway(doc, id, '192.168.0.254', 'me');
|
||
setRip(doc, id, true, 'me');
|
||
addRoute(doc, id, JAVA_MANUAL[1]!, 'me');
|
||
setInterfaceAddress(doc, homeId, home(doc, homeId).lan.portId, 'ipAddress', '192.168.7.1', 'me');
|
||
setRouterGateway(doc, homeId, '42.0.0.1', 'me');
|
||
let counter = 0;
|
||
const reopened = openProjectArchive(saveProjectArchive(readProject(doc)).archive, () => `40000000-0000-0000-0000-${(++counter).toString(16).padStart(12, '0')}`);
|
||
const [routerAgain, homeAgain] = reopened.graph.nodes;
|
||
const address = (node: typeof routerAgain, index: number) => reopened.interfaceConfigurations.get(`${node!.id}/${node!.ports[index]!.id}`)?.ipAddress;
|
||
expect(address(routerAgain, 2)).toBe('172.16.5.1');
|
||
expect(reopened.deviceConfigurations.get(routerAgain!.id)?.defaultGateway).toBe('192.168.0.254');
|
||
expect(reopened.ripEnabledByNodeId.get(routerAgain!.id)).toBe(true);
|
||
expect(reopened.manualRoutesByNodeId.get(routerAgain!.id)).toEqual([{ destinationNetwork: '10.20.0.0', subnetMask: '255.255.0.0', gateway: '10.0.0.2', interfaceIPAddress: '10.0.0.1' }]);
|
||
expect(address(homeAgain, 1)).toBe('192.168.7.1');
|
||
expect(reopened.deviceConfigurations.get(homeAgain!.id)?.defaultGateway).toBe('42.0.0.1');
|
||
});
|
||
});
|