refactor: improve test cases for utility functions

Author: ismail9k

src/utils/calculateAverage.spec.ts

@@ -3,23 +3,23 @@ import { describe, expect, test } from 'vitest'
 import { calculateAverage } from './calculateAverage'
 
 describe('calculateAverage', () => {
-  test('returns 0 for empty array', () => {
-    expect(calculateAverage([])).toBe(0)
+  test('calculates average for multiple values', () => {
+    expect(calculateAverage([1, 2, 3, 4, 5])).toBe(3)
   })
 
   test('calculates average for single value', () => {
     expect(calculateAverage([5])).toBe(5)
   })
 
-  test('calculates average for multiple values', () => {
-    expect(calculateAverage([1, 2, 3, 4, 5])).toBe(3)
-  })
-
   test('handles decimal numbers', () => {
     expect(calculateAverage([1.5, 2.5, 3.5])).toBe(2.5)
   })
 
   test('handles negative numbers', () => {
     expect(calculateAverage([-1, 0, 1])).toBe(0)
   })
+
+  test('returns 0 for empty array', () => {
+    expect(calculateAverage([])).toBe(0)
+  })
 })

src/utils/camelCaseToKebabCase.spec.ts

@@ -3,22 +3,22 @@ import { describe, it, expect } from 'vitest'
 import { camelCaseToKebabCase } from './camelCaseToKebabCase'
 
 describe('camelCaseToKebabCase', () => {
-  it('converts single camelCase word to kebab-case', () => {
-    expect(camelCaseToKebabCase('camelCase')).toBe('camel-case')
-  })
-
   it('converts multiple camelCase words to kebab-case', () => {
     expect(camelCaseToKebabCase('myVariableName')).toBe('my-variable-name')
   })
 
-  it('handles strings with no uppercase letters', () => {
-    expect(camelCaseToKebabCase('lowercase')).toBe('lowercase')
+  it('converts single camelCase word to kebab-case', () => {
+    expect(camelCaseToKebabCase('camelCase')).toBe('camel-case')
   })
 
   it('handles empty strings', () => {
     expect(camelCaseToKebabCase('')).toBe('')
   })
 
+  it('handles strings with no uppercase letters', () => {
+    expect(camelCaseToKebabCase('lowercase')).toBe('lowercase')
+  })
+
   it('handles strings with numbers', () => {
     expect(camelCaseToKebabCase('camelCase123')).toBe('camel-case123')
   })

src/utils/createCloneSlides.spec.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from 'vitest'
+import { h, ComponentInternalInstance } from 'vue'
+
+import { createCloneSlides } from './createCloneSlides'
+
+function createMockSlide(index: number): ComponentInternalInstance {
+  return {
+    vnode: h('div', { key: index }, `Slide ${index}`),
+    // ...other properties...
+  } as ComponentInternalInstance
+}
+
+describe('createCloneSlides', () => {
+  it('should clone slides correctly after', () => {
+    const slides = [createMockSlide(1), createMockSlide(2), createMockSlide(3)]
+    const clones = createCloneSlides({ slides, position: 'after', toShow: 1 })
+    expect(clones[0].key).toBe('clone-after-0')
+  })
+
+  it('should clone slides correctly before', () => {
+    const slides = [createMockSlide(1), createMockSlide(2), createMockSlide(3)]
+    const clones = createCloneSlides({ slides, position: 'before', toShow: 1 })
+    expect(clones[0].key).toBe('clone-before--1')
+  })
+
+  it('should create the correct number of clones after', () => {
+    const slides = [createMockSlide(1), createMockSlide(2), createMockSlide(3)]
+    const clones = createCloneSlides({ slides, position: 'after', toShow: 2 })
+    expect(clones.length).toBe(2)
+  })
+
+  it('should create the correct number of clones before', () => {
+    const slides = [createMockSlide(1), createMockSlide(2), createMockSlide(3)]
+    const clones = createCloneSlides({ slides, position: 'before', toShow: 2 })
+    expect(clones.length).toBe(2)
+  })
+
+  it('should handle empty slides array', () => {
+    const slides: ComponentInternalInstance[] = []
+    const clones = createCloneSlides({ slides, position: 'before', toShow: 2 })
+    expect(clones.length).toBe(0)
+  })
+
+  it('should handle zero clones', () => {
+    const slides = [createMockSlide(1), createMockSlide(2), createMockSlide(3)]
+    const clones = createCloneSlides({ slides, position: 'before', toShow: 0 })
+    expect(clones.length).toBe(0)
+  })
+})

src/utils/disableChildrenTabbing.spec.ts

@@ -0,0 +1,50 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { VNode } from 'vue'
+
+import { disableChildrenTabbing } from './disableChildrenTabbing'
+
+describe('disableChildrenTabbing', () => {
+  let container: HTMLElement
+
+  beforeEach(() => {
+    container = document.createElement('div')
+    document.body.appendChild(container)
+  })
+
+  afterEach(() => {
+    document.body.removeChild(container)
+  })
+
+  it('should disable tabbing for all child elements', () => {
+    const child1 = document.createElement('button')
+    const child2 = document.createElement('input')
+    container.appendChild(child1)
+    container.appendChild(child2)
+
+    disableChildrenTabbing({ el: container } as unknown as VNode)
+
+    expect(child1.tabIndex).toBe(-1)
+    expect(child2.tabIndex).toBe(-1)
+  })
+
+  it('should not affect elements outside the container', () => {
+    const outsideChild = document.createElement('button')
+    document.body.appendChild(outsideChild)
+
+    disableChildrenTabbing({ el: container } as unknown as VNode)
+
+    expect(outsideChild.tabIndex).not.toBe(-1)
+
+    document.body.removeChild(outsideChild)
+  })
+
+  it('should not change tabIndex for elements that already have tabIndex -1', () => {
+    const child = document.createElement('button')
+    child.tabIndex = -1
+    container.appendChild(child)
+
+    disableChildrenTabbing({ el: container } as unknown as VNode)
+
+    expect(child.tabIndex).toBe(-1)
+  })
+})

src/utils/getDraggedSlidesCount.spec.ts

@@ -13,16 +13,6 @@ describe('getDraggedSlidesCount', () => {
     expect(getDraggedSlidesCount(params)).toBe(-2)
   })
 
-  it('should calculate the correct number of slides for vertical drag', () => {
-    const params = {
-      isVertical: true,
-      isReversed: false,
-      dragged: { x: 0, y: 150 },
-      effectiveSlideSize: 100,
-    }
-    expect(getDraggedSlidesCount(params)).toBe(-2)
-  })
-
   it('should calculate the correct number of slides for reversed horizontal drag', () => {
     const params = {
       isVertical: false,
@@ -43,6 +33,16 @@ describe('getDraggedSlidesCount', () => {
     expect(getDraggedSlidesCount(params)).toBe(2)
   })
 
+  it('should calculate the correct number of slides for vertical drag', () => {
+    const params = {
+      isVertical: true,
+      isReversed: false,
+      dragged: { x: 0, y: 150 },
+      effectiveSlideSize: 100,
+    }
+    expect(getDraggedSlidesCount(params)).toBe(-2)
+  })
+
   it('should handle zero drag', () => {
     const params = {
       isVertical: false,

src/utils/getDraggedSlidesCount.ts

@@ -1,4 +1,4 @@
-interface DragParams {
+type DragParams = {
   isVertical: boolean
   isReversed: boolean
   dragged: { x: number; y: number }

src/utils/getNumberInRange.spec.ts

@@ -3,6 +3,15 @@ import { expect, it, describe } from 'vitest'
 import { getNumberInRange } from '@/utils'
 
 describe('getCurrentSlideIndex', () => {
+  it('When min is larger than max should return val', () => {
+    const val = 2
+    const min = 10
+    const max = 5
+    const results = getNumberInRange({ val, min, max })
+
+    expect(results).toBe(val)
+  })
+
   it('When the number inside the range should return the same value', () => {
     const val = 5
     const min = 0
@@ -30,16 +39,6 @@ describe('getCurrentSlideIndex', () => {
     expect(results).toBe(min)
   })
 
-  it('When the min is larger than max should return val', () => {
-    const val = 2
-    const min = 10
-    const max = 5
-    const results = getNumberInRange({ val, min, max })
-
-    expect(results).toBe(val)
-  })
-
-
   it('doesn`t bound a NaN min or max', () => {
     const val = 20
     expect(getNumberInRange({ val, min: 0, max: NaN })).toBe(val)

src/utils/getSnapAlignOffset.spec.ts

@@ -3,11 +3,33 @@ import { describe, expect, test } from 'vitest'
 import { getSnapAlignOffset } from './getSnapAlignOffset'
 
 describe('getSnapAlignOffset', () => {
-  describe('with itemsToShow parameter', () => {
-    test('should return correct offset for start alignment', () => {
-      expect(getSnapAlignOffset({ align: 'start', itemsToShow: 3 })).toBe(0)
+  describe('edge cases', () => {
+    test('should handle equal viewport and slide sizes', () => {
+      expect(
+        getSnapAlignOffset({
+          align: 'center',
+          slideSize: 800,
+          viewportSize: 800,
+        })
+      ).toBe(0)
+    })
+
+    test('should return 0 for invalid alignment', () => {
+      expect(
+        getSnapAlignOffset({
+          align: 'invalid' as any,
+          slideSize: 200,
+          viewportSize: 800,
+        })
+      ).toBe(0)
     })
 
+    test('should return 0 when no parameters provided', () => {
+      expect(getSnapAlignOffset({ align: 'start' })).toBe(0)
+    })
+  })
+
+  describe('with itemsToShow parameter', () => {
     test('should return correct offset for center/center-odd alignment', () => {
       expect(getSnapAlignOffset({ align: 'center', itemsToShow: 3 })).toBe(1)
       expect(getSnapAlignOffset({ align: 'center-odd', itemsToShow: 5 })).toBe(2)
@@ -20,19 +42,13 @@ describe('getSnapAlignOffset', () => {
     test('should return correct offset for end alignment', () => {
       expect(getSnapAlignOffset({ align: 'center-even', itemsToShow: 4 })).toBe(1)
     })
-  })
 
-  describe('with slideSize and viewportSize parameters', () => {
     test('should return correct offset for start alignment', () => {
-      expect(
-        getSnapAlignOffset({
-          align: 'start',
-          slideSize: 200,
-          viewportSize: 800,
-        })
-      ).toBe(0)
+      expect(getSnapAlignOffset({ align: 'start', itemsToShow: 3 })).toBe(0)
     })
+  })
 
+  describe('with slideSize and viewportSize parameters', () => {
     test('should return correct offset for center/center-odd alignment', () => {
       expect(
         getSnapAlignOffset({
@@ -70,31 +86,15 @@ describe('getSnapAlignOffset', () => {
         })
       ).toBe(600)
     })
-  })
-
-  describe('edge cases', () => {
-    test('should return 0 when no parameters provided', () => {
-      expect(getSnapAlignOffset({ align: 'start' })).toBe(0)
-    })
 
-    test('should return 0 for invalid alignment', () => {
+    test('should return correct offset for start alignment', () => {
       expect(
         getSnapAlignOffset({
-          align: 'invalid' as any,
+          align: 'start',
           slideSize: 200,
           viewportSize: 800,
         })
       ).toBe(0)
     })
-
-    test('should handle equal viewport and slide sizes', () => {
-      expect(
-        getSnapAlignOffset({
-          align: 'center',
-          slideSize: 800,
-          viewportSize: 800,
-        })
-      ).toBe(0)
-    })
   })
 })

src/utils/getSnapAlignOffset.ts

@@ -1,6 +1,6 @@
 import { SnapAlign } from '@/shared'
 
-interface SnapAlignOffsetParams {
+type SnapAlignOffsetParams = {
   align: SnapAlign
   slideSize?: number
   viewportSize?: number

src/utils/i18nFormatter.spec.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest'
+
+import { i18nFormatter } from './i18nFormatter'
+
+describe('i18nFormatter', () => {
+  it('handles empty string input', () => {
+    const result = i18nFormatter('', { name: 'World' })
+    expect(result).toBe('')
+  })
+
+  it('handles no values input', () => {
+    const result = i18nFormatter('Hello, World!')
+    expect(result).toBe('Hello, World!')
+  })
+
+  it('leaves placeholders without corresponding values unchanged', () => {
+    const result = i18nFormatter('Hello, {name}!', {})
+    expect(result).toBe('Hello, {name}!')
+  })
+
+  it('replaces multiple placeholders', () => {
+    const result = i18nFormatter('Hello, {name}! You have {count} messages.', {
+      name: 'Alice',
+      count: 5,
+    })
+    expect(result).toBe('Hello, Alice! You have 5 messages.')
+  })
+
+  it('replaces placeholders with corresponding values', () => {
+    const result = i18nFormatter('Hello, {name}!', { name: 'World' })
+    expect(result).toBe('Hello, World!')
+  })
+})