test(docdb): add unit tests for dbClusterNode in dbClusterNode.test.ts

Author: Muzaffer Aydin

packages/core/src/test/docdb/explorer/dbClusterNode.test.ts

@@ -5,7 +5,6 @@
 
 import assert from 'assert'
 import sinon from 'sinon'
-import { installFakeClock } from '../../testUtil'
 import { AWSTreeNodeBase } from '../../../shared/treeview/nodes/awsTreeNodeBase'
 import { DBCluster } from '@aws-sdk/client-docdb'
 import { DBClusterNode } from '../../../docdb/explorer/dbClusterNode'
@@ -16,6 +15,11 @@ describe('DBClusterNode', function () {
     let mockClient: DocumentDBClient
     beforeEach(() => {
         mockClient = {} as DocumentDBClient
+        DBClusterNode['globalPollingArns'].clear()
+    })
+
+    afterEach(() => {
+        DBClusterNode['globalPollingArns'].clear()
     })
 
     const parentNode = {} as AWSTreeNodeBase
@@ -38,16 +42,100 @@ describe('DBClusterNode', function () {
         assert.strictEqual(otherNodes.length, 0)
     })
 
-    it('waits for status to change', async function () {
-        const clock = installFakeClock()
-        const clusterStatus = { Status: 'testing', ...cluster }
-        const stub = sinon.stub().onFirstCall().resolves([cluster]).onSecondCall().resolves([clusterStatus])
-        mockClient.listClusters = stub
-        const node = new DBClusterNode(parentNode, cluster, mockClient)
+    it('returns false for available status', function () {
+        const clusterStatus = { ...cluster, Status: 'available' }
+        const node = new DBClusterNode(parentNode, clusterStatus, mockClient)
+
+        const requiresPolling = node.isStatusRequiringPolling()
+
+        assert.strictEqual(requiresPolling, false, 'isStatusRequiringPolling should return false for available status')
+    })
+
+    it('returns true for creating status', function () {
+        const clusterStatus = { ...cluster, Status: 'creating' }
+        const node = new DBClusterNode(parentNode, clusterStatus, mockClient)
+
+        const requiresPolling = node.isStatusRequiringPolling()
+
+        assert.strictEqual(requiresPolling, true, 'isStatusRequiringPolling should return true for creating status')
+    })
+
+    it('starts tracking changes when status requires polling', function () {
+        const clusterStatus = { ...cluster, Status: 'creating' }
+
+        const trackChangesSpy = sinon.spy(DBClusterNode.prototype, 'trackChanges')
+
+        // Initialize the node with a status that requires polling
+        const node = new DBClusterNode(parentNode, clusterStatus, mockClient)
+
+        // Check the result of isStatusRequiringPolling
+        const requiresPolling = node.isStatusRequiringPolling()
+        assert.strictEqual(requiresPolling, true, 'isStatusRequiringPolling should return true for creating status')
+
+        // Assert that trackChanges was called
+        assert.ok(trackChangesSpy.calledOnce, 'trackChanges should be called when polling is required')
+
+        // Verify the node is in the polling state
+        assert.strictEqual(node.isPolling, true, 'Node should be in polling state')
+
+        trackChangesSpy.restore()
+    })
+
+    it('does not start tracking changes when status does not require polling', function () {
+        const clusterStatus = { ...cluster, Status: 'available' }
+
+        const trackChangesSpy = sinon.spy(DBClusterNode.prototype, 'trackChanges')
+
+        // Initialize the node with a status that does not require polling
+        const node = new DBClusterNode(parentNode, clusterStatus, mockClient)
+
+        // Check the result of isStatusRequiringPolling
+        const requiresPolling = node.isStatusRequiringPolling()
+        assert.strictEqual(requiresPolling, false, 'isStatusRequiringPolling should return false for available status')
+
+        // Assert that trackChanges was not called
+        assert.ok(trackChangesSpy.notCalled, 'trackChanges should not be called when polling is not required')
+
+        // Verify the node is not in the polling state
+        assert.strictEqual(node.isPolling, false, 'Node should not be in polling state')
+
+        trackChangesSpy.restore()
+    })
+
+    it('does not polling when status is available', function () {
+        const clusterStatus = { ...cluster, Status: 'available' }
+
+        const trackChangesSpy = sinon.spy(DBClusterNode.prototype, 'trackChanges')
+
+        // Initialize the node with a status that does not require polling
+        const node = new DBClusterNode(parentNode, clusterStatus, mockClient)
+
+        // Check the result of isStatusRequiringPolling
+        const requiresPolling = node.isStatusRequiringPolling()
+        assert.strictEqual(requiresPolling, false, 'isStatusRequiringPolling should return false for available status')
+
+        // Assert that trackChanges was not called
+        assert.ok(trackChangesSpy.notCalled, 'trackChanges should not be called when polling is not required')
+
+        // Verify the node is not in the polling state
+        assert.strictEqual(node.isPolling, false, 'Node should not be in polling state')
+
+        trackChangesSpy.restore()
+    })
+
+    it('has isPolling set to false and getStatus returns available when status is available', async function () {
+        const clusterStatus = { ...cluster, Status: 'available' }
+
+        // Mock the DocumentDB client to return the status
+        mockClient.listClusters = sinon.stub().resolves([clusterStatus])
+
+        // Initialize the node with a status of 'available'
+        const node = new DBClusterNode(parentNode, clusterStatus, mockClient)
 
-        void node.waitUntilStatusChanged()
+        // Verify the node is not in the polling state
+        assert.strictEqual(node.isPolling, false, 'Node should not be in polling state')
 
-        await clock.runAllAsync()
-        assert(stub.calledTwice)
+        // Get the status from the node and verify it is 'available'
+        assert.strictEqual(node.status, 'available', 'getStatus should return available for the node')
     })
 })