test: migrate schema.spec.ts from TypeDoc to Easy AST

test/features.spec.ts

@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2018 StApps
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the Free
+ * Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+import {isLightweightClass, isLightweightEnum, isUnionType} from '@openstapps/core-tools/lib/easy-ast/ast-util';
+import {LightweightAliasDefinition} from '@openstapps/core-tools/lib/easy-ast/types/lightweight-alias-definition';
+import {LightweightProjectWithIndex} from '@openstapps/core-tools/lib/easy-ast/types/lightweight-project';
+import {LightweightType} from '@openstapps/core-tools/lib/easy-ast/types/lightweight-type';
+import {LightweightClassDefinition} from '@openstapps/core-tools/src/easy-ast/types/lightweight-class-definition';
+import {LightweightDefinition} from '@openstapps/core-tools/src/easy-ast/types/lightweight-definition';
+import {LightweightProperty} from '@openstapps/core-tools/src/easy-ast/types/lightweight-property';
+import {expect} from 'chai';
+import {assign, chain, clone, flatMap, isNil, reduce, reject, some} from 'lodash';
+
+process.on('unhandledRejection', (err) => {
+  throw err;
+});
+
+describe('Features', () => {
+  let project: LightweightProjectWithIndex;
+  let thingNames: string[];
+  let things: LightweightClassDefinition[];
+  let thingsWithoutReferences: LightweightClassDefinition[];
+
+  before(function () {
+    this.timeout(15000);
+    this.slow(10000);
+
+    project = new LightweightProjectWithIndex('src');
+
+    const thingsReflection = project.definitions['SCIndexableThings'] as LightweightAliasDefinition;
+    expect(isLightweightEnum(thingsReflection)).to.be.true;
+    expect(isUnionType(thingsReflection.type!)).to.be.true;
+
+    thingsReflection.type!.specificationTypes!.push({
+      flags: 524_288,
+      referenceName: 'SCDiff',
+    });
+
+    // tslint:disable-next-line:no-unused-expression
+    expect(thingsReflection.type?.specificationTypes?.every(it => typeof it.referenceName !== 'undefined')).to.be.true;
+    thingNames = thingsReflection.type?.specificationTypes?.map(type => type.referenceName!) ?? [];
+    things = thingNames
+      .map(it => project.definitions[it])
+      .filter(isLightweightClass);
+    thingsWithoutReferences = thingNames
+      .map(it => project.definitions[`${it}WithoutReferences`])
+      .filter(isLightweightClass);
+  });
+
+  const inheritedProperties = function (classLike: LightweightClassDefinition):
+    Record<string, LightweightProperty> | undefined {
+    return reduce(
+      [...(classLike.implementedDefinitions ?? []), ...(classLike.extendedDefinitions ?? [])],
+      (obj, extension) => {
+        const object = project.definitions[extension.referenceName ?? ''];
+
+        return assign(obj, isLightweightClass(object)
+          ? inheritedProperties(object)
+          : obj);
+      },
+      clone(classLike.properties)
+    );
+  };
+
+  it('should have an origin', () => {
+    for (const thing of things) {
+      expect(inheritedProperties(thing)?.['origin']).not.to.be.undefined;
+    }
+  });
+
+  it('should not have duplicate names', () => {
+    reduce(project.files, (fileResult, file) =>
+      reduce(file, (definitionResult, definition: LightweightDefinition) => {
+        expect(definitionResult[definition.name]).to.be.undefined;
+        definitionResult[definition.name] = true; // something that's not undefined
+
+        return definitionResult;
+      }, fileResult), {} as Record<string, true>);
+  });
+
+  it('should not have properties referencing SCThing', () => {
+    const allPropertyReferenceNames: (property: LightweightProperty) => string[] = property => reject([
+      property.type.referenceName!,
+      ...flatMap(property.properties, allPropertyReferenceNames),
+    ], isNil);
+
+    const typeHasSCThingReferences: (type?: LightweightType) => boolean = type => type?.referenceName
+      ? hasSCThingReferences(project.definitions[type.referenceName])
+      : some(type?.specificationTypes, typeHasSCThingReferences);
+
+    const hasSCThingReferences: (definition?: LightweightDefinition) => boolean = definition =>
+      isLightweightClass(definition)
+        ? chain(inheritedProperties(definition))
+          .flatMap(it => flatMap(it.properties, allPropertyReferenceNames))
+          .map(it => project.definitions[it] as LightweightDefinition)
+          .some(it => it.name === 'SCThing' || hasSCThingReferences(it))
+          .value()
+        : definition ? typeHasSCThingReferences(definition.type) : false;
+
+    for (const thing of things) {
+      expect(hasSCThingReferences(thing)).to.be.false;
+    }
+  });
+
+  function extendsSCThing(definition?: LightweightDefinition): boolean {
+    return isLightweightClass(definition)
+      ? chain([
+        ...(definition as LightweightClassDefinition).extendedDefinitions ?? [],
+        ...(definition as LightweightClassDefinition).implementedDefinitions ?? [],
+      ])
+        .map(it => it.referenceName)
+        .reject(isNil)
+        .some(it => it === 'SCThing' || extendsSCThing(project.definitions[it!]))
+        .value()
+      : false;
+  }
+
+  it('should extend SCThing if it is an SCThing', () => {
+    for (const thing of things) {
+      expect(extendsSCThing(thing)).to.be.true;
+    }
+  });
+
+  it('should not extend SCThing if it is an SCThingWithoutReferences', () => {
+    for (const thingWithoutReferences of thingsWithoutReferences) {
+      expect(extendsSCThing(thingWithoutReferences)).to.be.false;
+    }
+  });
+});