refactor tests to avoid mocking when not necessary

Author: Hweinstock

packages/core/src/test/shared/utilities/processUtils.test.ts

@@ -384,133 +384,135 @@ function startSleepProcess(timeout: number = 90): RunningProcess {
 
 describe('ChildProcessTracker', function () {
     let tracker: ChildProcessTracker
-    let clock: FakeTimers.InstalledClock
-    let usageMock: sinon.SinonStub
 
     before(function () {
-        clock = installFakeClock()
         tracker = ChildProcessTracker.instance
-        usageMock = sinon.stub(ChildProcessTracker.prototype, 'getUsage')
     })
 
     afterEach(function () {
         tracker.clear()
-        usageMock.reset()
     })
 
-    after(function () {
-        clock.uninstall()
-        usageMock.restore()
-    })
-
-    it(`removes stopped processes every ${ChildProcessTracker.pollingInterval / 1000} seconds`, async function () {
-        // Start a 'sleep' command, check it only removes after we stop it.
-        const runningProcess = startSleepProcess()
-        tracker.add(runningProcess.childProcess)
-        assert.strictEqual(tracker.has(runningProcess.childProcess), true, 'failed to add sleep command')
-
-        await clock.tickAsync(ChildProcessTracker.pollingInterval)
-        assert.strictEqual(tracker.has(runningProcess.childProcess), true, 'process was mistakenly removed')
-        await stopAndWait(runningProcess)
-
-        await clock.tickAsync(ChildProcessTracker.pollingInterval)
-        assert.strictEqual(tracker.has(runningProcess.childProcess), false, 'process was not removed after stopping')
-    })
+    describe('tracking functionality', function () {
+        let clock: FakeTimers.InstalledClock
+        let usageMock: sinon.SinonStub
 
-    it('multiple processes from same command are tracked seperately', async function () {
-        const runningProcess1 = startSleepProcess()
-        const runningProcess2 = startSleepProcess()
-        tracker.add(runningProcess1.childProcess)
-        tracker.add(runningProcess2.childProcess)
+        before(function () {
+            clock = installFakeClock()
+            tracker = ChildProcessTracker.instance
+            usageMock = sinon.stub(ChildProcessTracker.prototype, 'getUsage')
+        })
 
-        assert.strictEqual(tracker.has(runningProcess1.childProcess), true, 'Missing first process')
-        assert.strictEqual(tracker.has(runningProcess2.childProcess), true, 'Missing second process')
+        afterEach(function () {
+            usageMock.reset()
+        })
 
-        await stopAndWait(runningProcess1)
-        await clock.tickAsync(ChildProcessTracker.pollingInterval)
-        assert.strictEqual(tracker.has(runningProcess2.childProcess), true, 'second process was mistakenly removed')
-        assert.strictEqual(
-            tracker.has(runningProcess1.childProcess),
-            false,
-            'first process was not removed after stopping it'
-        )
-
-        await stopAndWait(runningProcess2)
-        await clock.tickAsync(ChildProcessTracker.pollingInterval)
-        assert.strictEqual(
-            tracker.has(runningProcess2.childProcess),
-            false,
-            'second process was not removed after stopping it'
-        )
-
-        assert.strictEqual(tracker.size, 0, 'expected tracker to be empty')
-    })
+        after(function () {
+            clock.uninstall()
+            usageMock.restore()
+        })
 
-    it('logs a warning message when system usage exceeds threshold', async function () {
-        const runningProcess = startSleepProcess()
-        tracker.add(runningProcess.childProcess)
+        it(`removes stopped processes every ${ChildProcessTracker.pollingInterval / 1000} seconds`, async function () {
+            // Start a 'sleep' command, check it only removes after we stop it.
+            const runningProcess = startSleepProcess()
+            tracker.add(runningProcess.childProcess)
+            assert.strictEqual(tracker.has(runningProcess.childProcess), true, 'failed to add sleep command')
+
+            await clock.tickAsync(ChildProcessTracker.pollingInterval)
+            assert.strictEqual(tracker.has(runningProcess.childProcess), true, 'process was mistakenly removed')
+            await stopAndWait(runningProcess)
+
+            await clock.tickAsync(ChildProcessTracker.pollingInterval)
+            assert.strictEqual(
+                tracker.has(runningProcess.childProcess),
+                false,
+                'process was not removed after stopping'
+            )
+        })
 
-        const highCpu: ProcessStats = {
-            cpu: ChildProcessTracker.thresholds.cpu + 1,
-            memory: 0,
-        }
-        const highMemory: ProcessStats = {
-            cpu: 0,
-            memory: ChildProcessTracker.thresholds.memory + 1,
-        }
+        it('multiple processes from same command are tracked seperately', async function () {
+            const runningProcess1 = startSleepProcess()
+            const runningProcess2 = startSleepProcess()
+            tracker.add(runningProcess1.childProcess)
+            tracker.add(runningProcess2.childProcess)
+
+            assert.strictEqual(tracker.has(runningProcess1.childProcess), true, 'Missing first process')
+            assert.strictEqual(tracker.has(runningProcess2.childProcess), true, 'Missing second process')
+
+            await stopAndWait(runningProcess1)
+            await clock.tickAsync(ChildProcessTracker.pollingInterval)
+            assert.strictEqual(tracker.has(runningProcess2.childProcess), true, 'second process was mistakenly removed')
+            assert.strictEqual(
+                tracker.has(runningProcess1.childProcess),
+                false,
+                'first process was not removed after stopping it'
+            )
+
+            await stopAndWait(runningProcess2)
+            await clock.tickAsync(ChildProcessTracker.pollingInterval)
+            assert.strictEqual(
+                tracker.has(runningProcess2.childProcess),
+                false,
+                'second process was not removed after stopping it'
+            )
+
+            assert.strictEqual(tracker.size, 0, 'expected tracker to be empty')
+        })
 
-        usageMock.resolves(highCpu)
+        it('logs a warning message when system usage exceeds threshold', async function () {
+            const runningProcess = startSleepProcess()
+            tracker.add(runningProcess.childProcess)
 
-        await clock.tickAsync(ChildProcessTracker.pollingInterval)
-        assertLogsContain('exceeded cpu threshold', false, 'warn')
+            const highCpu: ProcessStats = {
+                cpu: ChildProcessTracker.thresholds.cpu + 1,
+                memory: 0,
+            }
+            const highMemory: ProcessStats = {
+                cpu: 0,
+                memory: ChildProcessTracker.thresholds.memory + 1,
+            }
 
-        usageMock.resolves(highMemory)
-        await clock.tickAsync(ChildProcessTracker.pollingInterval)
-        assertLogsContain('exceeded memory threshold', false, 'warn')
+            usageMock.resolves(highCpu)
 
-        await stopAndWait(runningProcess)
-    })
+            await clock.tickAsync(ChildProcessTracker.pollingInterval)
+            assertLogsContain('exceeded cpu threshold', false, 'warn')
 
-    it('includes pid in logs', async function () {
-        const runningProcess = startSleepProcess()
-        tracker.add(runningProcess.childProcess)
+            usageMock.resolves(highMemory)
+            await clock.tickAsync(ChildProcessTracker.pollingInterval)
+            assertLogsContain('exceeded memory threshold', false, 'warn')
 
-        usageMock.resolves({
-            cpu: ChildProcessTracker.thresholds.cpu + 1,
-            memory: 0,
+            await stopAndWait(runningProcess)
         })
 
-        await clock.tickAsync(ChildProcessTracker.pollingInterval)
-        assertLogsContain(runningProcess.childProcess.pid().toString(), false, 'warn')
+        it('includes pid in logs', async function () {
+            const runningProcess = startSleepProcess()
+            tracker.add(runningProcess.childProcess)
 
-        await stopAndWait(runningProcess)
-    })
+            usageMock.resolves({
+                cpu: ChildProcessTracker.thresholds.cpu + 1,
+                memory: 0,
+            })
 
-    it('does not log for processes within threshold', async function () {
-        const runningProcess = startSleepProcess()
+            await clock.tickAsync(ChildProcessTracker.pollingInterval)
+            assertLogsContain(runningProcess.childProcess.pid().toString(), false, 'warn')
 
-        usageMock.resolves({
-            cpu: ChildProcessTracker.thresholds.cpu - 1,
-            memory: ChildProcessTracker.thresholds.memory - 1,
+            await stopAndWait(runningProcess)
         })
 
-        await clock.tickAsync(ChildProcessTracker.pollingInterval)
-
-        assert.throws(() => assertLogsContain(runningProcess.childProcess.pid().toString(), false, 'warn'))
+        it('does not log for processes within threshold', async function () {
+            const runningProcess = startSleepProcess()
 
-        await stopAndWait(runningProcess)
-    })
-})
+            usageMock.resolves({
+                cpu: ChildProcessTracker.thresholds.cpu - 1,
+                memory: ChildProcessTracker.thresholds.memory - 1,
+            })
 
-describe('ChildProcessTracker.logAllUsage', function () {
-    let tracker: ChildProcessTracker
+            await clock.tickAsync(ChildProcessTracker.pollingInterval)
 
-    before(function () {
-        tracker = ChildProcessTracker.instance
-    })
+            assert.throws(() => assertLogsContain(runningProcess.childProcess.pid().toString(), false, 'warn'))
 
-    afterEach(function () {
-        tracker.clear()
+            await stopAndWait(runningProcess)
+        })
     })
 
     it('logAllUsage includes only active processes', async function () {