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.
228 lines (208 loc) • 8.79 kB
text/typescript
import ProcessHelper from '../../tests/util/ProcessHelper';
import { FORMAT_HTML, FORMAT_PLAIN, FORMATS, LINE_ENDINGS, SUPPORTED_PLATFORMS } from '../constants';
import VeganIpsum from './VeganIpsum';
/**
* Unit tests for the VeganIpsum class covering formatting, generation,
* and platform-specific behavior across typical usage scenarios.
*/
describe('VeganIpsum', () => {
// Helper to mock and reset the platform during tests.
const process = new ProcessHelper();
/**
* Reset the platform to its original state after each test.
*/
afterEach(() => process.resetPlatform());
/**
* Test case: Should throw an error if instantiated with an unsupported format.
*/
test('Should throw an error if instantiated with an unsupported format', () => {
try {
// @ts-expect-error - Intentionally passing an invalid format
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const lorem = new VeganIpsum({}, 'blade');
} catch (error) {
// Expect an error to be thrown with a specific message
expect(error).toBeDefined();
// Expect the error message to indicate the invalid format and list supported formats
expect((error as Error).message).toEqual(`blade is an invalid format. Please use ${FORMATS.join(' or ')}.`);
}
});
/**
* Tests for the `getLineEnding` method.
*/
describe('getLineEnding', () => {
/**
* Test case: Should return WIN32 line ending on WIN32 platform.
*/
test('Should return WIN32 line ending on WIN32', () => {
const lorem = new VeganIpsum();
process.setPlatform(SUPPORTED_PLATFORMS.WIN32);
// Expect the line ending to be WIN32 when the platform is set to WIN32
expect(lorem.getLineEnding()).toEqual(LINE_ENDINGS.WIN32);
});
/**
* Test case: Should return POSIX line ending on Mac or Linux platforms.
*/
test('Should return POSIX line ending on Mac or Linux', () => {
const lorem = new VeganIpsum();
[SUPPORTED_PLATFORMS.DARWIN, SUPPORTED_PLATFORMS.LINUX].forEach((platform) => {
process.setPlatform(platform);
// Expect the line ending to be POSIX when the platform is set to Darwin or Linux
expect(lorem.getLineEnding()).toEqual(LINE_ENDINGS.POSIX);
});
});
/**
* Test case: Should return the custom suffix if it was set.
*/
test("Should return the 'suffix' if it was set", () => {
const lorem = new VeganIpsum({}, FORMAT_PLAIN, '*');
// Expect the line ending to be the custom suffix when it is set in the constructor
expect(lorem.getLineEnding()).toEqual('*');
});
});
/**
* Tests for the `formatString` method.
*/
describe('formatString', () => {
const str: string = 'string';
/**
* Test case: Should return the string by default.
*/
test('Should return the string by default', () => {
const lorem = new VeganIpsum();
// Expect the formatString method to return the input string unchanged when using the default format
expect(lorem.formatString(str)).toEqual(str);
});
/**
* Test case: Should return the string if the format is set to 'plain'.
*/
test("Should return the string if the format is set to 'plain'", () => {
const lorem = new VeganIpsum({}, FORMAT_PLAIN);
// Expect the formatString method to return the input string unchanged when the format is set to 'plain'
expect(lorem.formatString(str)).toEqual(str);
});
/**
* Test case: Should return the string wrapped in <p> tags if the format is set to 'html'.
*/
test("Should return the string wrapped in p tags if the format is set to 'html'", () => {
const lorem = new VeganIpsum({}, FORMAT_HTML);
// Expect the formatString method to return the input string wrapped in <p> tags when the format is set to 'html'
expect(lorem.formatString(str)).toEqual(`<p>${str}</p>`);
});
});
/**
* Tests for the `formatStrings` method.
*/
describe('formatStrings', () => {
const strings: string[] = ['string', 'string-a', 'string-b'];
/**
* Test case: Should return the strings by default.
*/
test('Should return the string by default', () => {
const lorem = new VeganIpsum();
const results = lorem.formatStrings(strings);
results.forEach((result, index) => {
// Expect each formatted string to equal the corresponding input string when using the default format
expect(result).toEqual(strings[index]);
});
});
/**
* Test case: Should return the strings if the format is set to 'plain'.
*/
test("Should return the string if the format is set to 'plain'", () => {
const lorem = new VeganIpsum({}, FORMAT_PLAIN);
const results = lorem.formatStrings(strings);
results.forEach((result, index) => {
// Expect each formatted string to equal the corresponding input string when the format is set to 'plain'
expect(result).toEqual(strings[index]);
});
});
/**
* Test case: Should return the strings wrapped in <p> tags if the format is set to 'html'.
*/
test("Should return the string wrapped in p tags if the foramt is set to 'html'", () => {
const lorem = new VeganIpsum({}, FORMAT_HTML);
const results = lorem.formatStrings(strings);
results.forEach((result, index) => {
// Expect each formatted string to equal the corresponding input string wrapped in <p> tags when the format is set to 'html'
expect(result).toEqual(`<p>${strings[index]}</p>`);
});
});
});
/**
* Tests for the `generateWords` method.
*/
describe('generateWords', () => {
/**
* Test case: Should generate a specific number of words.
*/
test('should generate a specific number of words', () => {
const lorem = new VeganIpsum();
const results = lorem.generateWords(7);
const words = results.split(' ');
// Expect the number of words to match the specified count of 7 when generateWords is called with 7
expect(words).toHaveLength(7);
});
/**
* Test case: Should generate a number of words between the min and max.
*/
test('should generate a number of words between the min and max', () => {
const max = 5;
const min = 3;
const lorem = new VeganIpsum({ wordsPerSentence: { max, min } });
for (let i = 0; i < 100; i++) {
const results = lorem.generateWords();
const words = results.split(' ');
// Expect the number of words to be between the specified min and max when generateWords is called without arguments and the wordsPerSentence option is set
expect(words.length <= max).toEqual(true);
expect(words.length >= min).toEqual(true);
}
});
});
/**
* Tests for the `generateSentences` method.
*/
describe('generateSentences', () => {
/**
* Test case: Should generate a specific number of sentences.
*/
test('should generate a specific number of sentences', () => {
const lorem = new VeganIpsum();
const results = lorem.generateSentences(18);
const sentences = results.split('. ');
// Expect the number of sentences to match the specified count of 18 when generateSentences is called with 18
expect(sentences).toHaveLength(18);
});
/**
* Test case: Should generate a number of sentences between the min and max.
*/
test('should generate a number of sentences between the min and max', () => {
const max = 19;
const min = 16;
const lorem = new VeganIpsum({ sentencesPerParagraph: { max, min } });
for (let i = 0; i < 100; i++) {
const results = lorem.generateSentences();
const sentences = results.split('. ');
// Expect the number of sentences to be between the specified min and max when generateSentences is called without arguments and the sentencesPerParagraph option is set
expect(sentences.length <= max).toEqual(true);
expect(sentences.length >= min).toEqual(true);
}
});
});
/**
* Tests for the `generateParagraphs` method.
*/
describe('generateParagraphs', () => {
/**
* Test case: Should generate a specific number of paragraphs.
*/
test('should generate a specific number of paragraphs', () => {
process.setPlatform(SUPPORTED_PLATFORMS.WIN32);
const lorem = new VeganIpsum();
const results = lorem.generateParagraphs(3);
const paragraphs = results.split(LINE_ENDINGS.WIN32);
// Expect the number of paragraphs to match the specified count of 3 when generateParagraphs is called with 3 and the platform is set to WIN32
expect(paragraphs).toHaveLength(3);
});
});
});