#296: refactored serialization tests

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;

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<unknown>
     {
-        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);
     }
 }

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', () =>
 {

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);
     });
 });