diff --git a/test/specificClass.test.js b/test/specificClass.test.js new file mode 100644 index 0000000..83e3e72 --- /dev/null +++ b/test/specificClass.test.js @@ -0,0 +1,263 @@ +/** + * Tests for settler specificClass (domain logic). + * + * The Settler class is a simple mass-balance separator: + * - Splits influent into effluent (clarified), surplus sludge, and return sludge + * - Concentrates particulate species (indices 7-12) into sludge stream + * - Removes particulates from effluent stream + * - registerChild: connects measurements, upstream reactors, machines + */ + +const { Settler } = require('../src/specificClass'); + +// --------------- helpers --------------- + +const NUM_SPECIES = 13; + +function makeConfig(overrides = {}) { + return { + general: { + name: 'TestSettler', + id: 'settler-test-1', + logging: { enabled: false, logLevel: 'error' }, + }, + functionality: { + softwareType: 'settler', + role: 'separator', + positionVsParent: 'downstream', + }, + ...overrides, + }; +} + +// --------------- tests --------------- + +describe('Settler specificClass', () => { + + describe('constructor / initialization', () => { + it('should create an instance with default values', () => { + const s = new Settler(makeConfig()); + expect(s).toBeDefined(); + expect(s.F_in).toBe(0); + expect(s.Cs_in).toEqual(new Array(NUM_SPECIES).fill(0)); + expect(s.C_TS).toBe(2500); + }); + + it('should have null upstreamReactor and returnPump initially', () => { + const s = new Settler(makeConfig()); + expect(s.upstreamReactor).toBeNull(); + expect(s.returnPump).toBeNull(); + }); + + it('should initialize an EventEmitter', () => { + const s = new Settler(makeConfig()); + expect(s.emitter).toBeDefined(); + expect(typeof s.emitter.on).toBe('function'); + }); + + it('should initialize a MeasurementContainer', () => { + const s = new Settler(makeConfig()); + expect(s.measurements).toBeDefined(); + }); + }); + + describe('getEffluent', () => { + + describe('with zero inflow', () => { + it('should return three streams with zero flows', () => { + const s = new Settler(makeConfig()); + s.F_in = 0; + s.Cs_in = new Array(NUM_SPECIES).fill(0); + const result = s.getEffluent; + expect(result).toHaveLength(3); + expect(result[0].payload.F).toBe(0); // effluent + expect(result[1].payload.F).toBe(0); // surplus sludge + expect(result[2].payload.F).toBe(0); // return sludge + }); + }); + + describe('with normal inflow and particulates', () => { + let s; + let result; + + beforeAll(() => { + s = new Settler(makeConfig()); + s.F_in = 100; + s.C_TS = 5000; + // Set concentrations: solubles at indices 0-6, particulates at 7-12 + const C = new Array(NUM_SPECIES).fill(10); + C[12] = 5000; // X_TS + s.Cs_in = C; + result = s.getEffluent; + }); + + it('should return 3 output streams', () => { + expect(result).toHaveLength(3); + }); + + it('should have effluent topic "Fluent"', () => { + expect(result[0].topic).toBe('Fluent'); + }); + + it('should calculate sludge flow F_s = min(F_in * X_TS_in / C_TS, F_in)', () => { + // F_s = min(100 * 5000 / 5000, 100) = min(100, 100) = 100 + const F_eff = result[0].payload.F; + const F_so = result[1].payload.F; + const F_sr = result[2].payload.F; + // Total out should equal F_in (mass balance) + expect(F_eff + F_so + F_sr).toBeCloseTo(100, 5); + }); + + it('should set effluent particulate indices to zero when F_s > 0', () => { + const Cs_eff = result[0].payload.C; + for (let i = 7; i <= 12; i++) { + expect(Cs_eff[i]).toBe(0); + } + }); + + it('should keep effluent soluble indices unchanged', () => { + const Cs_eff = result[0].payload.C; + for (let i = 0; i < 7; i++) { + expect(Cs_eff[i]).toBe(10); + } + }); + + it('should concentrate particulates in sludge stream', () => { + const Cs_s = result[1].payload.C; + const F_s = Math.min((s.F_in * s.Cs_in[12]) / s.C_TS, s.F_in); + // Cs_s[i] = F_in * Cs_in[i] / F_s for particulate indices + for (let i = 7; i <= 12; i++) { + const expected = s.F_in * s.Cs_in[i] / F_s; + expect(Cs_s[i]).toBeCloseTo(expected, 5); + } + }); + }); + + describe('with low X_TS and high C_TS (dilute sludge)', () => { + it('should produce mostly effluent flow', () => { + const s = new Settler(makeConfig()); + s.F_in = 100; + s.C_TS = 10000; // high target concentration + const C = new Array(NUM_SPECIES).fill(10); + C[12] = 100; // low X_TS in + s.Cs_in = C; + const result = s.getEffluent; + // F_s = min(100 * 100 / 10000, 100) = min(1, 100) = 1 + expect(result[0].payload.F).toBeCloseTo(99, 5); // most flow is effluent + }); + }); + + describe('mass balance', () => { + it('should conserve total flow (F_eff + F_so + F_sr = F_in)', () => { + const s = new Settler(makeConfig()); + s.F_in = 200; + s.C_TS = 3000; + const C = new Array(NUM_SPECIES).fill(5); + C[12] = 2000; + s.Cs_in = C; + const result = s.getEffluent; + const totalOut = result[0].payload.F + result[1].payload.F + result[2].payload.F; + expect(totalOut).toBeCloseTo(200, 5); + }); + + it('should not produce negative flows', () => { + const s = new Settler(makeConfig()); + s.F_in = 50; + s.C_TS = 1000; + const C = new Array(NUM_SPECIES).fill(0); + C[12] = 500; + s.Cs_in = C; + const result = s.getEffluent; + result.forEach(stream => { + expect(stream.payload.F).toBeGreaterThanOrEqual(0); + }); + }); + }); + + describe('no return pump', () => { + it('should have F_sr = 0 when there is no return pump', () => { + const s = new Settler(makeConfig()); + s.F_in = 100; + s.C_TS = 5000; + s.Cs_in = new Array(NUM_SPECIES).fill(10); + s.Cs_in[12] = 3000; + const result = s.getEffluent; + expect(result[2].payload.F).toBe(0); + }); + }); + + describe('edge case: X_TS > C_TS (F_s clamped to F_in)', () => { + it('should clamp F_s to F_in when X_TS/C_TS ratio exceeds 1', () => { + const s = new Settler(makeConfig()); + s.F_in = 100; + s.C_TS = 1000; + s.Cs_in = new Array(NUM_SPECIES).fill(10); + s.Cs_in[12] = 5000; // X_TS_in > C_TS => F_s = min(500, 100) = 100 + const result = s.getEffluent; + expect(result[0].payload.F).toBe(0); // all flow goes to sludge + }); + }); + }); + + describe('registerChild()', () => { + it('should not throw for null child', () => { + const s = new Settler(makeConfig()); + // null child should trigger the error log but not crash + expect(() => s.registerChild(null, 'measurement')).not.toThrow(); + }); + + it('should not throw for unknown software type with valid child', () => { + const s = new Settler(makeConfig()); + const fakeChild = { + config: { + general: { name: 'fake', id: 'fake-1' }, + functionality: { positionVsParent: 'upstream' }, + asset: { type: 'pressure' }, + }, + measurements: { emitter: { on: jest.fn() } }, + }; + expect(() => s.registerChild(fakeChild, 'unknownType')).not.toThrow(); + }); + }); + + describe('_connectMachine()', () => { + it('should set returnPump for downstream machine', () => { + const s = new Settler(makeConfig()); + const fakeMachine = { + config: { + general: { name: 'pump', id: 'pump-1' }, + functionality: { positionVsParent: 'downstream' }, + }, + }; + s._connectMachine(fakeMachine); + expect(s.returnPump).toBe(fakeMachine); + expect(fakeMachine.upstreamSource).toBe(s); + }); + + it('should not set returnPump for non-downstream machine', () => { + const s = new Settler(makeConfig()); + const fakeMachine = { + config: { + general: { name: 'pump', id: 'pump-2' }, + functionality: { positionVsParent: 'upstream' }, + }, + }; + s._connectMachine(fakeMachine); + expect(s.returnPump).toBeNull(); + }); + }); + + describe('_updateMeasurement()', () => { + it('should update C_TS when measurement type is "quantity (tss)"', () => { + const s = new Settler(makeConfig()); + s._updateMeasurement('quantity (tss)', 7000, 'atEquipment', {}); + expect(s.C_TS).toBe(7000); + }); + + it('should not change C_TS for unrecognized measurement type', () => { + const s = new Settler(makeConfig()); + s._updateMeasurement('temperature', 25, 'atEquipment', {}); + expect(s.C_TS).toBe(2500); // unchanged + }); + }); +});