test-verifier

Author: eleanorjboyd

src/test/e2e/environmentDiscovery.e2e.test.ts

@@ -68,8 +68,22 @@ suite('E2E: Environment Discovery', function () {
             return;
         }
 
-        // This should complete without throwing
+        // Capture state before refresh to verify API is callable
+        const beforeRefresh = await api.getEnvironments('all');
+        assert.ok(Array.isArray(beforeRefresh), 'Should get environments before refresh');
+
+        // Trigger refresh - this should complete without throwing
         await api.refreshEnvironments(undefined);
+
+        // Verify API still works after refresh (observable side effect: API remains functional)
+        const afterRefresh = await api.getEnvironments('all');
+        assert.ok(Array.isArray(afterRefresh), 'Should get environments after refresh');
+
+        // Environments should still be available after refresh
+        // (count may change if discovery finds more, but should not lose all)
+        if (beforeRefresh.length > 0) {
+            assert.ok(afterRefresh.length > 0, 'Should not lose all environments after refresh');
+        }
     });
 
     /**
@@ -117,20 +131,43 @@ suite('E2E: Environment Discovery', function () {
 
         const env = environments[0] as Record<string, unknown>;
 
-        // Check required properties exist
-        // These are the minimum properties an environment should have
+        // Check required properties exist AND have valid values
         // PythonEnvironment has envId (a PythonEnvironmentId object), not id directly
         assert.ok('envId' in env, 'Environment should have an envId property');
+        assert.ok(env.envId !== null && env.envId !== undefined, 'envId should not be null/undefined');
+
+        // Verify envId structure
+        const envId = env.envId as Record<string, unknown>;
+        assert.strictEqual(typeof envId, 'object', 'envId should be an object');
+        assert.ok('id' in envId, 'envId should have an id property');
+        assert.strictEqual(typeof envId.id, 'string', 'envId.id should be a string');
+        assert.ok((envId.id as string).length > 0, 'envId.id should not be empty');
+        assert.ok('managerId' in envId, 'envId should have a managerId property');
+
+        // Verify name exists and is a string
         assert.ok('name' in env, 'Environment should have a name property');
+        assert.strictEqual(typeof env.name, 'string', 'name should be a string');
+
+        // Verify displayName exists and is a string
         assert.ok('displayName' in env, 'Environment should have a displayName property');
+        assert.strictEqual(typeof env.displayName, 'string', 'displayName should be a string');
 
-        // If execInfo exists, it should have expected shape
+        // If execInfo exists, it should have expected shape with valid values
         if ('execInfo' in env && env.execInfo) {
             const execInfo = env.execInfo as Record<string, unknown>;
+            assert.strictEqual(typeof execInfo, 'object', 'execInfo should be an object');
             assert.ok(
                 'run' in execInfo || 'activatedRun' in execInfo,
                 'execInfo should have run or activatedRun property',
             );
+
+            // Verify run command structure if present
+            if ('run' in execInfo && execInfo.run) {
+                const run = execInfo.run as Record<string, unknown>;
+                assert.ok('executable' in run, 'run should have an executable property');
+                assert.strictEqual(typeof run.executable, 'string', 'executable should be a string');
+                assert.ok((run.executable as string).length > 0, 'executable should not be empty');
+            }
         }
     });
 
@@ -147,5 +184,27 @@ suite('E2E: Environment Discovery', function () {
 
         // Verify it returns an array
         assert.ok(Array.isArray(globalEnvs), 'getEnvironments should return an array');
+
+        // If there are global envs, verify they have valid structure
+        if (globalEnvs.length > 0) {
+            const env = globalEnvs[0] as Record<string, unknown>;
+
+            // Global environments should have the same structure as all environments
+            assert.ok('envId' in env || 'id' in env, 'Global environment should have an identifier');
+
+            // Verify envId is properly structured if present
+            if ('envId' in env && env.envId) {
+                const envId = env.envId as Record<string, unknown>;
+                assert.strictEqual(typeof envId, 'object', 'envId should be an object');
+                assert.ok('id' in envId, 'envId should have an id property');
+            }
+        }
+
+        // Global envs should be a subset of all envs
+        const allEnvs = await api.getEnvironments('all');
+        assert.ok(
+            globalEnvs.length <= allEnvs.length,
+            `Global envs (${globalEnvs.length}) should not exceed all envs (${allEnvs.length})`,
+        );
     });
 });

src/test/integration/envManagerApi.integration.test.ts

@@ -69,9 +69,8 @@ suite('Integration: Environment Manager + API', function () {
         // Get state after refresh
         const afterRefresh = await api.getEnvironments('all');
 
-        // State should be consistent (same or more environments)
-        // We can't assert exact equality since discovery might find more
-        assert.ok(afterRefresh.length >= 0, `Expected environments array, got ${typeof afterRefresh}`);
+        // Verify we got an actual array back (not undefined, null, or other type)
+        assert.ok(Array.isArray(afterRefresh), `Expected environments array, got ${typeof afterRefresh}`);
 
         // Verify the API returns consistent data on repeated calls
         const secondCall = await api.getEnvironments('all');
@@ -151,16 +150,37 @@ suite('Integration: Environment Manager + API', function () {
             return;
         }
 
-        // Check each environment has basic required properties
+        // Check each environment has basic required properties with valid values
         for (const env of environments) {
             const e = env as Record<string, unknown>;
 
             // Must have some form of identifier
             assert.ok('id' in e || 'envId' in e, 'Environment must have id or envId');
 
-            // If it has an id, it should be a string
+            // If it has an id, it should be a non-empty string
             if ('id' in e) {
                 assert.strictEqual(typeof e.id, 'string', 'Environment id should be a string');
+                assert.ok((e.id as string).length > 0, 'Environment id should not be empty');
+            }
+
+            // If it has envId, verify it's a valid object with required properties
+            if ('envId' in e && e.envId !== null && e.envId !== undefined) {
+                const envId = e.envId as Record<string, unknown>;
+                assert.strictEqual(typeof envId, 'object', 'envId should be an object');
+                assert.ok('id' in envId, 'envId should have an id property');
+                assert.ok('managerId' in envId, 'envId should have a managerId property');
+                assert.strictEqual(typeof envId.id, 'string', 'envId.id should be a string');
+                assert.ok((envId.id as string).length > 0, 'envId.id should not be empty');
+            }
+
+            // Verify name is a non-empty string if present
+            if ('name' in e && e.name !== undefined) {
+                assert.strictEqual(typeof e.name, 'string', 'Environment name should be a string');
+            }
+
+            // Verify displayName is a non-empty string if present
+            if ('displayName' in e && e.displayName !== undefined) {
+                assert.strictEqual(typeof e.displayName, 'string', 'Environment displayName should be a string');
             }
         }
     });