291 lines
7.8 KiB
JavaScript
291 lines
7.8 KiB
JavaScript
import moment from 'moment';
|
|
import { timeFormatStr } from 'utils/time';
|
|
import {
|
|
groupArray,
|
|
bytesFitler,
|
|
computePercentage,
|
|
firstUpperCase,
|
|
formatSize,
|
|
formatUsedTime,
|
|
generateArray,
|
|
generateId,
|
|
getGBValue,
|
|
getNoValue,
|
|
getOptions,
|
|
getOptionsWithNoset,
|
|
getQueryString,
|
|
getYesNo,
|
|
getYesNoList,
|
|
NoSetValue,
|
|
toLocalTimeFilter,
|
|
updateAddSelectValueToObj,
|
|
updateObjToAddSelectArray,
|
|
uppercaseFilter,
|
|
unescapeHtml,
|
|
isAdminPage,
|
|
} from 'utils/index';
|
|
|
|
describe('test utils index.js', () => {
|
|
it('formatSize', () => {
|
|
expect(formatSize(null)).toBe('-');
|
|
expect(formatSize(undefined)).toBe('-');
|
|
expect(formatSize(NaN)).toBe('-');
|
|
expect(formatSize('')).toBe('-');
|
|
expect(formatSize(1000)).toBe('1000 B');
|
|
expect(formatSize(128012010202)).toBe('119.22 GB');
|
|
expect(formatSize('128012010202')).toBe('128012010202');
|
|
expect(formatSize(10000 * 1024 ** 8)).toBe('9.77 BB');
|
|
expect(formatSize(10000 * 1024 ** 9)).toBe('10000.00 BB');
|
|
});
|
|
|
|
it('formatUsedTime', () => {
|
|
expect(formatUsedTime(900)).toBe('900 ms');
|
|
expect(formatUsedTime(50000)).toBe('50.00 s');
|
|
expect(formatUsedTime(3000000)).toBe('50.00 min');
|
|
expect(formatUsedTime(30000000)).toBe('8.33 h');
|
|
});
|
|
|
|
it('generateId', () => {
|
|
expect(generateId()).toHaveLength(6);
|
|
expect(generateId(10)).toHaveLength(10);
|
|
});
|
|
|
|
it('getQueryString', () => {
|
|
expect(getQueryString({ a: '', b: 'xxx', c: 'yyy' })).toBe('b=xxx&c=yyy');
|
|
});
|
|
|
|
it('getYesNo', () => {
|
|
expect(getYesNo(1)).toBe(t('Yes'));
|
|
expect(getYesNo(true)).toBe(t('Yes'));
|
|
expect(getYesNo(false)).toBe(t('No'));
|
|
expect(getYesNo(null)).toBe(t('No'));
|
|
expect(getYesNo(undefined)).toBe(t('No'));
|
|
expect(getYesNo(NaN)).toBe(t('No'));
|
|
expect(getYesNo('')).toBe(t('No'));
|
|
expect(getYesNo(0)).toBe(t('No'));
|
|
});
|
|
|
|
it('getGBValue', () => {
|
|
expect(getGBValue(1024)).toBe(1);
|
|
expect(getGBValue(2 * 1024)).toBe(2);
|
|
expect(getGBValue(2.554 * 1024)).toBe(2.55);
|
|
expect(getGBValue(2.555 * 1024)).toBe(2.56);
|
|
expect(getGBValue(2.556 * 1024)).toBe(2.56);
|
|
expect(getGBValue(true)).toBe(0);
|
|
expect(getGBValue(false)).toBe(0);
|
|
expect(getGBValue(null)).toBe(0);
|
|
expect(getGBValue(undefined)).toBe(0);
|
|
expect(getGBValue(NaN)).toBe(0);
|
|
expect(getGBValue('')).toBe(0);
|
|
expect(getGBValue(0)).toBe(0);
|
|
});
|
|
|
|
it('getNoValue', () => {
|
|
expect(getNoValue(123)).toBe(123);
|
|
expect(getNoValue('123')).toBe('123');
|
|
expect(getNoValue(true)).toBe(true);
|
|
expect(getNoValue(false)).toBe(false);
|
|
expect(getNoValue(null)).toBe('-');
|
|
expect(getNoValue(undefined)).toBe('-');
|
|
expect(getNoValue(NaN)).toBe(NaN);
|
|
expect(getNoValue('')).toBe('-');
|
|
expect(getNoValue(0)).toBe(0);
|
|
});
|
|
|
|
it('firstUpperCase', () => {
|
|
expect(firstUpperCase(123)).toBe(123);
|
|
expect(firstUpperCase('123')).toBe('123');
|
|
expect(firstUpperCase('abc')).toBe('Abc');
|
|
expect(firstUpperCase('ABC')).toBe('ABC');
|
|
expect(firstUpperCase(true)).toBe(true);
|
|
expect(firstUpperCase(false)).toBe(false);
|
|
expect(firstUpperCase(null)).toBe(null);
|
|
expect(firstUpperCase(undefined)).toBe(undefined);
|
|
expect(firstUpperCase(NaN)).toBe(NaN);
|
|
expect(firstUpperCase('')).toBe('');
|
|
expect(firstUpperCase(0)).toBe(0);
|
|
});
|
|
|
|
it('bytesFitler', () => {
|
|
expect(bytesFitler(-1)).toBe('');
|
|
expect(bytesFitler(NaN)).toBe('');
|
|
expect(bytesFitler(100)).toBe(t('{ size } bytes', { size: '100' }));
|
|
expect(bytesFitler(1024)).toBe(t('{ size } KB', { size: '1.00' }));
|
|
expect(bytesFitler(10 * 1024 ** 2)).toBe(
|
|
t('{ size } MB', { size: '10.00' })
|
|
);
|
|
expect(bytesFitler(1024 ** 2)).toBe(t('{ size } MB', { size: '1.00' }));
|
|
expect(bytesFitler(1024 ** 3)).toBe(t('{ size } GB', { size: '1.00' }));
|
|
expect(bytesFitler(1024 ** 4)).toBe(t('{ size } TB', { size: '1.00' }));
|
|
expect(bytesFitler(3.15 * 1024 ** 4)).toBe(
|
|
t('{ size } TB', { size: '3.15' })
|
|
);
|
|
});
|
|
|
|
it('uppercaseFilter', () => {
|
|
expect(uppercaseFilter(123)).toBe('-');
|
|
expect(uppercaseFilter('123')).toBe('123');
|
|
expect(uppercaseFilter('abc')).toBe('ABC');
|
|
expect(uppercaseFilter('AbC')).toBe('ABC');
|
|
expect(uppercaseFilter('ABC')).toBe('ABC');
|
|
expect(uppercaseFilter(true)).toBe('-');
|
|
expect(uppercaseFilter(false)).toBe('-');
|
|
expect(uppercaseFilter(null)).toBe('-');
|
|
expect(uppercaseFilter(undefined)).toBe('-');
|
|
expect(uppercaseFilter(NaN)).toBe('-');
|
|
expect(uppercaseFilter('')).toBe('-');
|
|
expect(uppercaseFilter(0)).toBe('-');
|
|
});
|
|
|
|
it('toLocalTimeFilter', () => {
|
|
expect(toLocalTimeFilter(1622025465 * 1000)).toBe(
|
|
moment.unix(1622025465).format(timeFormatStr.YMDHms)
|
|
);
|
|
const now = moment();
|
|
expect(toLocalTimeFilter(now.clone().utc().format())).toBe(
|
|
now.clone().format(timeFormatStr.YMDHms)
|
|
);
|
|
});
|
|
|
|
it('getOptions', () => {
|
|
expect(
|
|
getOptions({
|
|
key1: 'Key1',
|
|
key2: 'Key2',
|
|
})
|
|
).toEqual([
|
|
{
|
|
label: 'Key1',
|
|
value: 'key1',
|
|
key: 'key1',
|
|
},
|
|
{
|
|
label: 'Key2',
|
|
value: 'key2',
|
|
key: 'key2',
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('getYesNoList', () => {
|
|
expect(getYesNoList()).toEqual([
|
|
{ value: true, label: t('Yes') },
|
|
{ value: false, label: t('No') },
|
|
]);
|
|
});
|
|
|
|
it('generateArray', () => {
|
|
expect(generateArray(1, 10)).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
|
expect(generateArray(-10, -1)).toEqual([
|
|
-10, -9, -8, -7, -6, -5, -4, -3, -2,
|
|
]);
|
|
expect(generateArray(-2, 2)).toEqual([-2, -1, 0, 1]);
|
|
});
|
|
|
|
it('getOptionsWithNoset', () => {
|
|
expect(
|
|
getOptionsWithNoset({
|
|
key1: 'Key1',
|
|
key2: 'Key2',
|
|
})
|
|
).toEqual([
|
|
{
|
|
value: NoSetValue,
|
|
label: t('Not select'),
|
|
},
|
|
{
|
|
label: 'Key1',
|
|
value: 'key1',
|
|
key: 'key1',
|
|
},
|
|
{
|
|
label: 'Key2',
|
|
value: 'key2',
|
|
key: 'key2',
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('computePercentage', () => {
|
|
expect(computePercentage(10, 20)).toBe(50.0);
|
|
expect(computePercentage(1, 3)).toBe(33.33);
|
|
expect(computePercentage(2, 5)).toBe(40);
|
|
expect(computePercentage(7, 8)).toBe(87.5);
|
|
expect(computePercentage(2, 3)).toBe(66.67);
|
|
});
|
|
|
|
it('groupArray', () => {
|
|
expect(groupArray([1, 2, 3], 3)).toEqual([[1, 2, 3]]);
|
|
expect(groupArray([1, 2, 3], 2)).toEqual([[1, 2], [3]]);
|
|
expect(groupArray([1, 2, 3], 1)).toEqual([[1], [2], [3]]);
|
|
});
|
|
|
|
it('updateObjToAddSelectArray', () => {
|
|
expect(
|
|
updateObjToAddSelectArray({
|
|
key1: 'Key1',
|
|
key2: 'Key2',
|
|
})
|
|
).toEqual([
|
|
{
|
|
index: 0,
|
|
value: {
|
|
key: 'key1',
|
|
value: 'Key1',
|
|
},
|
|
},
|
|
{
|
|
index: 1,
|
|
value: {
|
|
key: 'key2',
|
|
value: 'Key2',
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('updateAddSelectValueToObj', () => {
|
|
expect(
|
|
updateAddSelectValueToObj([
|
|
{
|
|
value: {
|
|
key: 'key1',
|
|
value: 'Key1',
|
|
},
|
|
},
|
|
{
|
|
value: {
|
|
key: 'key2',
|
|
value: 'Key2',
|
|
},
|
|
},
|
|
])
|
|
).toEqual({
|
|
key1: 'Key1',
|
|
key2: 'Key2',
|
|
});
|
|
});
|
|
|
|
it('unescapeHtml', () => {
|
|
expect(unescapeHtml('fred, barney, & pebbles')).toBe(
|
|
'fred, barney, & pebbles'
|
|
);
|
|
expect(unescapeHtml('fred, barney, " pebbles')).toBe(
|
|
'fred, barney, " pebbles'
|
|
);
|
|
expect(unescapeHtml('fred, barney, < pebbles')).toBe(
|
|
'fred, barney, < pebbles'
|
|
);
|
|
expect(unescapeHtml('fred, barney, > pebbles')).toBe(
|
|
'fred, barney, > pebbles'
|
|
);
|
|
});
|
|
|
|
it('isAdminPage', () => {
|
|
expect(isAdminPage('admin')).toBe(true);
|
|
expect(isAdminPage('/admin/')).toBe(true);
|
|
expect(isAdminPage('/a/b/c/admin/d/e/f')).toBe(true);
|
|
expect(isAdminPage('/a/d/m/i/n')).toBe(false);
|
|
});
|
|
});
|