chore: use vscode.glob instead of glob

e2e/wdio.conf.ts

@@ -83,8 +83,8 @@ export function createBaseConfig(workspacePath: string, userSettings = {}): Webd
             if (process.platform === 'linux') {
                 const result = shell.exec('xdotool search --onlyvisible --name code')
                 const windowId = result.stdout.trim()
-                shell.exec(`xdotool windowmove ${windowId} 0 0`)
-                shell.exec(`xdotool windowsize ${windowId} 100% 100%`)
+                shell.exec(`xdotool windowmove ${windowId} 0 0`, { silent: true })
+                shell.exec(`xdotool windowsize ${windowId} 100% 100%`, { silent: true })
             }
         },
         afterTest: async function (_test: unknown, _context: unknown, result: Frameworks.TestResult) {

packages/vscode-wdio-config/package.json

@@ -17,8 +17,7 @@
   "dependencies": {
     "@vscode-wdio/constants": "workspace:*",
     "@vscode-wdio/logger": "workspace:*",
-    "@vscode-wdio/utils": "workspace:*",
-    "glob": "^11.0.1"
+    "@vscode-wdio/utils": "workspace:*"
   },
   "devDependencies": {
     "@vscode-wdio/types": "workspace:*"

packages/vscode-wdio-config/src/find.ts

@@ -1,24 +1,23 @@
 import fs from 'node:fs/promises'
-import path from 'node:path'
 
 import { log } from '@vscode-wdio/logger'
 import { normalizePath } from '@vscode-wdio/utils'
-import { glob } from 'glob'
+import * as vscode from 'vscode'
 
 export async function findWdioConfig(workSpaceRoot: string, configFilePattern: string[]) {
     log.debug(`Target workspace path: ${workSpaceRoot}`)
     log.debug(`Detecting the configuration file for WebdriverIO...: ${configFilePattern.join(', ')}`)
+    const globResult = await Promise.all(
+        configFilePattern.map((p) =>
+            vscode.workspace.findFiles(new vscode.RelativePattern(workSpaceRoot, p), '**/node_modules/**')
+        )
+    )
 
-    const wdioConfigPaths = await glob(configFilePattern, {
-        cwd: workSpaceRoot,
-        withFileTypes: false,
-        ignore: '**/node_modules/**',
-    })
+    const wdioConfigPaths = globResult.flatMap((uri) => uri).map((uri) => uri.fsPath)
 
     const configs = (
         await Promise.all(
-            wdioConfigPaths.map(async (_wdioConfigPath) => {
-                const wdioConfigPath = path.join(workSpaceRoot, _wdioConfigPath)
+            wdioConfigPaths.map(async (wdioConfigPath) => {
                 log.debug(`Checking the path: ${wdioConfigPath}`)
                 try {
                     await fs.access(wdioConfigPath, fs.constants.R_OK)

packages/vscode-wdio-config/tests/find.test.ts

@@ -1,16 +1,25 @@
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
-import { glob } from 'glob'
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import * as vscode from 'vscode'
 
 import { findWdioConfig } from '../src/find.js'
 
 // Mock dependencies
 vi.mock('node:fs/promises')
 vi.mock('glob')
 
-vi.mock('vscode', async () => import('../../../tests/__mocks__/vscode.cjs'))
+vi.mock('vscode', async () => {
+    const vscode = await import('../../../tests/__mocks__/vscode.cjs')
+    return {
+        ...vscode,
+        RelativePattern: vi.fn(),
+        workspace: {
+            findFiles: vi.fn(),
+        },
+    }
+})
 vi.mock('@vscode-wdio/logger', () => import('../../../tests/__mocks__/logger.js'))
 
 describe('findWdioConfig', () => {
@@ -19,6 +28,13 @@ describe('findWdioConfig', () => {
 
     beforeEach(() => {
         vi.resetAllMocks()
+        vi.mocked(vscode.RelativePattern).mockImplementation(function (this: any, r: unknown, p: string) {
+            this.path = p
+            this.root = r
+            this.toString = function () {
+                return path.join(this.root, this.path)
+            }
+        } as any)
     })
 
     afterEach(() => {
@@ -30,9 +46,9 @@ describe('findWdioConfig', () => {
         const mockConfigFiles = ['wdio.conf.js', 'wdio.conf.ts']
         const expectedPaths = mockConfigFiles.map((file) => path.join(mockWorkspaceRoot, file))
 
-        // Mock glob to return the config files
-        vi.mocked(glob).mockResolvedValue(mockConfigFiles)
-
+        vi.mocked(vscode.workspace.findFiles).mockImplementation(async (p: vscode.GlobPattern) => {
+            return [vscode.Uri.file(p.toString())]
+        })
         // Mock fs.access to succeed for all files
         vi.mocked(fs.access).mockResolvedValue(undefined)
 
@@ -41,21 +57,16 @@ describe('findWdioConfig', () => {
 
         // Verify
         expect(result).toEqual(expectedPaths)
-        expect(glob).toHaveBeenCalledWith(defaultConfigFilePattern, {
-            cwd: mockWorkspaceRoot,
-            withFileTypes: false,
-            ignore: '**/node_modules/**',
-        })
         expect(fs.access).toHaveBeenCalledTimes(2)
     })
 
     it('should filter out inaccessible files', async () => {
         // Setup
-        const mockConfigFiles = ['wdio.conf.js', 'wdio.conf.ts']
         const accessibleFile = path.join(mockWorkspaceRoot, 'wdio.conf.js')
 
-        // Mock glob to return the config files
-        vi.mocked(glob).mockResolvedValue(mockConfigFiles)
+        vi.mocked(vscode.workspace.findFiles).mockImplementation(async (p: vscode.GlobPattern) => {
+            return [vscode.Uri.file(p.toString())]
+        })
 
         // Mock fs.access to succeed only for the JS file
         vi.mocked(fs.access).mockImplementation(async (filePath) => {
@@ -75,10 +86,9 @@ describe('findWdioConfig', () => {
 
     it('should return empty array when no config files are accessible', async () => {
         // Setup
-        const mockConfigFiles = ['wdio.conf.js', 'wdio.conf.ts']
-
-        // Mock glob to return the config files
-        vi.mocked(glob).mockResolvedValue(mockConfigFiles)
+        vi.mocked(vscode.workspace.findFiles).mockImplementation(async (p: vscode.GlobPattern) => {
+            return [vscode.Uri.file(p.toString())]
+        })
 
         // Mock fs.access to fail for all files
         vi.mocked(fs.access).mockRejectedValue(new Error('File not found'))
@@ -93,8 +103,7 @@ describe('findWdioConfig', () => {
 
     it('should handle empty glob results', async () => {
         // Setup
-        // Mock glob to return no files
-        vi.mocked(glob).mockResolvedValue([])
+        vi.mocked(vscode.workspace.findFiles).mockResolvedValue([])
 
         // Execute
         const result = await findWdioConfig(mockWorkspaceRoot, defaultConfigFilePattern)
@@ -103,28 +112,4 @@ describe('findWdioConfig', () => {
         expect(result).toEqual([])
         expect(fs.access).not.toHaveBeenCalled()
     })
-
-    it('should use custom config file pattern when provided', async () => {
-        // Setup
-        const customConfigPattern = ['custom.wdio.conf.js']
-        const mockConfigFiles = ['custom.wdio.conf.js']
-        const expectedPaths = mockConfigFiles.map((file) => path.join(mockWorkspaceRoot, file))
-
-        // Mock glob to return the config files
-        vi.mocked(glob).mockResolvedValue(mockConfigFiles)
-
-        // Mock fs.access to succeed
-        vi.mocked(fs.access).mockResolvedValue(undefined)
-
-        // Execute
-        const result = await findWdioConfig(mockWorkspaceRoot, customConfigPattern)
-
-        // Verify
-        expect(result).toEqual(expectedPaths)
-        expect(glob).toHaveBeenCalledWith(customConfigPattern, {
-            cwd: mockWorkspaceRoot,
-            withFileTypes: false,
-            ignore: '**/node_modules/**',
-        })
-    })
 })