@trapi/metadata 0.1.1 → 0.1.5

package/test/unit/cache.spec.ts

@@ -1,48 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import {CacheDriver} from "../../src";
-import {getWritableDirPath} from "../../src/config";
-import * as fs from "fs";
-
-describe('src/cache/index.ts', function () {
-    it('should save cache', () => {
-        const cache = new CacheDriver(getWritableDirPath());
-
-        const cachePath : string = cache.save({
-            controllers: [],
-            referenceTypes: {},
-            sourceFilesSize: 0
-        });
-
-        expect(cachePath).toBeDefined();
-        expect(fs.existsSync(cachePath)).toBeTruthy();
-
-        const output = cache.get(0);
-
-        expect(output).toBeDefined();
-        expect(output).toHaveProperty('controllers');
-        expect(output).toHaveProperty('referenceTypes');
-        expect(output).toHaveProperty('sourceFilesSize');
-    });
-
-    it('should not save & get cache', () => {
-        const cacheNone = new CacheDriver(false);
-
-        const cachePath : string = cacheNone.save({
-            controllers: [],
-            referenceTypes: {},
-            sourceFilesSize: 0
-        });
-
-        expect(cachePath).toBeUndefined();
-
-        const output = cacheNone.get(0);
-
-        expect(output).toBeUndefined();
-    });
-});

package/test/unit/decorator/mapper/index.spec.ts

@@ -1,83 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import {DecoratorMapper, Decorator, RepresentationManager} from "../../../../src";
-
-describe('src/decorator/mapper/index.ts', () => {
-    const decorators : Decorator.Data[] = [
-        {text: 'foo', arguments: [], typeArguments: []},
-        {text: 'SwaggerTags', arguments: [], typeArguments: []}
-    ];
-
-    const decoratorsWithResponseExample : Decorator.Data[] = [
-        ...decorators,
-        {
-            text: 'ResponseExample',
-            arguments: [],
-            typeArguments: []
-        }
-    ];
-
-    const mapper = new DecoratorMapper({
-        internal: false
-    });
-
-    it('should not match', () => {
-        expect(mapper.match('RESPONSE_EXAMPLE', [])).toBeUndefined();
-        expect(mapper.match('RESPONSE_EXAMPLE', decorators)).toBeUndefined();
-        expect(mapper.match('RESPONSE_EXAMPLE', decoratorsWithResponseExample)).toBeUndefined();
-        expect(mapper.match('SWAGGER_TAGS', decorators)).toBeUndefined();
-    })
-
-    it('should work with internal configurations', () => {
-        mapper.setConfig({
-            internal: true
-        });
-
-        expect(mapper.match('SWAGGER_TAGS', decorators)).toBeDefined();
-        expect(mapper.match('RESPONSE_EXAMPLE', decorators)).toBeUndefined();
-        expect(mapper.match('RESPONSE_EXAMPLE', decoratorsWithResponseExample)).toBeDefined();
-    });
-
-    it('should work with library configurations', () => {
-        mapper.setConfig({internal: false, library: {'typescript-rest': {RESPONSE_EXAMPLE: false}}});
-        expect(mapper.match('RESPONSE_EXAMPLE', decoratorsWithResponseExample)).toBeUndefined();
-        mapper.setConfig({internal: false, library: {'typescript-rest': false}});
-        expect(mapper.match('RESPONSE_EXAMPLE', decoratorsWithResponseExample)).toBeUndefined();
-        mapper.setConfig({internal: false, library: {'typescript-rest': []}});
-        expect(mapper.match('RESPONSE_EXAMPLE', decoratorsWithResponseExample)).toBeUndefined();
-        mapper.setConfig({internal: false, library: {'typescript-rest': 'SWAGGER_TAGS'}});
-        expect(mapper.match('RESPONSE_EXAMPLE', decoratorsWithResponseExample)).toBeUndefined();
-
-        const data = [...decorators, {text: 'Example', arguments: [], typeArguments: []}];
-
-        mapper.setConfig({internal: false, library: {'typescript-rest': {RESPONSE_EXAMPLE: true}}});
-        expect(mapper.match('RESPONSE_EXAMPLE', data)).toBeDefined();
-        mapper.setConfig({internal: false, library: {'typescript-rest': true}});
-        expect(mapper.match('RESPONSE_EXAMPLE', data)).toBeDefined();
-        mapper.setConfig({internal: false, library: {'typescript-rest': ['RESPONSE_EXAMPLE']}});
-        expect(mapper.match('RESPONSE_EXAMPLE', data)).toBeDefined();
-    })
-
-    it('should match', () => {
-        mapper.setConfig({
-            map: {
-                SWAGGER_TAGS: {
-                    id: 'SwaggerTags',
-                    properties: {
-                        DEFAULT: {}
-                    }
-                }
-            }
-        });
-
-        const match = mapper.match('SWAGGER_TAGS', decorators);
-
-        expect(match).toBeDefined();
-        expect(match).toBeInstanceOf(RepresentationManager);
-    })
-});

package/test/unit/decorator/representation/index.spec.ts

@@ -1,102 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import {SyntaxKind, NodeFlags, ArrayLiteralExpression, NodeArray, Expression} from 'typescript';
-import {Decorator, RepresentationManager} from "../../../../src";
-import {mergeObjectArguments} from "../../../../src/decorator/representation/property/utils";
-
-describe('src/decorator/representation/index.ts', () => {
-    const swaggerTagsRepresentation : Decorator.Representation<'SWAGGER_TAGS'> = {
-        id: 'SwaggerTags',
-        properties: {
-            DEFAULT: {
-                srcArgumentType: "argument",
-                type: "array",
-                srcAmount: -1,
-                srcStrategy: "merge"
-            }
-        }
-    };
-
-    const swaggerTagsDecorators : Decorator.Data[] = [
-        {text: 'SwaggerTags', arguments: [['auth', 'admin']], typeArguments: []},
-        {text: 'SwaggerTags', arguments: [['auth'], ['admin']], typeArguments: []},
-        {text: 'SwaggerTags', arguments: [], typeArguments: []},
-    ]
-
-    const swaggerTagsRepresentationManager = new RepresentationManager<'SWAGGER_TAGS'>(swaggerTagsRepresentation, swaggerTagsDecorators);
-
-    // ----------------------------------------------------------------------------------
-
-    const responseExampleRepresentation : Decorator.Representation<'RESPONSE_EXAMPLE'> = {
-        id: 'ResponseExample',
-        properties: {
-            TYPE: {
-                isType: true,
-                srcArgumentType: "typeArgument",
-                srcStrategy: "none"
-            },
-            PAYLOAD: {
-                srcArgumentType: "argument",
-                srcAmount: -1,
-                srcStrategy: (items: unknown[] | unknown[][]) => {
-                    // return items.reduce((accumulator, value) => accumulator.concat(value), []);
-                    return mergeObjectArguments(items);
-                }
-            }
-        }
-    };
-
-    const responseExampleDecorators : Decorator.Data[] = [
-        {text: 'ResponseExample', arguments: [{foo: 'bar'}], typeArguments: [{foo: 'bar'}]},
-        {text: 'ResponseExample', arguments: [{foo: 'bar'}, {bar: 'baz'}], typeArguments: []}
-    ]
-
-    const responseExampleRepresentationManager = new RepresentationManager<'RESPONSE_EXAMPLE'>(responseExampleRepresentation, responseExampleDecorators);
-
-    it('should get property value', () => {
-        let value = swaggerTagsRepresentationManager.getPropertyValue('DEFAULT');
-        expect(value).toEqual(['auth', 'admin']);
-
-        value = swaggerTagsRepresentationManager.getPropertyValue('DEFAULT', 1);
-        expect(value).toEqual(['auth', 'admin']);
-
-        let payloadValue = responseExampleRepresentationManager.getPropertyValue('PAYLOAD');
-        expect(payloadValue).toEqual({foo: 'bar'});
-
-        payloadValue = responseExampleRepresentationManager.getPropertyValue('TYPE');
-        expect(payloadValue).toEqual({foo: 'bar'});
-
-        payloadValue = responseExampleRepresentationManager.getPropertyValue('PAYLOAD', 1);
-        expect(payloadValue).toEqual({foo: 'bar', bar: 'baz'});
-    });
-
-    it('should get property value with array literal expression', () => {
-        const arrayLiteralExpression : ArrayLiteralExpression = {
-            kind: SyntaxKind.ArrayLiteralExpression,
-            elements: [
-                {text: 'auth', flags: NodeFlags.None, parent: undefined} as unknown as Expression,
-                {text: 'admin', flags: NodeFlags.None, parent: undefined} as unknown as Expression,
-            ] as unknown as NodeArray<Expression>
-        } as ArrayLiteralExpression;
-
-        const manager = new RepresentationManager<'SWAGGER_TAGS'>(swaggerTagsRepresentation, [
-            {text: 'SwaggerTags', arguments: [arrayLiteralExpression], typeArguments: []}
-        ]);
-
-        const value = manager.getPropertyValue('DEFAULT');
-        expect(value).toEqual(['auth', 'admin']);
-    });
-
-    it('should not get property value', () => {
-        let value = swaggerTagsRepresentationManager.getPropertyValue('DEFAULT', 2);
-        expect(value).toEqual([]);
-
-        value = swaggerTagsRepresentationManager.getPropertyValue('DEFAULT', 3);
-        expect(value).toBeUndefined();
-    })
-});

package/test/unit/decorator/utils/node.spec.ts

@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import {Node, SyntaxKind} from 'typescript';
-import {getNodeDecorators} from "../../../../src";
-
-describe('src/decorator/utils/node.ts', () => {
-    const fakeNode : Record<string, any> = {
-        decorators: [
-            {
-                expression: {
-                    kind: SyntaxKind.CallExpression,
-                    arguments: [
-                        {
-                            kind: SyntaxKind.StringLiteral,
-                            text: 'foo'
-                        },
-                        {
-                            kind: SyntaxKind.NumericLiteral,
-                            text: 0
-                        }
-                    ],
-                    typeArguments: [],
-                    expression: {
-                        text: 'MyText'
-                    }
-                }
-            }
-        ],
-    };
-
-    it('should get node decorators', () => {
-        const decorators = getNodeDecorators(fakeNode as Node);
-
-        expect(decorators).toBeDefined();
-        expect(decorators.length).toEqual(1);
-        expect(decorators[0].arguments.length).toEqual(2);
-        expect(decorators[0].arguments).toEqual(['foo', 0]);
-
-        expect(decorators[0].typeArguments.length).toEqual(0);
-        expect(decorators[0].typeArguments).toEqual([]);
-    })
-});

package/test/unit/library/typescript-rest.spec.ts

@@ -1,342 +0,0 @@
-/*
- * Copyright (c) 2021.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */
-
-import path from "path";
-const jsonata = require('jsonata');
-import {Config, MetadataGenerator, Property, Resolver} from "../../../src";
-
-const config : Config = {
-    entryFile: ['./test/data/library/typescript-rest/api.ts'],
-    cache: {
-        directoryPath: './writable',
-        clearAtRandom: false,
-        enabled: false,
-        fileName: 'metadata.json'
-    },
-    decorator: {
-        internal: true,
-        library: 'typescript-rest'
-    }
-};
-
-const generator = new MetadataGenerator(config, {});
-
-const metadata = generator.generate();
-
-describe('library/typescript-rest', () => {
-    it('should be generated and have top level properties', () => {
-        expect(metadata).toBeDefined();
-        expect(metadata).toHaveProperty('controllers');
-        expect(metadata).toHaveProperty('referenceTypes');
-    });
-
-    describe('check controllers', () => {
-        it('should have elements', () => {
-            expect(metadata.controllers.length).toBeGreaterThan(0);
-        });
-
-        it('should have abstract structure', () => {
-            expect(metadata.controllers[0]).toHaveProperty('consumes');
-            expect(metadata.controllers[0].consumes.length).toEqual(0);
-
-            expect(metadata.controllers[0]).toHaveProperty('location');
-            expect(metadata.controllers[0].location).toEqual("test/data/library/typescript-rest/api.ts");
-
-            expect(metadata.controllers[0]).toHaveProperty('methods');
-            expect(metadata.controllers[0].methods.length).toBeGreaterThan(0);
-
-            expect(metadata.controllers[0]).toHaveProperty('name');
-            expect(metadata.controllers[0].name).toEqual('TestUnionType');
-
-            expect(metadata.controllers[0]).toHaveProperty('path');
-            expect(metadata.controllers[0].path).toEqual('unionTypes');
-
-            expect(metadata.controllers[0]).toHaveProperty('produces');
-            expect(metadata.controllers[0].produces.length).toEqual(0);
-
-            expect(metadata.controllers[0]).toHaveProperty('responses');
-            expect(metadata.controllers[0].responses.length).toEqual(0);
-
-            expect(metadata.controllers[0]).toHaveProperty('tags');
-            expect(metadata.controllers[0].tags.length).toEqual(0);
-        });
-
-        it('should have methods', () => {
-            const method = metadata.controllers[0].methods[0];
-
-            expect(method).toHaveProperty('consumes');
-            expect(method.consumes.length).toEqual(0);
-
-            expect(method).toHaveProperty('deprecated');
-            expect(method.deprecated).toBeFalsy();
-
-            expect(method).toHaveProperty('extensions');
-            expect(method.extensions.length).toEqual(0);
-
-            expect(method).toHaveProperty('hidden');
-            expect(method.hidden).toBeFalsy();
-
-            expect(method).toHaveProperty('method');
-            expect(method.method).toEqual("post");
-
-            expect(method).toHaveProperty('name');
-            expect(method.name).toEqual("post");
-
-            expect(method).toHaveProperty('parameters');
-            expect(method.parameters.length).toBeGreaterThan(0);
-
-            expect(method).toHaveProperty('path');
-            expect(method.path).toEqual("");
-
-            expect(method).toHaveProperty('produces');
-            expect(method.produces.length).toEqual(0);
-
-            expect(method).toHaveProperty('responses');
-            expect(method.responses.length).toEqual(1);
-
-            expect(method).toHaveProperty('tags');
-            expect(method.tags.length).toEqual(0);
-
-            expect(method).toHaveProperty('type');
-            expect(method.type).toHaveProperty('typeName');
-            expect(method.type.typeName).toEqual('string');
-        });
-    })
-
-    describe('check referenceTypes', () => {
-        it('referenceTypes should be defined', () => {
-            expect(metadata.referenceTypes).toHaveProperty('MyTypeWithUnion');
-            expect(metadata.referenceTypes).toHaveProperty('Address');
-            expect(metadata.referenceTypes).toHaveProperty('Person');
-            expect(metadata.referenceTypes).toHaveProperty('TestEnum');
-            expect(metadata.referenceTypes).toHaveProperty('TestNumericEnum');
-            expect(metadata.referenceTypes).toHaveProperty('TestMixedEnum');
-            expect(metadata.referenceTypes).toHaveProperty('TestInterface');
-            // todo: tod object keys seem not to work :(
-            // expect(metadata.referenceTypes).toHaveProperty('Return\.NewResourcePerson');
-            // expect(metadata.referenceTypes).toHaveProperty('Return\.DownloadBinaryData');
-            expect(metadata.referenceTypes).toHaveProperty('MyDataType2');
-            expect(metadata.referenceTypes).toHaveProperty('UUID');
-            expect(metadata.referenceTypes).toHaveProperty('Something');
-            expect(metadata.referenceTypes).toHaveProperty('SimpleHelloType');
-            expect(metadata.referenceTypes).toHaveProperty('PrimitiveClassModel');
-            expect(metadata.referenceTypes).toHaveProperty('PrimitiveInterfaceModel');
-            expect(metadata.referenceTypes).toHaveProperty('ResponseBodystringarray');
-            expect(metadata.referenceTypes).toHaveProperty('NamedEntity');
-        });
-
-        it('referenceType MyTypeWithUnion', () => {
-            let expression = jsonata("MyTypeWithUnion.properties[0]");
-            let value : Property = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.name).toEqual('property');
-            expect(value.required).toBeTruthy();
-            expect(value.type).toBeDefined();
-            expect(value.type.typeName).toEqual('union');
-            expect((value.type as Resolver.UnionType).members).toBeDefined();
-            expect((value.type as Resolver.UnionType).members.length).toEqual(2);
-            expect((value.type as Resolver.UnionType).members[0].typeName).toEqual('enum');
-            expect((value.type as Resolver.UnionType).members[1].typeName).toEqual('enum');
-        })
-
-        it('referenceType Address', () => {
-            let expression = jsonata("Address.properties[0]");
-            let value : Property = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.name).toEqual('street');
-            expect(value.required).toBeTruthy();
-            expect(value.type).toBeDefined();
-            expect(value.type.typeName).toEqual('string');
-        })
-
-        it('referenceType Person', () => {
-            let expression = jsonata("Person.properties[0]");
-            let value : Property = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.name).toEqual('name');
-            expect(value.required).toBeTruthy();
-            expect(value.type).toBeDefined();
-            expect(value.type.typeName).toEqual('string');
-
-            expression = jsonata("Person.properties[1]");
-            value = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.name).toEqual('address');
-            expect(value.required).toBeFalsy();
-            expect(value.type).toBeDefined();
-            expect(value.type.typeName).toEqual('refObject');
-        })
-
-        it('referenceType TestEnum', () => {
-            let expression = jsonata("TestEnum");
-            let value : Resolver.RefEnumType = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.typeName).toEqual('refEnum');
-            expect(value.members).toEqual(["option1", "option2"]);
-            expect(value.memberNames).toEqual(["Option1", "Option2"]);
-            expect(value.deprecated).toBeFalsy();
-        })
-
-        it('referenceType TestNumericEnum', () => {
-            let expression = jsonata("TestNumericEnum");
-            let value : Resolver.RefEnumType = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.typeName).toEqual('refEnum');
-            expect(value.members).toEqual([0, 1]);
-            expect(value.memberNames).toEqual(["Option1", "Option2"]);
-            expect(value.deprecated).toBeFalsy();
-        })
-
-        it('referenceType TestMixedEnum', () => {
-            let expression = jsonata("TestMixedEnum");
-            let value : Resolver.RefEnumType = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.typeName).toEqual('refEnum');
-            expect(value.members).toEqual([0, "option2"]);
-            expect(value.memberNames).toEqual(["Option1", "Option2"]);
-            expect(value.deprecated).toBeFalsy();
-        })
-
-        it('referenceType TestInterface', () => {
-            let expression = jsonata("TestInterface");
-            let value : Resolver.RefObjectType = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.typeName).toEqual('refObject');
-
-            expect(value.properties).toBeDefined();
-            expect(value.properties.length).toEqual(2);
-
-            expect(value.properties[0].name).toEqual("a");
-            expect(value.properties[0].type.typeName).toEqual("string");
-
-            expect(value.properties[1].name).toEqual("b");
-            expect(value.properties[1].type.typeName).toEqual("double");
-        })
-
-        it('referenceType MyDataType2', () => {
-            let expression = jsonata("MyDataType2");
-            let value : Resolver.RefObjectType = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.typeName).toEqual('refObject');
-
-            expect(value.properties).toBeDefined();
-            expect(value.properties.length).toEqual(2);
-
-            expect(value.properties[0].name).toEqual("prop");
-            expect(value.properties[0].type.typeName).toEqual("string");
-
-            expect(value.properties[1].name).toEqual("property1");
-            expect(value.properties[1].type.typeName).toEqual("string");
-        })
-
-        it('referenceType UUID', () => {
-            let expression = jsonata("UUID");
-            let value : Resolver.RefAliasType = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.typeName).toEqual('refAlias');
-            expect(value.refName).toEqual('UUID');
-            expect(value.type.typeName).toEqual('string');
-        })
-
-        it('referenceType Something', () => {
-            let expression = jsonata("Something");
-            let value : Resolver.RefObjectType = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.typeName).toEqual('refObject');
-
-            expect(value.properties).toBeDefined();
-            expect(value.properties.length).toEqual(3);
-
-            expect(value.properties[0].name).toEqual("id");
-            expect(value.properties[0].type.typeName).toEqual("refAlias");
-            expect((value.properties[0].type as Resolver.RefAliasType).refName).toEqual("UUID");
-
-            expect(value.properties[1].name).toEqual("someone");
-            expect(value.properties[1].type.typeName).toEqual("string");
-
-            expect(value.properties[2].name).toEqual("kind");
-            expect(value.properties[2].type.typeName).toEqual("string");
-        })
-
-        it('referenceType SimpleHelloType', () => {
-            let expression = jsonata("SimpleHelloType");
-            let value : Resolver.RefAliasType = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.typeName).toEqual('refAlias');
-
-            expect(value.type.typeName).toEqual('nestedObjectLiteral');
-
-            const typeValue = value.type as Resolver.NestedObjectLiteralType;
-
-            expect(typeValue.properties).toBeDefined();
-            expect(typeValue.properties.length).toEqual(4);
-
-            expect(typeValue.properties[0].name).toEqual("comparePassword");
-            expect(typeValue.properties[0].type.typeName).toEqual("object");
-
-            expect(typeValue.properties[1].name).toEqual("profile");
-            expect(typeValue.properties[1].description).toEqual("Description for profile");
-            expect(typeValue.properties[1].type.typeName).toEqual("nestedObjectLiteral");
-
-            expect(typeValue.properties[2].name).toEqual("arrayOfSomething");
-            expect(typeValue.properties[2].type.typeName).toEqual("array");
-
-            const arrayElementTypeValue = (typeValue.properties[2].type as Resolver.ArrayType).elementType;
-
-            expect(arrayElementTypeValue.typeName).toEqual('refObject');
-            expect((arrayElementTypeValue as Resolver.RefObjectType).refName).toEqual('Something');
-
-            expect(typeValue.properties[3].name).toEqual("greeting");
-            expect(typeValue.properties[3].type.typeName).toEqual("string");
-        })
-
-        it('referenceType PrimitiveClassModel & PrimitiveInterfaceModel', () => {
-            const values : Resolver.RefObjectType[] = [
-                jsonata("PrimitiveClassModel").evaluate(metadata.referenceTypes),
-                jsonata("PrimitiveInterfaceModel").evaluate(metadata.referenceTypes)
-            ];
-
-            values.map(value => {
-                expect(value.typeName).toEqual('refObject');
-                expect(value.properties).toBeDefined();
-                expect(value.properties.length).toEqual(4);
-
-                expect(value.properties[0].name).toEqual("int");
-                expect(value.properties[0].description).toEqual("An integer");
-                expect(value.properties[0].type.typeName).toEqual("integer");
-
-                expect(value.properties[1].name).toEqual("long");
-                expect(value.properties[1].type.typeName).toEqual("long");
-
-                expect(value.properties[2].name).toEqual("float");
-                expect(value.properties[2].type.typeName).toEqual("float");
-
-                expect(value.properties[3].name).toEqual("double");
-                expect(value.properties[3].type.typeName).toEqual("double");
-            });
-        });
-
-        it('referenceType ResponseBodystringarray', () => {
-            let expression = jsonata("ResponseBodystringarray");
-            let value: Resolver.RefObjectType = expression.evaluate(metadata.referenceTypes);
-
-            expect(value.properties).toBeDefined();
-            expect(value.properties[0].name).toEqual('data');
-            expect(value.properties[0].required).toBeTruthy();
-            expect(value.properties[0].type.typeName).toEqual('array');
-            expect((value.properties[0].type as Resolver.ArrayType).elementType.typeName).toEqual('string');
-        });
-
-        it('referenceType NamedEntity', () => {
-            let expression = jsonata("NamedEntity");
-            let value: Resolver.RefObjectType = expression.evaluate(metadata.referenceTypes);
-
-            expect(value).toBeDefined();
-            // todo: better testing.
-        });
-    })
-})