chore: add more unit tests (#7371)

* chore: add more unit tests

* chore: text correction

Author: ovflowd

apps/site/components/Common/ActiveLink/__tests__/index.test.mjs

@@ -2,7 +2,6 @@ import { render, screen } from '@testing-library/react';
 
 import ActiveLink from '..';
 
-// mock usePathname, but retain all the other imports
 jest.mock('@/navigation.mjs', () => ({
   ...jest.requireActual('@/navigation.mjs'),
   usePathname: jest.fn(),

apps/site/jest.config.mjs

@@ -1,8 +1,6 @@
 import nextJest from 'next/jest.js';
 
-const createJestConfig = nextJest({
-  dir: './',
-});
+const createJestConfig = nextJest({ dir: './' });
 
 /** @type {import('jest').Config} */
 const customJestConfig = {

apps/site/providers/__tests__/navigationStateProvider.test.mjs

@@ -0,0 +1,25 @@
+import { render } from '@testing-library/react';
+
+import { NavigationStateProvider } from '@/providers/navigationStateProvider';
+
+describe('NavigationStateProvider', () => {
+  it('should render without crashing', () => {
+    const { container } = render(
+      <NavigationStateProvider>
+        <div />
+      </NavigationStateProvider>
+    );
+
+    expect(container).toBeDefined();
+  });
+
+  it('should provide navigation state context', () => {
+    const { getByText } = render(
+      <NavigationStateProvider>
+        <div>Navigation State</div>
+      </NavigationStateProvider>
+    );
+
+    expect(getByText('Navigation State')).toBeDefined();
+  });
+});

apps/site/providers/__tests__/releaseProvider.test.mjs

@@ -0,0 +1,39 @@
+import { render } from '@testing-library/react';
+
+import { ReleaseProvider, ReleasesProvider } from '@/providers/releaseProvider';
+
+describe('ReleaseProvider', () => {
+  it('should render without crashing', () => {
+    const initialRelease = { versionWithPrefix: 'v14.17.0' };
+    const releases = [initialRelease];
+    const snippets = [];
+
+    const { container } = render(
+      <ReleasesProvider releases={releases} snippets={snippets}>
+        <ReleaseProvider initialRelease={initialRelease}>
+          <div />
+        </ReleaseProvider>
+      </ReleasesProvider>
+    );
+
+    expect(container).toBeDefined();
+  });
+
+  it('should set version from parent provider', () => {
+    const initialRelease = { versionWithPrefix: 'v14.17.0' };
+    const releases = [initialRelease];
+    const snippets = [];
+
+    const { getByText } = render(
+      <ReleasesProvider releases={releases} snippets={snippets}>
+        <ReleaseProvider initialRelease={initialRelease}>
+          <ReleaseProvider>
+            <div>Child Provider</div>
+          </ReleaseProvider>
+        </ReleaseProvider>
+      </ReleasesProvider>
+    );
+
+    expect(getByText('Child Provider')).toBeDefined();
+  });
+});

apps/site/reducers/__tests__/releaseReducer.test.mjs

@@ -0,0 +1,78 @@
+import reducer, { releaseState, getActions } from '@/reducers/releaseReducer';
+
+describe('releaseReducer', () => {
+  it('should return the initial state', () => {
+    const initialState = releaseState;
+    const action = { type: 'UNKNOWN_ACTION' };
+    expect(reducer(initialState, action)).toEqual(initialState);
+  });
+
+  it('should handle SET_VERSION action', () => {
+    const initialState = releaseState;
+    const action = { type: 'SET_VERSION', payload: 'v14.17.0' };
+    const expectedState = { ...initialState, version: 'v14.17.0' };
+    expect(reducer(initialState, action)).toEqual(expectedState);
+  });
+
+  it('should handle SET_OS action', () => {
+    const initialState = releaseState;
+    const action = { type: 'SET_OS', payload: 'Linux' };
+    const expectedState = { ...initialState, os: 'Linux' };
+    expect(reducer(initialState, action)).toEqual(expectedState);
+  });
+
+  it('should handle SET_PLATFORM action', () => {
+    const initialState = releaseState;
+    const action = { type: 'SET_PLATFORM', payload: 'arm64' };
+    const expectedState = { ...initialState, platform: 'arm64' };
+    expect(reducer(initialState, action)).toEqual(expectedState);
+  });
+
+  it('should handle SET_INSTALL_METHOD action', () => {
+    const initialState = releaseState;
+    const action = { type: 'SET_INSTALL_METHOD', payload: 'binary' };
+    const expectedState = { ...initialState, installMethod: 'binary' };
+    expect(reducer(initialState, action)).toEqual(expectedState);
+  });
+
+  it('should handle SET_MANAGER action', () => {
+    const initialState = releaseState;
+    const action = { type: 'SET_MANAGER', payload: 'Yarn' };
+    const expectedState = { ...initialState, packageManager: 'Yarn' };
+    expect(reducer(initialState, action)).toEqual(expectedState);
+  });
+});
+
+describe('getActions', () => {
+  it('should create actions correctly', () => {
+    const dispatch = jest.fn();
+    const actions = getActions(dispatch);
+
+    actions.setVersion('v14.17.0');
+    expect(dispatch).toHaveBeenCalledWith({
+      type: 'SET_VERSION',
+      payload: 'v14.17.0',
+    });
+
+    actions.setOS('Linux');
+    expect(dispatch).toHaveBeenCalledWith({ type: 'SET_OS', payload: 'Linux' });
+
+    actions.setPlatform('arm64');
+    expect(dispatch).toHaveBeenCalledWith({
+      type: 'SET_PLATFORM',
+      payload: 'arm64',
+    });
+
+    actions.setInstallMethod('binary');
+    expect(dispatch).toHaveBeenCalledWith({
+      type: 'SET_INSTALL_METHOD',
+      payload: 'binary',
+    });
+
+    actions.setPackageManager('Yarn');
+    expect(dispatch).toHaveBeenCalledWith({
+      type: 'SET_MANAGER',
+      payload: 'Yarn',
+    });
+  });
+});

apps/site/util/__tests__/authorUtils.test.mjs

@@ -2,7 +2,8 @@ import {
   mapAuthorToCardAuthors,
   getAuthorWithId,
   getAuthorWithName,
-} from '../authorUtils';
+  getAuthors,
+} from '@/util/authorUtils';
 
 describe('mapAuthorToCardAuthors', () => {
   it('maps authors to card authors with default avatar source', () => {
@@ -96,3 +97,25 @@ describe('getAuthorWithName', () => {
     ]);
   });
 });
+
+describe('authorUtils', () => {
+  test('mapAuthorToCardAuthors splits authors by common separators', () => {
+    const result = mapAuthorToCardAuthors('Node, React & prepared by Vue');
+    expect(result).toEqual(['Node', 'React', 'Vue']);
+  });
+
+  test('getAuthorWithId returns objects with GitHub avatars', () => {
+    const result = getAuthorWithId(['someUser'], false);
+    expect(result[0].image).toContain('github');
+  });
+
+  test('getAuthorWithName returns known author details or fallback to acronym', () => {
+    const result = getAuthorWithName(['unknownAuthor'], true);
+    expect(result[0].fallback).toBe('U');
+  });
+
+  test('getAuthors uses getAuthorWithId if usernames array is provided', () => {
+    const result = getAuthors({ usernames: ['testUser'] });
+    expect(result[0].nickname).toBe('testUser');
+  });
+});

apps/site/util/__tests__/blogUtils.test.mjs

@@ -0,0 +1,12 @@
+import { mapBlogCategoryToPreviewType } from '@/util/blogUtils';
+
+describe('mapBlogCategoryToPreviewType', () => {
+  test('returns the correct preview type for recognized categories', () => {
+    expect(mapBlogCategoryToPreviewType('release')).toBe('release');
+    expect(mapBlogCategoryToPreviewType('events')).toBe('announcements');
+  });
+
+  test('defaults to announcements for unknown categories', () => {
+    expect(mapBlogCategoryToPreviewType('random')).toBe('announcements');
+  });
+});

apps/site/util/__tests__/dateUtils.test.mjs

@@ -1,7 +1,7 @@
 import { dateIsBetween } from '@/util/dateUtils';
 
 describe('dateIsBetween', () => {
-  it('returns true when the current date is between start and end dates', () => {
+  it('should return true when the current date is between start and end dates', () => {
     const startDate = '2022-01-01T00:00:00.000Z';
     const endDate = '2069-01-01T00:00:00.000Z';
 
@@ -10,7 +10,7 @@ describe('dateIsBetween', () => {
     expect(result).toBe(true);
   });
 
-  it('returns false when the current date is not between start and end dates', () => {
+  it('should return false when the current date is not between start and end dates', () => {
     const startDate = '2010-01-01T00:00:00.000Z';
     const endDate = '2020-01-01T00:00:00.000Z';
 
@@ -19,12 +19,22 @@ describe('dateIsBetween', () => {
     expect(result).toBe(false);
   });
 
-  it('throws when either start or end date is invalid', () => {
+  it('should throw an error when either start or end date is invalid', () => {
     const invalidStartDate = 'Invalid Start Date';
     const validEndDate = '2024-01-01T00:00:00.000Z';
 
     expect(() => dateIsBetween(invalidStartDate, validEndDate)).toThrow(
       'dateIsBetween got called with invalid dates'
     );
   });
+
+  it('should return true if now is between startDate and endDate', () => {
+    const start = new Date(Date.now() - 1000).toISOString();
+    const end = new Date(Date.now() + 1000).toISOString();
+    expect(dateIsBetween(start, end)).toBe(true);
+  });
+
+  it('should throw an error if dates are invalid', () => {
+    expect(() => dateIsBetween('invalid', 'invalid')).toThrow();
+  });
 });

apps/site/util/__tests__/debounce.test.mjs

@@ -1,8 +1,8 @@
 import { debounce } from '@/util/debounce';
 
-describe('debounce', () => {
-  jest.useFakeTimers();
+jest.useFakeTimers();
 
+describe('debounce', () => {
   it('should call the function only once', () => {
     const fn = jest.fn();
     const debouncedFn = debounce(fn, 1000);
@@ -28,4 +28,15 @@ describe('debounce', () => {
 
     expect(fn).toHaveBeenCalledWith(3);
   });
+
+  it('should call the function after the delay', () => {
+    const mockFn = jest.fn();
+    const debouncedFn = debounce(mockFn, 500);
+
+    debouncedFn();
+    expect(mockFn).not.toBeCalled();
+
+    jest.advanceTimersByTime(500);
+    expect(mockFn).toBeCalled();
+  });
 });

apps/site/util/__tests__/deepMerge.test.mjs

@@ -0,0 +1,17 @@
+import deepMerge from '@/util/deepMerge';
+
+describe('deepMerge', () => {
+  it('should merge nested objects', () => {
+    const obj1 = { a: { b: 1 }, c: 2 };
+    const obj2 = { a: { d: 3 }, e: 4 };
+    const result = deepMerge(obj1, obj2);
+    expect(result).toEqual({ a: { b: 1, d: 3 }, c: 2, e: 4 });
+  });
+
+  it('should overwrite primitive properties', () => {
+    const obj1 = { a: 1 };
+    const obj2 = { a: 2 };
+    const result = deepMerge(obj1, obj2);
+    expect(result).toEqual({ a: 2 });
+  });
+});