Review jasmine asymmetric compatibility

Author: dprevost-LMI

docs/API.md

@@ -1010,18 +1010,10 @@ await expect(browser).toHaveTitle(expect.not.stringContaining('some title'))
 
 ### Jasmine
 
-Even under `@wdio/jasmine-framework`, Jasmine asymmetric matchers do not work with WebdriverIO matchers. 
+Under `@wdio/jasmine-framework`, Jasmine asymmetric matchers now works with WebdriverIO matchers and the global import 
 
 ```ts
-// DOES NOT work
+// Jasmine stringContaining works just lik expect one's
 await expect(browser).toHaveTitle(jasmine.stringContaining('some title'))
-
-// Use expect
 await expect(browser).toHaveTitle(expect.stringContaining('some title'))
 ```
-
-However, when using Jasmine original matchers, both works.
-```ts
-await expect(url).toEqual(jasmine.stringMatching(/^https:\/\//))
-await expect(url).toEqual(expect.stringMatching(/^https:\/\//))
-```

package-lock.json

@@ -99,9 +99,7 @@
     "shelljs": "^0.10.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.16",
-    "webdriverio": "^9.21.0",
-    "jasmine": "^5.1.2",
-    "jasmine-core": "^5.1.2"
+    "webdriverio": "^9.21.0"
   },
   "peerDependencies": {
     "@wdio/globals": "^9.0.0",

package.json

@@ -19,7 +19,6 @@ export async function toHaveUrl(
     const pass = await waitUntil(async () => {
         actual = await browser.getUrl()
 
-        console.log('toHaveUrl', { actual, expectedValue })
         return compareText(actual, expectedValue, options).result
     }, isNot, options)
 

src/matchers/browser/toHaveUrl.ts

@@ -19,38 +19,32 @@ export function isJasmineAsymmetricMatcher<T>(expected: unknown): expected is Ja
     return isAsymmetricMatcher(expected) && 'expected' in expected
 }
 
-export function isAsymmetricMatcher(expected: unknown): expected is WdioAsymmetricMatcher<unknown> | JasmineAsymmetricMatcher<unknown> {
+export function isAsymmetricMatcher<T>(expected: unknown): expected is WdioAsymmetricMatcher<T> | JasmineAsymmetricMatcher<T> {
     return (
         typeof expected === 'object' &&
         !!expected &&
         'asymmetricMatch' in expected &&
-        Boolean(expected.asymmetricMatch)
+        !!expected.asymmetricMatch
     )
 }
 
-export function isStringContainingMatcher(expected: unknown): expected is WdioAsymmetricMatcher<unknown> | JasmineAsymmetricMatcher<unknown> {
+export function isStringContainingMatcherLike(expected: unknown): expected is WdioAsymmetricMatcher<string> | JasmineAsymmetricMatcher<string> {
     return !!expected && expected.constructor.name === 'StringContaining'
 }
 
-export function isStrictStringContainingMatcher(expected: unknown): expected is WdioAsymmetricMatcher<unknown> | JasmineAsymmetricMatcher<unknown> {
-    if (isStringContainingMatcher(expected)) {
-        if (isWdioAsymmetricMatcher(expected)) {
-            return expected.toString().includes('StringContaining')
-        }
-        return true
-    }
-    return false
+export function isStrictlyStringContainingMatcher(expected: unknown): expected is WdioAsymmetricMatcher<string> | JasmineAsymmetricMatcher<string> {
+    return isStringContainingMatcherLike(expected) && (!isWdioAsymmetricMatcher(expected) || expected.toString().includes('StringContaining'))
 }
 
-export function getValueFromAsymmetricMatcher<T>(
+export function getAsymmetricMatcherValue<T>(
     expected: WdioAsymmetricMatcher<T> | JasmineAsymmetricMatcher<T>
 ): T {
     if ('expected' in expected) {
         return expected.expected
     } else if ('sample' in expected) {
         return expected.sample
     }
-    throw new Error('Could not extract value from asymmetric matcher: ' + expected)
+    throw new Error(`Could not extract value from asymmetric matcher: ${String(expected)}`)
 }
 
 /**
@@ -191,9 +185,9 @@ export const compareText = (
         actual = actual.toLowerCase()
         if (typeof expected === 'string') {
             expected = expected.toLowerCase()
-        } else if (isStringContainingMatcher(expected)) {
-            const sample = getValueFromAsymmetricMatcher<string>(expected).toString().toLocaleLowerCase()
-            expected = (isStrictStringContainingMatcher(expected)
+        } else if (isStringContainingMatcherLike(expected)) {
+            const sample = getAsymmetricMatcherValue<string>(expected).toString().toLocaleLowerCase()
+            expected = (isStrictlyStringContainingMatcher(expected)
                 ? expect.stringContaining(sample)
                 : expect.not.stringContaining(sample)) as WdioAsymmetricMatcher<string>
         }
@@ -279,7 +273,7 @@ export const compareTextWithArray = (
             if (typeof item === 'string') {
                 return item.toLowerCase()
             }
-            if (isStringContainingMatcher(item)) {
+            if (isStringContainingMatcherLike(item)) {
                 return (item.toString() === 'StringContaining'
                     ? expect.stringContaining(item.sample?.toString().toLowerCase())
                     : expect.not.stringContaining(item.sample?.toString().toLowerCase())) as WdioAsymmetricMatcher<string>

src/utils.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect, vi } from 'vitest'
-import { compareNumbers, compareObject, compareText, compareTextWithArray, isAsymmetricMatcher, isStringContainingMatcher, waitUntil } from '../src/utils'
+import { compareNumbers, compareObject, compareText, compareTextWithArray, getAsymmetricMatcherValue, isAsymmetricMatcher, isStrictlyStringContainingMatcher, isStringContainingMatcherLike, waitUntil } from '../src/utils'
 
 describe('utils', () => {
 
@@ -386,7 +386,7 @@ describe('utils', () => {
                 // @ts-expect-error
                 expect(() => new StringContaining(123)).toThrow('Expected is not a string')
             })
-            test('toString and getExpectedType', () => {
+            test('jasmineToString and getExpectedType', () => {
                 const matcher = new StringContaining('foo')
                 expect(matcher.jasmineToString()).toBe('<jasmine.stringContaining>')
                 expect(matcher.getExpectedType()).toBe('string')
@@ -396,19 +396,58 @@ describe('utils', () => {
         test.for([
             expect.stringContaining('foo'),
             new StringContaining('foo')
-        ])('isAsymmetricMatcher should work with %s matcher', async (asymmetricMatcher) => {
+        ])('should work with %s matcher', async (asymmetricMatcher) => {
             const isAsymmetric = isAsymmetricMatcher(asymmetricMatcher)
 
             expect(isAsymmetric).toBe(true)
         })
+    })
 
+    describe(isStringContainingMatcherLike, () => {
         test.for([
             expect.stringContaining('foo'),
+            expect.not.stringContaining('foo'),
             new StringContaining('foo')
-        ])('isStringContainingMatcher should work with %s matcher', async (asymmetricMatcher) => {
-            const isAsymmetric = isStringContainingMatcher(asymmetricMatcher)
+        ])('should work with %s matcher', async (asymmetricMatcher) => {
+            const isStringContaining = isStringContainingMatcherLike(asymmetricMatcher)
 
-            expect(isAsymmetric).toBe(true)
+            expect(isStringContaining).toBe(true)
+        })
+    })
+
+    describe(isStrictlyStringContainingMatcher, () => {
+        test.for([
+            // expect.stringContaining('foo'),
+            new StringContaining('foo')
+        ])('should work with %s matcher', async (asymmetricMatcher) => {
+            const isStrictlyStringContaining = isStrictlyStringContainingMatcher(asymmetricMatcher)
+
+            expect(isStrictlyStringContaining).toBe(true)
+        })
+
+        test('should work with %s matcher', async () => {
+            const asymmetricMatcher = expect.not.stringContaining('foo')
+
+            const isStrictlyStringContaining = isStrictlyStringContainingMatcher(asymmetricMatcher)
+
+            expect(isStrictlyStringContaining).toBe(false)
+        })
+    })
+
+    describe(getAsymmetricMatcherValue, () => {
+        test.for([
+            expect.stringContaining('foo'),
+            expect.not.stringContaining('foo'),
+            new StringContaining('foo'),
+        ])('should return expected value of matcher', (asymmetricMatcher) => {
+
+            const value = getAsymmetricMatcherValue(asymmetricMatcher)
+
+            expect(value).toBe('foo')
+        })
+
+        test('should throw when unknown matcher', () => {
+            expect(() => getAsymmetricMatcherValue({} as any)).toThrow('Could not extract value from asymmetric matcher: [object Object]')
         })
     })
 })