From d62e9c8c791aa88770b47147e810b237e680113e Mon Sep 17 00:00:00 2001 From: Peter van Vliet Date: Thu, 26 Sep 2024 17:15:36 +0200 Subject: [PATCH] #296: refactored serialization tests --- .../src/interfaces/ClassResolver.ts | 4 +- .../src/serializers/ClassSerializer.ts | 18 +-- .../test/DefaultClassLoader.spec.ts | 51 ------- .../serialization/test/Serializer.spec.ts | 17 +-- .../test/SerializerBuilder.spec.ts | 83 +++++------- .../_fixtures/DefaultClassLoader.fixture.ts | 48 ------- .../_fixtures/SerializerBuilder.fixture.ts | 9 -- .../serializers/ArraySerializer.fixture.ts | 21 --- .../serializers/ClassSerializer.fixture.ts | 126 ------------------ .../serializers/ObjectSerializer.fixture.ts | 21 --- .../PrimitiveSerializer.fixture.ts | 9 -- packages/serialization/test/fixtures/index.ts | 2 + .../serializers.fixture.ts} | 9 +- .../test/serializers/ArraySerializer.spec.ts | 49 +++---- .../test/serializers/BigIntSerializer.spec.ts | 33 ++--- .../test/serializers/ClassSerializer.spec.ts | 67 +++++----- .../test/serializers/DateSerializer.spec.ts | 33 ++--- .../test/serializers/ErrorSerializer.spec.ts | 87 ++++++------ .../test/serializers/MapSerializer.spec.ts | 56 ++++---- .../test/serializers/ObjectSerializer.spec.ts | 49 +++---- .../serializers/PrimitiveSerializer.spec.ts | 72 +++++----- .../test/serializers/RegExpSerializer.spec.ts | 38 +++--- .../test/serializers/SetSerializer.spec.ts | 54 ++++---- .../serializers/TypedArraySerializer.spec.ts | 56 ++++---- .../test/serializers/UrlSerializer.spec.ts | 33 ++--- .../serializers/fixtures/arrays.fixture.ts | 16 +++ .../fixtures/bigIntegers.fixture.ts} | 13 +- .../fixtures/classResolver.fixture.ts | 27 ++++ .../serializers/fixtures/classes.fixture.ts | 103 ++++++++++++++ .../fixtures/dates.fixture.ts} | 14 +- .../fixtures/errors.fixture.ts} | 26 +++- .../test/serializers/fixtures/index.ts | 14 ++ .../fixtures/maps.fixture.ts} | 27 ++-- .../serializers/fixtures/objects.fixture.ts | 16 +++ .../fixtures/primitives.fixture.ts | 17 +++ .../fixtures/regularExpressions.fixture.ts} | 16 ++- .../fixtures/sets.fixture.ts} | 26 ++-- .../fixtures/typedArrays.fixture.ts} | 18 ++- .../fixtures/urls.fixture.ts} | 13 +- .../src/worker/ExecutionClassResolver.ts | 20 +-- 40 files changed, 661 insertions(+), 750 deletions(-) delete mode 100644 packages/serialization/test/DefaultClassLoader.spec.ts delete mode 100644 packages/serialization/test/_fixtures/DefaultClassLoader.fixture.ts delete mode 100644 packages/serialization/test/_fixtures/SerializerBuilder.fixture.ts delete mode 100644 packages/serialization/test/_fixtures/serializers/ArraySerializer.fixture.ts delete mode 100644 packages/serialization/test/_fixtures/serializers/ClassSerializer.fixture.ts delete mode 100644 packages/serialization/test/_fixtures/serializers/ObjectSerializer.fixture.ts delete mode 100644 packages/serialization/test/_fixtures/serializers/PrimitiveSerializer.fixture.ts create mode 100644 packages/serialization/test/fixtures/index.ts rename packages/serialization/test/{_fixtures/Serializer.fixture.ts => fixtures/serializers.fixture.ts} (94%) create mode 100644 packages/serialization/test/serializers/fixtures/arrays.fixture.ts rename packages/serialization/test/{_fixtures/serializers/BigIntSerializer.fixture.ts => serializers/fixtures/bigIntegers.fixture.ts} (65%) create mode 100644 packages/serialization/test/serializers/fixtures/classResolver.fixture.ts create mode 100644 packages/serialization/test/serializers/fixtures/classes.fixture.ts rename packages/serialization/test/{_fixtures/serializers/DateSerializer.fixture.ts => serializers/fixtures/dates.fixture.ts} (64%) rename packages/serialization/test/{_fixtures/serializers/ErrorSerializer.fixture.ts => serializers/fixtures/errors.fixture.ts} (75%) create mode 100644 packages/serialization/test/serializers/fixtures/index.ts rename packages/serialization/test/{_fixtures/serializers/MapSerializer.fixture.ts => serializers/fixtures/maps.fixture.ts} (65%) create mode 100644 packages/serialization/test/serializers/fixtures/objects.fixture.ts create mode 100644 packages/serialization/test/serializers/fixtures/primitives.fixture.ts rename packages/serialization/test/{_fixtures/serializers/RegExpSerializer.fixture.ts => serializers/fixtures/regularExpressions.fixture.ts} (63%) rename packages/serialization/test/{_fixtures/serializers/SetSerializer.fixture.ts => serializers/fixtures/sets.fixture.ts} (58%) rename packages/serialization/test/{_fixtures/serializers/TypedArraySerializer.fixture.ts => serializers/fixtures/typedArrays.fixture.ts} (81%) rename packages/serialization/test/{_fixtures/serializers/UrlSerializer.fixture.ts => serializers/fixtures/urls.fixture.ts} (65%) diff --git a/packages/serialization/src/interfaces/ClassResolver.ts b/packages/serialization/src/interfaces/ClassResolver.ts index ef2e1353..80349656 100644 --- a/packages/serialization/src/interfaces/ClassResolver.ts +++ b/packages/serialization/src/interfaces/ClassResolver.ts @@ -1,9 +1,9 @@ interface ClassResolver { - resolveKey(clazz: Function): string; + resolveKey(clazz: Function): string | undefined; - resolveClass(key: string): Function; + resolveClass(key: string): Function | undefined; } export default ClassResolver; diff --git a/packages/serialization/src/serializers/ClassSerializer.ts b/packages/serialization/src/serializers/ClassSerializer.ts index e492896a..d7775b25 100644 --- a/packages/serialization/src/serializers/ClassSerializer.ts +++ b/packages/serialization/src/serializers/ClassSerializer.ts @@ -51,6 +51,12 @@ export default class ClassSerializer extends ValueSerializer const name = 'class'; const key = this.#classResolver.resolveKey(clazz); + + if (key === undefined) + { + throw new ClassNotFound(clazz.name); + } + const args: FlexObject = await this.#serializeConstructor(model, parameterNames, object); const fields: FlexObject = await this.#serializeFields(model, parameterNames, object); @@ -112,11 +118,11 @@ export default class ClassSerializer extends ValueSerializer if (clazz === undefined) { - throw new ClassNotFound(object.name); + throw new ClassNotFound(object.key); } else if ((clazz instanceof Function) === false) { - throw new InvalidClass(object.name); + throw new InvalidClass(object.key); } const args = await this.#deserializeConstructor(clazz, object.args); @@ -152,11 +158,7 @@ export default class ClassSerializer extends ValueSerializer async #getClass(resolvable: Resolvable): Promise { - if (resolvable.key === undefined) - { - return (globalThis as FlexObject)[resolvable.key]; - } - - return this.#classResolver.resolveClass(resolvable.key); + return (globalThis as FlexObject)[resolvable.key] + ?? this.#classResolver.resolveClass(resolvable.key); } } diff --git a/packages/serialization/test/DefaultClassLoader.spec.ts b/packages/serialization/test/DefaultClassLoader.spec.ts deleted file mode 100644 index 7dbc7686..00000000 --- a/packages/serialization/test/DefaultClassLoader.spec.ts +++ /dev/null @@ -1,51 +0,0 @@ - -import { describe, expect, it } from 'vitest'; - -import DefaultClassLoader from '../src/DefaultClassLoader'; -import ClassNotFound from '../src/errors/ClassNotFound'; -import InvalidClass from '../src/errors/InvalidClass'; - -import - { - Person, Customer, - personLoadable, customerLoadable, primitiveLoadable, - nonexistingLoadable, invalidLoadable - } from './_fixtures/DefaultClassLoader.fixture'; - -const loader = new DefaultClassLoader(); - -describe('DefaultClassLoader', () => -{ - describe('.loadClass(loadable)', () => - { - it('should load classes', async () => - { - const person = await loader.loadClass(personLoadable); - const customer = await loader.loadClass(customerLoadable); - - expect(person).toBe(Person); - expect(customer).toBe(Customer); - }); - - it('should not load non-class types', async () => - { - const loadClass = async () => loader.loadClass(primitiveLoadable); - - expect(loadClass).rejects.toStrictEqual(new InvalidClass('primitive')); - }); - - it('should not load non-existing classes', async () => - { - const loadClass = async () => loader.loadClass(nonexistingLoadable); - - expect(loadClass).rejects.toStrictEqual(new ClassNotFound('nonexisting')); - }); - - it('should not load from invalid sources', async () => - { - const loadClass = async () => loader.loadClass(invalidLoadable); - - expect(loadClass).rejects.toStrictEqual(new ClassNotFound('invalid')); - }); - }); -}); diff --git a/packages/serialization/test/Serializer.spec.ts b/packages/serialization/test/Serializer.spec.ts index f37f7371..f2de599c 100644 --- a/packages/serialization/test/Serializer.spec.ts +++ b/packages/serialization/test/Serializer.spec.ts @@ -1,23 +1,20 @@ import { describe, expect, it } from 'vitest'; -import Serializer from '../src/Serializer'; import NoSerializerFound from '../src/errors/NoSerializerFound'; import NoDeserializerFound from '../src/errors/NoDeserializerFound'; -import - { - FirstSerializer, SecondSerializer, - NumberSerializer, StringSerializer - } from './_fixtures/Serializer.fixture'; +import Serializer from '../src/Serializer'; + +import { SERIALIZERS } from './fixtures'; const overrideSerializer = new Serializer(); -overrideSerializer.addSerializer(new FirstSerializer()); -overrideSerializer.addSerializer(new SecondSerializer()); +overrideSerializer.addSerializer(new SERIALIZERS.FirstSerializer()); +overrideSerializer.addSerializer(new SERIALIZERS.SecondSerializer()); const typeSerializer = new Serializer(); -typeSerializer.addSerializer(new NumberSerializer()); -typeSerializer.addSerializer(new StringSerializer()); +typeSerializer.addSerializer(new SERIALIZERS.NumberSerializer()); +typeSerializer.addSerializer(new SERIALIZERS.StringSerializer()); describe('Serializer', () => { diff --git a/packages/serialization/test/SerializerBuilder.spec.ts b/packages/serialization/test/SerializerBuilder.spec.ts index a46d58fd..be42d176 100644 --- a/packages/serialization/test/SerializerBuilder.spec.ts +++ b/packages/serialization/test/SerializerBuilder.spec.ts @@ -3,60 +3,51 @@ import { describe, expect, it } from 'vitest'; import SerializerBuilder from '../src/SerializerBuilder'; -import { - classLoader, - mixedArray, mixedObject, - dataClass, serializedDataClass, - fixedDate, serializedFixedDate, - mixedMap, serializedMixedMap, - mixedSet, serializedMixedSet, - viewInt8, serializedViewInt8, - stringValue -} from './_fixtures/SerializerBuilder.fixture'; - -const serializer = SerializerBuilder.build(classLoader); +import { ARRAYS, OBJECTS, CLASSES, DATES, MAPS, SETS, TYPED_ARRAYS, PRIMITIVES, classResolver } from './serializers/fixtures'; + +const serializer = SerializerBuilder.build(classResolver); describe('SerializerBuilder', () => { it('should serialize mixed types with the build serializer', async () => { - const resultArray = await serializer.serialize(mixedArray); - const resultObject = await serializer.serialize(mixedObject); - const resultClass = await serializer.serialize(dataClass); - const resultDate = await serializer.serialize(fixedDate); - const resultMap = await serializer.serialize(mixedMap); - const resultSet = await serializer.serialize(mixedSet); - const resultView = await serializer.serialize(viewInt8); - const resultString = await serializer.serialize(stringValue); - - expect(resultArray).toStrictEqual(mixedArray); - expect(resultObject).toStrictEqual(mixedObject); - expect(resultClass).toStrictEqual(serializedDataClass); - expect(resultDate).toStrictEqual(serializedFixedDate); - expect(resultMap).toStrictEqual(serializedMixedMap); - expect(resultSet).toStrictEqual(serializedMixedSet); - expect(resultView).toStrictEqual(serializedViewInt8); - expect(resultString).toStrictEqual(stringValue); + const resultArray = await serializer.serialize(ARRAYS.MIXED); + const resultObject = await serializer.serialize(OBJECTS.MIXED); + const resultClass = await serializer.serialize(CLASSES.DATA_INSTANCE); + const resultDate = await serializer.serialize(DATES.FIXED); + const resultMap = await serializer.serialize(MAPS.MIXED); + const resultSet = await serializer.serialize(SETS.MIXED); + const resultView = await serializer.serialize(TYPED_ARRAYS.INT8); + const resultString = await serializer.serialize(PRIMITIVES.STRING); + + expect(resultArray).toStrictEqual(ARRAYS.MIXED); + expect(resultObject).toStrictEqual(OBJECTS.MIXED); + expect(resultClass).toStrictEqual(CLASSES.DATA_SERIALIZED); + expect(resultDate).toStrictEqual(DATES.FIXED_SERIALIZED); + expect(resultMap).toStrictEqual(MAPS.MIXED_SERIALIZED); + expect(resultSet).toStrictEqual(SETS.MIXED_SERIALIZED); + expect(resultView).toStrictEqual(TYPED_ARRAYS.INT8_SERIALIZED); + expect(resultString).toStrictEqual(PRIMITIVES.STRING); }); it('should deserialize mixed types with the build serializer', async () => { - const resultArray = await serializer.deserialize(mixedArray); - const resultObject = await serializer.deserialize(mixedObject); - const resultClass = await serializer.deserialize(serializedDataClass); - const resultDate = await serializer.deserialize(serializedFixedDate); - const resultMap = await serializer.deserialize(serializedMixedMap); - const resultSet = await serializer.deserialize(serializedMixedSet); - const resultView = await serializer.deserialize(serializedViewInt8); - const resultString = await serializer.deserialize(stringValue); - - expect(resultArray).toStrictEqual(mixedArray); - expect(resultObject).toStrictEqual(mixedObject); - expect(resultClass).toStrictEqual(dataClass); - expect(resultDate).toStrictEqual(fixedDate); - expect(resultMap).toStrictEqual(mixedMap); - expect(resultSet).toStrictEqual(mixedSet); - expect(resultView).toStrictEqual(viewInt8); - expect(resultString).toStrictEqual(stringValue); + const resultArray = await serializer.deserialize(ARRAYS.MIXED); + const resultObject = await serializer.deserialize(OBJECTS.MIXED); + const resultClass = await serializer.deserialize(CLASSES.DATA_SERIALIZED); + const resultDate = await serializer.deserialize(DATES.FIXED_SERIALIZED); + const resultMap = await serializer.deserialize(MAPS.MIXED_SERIALIZED); + const resultSet = await serializer.deserialize(SETS.MIXED_SERIALIZED); + const resultView = await serializer.deserialize(TYPED_ARRAYS.INT8_SERIALIZED); + const resultString = await serializer.deserialize(PRIMITIVES.STRING); + + expect(resultArray).toStrictEqual(ARRAYS.MIXED); + expect(resultObject).toStrictEqual(OBJECTS.MIXED); + expect(resultClass).toStrictEqual(CLASSES.DATA_INSTANCE); + expect(resultDate).toStrictEqual(DATES.FIXED); + expect(resultMap).toStrictEqual(MAPS.MIXED); + expect(resultSet).toStrictEqual(SETS.MIXED); + expect(resultView).toStrictEqual(TYPED_ARRAYS.INT8); + expect(resultString).toStrictEqual(PRIMITIVES.STRING); }); }); diff --git a/packages/serialization/test/_fixtures/DefaultClassLoader.fixture.ts b/packages/serialization/test/_fixtures/DefaultClassLoader.fixture.ts deleted file mode 100644 index 14a6a217..00000000 --- a/packages/serialization/test/_fixtures/DefaultClassLoader.fixture.ts +++ /dev/null @@ -1,48 +0,0 @@ - -import * as url from 'url'; - -import Loadable from '../../src/types/Loadable'; - -const __dirname = url.fileURLToPath(new URL('.', import.meta.url)); - -class Person {} - -class Customer extends Person {} - -const primitive = 42; - -const personLoadable: Loadable = -{ - name: 'Person', - source: `${__dirname}DefaultClassLoader.fixture.ts` -}; - -const customerLoadable: Loadable = -{ - name: 'Customer', - source: `${__dirname}DefaultClassLoader.fixture.ts` -}; - -const primitiveLoadable: Loadable = -{ - name: 'primitive', - source: `${__dirname}DefaultClassLoader.fixture.ts` -}; - -const nonexistingLoadable: Loadable = -{ - name: 'nonexisting', - source: `${__dirname}DefaultClassLoader.fixture.ts` -}; - -const invalidLoadable: Loadable = -{ - name: 'invalid', - source: null -}; - -export { - Person, Customer, primitive, - personLoadable, customerLoadable, primitiveLoadable, - nonexistingLoadable, invalidLoadable -}; diff --git a/packages/serialization/test/_fixtures/SerializerBuilder.fixture.ts b/packages/serialization/test/_fixtures/SerializerBuilder.fixture.ts deleted file mode 100644 index 7081a107..00000000 --- a/packages/serialization/test/_fixtures/SerializerBuilder.fixture.ts +++ /dev/null @@ -1,9 +0,0 @@ - -export { mixedArray } from './serializers/ArraySerializer.fixture'; -export { classLoader, dataClass, serializedDataClass } from './serializers/ClassSerializer.fixture'; -export { fixedDate, serializedFixedDate } from './serializers/DateSerializer.fixture'; -export { mixedMap, serializedMixedMap } from './serializers/MapSerializer.fixture'; -export { mixedObject } from './serializers/ObjectSerializer.fixture'; -export { stringValue } from './serializers/PrimitiveSerializer.fixture'; -export { mixedSet, serializedMixedSet } from './serializers/SetSerializer.fixture'; -export { viewInt8, serializedViewInt8 } from './serializers/TypedArraySerializer.fixture'; diff --git a/packages/serialization/test/_fixtures/serializers/ArraySerializer.fixture.ts b/packages/serialization/test/_fixtures/serializers/ArraySerializer.fixture.ts deleted file mode 100644 index 9352d490..00000000 --- a/packages/serialization/test/_fixtures/serializers/ArraySerializer.fixture.ts +++ /dev/null @@ -1,21 +0,0 @@ - -import Serializer from '../../../src/Serializer'; -import PrimitiveSerializer from '../../../src/serializers/PrimitiveSerializer'; -import ArraySerializer from '../../../src/serializers/ArraySerializer'; - -const parent = new Serializer(); -parent.addSerializer(new ArraySerializer()); -parent.addSerializer(new PrimitiveSerializer()); - -const emptyArray: unknown[] = []; -const mixedArray: unknown[] = ['a', 1, true]; -const nestedArray: unknown[] = ['b', 2, ['c', false], true]; - -const nonObject = 42; -const nonArray = new Map(); - -export { - parent, - emptyArray, mixedArray, nestedArray, - nonObject, nonArray -}; diff --git a/packages/serialization/test/_fixtures/serializers/ClassSerializer.fixture.ts b/packages/serialization/test/_fixtures/serializers/ClassSerializer.fixture.ts deleted file mode 100644 index d63d828d..00000000 --- a/packages/serialization/test/_fixtures/serializers/ClassSerializer.fixture.ts +++ /dev/null @@ -1,126 +0,0 @@ - -import Serializer from '../../../src/Serializer'; -import PrimitiveSerializer from '../../../src/serializers/PrimitiveSerializer'; -import ClassSerializer from '../../../src/serializers/ClassSerializer'; -import ClassLoader from '../../../src/interfaces/ClassLoader'; -import Loadable from '../../../src/types/Loadable'; - -class Data -{ - a?: number; - b?: boolean; -} - -(Data as Loadable).source = Data.name; - -class Constructed -{ - #a: number; - #b: boolean; - #c?: string; - - constructor(a: number, b: boolean) - { - this.#a = a; - this.#b = b; - } - - get a() { return this.#a; } - - get b() { return this.#b; } - - get c() { return this.#c; } - - set c(c) { this.#c = c; } -} - -(Constructed as Loadable).source = Constructed.name; - -class Nested -{ - name: string; - #constructed: Constructed; - - constructor(name: string, constructed: Constructed) - { - this.name = name; - this.#constructed = constructed; - } - - get constructed() { return this.#constructed; } -} - -(Nested as Loadable).source = Nested.name; - -class PrivateFieldClass -{ - #a: number; - #b: boolean; - #c?: string; - - constructor(a: number, b: boolean, c?: string) - { - this.#a = a; - this.#b = b; - this.#c = c; - } - - get d() { return this.#a; } -} - -(PrivateFieldClass as Loadable).source = PrivateFieldClass.name; - -class MockClassLoader implements ClassLoader -{ - async loadClass(loadable: Loadable): Promise - { - switch (loadable.source) - { - case 'Data': return Data; - case 'Constructed': return Constructed; - case 'Nested': return Nested; - case 'PrivateFieldClass': return PrivateFieldClass; - } - - throw new Error(`Unknown class: ${loadable.source}`); - } -} - -const classLoader = new MockClassLoader(); - -const parent = new Serializer(); -parent.addSerializer(new ClassSerializer(classLoader)); -parent.addSerializer(new PrimitiveSerializer()); - -const dataClass = new Data(); -dataClass.a = 1; -dataClass.b = true; - -const constructedClass = new Constructed(1, true); -constructedClass.c = 'hello'; - -const nestedClass = new Nested('hello', constructedClass); -const privateClass = new PrivateFieldClass(1, true); - -const serializedDataClass = { serialized: true, name: 'Data', source: 'Data', args: {}, fields: { a: 1, b: true } }; -const serializedConstructedClass = { serialized: true, name: 'Constructed', source: 'Constructed', args: { a: 1, b: true }, fields: { c: 'hello' } }; -const serializedNestedClass = { serialized: true, name: 'Nested', source: 'Nested', args: { name: 'hello', constructed: { serialized: true, name: 'Constructed', source: 'Constructed', args: { a: 1, b: true }, fields: { c: 'hello' } } }, fields: {} }; -const serializedPrivateClass = { serialized: true, name: 'PrivateFieldClass', source: 'PrivateFieldClass', args: { a: undefined, b: undefined, c: undefined }, fields: { } }; - -const serializedInvalidClass = { serialized: true, name: 'Invalid', source: undefined, args: {}, fields: {} }; -const serializedUnserializableClass = { serialized: true, name: 'Infinity', source: undefined, args: {}, fields: {} }; - -const nonObject = 42; -const nonClassObject = new Object(); -const notSerialized = { name: 'Data', source: undefined, args: {}, fields: {} }; -const invalidName = { serialized: true, name: 123, source: undefined, args: {}, fields: {} }; -const invalidArgs = { serialized: true, name: 'Data', source: undefined, args: [], fields: {} }; -const invalidFields = { serialized: true, name: 'Data', source: undefined, args: {}, fields: [] }; - -export { - Data, Constructed, Nested, PrivateFieldClass, - parent, classLoader, - dataClass, constructedClass, nestedClass, privateClass, - serializedDataClass, serializedConstructedClass, serializedNestedClass, serializedPrivateClass, serializedInvalidClass, serializedUnserializableClass, - nonObject, nonClassObject, notSerialized, invalidName, invalidArgs, invalidFields -}; diff --git a/packages/serialization/test/_fixtures/serializers/ObjectSerializer.fixture.ts b/packages/serialization/test/_fixtures/serializers/ObjectSerializer.fixture.ts deleted file mode 100644 index e8bb33e4..00000000 --- a/packages/serialization/test/_fixtures/serializers/ObjectSerializer.fixture.ts +++ /dev/null @@ -1,21 +0,0 @@ - -import Serializer from '../../../src/Serializer'; -import PrimitiveSerializer from '../../../src/serializers/PrimitiveSerializer'; -import ObjectSerializer from '../../../src/serializers/ObjectSerializer'; - -const parent = new Serializer(); -parent.addSerializer(new ObjectSerializer()); -parent.addSerializer(new PrimitiveSerializer()); - -const emptyObject = {}; -const mixedObject = { a: 1, b: true, c: 'hello' }; -const nestedObject = { a: 1, b: true, c: { d: false, e: true } }; - -const nonObject = 42; -const specificObject = new Map(); - -export { - parent, - emptyObject, mixedObject, nestedObject, - nonObject, specificObject -}; diff --git a/packages/serialization/test/_fixtures/serializers/PrimitiveSerializer.fixture.ts b/packages/serialization/test/_fixtures/serializers/PrimitiveSerializer.fixture.ts deleted file mode 100644 index 2e416907..00000000 --- a/packages/serialization/test/_fixtures/serializers/PrimitiveSerializer.fixture.ts +++ /dev/null @@ -1,9 +0,0 @@ - -const numberValue = 1; -const boolValue = true; -const stringValue = 'hello'; -const nullValue = null; -const undefinedValue = undefined; -const objectValue = {}; - -export { numberValue, boolValue, stringValue, nullValue, undefinedValue, objectValue }; diff --git a/packages/serialization/test/fixtures/index.ts b/packages/serialization/test/fixtures/index.ts new file mode 100644 index 00000000..42771205 --- /dev/null +++ b/packages/serialization/test/fixtures/index.ts @@ -0,0 +1,2 @@ + +export * from './serializers.fixture'; diff --git a/packages/serialization/test/_fixtures/Serializer.fixture.ts b/packages/serialization/test/fixtures/serializers.fixture.ts similarity index 94% rename from packages/serialization/test/_fixtures/Serializer.fixture.ts rename to packages/serialization/test/fixtures/serializers.fixture.ts index 9dcdcdb1..890d0a16 100644 --- a/packages/serialization/test/_fixtures/Serializer.fixture.ts +++ b/packages/serialization/test/fixtures/serializers.fixture.ts @@ -53,7 +53,10 @@ class StringSerializer extends ValueSerializer async deserialize(value: string): Promise { return value; } } -export { - FirstSerializer, SecondSerializer, - NumberSerializer, StringSerializer +export const SERIALIZERS = +{ + FirstSerializer, + SecondSerializer, + NumberSerializer, + StringSerializer, }; diff --git a/packages/serialization/test/serializers/ArraySerializer.spec.ts b/packages/serialization/test/serializers/ArraySerializer.spec.ts index 5951514c..660b256b 100644 --- a/packages/serialization/test/serializers/ArraySerializer.spec.ts +++ b/packages/serialization/test/serializers/ArraySerializer.spec.ts @@ -1,16 +1,17 @@ import { describe, expect, it } from 'vitest'; +import Serializer from '../../src/Serializer'; +import PrimitiveSerializer from '../../src/serializers/PrimitiveSerializer'; import ArraySerializer from '../../src/serializers/ArraySerializer'; -import { - parent, - emptyArray, mixedArray, nestedArray, - nonObject, nonArray -} from '../_fixtures/serializers/ArraySerializer.fixture'; +import { ARRAYS } from './fixtures'; const serializer = new ArraySerializer(); -serializer.parent = parent; +const parent = new Serializer(); + +parent.addSerializer(serializer); +parent.addSerializer(new PrimitiveSerializer()); describe('serializers/ArraySerializer', () => { @@ -18,15 +19,15 @@ describe('serializers/ArraySerializer', () => { it('should tell it can serialize an array', () => { - const supportsArray = serializer.canSerialize(emptyArray); + const supportsArray = serializer.canSerialize(ARRAYS.EMPTY); expect(supportsArray).toBeTruthy(); }); it('should tell it cannot serialize others', () => { - const supportsNonObject = serializer.canSerialize(nonObject); - const supportsNonArray = serializer.canSerialize(nonArray); + const supportsNonObject = serializer.canSerialize(ARRAYS.NON_OBJECT); + const supportsNonArray = serializer.canSerialize(ARRAYS.NON_ARRAY); expect(supportsNonObject).toBeFalsy(); expect(supportsNonArray).toBeFalsy(); @@ -37,15 +38,15 @@ describe('serializers/ArraySerializer', () => { it('should tell it can deserialize an array', () => { - const supportsArray = serializer.canDeserialize(emptyArray); + const supportsArray = serializer.canDeserialize(ARRAYS.EMPTY); expect(supportsArray).toBeTruthy(); }); it('should tell it cannot deserialize others', () => { - const supportsNonObject = serializer.canDeserialize(nonObject); - const supportsNonArray = serializer.canDeserialize(nonArray); + const supportsNonObject = serializer.canDeserialize(ARRAYS.NON_OBJECT); + const supportsNonArray = serializer.canDeserialize(ARRAYS.NON_ARRAY); expect(supportsNonObject).toBeFalsy(); expect(supportsNonArray).toBeFalsy(); @@ -56,13 +57,13 @@ describe('serializers/ArraySerializer', () => { it('should serialize an array', async () => { - const resultEmptyArray = await serializer.serialize(emptyArray); - const resultMixedArray = await serializer.serialize(mixedArray); - const resultNestedArray = await serializer.serialize(nestedArray); + const resultEmptyArray = await serializer.serialize(ARRAYS.EMPTY); + const resultMixedArray = await serializer.serialize(ARRAYS.MIXED); + const resultNestedArray = await serializer.serialize(ARRAYS.NESTED); - expect(resultEmptyArray).toStrictEqual(emptyArray); - expect(resultMixedArray).toStrictEqual(mixedArray); - expect(resultNestedArray).toStrictEqual(nestedArray); + expect(resultEmptyArray).toStrictEqual(ARRAYS.EMPTY); + expect(resultMixedArray).toStrictEqual(ARRAYS.MIXED); + expect(resultNestedArray).toStrictEqual(ARRAYS.NESTED); }); }); @@ -70,13 +71,13 @@ describe('serializers/ArraySerializer', () => { it('should deserialize an array', async () => { - const resultEmptyArray = await serializer.deserialize(emptyArray); - const resultMixedArray = await serializer.deserialize(mixedArray); - const resultNestedArray = await serializer.deserialize(nestedArray); + const resultEmptyArray = await serializer.deserialize(ARRAYS.EMPTY); + const resultMixedArray = await serializer.deserialize(ARRAYS.MIXED); + const resultNestedArray = await serializer.deserialize(ARRAYS.NESTED); - expect(resultEmptyArray).toStrictEqual(emptyArray); - expect(resultMixedArray).toStrictEqual(mixedArray); - expect(resultNestedArray).toStrictEqual(nestedArray); + expect(resultEmptyArray).toStrictEqual(ARRAYS.EMPTY); + expect(resultMixedArray).toStrictEqual(ARRAYS.MIXED); + expect(resultNestedArray).toStrictEqual(ARRAYS.NESTED); }); }); }); diff --git a/packages/serialization/test/serializers/BigIntSerializer.spec.ts b/packages/serialization/test/serializers/BigIntSerializer.spec.ts index ccacc5aa..727fad38 100644 --- a/packages/serialization/test/serializers/BigIntSerializer.spec.ts +++ b/packages/serialization/test/serializers/BigIntSerializer.spec.ts @@ -4,12 +4,7 @@ import { describe, expect, it } from 'vitest'; import BigIntSerializer from '../../src/serializers/BigIntSerializer'; import InvalidBigIntString from '../../src/serializers/errors/InvalidBigIntString'; -import -{ - validBigInt, - serializedValidBigInt, - nonObject, nonBigInt, notSerialized, invalidName, invalidBigIntValue, invalidBigIntString -} from '../_fixtures/serializers/BigIntSerializer.fixture'; +import { BIG_INTEGERS } from './fixtures'; const serializer = new BigIntSerializer(); @@ -19,15 +14,15 @@ describe('serializers/BigIntSerializer', () => { it('should tell it can serialize a big int', () => { - const supportsBigInt = serializer.canSerialize(validBigInt); + const supportsBigInt = serializer.canSerialize(BIG_INTEGERS.VALID); expect(supportsBigInt).toBeTruthy(); }); it('should tell it cannot serialize others', () => { - const supportsNonObject = serializer.canSerialize(nonObject); - const supportsNonBigInt = serializer.canSerialize(nonBigInt); + const supportsNonObject = serializer.canSerialize(BIG_INTEGERS.NON_OBJECT); + const supportsNonBigInt = serializer.canSerialize(BIG_INTEGERS.NON_BIGINT); expect(supportsNonObject).toBeFalsy(); expect(supportsNonBigInt).toBeFalsy(); @@ -38,17 +33,17 @@ describe('serializers/BigIntSerializer', () => { it('should tell it can deserialize a big int', () => { - const supportsBigInt = serializer.canDeserialize(serializedValidBigInt); + const supportsBigInt = serializer.canDeserialize(BIG_INTEGERS.VALID_SERIALIZED); expect(supportsBigInt).toBeTruthy(); }); it('should tell it cannot deserialize others', () => { - const supportsNonObject = serializer.canDeserialize(nonObject); - const supportsNotSerialized = serializer.canDeserialize(notSerialized); - const supportsInvalidName = serializer.canDeserialize(invalidName); - const supportsInvalidBigIntValue = serializer.canDeserialize(invalidBigIntValue); + const supportsNonObject = serializer.canDeserialize(BIG_INTEGERS.NON_OBJECT); + const supportsNotSerialized = serializer.canDeserialize(BIG_INTEGERS.NOT_SERIALIZED); + const supportsInvalidName = serializer.canDeserialize(BIG_INTEGERS.INVALID_NAME); + const supportsInvalidBigIntValue = serializer.canDeserialize(BIG_INTEGERS.INVALID_BIGINT_VALUE); expect(supportsNonObject).toBeFalsy(); expect(supportsNotSerialized).toBeFalsy(); @@ -61,9 +56,9 @@ describe('serializers/BigIntSerializer', () => { it('should serialize a big int', async () => { - const resultValidBigInt = await serializer.serialize(validBigInt); + const resultValidBigInt = await serializer.serialize(BIG_INTEGERS.VALID); - expect(resultValidBigInt).toStrictEqual(serializedValidBigInt); + expect(resultValidBigInt).toStrictEqual(BIG_INTEGERS.VALID_SERIALIZED); }); }); @@ -71,14 +66,14 @@ describe('serializers/BigIntSerializer', () => { it('should deserialize a big int', async () => { - const resultValidBigInt = await serializer.deserialize(serializedValidBigInt); + const resultValidBigInt = await serializer.deserialize(BIG_INTEGERS.VALID_SERIALIZED); - expect(resultValidBigInt).toStrictEqual(validBigInt); + expect(resultValidBigInt).toStrictEqual(BIG_INTEGERS.VALID); }); it('should not deserialize a big int with an invalid big int string', async () => { - const deserialize = async () => serializer.deserialize(invalidBigIntString); + const deserialize = async () => serializer.deserialize(BIG_INTEGERS.INVALID_BIGINT_STRING); expect(deserialize).rejects.toStrictEqual(new InvalidBigIntString('1.3')); }); diff --git a/packages/serialization/test/serializers/ClassSerializer.spec.ts b/packages/serialization/test/serializers/ClassSerializer.spec.ts index 1b48d6bd..18319e90 100644 --- a/packages/serialization/test/serializers/ClassSerializer.spec.ts +++ b/packages/serialization/test/serializers/ClassSerializer.spec.ts @@ -4,18 +4,17 @@ import { describe, expect, it } from 'vitest'; import ClassNotFound from '../../src/errors/ClassNotFound'; import InvalidClass from '../../src/errors/InvalidClass'; +import Serializer from '../../src/Serializer'; +import PrimitiveSerializer from '../../src/serializers/PrimitiveSerializer'; import ClassSerializer from '../../src/serializers/ClassSerializer'; -import - { - parent, classLoader, - dataClass, constructedClass, nestedClass, privateClass, - serializedDataClass, serializedConstructedClass, serializedNestedClass, serializedPrivateClass, serializedInvalidClass, serializedUnserializableClass, - nonObject, nonClassObject, notSerialized, invalidName, invalidArgs, invalidFields - } from '../_fixtures/serializers/ClassSerializer.fixture'; +import { CLASSES, classResolver } from './fixtures'; + +const serializer = new ClassSerializer(classResolver); +const parent = new Serializer(); -const serializer = new ClassSerializer(classLoader); -serializer.parent = parent; +parent.addSerializer(serializer); +parent.addSerializer(new PrimitiveSerializer()); describe('serializers/ClassSerializer', () => { @@ -23,15 +22,15 @@ describe('serializers/ClassSerializer', () => { it('should tell it can serialize a class instance', () => { - const supportsClass = serializer.canSerialize(dataClass); + const supportsClass = serializer.canSerialize(CLASSES.DATA_INSTANCE); expect(supportsClass).toBeTruthy(); }); it('should tell it cannot serialize others', () => { - const supportsNonObject = serializer.canSerialize(nonObject); - const supportsNonClassObject = serializer.canSerialize(nonClassObject); + const supportsNonObject = serializer.canSerialize(CLASSES.NON_OBJECT); + const supportsNonClassObject = serializer.canSerialize(CLASSES.NON_CLASS_OBJECT); expect(supportsNonObject).toBeFalsy(); expect(supportsNonClassObject).toBeFalsy(); @@ -42,20 +41,20 @@ describe('serializers/ClassSerializer', () => { it('should tell it can deserialize a class instance', () => { - const supportsClass = serializer.canDeserialize(serializedDataClass); + const supportsClass = serializer.canDeserialize(CLASSES.DATA_SERIALIZED); expect(supportsClass).toBeTruthy(); }); it('should tell it cannot deserialize others', () => { - const supportsNotSerialized = serializer.canDeserialize(notSerialized); - const supportsInvalidName = serializer.canDeserialize(invalidName); - const supportsInvalidArgs = serializer.canDeserialize(invalidArgs); - const supportsInvalidFields = serializer.canDeserialize(invalidFields); + const supportsNotSerialized = serializer.canDeserialize(CLASSES.NOT_SERIALIZED); + const supportsInvalidKey = serializer.canDeserialize(CLASSES.INVALID_KEY); + const supportsInvalidArgs = serializer.canDeserialize(CLASSES.INVALID_ARGS); + const supportsInvalidFields = serializer.canDeserialize(CLASSES.INVALID_FIELDS); expect(supportsNotSerialized).toBeFalsy(); - expect(supportsInvalidName).toBeFalsy(); + expect(supportsInvalidKey).toBeFalsy(); expect(supportsInvalidArgs).toBeFalsy(); expect(supportsInvalidFields).toBeFalsy(); }); @@ -65,20 +64,20 @@ describe('serializers/ClassSerializer', () => { it('should serialize a class instance', async () => { - const resultDataClass = await serializer.serialize(dataClass); - const resultConstructedClass = await serializer.serialize(constructedClass); - const resultNestedClass = await serializer.serialize(nestedClass); + const resultDataClass = await serializer.serialize(CLASSES.DATA_INSTANCE); + const resultConstructedClass = await serializer.serialize(CLASSES.CONSTRUCTED_INSTANCE); + const resultNestedClass = await serializer.serialize(CLASSES.NESTED_INSTANCE); - expect(resultDataClass).toStrictEqual(serializedDataClass); - expect(resultConstructedClass).toStrictEqual(serializedConstructedClass); - expect(resultNestedClass).toStrictEqual(serializedNestedClass); + expect(resultDataClass).toStrictEqual(CLASSES.DATA_SERIALIZED); + expect(resultConstructedClass).toStrictEqual(CLASSES.CONSTRUCTED_SERIALIZED); + expect(resultNestedClass).toStrictEqual(CLASSES.NESTED_SERIALIZED); }); it('should not serialize set or get only variables', async () => { - const resultPrivateClass = await serializer.serialize(privateClass); + const resultPrivateClass = await serializer.serialize(CLASSES.PRIVATE_INSTANCE); - expect(resultPrivateClass).toStrictEqual(serializedPrivateClass); + expect(resultPrivateClass).toStrictEqual(CLASSES.PRIVATE_SERIALIZED); }); }); @@ -86,25 +85,25 @@ describe('serializers/ClassSerializer', () => { it('should deserialize a class instance', async () => { - const resultDataClass = await serializer.deserialize(serializedDataClass); - const resultConstructedClass = await serializer.deserialize(serializedConstructedClass); - const resultNestedClass = await serializer.deserialize(serializedNestedClass); + const resultDataClass = await serializer.deserialize(CLASSES.DATA_SERIALIZED); + const resultConstructedClass = await serializer.deserialize(CLASSES.CONSTRUCTED_SERIALIZED); + const resultNestedClass = await serializer.deserialize(CLASSES.NESTED_SERIALIZED); - expect(resultDataClass).toStrictEqual(dataClass); - expect(resultConstructedClass).toStrictEqual(constructedClass); - expect(resultNestedClass).toStrictEqual(nestedClass); + expect(resultDataClass).toStrictEqual(CLASSES.DATA_INSTANCE); + expect(resultConstructedClass).toStrictEqual(CLASSES.CONSTRUCTED_INSTANCE); + expect(resultNestedClass).toStrictEqual(CLASSES.NESTED_INSTANCE); }); it('should not deserialize invalid objects', async () => { - const deserialize = async () => serializer.deserialize(serializedInvalidClass); + const deserialize = async () => serializer.deserialize(CLASSES.INVALID_SERIALIZED); expect(deserialize).rejects.toStrictEqual(new ClassNotFound('Invalid')); }); it('should not deserialize non-function instances', async () => { - const deserialize = async () => serializer.deserialize(serializedUnserializableClass); + const deserialize = async () => serializer.deserialize(CLASSES.UNSERIALIZABLE); expect(deserialize).rejects.toStrictEqual(new InvalidClass('Infinity')); }); diff --git a/packages/serialization/test/serializers/DateSerializer.spec.ts b/packages/serialization/test/serializers/DateSerializer.spec.ts index c7f68c11..8d8e6740 100644 --- a/packages/serialization/test/serializers/DateSerializer.spec.ts +++ b/packages/serialization/test/serializers/DateSerializer.spec.ts @@ -4,12 +4,7 @@ import { describe, expect, it } from 'vitest'; import DateSerializer from '../../src/serializers/DateSerializer'; import InvalidDateString from '../../src/serializers/errors/InvalidDateString'; -import - { - fixedDate, - serializedFixedDate, - nonObject, nonDate, notSerialized, invalidName, invalidDateValue, invalidDateString - } from '../_fixtures/serializers/DateSerializer.fixture'; +import { DATES } from './fixtures'; const serializer = new DateSerializer(); @@ -19,15 +14,15 @@ describe('serializers/DateSerializer', () => { it('should tell it can serialize a date', () => { - const supportsDate = serializer.canSerialize(fixedDate); + const supportsDate = serializer.canSerialize(DATES.FIXED); expect(supportsDate).toBeTruthy(); }); it('should tell it cannot serialize others', () => { - const supportsNonObject = serializer.canSerialize(nonObject); - const supportsNonDate = serializer.canSerialize(nonDate); + const supportsNonObject = serializer.canSerialize(DATES.NON_OBJECT); + const supportsNonDate = serializer.canSerialize(DATES.NON_DATE); expect(supportsNonObject).toBeFalsy(); expect(supportsNonDate).toBeFalsy(); @@ -38,17 +33,17 @@ describe('serializers/DateSerializer', () => { it('should tell it can deserialize a date', () => { - const supportsDate = serializer.canDeserialize(serializedFixedDate); + const supportsDate = serializer.canDeserialize(DATES.FIXED_SERIALIZED); expect(supportsDate).toBeTruthy(); }); it('should tell it cannot deserialize others', () => { - const supportsNonObject = serializer.canDeserialize(nonObject); - const supportsNotSerialized = serializer.canDeserialize(notSerialized); - const supportsInvalidName = serializer.canDeserialize(invalidName); - const supportsInvalidDateValue = serializer.canDeserialize(invalidDateValue); + const supportsNonObject = serializer.canDeserialize(DATES.NON_OBJECT); + const supportsNotSerialized = serializer.canDeserialize(DATES.NOT_SERIALIZED); + const supportsInvalidName = serializer.canDeserialize(DATES.INVALID_NAME); + const supportsInvalidDateValue = serializer.canDeserialize(DATES.INVALID_DATE_VALUE); expect(supportsNonObject).toBeFalsy(); expect(supportsNotSerialized).toBeFalsy(); @@ -61,9 +56,9 @@ describe('serializers/DateSerializer', () => { it('should serialize a date', async () => { - const resultFixedDate = await serializer.serialize(fixedDate); + const resultFixedDate = await serializer.serialize(DATES.FIXED); - expect(resultFixedDate).toStrictEqual(serializedFixedDate); + expect(resultFixedDate).toStrictEqual(DATES.FIXED_SERIALIZED); }); }); @@ -71,14 +66,14 @@ describe('serializers/DateSerializer', () => { it('should deserialize a date', async () => { - const resultFixedDate = await serializer.deserialize(serializedFixedDate); + const resultFixedDate = await serializer.deserialize(DATES.FIXED_SERIALIZED); - expect(resultFixedDate).toStrictEqual(fixedDate); + expect(resultFixedDate).toStrictEqual(DATES.FIXED); }); it('should not deserialize a date with an invalid date string', async () => { - const deserialize = async () => serializer.deserialize(invalidDateString); + const deserialize = async () => serializer.deserialize(DATES.INVALID_DATE_STRING); expect(deserialize).rejects.toStrictEqual(new InvalidDateString('hello')); }); diff --git a/packages/serialization/test/serializers/ErrorSerializer.spec.ts b/packages/serialization/test/serializers/ErrorSerializer.spec.ts index 68a0449b..f2fe86ed 100644 --- a/packages/serialization/test/serializers/ErrorSerializer.spec.ts +++ b/packages/serialization/test/serializers/ErrorSerializer.spec.ts @@ -3,12 +3,7 @@ import { describe, expect, it } from 'vitest'; import ErrorSerializer from '../../src/serializers/ErrorSerializer'; -import { - plainError, evalError, rangeError, referenceError, syntaxError, typeError, uriError, - serializedPlainError, serializedEvalError, serializedRangeError, serializedReferenceError, serializedSyntaxError, serializedTypeError, serializedURIError, - customError, otherClass, - notSerialized, invalidName, invalidType -} from '../_fixtures/serializers/ErrorSerializer.fixture'; +import { ERRORS } from './fixtures'; const serializer = new ErrorSerializer(); @@ -18,13 +13,13 @@ describe('serializers/ErrorSerializer', () => { it('should tell it can serialize an error', () => { - const supportsPlainError = serializer.canSerialize(plainError); - const supportsEvalError = serializer.canSerialize(evalError); - const supportsRangeError = serializer.canSerialize(rangeError); - const supportsReferenceError = serializer.canSerialize(referenceError); - const supportsSyntaxError = serializer.canSerialize(syntaxError); - const supportsTypeError = serializer.canSerialize(typeError); - const supportsURIError = serializer.canSerialize(uriError); + const supportsPlainError = serializer.canSerialize(ERRORS.PLAIN); + const supportsEvalError = serializer.canSerialize(ERRORS.EVAL); + const supportsRangeError = serializer.canSerialize(ERRORS.RANGE); + const supportsReferenceError = serializer.canSerialize(ERRORS.REFERENCE); + const supportsSyntaxError = serializer.canSerialize(ERRORS.SYNTAX); + const supportsTypeError = serializer.canSerialize(ERRORS.TYPE); + const supportsURIError = serializer.canSerialize(ERRORS.URI); expect(supportsPlainError).toBeTruthy(); expect(supportsEvalError).toBeTruthy(); @@ -37,11 +32,11 @@ describe('serializers/ErrorSerializer', () => it('should tell it cannot serialize others', () => { - const supportsCustomError = serializer.canSerialize(customError); - const supportsOtherClass = serializer.canSerialize(otherClass); - const supportsNotSerialized = serializer.canDeserialize(notSerialized); - const supportsInvalidName = serializer.canDeserialize(invalidName); - const supportsInvalidType = serializer.canDeserialize(invalidType); + const supportsCustomError = serializer.canSerialize(ERRORS.CUSTOM); + const supportsOtherClass = serializer.canSerialize(ERRORS.OTHER_CLASS); + const supportsNotSerialized = serializer.canDeserialize(ERRORS.NOT_SERIALIZED); + const supportsInvalidName = serializer.canDeserialize(ERRORS.INVALID_NAME); + const supportsInvalidType = serializer.canDeserialize(ERRORS.INVALID_TYPE); expect(supportsCustomError).toBeFalsy(); expect(supportsOtherClass).toBeFalsy(); @@ -55,21 +50,21 @@ describe('serializers/ErrorSerializer', () => { it('should serialize an error', async () => { - const resultPlainError = await serializer.serialize(plainError); - const resultEvalError = await serializer.serialize(evalError); - const resultRangeError = await serializer.serialize(rangeError); - const resultReferenceError = await serializer.serialize(referenceError); - const resultSyntaxError = await serializer.serialize(syntaxError); - const resultTypeError = await serializer.serialize(typeError); - const resultURIError = await serializer.serialize(uriError); + const resultPlainError = await serializer.serialize(ERRORS.PLAIN); + const resultEvalError = await serializer.serialize(ERRORS.EVAL); + const resultRangeError = await serializer.serialize(ERRORS.RANGE); + const resultReferenceError = await serializer.serialize(ERRORS.REFERENCE); + const resultSyntaxError = await serializer.serialize(ERRORS.SYNTAX); + const resultTypeError = await serializer.serialize(ERRORS.TYPE); + const resultURIError = await serializer.serialize(ERRORS.URI); - expect(resultPlainError).toStrictEqual(serializedPlainError); - expect(resultEvalError).toStrictEqual(serializedEvalError); - expect(resultRangeError).toStrictEqual(serializedRangeError); - expect(resultReferenceError).toStrictEqual(serializedReferenceError); - expect(resultSyntaxError).toStrictEqual(serializedSyntaxError); - expect(resultTypeError).toStrictEqual(serializedTypeError); - expect(resultURIError).toStrictEqual(serializedURIError); + expect(resultPlainError).toStrictEqual(ERRORS.PLAIN_SERIALIZED); + expect(resultEvalError).toStrictEqual(ERRORS.EVAL_SERIALIZED); + expect(resultRangeError).toStrictEqual(ERRORS.RANGE_SERIALIZED); + expect(resultReferenceError).toStrictEqual(ERRORS.REFERENCE_SERIALIZED); + expect(resultSyntaxError).toStrictEqual(ERRORS.SYNTAX_SERIALIZED); + expect(resultTypeError).toStrictEqual(ERRORS.TYPE_SERIALIZED); + expect(resultURIError).toStrictEqual(ERRORS.URI_SERIALIZED); }); }); @@ -77,21 +72,21 @@ describe('serializers/ErrorSerializer', () => { it('should deserialize an error', async () => { - const resultPlainError = await serializer.deserialize(serializedPlainError); - const resultEvalError = await serializer.deserialize(serializedEvalError); - const resultRangeError = await serializer.deserialize(serializedRangeError); - const resultReferenceError = await serializer.deserialize(serializedReferenceError); - const resultSyntaxError = await serializer.deserialize(serializedSyntaxError); - const resultTypeError = await serializer.deserialize(serializedTypeError); - const resultURIError = await serializer.deserialize(serializedURIError); + const resultPlainError = await serializer.deserialize(ERRORS.PLAIN_SERIALIZED); + const resultEvalError = await serializer.deserialize(ERRORS.EVAL_SERIALIZED); + const resultRangeError = await serializer.deserialize(ERRORS.RANGE_SERIALIZED); + const resultReferenceError = await serializer.deserialize(ERRORS.REFERENCE_SERIALIZED); + const resultSyntaxError = await serializer.deserialize(ERRORS.SYNTAX_SERIALIZED); + const resultTypeError = await serializer.deserialize(ERRORS.TYPE_SERIALIZED); + const resultURIError = await serializer.deserialize(ERRORS.URI_SERIALIZED); - expect(resultPlainError).toStrictEqual(plainError); - expect(resultEvalError).toStrictEqual(evalError); - expect(resultRangeError).toStrictEqual(rangeError); - expect(resultReferenceError).toStrictEqual(referenceError); - expect(resultSyntaxError).toStrictEqual(syntaxError); - expect(resultTypeError).toStrictEqual(typeError); - expect(resultURIError).toStrictEqual(uriError); + expect(resultPlainError).toStrictEqual(ERRORS.PLAIN); + expect(resultEvalError).toStrictEqual(ERRORS.EVAL); + expect(resultRangeError).toStrictEqual(ERRORS.RANGE); + expect(resultReferenceError).toStrictEqual(ERRORS.REFERENCE); + expect(resultSyntaxError).toStrictEqual(ERRORS.SYNTAX); + expect(resultTypeError).toStrictEqual(ERRORS.TYPE); + expect(resultURIError).toStrictEqual(ERRORS.URI); }); }); }); diff --git a/packages/serialization/test/serializers/MapSerializer.spec.ts b/packages/serialization/test/serializers/MapSerializer.spec.ts index ecabb352..c207abc0 100644 --- a/packages/serialization/test/serializers/MapSerializer.spec.ts +++ b/packages/serialization/test/serializers/MapSerializer.spec.ts @@ -1,17 +1,17 @@ import { describe, expect, it } from 'vitest'; +import Serializer from '../../src/Serializer'; +import PrimitiveSerializer from '../../src/serializers/PrimitiveSerializer'; import MapSerializer from '../../src/serializers/MapSerializer'; -import { - parent, - emptyMap, mixedMap, nestedMap, - serializedEmptyMap, serializedMixedMap, serializedNestedMap, - nonObject, nonMap, notSerialized, invalidName, invalidKeys, invalidValues -} from '../_fixtures/serializers/MapSerializer.fixture'; +import { MAPS } from './fixtures'; const serializer = new MapSerializer(); -serializer.parent = parent; +const parent = new Serializer(); + +parent.addSerializer(serializer); +parent.addSerializer(new PrimitiveSerializer()); describe('serializers/MapSerializer', () => { @@ -19,15 +19,15 @@ describe('serializers/MapSerializer', () => { it('should tell it can serialize a map', () => { - const supportsMap = serializer.canSerialize(emptyMap); + const supportsMap = serializer.canSerialize(MAPS.EMPTY); expect(supportsMap).toBeTruthy(); }); it('should tell it cannot serialize others', () => { - const supportsNonObject = serializer.canSerialize(nonObject); - const supportsNonMap = serializer.canSerialize(nonMap); + const supportsNonObject = serializer.canSerialize(MAPS.NON_OBJECT); + const supportsNonMap = serializer.canSerialize(MAPS.NON_MAP); expect(supportsNonObject).toBeFalsy(); expect(supportsNonMap).toBeFalsy(); @@ -38,18 +38,18 @@ describe('serializers/MapSerializer', () => { it('should tell it can deserialize a map', () => { - const supportsMap = serializer.canDeserialize(serializedEmptyMap); + const supportsMap = serializer.canDeserialize(MAPS.EMPTY_SERIALIZED); expect(supportsMap).toBeTruthy(); }); it('should tell it cannot deserialize others', () => { - const supportsNonObject = serializer.canDeserialize(nonObject); - const supportsNotSerialized = serializer.canDeserialize(notSerialized); - const supportsInvalidName = serializer.canDeserialize(invalidName); - const supportsInvalidKeys = serializer.canDeserialize(invalidKeys); - const supportsInvalidValues = serializer.canDeserialize(invalidValues); + const supportsNonObject = serializer.canDeserialize(MAPS.NON_OBJECT); + const supportsNotSerialized = serializer.canDeserialize(MAPS.NOT_SERIALIZED); + const supportsInvalidName = serializer.canDeserialize(MAPS.INVALID_NAME); + const supportsInvalidKeys = serializer.canDeserialize(MAPS.INVALID_KEYS); + const supportsInvalidValues = serializer.canDeserialize(MAPS.INVALID_VALUES); expect(supportsNonObject).toBeFalsy(); expect(supportsNotSerialized).toBeFalsy(); @@ -63,13 +63,13 @@ describe('serializers/MapSerializer', () => { it('should serialize a map', async () => { - const resultEmptyMap = await serializer.serialize(emptyMap); - const resultMixedMap = await serializer.serialize(mixedMap); - const resultNestedMap = await serializer.serialize(nestedMap); + const resultEmptyMap = await serializer.serialize(MAPS.EMPTY); + const resultMixedMap = await serializer.serialize(MAPS.MIXED); + const resultNestedMap = await serializer.serialize(MAPS.NESTED); - expect(resultEmptyMap).toStrictEqual(serializedEmptyMap); - expect(resultMixedMap).toStrictEqual(serializedMixedMap); - expect(resultNestedMap).toStrictEqual(serializedNestedMap); + expect(resultEmptyMap).toStrictEqual(MAPS.EMPTY_SERIALIZED); + expect(resultMixedMap).toStrictEqual(MAPS.MIXED_SERIALIZED); + expect(resultNestedMap).toStrictEqual(MAPS.NESTED_SERIALIZED); }); }); @@ -77,13 +77,13 @@ describe('serializers/MapSerializer', () => { it('should deserialize a map', async () => { - const resultEmptyMap = await serializer.deserialize(serializedEmptyMap); - const resultMixedMap = await serializer.deserialize(serializedMixedMap); - const resultNestedMap = await serializer.deserialize(serializedNestedMap); + const resultEmptyMap = await serializer.deserialize(MAPS.EMPTY_SERIALIZED); + const resultMixedMap = await serializer.deserialize(MAPS.MIXED_SERIALIZED); + const resultNestedMap = await serializer.deserialize(MAPS.NESTED_SERIALIZED); - expect(resultEmptyMap).toStrictEqual(emptyMap); - expect(resultMixedMap).toStrictEqual(mixedMap); - expect(resultNestedMap).toStrictEqual(nestedMap); + expect(resultEmptyMap).toStrictEqual(MAPS.EMPTY); + expect(resultMixedMap).toStrictEqual(MAPS.MIXED); + expect(resultNestedMap).toStrictEqual(MAPS.NESTED); }); }); }); diff --git a/packages/serialization/test/serializers/ObjectSerializer.spec.ts b/packages/serialization/test/serializers/ObjectSerializer.spec.ts index dd7e6118..739eb165 100644 --- a/packages/serialization/test/serializers/ObjectSerializer.spec.ts +++ b/packages/serialization/test/serializers/ObjectSerializer.spec.ts @@ -1,16 +1,17 @@ import { describe, expect, it } from 'vitest'; +import Serializer from '../../src/Serializer'; +import PrimitiveSerializer from '../../src/serializers/PrimitiveSerializer'; import ObjectSerializer from '../../src/serializers/ObjectSerializer'; -import { - parent, - emptyObject, mixedObject, nestedObject, - nonObject, specificObject -} from '../_fixtures/serializers/ObjectSerializer.fixture'; +import { OBJECTS } from './fixtures'; const serializer = new ObjectSerializer(); -serializer.parent = parent; +const parent = new Serializer(); + +parent.addSerializer(serializer); +parent.addSerializer(new PrimitiveSerializer()); describe('serializers/ObjectSerializer', () => { @@ -18,15 +19,15 @@ describe('serializers/ObjectSerializer', () => { it('should tell it can serialize an object', () => { - const supportsObject = serializer.canSerialize(emptyObject); + const supportsObject = serializer.canSerialize(OBJECTS.EMPTY); expect(supportsObject).toBeTruthy(); }); it('should tell it cannot serialize others', () => { - const supportsNonObject = serializer.canSerialize(nonObject); - const supportsSpecificObject = serializer.canSerialize(specificObject); + const supportsNonObject = serializer.canSerialize(OBJECTS.NON_OBJECT); + const supportsSpecificObject = serializer.canSerialize(OBJECTS.SPECIFIC_OBJECT); expect(supportsNonObject).toBeFalsy(); expect(supportsSpecificObject).toBeFalsy(); @@ -37,15 +38,15 @@ describe('serializers/ObjectSerializer', () => { it('should tell it can deserialize an object', () => { - const supportsObject = serializer.canDeserialize(emptyObject); + const supportsObject = serializer.canDeserialize(OBJECTS.EMPTY); expect(supportsObject).toBeTruthy(); }); it('should tell it cannot deserialize others', () => { - const supportsNonObject = serializer.canDeserialize(nonObject); - const supportsSpecificObject = serializer.canDeserialize(specificObject); + const supportsNonObject = serializer.canDeserialize(OBJECTS.NON_OBJECT); + const supportsSpecificObject = serializer.canDeserialize(OBJECTS.SPECIFIC_OBJECT); expect(supportsNonObject).toBeFalsy(); expect(supportsSpecificObject).toBeFalsy(); @@ -56,13 +57,13 @@ describe('serializers/ObjectSerializer', () => { it('should serialize an object', async () => { - const resultEmptyObject = await serializer.serialize(emptyObject); - const resultMixedObject = await serializer.serialize(mixedObject); - const resultNestedObject = await serializer.serialize(nestedObject); + const resultEmptyObject = await serializer.serialize(OBJECTS.EMPTY); + const resultMixedObject = await serializer.serialize(OBJECTS.MIXED); + const resultNestedObject = await serializer.serialize(OBJECTS.NESTED); - expect(resultEmptyObject).toStrictEqual(emptyObject); - expect(resultMixedObject).toStrictEqual(mixedObject); - expect(resultNestedObject).toStrictEqual(nestedObject); + expect(resultEmptyObject).toStrictEqual(OBJECTS.EMPTY); + expect(resultMixedObject).toStrictEqual(OBJECTS.MIXED); + expect(resultNestedObject).toStrictEqual(OBJECTS.NESTED); }); }); @@ -70,13 +71,13 @@ describe('serializers/ObjectSerializer', () => { it('should deserialize an object', async () => { - const resultEmptyObject = await serializer.deserialize(emptyObject); - const resultMixedObject = await serializer.deserialize(mixedObject); - const resultNestedObject = await serializer.deserialize(nestedObject); + const resultEmptyObject = await serializer.deserialize(OBJECTS.EMPTY); + const resultMixedObject = await serializer.deserialize(OBJECTS.MIXED); + const resultNestedObject = await serializer.deserialize(OBJECTS.NESTED); - expect(resultEmptyObject).toStrictEqual(emptyObject); - expect(resultMixedObject).toStrictEqual(mixedObject); - expect(resultNestedObject).toStrictEqual(nestedObject); + expect(resultEmptyObject).toStrictEqual(OBJECTS.EMPTY); + expect(resultMixedObject).toStrictEqual(OBJECTS.MIXED); + expect(resultNestedObject).toStrictEqual(OBJECTS.NESTED); }); }); }); diff --git a/packages/serialization/test/serializers/PrimitiveSerializer.spec.ts b/packages/serialization/test/serializers/PrimitiveSerializer.spec.ts index 07ae4b14..b6e6a800 100644 --- a/packages/serialization/test/serializers/PrimitiveSerializer.spec.ts +++ b/packages/serialization/test/serializers/PrimitiveSerializer.spec.ts @@ -3,9 +3,7 @@ import { describe, expect, it } from 'vitest'; import PrimitiveSerializer from '../../src/serializers/PrimitiveSerializer'; -import { - numberValue, boolValue, stringValue, nullValue, undefinedValue, objectValue -} from '../_fixtures/serializers/PrimitiveSerializer.fixture'; +import { PRIMITIVES } from './fixtures'; const serializer = new PrimitiveSerializer(); @@ -15,11 +13,11 @@ describe('serializers/PrimitiveSerializer', () => { it('should tell it can serialize a primitive', () => { - const supportsNumber = serializer.canSerialize(numberValue); - const supportsBool = serializer.canSerialize(boolValue); - const supportsString = serializer.canSerialize(stringValue); - const supportsNull = serializer.canSerialize(nullValue); - const supportsUndefined = serializer.canSerialize(undefinedValue); + const supportsNumber = serializer.canSerialize(PRIMITIVES.NUMBER); + const supportsBool = serializer.canSerialize(PRIMITIVES.BOOL); + const supportsString = serializer.canSerialize(PRIMITIVES.STRING); + const supportsNull = serializer.canSerialize(PRIMITIVES.NULL); + const supportsUndefined = serializer.canSerialize(PRIMITIVES.UNDEFINED); expect(supportsNumber).toBeTruthy(); expect(supportsBool).toBeTruthy(); @@ -30,7 +28,7 @@ describe('serializers/PrimitiveSerializer', () => it('should tell it cannot serialize others', () => { - const supportsObject = serializer.canSerialize(objectValue); + const supportsObject = serializer.canSerialize(PRIMITIVES.OBJECT); expect(supportsObject).toBeFalsy(); }); @@ -40,11 +38,11 @@ describe('serializers/PrimitiveSerializer', () => { it('should tell it can deserialize a primitive', () => { - const supportsNumber = serializer.canSerialize(numberValue); - const supportsBool = serializer.canSerialize(boolValue); - const supportsString = serializer.canSerialize(stringValue); - const supportsNull = serializer.canSerialize(nullValue); - const supportsUndefined = serializer.canSerialize(undefinedValue); + const supportsNumber = serializer.canSerialize(PRIMITIVES.NUMBER); + const supportsBool = serializer.canSerialize(PRIMITIVES.BOOL); + const supportsString = serializer.canSerialize(PRIMITIVES.STRING); + const supportsNull = serializer.canSerialize(PRIMITIVES.NULL); + const supportsUndefined = serializer.canSerialize(PRIMITIVES.UNDEFINED); expect(supportsNumber).toBeTruthy(); expect(supportsBool).toBeTruthy(); @@ -55,7 +53,7 @@ describe('serializers/PrimitiveSerializer', () => it('should tell it cannot deserialize others', () => { - const supportsObject = serializer.canSerialize(objectValue); + const supportsObject = serializer.canSerialize(PRIMITIVES.OBJECT); expect(supportsObject).toBeFalsy(); }); @@ -65,17 +63,17 @@ describe('serializers/PrimitiveSerializer', () => { it('should serialize a primitive', async () => { - const resultNumber = await serializer.serialize(numberValue); - const resultBool = await serializer.serialize(boolValue); - const resultString = await serializer.serialize(stringValue); - const resultNull = await serializer.serialize(nullValue); - const resultUndefined = await serializer.serialize(undefinedValue); - - expect(resultNumber).toEqual(numberValue); - expect(resultBool).toEqual(boolValue); - expect(resultString).toEqual(stringValue); - expect(resultNull).toEqual(nullValue); - expect(resultUndefined).toEqual(undefinedValue); + const resultNumber = await serializer.serialize(PRIMITIVES.NUMBER); + const resultBool = await serializer.serialize(PRIMITIVES.BOOL); + const resultString = await serializer.serialize(PRIMITIVES.STRING); + const resultNull = await serializer.serialize(PRIMITIVES.NULL); + const resultUndefined = await serializer.serialize(PRIMITIVES.UNDEFINED); + + expect(resultNumber).toEqual(PRIMITIVES.NUMBER); + expect(resultBool).toEqual(PRIMITIVES.BOOL); + expect(resultString).toEqual(PRIMITIVES.STRING); + expect(resultNull).toEqual(PRIMITIVES.NULL); + expect(resultUndefined).toEqual(PRIMITIVES.UNDEFINED); }); }); @@ -83,17 +81,17 @@ describe('serializers/PrimitiveSerializer', () => { it('should deserialize a primitive', async () => { - const resultNumber = await serializer.deserialize(numberValue); - const resultBool = await serializer.deserialize(boolValue); - const resultString = await serializer.deserialize(stringValue); - const resultNull = await serializer.deserialize(nullValue); - const resultUndefined = await serializer.deserialize(undefinedValue); - - expect(resultNumber).toEqual(numberValue); - expect(resultBool).toEqual(boolValue); - expect(resultString).toEqual(stringValue); - expect(resultNull).toEqual(nullValue); - expect(resultUndefined).toEqual(undefinedValue); + const resultNumber = await serializer.deserialize(PRIMITIVES.NUMBER); + const resultBool = await serializer.deserialize(PRIMITIVES.BOOL); + const resultString = await serializer.deserialize(PRIMITIVES.STRING); + const resultNull = await serializer.deserialize(PRIMITIVES.NULL); + const resultUndefined = await serializer.deserialize(PRIMITIVES.UNDEFINED); + + expect(resultNumber).toEqual(PRIMITIVES.NUMBER); + expect(resultBool).toEqual(PRIMITIVES.BOOL); + expect(resultString).toEqual(PRIMITIVES.STRING); + expect(resultNull).toEqual(PRIMITIVES.NULL); + expect(resultUndefined).toEqual(PRIMITIVES.UNDEFINED); }); }); }); diff --git a/packages/serialization/test/serializers/RegExpSerializer.spec.ts b/packages/serialization/test/serializers/RegExpSerializer.spec.ts index f2fd6e5e..4c70ff37 100644 --- a/packages/serialization/test/serializers/RegExpSerializer.spec.ts +++ b/packages/serialization/test/serializers/RegExpSerializer.spec.ts @@ -4,13 +4,7 @@ import { describe, expect, it } from 'vitest'; import RegExpSerializer from '../../src/serializers/RegExpSerializer'; import InvalidRegExp from '../../src/serializers/errors/InvalidRegExp'; -import -{ - validRegExp, - serializedValidRegExp, - nonObject, nonRegExp, notSerialized, invalidName, invalidRegExpSource, invalidRegExpFlag, - serializedInvalidRegExpSource, serializedInvalidRegExpFlag -} from '../_fixtures/serializers/RegExpSerializer.fixture'; +import { REGULAR_EXPRESSIONS } from './fixtures'; const serializer = new RegExpSerializer(); @@ -20,15 +14,15 @@ describe('serializers/RegExpSerializer', () => { it('should tell it can serialize an regular expression', () => { - const supportsRegExp = serializer.canSerialize(validRegExp); + const supportsRegExp = serializer.canSerialize(REGULAR_EXPRESSIONS.VALID); expect(supportsRegExp).toBeTruthy(); }); it('should tell it cannot serialize others', () => { - const supportsNonObject = serializer.canSerialize(nonObject); - const supportsNonRegExp = serializer.canSerialize(nonRegExp); + const supportsNonObject = serializer.canSerialize(REGULAR_EXPRESSIONS.NON_OBJECT); + const supportsNonRegExp = serializer.canSerialize(REGULAR_EXPRESSIONS.NON_REGEXP); expect(supportsNonObject).toBeFalsy(); expect(supportsNonRegExp).toBeFalsy(); @@ -39,18 +33,18 @@ describe('serializers/RegExpSerializer', () => { it('should tell it can deserialize an regular expression', () => { - const supportsRegExp = serializer.canDeserialize(serializedValidRegExp); + const supportsRegExp = serializer.canDeserialize(REGULAR_EXPRESSIONS.VALID_SERIALIZED); expect(supportsRegExp).toBeTruthy(); }); it('should tell it cannot deserialize others', () => { - const supportsNonObject = serializer.canDeserialize(nonObject); - const supportsNotSerialized = serializer.canDeserialize(notSerialized); - const supportsInvalidName = serializer.canDeserialize(invalidName); - const supportsInvalidSourceString = serializer.canDeserialize(invalidRegExpSource); - const supportsInvalidFlagString = serializer.canDeserialize(invalidRegExpFlag); + const supportsNonObject = serializer.canDeserialize(REGULAR_EXPRESSIONS.NON_OBJECT); + const supportsNotSerialized = serializer.canDeserialize(REGULAR_EXPRESSIONS.NOT_SERIALIZED); + const supportsInvalidName = serializer.canDeserialize(REGULAR_EXPRESSIONS.INVALID_NAME); + const supportsInvalidSourceString = serializer.canDeserialize(REGULAR_EXPRESSIONS.INVALID_SOURCE); + const supportsInvalidFlagString = serializer.canDeserialize(REGULAR_EXPRESSIONS.INVALID_FLAG); expect(supportsNonObject).toBeFalsy(); expect(supportsNotSerialized).toBeFalsy(); @@ -64,9 +58,9 @@ describe('serializers/RegExpSerializer', () => { it('should serialize a regular expression', async () => { - const resultValidRegExp = await serializer.serialize(validRegExp); + const resultValidRegExp = await serializer.serialize(REGULAR_EXPRESSIONS.VALID); - expect(resultValidRegExp).toStrictEqual(serializedValidRegExp); + expect(resultValidRegExp).toStrictEqual(REGULAR_EXPRESSIONS.VALID_SERIALIZED); }); }); @@ -74,21 +68,21 @@ describe('serializers/RegExpSerializer', () => { it('should deserialize a regular expression', async () => { - const resultValidRegExp = await serializer.deserialize(serializedValidRegExp); + const resultValidRegExp = await serializer.deserialize(REGULAR_EXPRESSIONS.VALID_SERIALIZED); - expect(resultValidRegExp).toStrictEqual(validRegExp); + expect(resultValidRegExp).toStrictEqual(REGULAR_EXPRESSIONS.VALID); }); it('should not deserialize a regular expression with invalid source', async () => { - const deserialize = async () => serializer.deserialize(serializedInvalidRegExpSource); + const deserialize = async () => serializer.deserialize(REGULAR_EXPRESSIONS.INVALID_SOURCE_SERIALIZED); expect(deserialize).rejects.toStrictEqual(new InvalidRegExp('sel/\\', 'g')); }); it('should not deserialize a regular expression with invalid flag', async () => { - const deserialize = async () => serializer.deserialize(serializedInvalidRegExpFlag); + const deserialize = async () => serializer.deserialize(REGULAR_EXPRESSIONS.INVALID_FLAG_SERIALIZED); expect(deserialize).rejects.toStrictEqual(new InvalidRegExp('w+', true)); }); diff --git a/packages/serialization/test/serializers/SetSerializer.spec.ts b/packages/serialization/test/serializers/SetSerializer.spec.ts index 80c1aa27..c70f4eaa 100644 --- a/packages/serialization/test/serializers/SetSerializer.spec.ts +++ b/packages/serialization/test/serializers/SetSerializer.spec.ts @@ -1,17 +1,17 @@ import { describe, expect, it } from 'vitest'; +import Serializer from '../../src/Serializer'; +import PrimitiveSerializer from '../../src/serializers/PrimitiveSerializer'; import SetSerializer from '../../src/serializers/SetSerializer'; -import { - parent, - emptySet, mixedSet, nestedSet, - serializedEmptySet, serializedMixedSet, serializedNestedSet, - nonObject, nonSet, notSerialized, invalidName, invalidValues -} from '../_fixtures/serializers/SetSerializer.fixture'; +import { SETS } from './fixtures'; const serializer = new SetSerializer(); -serializer.parent = parent; +const parent = new Serializer(); + +parent.addSerializer(serializer); +parent.addSerializer(new PrimitiveSerializer()); describe('serializers/SetSerializer', () => { @@ -19,15 +19,15 @@ describe('serializers/SetSerializer', () => { it('should tell it can serialize a set', () => { - const supportsSet = serializer.canSerialize(emptySet); + const supportsSet = serializer.canSerialize(SETS.EMPTY); expect(supportsSet).toBeTruthy(); }); it('should tell it cannot serialize others', () => { - const supportsNonObject = serializer.canSerialize(nonObject); - const supportsNonSet = serializer.canSerialize(nonSet); + const supportsNonObject = serializer.canSerialize(SETS.NON_OBJECT); + const supportsNonSet = serializer.canSerialize(SETS.NON_SET); expect(supportsNonObject).toBeFalsy(); expect(supportsNonSet).toBeFalsy(); @@ -38,17 +38,17 @@ describe('serializers/SetSerializer', () => { it('should tell it can deserialize a set', () => { - const supportsSet = serializer.canDeserialize(serializedEmptySet); + const supportsSet = serializer.canDeserialize(SETS.EMPTY_SERIALIZED); expect(supportsSet).toBeTruthy(); }); it('should tell it cannot deserialize others', () => { - const supportsNonObject = serializer.canDeserialize(nonObject); - const supportsNotSerialized = serializer.canDeserialize(notSerialized); - const supportsInvalidName = serializer.canDeserialize(invalidName); - const supportsInvalidValues = serializer.canDeserialize(invalidValues); + const supportsNonObject = serializer.canDeserialize(SETS.NON_OBJECT); + const supportsNotSerialized = serializer.canDeserialize(SETS.NOT_SERIALIZED); + const supportsInvalidName = serializer.canDeserialize(SETS.INVALID_NAME); + const supportsInvalidValues = serializer.canDeserialize(SETS.INVALID_VALUES); expect(supportsNonObject).toBeFalsy(); expect(supportsNotSerialized).toBeFalsy(); @@ -61,13 +61,13 @@ describe('serializers/SetSerializer', () => { it('should serialize a set', async () => { - const resultEmptySet = await serializer.serialize(emptySet); - const resultMixedSet = await serializer.serialize(mixedSet); - const resultNestedSet = await serializer.serialize(nestedSet); + const resultEmptySet = await serializer.serialize(SETS.EMPTY); + const resultMixedSet = await serializer.serialize(SETS.MIXED); + const resultNestedSet = await serializer.serialize(SETS.NESTED); - expect(resultEmptySet).toStrictEqual(serializedEmptySet); - expect(resultMixedSet).toStrictEqual(serializedMixedSet); - expect(resultNestedSet).toStrictEqual(serializedNestedSet); + expect(resultEmptySet).toStrictEqual(SETS.EMPTY_SERIALIZED); + expect(resultMixedSet).toStrictEqual(SETS.MIXED_SERIALIZED); + expect(resultNestedSet).toStrictEqual(SETS.NESTED_SERIALIZED); }); }); @@ -75,13 +75,13 @@ describe('serializers/SetSerializer', () => { it('should deserialize a set', async () => { - const resultEmptySet = await serializer.deserialize(serializedEmptySet); - const resultMixedSet = await serializer.deserialize(serializedMixedSet); - const resultNestedSet = await serializer.deserialize(serializedNestedSet); + const resultEmptySet = await serializer.deserialize(SETS.EMPTY_SERIALIZED); + const resultMixedSet = await serializer.deserialize(SETS.MIXED_SERIALIZED); + const resultNestedSet = await serializer.deserialize(SETS.NESTED_SERIALIZED); - expect(resultEmptySet).toStrictEqual(emptySet); - expect(resultMixedSet).toStrictEqual(mixedSet); - expect(resultNestedSet).toStrictEqual(nestedSet); + expect(resultEmptySet).toStrictEqual(SETS.EMPTY); + expect(resultMixedSet).toStrictEqual(SETS.MIXED); + expect(resultNestedSet).toStrictEqual(SETS.NESTED); }); }); }); diff --git a/packages/serialization/test/serializers/TypedArraySerializer.spec.ts b/packages/serialization/test/serializers/TypedArraySerializer.spec.ts index 70fd1156..39d62309 100644 --- a/packages/serialization/test/serializers/TypedArraySerializer.spec.ts +++ b/packages/serialization/test/serializers/TypedArraySerializer.spec.ts @@ -3,11 +3,7 @@ import { describe, expect, it } from 'vitest'; import TypedArraySerializer from '../../src/serializers/TypedArraySerializer'; -import { - viewUint16, viewInt8, viewBigInt64, - serializedViewUint16, serializedViewInt8, serializedViewBigInt64, - nonObject, plainObject, notSerialized, invalidName, invalidType, invalidBytes -} from '../_fixtures/serializers/TypedArraySerializer.fixture'; +import { TYPED_ARRAYS } from './fixtures'; const serializer = new TypedArraySerializer(); @@ -17,9 +13,9 @@ describe('serializers/TypedArraySerializer', () => { it('should tell it can serialize an array buffer', () => { - const supportsUint16 = serializer.canSerialize(viewUint16); - const supportsInt8 = serializer.canSerialize(viewInt8); - const supportsBigInt64 = serializer.canSerialize(viewBigInt64); + const supportsUint16 = serializer.canSerialize(TYPED_ARRAYS.UINT16); + const supportsInt8 = serializer.canSerialize(TYPED_ARRAYS.INT8); + const supportsBigInt64 = serializer.canSerialize(TYPED_ARRAYS.BIG_INT64); expect(supportsUint16).toBeTruthy(); expect(supportsInt8).toBeTruthy(); @@ -28,8 +24,8 @@ describe('serializers/TypedArraySerializer', () => it('should tell it cannot serialize others', () => { - const supportsPlainObject = serializer.canSerialize(plainObject); - const supportsNonObject = serializer.canSerialize(nonObject); + const supportsPlainObject = serializer.canSerialize(TYPED_ARRAYS.PLAIN_OBJECT); + const supportsNonObject = serializer.canSerialize(TYPED_ARRAYS.NON_OBJECT); expect(supportsPlainObject).toBeFalsy(); expect(supportsNonObject).toBeFalsy(); @@ -40,9 +36,9 @@ describe('serializers/TypedArraySerializer', () => { it('should tell it can deserialize an array buffer', () => { - const supportsUint16 = serializer.canDeserialize(serializedViewUint16); - const supportsInt8 = serializer.canDeserialize(serializedViewInt8); - const supportsBigInt64 = serializer.canDeserialize(serializedViewBigInt64); + const supportsUint16 = serializer.canDeserialize(TYPED_ARRAYS.UINT16_SERIALIZED); + const supportsInt8 = serializer.canDeserialize(TYPED_ARRAYS.INT8_SERIALIZED); + const supportsBigInt64 = serializer.canDeserialize(TYPED_ARRAYS.BIG_INT64_SERIALIZED); expect(supportsUint16).toBeTruthy(); expect(supportsInt8).toBeTruthy(); @@ -51,11 +47,11 @@ describe('serializers/TypedArraySerializer', () => it('should tell it cannot deserialize others', () => { - const supportsNonObject = serializer.canDeserialize(nonObject); - const supportsNotSerialized = serializer.canDeserialize(notSerialized); - const supportsInvalidName = serializer.canDeserialize(invalidName); - const supportsInvalidType = serializer.canDeserialize(invalidType); - const supportsInvalidBytes = serializer.canDeserialize(invalidBytes); + const supportsNonObject = serializer.canDeserialize(TYPED_ARRAYS.NON_OBJECT); + const supportsNotSerialized = serializer.canDeserialize(TYPED_ARRAYS.NOT_SERIALIZED); + const supportsInvalidName = serializer.canDeserialize(TYPED_ARRAYS.INVALID_NAME); + const supportsInvalidType = serializer.canDeserialize(TYPED_ARRAYS.INVALID_TYPE); + const supportsInvalidBytes = serializer.canDeserialize(TYPED_ARRAYS.INVALID_BYTES); expect(supportsNonObject).toBeFalsy(); expect(supportsNotSerialized).toBeFalsy(); @@ -69,13 +65,13 @@ describe('serializers/TypedArraySerializer', () => { it('should serialize an array buffer', async () => { - const resultUint16 = await serializer.serialize(viewUint16); - const resultInt8 = await serializer.serialize(viewInt8); - const resultBigInt64 = await serializer.serialize(viewBigInt64); + const resultUint16 = await serializer.serialize(TYPED_ARRAYS.UINT16); + const resultInt8 = await serializer.serialize(TYPED_ARRAYS.INT8); + const resultBigInt64 = await serializer.serialize(TYPED_ARRAYS.BIG_INT64); - expect(resultUint16).toStrictEqual(serializedViewUint16); - expect(resultInt8).toStrictEqual(serializedViewInt8); - expect(resultBigInt64).toStrictEqual(serializedViewBigInt64); + expect(resultUint16).toStrictEqual(TYPED_ARRAYS.UINT16_SERIALIZED); + expect(resultInt8).toStrictEqual(TYPED_ARRAYS.INT8_SERIALIZED); + expect(resultBigInt64).toStrictEqual(TYPED_ARRAYS.BIG_INT64_SERIALIZED); }); }); @@ -83,13 +79,13 @@ describe('serializers/TypedArraySerializer', () => { it('should deserialize an array buffer', async () => { - const resultUint16 = await serializer.deserialize(serializedViewUint16); - const resultInt8 = await serializer.deserialize(serializedViewInt8); - const resultBigInt64 = await serializer.deserialize(serializedViewBigInt64); + const resultUint16 = await serializer.deserialize(TYPED_ARRAYS.UINT16_SERIALIZED); + const resultInt8 = await serializer.deserialize(TYPED_ARRAYS.INT8_SERIALIZED); + const resultBigInt64 = await serializer.deserialize(TYPED_ARRAYS.BIG_INT64_SERIALIZED); - expect(resultUint16).toStrictEqual(viewUint16); - expect(resultInt8).toStrictEqual(viewInt8); - expect(resultBigInt64).toStrictEqual(viewBigInt64); + expect(resultUint16).toStrictEqual(TYPED_ARRAYS.UINT16); + expect(resultInt8).toStrictEqual(TYPED_ARRAYS.INT8); + expect(resultBigInt64).toStrictEqual(TYPED_ARRAYS.BIG_INT64); }); }); }); diff --git a/packages/serialization/test/serializers/UrlSerializer.spec.ts b/packages/serialization/test/serializers/UrlSerializer.spec.ts index e4b0e614..a399ae89 100644 --- a/packages/serialization/test/serializers/UrlSerializer.spec.ts +++ b/packages/serialization/test/serializers/UrlSerializer.spec.ts @@ -4,12 +4,7 @@ import { describe, expect, it } from 'vitest'; import UrlSerializer from '../../src/serializers/UrlSerializer'; import InvalidUrlString from '../../src/serializers/errors/InvalidUrlString'; -import -{ - validUrl, - serializedValidUrl, - nonObject, nonUrl, notSerialized, invalidName, invalidUrlValue, invalidUrlString -} from '../_fixtures/serializers/UrlSerializer.fixture'; +import { URLS } from './fixtures'; const serializer = new UrlSerializer(); @@ -19,15 +14,15 @@ describe('serializers/UrlSerializer', () => { it('should tell it can serialize an url', () => { - const supportsUrl = serializer.canSerialize(validUrl); + const supportsUrl = serializer.canSerialize(URLS.VALID); expect(supportsUrl).toBeTruthy(); }); it('should tell it cannot serialize others', () => { - const supportsNonObject = serializer.canSerialize(nonObject); - const supportsNonUrl = serializer.canSerialize(nonUrl); + const supportsNonObject = serializer.canSerialize(URLS.NON_OBJECT); + const supportsNonUrl = serializer.canSerialize(URLS.NON_URL); expect(supportsNonObject).toBeFalsy(); expect(supportsNonUrl).toBeFalsy(); @@ -38,17 +33,17 @@ describe('serializers/UrlSerializer', () => { it('should tell it can deserialize an url', () => { - const supportsUrl = serializer.canDeserialize(serializedValidUrl); + const supportsUrl = serializer.canDeserialize(URLS.VALID_SERIALIZED); expect(supportsUrl).toBeTruthy(); }); it('should tell it cannot deserialize others', () => { - const supportsNonObject = serializer.canDeserialize(nonObject); - const supportsNotSerialized = serializer.canDeserialize(notSerialized); - const supportsInvalidName = serializer.canDeserialize(invalidName); - const supportsInvalidUrlValue = serializer.canDeserialize(invalidUrlValue); + const supportsNonObject = serializer.canDeserialize(URLS.NON_OBJECT); + const supportsNotSerialized = serializer.canDeserialize(URLS.NOT_SERIALIZED); + const supportsInvalidName = serializer.canDeserialize(URLS.INVALID_NAME); + const supportsInvalidUrlValue = serializer.canDeserialize(URLS.INVALID_URL_VALUE); expect(supportsNonObject).toBeFalsy(); expect(supportsNotSerialized).toBeFalsy(); @@ -61,9 +56,9 @@ describe('serializers/UrlSerializer', () => { it('should serialize a url', async () => { - const resultValidUrl = await serializer.serialize(validUrl); + const resultValidUrl = await serializer.serialize(URLS.VALID); - expect(resultValidUrl).toStrictEqual(serializedValidUrl); + expect(resultValidUrl).toStrictEqual(URLS.VALID_SERIALIZED); }); }); @@ -71,14 +66,14 @@ describe('serializers/UrlSerializer', () => { it('should deserialize an url', async () => { - const resultValidUrl = await serializer.deserialize(serializedValidUrl); + const resultValidUrl = await serializer.deserialize(URLS.VALID_SERIALIZED); - expect(resultValidUrl).toStrictEqual(validUrl); + expect(resultValidUrl).toStrictEqual(URLS.VALID); }); it('should not deserialize an url with an invalid url string', async () => { - const deserialize = async () => serializer.deserialize(invalidUrlString); + const deserialize = async () => serializer.deserialize(URLS.INVALID_URL_STRING); expect(deserialize).rejects.toStrictEqual(new InvalidUrlString('example')); }); diff --git a/packages/serialization/test/serializers/fixtures/arrays.fixture.ts b/packages/serialization/test/serializers/fixtures/arrays.fixture.ts new file mode 100644 index 00000000..ba297d0e --- /dev/null +++ b/packages/serialization/test/serializers/fixtures/arrays.fixture.ts @@ -0,0 +1,16 @@ + +const emptyArray: unknown[] = []; +const mixedArray: unknown[] = ['a', 1, true]; +const nestedArray: unknown[] = ['b', 2, ['c', false], true]; + +const nonObject = 42; +const nonArray = new Map(); + +export const ARRAYS = +{ + EMPTY: emptyArray, + MIXED: mixedArray, + NESTED: nestedArray, + NON_OBJECT: nonObject, + NON_ARRAY: nonArray, +}; diff --git a/packages/serialization/test/_fixtures/serializers/BigIntSerializer.fixture.ts b/packages/serialization/test/serializers/fixtures/bigIntegers.fixture.ts similarity index 65% rename from packages/serialization/test/_fixtures/serializers/BigIntSerializer.fixture.ts rename to packages/serialization/test/serializers/fixtures/bigIntegers.fixture.ts index fb2b737d..0786d835 100644 --- a/packages/serialization/test/_fixtures/serializers/BigIntSerializer.fixture.ts +++ b/packages/serialization/test/serializers/fixtures/bigIntegers.fixture.ts @@ -10,9 +10,14 @@ const invalidName = { serialized: true, name: 'Map', value: '7124811545485115646 const invalidBigIntValue = { serialized: true, name: 'BigInt', value: true }; const invalidBigIntString = { serialized: true, name: 'BigInt', value: '1.3' }; -export +export const BIG_INTEGERS = { - validBigInt, - serializedValidBigInt, - nonObject, nonBigInt, notSerialized, invalidName, invalidBigIntValue, invalidBigIntString + VALID: validBigInt, + VALID_SERIALIZED: serializedValidBigInt, + NON_OBJECT: nonObject, + NON_BIGINT: nonBigInt, + NOT_SERIALIZED: notSerialized, + INVALID_NAME: invalidName, + INVALID_BIGINT_VALUE: invalidBigIntValue, + INVALID_BIGINT_STRING: invalidBigIntString }; diff --git a/packages/serialization/test/serializers/fixtures/classResolver.fixture.ts b/packages/serialization/test/serializers/fixtures/classResolver.fixture.ts new file mode 100644 index 00000000..96fe0fc5 --- /dev/null +++ b/packages/serialization/test/serializers/fixtures/classResolver.fixture.ts @@ -0,0 +1,27 @@ + +import ClassResolver from '../../../src/interfaces/ClassResolver'; + +import { CLASSES } from './classes.fixture'; + +class MockClassResolver implements ClassResolver +{ + resolveKey(clazz: Function): string | undefined + { + return clazz.name; + } + + resolveClass(key: string): Function | undefined + { + switch (key) + { + case 'Data': return CLASSES.Data; + case 'Constructed': return CLASSES.Constructed; + case 'Nested': return CLASSES.Nested; + case 'PrivateFieldClass': return CLASSES.PrivateFieldClass; + } + + return undefined; + } +} + +export const classResolver = new MockClassResolver(); diff --git a/packages/serialization/test/serializers/fixtures/classes.fixture.ts b/packages/serialization/test/serializers/fixtures/classes.fixture.ts new file mode 100644 index 00000000..6dce9069 --- /dev/null +++ b/packages/serialization/test/serializers/fixtures/classes.fixture.ts @@ -0,0 +1,103 @@ + +class Data +{ + a?: number; + b?: boolean; +} + +class Constructed +{ + #a: number; + #b: boolean; + #c?: string; + + constructor(a: number, b: boolean) + { + this.#a = a; + this.#b = b; + } + + get a() { return this.#a; } + + get b() { return this.#b; } + + get c() { return this.#c; } + + set c(c) { this.#c = c; } +} + +class Nested +{ + name: string; + #constructed: Constructed; + + constructor(name: string, constructed: Constructed) + { + this.name = name; + this.#constructed = constructed; + } + + get constructed() { return this.#constructed; } +} + +class PrivateFieldClass +{ + #a: number; + #b: boolean; + #c?: string; + + constructor(a: number, b: boolean, c?: string) + { + this.#a = a; + this.#b = b; + this.#c = c; + } + + get d() { return this.#a; } +} + +const dataClass = new Data(); +dataClass.a = 1; +dataClass.b = true; + +const constructedClass = new Constructed(1, true); +constructedClass.c = 'hello'; + +const nestedClass = new Nested('hello', constructedClass); +const privateClass = new PrivateFieldClass(1, true); + +const serializedDataClass = { serialized: true, name: 'class', key: 'Data', args: {}, fields: { a: 1, b: true } }; +const serializedConstructedClass = { serialized: true, name: 'class', key: 'Constructed', args: { '0': 1, '1': true }, fields: { c: 'hello' } }; +const serializedNestedClass = { serialized: true, name: 'class', key: 'Nested', args: { '0': 'hello', '1': { serialized: true, name: 'class', key: 'Constructed', args: { '0': 1, '1': true }, fields: { c: 'hello' } } }, fields: {} }; +const serializedPrivateClass = { serialized: true, name: 'class', key: 'PrivateFieldClass', args: { '0': undefined, '1': undefined, '2': undefined }, fields: { } }; + +const serializedInvalidClass = { serialized: true, name: 'class', key: 'Invalid', args: {}, fields: {} }; +const serializedUnserializableClass = { serialized: true, name: 'class', key: 'Infinity', args: {}, fields: {} }; + +const nonObject = 42; +const nonClassObject = new Object(); +const notSerialized = { name: 'class', key: 'Unserialized', args: {}, fields: {} }; +const invalidKey = { serialized: true, name: 'class', key: 123, args: {}, fields: {} }; +const invalidArgs = { serialized: true, name: 'class', key: 'Invalid', args: [], fields: {} }; +const invalidFields = { serialized: true, name: 'class', key: 'Invalid', args: {}, fields: [] }; + +export const CLASSES = +{ + Data, Constructed, Nested, PrivateFieldClass, + DATA_INSTANCE: dataClass, + DATA_SERIALIZED: serializedDataClass, + CONSTRUCTED_INSTANCE: constructedClass, + CONSTRUCTED_SERIALIZED: serializedConstructedClass, + NESTED_INSTANCE: nestedClass, + NESTED_SERIALIZED: serializedNestedClass, + PRIVATE_INSTANCE: privateClass, + PRIVATE_SERIALIZED: serializedPrivateClass, + INVALID_SERIALIZED: serializedInvalidClass, + UNSERIALIZABLE: serializedUnserializableClass, + NON_OBJECT: nonObject, + NON_CLASS_OBJECT: nonClassObject, + NOT_SERIALIZED: notSerialized, + INVALID_KEY: invalidKey, + INVALID_ARGS: invalidArgs, + INVALID_FIELDS: invalidFields +}; diff --git a/packages/serialization/test/_fixtures/serializers/DateSerializer.fixture.ts b/packages/serialization/test/serializers/fixtures/dates.fixture.ts similarity index 64% rename from packages/serialization/test/_fixtures/serializers/DateSerializer.fixture.ts rename to packages/serialization/test/serializers/fixtures/dates.fixture.ts index ac0ab67e..a42c37a0 100644 --- a/packages/serialization/test/_fixtures/serializers/DateSerializer.fixture.ts +++ b/packages/serialization/test/serializers/fixtures/dates.fixture.ts @@ -12,8 +12,14 @@ const invalidName = { serialized: true, name: 'Map', value: DATE_TIME_STRING }; const invalidDateValue = { serialized: true, name: 'Date', value: true }; const invalidDateString = { serialized: true, name: 'Date', value: 'hello' }; -export { - fixedDate, - serializedFixedDate, - nonObject, nonDate, notSerialized, invalidName, invalidDateValue, invalidDateString +export const DATES = +{ + FIXED: fixedDate, + FIXED_SERIALIZED: serializedFixedDate, + NON_OBJECT: nonObject, + NON_DATE: nonDate, + NOT_SERIALIZED: notSerialized, + INVALID_NAME: invalidName, + INVALID_DATE_VALUE: invalidDateValue, + INVALID_DATE_STRING: invalidDateString }; diff --git a/packages/serialization/test/_fixtures/serializers/ErrorSerializer.fixture.ts b/packages/serialization/test/serializers/fixtures/errors.fixture.ts similarity index 75% rename from packages/serialization/test/_fixtures/serializers/ErrorSerializer.fixture.ts rename to packages/serialization/test/serializers/fixtures/errors.fixture.ts index 641f3794..315a96f6 100644 --- a/packages/serialization/test/_fixtures/serializers/ErrorSerializer.fixture.ts +++ b/packages/serialization/test/serializers/fixtures/errors.fixture.ts @@ -32,9 +32,25 @@ const notSerialized = { name: 'Error', type: 'Error', stack: undefined, message: const invalidName = { serialized: true, name: 'CustomError', type: 'Error', stack: undefined, message: 'error', cause: undefined }; const invalidType = { serialized: true, name: 'Error', type: 'CustomError', stack: undefined, message: 'error', cause: undefined }; -export { - plainError, evalError, rangeError, referenceError, syntaxError, typeError, uriError, - serializedPlainError, serializedEvalError, serializedRangeError, serializedReferenceError, serializedSyntaxError, serializedTypeError, serializedURIError, - customError, otherClass, - notSerialized, invalidName, invalidType +export const ERRORS = +{ + PLAIN: plainError, + PLAIN_SERIALIZED: serializedPlainError, + EVAL: evalError, + EVAL_SERIALIZED: serializedEvalError, + RANGE: rangeError, + RANGE_SERIALIZED: serializedRangeError, + REFERENCE: referenceError, + REFERENCE_SERIALIZED: serializedReferenceError, + SYNTAX: syntaxError, + SYNTAX_SERIALIZED: serializedSyntaxError, + TYPE: typeError, + TYPE_SERIALIZED: serializedTypeError, + URI: uriError, + URI_SERIALIZED: serializedURIError, + CUSTOM: customError, + OTHER_CLASS: otherClass, + NOT_SERIALIZED: notSerialized, + INVALID_NAME: invalidName, + INVALID_TYPE: invalidType }; diff --git a/packages/serialization/test/serializers/fixtures/index.ts b/packages/serialization/test/serializers/fixtures/index.ts new file mode 100644 index 00000000..31f53065 --- /dev/null +++ b/packages/serialization/test/serializers/fixtures/index.ts @@ -0,0 +1,14 @@ + +export * from './arrays.fixture'; +export * from './bigIntegers.fixture'; +export * from './classes.fixture'; +export * from './classResolver.fixture'; +export * from './dates.fixture'; +export * from './errors.fixture'; +export * from './maps.fixture'; +export * from './objects.fixture'; +export * from './primitives.fixture'; +export * from './regularExpressions.fixture'; +export * from './sets.fixture'; +export * from './typedArrays.fixture'; +export * from './urls.fixture'; diff --git a/packages/serialization/test/_fixtures/serializers/MapSerializer.fixture.ts b/packages/serialization/test/serializers/fixtures/maps.fixture.ts similarity index 65% rename from packages/serialization/test/_fixtures/serializers/MapSerializer.fixture.ts rename to packages/serialization/test/serializers/fixtures/maps.fixture.ts index 5e603f6d..f2342a3d 100644 --- a/packages/serialization/test/_fixtures/serializers/MapSerializer.fixture.ts +++ b/packages/serialization/test/serializers/fixtures/maps.fixture.ts @@ -1,12 +1,4 @@ -import Serializer from '../../../src/Serializer'; -import PrimitiveSerializer from '../../../src/serializers/PrimitiveSerializer'; -import MapSerializer from '../../../src/serializers/MapSerializer'; - -const parent = new Serializer(); -parent.addSerializer(new MapSerializer()); -parent.addSerializer(new PrimitiveSerializer()); - const emptyMap: Map = new Map(); const mixedMap: Map = new Map().set('a', 1).set('b', true); const nestedMap: Map = new Map().set('b', 'hello').set('c', new Map().set('d', false)); @@ -22,9 +14,18 @@ const invalidName = { serialized: true, name: 'Set', entries: [], values: [] }; const invalidKeys = { serialized: true, name: 'Map', entries: {}, values: [] }; const invalidValues = { serialized: true, name: 'Map', entries: [], values: {} }; -export { - parent, - emptyMap, mixedMap, nestedMap, - serializedEmptyMap, serializedMixedMap, serializedNestedMap, - nonObject, nonMap, notSerialized, invalidName, invalidKeys, invalidValues +export const MAPS = +{ + EMPTY: emptyMap, + EMPTY_SERIALIZED: serializedEmptyMap, + MIXED: mixedMap, + MIXED_SERIALIZED: serializedMixedMap, + NESTED: nestedMap, + NESTED_SERIALIZED: serializedNestedMap, + NON_OBJECT: nonObject, + NON_MAP: nonMap, + NOT_SERIALIZED: notSerialized, + INVALID_NAME: invalidName, + INVALID_KEYS: invalidKeys, + INVALID_VALUES: invalidValues }; diff --git a/packages/serialization/test/serializers/fixtures/objects.fixture.ts b/packages/serialization/test/serializers/fixtures/objects.fixture.ts new file mode 100644 index 00000000..3e41ea41 --- /dev/null +++ b/packages/serialization/test/serializers/fixtures/objects.fixture.ts @@ -0,0 +1,16 @@ + +const emptyObject = {}; +const mixedObject = { a: 1, b: true, c: 'hello' }; +const nestedObject = { a: 1, b: true, c: { d: false, e: true } }; + +const nonObject = 42; +const specificObject = new Map(); + +export const OBJECTS = +{ + EMPTY: emptyObject, + MIXED: mixedObject, + NESTED: nestedObject, + NON_OBJECT: nonObject, + SPECIFIC_OBJECT: specificObject +}; diff --git a/packages/serialization/test/serializers/fixtures/primitives.fixture.ts b/packages/serialization/test/serializers/fixtures/primitives.fixture.ts new file mode 100644 index 00000000..103425c0 --- /dev/null +++ b/packages/serialization/test/serializers/fixtures/primitives.fixture.ts @@ -0,0 +1,17 @@ + +const numberValue = 1; +const boolValue = true; +const stringValue = 'hello'; +const nullValue = null; +const undefinedValue = undefined; +const objectValue = {}; + +export const PRIMITIVES = +{ + NUMBER: numberValue, + BOOL: boolValue, + STRING: stringValue, + NULL: nullValue, + UNDEFINED: undefinedValue, + OBJECT: objectValue +}; diff --git a/packages/serialization/test/_fixtures/serializers/RegExpSerializer.fixture.ts b/packages/serialization/test/serializers/fixtures/regularExpressions.fixture.ts similarity index 63% rename from packages/serialization/test/_fixtures/serializers/RegExpSerializer.fixture.ts rename to packages/serialization/test/serializers/fixtures/regularExpressions.fixture.ts index b7101663..1db86ab1 100644 --- a/packages/serialization/test/_fixtures/serializers/RegExpSerializer.fixture.ts +++ b/packages/serialization/test/serializers/fixtures/regularExpressions.fixture.ts @@ -12,10 +12,16 @@ const invalidRegExpFlag = { serialized: true, name: 'RegExp', source: 'w+', flag const serializedInvalidRegExpSource = { serialized: true, name: 'RegExp', source: 'sel/\\', flags: 'g' }; const serializedInvalidRegExpFlag = { serialized: true, name: 'RegExp', source: 'w+', flags: 'true' }; -export +export const REGULAR_EXPRESSIONS = { - validRegExp, - serializedValidRegExp, - nonObject, nonRegExp, notSerialized, invalidName, invalidRegExpSource, invalidRegExpFlag, - serializedInvalidRegExpSource, serializedInvalidRegExpFlag + VALID: validRegExp, + VALID_SERIALIZED: serializedValidRegExp, + NON_OBJECT: nonObject, + NON_REGEXP: nonRegExp, + NOT_SERIALIZED: notSerialized, + INVALID_NAME: invalidName, + INVALID_SOURCE: invalidRegExpSource, + INVALID_FLAG: invalidRegExpFlag, + INVALID_SOURCE_SERIALIZED: serializedInvalidRegExpSource, + INVALID_FLAG_SERIALIZED: serializedInvalidRegExpFlag }; diff --git a/packages/serialization/test/_fixtures/serializers/SetSerializer.fixture.ts b/packages/serialization/test/serializers/fixtures/sets.fixture.ts similarity index 58% rename from packages/serialization/test/_fixtures/serializers/SetSerializer.fixture.ts rename to packages/serialization/test/serializers/fixtures/sets.fixture.ts index 94bc83ad..a49d5000 100644 --- a/packages/serialization/test/_fixtures/serializers/SetSerializer.fixture.ts +++ b/packages/serialization/test/serializers/fixtures/sets.fixture.ts @@ -1,12 +1,4 @@ -import Serializer from '../../../src/Serializer'; -import PrimitiveSerializer from '../../../src/serializers/PrimitiveSerializer'; -import SetSerializer from '../../../src/serializers/SetSerializer'; - -const parent = new Serializer(); -parent.addSerializer(new SetSerializer()); -parent.addSerializer(new PrimitiveSerializer()); - const emptySet: Set = new Set(); const mixedSet: Set = new Set().add(1).add(true); const nestedSet: Set = new Set().add('hello').add(new Set().add(false)); @@ -21,9 +13,17 @@ const notSerialized = { name: 'Set', bytes: [] }; const invalidName = { serialized: true, name: 'Map', values: [] }; const invalidValues = { serialized: true, name: 'Set', values: {} }; -export { - parent, - emptySet, mixedSet, nestedSet, - serializedEmptySet, serializedMixedSet, serializedNestedSet, - nonObject, nonSet, notSerialized, invalidName, invalidValues +export const SETS = +{ + EMPTY: emptySet, + EMPTY_SERIALIZED: serializedEmptySet, + MIXED: mixedSet, + MIXED_SERIALIZED: serializedMixedSet, + NESTED: nestedSet, + NESTED_SERIALIZED: serializedNestedSet, + NON_OBJECT: nonObject, + NON_SET: nonSet, + NOT_SERIALIZED: notSerialized, + INVALID_NAME: invalidName, + INVALID_VALUES: invalidValues }; diff --git a/packages/serialization/test/_fixtures/serializers/TypedArraySerializer.fixture.ts b/packages/serialization/test/serializers/fixtures/typedArrays.fixture.ts similarity index 81% rename from packages/serialization/test/_fixtures/serializers/TypedArraySerializer.fixture.ts rename to packages/serialization/test/serializers/fixtures/typedArrays.fixture.ts index d9f1b521..3e9de339 100644 --- a/packages/serialization/test/_fixtures/serializers/TypedArraySerializer.fixture.ts +++ b/packages/serialization/test/serializers/fixtures/typedArrays.fixture.ts @@ -53,8 +53,18 @@ const invalidName = { serialized: true, name: 'OtherBuffer', type: 'Uint16Array' const invalidType = { serialized: true, name: 'TypedArray', type: 'Int42Array', bytes: [] }; const invalidBytes = { serialized: true, name: 'TypedArray', type: 'Uint16Array', bytes: {} }; -export { - viewUint16, viewInt8, viewBigInt64, - serializedViewUint16, serializedViewInt8, serializedViewBigInt64, - nonObject, plainObject, notSerialized, invalidName, invalidType, invalidBytes +export const TYPED_ARRAYS = +{ + UINT16: viewUint16, + UINT16_SERIALIZED: serializedViewUint16, + INT8: viewInt8, + INT8_SERIALIZED: serializedViewInt8, + BIG_INT64: viewBigInt64, + BIG_INT64_SERIALIZED: serializedViewBigInt64, + NON_OBJECT: nonObject, + PLAIN_OBJECT: plainObject, + NOT_SERIALIZED: notSerialized, + INVALID_NAME: invalidName, + INVALID_TYPE: invalidType, + INVALID_BYTES: invalidBytes }; diff --git a/packages/serialization/test/_fixtures/serializers/UrlSerializer.fixture.ts b/packages/serialization/test/serializers/fixtures/urls.fixture.ts similarity index 65% rename from packages/serialization/test/_fixtures/serializers/UrlSerializer.fixture.ts rename to packages/serialization/test/serializers/fixtures/urls.fixture.ts index f85cd8da..4ead8994 100644 --- a/packages/serialization/test/_fixtures/serializers/UrlSerializer.fixture.ts +++ b/packages/serialization/test/serializers/fixtures/urls.fixture.ts @@ -10,9 +10,14 @@ const invalidName = { serialized: true, name: 'Map', value: '2021-01-01T00:00:00 const invalidUrlValue = { serialized: true, name: 'Url', value: true }; const invalidUrlString = { serialized: true, name: 'Url', value: 'example' }; -export +export const URLS = { - validUrl, - serializedValidUrl, - nonObject, nonUrl, notSerialized, invalidName, invalidUrlValue, invalidUrlString + VALID: validUrl, + VALID_SERIALIZED: serializedValidUrl, + NON_OBJECT: nonObject, + NON_URL: nonUrl, + NOT_SERIALIZED: notSerialized, + INVALID_NAME: invalidName, + INVALID_URL_VALUE: invalidUrlValue, + INVALID_URL_STRING: invalidUrlString }; diff --git a/packages/services/src/worker/ExecutionClassResolver.ts b/packages/services/src/worker/ExecutionClassResolver.ts index 8c460241..121ac6cd 100644 --- a/packages/services/src/worker/ExecutionClassResolver.ts +++ b/packages/services/src/worker/ExecutionClassResolver.ts @@ -1,5 +1,5 @@ -import { ClassResolver, ClassNotFound } from '@jitar/serialization'; +import { ClassResolver } from '@jitar/serialization'; import type { ExecutionManager } from '@jitar/execution'; export default class ExecutionClassResolver implements ClassResolver @@ -11,27 +11,17 @@ export default class ExecutionClassResolver implements ClassResolver this.#executionManager = executionManager; } - resolveKey(clazz: Function): string + resolveKey(clazz: Function): string | undefined { const model = this.#executionManager.getClassByImplementation(clazz); - if (model === undefined) - { - throw new ClassNotFound(clazz.name); - } - - return model.fqn; + return model?.fqn; } - resolveClass(key: string): Function + resolveClass(key: string): Function | undefined { const model = this.#executionManager.getClass(key); - if (model === undefined) - { - throw new ClassNotFound(key); - } - - return model.implementation; + return model?.implementation; } }