@vscada/cli 0.0.1

package/templates/waste-to-energy/wte-checklist.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest';
+import { elementBindings } from '../template-test-utils';
+import sceneBuilder from './scene';
+
+/**
+ * Story 5.4 Task 5 — "the AC is a checklist, test it as one" (Dev Notes).
+ * Every `it` below is one bullet from base spec §16 (doc/SCADA-COMPONENT-SPEC.md),
+ * asserted as an item-by-item presence check against the built scene.
+ */
+describe('waste-to-energy §16 checklist (Story 5.4 AC2)', () => {
+  const scene = sceneBuilder.build();
+  const elementsById = new Map(scene.elements.map((el) => [el.id, el]));
+  const typesById = new Map(scene.elements.map((el) => [el.id, el.type]));
+  const connectionsById = new Map(scene.connections.map((c) => [c.id, c]));
+
+  it('feed hopper (level) → furnace (state, firing rate)', () => {
+    expect(typesById.get('HPR-01')).toBe('hopper');
+    expect(elementBindings(elementsById.get('HPR-01')).some((b) => b.type === 'level')).toBe(true);
+    expect(typesById.get('FCE-01')).toBe('furnace');
+    expect(elementBindings(elementsById.get('FCE-01')).some((b) => b.type === 'state')).toBe(true);
+    expect(elementBindings(elementsById.get('FCE-01')).some((b) => b.type === 'color-ramp')).toBe(true); // firing rate
+    expect(connectionsById.get('C-WASTE')).toMatchObject({ from: 'HPR-01.outlet-bot', to: 'FCE-01.fuel-inlet' });
+  });
+
+  it('furnace → boiler drum via flue gas duct (gas train: furnace → duct → fans → coil bank → stack)', () => {
+    expect(typesById.get('DCT-01')).toBe('duct');
+    expect(connectionsById.get('C-FG1')).toMatchObject({ from: 'FCE-01.flue-outlet', to: 'DCT-01.inlet', medium: 'flue-gas' });
+  });
+
+  it('boiler drum (level, pressure) → turbine via steam line', () => {
+    expect(typesById.get('BLR-01')).toBe('boiler');
+    const boilerBindingTypes = elementBindings(elementsById.get('BLR-01')).map((b) => b.type);
+    expect(boilerBindingTypes).toContain('level');
+    expect(boilerBindingTypes).toContain('readout'); // pressure
+    expect(connectionsById.get('C-STM1')).toMatchObject({ from: 'BLR-01.steam-outlet', to: 'VLV-01.inlet', medium: 'steam' });
+    expect(connectionsById.get('C-STM2')).toMatchObject({ from: 'VLV-01.outlet', to: 'TRB-01.inlet', medium: 'steam' });
+  });
+
+  it('turbine (power, RPM readouts) → condenser → feedwater pump → back to drum (the recycle loop)', () => {
+    expect(typesById.get('TRB-01')).toBe('turbine');
+    const turbineBindingTypes = elementBindings(elementsById.get('TRB-01')).map((b) => b.type);
+    expect(turbineBindingTypes).toContain('readout'); // power
+    expect(turbineBindingTypes).toContain('rotate'); // rpm
+    expect(connectionsById.get('C-STM3')).toMatchObject({ from: 'TRB-01.outlet', to: 'CND-01.inlet' });
+    expect(connectionsById.get('C-COND')).toMatchObject({ from: 'CND-01.outlet', to: 'PMP-02.suction' });
+    expect(connectionsById.get('C-FW')).toMatchObject({ from: 'PMP-02.discharge', to: 'BLR-01.feedwater-inlet' }); // closes the loop
+  });
+
+  it('steam control valve (position 0–100) on the turbine inlet', () => {
+    expect(typesById.get('VLV-01')).toBe('valve-control');
+    const positionBinding = elementBindings(elementsById.get('VLV-01')).find((b) => b.type === 'position');
+    expect(positionBinding).toMatchObject({ min: 0, max: 100 });
+  });
+
+  it('two ID fans on the gas path', () => {
+    expect(typesById.get('FAN-01')).toBe('fan-centrifugal');
+    expect(typesById.get('FAN-02')).toBe('fan-centrifugal');
+  });
+
+  it('heat exchanger coil bank', () => {
+    expect(typesById.get('COIL-01')).toBe('heat-exchanger-coil');
+  });
+
+  it('stack with temperature readout and plume', () => {
+    expect(typesById.get('STK-01')).toBe('stack');
+    expect(elementBindings(elementsById.get('STK-01')).some((b) => b.type === 'readout')).toBe(true);
+    expect(typesById.get('PLM-01')).toBe('plume');
+  });
+
+  it('motor starter panels for each pump', () => {
+    const pumpIds = [...typesById.entries()].filter(([, type]) => type === 'pump-centrifugal' || type === 'pump-positive-displacement');
+    const panelIds = [...typesById.entries()].filter(([, type]) => type === 'motor-starter-panel');
+    expect(pumpIds.length).toBeGreaterThan(0);
+    expect(panelIds.length).toBe(pumpIds.length);
+  });
+
+  it('analog gauges for temperature and flow at four points', () => {
+    const gauges = [...typesById.entries()].filter(([, type]) => type === 'gauge-analog');
+    expect(gauges.length).toBe(4);
+    const gaugeTagUnits = gauges.map(([id]) => elementBindings(elementsById.get(id))[0]);
+    // At least one temperature-scaled gauge and one flow-scaled gauge, by convention of this template's own tag names.
+    expect(gaugeTagUnits.some((b) => b?.tag.includes('temp') || b?.tag.startsWith('FCE01') || b?.tag.startsWith('STK01'))).toBe(true);
+    expect(gaugeTagUnits.some((b) => b?.tag.includes('flow'))).toBe(true);
+  });
+
+  it('bottom status bar with plant-level readouts and a STOP button', () => {
+    expect(typesById.get('RDP-01')).toBe('readout-panel');
+    expect(typesById.get('PB-01')).toBe('pushbutton');
+    const group = scene.groups.find((g) => g.id === 'status-bar-group');
+    expect(group?.children).toEqual(expect.arrayContaining(['RDP-01', 'PB-01']));
+  });
+
+  it('media exercised: waste (solid), flue gas, steam, feedwater, condensate, ash', () => {
+    const media = new Set(scene.connections.map((c) => c.medium));
+    for (const expected of ['waste', 'flue-gas', 'steam', 'feedwater', 'condensate', 'ash']) {
+      expect(media.has(expected), `missing medium "${expected}"`).toBe(true);
+    }
+  });
+
+  it('boiler section is a collapsible group (Dev Notes)', () => {
+    const group = scene.groups.find((g) => g.id === 'boiler-section');
+    expect(group).toBeDefined();
+    expect(group?.children).toEqual(expect.arrayContaining(['BLR-01', 'VLV-01']));
+  });
+});

package/templates/waste-to-energy/wte-topology.test.ts

@@ -0,0 +1,38 @@
+import { buildTopologyGraph, downstreamOf } from '@vscada/core';
+import { describe, expect, it } from 'vitest';
+import sceneBuilder from './scene';
+
+/**
+ * Story 5.4 Task 5 — "WtE topology cycle test": the recycle loop
+ * (boiler → valve → turbine → condenser → feedwater pump → boiler) must
+ * actually close, exercising Story 2.3's cycle-safe traversal (§16, AC2).
+ * `downstreamOf`/`reachableSet` always include the start node trivially
+ * (Story 2.3's own doc), so the real assertion walks from a DIRECT
+ * successor of the boiler and confirms the boiler is reachable again from
+ * there — a nontrivial cycle, not the traversal's own trivial self-membership.
+ */
+describe('waste-to-energy topology (Story 5.4 AC2, Story 2.3 cycle safety)', () => {
+  const scene = sceneBuilder.build();
+  const graph = buildTopologyGraph(scene);
+
+  it('closes a recycle loop back onto the boiler drum', () => {
+    const boilerSuccessors = graph.outgoing.get('BLR-01') ?? [];
+    expect(boilerSuccessors.length).toBeGreaterThan(0);
+
+    const firstSuccessorId = boilerSuccessors[0]!.to;
+    const reachableFromSuccessor = downstreamOf(graph, firstSuccessorId);
+    expect(reachableFromSuccessor.has('BLR-01')).toBe(true);
+  });
+
+  it('the recycle loop passes through the turbine, condenser, and feedwater pump', () => {
+    const downstreamOfBoiler = downstreamOf(graph, 'BLR-01');
+    for (const id of ['VLV-01', 'TRB-01', 'CND-01', 'PMP-02']) {
+      expect(downstreamOfBoiler.has(id)).toBe(true);
+    }
+  });
+
+  it('does not throw or hang when traversing a graph that contains a cycle (the cycle-safety guard itself)', () => {
+    expect(() => downstreamOf(graph, 'BLR-01')).not.toThrow();
+    expect(() => downstreamOf(graph, 'FCE-01')).not.toThrow();
+  });
+});