chore: add tests

Author: dinohamzic

src/notebooks/deepnote/deepnoteTreeDataProvider.unit.test.ts

@@ -160,6 +160,102 @@ suite('DeepnoteTreeDataProvider', () => {
         });
     });
 
+    suite('loading state', () => {
+        test('should show loading item on first getChildren call', async () => {
+            const children = await provider.getChildren();
+
+            assert.isArray(children);
+            assert.strictEqual(children.length, 1);
+            assert.strictEqual(children[0].type, DeepnoteTreeItemType.Loading);
+            assert.strictEqual(children[0].contextValue, 'loading');
+        });
+
+        test('should create loading item with correct properties', async () => {
+            const children = await provider.getChildren();
+            const loadingItem = children[0];
+
+            assert.strictEqual(loadingItem.type, DeepnoteTreeItemType.Loading);
+            assert.strictEqual(loadingItem.label, 'Scanning for Deepnote projects...');
+            assert.strictEqual(loadingItem.collapsibleState, 0); // TreeItemCollapsibleState.None
+            assert.strictEqual(loadingItem.data, null);
+            assert.isDefined(loadingItem.iconPath);
+        });
+
+        test('should not show loading item after initial scan completes', async () => {
+            const firstChildren = await provider.getChildren();
+            assert.strictEqual(firstChildren.length, 1);
+            assert.strictEqual(firstChildren[0].type, DeepnoteTreeItemType.Loading);
+
+            // Wait for the scan to complete - give it time to finish
+            await new Promise((resolve) => setTimeout(resolve, 100));
+
+            const secondChildren = await provider.getChildren();
+            assert.isArray(secondChildren);
+
+            if (secondChildren.length > 0) {
+                assert.notStrictEqual(secondChildren[0].type, DeepnoteTreeItemType.Loading);
+            }
+        });
+
+        test('should reset loading state on refresh', async () => {
+            const firstChildren = await provider.getChildren();
+            assert.strictEqual(firstChildren[0].type, DeepnoteTreeItemType.Loading);
+
+            await new Promise((resolve) => setTimeout(resolve, 100));
+
+            const afterScan = await provider.getChildren();
+            if (afterScan.length > 0) {
+                assert.notStrictEqual(afterScan[0].type, DeepnoteTreeItemType.Loading);
+            }
+
+            // Call refresh to reset state, should show loading again
+            provider.refresh();
+            const afterRefresh = await provider.getChildren();
+            assert.isArray(afterRefresh);
+            assert.strictEqual(afterRefresh.length, 1);
+            assert.strictEqual(afterRefresh[0].type, DeepnoteTreeItemType.Loading);
+        });
+
+        test('should handle multiple concurrent getChildren calls during initial scan', async () => {
+            const promise1 = provider.getChildren();
+            const promise2 = provider.getChildren();
+            const promise3 = provider.getChildren();
+
+            const [children1, children2, children3] = await Promise.all([promise1, promise2, promise3]);
+
+            // All should return loading item
+            assert.strictEqual(children1.length, 1);
+            assert.strictEqual(children1[0].type, DeepnoteTreeItemType.Loading);
+
+            assert.strictEqual(children2.length, 1);
+            assert.strictEqual(children2[0].type, DeepnoteTreeItemType.Loading);
+
+            assert.strictEqual(children3.length, 1);
+            assert.strictEqual(children3[0].type, DeepnoteTreeItemType.Loading);
+        });
+
+        test('should not show loading item when called with parent element', async () => {
+            const mockProjectItem = new DeepnoteTreeItem(
+                DeepnoteTreeItemType.ProjectFile,
+                {
+                    filePath: '/workspace/project.deepnote',
+                    projectId: 'project-123'
+                },
+                mockProject,
+                1 // TreeItemCollapsibleState.Collapsed
+            );
+
+            // Even during initial scan, should not show loading for children of a project
+            const children = await provider.getChildren(mockProjectItem);
+
+            assert.isArray(children);
+
+            children.forEach((child) => {
+                assert.notStrictEqual(child.type, DeepnoteTreeItemType.Loading);
+            });
+        });
+    });
+
     suite('integration scenarios', () => {
         test('should maintain independence between multiple providers', () => {
             const provider1 = new DeepnoteTreeDataProvider();

src/notebooks/deepnote/deepnoteTreeItem.unit.test.ts

@@ -579,6 +579,98 @@ suite('DeepnoteTreeItem', () => {
         });
     });
 
+    suite('Loading type', () => {
+        test('should create loading item with null data', () => {
+            const context: DeepnoteTreeItemContext = {
+                filePath: '',
+                projectId: ''
+            };
+
+            const item = new DeepnoteTreeItem(
+                DeepnoteTreeItemType.Loading,
+                context,
+                null,
+                TreeItemCollapsibleState.None
+            );
+
+            assert.strictEqual(item.type, DeepnoteTreeItemType.Loading);
+            assert.strictEqual(item.data, null);
+            assert.strictEqual(item.collapsibleState, TreeItemCollapsibleState.None);
+            assert.strictEqual(item.contextValue, 'loading');
+        });
+
+        test('should not initialize label/tooltip/icon for loading items', () => {
+            const context: DeepnoteTreeItemContext = {
+                filePath: '',
+                projectId: ''
+            };
+
+            const item = new DeepnoteTreeItem(
+                DeepnoteTreeItemType.Loading,
+                context,
+                null,
+                TreeItemCollapsibleState.None
+            );
+
+            // Label, iconPath, tooltip should be undefined or empty until manually set
+            // (they are not initialized in constructor for loading items)
+            assert.strictEqual(item.label, '');
+        });
+
+        test('should allow manual label and icon assignment for loading items', () => {
+            const context: DeepnoteTreeItemContext = {
+                filePath: '',
+                projectId: ''
+            };
+
+            const item = new DeepnoteTreeItem(
+                DeepnoteTreeItemType.Loading,
+                context,
+                null,
+                TreeItemCollapsibleState.None
+            );
+
+            item.label = 'Scanning for Deepnote projects...';
+            item.iconPath = new ThemeIcon('loading~spin');
+
+            assert.strictEqual(item.label, 'Scanning for Deepnote projects...');
+            assert.instanceOf(item.iconPath, ThemeIcon);
+            assert.strictEqual((item.iconPath as ThemeIcon).id, 'loading~spin');
+        });
+
+        test('should not have command for loading items', () => {
+            const context: DeepnoteTreeItemContext = {
+                filePath: '',
+                projectId: ''
+            };
+
+            const item = new DeepnoteTreeItem(
+                DeepnoteTreeItemType.Loading,
+                context,
+                null,
+                TreeItemCollapsibleState.None
+            );
+
+            assert.isUndefined(item.command);
+        });
+
+        test('should not have resourceUri for loading items', () => {
+            const context: DeepnoteTreeItemContext = {
+                filePath: '',
+                projectId: ''
+            };
+
+            const item = new DeepnoteTreeItem(
+                DeepnoteTreeItemType.Loading,
+                context,
+                null,
+                TreeItemCollapsibleState.None
+            );
+
+            assert.isUndefined(item.resourceUri);
+        });
+    });
+
     suite('integration scenarios', () => {
         test('should create valid tree structure hierarchy', () => {
             // Create parent project file