@rogolev/value 0.0.1 → 0.0.3

package/tests/classes/Value.test.mjs

@@ -0,0 +1,423 @@
+import { expect, test, describe, jest } from '@jest/globals';
+import { Value } from '../../index.mjs';
+
+describe('Класс Value', () => {
+    describe('Метод get', () => {
+        test('должен возвращать значение', () => {
+            const value = new Value('test');
+            expect(value.get()).toBe('test');
+        });
+    });
+
+    describe('Метод getType', () => {
+        test('должен возвращать тип значения', () => {
+            const value = new Value('test');
+            expect(value.getType()).toBe('string');
+        });
+    });
+
+    describe('Метод isEmpty', () => {
+        test('должен возвращать логическое значение', () => {
+            const value = new Value('test');
+            expect(value.isEmpty()).toBe(false);
+        });
+
+        test('должен возвращать true для пустых значений', () => {
+            const value1 = new Value(null);
+            const value2 = new Value(undefined);
+            const value3 = new Value('');
+            const value4 = new Value(0);
+            const value5 = new Value(false);
+            const value6 = new Value([]);
+            const value7 = new Value({});
+
+            expect(value1.isEmpty()).toBe(true);
+            expect(value2.isEmpty()).toBe(true);
+            expect(value3.isEmpty()).toBe(true);
+            expect(value4.isEmpty()).toBe(true);
+            expect(value5.isEmpty()).toBe(true);
+            expect(value6.isEmpty()).toBe(true);
+            expect(value7.isEmpty()).toBe(true);
+        });
+    });
+
+    describe('Метод print', () => {
+        test('должен распечатывать значение в консоль и возвращать текущий экземпляр класса Value', () => {
+            const logSpy = jest.spyOn(console, 'log');
+            const value = new Value('test');
+
+            expect(value.print()).toBe(value);
+            expect(logSpy).toHaveBeenCalledWith('"test"');
+        });
+    });
+
+    describe('Метод toPrint', () => {
+        test('должен возвращать распечатанное значение в виде экземпляра Value', () => {
+            const value = new Value('test');
+            const result = value.toPrint();
+
+            expect(result).toBeInstanceOf(Value);
+            expect(result.get()).toBe('"test"');
+        });
+    });
+
+    describe('Метод printType', () => {
+        test('должен распечатывать значение в консоль и возвращать текущий экземпляр класса Value', () => {
+            const logSpy = jest.spyOn(console, 'log');
+            const value = new Value('test');
+
+            expect(value.printType()).toBe(value);
+            expect(logSpy).toHaveBeenCalledWith('string(4) "test"');
+        });
+    });
+
+    describe('Метод toPrintType', () => {
+        test('должен возвращать распечатанное значение в виде экземпляра Value', () => {
+            const value = new Value('test');
+            const result = value.toPrintType();
+
+            expect(result).toBeInstanceOf(Value);
+            expect(result.get()).toBe('string(4) "test"');
+        });
+    });
+
+    describe('Метод isArray', () => {
+        test('должен проверять, является ли значение массивом', () => {
+            const value1 = new Value([1, 2, 3]);
+            const value2 = new Value({ foo: 'bar' });
+
+            expect(value1.isArray()).toBe(true);
+            expect(value2.isArray()).toBe(true);
+        });
+    });
+
+    describe('Метод isAssoc', () => {
+        test('должен проверять, является ли значение ассоциативным массивом', () => {
+            const value1 = new Value({ foo: 'bar' });
+            const value2 = new Value([1, 2, 3]);
+
+            expect(value1.isAssoc()).toBe(true);
+            expect(value2.isAssoc()).toBe(false);
+        });
+    });
+
+    describe('Метод isBigInt', () => {
+        test('должен проверять, является ли значение типом bigint', () => {
+            const value1 = new Value(BigInt(123456));
+            const value2 = new Value(123456);
+
+            expect(value1.isBigInt()).toBe(true);
+            expect(value2.isBigInt()).toBe(false);
+        });
+    });
+
+    describe('Метод isBool', () => {
+        test('должен проверять, является ли значение логическим типом', () => {
+            const value1 = new Value(true);
+            const value2 = new Value('true');
+
+            expect(value1.isBool()).toBe(true);
+            expect(value2.isBool()).toBe(false);
+        });
+    });
+
+    describe('Метод isBoolean', () => {
+        test('должен проверять, является ли значение логическим типом', () => {
+            const value1 = new Value(true);
+            const value2 = new Value('true');
+
+            expect(value1.isBoolean()).toBe(true);
+            expect(value2.isBoolean()).toBe(false);
+        });
+    });
+
+    describe('Метод isClass', () => {
+        test('должен проверять, является ли значение классом', () => {
+            class MyClass {}
+            function MyFunction() {}
+
+            const value1 = new Value(MyClass);
+            const value2 = new Value(MyFunction);
+
+            expect(value1.isClass()).toBe(true);
+            expect(value2.isClass()).toBe(false);
+        });
+    });
+
+    describe('Метод isFloat', () => {
+        test('должен проверять, является ли значение числом с плавающей точкой', () => {
+            const value1 = new Value(3.14);
+            const value2 = new Value(42);
+
+            expect(value1.isFloat()).toBe(true);
+            expect(value2.isFloat()).toBe(false);
+        });
+    });
+
+    describe('Метод isFunction', () => {
+        test('должен проверять, является ли значение функцией', () => {
+            function MyFunction() {}
+            class MyClass {}
+
+            const value1 = new Value(MyFunction);
+            const value2 = new Value(MyClass);
+
+            expect(value1.isFunction()).toBe(true);
+            expect(value2.isFunction()).toBe(false);
+        });
+    });
+
+    describe('Метод isInfinity', () => {
+        test('должен проверять, является ли значение бесконечностью', () => {
+            const value1 = new Value(Infinity);
+            const value2 = new Value(42);
+
+            expect(value1.isInfinity()).toBe(true);
+            expect(value2.isInfinity()).toBe(false);
+        });
+    });
+
+    describe('Метод isInt', () => {
+        test('должен проверять, является ли значение целым числом', () => {
+            const value1 = new Value(42);
+            const value2 = new Value(3.14);
+
+            expect(value1.isInt()).toBe(true);
+            expect(value2.isInt()).toBe(false);
+        });
+    });
+
+    describe('Метод isInteger', () => {
+        test('должен проверять, является ли значение целым числом', () => {
+            const value1 = new Value(42);
+            const value2 = new Value(3.14);
+
+            expect(value1.isInteger()).toBe(true);
+            expect(value2.isInteger()).toBe(false);
+        });
+    });
+
+    describe('Метод isList', () => {
+        test('должен проверять, является ли значение списком', () => {
+            const value1 = new Value([1, 2, 3]);
+            const value2 = new Value({ foo: 'bar' });
+
+            expect(value1.isList()).toBe(true);
+            expect(value2.isList()).toBe(false);
+        });
+    });
+
+    describe('Метод isNaN', () => {
+        test('должен проверять, является ли значение NaN', () => {
+            const value1 = new Value(NaN);
+            const value2 = new Value(42);
+
+            expect(value1.isNaN()).toBe(true);
+            expect(value2.isNaN()).toBe(false);
+        });
+    });
+
+    describe('Метод isNull', () => {
+        test('должен проверять, является ли значение null', () => {
+            const value1 = new Value(null);
+            const value2 = new Value(undefined);
+
+            expect(value1.isNull()).toBe(true);
+            expect(value2.isNull()).toBe(false);
+        });
+    });
+
+    describe('Метод isNumber', () => {
+        test('должен проверять, является ли значение числом', () => {
+            const value1 = new Value(42);
+            const value2 = new Value('42');
+
+            expect(value1.isNumber()).toBe(true);
+            expect(value2.isNumber()).toBe(false);
+        });
+    });
+
+    describe('Метод isNumeric', () => {
+        test('должен проверять, является ли значение числом или числовой строкой', () => {
+            const value1 = new Value(42);
+            const value2 = new Value('42');
+            const value3 = new Value('hello');
+
+            expect(value1.isNumeric()).toBe(true);
+            expect(value2.isNumeric()).toBe(true);
+            expect(value3.isNumeric()).toBe(false);
+        });
+    });
+
+    describe('Метод isObject', () => {
+        test('должен проверять, является ли значение объектом', () => {
+            const value1 = new Value(new (class {})());
+            const value2 = new Value(42);
+
+            expect(value1.isObject()).toBe(true);
+            expect(value2.isObject()).toBe(false);
+        });
+    });
+
+    describe('Метод isScalar', () => {
+        test('должен проверять, является ли значение скалярным', () => {
+            const value1 = new Value(42);
+            const value2 = new Value({});
+            const value3 = new Value('hello');
+
+            expect(value1.isScalar()).toBe(true);
+            expect(value2.isScalar()).toBe(false);
+            expect(value3.isScalar()).toBe(true);
+        });
+    });
+
+    describe('Метод isString', () => {
+        test('должен проверять, является ли значение строкой', () => {
+            const value1 = new Value('hello');
+            const value2 = new Value(42);
+
+            expect(value1.isString()).toBe(true);
+            expect(value2.isString()).toBe(false);
+        });
+    });
+
+    describe('Метод isSymbol', () => {
+        test('должен проверять, является ли значение символом', () => {
+            const value1 = new Value(Symbol('symbol'));
+            const value2 = new Value('symbol');
+
+            expect(value1.isSymbol()).toBe(true);
+            expect(value2.isSymbol()).toBe(false);
+        });
+    });
+
+    describe('Метод isUndefined', () => {
+        test('должен проверять, является ли значение undefined', () => {
+            const value1 = new Value(undefined);
+            const value2 = new Value(null);
+
+            expect(value1.isUndefined()).toBe(true);
+            expect(value2.isUndefined()).toBe(false);
+        });
+    });
+
+    describe('Метод toArray', () => {
+        test('должен преобразовывать значение в массив', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(123);
+            const value3 = new Value({ key: 'value' });
+
+            expect(value1.toArray().get()).toEqual(['test']);
+            expect(value2.toArray().get()).toEqual([123]);
+            expect(value3.toArray().get()).toEqual({ key: 'value' });
+        });
+    });
+
+    describe('Метод toAssoc', () => {
+        test('должен преобразовывать значение в ассоциативный массив', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(123);
+            const value3 = new Value([1, 2, 3]);
+
+            expect(value1.toAssoc().get()).toEqual({ 0: 'test' });
+            expect(value2.toAssoc().get()).toEqual({ 0: 123 });
+            expect(value3.toAssoc().get()).toEqual({ 0: 1, 1: 2, 2: 3 });
+        });
+    });
+
+    describe('Метод toBool', () => {
+        test('должен преобразовывать значение в логическое значение', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(0);
+            const value3 = new Value(null);
+
+            expect(value1.toBool().get()).toBe(true);
+            expect(value2.toBool().get()).toBe(false);
+            expect(value3.toBool().get()).toBe(false);
+        });
+    });
+
+    describe('Метод toBoolean', () => {
+        test('должен преобразовывать значение в логическое значение', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(0);
+            const value3 = new Value(null);
+
+            expect(value1.toBoolean().get()).toBe(true);
+            expect(value2.toBoolean().get()).toBe(false);
+            expect(value3.toBoolean().get()).toBe(false);
+        });
+    });
+
+    describe('Метод toFloat', () => {
+        test('должен преобразовывать значение в число с плавающей точкой', () => {
+            const value1 = new Value('123.45');
+            const value2 = new Value(123);
+            const value3 = new Value('test');
+
+            expect(value1.toFloat().get()).toBe(123.45);
+            expect(value2.toFloat().get()).toBe(123.0);
+            expect(value3.toFloat().get()).toBe(0.0);
+        });
+    });
+
+    describe('Метод toInt', () => {
+        test('должен преобразовывать значение в целое число', () => {
+            const value1 = new Value('123');
+            const value2 = new Value(123.45);
+            const value3 = new Value('test');
+
+            expect(value1.toInt().get()).toBe(123);
+            expect(value2.toInt().get()).toBe(123);
+            expect(value3.toInt().get()).toBe(0);
+        });
+    });
+
+    describe('Метод toInteger', () => {
+        test('должен преобразовывать значение в целое число', () => {
+            const value1 = new Value('123');
+            const value2 = new Value(123.45);
+            const value3 = new Value('test');
+
+            expect(value1.toInteger().get()).toBe(123);
+            expect(value2.toInteger().get()).toBe(123);
+            expect(value3.toInteger().get()).toBe(0);
+        });
+    });
+
+    describe('Метод toList', () => {
+        test('должен преобразовывать значение в список', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(123);
+            const value3 = new Value({ key: 'value' });
+
+            expect(value1.toList().get()).toEqual(['test']);
+            expect(value2.toList().get()).toEqual([123]);
+            expect(value3.toList().get()).toEqual(['value']);
+        });
+    });
+
+    describe('Метод toObject', () => {
+        test('должен преобразовывать значение в объект', () => {
+            const value1 = new Value('test');
+            const value2 = new Value(123);
+            const value3 = new Value([1, 2, 3]);
+
+            expect(value1.toObject().get()).toEqual({ value: 'test' });
+            expect(value2.toObject().get()).toEqual({ value: 123 });
+            expect(value3.toObject().get()).toEqual({ 0: 1, 1: 2, 2: 3 });
+        });
+    });
+
+    describe('Метод toString', () => {
+        test('должен преобразовывать значение в строку', () => {
+            const value1 = new Value(123);
+            const value2 = new Value(true);
+            const value3 = new Value({ key: 'value' });
+
+            expect(value1.toString().get()).toBe('123');
+            expect(value2.toString().get()).toBe('true');
+            expect(value3.toString().get()).toBe("{\n    key: 'value',\n}");
+        });
+    });
+});

package/tests/constants.test.mjs

@@ -0,0 +1,75 @@
+import { describe, test, expect } from '@jest/globals';
+import {
+    TYPE_ARRAY,
+    TYPE_BIGINT,
+    TYPE_BOOLEAN,
+    TYPE_CLASS,
+    TYPE_FLOAT,
+    TYPE_FUNCTION,
+    TYPE_INFINITY,
+    TYPE_INTEGER,
+    TYPE_NAN,
+    TYPE_NULL,
+    TYPE_OBJECT,
+    TYPE_STRING,
+    TYPE_SYMBOL,
+    TYPE_UNDEFINED,
+} from '../index.mjs';
+
+describe('Константы', () => {
+    test('TYPE_NULL должно быть "null"', () => {
+        expect(TYPE_NULL).toBe('null');
+    });
+
+    test('TYPE_NAN должно быть "NaN"', () => {
+        expect(TYPE_NAN).toBe('NaN');
+    });
+
+    test('TYPE_UNDEFINED должно быть "undefined"', () => {
+        expect(TYPE_UNDEFINED).toBe('undefined');
+    });
+
+    test('TYPE_INFINITY должно быть "infinity"', () => {
+        expect(TYPE_INFINITY).toBe('infinity');
+    });
+
+    test('TYPE_BOOLEAN должно быть "boolean"', () => {
+        expect(TYPE_BOOLEAN).toBe('boolean');
+    });
+
+    test('TYPE_INTEGER должно быть "integer"', () => {
+        expect(TYPE_INTEGER).toBe('integer');
+    });
+
+    test('TYPE_BIGINT должно быть "bigint"', () => {
+        expect(TYPE_BIGINT).toBe('bigint');
+    });
+
+    test('TYPE_FLOAT должно быть "float"', () => {
+        expect(TYPE_FLOAT).toBe('float');
+    });
+
+    test('TYPE_STRING должно быть "string"', () => {
+        expect(TYPE_STRING).toBe('string');
+    });
+
+    test('TYPE_SYMBOL должно быть "symbol"', () => {
+        expect(TYPE_SYMBOL).toBe('symbol');
+    });
+
+    test('TYPE_CLASS должно быть "class"', () => {
+        expect(TYPE_CLASS).toBe('class');
+    });
+
+    test('TYPE_FUNCTION должно быть "function"', () => {
+        expect(TYPE_FUNCTION).toBe('function');
+    });
+
+    test('TYPE_ARRAY должно быть "array"', () => {
+        expect(TYPE_ARRAY).toBe('array');
+    });
+
+    test('TYPE_OBJECT должно быть "object"', () => {
+        expect(TYPE_OBJECT).toBe('object');
+    });
+});

package/tests/helpers/value.test.mjs

@@ -0,0 +1,68 @@
+import { expect, test, describe } from '@jest/globals';
+import { Value, value } from '../../index.mjs';
+
+describe('Функция value', () => {
+    test('Должна создавать экземпляр класса Value с числом', () => {
+        const val = 123;
+        const result = value(val);
+        expect(result).toBeInstanceOf(Value);
+        expect(result.get()).toBe(val);
+        expect(result.getType()).toBe('integer');
+        expect(result.isNumber()).toBe(true);
+    });
+
+    test('Должна создавать экземпляр класса Value со строкой', () => {
+        const val = 'example';
+        const result = value(val);
+        expect(result).toBeInstanceOf(Value);
+        expect(result.get()).toBe(val);
+        expect(result.getType()).toBe('string');
+        expect(result.isString()).toBe(true);
+    });
+
+    test('Должна создавать экземпляр класса Value с ассоциативным массивом', () => {
+        const val = { key: 'value' };
+        const result = value(val);
+        expect(result).toBeInstanceOf(Value);
+        expect(result.get()).toEqual(val);
+        expect(result.getType()).toBe('array');
+        expect(result.isAssoc()).toBe(true);
+    });
+
+    test('Должна создавать экземпляр класса Value с массивом', () => {
+        const val = [1, 2, 3];
+        const result = value(val);
+        expect(result).toBeInstanceOf(Value);
+        expect(result.get()).toEqual(val);
+        expect(result.getType()).toBe('array');
+        expect(result.isArray()).toBe(true);
+    });
+
+    test('Должна создавать экземпляр класса Value с булевым значением', () => {
+        const val = true;
+        const result = value(val);
+        expect(result).toBeInstanceOf(Value);
+        expect(result.get()).toBe(val);
+        expect(result.getType()).toBe('boolean');
+        expect(result.isBool()).toBe(true);
+    });
+
+    test('Должна создавать экземпляр класса Value с null', () => {
+        const val = null;
+        const result = value(val);
+        expect(result).toBeInstanceOf(Value);
+        expect(result.get()).toBe(val);
+        expect(result.getType()).toBe('null');
+        expect(result.isNull()).toBe(true);
+    });
+
+    test('Должна создавать экземпляр класса Value с undefined', () => {
+        const val = undefined;
+        const result = value(val);
+        expect(result).toBeInstanceOf(Value);
+        expect(result.get()).toBe(val);
+        expect(result.getType()).toBe('undefined');
+        expect(result.isUndefined()).toBe(true);
+    });
+});
+