@rogolev/value 0.0.4 → 0.0.5

package/tests/classes/Expect/toBeScalar.test.mjs

@@ -0,0 +1,63 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeScalar класса Expect', () => {
+    test('Должен возвращать true, если значение является скалярным (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(expectInstance.toBeScalar()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является скалярным (строка)', () => {
+        const expectInstance = new Expect('hello');
+        expect(expectInstance.toBeScalar()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является скалярным (boolean)', () => {
+        const expectInstance = new Expect(true);
+        expect(expectInstance.toBeScalar()).toBe(true);
+    });
+
+    test('Должен возвращать true, если значение является скалярным (symbol)', () => {
+        const expectInstance = new Expect(Symbol('symbol'));
+        expect(expectInstance.toBeScalar()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является скалярным (объект)', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeScalar()).toThrow(TypeError);
+        expect(() => expectInstance.toBeScalar()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является скалярным', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeScalar('Значение должно быть скалярным')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeScalar('Значение должно быть скалярным')).toThrow(
+            'Значение должно быть скалярным',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeScalar(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeScalar(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является массивом, а не скалярным', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeScalar()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является null, а не скалярным', () => {
+        const expectInstance = new Expect(null);
+        expect(() => expectInstance.toBeScalar()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является undefined, а не скалярным', () => {
+        const expectInstance = new Expect(undefined);
+        expect(() => expectInstance.toBeScalar()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toBeString.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeString класса Expect', () => {
+    test('Должен возвращать true, если значение является строкой', () => {
+        const expectInstance = new Expect('hello');
+        expect(expectInstance.toBeString()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является строкой (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeString()).toThrow(TypeError);
+        expect(() => expectInstance.toBeString()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является строкой', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeString('Значение должно быть строкой')).toThrow(TypeError);
+        expect(() => expectInstance.toBeString('Значение должно быть строкой')).toThrow(
+            'Значение должно быть строкой',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect('hello');
+        expect(() => expectInstance.toBeString(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeString(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не строкой', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeString()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является массивом, а не строкой', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toBeString()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является пустой строкой', () => {
+        const expectInstance = new Expect('');
+        expect(expectInstance.toBeString()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeSymbol.test.mjs

@@ -0,0 +1,46 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeSymbol класса Expect', () => {
+    test('Должен возвращать true, если значение является символом', () => {
+        const expectInstance = new Expect(Symbol('example'));
+        expect(expectInstance.toBeSymbol()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является символом (строка)', () => {
+        const expectInstance = new Expect('example');
+        expect(() => expectInstance.toBeSymbol()).toThrow(TypeError);
+        expect(() => expectInstance.toBeSymbol()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является символом', () => {
+        const expectInstance = new Expect('example');
+        expect(() => expectInstance.toBeSymbol('Значение должно быть символом')).toThrow(TypeError);
+        expect(() => expectInstance.toBeSymbol('Значение должно быть символом')).toThrow(
+            'Значение должно быть символом',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(Symbol('example'));
+        expect(() => expectInstance.toBeSymbol(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeSymbol(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является числом, а не символом', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeSymbol()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не символом', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeSymbol()).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значение является символом (уникальный символ)', () => {
+        const expectInstance = new Expect(Symbol.for('unique'));
+        expect(expectInstance.toBeSymbol()).toBe(true);
+    });
+});

package/tests/classes/Expect/toBeUndefined.test.mjs

@@ -0,0 +1,50 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toBeUndefined класса Expect', () => {
+    test('Должен возвращать true, если значение является undefined', () => {
+        let value;
+        const expectInstance = new Expect(value);
+        expect(expectInstance.toBeUndefined()).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значение не является undefined (число)', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeUndefined()).toThrow(TypeError);
+        expect(() => expectInstance.toBeUndefined()).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значение не является undefined', () => {
+        const expectInstance = new Expect(123);
+        expect(() => expectInstance.toBeUndefined('Значение должно быть undefined')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toBeUndefined('Значение должно быть undefined')).toThrow(
+            'Значение должно быть undefined',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        let value;
+        const expectInstance = new Expect(value);
+        expect(() => expectInstance.toBeUndefined(123)).toThrow(TypeError);
+        expect(() => expectInstance.toBeUndefined(123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значение является строкой, а не undefined', () => {
+        const expectInstance = new Expect('undefined');
+        expect(() => expectInstance.toBeUndefined()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является объектом, а не undefined', () => {
+        const expectInstance = new Expect({ a: 1 });
+        expect(() => expectInstance.toBeUndefined()).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значение является null, а не undefined', () => {
+        const expectInstance = new Expect(null);
+        expect(() => expectInstance.toBeUndefined()).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toEqual.test.mjs

@@ -0,0 +1,66 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toEqual класса Expect', () => {
+    test('Должен возвращать true, если значения эквивалентны (числа)', () => {
+        const expectInstance = new Expect(5);
+        expect(expectInstance.toEqual(5)).toBe(true);
+    });
+
+    test('Должен возвращать true, если значения эквивалентны (строки)', () => {
+        const expectInstance = new Expect('hello');
+        expect(expectInstance.toEqual('hello')).toBe(true);
+    });
+
+    test('Должен возвращать true, если значения эквивалентны (объекты)', () => {
+        const expectInstance = new Expect({ a: 1, b: 2 });
+        expect(expectInstance.toEqual({ a: 1, b: 2 })).toBe(true);
+    });
+
+    test('Должен возвращать true, если значения эквивалентны (массивы)', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(expectInstance.toEqual([1, 2, 3])).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значения не эквивалентны (числа)', () => {
+        const expectInstance = new Expect(5);
+        expect(() => expectInstance.toEqual(10)).toThrow(TypeError);
+        expect(() => expectInstance.toEqual(10)).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значения не эквивалентны', () => {
+        const expectInstance = new Expect(5);
+        expect(() => expectInstance.toEqual(10, 'Значения не эквивалентны')).toThrow(TypeError);
+        expect(() => expectInstance.toEqual(10, 'Значения не эквивалентны')).toThrow(
+            'Значения не эквивалентны',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(5);
+        expect(() => expectInstance.toEqual(5, 123)).toThrow(TypeError);
+        expect(() => expectInstance.toEqual(5, 123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значения не эквивалентны (объекты)', () => {
+        const expectInstance = new Expect({ a: 1, b: 2 });
+        expect(() => expectInstance.toEqual({ a: 1, b: 3 })).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значения не эквивалентны (массивы)', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toEqual([1, 2, 4])).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значения эквивалентны (вложенные объекты)', () => {
+        const expectInstance = new Expect({ a: { b: 2 }, c: 3 });
+        expect(expectInstance.toEqual({ a: { b: 2 }, c: 3 })).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значения не эквивалентны (вложенные объекты)', () => {
+        const expectInstance = new Expect({ a: { b: 2 }, c: 3 });
+        expect(() => expectInstance.toEqual({ a: { b: 3 }, c: 3 })).toThrow(TypeError);
+    });
+});

package/tests/classes/Expect/toStrictEqual.test.mjs

@@ -0,0 +1,73 @@
+import { expect, test, describe } from '@jest/globals';
+import { Expect } from '../../../index.mjs';
+
+describe('Метод toStrictEqual класса Expect', () => {
+    test('Должен возвращать true, если значения строго эквивалентны (числа)', () => {
+        const expectInstance = new Expect(5);
+        expect(expectInstance.toStrictEqual(5)).toBe(true);
+    });
+
+    test('Должен возвращать true, если значения строго эквивалентны (строки)', () => {
+        const expectInstance = new Expect('hello');
+        expect(expectInstance.toStrictEqual('hello')).toBe(true);
+    });
+
+    test('Должен возвращать true, если значения строго эквивалентны (объекты)', () => {
+        const expectInstance = new Expect({ a: 1, b: 2 });
+        expect(expectInstance.toStrictEqual({ a: 1, b: 2 })).toBe(true);
+    });
+
+    test('Должен возвращать true, если значения строго эквивалентны (массивы)', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(expectInstance.toStrictEqual([1, 2, 3])).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значения не строго эквивалентны (числа)', () => {
+        const expectInstance = new Expect(5);
+        expect(() => expectInstance.toStrictEqual(10)).toThrow(TypeError);
+        expect(() => expectInstance.toStrictEqual(10)).toThrow('');
+    });
+
+    test('Должен выбрасывать ошибку с пользовательским сообщением, если значения не строго эквивалентны', () => {
+        const expectInstance = new Expect(5);
+        expect(() => expectInstance.toStrictEqual(10, 'Значения не строго эквивалентны')).toThrow(
+            TypeError,
+        );
+        expect(() => expectInstance.toStrictEqual(10, 'Значения не строго эквивалентны')).toThrow(
+            'Значения не строго эквивалентны',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если параметр message не является строкой', () => {
+        const expectInstance = new Expect(5);
+        expect(() => expectInstance.toStrictEqual(5, 123)).toThrow(TypeError);
+        expect(() => expectInstance.toStrictEqual(5, 123)).toThrow(
+            'Параметр "message" должен быть строкой.',
+        );
+    });
+
+    test('Должен выбрасывать ошибку, если значения не строго эквивалентны (объекты)', () => {
+        const expectInstance = new Expect({ a: 1, b: 2 });
+        expect(() => expectInstance.toStrictEqual({ a: 1, b: 3 })).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значения не строго эквивалентны (массивы)', () => {
+        const expectInstance = new Expect([1, 2, 3]);
+        expect(() => expectInstance.toStrictEqual([1, 2, 4])).toThrow(TypeError);
+    });
+
+    test('Должен возвращать true, если значения строго эквивалентны (вложенные объекты)', () => {
+        const expectInstance = new Expect({ a: { b: 2 }, c: 3 });
+        expect(expectInstance.toStrictEqual({ a: { b: 2 }, c: 3 })).toBe(true);
+    });
+
+    test('Должен выбрасывать ошибку, если значения не строго эквивалентны (вложенные объекты)', () => {
+        const expectInstance = new Expect({ a: { b: 2 }, c: 3 });
+        expect(() => expectInstance.toStrictEqual({ a: { b: 3 }, c: 3 })).toThrow(TypeError);
+    });
+
+    test('Должен выбрасывать ошибку, если значения эквивалентны, но не строго (число и строка)', () => {
+        const expectInstance = new Expect(5);
+        expect(() => expectInstance.toStrictEqual('5')).toThrow(TypeError);
+    });
+});