feat: add istanbul coverage provider (#399)

Co-authored-by: gaoyuan.1226 <[email protected]>

Author: travzhang

.gitignore

@@ -34,3 +34,5 @@ test-results/
 fixtures-test/
 fixtures-test-*/
 .rslib/
+
+!packages/core/src/coverage

cspell.config.cjs

@@ -18,6 +18,7 @@ module.exports = {
     'node_modules',
     'pnpm-lock.yaml',
     'LICENSE.md',
+    'fixtures',
   ],
   flagWords: banWords,
   dictionaries: ['dictionary'],

e2e/test-coverage/fixtures/package.json

@@ -0,0 +1,12 @@
+{
+  "private": true,
+  "name": "@rstest/tests-coverage",
+  "main": "index.js",
+  "type": "module",
+  "sideEffects": true,
+  "version": "1.0.0",
+  "devDependencies": {
+    "@rstest/core": "workspace:*",
+    "@rstest/coverage-istanbul": "workspace:*"
+  }
+}

e2e/test-coverage/fixtures/rstest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from '@rstest/core';
+
+export default defineConfig({
+  coverage: {
+    enabled: true,
+    provider: 'istanbul',
+  },
+});

e2e/test-coverage/fixtures/src/array.ts

@@ -0,0 +1,38 @@
+export const removeDuplicates = <T>(arr: T[]): T[] => {
+  return [...new Set(arr)];
+};
+
+export const chunk = <T>(arr: T[], size: number): T[][] => {
+  if (size <= 0) {
+    throw new Error('Chunk size must be greater than 0');
+  }
+  const result: T[][] = [];
+  for (let i = 0; i < arr.length; i += size) {
+    result.push(arr.slice(i, i + size));
+  }
+  return result;
+};
+
+export const flatten = <T>(arr: (T | T[])[]): T[] => {
+  return arr.reduce<T[]>((acc, val) => {
+    return acc.concat(Array.isArray(val) ? flatten(val) : val);
+  }, []);
+};
+
+export const findMax = (arr: number[]): number => {
+  if (arr.length === 0) {
+    throw new Error('Array cannot be empty');
+  }
+  return Math.max(...arr);
+};
+
+export const shuffle = <T>(arr: T[]): T[] => {
+  const shuffled = [...arr];
+  for (let i = shuffled.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = shuffled[i]!;
+    shuffled[i] = shuffled[j]!;
+    shuffled[j] = temp;
+  }
+  return shuffled;
+};

e2e/test-coverage/fixtures/src/date.ts

@@ -0,0 +1,30 @@
+export const formatDate = (date: Date, format = 'YYYY-MM-DD'): string => {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+
+  return format
+    .replace('YYYY', year.toString())
+    .replace('MM', month)
+    .replace('DD', day);
+};
+
+export const addDays = (date: Date, days: number): Date => {
+  const result = new Date(date);
+  result.setDate(result.getDate() + days);
+  return result;
+};
+
+export const getDaysBetween = (date1: Date, date2: Date): number => {
+  const timeDiff = Math.abs(date2.getTime() - date1.getTime());
+  return Math.ceil(timeDiff / (1000 * 3600 * 24));
+};
+
+export const isWeekend = (date: Date): boolean => {
+  const day = date.getDay();
+  return day === 0 || day === 6; // Sunday = 0, Saturday = 6
+};
+
+export const getQuarter = (date: Date): number => {
+  return Math.floor((date.getMonth() + 3) / 3);
+};

e2e/test-coverage/fixtures/src/index.ts

@@ -0,0 +1 @@
+export const sayHi = () => 'hi';

e2e/test-coverage/fixtures/src/string.ts

@@ -0,0 +1,25 @@
+export const capitalize = (str: string): string => {
+  if (!str) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+};
+
+export const reverseString = (str: string): string => {
+  return str.split('').reverse().join('');
+};
+
+export const isPalindrome = (str: string): boolean => {
+  const cleaned = str.toLowerCase().replace(/[^a-z0-9]/g, '');
+  return cleaned === cleaned.split('').reverse().join('');
+};
+
+export const countWords = (str: string): number => {
+  return str
+    .trim()
+    .split(/\s+/)
+    .filter((word) => word.length > 0).length;
+};
+
+export const truncate = (str: string, maxLength: number): string => {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + '...';
+};

e2e/test-coverage/fixtures/test/array.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from '@rstest/core';
+import {
+  chunk,
+  findMax,
+  flatten,
+  removeDuplicates,
+  shuffle,
+} from '../src/array';
+
+describe('Array Utils', () => {
+  describe('removeDuplicates', () => {
+    it('should remove duplicate numbers', () => {
+      expect(removeDuplicates([1, 2, 2, 3, 3, 4])).toEqual([1, 2, 3, 4]);
+    });
+
+    it('should remove duplicate strings', () => {
+      expect(removeDuplicates(['a', 'b', 'b', 'c'])).toEqual(['a', 'b', 'c']);
+    });
+
+    it('should handle empty array', () => {
+      expect(removeDuplicates([])).toEqual([]);
+    });
+  });
+
+  describe('chunk', () => {
+    it('should chunk array into specified size', () => {
+      expect(chunk([1, 2, 3, 4, 5, 6], 2)).toEqual([
+        [1, 2],
+        [3, 4],
+        [5, 6],
+      ]);
+    });
+
+    it('should handle remainder elements', () => {
+      expect(chunk([1, 2, 3, 4, 5], 2)).toEqual([[1, 2], [3, 4], [5]]);
+    });
+
+    it('should throw error for invalid chunk size', () => {
+      expect(() => chunk([1, 2, 3], 0)).toThrow(
+        'Chunk size must be greater than 0',
+      );
+    });
+  });
+
+  describe('flatten', () => {
+    it('should flatten nested arrays', () => {
+      expect(flatten([1, [2, 3], [4, [5, 6]]])).toEqual([1, 2, 3, 4, 5, 6]);
+    });
+
+    it('should handle empty arrays', () => {
+      expect(flatten([])).toEqual([]);
+    });
+  });
+
+  describe('findMax', () => {
+    it('should find maximum number', () => {
+      expect(findMax([1, 5, 3, 9, 2])).toBe(9);
+    });
+
+    it('should throw error for empty array', () => {
+      expect(() => findMax([])).toThrow('Array cannot be empty');
+    });
+  });
+
+  describe('shuffle', () => {
+    it('should return array with same length', () => {
+      const original = [1, 2, 3, 4, 5];
+      const shuffled = shuffle(original);
+      expect(shuffled).toHaveLength(original.length);
+    });
+
+    it('should contain all original elements', () => {
+      const original = [1, 2, 3, 4, 5];
+      const shuffled = shuffle(original);
+      expect(shuffled.sort()).toEqual(original.sort());
+    });
+  });
+});

e2e/test-coverage/fixtures/test/date.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from '@rstest/core';
+import {
+  addDays,
+  formatDate,
+  getDaysBetween,
+  getQuarter,
+  isWeekend,
+} from '../src/date';
+
+describe('Date Utils', () => {
+  describe('formatDate', () => {
+    it('should format date with default format', () => {
+      const date = new Date('2023-12-25');
+      expect(formatDate(date)).toBe('2023-12-25');
+    });
+
+    it('should format date with custom format', () => {
+      const date = new Date('2023-12-25');
+      expect(formatDate(date, 'DD/MM/YYYY')).toBe('25/12/2023');
+    });
+  });
+
+  describe('addDays', () => {
+    it('should add days to date', () => {
+      const date = new Date('2023-12-25');
+      const result = addDays(date, 5);
+      expect(result.getDate()).toBe(30);
+    });
+
+    it('should subtract days from date', () => {
+      const date = new Date('2023-12-25');
+      const result = addDays(date, -5);
+      expect(result.getDate()).toBe(20);
+    });
+  });
+
+  describe('getDaysBetween', () => {
+    it('should calculate days between two dates', () => {
+      const date1 = new Date('2023-12-25');
+      const date2 = new Date('2023-12-30');
+      expect(getDaysBetween(date1, date2)).toBe(5);
+    });
+
+    it('should handle reversed dates', () => {
+      const date1 = new Date('2023-12-30');
+      const date2 = new Date('2023-12-25');
+      expect(getDaysBetween(date1, date2)).toBe(5);
+    });
+  });
+
+  describe('isWeekend', () => {
+    it('should return true for Saturday', () => {
+      const saturday = new Date('2023-12-23'); // Saturday
+      expect(isWeekend(saturday)).toBe(true);
+    });
+
+    it('should return true for Sunday', () => {
+      const sunday = new Date('2023-12-24'); // Sunday
+      expect(isWeekend(sunday)).toBe(true);
+    });
+
+    it('should return false for weekday', () => {
+      const monday = new Date('2023-12-25'); // Monday
+      expect(isWeekend(monday)).toBe(false);
+    });
+  });
+
+  describe('getQuarter', () => {
+    it('should return correct quarter for different months', () => {
+      expect(getQuarter(new Date('2023-01-15'))).toBe(1);
+      expect(getQuarter(new Date('2023-04-15'))).toBe(2);
+      expect(getQuarter(new Date('2023-07-15'))).toBe(3);
+      expect(getQuarter(new Date('2023-10-15'))).toBe(4);
+    });
+  });
+});