@rogolev/value 0.0.1 → 0.0.2

package/tests/classes/Convert.test.mjs

@@ -0,0 +1,399 @@
+import { expect, test, describe } from '@jest/globals';
+import { Convert } from '../../index.mjs';
+
+describe('Класс Convert', () => {
+    describe('Метод Convert.toArray', () => {
+        test('Должен возвращать пустой массив для null и undefined', () => {
+            expect(Convert.toArray(null)).toEqual([]);
+            expect(Convert.toArray(undefined)).toEqual([]);
+        });
+
+        test('Должен возвращать исходный массив, если он передан', () => {
+            const input = [1, 2, 3];
+            expect(Convert.toArray(input)).toBe(input);
+        });
+
+        test('Должен возвращать ассоциативный массив без прототипа и с итератором Symbol.iterator при передаче объекта', () => {
+            const result = Convert.toArray({ key: 'value' });
+
+            expect(Object.getPrototypeOf(result)).toBeNull();
+
+            for (const entry of result) {
+                expect(entry).toEqual(['key', 'value']);
+            }
+        });
+
+        test('Должен возвращать массив с примитивными значениями', () => {
+            expect(Convert.toArray(true)).toEqual([true]);
+            expect(Convert.toArray(false)).toEqual([false]);
+            expect(Convert.toArray('example')).toEqual(['example']);
+            expect(Convert.toArray(123)).toEqual([123]);
+        });
+
+        test('Должен оборачивать экземпляр класса в массив', () => {
+            class MyClass {}
+
+            const instance = new MyClass();
+            expect(Convert.toArray(instance)).toEqual([instance]);
+        });
+    });
+
+    describe('Метод Convert.toAssoc', () => {
+        test('Должен возвращать пустой ассоциативный массив для null и undefined', () => {
+            expect(Convert.toAssoc(null)).toEqual({});
+            expect(Convert.toAssoc(undefined)).toEqual({});
+        });
+
+        test('Должен преобразовывать список в ассоциативный массив', () => {
+            const input = [1, 2, 3];
+            expect(Convert.toAssoc(input)).toEqual({ 0: 1, 1: 2, 2: 3 });
+        });
+
+        test('Должен возвращать исходный ассоциативный массив, если он передан', () => {
+            const input = { key: 'value' };
+            expect(Convert.toAssoc(input)).toBe(input);
+        });
+
+        test('Должен возвращать ассоциативный массив с ключом 0 и переданным значением для примитивов', () => {
+            expect(Convert.toAssoc(true)).toEqual({ 0: true });
+            expect(Convert.toAssoc(false)).toEqual({ 0: false });
+            expect(Convert.toAssoc('example')).toEqual({ 0: 'example' });
+            expect(Convert.toAssoc(123)).toEqual({ 0: 123 });
+        });
+
+        test('Должен оборачивать экземпляр класса в ассоциативный массив с ключом 0', () => {
+            class MyClass {}
+
+            const instance = new MyClass();
+            expect(Convert.toAssoc(instance)).toEqual({ 0: instance });
+        });
+    });
+
+    describe('Метод Convert.toBool', () => {
+        test('Должен возвращать false для пустого массива', () => {
+            expect(Convert.toBool([])).toBe(false);
+        });
+
+        test('Должен возвращать true для непустого массива', () => {
+            expect(Convert.toBool([1, 2, 3])).toBe(true);
+        });
+
+        test('Должен возвращать false для пустого ассоциативного массива', () => {
+            expect(Convert.toBool({})).toBe(false);
+        });
+
+        test('Должен возвращать true для непустого ассоциативного массива', () => {
+            expect(Convert.toBool({ key: 'value' })).toBe(true);
+        });
+
+        test('Должен возвращать true для строки', () => {
+            expect(Convert.toBool('example')).toBe(true);
+        });
+
+        test('Должен возвращать true для числа', () => {
+            expect(Convert.toBool(123)).toBe(true);
+        });
+
+        test('Должен возвращать false для null и undefined', () => {
+            expect(Convert.toBool(null)).toBe(false);
+            expect(Convert.toBool(undefined)).toBe(false);
+        });
+
+        test('Должен возвращать true для булевых значений', () => {
+            expect(Convert.toBool(true)).toBe(true);
+            expect(Convert.toBool(false)).toBe(false);
+        });
+
+        test('Должен возвращать true для экземпляров класса', () => {
+            class MyClass {}
+
+            const instance = new MyClass();
+            expect(Convert.toBool(instance)).toBe(true);
+        });
+
+        test('Должен возвращать true для классов', () => {
+            class MyClass {}
+
+            expect(Convert.toBool(MyClass)).toBe(true);
+        });
+    });
+
+    describe('Метод Convert.toBoolean', () => {
+        test('Должен возвращать false для пустого массива', () => {
+            expect(Convert.toBoolean([])).toBe(false);
+        });
+
+        test('Должен возвращать true для непустого массива', () => {
+            expect(Convert.toBoolean([1, 2, 3])).toBe(true);
+        });
+
+        test('Должен возвращать false для пустого ассоциативного массива', () => {
+            expect(Convert.toBoolean({})).toBe(false);
+        });
+
+        test('Должен возвращать true для непустого ассоциативного массива', () => {
+            expect(Convert.toBoolean({ key: 'value' })).toBe(true);
+        });
+
+        test('Должен возвращать true для строки', () => {
+            expect(Convert.toBoolean('example')).toBe(true);
+        });
+
+        test('Должен возвращать true для числа', () => {
+            expect(Convert.toBoolean(123)).toBe(true);
+        });
+
+        test('Должен возвращать false для null и undefined', () => {
+            expect(Convert.toBoolean(null)).toBe(false);
+            expect(Convert.toBoolean(undefined)).toBe(false);
+        });
+
+        test('Должен возвращать true для булевых значений', () => {
+            expect(Convert.toBoolean(true)).toBe(true);
+            expect(Convert.toBoolean(false)).toBe(false);
+        });
+
+        test('Должен возвращать true для экземпляров класса', () => {
+            class MyClass {}
+
+            const instance = new MyClass();
+            expect(Convert.toBoolean(instance)).toBe(true);
+        });
+
+        test('Должен возвращать true для классов', () => {
+            class MyClass {}
+
+            expect(Convert.toBoolean(MyClass)).toBe(true);
+        });
+    });
+
+    describe('Метод Convert.toFloat', () => {
+        test('Должен возвращать число с плавающей точкой для строки', () => {
+            expect(Convert.toFloat('123.45')).toBe(123.45);
+        });
+
+        test('Должен возвращать число с плавающей точкой для целого числа', () => {
+            expect(Convert.toFloat(123)).toBe(123.0);
+        });
+
+        test('Должен возвращать 1 для true и 0 для false', () => {
+            expect(Convert.toFloat(true)).toBe(1.0);
+            expect(Convert.toFloat(false)).toBe(0.0);
+        });
+
+        test('Должен возвращать 0 для null и undefined', () => {
+            expect(Convert.toFloat(null)).toBe(0.0);
+            expect(Convert.toFloat(undefined)).toBe(0.0);
+        });
+
+        test('Должен возвращать 0 для нечисловых строк', () => {
+            expect(Convert.toFloat('example')).toBe(0.0);
+        });
+    });
+
+    describe('Метод Convert.toInt', () => {
+        test('Должен возвращать целое число для строки', () => {
+            expect(Convert.toInt('123')).toBe(123);
+        });
+
+        test('Должен возвращать целое число для числа с плавающей точкой', () => {
+            expect(Convert.toInt(123.45)).toBe(123);
+        });
+
+        test('Должен возвращать 1 для true и 0 для false', () => {
+            expect(Convert.toInt(true)).toBe(1);
+            expect(Convert.toInt(false)).toBe(0);
+        });
+
+        test('Должен возвращать 0 для null и undefined', () => {
+            expect(Convert.toInt(null)).toBe(0);
+            expect(Convert.toInt(undefined)).toBe(0);
+        });
+
+        test('Должен возвращать 0 для нечисловых строк', () => {
+            expect(Convert.toInt('example')).toBe(0);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления', () => {
+            expect(Convert.toInt('10', 2)).toBe(2);
+            expect(Convert.toInt('A', 16)).toBe(10);
+            expect(Convert.toInt('7', 8)).toBe(7);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 2', () => {
+            expect(Convert.toInt('1010', 2)).toBe(10);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 16', () => {
+            expect(Convert.toInt('A', 16)).toBe(10);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 8', () => {
+            expect(Convert.toInt('7', 8)).toBe(7);
+        });
+
+        test('Должен выбрасывать исключение для неверного значения параметра base', () => {
+            expect(() => Convert.toInt('123', 'invalid')).toThrow(TypeError);
+        });
+    });
+
+    describe('Метод Convert.toInteger', () => {
+        test('Должен возвращать целое число для строки', () => {
+            expect(Convert.toInteger('123')).toBe(123);
+        });
+
+        test('Должен возвращать целое число для числа с плавающей точкой', () => {
+            expect(Convert.toInteger(123.45)).toBe(123);
+        });
+
+        test('Должен возвращать 1 для true и 0 для false', () => {
+            expect(Convert.toInteger(true)).toBe(1);
+            expect(Convert.toInteger(false)).toBe(0);
+        });
+
+        test('Должен возвращать 0 для null и undefined', () => {
+            expect(Convert.toInteger(null)).toBe(0);
+            expect(Convert.toInteger(undefined)).toBe(0);
+        });
+
+        test('Должен возвращать 0 для нечисловых строк', () => {
+            expect(Convert.toInteger('example')).toBe(0);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления', () => {
+            expect(Convert.toInteger('10', 2)).toBe(2);
+            expect(Convert.toInteger('A', 16)).toBe(10);
+            expect(Convert.toInteger('7', 8)).toBe(7);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 2', () => {
+            expect(Convert.toInteger('1010', 2)).toBe(10);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 16', () => {
+            expect(Convert.toInteger('A', 16)).toBe(10);
+        });
+
+        test('Должен возвращать целое число для строки с основанием системы счисления 8', () => {
+            expect(Convert.toInteger('7', 8)).toBe(7);
+        });
+
+        test('Должен выбрасывать исключение для неверного значения параметра base', () => {
+            expect(() => Convert.toInteger('123', 'invalid')).toThrow(TypeError);
+        });
+    });
+
+    describe('Метод Convert.toList', () => {
+        test('Должен возвращать пустой массив для null и undefined', () => {
+            expect(Convert.toList(null)).toEqual([]);
+            expect(Convert.toList(undefined)).toEqual([]);
+        });
+
+        test('Должен возвращать исходный массив, если он передан', () => {
+            const input = [1, 2, 3];
+            expect(Convert.toList(input)).toBe(input);
+        });
+
+        test('Должен возвращать массив значений объекта, если передан ассоциативный массив', () => {
+            const input = { key: 'value' };
+            expect(Convert.toList(input)).toEqual(['value']);
+        });
+
+        test('Должен возвращать массив, содержащий переданное значение для примитивов', () => {
+            expect(Convert.toList(true)).toEqual([true]);
+            expect(Convert.toList(false)).toEqual([false]);
+            expect(Convert.toList('example')).toEqual(['example']);
+            expect(Convert.toList(123)).toEqual([123]);
+        });
+    });
+
+    describe('Метод Convert.toObject', () => {
+        test('Должен возвращать объект без изменений', () => {
+            class MyClass {}
+            const obj = new MyClass();
+            expect(Convert.toObject(obj)).toBe(obj);
+        });
+
+        test('Должен возвращать новый экземпляр класса', () => {
+            class MyClass {}
+            const instance = Convert.toObject(MyClass);
+            expect(instance).toBeInstanceOf(MyClass);
+        });
+
+        test('Должен возвращать объект с элементами массива', () => {
+            const arr = [1, 2, 3];
+            const result = Convert.toObject(arr);
+            expect(result).toEqual({ 0: 1, 1: 2, 2: 3 });
+        });
+
+        test('Должен возвращать объект с полем value для примитивов', () => {
+            expect(Convert.toObject('example')).toEqual({ value: 'example' });
+            expect(Convert.toObject(123)).toEqual({ value: 123 });
+            expect(Convert.toObject(true)).toEqual({ value: true });
+        });
+
+        test('Должен возвращать экземпляр анонимного класса для null и undefined', () => {
+            expect(Convert.toObject(null)).toBeInstanceOf(Object);
+            expect(Convert.toObject(undefined)).toBeInstanceOf(Object);
+        });
+    });
+
+    describe('Метод Convert.toString', () => {
+        test('Должен возвращать строку без изменений', () => {
+            expect(Convert.toString('example')).toBe('example');
+        });
+
+        test('Должен преобразовывать число в строку', () => {
+            expect(Convert.toString(123)).toBe('123');
+        });
+
+        test('Должен преобразовывать булевые значения в строку', () => {
+            expect(Convert.toString(true)).toBe('true');
+            expect(Convert.toString(false)).toBe('false');
+        });
+
+        test('Должен преобразовывать null и undefined в строку', () => {
+            expect(Convert.toString(null)).toBe('null');
+            expect(Convert.toString(undefined)).toBe('undefined');
+        });
+
+        test('Должен преобразовывать массив в строку', () => {
+            const arr = [1, 2, 3];
+            expect(Convert.toString(arr)).toBe('[\n    1,\n    2,\n    3,\n]');
+        });
+
+        test('Должен преобразовывать объект в строку', () => {
+            const obj = { key: 'value' };
+            expect(Convert.toString(obj)).toBe("{\n    key: 'value',\n}");
+        });
+
+        test('Должен преобразовывать функцию в строку', () => {
+            const func = function () {};
+            expect(Convert.toString(func)).toBe('function func() {}');
+        });
+
+        test('Должен преобразовывать символ в строку', () => {
+            const symbol = Symbol('example');
+            expect(Convert.toString(symbol)).toBe('Symbol(example)');
+        });
+
+        test('Должен преобразовывать BigInt в строку', () => {
+            const bigInt = BigInt(123);
+            expect(Convert.toString(bigInt)).toBe('123');
+        });
+
+        test('Должен преобразовывать класс в строку', () => {
+            class MyClass {
+                static test = 'test';
+            }
+            expect(Convert.toString(MyClass)).toBe('class MyClass {}');
+        });
+
+        test('Должен преобразовывать экземпляр класса в строку', () => {
+            class MyClass {}
+            const instance = new MyClass();
+            expect(Convert.toString(instance)).toBe('object MyClass');
+        });
+    });
+});
+