[DO NOT MERGE] Display only attachable clusters (#116)

Fixes #21 

Wait for #118 (adds
Permissions API) to merge



https://user-images.githubusercontent.com/88345179/194365639-36dc4f38-4f6b-4d3d-9e9d-d2c88327d971.mov

Author: kartikgupta-db

packages/databricks-vscode/src/cluster/ClusterListDataProvider.test.ts

@@ -45,7 +45,7 @@ describe(__filename, () => {
             };
         });
         let apiClient = instance(mock(ApiClient));
-        when(mockedClusterModel.roots).thenResolve(
+        when(mockedClusterModel.roots).thenReturn(
             mockListClustersResponse.clusters!.map(
                 (m: any) => new Cluster(apiClient, m)
             )
@@ -99,20 +99,6 @@ describe(__filename, () => {
         assert.equal(children.length, 4);
     });
 
-    it("should return placeholder if list is empty", async () => {
-        when(mockedClusterModel.roots).thenResolve([]);
-
-        let model = instance(mockedClusterModel);
-        let provider = new ClusterListDataProvider(model);
-        disposables.push(provider);
-
-        let children = await resolveProviderResult(provider.getChildren());
-        assert(children);
-        assert.equal(children.length, 1);
-        assert(children[0] instanceof TreeItem);
-        assert.equal(children[0].label, "No clusters found");
-    });
-
     it("should get cluster tree node items", () => {
         let cluster = new Cluster(
             instance(mock(ApiClient)),

packages/databricks-vscode/src/cluster/ClusterListDataProvider.ts

@@ -30,8 +30,8 @@ export class ClusterListDataProvider
             model.onDidChange(() => {
                 this._onDidChangeTreeData.fire();
             }),
-            this.autoReload(15000),
         ];
+        this.model.refresh();
     }
 
     dispose() {
@@ -54,17 +54,6 @@ export class ClusterListDataProvider
         return (element as Cluster).state !== undefined;
     }
 
-    private autoReload(refreshRateInMs: number): Disposable {
-        let interval = setInterval(() => {
-            this.model.refresh();
-        }, refreshRateInMs);
-        return {
-            dispose() {
-                clearInterval(interval);
-            },
-        };
-    }
-
     getChildren(
         element?: Cluster | TreeItem | undefined
     ): ProviderResult<Array<Cluster | TreeItem>> {
@@ -75,13 +64,8 @@ export class ClusterListDataProvider
                 return [];
             }
         } else {
-            return (async () => {
-                let roots = await this.model.roots;
-                if (roots && roots.length === 0) {
-                    return [new TreeItem("No clusters found")];
-                } else {
-                    return roots;
-                }
+            return (() => {
+                return this.model.roots;
             })();
         }
     }

packages/databricks-vscode/src/cluster/ClusterLoader.test.ts

@@ -0,0 +1,135 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import {ApiClient, cluster, permissions} from "@databricks/databricks-sdk";
+import {ScimMeResponse} from "@databricks/databricks-sdk/dist/apis/scim";
+import assert from "assert";
+import {anyString, anything, instance, mock, spy, when} from "ts-mockito";
+import {ConnectionManager} from "../configuration/ConnectionManager";
+import {ClusterLoader} from "./ClusterLoader";
+
+const me: ScimMeResponse = {
+    entitlements: [],
+    groups: [
+        {
+            value: "group-1",
+            display: "group-1",
+        },
+    ],
+    userName: "user-1",
+    roles: [],
+    schemas: [],
+};
+const mockListClustersResponse: cluster.ListClustersResponse = {
+    clusters: [
+        {
+            cluster_id: "cluster-id-2",
+            cluster_name: "cluster-name-2",
+            cluster_source: "UI",
+            creator_user_name: "user-2",
+            state: "TERMINATED",
+        },
+        {
+            cluster_id: "cluster-id-1",
+            cluster_name: "cluster-name-1",
+            cluster_source: "UI",
+            creator_user_name: me.userName,
+            state: "RUNNING",
+        },
+        {
+            cluster_id: "cluster-id-3",
+            cluster_name: "cluster-name-3",
+            cluster_source: "API",
+            creator_user_name: me.userName,
+            state: "RUNNING",
+        },
+        {
+            cluster_id: "cluster-id-5",
+            cluster_name: "cluster-name-5",
+            cluster_source: "JOB",
+            creator_user_name: me.userName,
+            state: "RUNNING",
+        },
+        {
+            cluster_id: "cluster-id-4",
+            cluster_name: "cluster-name-4",
+            cluster_source: "API",
+            creator_user_name: "user-2",
+            state: "RUNNING",
+            single_user_name: me.userName,
+            data_security_mode: "SINGLE_USER",
+        },
+    ],
+};
+
+const mockClusterPermissions: Map<string, permissions.ObjectPermissions> =
+    new Map([
+        [
+            "cluster-id-1",
+            {
+                access_control_list: [{user_name: me.userName}],
+            },
+        ],
+        [
+            "cluster-id-2",
+            {
+                access_control_list: [{group_name: me.groups[0].display}],
+            },
+        ],
+        [
+            "cluster-id-3",
+            {
+                access_control_list: [],
+            },
+        ],
+        [
+            "cluster-id-4",
+            {
+                access_control_list: [{group_name: me.groups[0].display}],
+            },
+        ],
+    ]);
+describe(__filename, () => {
+    let mockedConnectionManager: ConnectionManager;
+    let mockedApiClient: ApiClient;
+
+    beforeEach(() => {
+        mockedConnectionManager = mock(ConnectionManager);
+        mockedApiClient = mock<ApiClient>();
+        when<cluster.ListClustersResponse>(
+            mockedApiClient.request(
+                "/api/2.0/clusters/list",
+                "GET",
+                anything(),
+                anything()
+            )
+        ).thenResolve(mockListClustersResponse);
+        when(mockedConnectionManager.apiClient).thenReturn(
+            instance(mockedApiClient)
+        );
+        for (let [id, perms] of mockClusterPermissions.entries()) {
+            when<permissions.ObjectPermissions>(
+                mockedApiClient.request(
+                    `/api/2.0/permissions/clusters/${id}`,
+                    "GET",
+                    anything(),
+                    anything()
+                )
+            ).thenResolve(perms);
+        }
+        when(mockedConnectionManager.me).thenReturn(me.userName);
+        when(mockedConnectionManager.meDetails).thenReturn(me);
+    });
+
+    it("should only load accessible clusters", async () => {
+        const loader = spy(
+            new ClusterLoader(instance(mockedConnectionManager))
+        );
+        when(loader.running).thenReturn(true);
+        when(loader.stopped).thenReturn(false);
+        instance(loader)._load();
+        for (let [id, _] of instance(loader).clusters.entries()) {
+            assert.ok(
+                ["cluster-id-2", "cluster-id-1", "cluster-id-4"].includes(id)
+            );
+        }
+    });
+});