fix(cli): properly check and find the config file (webdriverio#14229)

* fix: add checks for file paths containing extensions

* test: add test for `canAccessConfigPath`

* test: adjust mocking for run command

Author: mato533

packages/wdio-cli/src/commands/config.ts

@@ -193,17 +193,25 @@ export async function formatConfigFilePaths(config: string) {
 
 /**
  * Helper utility used in `run` and `install` command to check whether a config file currently exists
- * @param configPath the file path to the WDIO config file
+ * @param configPathNoExtension the file path to the WDIO config file without extension
+ * @param configPath the file path to the WDIO config file that is checked first if set
  * @returns {string} the path to the config file that exists, otherwise undefined
  */
-export async function canAccessConfigPath(configPath: string) {
-    return Promise.all(SUPPORTED_CONFIG_FILE_EXTENSION.map(async (supportedExtension) => {
-        const configPathWithExtension = `${configPath}.${supportedExtension}`
+export async function canAccessConfigPath(configPathNoExtension:string, configPath?:string) {
+    return new Promise<string | undefined>((resolve, reject)=>{
+        if (configPath) {
+            const _configPath = configPath
+            fs.access(_configPath).then(()=>resolve(_configPath), reject)
+        } else {
+            reject()
+        }
+    }).catch(()=>Promise.all(SUPPORTED_CONFIG_FILE_EXTENSION.map(async (supportedExtension) => {
+        const configPathWithExtension = `${configPathNoExtension}.${supportedExtension}`
         return fs.access(configPathWithExtension).then(() => configPathWithExtension, () => undefined)
     })).then(
         (configFilePaths) => configFilePaths.find(Boolean),
         () => undefined
-    )
+    ))
 }
 
 /**

packages/wdio-cli/src/commands/run.ts

@@ -176,7 +176,7 @@ export async function handler(argv: RunCommandArguments) {
     const { configPath = 'wdio.conf.js', ...params } = argv
 
     const wdioConf = await formatConfigFilePaths(configPath)
-    const confAccess = await canAccessConfigPath(wdioConf.fullPathNoExtension)
+    const confAccess = await canAccessConfigPath(wdioConf.fullPathNoExtension, wdioConf.fullPath)
     if (!confAccess) {
         try {
             await missingConfigurationPrompt('run', wdioConf.fullPathNoExtension)

packages/wdio-cli/tests/commands/config.test.ts

@@ -172,17 +172,45 @@ test('missingConfigurationPrompt does run config if user agrees', async () => {
     expect(runConfigCmd).toBeCalledTimes(1)
 })
 
-test('canAccessConfigPath', async () => {
-    vi.mocked(fs.access)
-        .mockRejectedValueOnce(new Error('not found'))
-        .mockRejectedValueOnce(new Error('not found'))
-        .mockRejectedValueOnce(new Error('not found'))
-        .mockResolvedValue('Yay' as any)
-    expect(await canAccessConfigPath('/foo/bar')).toBe('/foo/bar.mts')
-    expect(fs.access).toBeCalledWith('/foo/bar.js')
-    expect(fs.access).toBeCalledWith('/foo/bar.ts')
-    expect(fs.access).toBeCalledWith('/foo/bar.mjs')
-    expect(fs.access).toBeCalledWith('/foo/bar.mts')
+describe('canAccessConfigPath', () => {
+    beforeEach(()=>{
+        vi.mocked(fs.access).mockClear()
+    })
+    test('no extension only', async () => {
+        vi.mocked(fs.access)
+            .mockRejectedValueOnce(new Error('not found'))
+            .mockRejectedValueOnce(new Error('not found'))
+            .mockRejectedValueOnce(new Error('not found'))
+            .mockResolvedValue('Yay' as any)
+        expect(await canAccessConfigPath('/foo/bar')).toBe('/foo/bar.mts')
+        expect(fs.access).not.toBeCalledWith('/foo/bar')
+        expect(fs.access).toBeCalledWith('/foo/bar.js')
+        expect(fs.access).toBeCalledWith('/foo/bar.ts')
+        expect(fs.access).toBeCalledWith('/foo/bar.mjs')
+        expect(fs.access).toBeCalledWith('/foo/bar.mts')
+    })
+
+    test('with full path of the existed file', async () => {
+        vi.mocked(fs.access)
+            .mockResolvedValue('Yay' as any)
+        expect(await canAccessConfigPath('/foo/bar', '/foo/bar.ts')).toBe('/foo/bar.ts')
+        expect(fs.access).toHaveBeenCalledTimes(1)
+        expect(fs.access).toBeCalledWith('/foo/bar.ts')
+    })
+
+    test('with full path of the not existed file', async () => {
+        vi.mocked(fs.access)
+            .mockRejectedValueOnce(new Error('not found'))
+            .mockRejectedValueOnce(new Error('not found'))
+            .mockRejectedValueOnce(new Error('not found'))
+            .mockRejectedValueOnce(new Error('not found'))
+            .mockResolvedValue('Yay' as any)
+        expect(await canAccessConfigPath('/foo/bar', '/foo/bar.ts')).toBe('/foo/bar.mts')
+        expect(fs.access).toBeCalledWith('/foo/bar.js')
+        expect(fs.access).toBeCalledWith('/foo/bar.ts')
+        expect(fs.access).toBeCalledWith('/foo/bar.mjs')
+        expect(fs.access).toBeCalledWith('/foo/bar.mts')
+    })
 })
 
 describe('Serenity/JS project generation', () => {

packages/wdio-cli/tests/commands/run.test.ts

@@ -66,7 +66,9 @@ describe('Command: run', () => {
     })
 
     it('should check for js and ts default config files', async () => {
-        vi.mocked(fs.access).mockRejectedValueOnce('not found')
+        vi.mocked(fs.access)
+            .mockRejectedValueOnce('not found')
+            .mockRejectedValueOnce('not found')
         const result = await runCmd.handler({ configPath: 'sample.conf.js' } as any)
         expect(result).toContain('sample.conf.ts')
     })