:recycle: test channels

src/channel.js

     get interval() {
         return this._interval
     }
+    get lastUpdate() {
+        return this._reader.created
+    }
     get val() {
         return this._reader.val
     }

test/channel.spec.js

+import { expect, test } from 'vitest'
+import { Channel } from '../src/channel.js'
+import { Reading } from '../src/channel.js'
+
+test('channel - instantiate channel with readers correctly', () => {
+    let now = Date.now()
+    let mockTemp = 70
+    let testReader = new Reading({
+        onRead: () => mockTemp,
+        unit: 'F',
+        max: 100,
+        min: 50,
+    })
+    let testChan = new Channel({ interval: 1, reader: testReader })
+
+    // Test that the channel and channel.reader are working
+    expect(testChan.lastUpdate == now).toStrictEqual(true)
+    expect(testChan.val).toStrictEqual(70)
+    expect(testChan.unit).toStrictEqual('F')
+
+    mockTemp = 101
+    testChan = testChan.update()
+    expect(testChan.lastUpdate > now).toStrictEqual(true)
+    expect(testChan.val).toStrictEqual(101)
+    expect(testChan.inRange).toStrictEqual(false)
+    expect(testChan.aboveRange).toStrictEqual(true)
+    expect(testChan.belowRange).toStrictEqual(false)
+
+    mockTemp = 49
+    testChan = testChan.update()
+    now = Date.now()
+    expect(testChan.lastUpdate == now).toStrictEqual(true)
+    expect(testChan.inRange).toStrictEqual(false)
+    expect(testChan.aboveRange).toStrictEqual(false)
+    expect(testChan.belowRange).toStrictEqual(true)
+})

test/system.spec.js

 import { expect, test } from 'vitest'
 import { System, makeContainerT } from '../src/system.js'
-import { Reading } from '../src/channel.js'
 import { Container } from '../src/container.js'
 import { controllerTypes } from '../src/controller.js'
 import { InputConf } from '../src/index.js'
     const outputs = testSystem.outputsFor({ id: 'aaa' })
     expect(outputs).toStrictEqual(['output_test'])
 
+    testSystem.replaceContainer({ id: 'aaa' })
+    expect(testSystem.containers[0].id).toStrictEqual('aaa')
+
     testSystem.remove('aaa')
     expect(testSystem.inventory).toStrictEqual({})
 })
 
-test('system - instiantes channels with readers correctly', () => {
+test('system - update channels with readers correctly', () => {
     let testSystem = new System()
     let testContainer = new Container({ l: 10, w: 10, h: 10 })
     let mockTemp = 70
         controllerTypes.temp,
         () => mockTemp,
         0.1,
-        () => {
-            console.log('tick')
-            return 'tick'
-        }
+        () => 'tick'
     )
     const cT = makeContainerT([testInConf], [], testContainer)
     testSystem.add('aaa', cT)
 
     let chan = testSystem.inputs[0].channel
     expect(chan.interval).toStrictEqual(0.1)
-
-    // Test that the channel and channel.reader are working
-    expect(chan.val).toStrictEqual(70)
-    expect(chan.unit).toStrictEqual('F')
-    expect(chan.inRange).toStrictEqual(false)
     expect(testSystem.inputs[0].onUpdate()).toStrictEqual('tick')
-
-    mockTemp = 79
-    chan = chan.update()
-    expect(chan.val).toStrictEqual(79)
 })