Fixing jasmine prob, once for all

Author: dprevost-LMI

docs/CustomMatchers.md

@@ -1,6 +1,16 @@
+# Custom Matchers
+
+`expect-webdriverio` registers WebdriverIO custom matchers out of the box for a seamless experience.
+
+To use WebdriverIO custom matchers (except asymmetric matchers) directly in:
+- **Jest**: Register matchers manually with `expect.extend`.
+- **Jasmine**: Register matchers manually with `jasmine.addAsyncMatchers`, then they will be available on `expectAsync`.
+    - Using `@wdio/jasmine-framework` provides a similar out-of-the-box experience.
+- **Types**: Type augmentation for custom matchers is provided. See [Types.md](Types.md) for details.
+
 ## Adding your own matchers
 
-Similar to how `expect-webdriverio` extends Jasmine/Jest matchers it's possible to add custom matchers.
+Similar to how `expect-webdriverio` provide custom matchers it's possible to add your own custom matchers.
 
 - [Jasmine](https://jasmine.github.io/) see [custom matchers](https://jasmine.github.io/tutorials/custom_matchers) doc
 - Everyone else see [Jest's expect.extend](https://jestjs.io/docs/expect#expectextendmatchers)

jasmine-wdio-expect-async.d.ts

@@ -14,6 +14,10 @@ declare namespace jasmine {
 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars -- U is required to properly override Jasmine's AsyncMatchers
     interface AsyncMatchers<T, U> extends ExpectWebdriverIO.CustomMatchers<Promise<void>, T> {}
+
+    // Needed to reference it below for the withContext method
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    interface Matchers<T> {}
 }
 
 declare namespace ExpectWebdriverIO {
@@ -39,12 +43,12 @@ declare namespace ExpectWebdriverIO {
          * @param actual The value to apply matchers against.
          */
         <T = unknown>(actual: T): {
-            withContext(message: string): jasmine.AsyncMatchers<T, U> & jasmine.Matchers<T>;
-        } & jasmine.AsyncMatchers<T, void> & jasmine.Matchers<T>
+            withContext(message: string): jasmine.AsyncMatchers<T, Promise<void>> & jasmine.Matchers<T>;
+        } & jasmine.AsyncMatchers<T, Promise<void>> & jasmine.Matchers<T>
     }
 }
 
-//// @ts-expect-error: IDE might flags this one but just does be concerned by it. This way the `tsc:root-types` can pass!
+// @ts-expect-error: IDE might flags this one but just does be concerned by it. This way the `tsc:root-types` can pass!
 declare const expect: ExpectWebdriverIO.JasmineExpect
 declare namespace NodeJS {
     interface Global {

package-lock.json

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

package.json

@@ -119,16 +119,18 @@ describe('Jasmine-Specific Features', () => {
 
     // failing on jasmine.stringContaining not working properly with wdio matchers
     describe('Browser state validation', () => {
-        xit('should validate browser properties with asymmetric matchers', async () => {
+        fit('should validate browser properties with asymmetric matchers', async () => {
             const title = await browser.getTitle()
             const url = await browser.getUrl()
 
             await expect(title).toEqual(jasmine.stringMatching(/WebdriverIO/i))
             await expect(url).toEqual(jasmine.stringContaining('webdriver.io'))
 
             // Combined with WebdriverIO matchers
-            await expect(browser).toHaveUrl(jasmine.stringContaining('webdriver.io'))
-            await expect(browser).toHaveTitle(jasmine.stringContaining('WebdriverIO'))
+            // await expect(browser).toHaveUrl(jasmine.stringContaining('webdriver.io'))
+            // await expect(browser).toHaveTitle(jasmine.stringContaining('WebdriverIO'))
+            // await expect(browser).toHaveUrl(jasmine.stringContaining('WEBDRIVER.io'),{ignoreCase: true})
+            await expect(browser).toHaveTitle(jasmine.stringContaining('WEBDRIVERIO'), {ignoreCase: true})
         })
     })
 

playgrounds/jasmine/test/specs/globalImport/jasmine-specific.test.ts

@@ -17,7 +17,9 @@ export const config: WebdriverIO.Config = {
     specs: [
         './test/specs/**/*.test.ts'
         // './test/specs/**/jasmine-specific.test.ts',
+        // './test/specs/expectWdioImport/basic-matchers.test.ts',
         // './test/specs/expectWdioImport/wdio-matchers.test.ts'
+        './test/specs/globalImport/jasmine-specific.test.ts',
     ],
 
     //

playgrounds/jasmine/wdio.conf.ts

@@ -5,6 +5,61 @@ describe('Basic Expect Matchers', () => {
         await browser.url('https://webdriver.io')
     })
 
+    describe('Expect matchers', () => {
+        test('Basic matchers', async () => {
+            // Equality
+            expect(2 + 2).toBe(4);
+            expect({a: 1}).toEqual({a: 1});
+            expect([1, 2, 3]).toStrictEqual([1, 2, 3]);
+            expect(2 + 2).not.toBe(5);
+
+            // Truthiness
+            expect(null).toBeNull();
+            expect(undefined).toBeUndefined();
+            expect(0).toBeFalsy();
+            expect(1).toBeTruthy();
+            expect(NaN).toBeNaN();
+
+            // Numbers
+            expect(4).toBeGreaterThan(3);
+            expect(4).toBeGreaterThanOrEqual(4);
+            expect(4).toBeLessThan(5);
+            expect(4).toBeLessThanOrEqual(4);
+            expect(0.2 + 0.1).toBeCloseTo(0.3, 5);
+
+            // Strings
+            expect('team').toMatch(/team/);
+            expect('Christoph').toContain('stop');
+
+            // Arrays and iterables
+            expect([1, 2, 3]).toContain(2);
+            expect([{a: 1}, {b: 2}]).toContainEqual({a: 1});
+            expect([1, 2, 3]).toHaveLength(3);
+
+            // Objects
+            expect({a: 1, b: 2}).toHaveProperty('a');
+            expect({a: {b: 2}}).toHaveProperty('a.b', 2);
+
+            // Errors
+            expect(() => { throw new Error('error!') }).toThrow('error!');
+            expect(() => { throw new TypeError('wrong type') }).toThrow(TypeError);
+
+            // Asymmetric matchers
+            expect({foo: 'bar', baz: 1}).toEqual(expect.objectContaining({foo: expect.any(String)}));
+            expect([1, 2, 3]).toEqual(expect.arrayContaining([2]));
+            expect('abc').toEqual(expect.stringContaining('b'));
+            expect('abc').toEqual(expect.stringMatching(/b/));
+            expect(123).toEqual(expect.any(Number));
+
+            // Others
+            expect(new Set([1, 2, 3])).toContain(2);
+
+            // .resolves / .rejects (async)
+            await expect(Promise.resolve(42)).resolves.toBe(42);
+            await expect(Promise.reject(new Error('fail'))).rejects.toThrow('fail');
+        });
+    });
+
     describe('Boolean matchers', () => {
         it('should verify truthy values', async () => {
             const element = await $('.navbar')

playgrounds/mocha/test/specs/basic-matchers.test.ts

@@ -19,6 +19,7 @@ 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

@@ -11,24 +11,46 @@ import { enhanceError, enhanceErrorBe, numberError } from './util/formatMessage.
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
 
-const asymmetricMatcher =
-    typeof Symbol === 'function' && Symbol.for
-        ? Symbol.for('jest.asymmetricMatcher')
-        : 0x13_57_a5
+export function isWdioAsymmetricMatcher<T>(expected: unknown): expected is WdioAsymmetricMatcher<T> {
+    return isAsymmetricMatcher(expected) && 'sample' in expected
+}
+
+export function isJasmineAsymmetricMatcher<T>(expected: unknown): expected is JasmineAsymmetricMatcher<T> {
+    return isAsymmetricMatcher(expected) && 'expected' in expected
+}
 
-export function isAsymmetricMatcher(expected: unknown): expected is WdioAsymmetricMatcher<unknown> {
+export function isAsymmetricMatcher(expected: unknown): expected is WdioAsymmetricMatcher<unknown> | JasmineAsymmetricMatcher<unknown> {
     return (
         typeof expected === 'object' &&
-        expected &&
-        '$$typeof' in expected &&
+        !!expected &&
         'asymmetricMatch' in expected &&
-        expected.$$typeof === asymmetricMatcher &&
         Boolean(expected.asymmetricMatch)
-    ) as boolean
+    )
+}
+
+export function isStringContainingMatcher(expected: unknown): expected is WdioAsymmetricMatcher<unknown> | JasmineAsymmetricMatcher<unknown> {
+    return !!expected && expected.constructor.name === 'StringContaining'
 }
 
-function isStringContainingMatcher(expected: unknown): expected is WdioAsymmetricMatcher<unknown> {
-    return isAsymmetricMatcher(expected) && ['StringContaining', 'StringNotContaining'].includes(expected.toString())
+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 getValueFromAsymmetricMatcher<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)
 }
 
 /**
@@ -141,7 +163,7 @@ const compareNumbers = (actual: number, options: ExpectWebdriverIO.NumberOptions
 
 export const compareText = (
     actual: string,
-    expected: string | RegExp | WdioAsymmetricMatcher<string>,
+    expected: string | RegExp | WdioAsymmetricMatcher<string> | JasmineAsymmetricMatcher<string>,
     {
         ignoreCase = false,
         trim = true,
@@ -170,9 +192,10 @@ export const compareText = (
         if (typeof expected === 'string') {
             expected = expected.toLowerCase()
         } else if (isStringContainingMatcher(expected)) {
-            expected = (expected.toString() === 'StringContaining'
-                ? expect.stringContaining(expected.sample?.toString().toLowerCase())
-                : expect.not.stringContaining(expected.sample?.toString().toLowerCase())) as WdioAsymmetricMatcher<string>
+            const sample = getValueFromAsymmetricMatcher<string>(expected).toString().toLocaleLowerCase()
+            expected = (isStrictStringContainingMatcher(expected)
+                ? expect.stringContaining(sample)
+                : expect.not.stringContaining(sample)) as WdioAsymmetricMatcher<string>
         }
     }
 

src/utils.ts

@@ -8,7 +8,6 @@
     "types": [
       "@types/jasmine",
       "../../jasmine.d.ts",
-      "../../jasmine-wdio-expect-async.d.ts"
     ]
   }
-}
+}