vegan-ipsum
Version:
Generates passages of vegan-themed placeholder text suitable for use in web pages, graphics, and more. Works in the browser, NodeJS, and React Native.
227 lines (196 loc) • 7.61 kB
text/typescript
import fs from 'fs';
import nockExec from 'nock-exec';
import { COPY, CANNOT_DETERMINE_PLATFORM } from './constants';
import { copyToClipboard, getCopyCommand, getPlatform, getVersion, isSupportedPlatform } from './utils';
import ProcessHelper from '../../../tests/util/ProcessHelper';
import { SUPPORTED_PLATFORMS } from '../../constants';
// Parse the `package.json` file to retrieve its contents
const pkg = JSON.parse(fs.readFileSync('package.json', 'utf8'));
/**
* Unit tests for CLI utility helpers verifying clipboard, platform detection,
* and version behaviors under simulated environments.
*/
describe('bin util functions', () => {
/**
* Tests for `copyToClipboard`.
*/
describe('copyToClipboard', () => {
/**
* Helper to mock and reset the platform during tests.
*/
const process = new ProcessHelper();
// Define a sample string to be used in clipboard tests
const str: string = 'Some string';
/**
* Reset the platform to its original state after each test.
*/
afterEach(() => {
process.resetPlatform();
});
/**
* Test case: Should throw an error if the platform is not supported.
*/
test('should throw an error if the platform is not supported', () => {
// Simulate an unsupported platform
process.setPlatform('OS2');
copyToClipboard(str).catch((error) => {
// Expect an error to be thrown with a specific message
expect(error).toBeDefined();
expect(error.message).toEqual(`Copy is not supported for OS2`);
});
});
/**
* Test case: Should copy to the clipboard if the platform is supported.
*/
test('should copy to the clipboard if the platform is supported', () => {
// Simulate a supported platform (Windows)
process.setPlatform(SUPPORTED_PLATFORMS.WIN32);
// Mock the clipboard copy command
nockExec(`echo "${str}" | ${COPY.WIN32}`).reply(0);
copyToClipboard(str).then((result) => {
// Expect the function to resolve with the input string
expect(result).toEqual(str);
});
});
/**
* Test case: Should throw an error if the copy command fails.
*/
test('should throw an error if the copy command does not work', () => {
const errorMessage: string = 'Something went wrong.';
// Simulate a supported platform (Windows)
process.setPlatform(SUPPORTED_PLATFORMS.WIN32);
// Mock the clipboard copy command to simulate an error
nockExec(`echo "${str}" | ${COPY.WIN32}`).err(errorMessage).reply(0);
copyToClipboard(str).catch((error) => {
// Expect an error to be thrown with the mocked error message
expect(error).toBeDefined();
// Expect the error message to match the mocked error message from nockExec
expect(error.message).toEqual(errorMessage);
});
});
/**
* Test case: Should reject when exec callback receives an error.
* This simulates a failure in the underlying system command used for copying to the clipboard.
*/
test('rejects when exec callback receives an error', async () => {
process.setPlatform(SUPPORTED_PLATFORMS.WIN32);
// Mock exec for this test
const execMock = vi.fn();
vi.doMock('child_process', () => ({ exec: execMock }));
// clear module cache
vi.resetModules();
const callbackError = new Error('exec failed');
execMock.mockImplementation(
(_command: string, callback: (error: Error | null, stdout: string, stderr: string) => void) => {
callback(callbackError, '', '');
return undefined;
}
);
const { copyToClipboard } = await import('./utils');
await expect(copyToClipboard('Some string')).rejects.toBe(callbackError);
});
});
/**
* Tests for `getCopyCommand`.
*/
describe('getCopyCommand', () => {
/**
* Test case: Should return the copy command for Mac OSX.
*/
test('Should return the copy command for Mac OSX', () => {
// Expect the copy command for Darwin (Mac OSX) to match the constant
expect(getCopyCommand(SUPPORTED_PLATFORMS.DARWIN)).toEqual(COPY.DARWIN);
});
/**
* Test case: Should return the copy command for Linux.
*/
test('Should return the copy command for Linux', () => {
// Expect the copy command for Linux to match the constant
expect(getCopyCommand(SUPPORTED_PLATFORMS.LINUX)).toEqual(COPY.LINUX);
// Expect the default copy command (when no platform is provided) to be for Linux
expect(getCopyCommand()).toEqual(COPY.LINUX);
});
/**
* Test case: Should return the copy command for Windows.
*/
test('Should return the copy command for Windows', () => {
// Expect the copy command for Windows to match the constant
expect(getCopyCommand(SUPPORTED_PLATFORMS.WIN32)).toEqual(COPY.WIN32);
});
});
/**
* Tests for `getPlatform`.
*/
describe('getPlatform', () => {
/**
* Use the shared ProcessHelper to mock and restore `process.platform`.
*/
const process = new ProcessHelper();
/**
* Reset the platform to its original state after each test to avoid side effects.
*/
afterEach(() => {
process.resetPlatform();
});
/**
* Test case: Should throw an error if it cannot determine the platform.
*/
test('Should throw an error if it cannot determine the platform', () => {
// Simulate an undefined platform
process.setPlatform();
try {
getPlatform();
} catch (error) {
// Expect an error to be thrown with a specific message
expect(error).toBeDefined();
// Expect the error message to indicate that the platform cannot be determined
expect((error as Error).message).toEqual(CANNOT_DETERMINE_PLATFORM);
}
});
/**
* Test case: Should return the platform if it is supported.
*/
test('Should return the platform', () => {
// Iterate over all supported platforms and ensure the function returns the correct platform
Object.values(SUPPORTED_PLATFORMS).forEach((platform: string) => {
process.setPlatform(platform);
// Expect the function to return the correct platform for each supported platform
expect(getPlatform()).toEqual(platform);
});
});
});
/**
* Tests for `getVersion`.
*/
describe('getVersion', () => {
/**
* Test case: Should return the version from `package.json`.
*/
test('Returns the version from package.json', () => {
// Expect the function to return the version field from `package.json`
expect(getVersion()).toEqual(pkg.version);
});
});
/**
* Tests for `isSupportedPlatform`.
*/
describe('isSupportedPlatform', () => {
/**
* Test case: Should return true if the platform is supported.
*/
test('Should return true if the platform is supported', () => {
// Iterate over all supported platforms and ensure the function returns true
Object.values(SUPPORTED_PLATFORMS).forEach((platform: string) => {
// Expect the function to return true for each supported platform
expect(isSupportedPlatform(platform)).toEqual(true);
});
});
/**
* Test case: Should return false if the platform is unsupported.
*/
test('Should return false if the platform is unsupported', () => {
// Expect the function to return false for an unsupported platform
expect(isSupportedPlatform('os2')).toEqual(false);
});
});
});