Welcome to mirror list, hosted at ThFree Co, Russian Federation.

gitlab.com/gitlab-org/gitlab-foss.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/spec/frontend/lib/utils/unit_format/index_spec.js
diff options
context:
space:
mode:
Diffstat (limited to 'spec/frontend/lib/utils/unit_format/index_spec.js')
-rw-r--r--spec/frontend/lib/utils/unit_format/index_spec.js304
1 files changed, 180 insertions, 124 deletions
diff --git a/spec/frontend/lib/utils/unit_format/index_spec.js b/spec/frontend/lib/utils/unit_format/index_spec.js
index 5b2fdf1f02b..7fd273f1b58 100644
--- a/spec/frontend/lib/utils/unit_format/index_spec.js
+++ b/spec/frontend/lib/utils/unit_format/index_spec.js
@@ -1,157 +1,213 @@
-import { getFormatter, SUPPORTED_FORMATS } from '~/lib/utils/unit_format';
+import {
+ number,
+ percent,
+ percentHundred,
+ seconds,
+ milliseconds,
+ decimalBytes,
+ kilobytes,
+ megabytes,
+ gigabytes,
+ terabytes,
+ petabytes,
+ bytes,
+ kibibytes,
+ mebibytes,
+ gibibytes,
+ tebibytes,
+ pebibytes,
+ engineering,
+ getFormatter,
+ SUPPORTED_FORMATS,
+} from '~/lib/utils/unit_format';
describe('unit_format', () => {
- describe('when a supported format is provided, the returned function formats', () => {
- it('numbers, by default', () => {
- expect(getFormatter()(1)).toBe('1');
- });
-
- it('numbers', () => {
- const formatNumber = getFormatter(SUPPORTED_FORMATS.number);
-
- expect(formatNumber(1)).toBe('1');
- expect(formatNumber(100)).toBe('100');
- expect(formatNumber(1000)).toBe('1,000');
- expect(formatNumber(10000)).toBe('10,000');
- expect(formatNumber(1000000)).toBe('1,000,000');
- });
-
- it('percent', () => {
- const formatPercent = getFormatter(SUPPORTED_FORMATS.percent);
+ it('engineering', () => {
+ expect(engineering(1)).toBe('1');
+ expect(engineering(100)).toBe('100');
+ expect(engineering(1000)).toBe('1k');
+ expect(engineering(10_000)).toBe('10k');
+ expect(engineering(1_000_000)).toBe('1M');
+
+ expect(engineering(10 ** 9)).toBe('1G');
+ });
- expect(formatPercent(1)).toBe('100%');
- expect(formatPercent(1, 2)).toBe('100.00%');
+ it('number', () => {
+ expect(number(1)).toBe('1');
+ expect(number(100)).toBe('100');
+ expect(number(1000)).toBe('1,000');
+ expect(number(10_000)).toBe('10,000');
+ expect(number(1_000_000)).toBe('1,000,000');
- expect(formatPercent(0.1)).toBe('10%');
- expect(formatPercent(0.5)).toBe('50%');
+ expect(number(10 ** 9)).toBe('1,000,000,000');
+ });
- expect(formatPercent(0.888888)).toBe('89%');
- expect(formatPercent(0.888888, 2)).toBe('88.89%');
- expect(formatPercent(0.888888, 5)).toBe('88.88880%');
+ it('percent', () => {
+ expect(percent(1)).toBe('100%');
+ expect(percent(1, 2)).toBe('100.00%');
- expect(formatPercent(2)).toBe('200%');
- expect(formatPercent(10)).toBe('1,000%');
- });
+ expect(percent(0.1)).toBe('10%');
+ expect(percent(0.5)).toBe('50%');
- it('percentunit', () => {
- const formatPercentHundred = getFormatter(SUPPORTED_FORMATS.percentHundred);
+ expect(percent(0.888888)).toBe('89%');
+ expect(percent(0.888888, 2)).toBe('88.89%');
+ expect(percent(0.888888, 5)).toBe('88.88880%');
- expect(formatPercentHundred(1)).toBe('1%');
- expect(formatPercentHundred(1, 2)).toBe('1.00%');
-
- expect(formatPercentHundred(88.8888)).toBe('89%');
- expect(formatPercentHundred(88.8888, 2)).toBe('88.89%');
- expect(formatPercentHundred(88.8888, 5)).toBe('88.88880%');
+ expect(percent(2)).toBe('200%');
+ expect(percent(10)).toBe('1,000%');
+ });
- expect(formatPercentHundred(100)).toBe('100%');
- expect(formatPercentHundred(100, 2)).toBe('100.00%');
+ it('percentHundred', () => {
+ expect(percentHundred(1)).toBe('1%');
+ expect(percentHundred(1, 2)).toBe('1.00%');
- expect(formatPercentHundred(200)).toBe('200%');
- expect(formatPercentHundred(1000)).toBe('1,000%');
- });
+ expect(percentHundred(88.8888)).toBe('89%');
+ expect(percentHundred(88.8888, 2)).toBe('88.89%');
+ expect(percentHundred(88.8888, 5)).toBe('88.88880%');
- it('seconds', () => {
- expect(getFormatter(SUPPORTED_FORMATS.seconds)(1)).toBe('1s');
- });
+ expect(percentHundred(100)).toBe('100%');
+ expect(percentHundred(100, 2)).toBe('100.00%');
- it('milliseconds', () => {
- const formatMilliseconds = getFormatter(SUPPORTED_FORMATS.milliseconds);
+ expect(percentHundred(200)).toBe('200%');
+ expect(percentHundred(1000)).toBe('1,000%');
+ });
- expect(formatMilliseconds(1)).toBe('1ms');
- expect(formatMilliseconds(100)).toBe('100ms');
- expect(formatMilliseconds(1000)).toBe('1,000ms');
- expect(formatMilliseconds(10000)).toBe('10,000ms');
- expect(formatMilliseconds(1000000)).toBe('1,000,000ms');
- });
+ it('seconds', () => {
+ expect(seconds(1)).toBe('1s');
+ });
- it('decimalBytes', () => {
- const formatDecimalBytes = getFormatter(SUPPORTED_FORMATS.decimalBytes);
-
- expect(formatDecimalBytes(1)).toBe('1B');
- expect(formatDecimalBytes(1, 1)).toBe('1.0B');
-
- expect(formatDecimalBytes(10)).toBe('10B');
- expect(formatDecimalBytes(10 ** 2)).toBe('100B');
- expect(formatDecimalBytes(10 ** 3)).toBe('1kB');
- expect(formatDecimalBytes(10 ** 4)).toBe('10kB');
- expect(formatDecimalBytes(10 ** 5)).toBe('100kB');
- expect(formatDecimalBytes(10 ** 6)).toBe('1MB');
- expect(formatDecimalBytes(10 ** 7)).toBe('10MB');
- expect(formatDecimalBytes(10 ** 8)).toBe('100MB');
- expect(formatDecimalBytes(10 ** 9)).toBe('1GB');
- expect(formatDecimalBytes(10 ** 10)).toBe('10GB');
- expect(formatDecimalBytes(10 ** 11)).toBe('100GB');
- });
+ it('milliseconds', () => {
+ expect(milliseconds(1)).toBe('1ms');
+ expect(milliseconds(100)).toBe('100ms');
+ expect(milliseconds(1000)).toBe('1,000ms');
+ expect(milliseconds(10_000)).toBe('10,000ms');
+ expect(milliseconds(1_000_000)).toBe('1,000,000ms');
+ });
- it('kilobytes', () => {
- expect(getFormatter(SUPPORTED_FORMATS.kilobytes)(1)).toBe('1kB');
- expect(getFormatter(SUPPORTED_FORMATS.kilobytes)(1, 1)).toBe('1.0kB');
- });
+ it('decimalBytes', () => {
+ expect(decimalBytes(1)).toBe('1B');
+ expect(decimalBytes(1, 1)).toBe('1.0B');
+
+ expect(decimalBytes(10)).toBe('10B');
+ expect(decimalBytes(10 ** 2)).toBe('100B');
+ expect(decimalBytes(10 ** 3)).toBe('1kB');
+ expect(decimalBytes(10 ** 4)).toBe('10kB');
+ expect(decimalBytes(10 ** 5)).toBe('100kB');
+ expect(decimalBytes(10 ** 6)).toBe('1MB');
+ expect(decimalBytes(10 ** 7)).toBe('10MB');
+ expect(decimalBytes(10 ** 8)).toBe('100MB');
+ expect(decimalBytes(10 ** 9)).toBe('1GB');
+ expect(decimalBytes(10 ** 10)).toBe('10GB');
+ expect(decimalBytes(10 ** 11)).toBe('100GB');
+ });
- it('megabytes', () => {
- expect(getFormatter(SUPPORTED_FORMATS.megabytes)(1)).toBe('1MB');
- expect(getFormatter(SUPPORTED_FORMATS.megabytes)(1, 1)).toBe('1.0MB');
- });
+ it('kilobytes', () => {
+ expect(kilobytes(1)).toBe('1kB');
+ expect(kilobytes(1, 1)).toBe('1.0kB');
+ });
- it('gigabytes', () => {
- expect(getFormatter(SUPPORTED_FORMATS.gigabytes)(1)).toBe('1GB');
- expect(getFormatter(SUPPORTED_FORMATS.gigabytes)(1, 1)).toBe('1.0GB');
- });
+ it('megabytes', () => {
+ expect(megabytes(1)).toBe('1MB');
+ expect(megabytes(1, 1)).toBe('1.0MB');
+ });
- it('terabytes', () => {
- expect(getFormatter(SUPPORTED_FORMATS.terabytes)(1)).toBe('1TB');
- expect(getFormatter(SUPPORTED_FORMATS.terabytes)(1, 1)).toBe('1.0TB');
- });
+ it('gigabytes', () => {
+ expect(gigabytes(1)).toBe('1GB');
+ expect(gigabytes(1, 1)).toBe('1.0GB');
+ });
- it('petabytes', () => {
- expect(getFormatter(SUPPORTED_FORMATS.petabytes)(1)).toBe('1PB');
- expect(getFormatter(SUPPORTED_FORMATS.petabytes)(1, 1)).toBe('1.0PB');
- });
+ it('terabytes', () => {
+ expect(terabytes(1)).toBe('1TB');
+ expect(terabytes(1, 1)).toBe('1.0TB');
+ });
- it('bytes', () => {
- const formatBytes = getFormatter(SUPPORTED_FORMATS.bytes);
+ it('petabytes', () => {
+ expect(petabytes(1)).toBe('1PB');
+ expect(petabytes(1, 1)).toBe('1.0PB');
+ });
- expect(formatBytes(1)).toBe('1B');
- expect(formatBytes(1, 1)).toBe('1.0B');
+ it('bytes', () => {
+ expect(bytes(1)).toBe('1B');
+ expect(bytes(1, 1)).toBe('1.0B');
- expect(formatBytes(10)).toBe('10B');
- expect(formatBytes(100)).toBe('100B');
- expect(formatBytes(1000)).toBe('1,000B');
+ expect(bytes(10)).toBe('10B');
+ expect(bytes(100)).toBe('100B');
+ expect(bytes(1000)).toBe('1,000B');
- expect(formatBytes(1 * 1024)).toBe('1KiB');
- expect(formatBytes(1 * 1024 ** 2)).toBe('1MiB');
- expect(formatBytes(1 * 1024 ** 3)).toBe('1GiB');
- });
+ expect(bytes(1 * 1024)).toBe('1KiB');
+ expect(bytes(1 * 1024 ** 2)).toBe('1MiB');
+ expect(bytes(1 * 1024 ** 3)).toBe('1GiB');
+ });
- it('kibibytes', () => {
- expect(getFormatter(SUPPORTED_FORMATS.kibibytes)(1)).toBe('1KiB');
- expect(getFormatter(SUPPORTED_FORMATS.kibibytes)(1, 1)).toBe('1.0KiB');
- });
+ it('kibibytes', () => {
+ expect(kibibytes(1)).toBe('1KiB');
+ expect(kibibytes(1, 1)).toBe('1.0KiB');
+ });
- it('mebibytes', () => {
- expect(getFormatter(SUPPORTED_FORMATS.mebibytes)(1)).toBe('1MiB');
- expect(getFormatter(SUPPORTED_FORMATS.mebibytes)(1, 1)).toBe('1.0MiB');
- });
+ it('mebibytes', () => {
+ expect(mebibytes(1)).toBe('1MiB');
+ expect(mebibytes(1, 1)).toBe('1.0MiB');
+ });
- it('gibibytes', () => {
- expect(getFormatter(SUPPORTED_FORMATS.gibibytes)(1)).toBe('1GiB');
- expect(getFormatter(SUPPORTED_FORMATS.gibibytes)(1, 1)).toBe('1.0GiB');
- });
+ it('gibibytes', () => {
+ expect(gibibytes(1)).toBe('1GiB');
+ expect(gibibytes(1, 1)).toBe('1.0GiB');
+ });
- it('tebibytes', () => {
- expect(getFormatter(SUPPORTED_FORMATS.tebibytes)(1)).toBe('1TiB');
- expect(getFormatter(SUPPORTED_FORMATS.tebibytes)(1, 1)).toBe('1.0TiB');
- });
+ it('tebibytes', () => {
+ expect(tebibytes(1)).toBe('1TiB');
+ expect(tebibytes(1, 1)).toBe('1.0TiB');
+ });
- it('pebibytes', () => {
- expect(getFormatter(SUPPORTED_FORMATS.pebibytes)(1)).toBe('1PiB');
- expect(getFormatter(SUPPORTED_FORMATS.pebibytes)(1, 1)).toBe('1.0PiB');
- });
+ it('pebibytes', () => {
+ expect(pebibytes(1)).toBe('1PiB');
+ expect(pebibytes(1, 1)).toBe('1.0PiB');
});
- describe('when get formatter format is incorrect', () => {
- it('formatter fails', () => {
- expect(() => getFormatter('not-supported')(1)).toThrow();
+ describe('getFormatter', () => {
+ it.each([
+ [1],
+ [10],
+ [200],
+ [100],
+ [1000],
+ [10_000],
+ [100_000],
+ [1_000_000],
+ [10 ** 6],
+ [10 ** 9],
+ [0.1],
+ [0.5],
+ [0.888888],
+ ])('formatting functions yield the same result as getFormatter for %d', (value) => {
+ expect(number(value)).toBe(getFormatter(SUPPORTED_FORMATS.number)(value));
+ expect(percent(value)).toBe(getFormatter(SUPPORTED_FORMATS.percent)(value));
+ expect(percentHundred(value)).toBe(getFormatter(SUPPORTED_FORMATS.percentHundred)(value));
+
+ expect(seconds(value)).toBe(getFormatter(SUPPORTED_FORMATS.seconds)(value));
+ expect(milliseconds(value)).toBe(getFormatter(SUPPORTED_FORMATS.milliseconds)(value));
+
+ expect(decimalBytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.decimalBytes)(value));
+ expect(kilobytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.kilobytes)(value));
+ expect(megabytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.megabytes)(value));
+ expect(gigabytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.gigabytes)(value));
+ expect(terabytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.terabytes)(value));
+ expect(petabytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.petabytes)(value));
+
+ expect(bytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.bytes)(value));
+ expect(kibibytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.kibibytes)(value));
+ expect(mebibytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.mebibytes)(value));
+ expect(gibibytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.gibibytes)(value));
+ expect(tebibytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.tebibytes)(value));
+ expect(pebibytes(value)).toBe(getFormatter(SUPPORTED_FORMATS.pebibytes)(value));
+
+ expect(engineering(value)).toBe(getFormatter(SUPPORTED_FORMATS.engineering)(value));
+ });
+
+ describe('when get formatter format is incorrect', () => {
+ it('formatter fails', () => {
+ expect(() => getFormatter('not-supported')(1)).toThrow();
+ });
});
});
});
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-20 22:48:04 +0300