Increase coverage

Author: dprevost-LMI

src/util/executeCommand.ts

@@ -44,8 +44,9 @@ export async function executeCommand<T>(
     if (!singleElementCompareStrategy && !mutipleElementsCompareStrategy) { throw new Error('No condition or customMultipleElementCompareStrategy provided to executeCommand') }
 
     const elementOrArray = element ? element : elements ? elements : undefined
+
+    /* v8 ignore next -- @preserve -- should be unreachable due to checks above */
     if (!elementOrArray) {
-        // Should be unreachable due to checks above
         throw new Error('No elements to process in executeCommand')
     }
 
@@ -57,7 +58,7 @@ export async function executeCommand<T>(
     } else if (singleElementCompareStrategy && elements) {
         results = await map(elements, (el: WebdriverIO.Element) => singleElementCompareStrategy(el))
     } else  {
-        // To please tsc but never reached due to checks above
+        /* v8 ignore next -- @preserve -- To please tsc but never reached due to checks above */
         throw new Error('Unable to process executeCommand with the provided parameters')
     }
 

test/matchers/element/toHaveWidth.test.ts

@@ -214,7 +214,7 @@ Received      : [50, 50]`
             )
         })
 
-        test.only('not - failure lte - pass should be true', async () => {
+        test('not - failure lte - pass should be true', async () => {
             elements.forEach(el => el.getSize = vi.fn().mockResolvedValue(50))
 
             const result = await thisNotContext.toHaveWidth(elements, { lte: 51 })
@@ -228,7 +228,7 @@ Received      : [50, 50]`
             )
         })
 
-        test.only('not - failure lte only first element - pass should be true', async () => {
+        test('not - failure lte only first element - pass should be true', async () => {
             elements.forEach(el => el.getSize = vi.fn().mockResolvedValue(50))
 
             const result = await thisNotContext.toHaveWidth(elements, [{ lte: 51 }, 51])
@@ -242,7 +242,7 @@ Received      : [50, 50]`
             )
         })
 
-        test.only('not - failure gte - pass should be true', async () => {
+        test('not - failure gte - pass should be true', async () => {
             elements.forEach(el => el.getSize = vi.fn().mockResolvedValue(50))
 
             const result = await thisNotContext.toHaveWidth(elements, { gte: 49 })

test/matchers/elements/toBeElementsArrayOfSize.test.ts

@@ -94,7 +94,7 @@ Received      : 2`
                 )
             })
 
-            test.only('not - failure - lte - pass should be true', async () => {
+            test('not - failure - lte - pass should be true', async () => {
                 const result = await thisNotContext.toBeElementsArrayOfSize(els, { lte: 3 })
 
                 expect(result.pass).toBe(true) // failure, boolean is inverted later in .not cases
@@ -106,7 +106,7 @@ Received      : 2`
                 )
             })
 
-            test.only('not - failure - gte - pass should be true', async () => {
+            test('not - failure - gte - pass should be true', async () => {
                 const result = await thisNotContext.toBeElementsArrayOfSize(els, { gte: 1 })
 
                 expect(result.pass).toBe(true) // failure, boolean is inverted later in .not cases

test/util/stringUtil.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from 'vitest'
+import { isString, toJsonString } from '../../src/util/stringUtil'
+
+describe('stringUtil', () => {
+    describe(isString, () => {
+        test('should return true for a string', () => {
+            expect(isString('hello')).toBe(true)
+            expect(isString('')).toBe(true)
+        })
+
+        test('should return false for non-string values', () => {
+            expect(isString(123)).toBe(false)
+            expect(isString(true)).toBe(false)
+            expect(isString({})).toBe(false)
+            expect(isString(null)).toBe(false)
+            expect(isString(undefined)).toBe(false)
+            expect(isString([])).toBe(false)
+        })
+    })
+
+    describe(toJsonString, () => {
+        test('should return the string as is if input is a string', () => {
+            expect(toJsonString('hello')).toBe('hello')
+        })
+
+        test('should return JSON string if input is a serializable object', () => {
+            const obj = { foo: 'bar', num: 123 }
+            expect(toJsonString(obj)).toBe(JSON.stringify(obj))
+        })
+
+        test('should return string representation if JSON.stringify throws', () => {
+            const circular: any = { foo: 'bar' }
+            circular.self = circular
+
+            expect(toJsonString(circular)).toBe('[object Object]')
+            expect(toJsonString(BigInt(9007199254740991))).toBe('9007199254740991')
+        })
+
+        test('should return string representation for other types', () => {
+            expect(toJsonString(123)).toBe('123')
+            expect(toJsonString(true)).toBe('true')
+            expect(toJsonString(null)).toBe('null')
+        })
+
+        test('should handle undefined correctly', () => {
+            expect(toJsonString(undefined)).toBeUndefined()
+        })
+    })
+})

test/utils.test.ts

@@ -291,7 +291,11 @@ Received: "not displayed"`)
                 beforeEach(() => {
                     // Success for `.not`
                     vi.mocked(command).mockResolvedValue(false)
-                    negatedContext = { ...context, isNot: true }
+                    negatedContext = {
+                        expectation: 'displayed',
+                        verb: 'be',
+                        isNot: true
+                    }
                 })
 
                 test('should succeed so pass=false since it is inverted later', async () => {
@@ -433,7 +437,11 @@ Expect ${selectorName} to be displayed
                 beforeEach(() => {
                     // Success for `.not`
                     vi.mocked(command).mockResolvedValue(false)
-                    negatedContext = { ...context, isNot: true }
+                    negatedContext = {
+                        expectation: 'displayed',
+                        verb: 'be',
+                        isNot: true
+                    }
                 })
 
                 test('should succeed so pass=false since it is inverted later', async () => {