feat: tests for update pr script

Author: github-actions[bot]

src/github/__tests__/bundle.test.ts

@@ -0,0 +1,111 @@
+import {
+    generateBundleSizeSection,
+    getBundleInfo,
+} from '../../../.github/workflows/scripts/utils/bundle';
+
+describe('bundle utils', () => {
+    describe('generateBundleSizeSection', () => {
+        it('should generate section for increased bundle size', () => {
+            const bundleInfo = {
+                currentSize: 1024 * 1024 * 2, // 2MB
+                mainSize: 1024 * 1024, // 1MB
+                diff: 1024 * 1024, // 1MB increase
+                percent: '100',
+            };
+
+            const result = generateBundleSizeSection(bundleInfo);
+            expect(result).toContain('Bundle Size: 🔺');
+            expect(result).toContain('Current: 2.00 MB | Main: 1.00 MB');
+            expect(result).toContain('Diff: +1.00 MB (100%)');
+            expect(result).toContain('⚠️ Bundle size increased. Please review.');
+        });
+
+        it('should generate section for decreased bundle size', () => {
+            const bundleInfo = {
+                currentSize: 1024 * 1024, // 1MB
+                mainSize: 1024 * 1024 * 2, // 2MB
+                diff: -1024 * 1024, // 1MB decrease
+                percent: '-50',
+            };
+
+            const result = generateBundleSizeSection(bundleInfo);
+            expect(result).toContain('Bundle Size: 🔽');
+            expect(result).toContain('Current: 1.00 MB | Main: 2.00 MB');
+            expect(result).toContain('Diff: 1.00 MB (-50%)');
+            expect(result).toContain('✅ Bundle size decreased.');
+        });
+
+        it('should generate section for unchanged bundle size', () => {
+            const bundleInfo = {
+                currentSize: 1024 * 1024, // 1MB
+                mainSize: 1024 * 1024, // 1MB
+                diff: 0,
+                percent: '0',
+            };
+
+            const result = generateBundleSizeSection(bundleInfo);
+            expect(result).toContain('Bundle Size: ✅');
+            expect(result).toContain('Current: 1.00 MB | Main: 1.00 MB');
+            expect(result).toContain('Diff: 0.00 KB (0%)');
+            expect(result).toContain('✅ Bundle size unchanged.');
+        });
+
+        it('should handle N/A percent', () => {
+            const bundleInfo = {
+                currentSize: 1024 * 1024, // 1MB
+                mainSize: 0,
+                diff: 1024 * 1024,
+                percent: 'N/A',
+            };
+
+            const result = generateBundleSizeSection(bundleInfo);
+            expect(result).toContain('Bundle Size: ⚠️');
+            expect(result).toContain('Current: 1.00 MB | Main: 0.00 KB');
+            expect(result).toContain('Diff: +1.00 MB (N/A)');
+            expect(result).toContain('⚠️ Unable to calculate change.');
+        });
+    });
+
+    describe('getBundleInfo', () => {
+        const originalEnv = process.env;
+
+        beforeEach(() => {
+            jest.resetModules();
+            process.env = {...originalEnv};
+        });
+
+        afterAll(() => {
+            process.env = originalEnv;
+        });
+
+        it('should get bundle info from environment variables', () => {
+            process.env.CURRENT_SIZE = '2097152'; // 2MB
+            process.env.MAIN_SIZE = '1048576'; // 1MB
+            process.env.SIZE_DIFF = '1048576'; // 1MB
+            process.env.SIZE_PERCENT = '100';
+
+            const result = getBundleInfo();
+            expect(result).toEqual({
+                currentSize: 2097152,
+                mainSize: 1048576,
+                diff: 1048576,
+                percent: '100',
+            });
+        });
+
+        it('should handle missing environment variables', () => {
+            delete process.env.CURRENT_SIZE;
+            delete process.env.MAIN_SIZE;
+            delete process.env.SIZE_DIFF;
+            delete process.env.SIZE_PERCENT;
+
+            const result = getBundleInfo();
+            expect(result).toEqual({
+                currentSize: 0,
+                mainSize: 0,
+                diff: 0,
+                percent: 'N/A',
+            });
+        });
+    });
+});

src/github/__tests__/format.test.ts

@@ -0,0 +1,101 @@
+import {
+    formatSize,
+    generateTestChangesSummary,
+} from '../../../.github/workflows/scripts/utils/format';
+
+describe('format utils', () => {
+    describe('formatSize', () => {
+        it('should format size in KB when less than 1024 bytes', () => {
+            const size = 512; // 512 bytes
+            expect(formatSize(size)).toBe('0.50 KB');
+        });
+
+        it('should format size in MB when greater than or equal to 1024 bytes', () => {
+            const size = 2.5 * 1024; // 2.5 KB -> will be shown in MB
+            expect(formatSize(size)).toBe('0.00 MB');
+        });
+
+        it('should handle small sizes', () => {
+            const size = 100; // 100 bytes
+            expect(formatSize(size)).toBe('0.10 KB');
+        });
+
+        it('should handle zero', () => {
+            expect(formatSize(0)).toBe('0.00 KB');
+        });
+    });
+
+    describe('generateTestChangesSummary', () => {
+        it('should generate summary for new tests only', () => {
+            const comparison = {
+                new: ['Test 1 (file1.ts)', 'Test 2 (file2.ts)'],
+                skipped: [],
+                deleted: [],
+            };
+
+            const summary = generateTestChangesSummary(comparison);
+            expect(summary).toContain('✨ New Tests (2)');
+            expect(summary).toContain('1. Test 1 (file1.ts)');
+            expect(summary).toContain('2. Test 2 (file2.ts)');
+            expect(summary).not.toContain('⏭️ Skipped Tests');
+            expect(summary).not.toContain('🗑️ Deleted Tests');
+        });
+
+        it('should generate summary for skipped tests only', () => {
+            const comparison = {
+                new: [],
+                skipped: ['Test 1 (file1.ts)', 'Test 2 (file2.ts)'],
+                deleted: [],
+            };
+
+            const summary = generateTestChangesSummary(comparison);
+            expect(summary).toContain('⏭️ Skipped Tests (2)');
+            expect(summary).toContain('1. Test 1 (file1.ts)');
+            expect(summary).toContain('2. Test 2 (file2.ts)');
+            expect(summary).not.toContain('✨ New Tests');
+            expect(summary).not.toContain('🗑️ Deleted Tests');
+        });
+
+        it('should generate summary for deleted tests only', () => {
+            const comparison = {
+                new: [],
+                skipped: [],
+                deleted: ['Test 1 (file1.ts)', 'Test 2 (file2.ts)'],
+            };
+
+            const summary = generateTestChangesSummary(comparison);
+            expect(summary).toContain('🗑️ Deleted Tests (2)');
+            expect(summary).toContain('1. Test 1 (file1.ts)');
+            expect(summary).toContain('2. Test 2 (file2.ts)');
+            expect(summary).not.toContain('✨ New Tests');
+            expect(summary).not.toContain('⏭️ Skipped Tests');
+        });
+
+        it('should generate summary for all types of changes', () => {
+            const comparison = {
+                new: ['New Test (file1.ts)'],
+                skipped: ['Skipped Test (file2.ts)'],
+                deleted: ['Deleted Test (file3.ts)'],
+            };
+
+            const summary = generateTestChangesSummary(comparison);
+            expect(summary).toContain('✨ New Tests (1)');
+            expect(summary).toContain('⏭️ Skipped Tests (1)');
+            expect(summary).toContain('🗑️ Deleted Tests (1)');
+            expect(summary).toContain('New Test (file1.ts)');
+            expect(summary).toContain('Skipped Test (file2.ts)');
+            expect(summary).toContain('Deleted Test (file3.ts)');
+        });
+
+        it('should handle no changes', () => {
+            const comparison = {
+                new: [],
+                skipped: [],
+                deleted: [],
+            };
+
+            const summary = generateTestChangesSummary(comparison);
+            expect(summary).toBe('😟 No changes in tests. 😕');
+        });
+    });
+});

src/github/__tests__/results.test.ts

@@ -0,0 +1,135 @@
+import fs from 'fs';
+
+import {getTestStatus, readTestResults} from '../../../.github/workflows/scripts/utils/results';
+import type {TestResults, TestResultsInfo, TestStatusInfo} from '../types';
+
+jest.mock('fs');
+
+describe('results utils', () => {
+    describe('readTestResults', () => {
+        beforeEach(() => {
+            jest.clearAllMocks();
+        });
+
+        it('should handle non-existent file', () => {
+            (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+            const result = readTestResults('nonexistent.json');
+            expect(result).toEqual({
+                total: 0,
+                passed: 0,
+                failed: 0,
+                flaky: 0,
+                skipped: 0,
+                tests: [],
+            });
+        });
+
+        it('should read and process test results correctly', () => {
+            const mockTestResults: TestResults = {
+                config: {} as any,
+                suites: [
+                    {
+                        title: 'Test Suite',
+                        file: 'test.spec.ts',
+                        column: 1,
+                        line: 1,
+                        specs: [
+                            {
+                                title: 'Test 1',
+                                ok: true,
+                                tags: [],
+                                id: '1',
+                                file: 'test.spec.ts',
+                                line: 2,
+                                column: 1,
+                                tests: [
+                                    {
+                                        timeout: 5000,
+                                        annotations: [],
+                                        expectedStatus: 'passed',
+                                        projectId: '1',
+                                        projectName: 'test',
+                                        results: [],
+                                        status: 'passed',
+                                    },
+                                ],
+                            },
+                        ],
+                        suites: [],
+                    },
+                ],
+            };
+
+            (fs.existsSync as jest.Mock).mockReturnValue(true);
+            (fs.readFileSync as jest.Mock).mockReturnValue(
+                JSON.stringify({
+                    ...mockTestResults,
+                    stats: {
+                        expected: 5,
+                        unexpected: 2,
+                        flaky: 1,
+                        skipped: 3,
+                    },
+                }),
+            );
+
+            const result = readTestResults('test-results.json');
+            expect(result).toEqual({
+                total: 11,
+                passed: 5,
+                failed: 2,
+                flaky: 1,
+                skipped: 3,
+                tests: expect.any(Array),
+            });
+        });
+    });
+
+    describe('getTestStatus', () => {
+        it('should return failed status when there are failures', () => {
+            const results: TestResultsInfo = {
+                total: 10,
+                passed: 8,
+                failed: 2,
+                flaky: 0,
+                skipped: 0,
+                tests: [],
+            };
+
+            const result = getTestStatus(results) as TestStatusInfo;
+            expect(result.status).toBe('❌ FAILED');
+            expect(result.statusColor).toBe('red');
+        });
+
+        it('should return flaky status when there are flaky tests but no failures', () => {
+            const results: TestResultsInfo = {
+                total: 10,
+                passed: 8,
+                failed: 0,
+                flaky: 2,
+                skipped: 0,
+                tests: [],
+            };
+
+            const result = getTestStatus(results) as TestStatusInfo;
+            expect(result.status).toBe('⚠️ FLAKY');
+            expect(result.statusColor).toBe('orange');
+        });
+
+        it('should return passed status when all tests pass', () => {
+            const results: TestResultsInfo = {
+                total: 10,
+                passed: 10,
+                failed: 0,
+                flaky: 0,
+                skipped: 0,
+                tests: [],
+            };
+
+            const result = getTestStatus(results) as TestStatusInfo;
+            expect(result.status).toBe('✅ PASSED');
+            expect(result.statusColor).toBe('green');
+        });
+    });
+});