fix(tree-explorer): update tests to use inspect and check for global and workspace settings

Author: gagik

src/storage/connectionStorage.ts

@@ -191,14 +191,14 @@ export class ConnectionStorage {
     }
 
     const combinedPresetSavedConnections: PresetSavedConnectionWithSource[] = [
-      ...(presetSavedConnectionsInfo?.workspaceValue ?? []).map((preset) => ({
-        ...preset,
-        source: 'workspaceSettings' as const,
-      })),
       ...(presetSavedConnectionsInfo?.globalValue ?? []).map((preset) => ({
         ...preset,
         source: 'globalSettings' as const,
       })),
+      ...(presetSavedConnectionsInfo?.workspaceValue ?? []).map((preset) => ({
+        ...preset,
+        source: 'workspaceSettings' as const,
+      })),
     ];
 
     return combinedPresetSavedConnections.map((presetConnection) => ({
@@ -252,7 +252,7 @@ export class ConnectionStorage {
 
     const presetSavedConnections = this._loadPresetSavedConnections();
 
-    return [...presetSavedConnections, ...loadedConnections];
+    return [...loadedConnections, ...presetSavedConnections];
   }
 
   async removeConnection(connectionId: string): Promise<void> {

src/test/suite/storage/connectionStorage.test.ts

@@ -324,6 +324,12 @@ suite('Connection Storage Test Suite', function () {
 
     suite('when there are preset connections', () => {
       const presetConnections = {
+        globalValue: [
+          {
+            name: 'Global Connection 1',
+            connectionString: 'mongodb://localhost:27017/',
+          },
+        ],
         workspaceValue: [
           {
             name: 'Preset Connection 1',
@@ -343,11 +349,11 @@ suite('Connection Storage Test Suite', function () {
         ],
         vscode.WorkspaceConfiguration
       >;
-      let getPresetSavedConnectionsStub: sinon.SinonStub;
+      let inspectPresetSavedConnectionsStub: sinon.SinonStub;
 
       beforeEach(() => {
         testSandbox.restore();
-        getPresetSavedConnectionsStub = testSandbox.stub();
+        inspectPresetSavedConnectionsStub = testSandbox.stub();
       });
 
       test('loads the preset connections', async () => {
@@ -356,25 +362,39 @@ suite('Connection Storage Test Suite', function () {
           'getConfiguration'
         );
         getConfigurationStub.returns({
-          inspect: getPresetSavedConnectionsStub,
+          inspect: inspectPresetSavedConnectionsStub,
+          get: () => undefined,
         } as any);
 
-        getPresetSavedConnectionsStub
+        inspectPresetSavedConnectionsStub
           .withArgs('presetSavedConnections')
           .returns(presetConnections);
 
-        const connections = await testConnectionStorage.loadConnections();
+        const loadedConnections = await testConnectionStorage.loadConnections();
 
-        expect(connections.length).to.equal(2);
+        const expectedConnectionValues = [
+          ...presetConnections.globalValue.map((connection) => ({
+            ...connection,
+            source: 'globalSettings',
+          })),
+          ...presetConnections.workspaceValue.map((connection) => ({
+            ...connection,
+            source: 'workspaceSettings',
+          })),
+        ];
+
+        expect(loadedConnections.length).equals(
+          expectedConnectionValues.length
+        );
 
-        for (let i = 0; i < connections.length; i++) {
-          const connection = connections[i];
-          const presetConnection = presetConnections[i];
-          expect(connection.name).equals(presetConnection.name);
-          expect(connection.connectionOptions.connectionString).equals(
-            presetConnection.connectionString
+        for (let i = 0; i < expectedConnectionValues.length; i++) {
+          const connection = loadedConnections[i];
+          const expected = expectedConnectionValues[i];
+          expect(connection.name).equals(expected.name);
+          expect(connection.connectionOptions.connectionString).contains(
+            expected.connectionString
           );
-          expect(connection.source).equals('workspaceSettings');
+          expect(connection.source).equals(expected.source);
         }
       });
 
@@ -387,34 +407,46 @@ suite('Connection Storage Test Suite', function () {
           'getConfiguration'
         );
         getConfigurationStub.returns({
-          get: getPresetSavedConnectionsStub,
+          inspect: inspectPresetSavedConnectionsStub,
+          get: () => undefined,
         } as any);
 
-        getPresetSavedConnectionsStub
+        inspectPresetSavedConnectionsStub
           .withArgs('presetSavedConnections')
           .returns(presetConnections);
 
         const loadedConnections = await testConnectionStorage.loadConnections();
 
-        expect(loadedConnections.length).equals(3);
+        const expectedConnectionValues = [
+          {
+            name: savedConnection.name,
+            source: 'user',
+            connectionString:
+              savedConnection.connectionOptions.connectionString,
+          },
+          ...presetConnections.globalValue.map((connection) => ({
+            ...connection,
+            source: 'globalSettings',
+          })),
+          ...presetConnections.workspaceValue.map((connection) => ({
+            ...connection,
+            source: 'workspaceSettings',
+          })),
+        ];
+
+        expect(loadedConnections.length).equals(
+          expectedConnectionValues.length
+        );
 
-        for (let i = 0; i < presetConnections.workspaceValue.length; i++) {
+        for (let i = 0; i < expectedConnectionValues.length; i++) {
           const connection = loadedConnections[i];
-          const presetConnection = presetConnections[i];
-          expect(connection.name).equals(presetConnection.name);
-          expect(connection.connectionOptions.connectionString).equals(
-            presetConnection.connectionString
+          const expected = expectedConnectionValues[i];
+          expect(connection.name).equals(expected.name);
+          expect(connection.connectionOptions.connectionString).contains(
+            expected.connectionString
           );
-          expect(connection.source).equals('workspaceSettings');
+          expect(connection.source).equals(expected.source);
         }
-
-        const savedLoadedConnection = loadedConnections[2];
-
-        expect(savedLoadedConnection.name).equals(savedConnection.name);
-        expect(
-          savedLoadedConnection.connectionOptions.connectionString
-        ).contains(savedConnection.connectionOptions.connectionString);
-        expect(savedLoadedConnection.source).equals('workspaceSettings');
       });
     });