Make SoftAssertService compatible with basic non-promises matchers

- fix `.not` not working for basic matchers
- Use soft for all `to` matchers
- Use a non async version for basic matchers

Author: dprevost-LMI

src/softExpect.ts

@@ -1,15 +1,18 @@
-import { expect, matchers } from './index.js'
+import { expect } from './index.js'
 import { SoftAssertService } from './softAssert.js'
+import type { SyncExpectationResult } from 'expect'
+
+const isPossibleMatcher = (propName: string) => propName.startsWith('to') && propName.length > 2
 
 /**
  * Creates a soft assertion wrapper using lazy evaluation
  * Only creates matchers when they're actually accessed
  */
-const createSoftExpect = <T = unknown>(actual: T): ExpectWebdriverIO.Matchers<Promise<void>, T> => {
+const createSoftExpect = <T = unknown>(actual: T): ExpectWebdriverIO.Matchers<Promise<void> | void, T> => {
     const softService = SoftAssertService.getInstance()
 
     // Use a simple proxy that creates matchers on-demand
-    return new Proxy({} as ExpectWebdriverIO.Matchers<Promise<void>, T>, {
+    return new Proxy({} as ExpectWebdriverIO.Matchers<Promise<void> | void, T>, {
         get(target, prop) {
             const propName = String(prop)
 
@@ -23,12 +26,10 @@ const createSoftExpect = <T = unknown>(actual: T): ExpectWebdriverIO.Matchers<Pr
                 return createSoftChainProxy(actual, propName, softService)
             }
 
-            // Handle matchers
-            if (matchers.has(propName)) {
+            if (isPossibleMatcher(propName)) {
+                // Support basic & wdio (and more) matchers that start with "to"
                 return createSoftMatcher(actual, propName, softService)
             }
-
-            // For any other properties, return undefined
             return undefined
         }
     })
@@ -38,13 +39,10 @@ const createSoftExpect = <T = unknown>(actual: T): ExpectWebdriverIO.Matchers<Pr
  * Creates a soft .not proxy
  */
 const createSoftNotProxy = <T>(actual: T, softService: SoftAssertService) => {
-    return new Proxy({} as ExpectWebdriverIO.Matchers<Promise<void>, T>, {
-        get(target, prop) {
+    return new Proxy({} as ExpectWebdriverIO.Matchers<Promise<void> | void, T>, {
+        get(_target, prop) {
             const propName = String(prop)
-            if (matchers.has(propName)) {
-                return createSoftMatcher(actual, propName, softService, 'not')
-            }
-            return undefined
+            return isPossibleMatcher(propName) ? createSoftMatcher(actual, propName, softService, 'not') : undefined
         }
     })
 }
@@ -53,13 +51,10 @@ const createSoftNotProxy = <T>(actual: T, softService: SoftAssertService) => {
  * Creates a soft chain proxy (resolves/rejects)
  */
 const createSoftChainProxy = <T>(actual: T, chainType: string, softService: SoftAssertService) => {
-    return new Proxy({} as ExpectWebdriverIO.Matchers<Promise<void>, T>, {
-        get(target, prop) {
+    return new Proxy({} as ExpectWebdriverIO.Matchers<Promise<void> | void, T>, {
+        get(_target, prop) {
             const propName = String(prop)
-            if (matchers.has(propName)) {
-                return createSoftMatcher(actual, propName, softService, chainType)
-            }
-            return undefined
+            return isPossibleMatcher(propName) ? createSoftMatcher(actual, propName, softService, chainType) : undefined
         }
     })
 }
@@ -73,7 +68,7 @@ const createSoftMatcher = <T>(
     softService: SoftAssertService,
     prefix?: string
 ) => {
-    return async (...args: unknown[]) => {
+    return (...args: unknown[]) => {
         try {
             // Build the expectation chain
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -87,20 +82,31 @@ const createSoftMatcher = <T>(
                 expectChain = expectChain.rejects
             }
 
-            return await ((expectChain as unknown) as Record<string, (...args: unknown[]) => ExpectWebdriverIO.AsyncAssertionResult>)[matcherName](...args)
+            // In case of matchers failures we jump into the catch block below
+            const assertionResult: ExpectWebdriverIO.AsyncAssertionResult | SyncExpectationResult  = expectChain[matcherName](...args)
 
-        } catch (error) {
-            // Record the failure
-            const fullMatcherName = prefix ? `${prefix}.${matcherName}` : matcherName
-            softService.addFailure(error as Error, fullMatcherName)
-
-            // Return a passing result to continue execution
-            return {
-                pass: true,
-                message: () => `Soft assertion failed: ${fullMatcherName}`
+            // Handle async matchers, and allow to not be a promise for basic non-async matchers
+            if ( assertionResult instanceof Promise) {
+                return assertionResult.catch((error: Error) => handlingMatcherFailure(prefix, matcherName, softService, error))
             }
+            return assertionResult
+
+        } catch (error) {
+            return handlingMatcherFailure(prefix, matcherName, softService, error as Error)
         }
     }
 }
 
+function handlingMatcherFailure(prefix: string | undefined, matcherName: string, softService: SoftAssertService, error: unknown) {
+    // Record the failure
+    const fullMatcherName = prefix ? `${prefix}.${matcherName}` : matcherName
+    softService.addFailure(error as Error, fullMatcherName)
+
+    // Return a passing result to continue execution
+    return {
+        pass: true,
+        message: () => `Soft assertion failed: ${fullMatcherName}`
+    }
+}
+
 export default createSoftExpect

test/softAssertions.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { $ } from '@wdio/globals'
+import { $, $$ } from '@wdio/globals'
+import expectLib from 'expect'
 import { expect as expectWdio, SoftAssertionService, SoftAssertService } from '../src/index.js'
 
 vi.mock('@wdio/globals')
@@ -19,6 +20,77 @@ describe('Soft Assertions', () => {
     })
 
     describe('expect.soft', () => {
+
+        it('should handle promises properly and return a promise when matchers are used with Promises or Elements', async () => {
+            const softService = SoftAssertService.getInstance()
+            softService.setCurrentTest('promise-0', 'test name', 'test file')
+
+            expect(expectLib(Promise.resolve(true)).resolves.toBe(true)).toBeInstanceOf(Promise)
+            expect(expectWdio(Promise.resolve(true)).resolves.toBe(true)).toBeInstanceOf(Promise)
+            expect(expectWdio(Promise.resolve(true)).resolves.not.toBe(false)).toBeInstanceOf(Promise)
+            expect(expectWdio.soft(Promise.resolve(true)).resolves.toBe(true)).toBeInstanceOf(Promise)
+
+            const elementToHaveText = expectWdio($('element1')).toHaveText('Valid Text')
+            expect(elementToHaveText).toBeInstanceOf(Promise)
+
+            // TODO remove await once $$() support is merged
+            const elementsToHaveText = expectWdio(await $$('elements2')).toHaveText('Valid Text')
+            expect(elementsToHaveText).toBeInstanceOf(Promise)
+
+            const elementsNotToHaveText = expectWdio(await $$('elements3')).not.toHaveText('Not Valid Text')
+            expect(elementsNotToHaveText).toBeInstanceOf(Promise)
+
+            await Promise.all([elementToHaveText, elementsToHaveText, elementsNotToHaveText])
+
+            const elementSoftToHaveText = expectWdio.soft($('element4')).toHaveText('Valid Text')
+            expect(elementSoftToHaveText).toBeInstanceOf(Promise)
+
+            const elementsSoftToHaveText = expectWdio.soft(await $$('elements5')).toHaveText('Valid Text')
+            expect(elementsSoftToHaveText).toBeInstanceOf(Promise)
+
+            const elementsSoftNotToHaveText = expectWdio.soft(await $$('elements6')).not.toHaveText('Not Valid Text')
+            expect(elementsSoftNotToHaveText).toBeInstanceOf(Promise)
+
+            // Ensure all assertions are awaited to avoid conflicts in other tests
+            await Promise.all([elementSoftToHaveText, elementsSoftToHaveText, elementsSoftNotToHaveText])
+        })
+
+        it('should handle non-promises properly', () => {
+            const softService = SoftAssertService.getInstance()
+            softService.setCurrentTest('non-promise-1', 'test name', 'test file')
+
+            expect(expectLib(true).toBe(true)).toBeUndefined()
+            expect(expectLib(true).toBe).toBeInstanceOf(Function)
+            expect(expectLib(true).toBe(true)).not.toBeInstanceOf(Promise)
+            expect(expectLib(true).not.toBe(false)).not.toBeInstanceOf(Promise)
+
+            expect(expectWdio(true).toBe(true)).toBeUndefined()
+            expect(expectWdio(true).toBe).toBeInstanceOf(Function)
+            expect(expectWdio(true).toBe(true)).not.toBeInstanceOf(Promise)
+            expect(expectWdio(true).not.toBe(false)).not.toBeInstanceOf(Promise)
+
+            expect(expectWdio.soft(true).toBe(true)).toBeUndefined()
+            expect(expectWdio.soft(true).toBe).toBeInstanceOf(Function)
+            expect(expectWdio.soft(true).toBe).not.toBeInstanceOf(Promise)
+            expect(expectWdio.soft(true).not.toBe(false)).not.toBeInstanceOf(Promise)
+        })
+
+        it.for([
+            '',
+            2,
+            [],
+        ])('should handle non-promises and return a non-promise target to have the correct runtime type', (actualPromise) => {
+            const softService = SoftAssertService.getInstance()
+            softService.setCurrentTest('non-promise-2', 'test name', 'test file')
+
+            const wdioExpect = expectWdio(actualPromise)
+            expect(wdioExpect).not.toBeInstanceOf(Promise)
+
+            const softExpect = expectWdio.soft(actualPromise)
+            expect(softExpect).toBeInstanceOf(Object)
+            expect(softExpect).not.toBeInstanceOf(Promise)
+        })
+
         it('should not throw immediately on failure', async () => {
             const softService = SoftAssertService.getInstance()
             softService.setCurrentTest('test-1', 'test name', 'test file')
@@ -108,20 +180,48 @@ describe('Soft Assertions', () => {
             expect(expectWdio.getSoftFailures().length).toBe(0)
         })
 
-        /**
-         * TODO: Skipped since soft assertions are currently not supporting basic matchers like toBe or toEqual. To fix one day!
-         * @see https://github.com/webdriverio/expect-webdriverio/issues/1887
-         */
-        it.skip('should support basic text matching', async () => {
-            const softService = SoftAssertService.getInstance()
-            softService.setCurrentTest('test-7', 'test name', 'test file')
-            const text = await el.getText()
+        describe('Basic Matchers Support', () => {
+            it('should support basic matchers failure without await', () => {
+                const softService = SoftAssertService.getInstance()
+                softService.setCurrentTest('test-7', 'test name', 'test file')
 
-            expectWdio.soft(text).toEqual('!Actual Text')
+                expectWdio.soft('Actual Text').toEqual('!Actual Text')
 
-            const failures = expectWdio.getSoftFailures()
-            expect(failures.length).toBe(1)
-            expect(failures[0].matcherName).toBe('toHaveText')
+                const failures = expectWdio.getSoftFailures()
+                expect(failures.length).toBe(1)
+                expect(failures[0].matcherName).toBe('toEqual')
+            })
+
+            it('should support basic matchers success', async () => {
+                const softService = SoftAssertService.getInstance()
+                softService.setCurrentTest('test-8', 'test name', 'test file')
+
+                expectWdio.soft('Actual Text').toEqual('Actual Text')
+
+                const failures = expectWdio.getSoftFailures()
+                expect(failures.length).toBe(0)
+            })
+
+            it('not - should support basic matchers failure without await', async () => {
+                const softService = SoftAssertService.getInstance()
+                softService.setCurrentTest('test-9', 'test name', 'test file')
+
+                expectWdio.soft('Actual Text').not.toEqual('Actual Text')
+
+                const failures = expectWdio.getSoftFailures()
+                expect(failures.length).toBe(1)
+                expect(failures[0].matcherName).toBe('not.toEqual')
+            })
+
+            it.skip('not - should support basic matcher success', async () => {
+                const softService = SoftAssertService.getInstance()
+                softService.setCurrentTest('test-10', 'test name', 'test file')
+
+                expectWdio.soft('Actual Text').not.toEqual('Not Actual Text')
+
+                const failures = expectWdio.getSoftFailures()
+                expect(failures.length).toBe(0)
+            })
         })
 
     })

test/types.test-d.ts

@@ -0,0 +1,59 @@
+import { describe, expect, expectTypeOf, test } from 'vitest'
+import { $, $$ } from '@wdio/globals'
+import type { Matchers, Inverse } from 'expect'
+import expectLib from 'expect'
+import { expect as expectWdio } from '../src/index.js'
+
+describe('Type test', () => {
+
+    test('Jest "expect" lib type tests as baseline', () => {
+        // Basic matchers
+        expectTypeOf(expectLib(true)).toExtend<Matchers<void, boolean> & Inverse<Matchers<void, boolean>>>()
+        expectTypeOf(expectLib(true).toBe(true)).toBeVoid()
+        expectTypeOf(expectLib(true).toBe(true)).not.toExtend<Promise<void>>()
+        expectTypeOf(expectLib(Promise.resolve(true)).toBe(expect.any)).toBeVoid()
+        expectTypeOf(expectLib(Promise.resolve(true)).resolves.toBe(expect.any)).resolves.toBeVoid()
+
+        // element matchers are not available in 'expect' lib
+        expectTypeOf(expectLib($('element')).toBe(expect.any)).toBeVoid()
+        expectTypeOf(expectLib($('element'))).not.toHaveProperty('toHaveText')
+        expectTypeOf(expectLib($$('elements')).toBe(expect.any)).toBeVoid()
+        expectTypeOf(expectLib($$('elements'))).not.toHaveProperty('toHaveText')
+    })
+
+    test('Wdio expect & matchers type tests', () => {
+        // Basic matchers
+        expectTypeOf(expectWdio(true)).toExtend<Matchers<void, boolean> & Inverse<Matchers<void, boolean>>>()
+        expectTypeOf(expectWdio(true).toBe(true)).toBeVoid()
+        expectTypeOf(expectWdio(true).toBe(true)).not.toExtend<Promise<void>>()
+        expectTypeOf(expectWdio(Promise.resolve(true)).toBe(true))
+        expectTypeOf(expectWdio(Promise.resolve(true)).resolves.toBe(true)).resolves.toBeVoid()
+
+        // element matchers
+        expectTypeOf(expectWdio($('element')).toBe(expect.any)).toBeVoid()
+        expectTypeOf(expectWdio($('element')).toHaveText('test')).not.toBeVoid()
+        expectTypeOf(expectWdio($('element')).toHaveText('test')).toExtend<Promise<void>>()
+        expectTypeOf(expectWdio($$('elements')).toBe(expect.any)).toBeVoid()
+        expectTypeOf(expectWdio($$('elements')).toHaveText('test')).toExtend<Promise<void>>()
+        expectTypeOf(expectWdio($$('elements')).toHaveText('test')).not.toBeVoid()
+
+    })
+
+    test('Wdio soft expect & matchers type tests', () => {
+        // Basic matchers
+        expectTypeOf(expectWdio.soft(true)).toExtend<Matchers<void, boolean> & Inverse<Matchers<void, boolean>>>()
+        expectTypeOf(expectWdio.soft(true).toBe(true)).toExtend<void>()
+        expectTypeOf(expectWdio.soft(true).toBe(true)).not.toExtend<Promise<void>>()
+        // to fix?
+        //expectTypeOf(expectWdio.soft(Promise.resolve(true)).toBe(expect.any)).toBeVoid()
+        expectTypeOf(expectWdio.soft(Promise.resolve(true)).resolves.toBe(expect.any)).toExtend<Promise<void>>()
+
+        // element matchers
+        expectTypeOf(expectWdio($('element')).toBe(expect.any)).toBeVoid()
+        expectTypeOf(expectWdio($('element')).toHaveText('test')).not.toBeVoid()
+        expectTypeOf(expectWdio($('element')).toHaveText('test')).toExtend<Promise<void>>()
+        expectTypeOf(expectWdio($$('elements')).toBe(expect.any)).toBeVoid()
+        expectTypeOf(expectWdio($$('elements')).toHaveText('test')).toExtend<Promise<void>>()
+        expectTypeOf(expectWdio($$('elements')).toHaveText('test')).not.toBeVoid()
+    })
+})