Allow verbose logging for VSCode extension host (#8)

* debug caps

* test for notification

* fix assertion

* enable verbose logging

* elliminate dashes

* set extensions-dir

* don't disable extensions

* skip test on windows due to #4

package.json

@@ -45,7 +45,7 @@
     "wdio-chromedriver-service": "^7.3.2"
   },
   "peerDependencies": {
-    "webdriverio": "^7.19.1"
+    "webdriverio": "^7.19.2"
   },
   "peerDependenciesMeta": {
     "webdriverio": {

src/pageobjects/workbench/Notification.ts

@@ -1,5 +1,7 @@
 import { ChainablePromiseElement } from 'webdriverio'
-import { BasePage, IPluginDecorator, VSCodeLocatorMap } from '../utils'
+import {
+    BasePage, IPluginDecorator, PluginDecorator, VSCodeLocatorMap
+} from '../utils'
 import { Notification as NotificationLocators } from '../../locators/1.61.0'
 
 /**
@@ -145,6 +147,7 @@ export abstract class Notification extends BasePage<typeof NotificationLocators>
  *
  * @category Workbench
  */
+@PluginDecorator(NotificationLocators)
 export class StandaloneNotification extends Notification {
     /**
      * @private
@@ -164,6 +167,7 @@ export class StandaloneNotification extends Notification {
  *
  * @category Workbench
  */
+@PluginDecorator(NotificationLocators)
 export class CenterNotification extends Notification {
     /**
      * @private

src/pageobjects/workbench/Workbench.ts

@@ -73,22 +73,26 @@ export class Workbench extends BasePage<typeof WorkbenchLocators> {
      */
     async getNotifications (): Promise<Notification[]> {
         const notifications: Notification[] = []
-        const container = await this.notificationContainer$
+        const containers = await this.notificationContainer$$
 
-        if (!await container.isExisting()) {
+        if (containers.length === 0) {
             return []
         }
-        const elements = await container.$$(this.locators.notificationItem)
-
-        for (const element of elements) {
-            notifications.push(
-                await new StandaloneNotification(
-                    this.locatorMap,
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    element as any
-                ).wait()
-            )
+
+        for (const container of containers) {
+            const elements = await container.$$(this.locators.notificationItem)
+
+            for (const element of elements) {
+                notifications.push(
+                    await new StandaloneNotification(
+                        this.locatorMap,
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                        element as any
+                    ).wait()
+                )
+            }
         }
+
         return notifications
     }
 

src/service.ts

@@ -8,11 +8,13 @@ import { SevereServiceError } from 'webdriverio'
 import { Workbench } from './pageobjects'
 import { getLocators } from './utils'
 import { VSCODE_APPLICATION_ARGS, DEFAULT_VSCODE_SETTINGS } from './constants'
-import type { ServiceOptions, ServiceCapabilities } from './types'
+import type { ServiceOptions, ServiceCapabilities, WDIOLogs } from './types'
 
 const log = logger('wdio-vscode-service')
 
 export default class VSCodeWorkerService implements Services.ServiceInstance {
+    private _browser?: WebdriverIO.Browser
+
     constructor (private _options: ServiceOptions) {}
 
     async beforeSession (_: Options.Testrunner, capabilities: ServiceCapabilities) {
@@ -43,13 +45,18 @@ export default class VSCodeWorkerService implements Services.ServiceInstance {
             customArgs.push(`--file-uri=${this._options.filePath}`)
         }
 
+        if (this._options.verboseLogging) {
+            customArgs.push('--verbose', '--logExtensionHostCommunication')
+        }
+
         capabilities.browserName = 'chrome'
         capabilities['goog:chromeOptions'] = {
             binary: capabilities['wdio:vscodeService'].vscode.path,
             args: [
                 ...VSCODE_APPLICATION_ARGS,
                 `--extensionDevelopmentPath=${this._options.extensionPath}`,
                 `--user-data-dir=${path.join(storagePath.path, 'settings')}`,
+                `--extensions-dir=${path.join(storagePath.path, 'extensions')}`,
                 ...customArgs,
                 ...(this._options.args || [])
             ].filter(Boolean),
@@ -58,15 +65,38 @@ export default class VSCodeWorkerService implements Services.ServiceInstance {
     }
 
     async before (capabilities: ServiceCapabilities, __: never, browser: WebdriverIO.Browser) {
+        this._browser = browser
         const locators = await getLocators(capabilities['wdio:vscodeService'].vscode.version)
         const workbenchPO = new Workbench(locators)
-        browser.addCommand('getWorkbench', () => workbenchPO.wait())
-        browser.addCommand('getVSCodeVersion', () => capabilities['wdio:vscodeService'].vscode.version)
-        browser.addCommand('getVSCodeChannel', () => (
+        this._browser.addCommand('getWorkbench', () => workbenchPO.wait())
+        this._browser.addCommand('getVSCodeVersion', () => capabilities['wdio:vscodeService'].vscode.version)
+        this._browser.addCommand('getVSCodeChannel', () => (
             capabilities['wdio:vscodeService'].vscode.version === 'insiders' ? 'insiders' : 'vscode'
         ))
         return workbenchPO.elem.waitForExist()
     }
+
+    async after () {
+        if (!this._browser || !this._options.verboseLogging) {
+            return
+        }
+
+        const logs = await this._browser.getLogs('browser').then(
+            (res) => res as WDIOLogs[],
+            (err) => err as Error
+        )
+
+        if (logs instanceof Error) {
+            return
+        }
+
+        for (const l of logs) {
+            log.info(
+                `[${(new Date(l.timestamp)).toISOString()}]`
+                + ` - ${l.source} - ${l.message}`
+            )
+        }
+    }
 }
 
 declare global {

src/types.ts

@@ -40,6 +40,13 @@ export interface ServiceOptions extends ChromedriverServiceOptions {
      * Additional start-up arguments
      */
     args?: string[]
+    /**
+     * If set to true, service logs VSCode output from the extension host
+     * and console API
+     *
+     * @default `true`
+     */
+    verboseLogging?: boolean
 }
 
 export interface BundleInformation {
@@ -55,3 +62,10 @@ export interface ServiceCapability {
 export interface ServiceCapabilities extends Capabilities.Capabilities {
     'wdio:vscodeService': ServiceCapability
 }
+
+export interface WDIOLogs {
+    level: string
+    message: string
+    source: string
+    timestamp: number
+}

test/specs/basic.e2e.ts

@@ -2,10 +2,11 @@
 /// <reference path="../../dist/service.d.ts" />
 
 import {
-    PluginDecorator, IPluginDecorator, BasePage, BottomBarPanel,
-    ExtensionsViewSection
+    PluginDecorator, IPluginDecorator, BasePage, BottomBarPanel
 } from '../..'
 
+const skipWindows = process.platform === 'win32' ? it.skip : it
+
 const locators = {
     marquee: {
         elem: 'ul[aria-label="Active View Switcher"]',
@@ -47,6 +48,17 @@ describe('WDIO VSCode Service', () => {
         expect(title).toContain('wdio-vscode-service')
     })
 
+    skipWindows('is able to read guinea pig notification', async () => {
+        const workbench = await browser.getWorkbench()
+        await browser.waitUntil(async () => {
+            const notifs = await workbench.getNotifications()
+            const messages = await Promise.all(notifs.map((n) => n.getMessage()))
+            return messages.includes('Hello World!')
+        }, {
+            timeoutMsg: 'Could not find test extension notification'
+        })
+    })
+
     describe('activity bar', () => {
         it('should show all activity bar items', async () => {
             const workbench = await browser.getWorkbench()