fix: filter tags override inherited type tags

test/aggregations.spec.ts

@@ -13,59 +13,38 @@
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
 import {Logger} from '@openstapps/logger';
-import {slow, suite, test, timeout} from '@testdeck/mocha';
+import {readdirSync, statSync} from 'fs';
+import path from 'path';
 import {MapAggTest} from './mapping-model/MapAggTest';
-import {aggArrayTest} from './mapping-model/aggregations/src/agg-array';
-import {aggNestedTest} from './mapping-model/aggregations/src/agg-nested';
-import {aggGlobalTest} from './mapping-model/aggregations/src/agg-global';
-import {aggGlobalNestedTest} from './mapping-model/aggregations/src/agg-global-nested';
-import {aggInheritedTest} from './mapping-model/aggregations/src/agg-inherited';
-import {aggInheritedGlobalTest} from './mapping-model/aggregations/src/agg-inherited-global';
-import {aggInheritedOverwrittenTest} from './mapping-model/aggregations/src/agg-inherited-overwritten';
+import {MapAggTestOptions} from './mapping-model/MapAggTestOptions';
 
-process.on('unhandledRejection', (error: unknown) => {
-  if (error instanceof Error) {
-    void Logger.error('UNHANDLED REJECTION', error.stack);
-  }
-  process.exit(1);
-});
+describe('ES Aggregation Gen', async () => {
+  const magAppInstance = new MapAggTest('aggregations');
 
-const magAppInstance = new MapAggTest('aggregations');
+  /**
+   * Expand a path to a list of all files deeply contained in it
+   */
+  function expandPathToFilesSync(sourcePath: string, accept: (fileName: string) => boolean): string[] {
+    const fullPath = path.resolve(sourcePath);
+    const directory = statSync(fullPath);
 
-@suite(timeout(20000), slow(10000))
-export class AggregationsSpec {
-  @test
-  async 'Aggregation tag should propagate on arrays'() {
-    magAppInstance.testInterfaceAgainstPath(aggArrayTest);
+    return directory.isDirectory()
+      ? ([] as string[]).concat(...readdirSync(fullPath).map(fragment =>
+        expandPathToFilesSync(path.resolve(sourcePath, fragment), accept),
+      ))
+      : [fullPath].filter(accept);
   }
 
-  @test
-  async 'Should work on nested properties'() {
-    magAppInstance.testInterfaceAgainstPath(aggNestedTest);
-  }
+  for (const file of expandPathToFilesSync('./test/mapping-model/aggregations/', file => file.endsWith('agg-test.ts'))) {
+    try {
+      const test = (await import(file))['testConfig'] as MapAggTestOptions;
 
-  @test
-  async 'Global option should work'() {
-    magAppInstance.testInterfaceAgainstPath(aggGlobalTest);
+      it(test.testName, function () {
+        magAppInstance.testInterfaceAgainstPath(test);
+      });
+    } catch (error) {
+      await Logger.error('UNHANDLED REJECTION', error.stack);
+      process.exit(1);
+    }
   }
-
-  @test
-  async 'Global aggregations when nested'() {
-    magAppInstance.testInterfaceAgainstPath(aggGlobalNestedTest);
-  }
-
-  @test
-  async 'Inherited aggregations should work'() {
-    magAppInstance.testInterfaceAgainstPath(aggInheritedTest);
-  }
-
-  @test
-  async 'Inherited global aggregations should work'() {
-    magAppInstance.testInterfaceAgainstPath(aggInheritedGlobalTest);
-  }
-
-  @test
-  async 'Inherited aggregations should work when overwritten'() {
-    magAppInstance.testInterfaceAgainstPath(aggInheritedOverwrittenTest);
-  }
-}
+}).timeout(20_000).slow(10_000);

test/mapping-model/MapAggTestOptions.ts

@@ -16,6 +16,7 @@
 import {ElasticsearchDynamicTemplate, ElasticsearchValue} from '../../src/types/mapping';
 
 export interface MapAggTestOptions {
+  testName: string;
   name: string;
   agg?: {
     fields?: string[];

test/mapping-model/aggregations/src/agg-array.agg-test.ts

@@ -29,7 +29,8 @@ export interface AggArray {
 }
 type Foo = 'A' | 'B' | 'C';
 
-export const aggArrayTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Aggregation tag should propagate on arrays',
   name: ThingType.AggArray,
   agg: {
     fields: ['array'],

test/mapping-model/aggregations/src/agg-global-nested.agg-test.ts

@@ -30,7 +30,8 @@ export interface AggGlobalNested {
   type: ThingType.AggGlobalNested;
 }
 
-export const aggGlobalNestedTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Global aggregations when nested',
   name: ThingType.AggGlobalNested,
   agg: {
     globals: ['foo'],

test/mapping-model/aggregations/src/agg-global.agg-test.ts

@@ -28,7 +28,8 @@ export interface AggGlobal {
   type: ThingType.AggGlobal;
 }
 
-export const aggGlobalTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Global option should work',
   name: ThingType.AggGlobal,
   agg: {
     globals: ['foo'],

test/mapping-model/aggregations/src/agg-inherited-global.agg-test.ts

@@ -31,7 +31,8 @@ interface Foo {
   bar: string;
 }
 
-export const aggInheritedGlobalTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Inherited global aggregations should work',
   name: ThingType.AggInheritedGlobal,
   agg: {
     globals: ['bar'],

test/mapping-model/aggregations/src/agg-inherited-overwritten.agg-test.ts

@@ -36,7 +36,8 @@ interface Foo {
   bar: string;
 }
 
-export const aggInheritedOverwrittenTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Inherited aggregations should work when overwritten',
   name: ThingType.AggInherited,
   agg: {
     fields: ['bar'],

test/mapping-model/aggregations/src/agg-inherited.agg-test.ts

@@ -31,7 +31,8 @@ interface Foo {
   bar: string;
 }
 
-export const aggInheritedTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Inherited aggregations should work',
   name: ThingType.AggInherited,
   agg: {
     fields: ['bar'],

test/mapping-model/aggregations/src/agg-nested.agg-test.ts

@@ -30,7 +30,8 @@ export interface AggNested {
   type: ThingType.AggNested;
 }
 
-export const aggNestedTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Should work on nested properties',
   name: ThingType.AggNested,
   agg: {
     fields: ['nested.foo'],

test/mapping-model/mappings/src/any-unknown.mapping-test.ts

@@ -27,7 +27,8 @@ export interface AnyUnknown {
   type: ThingType.AnyUnknown
 }
 
-export const anyUnknownTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Any or unknown should create a dynamic field',
   name: ThingType.AnyUnknown,
   map: {
     maps: {

test/mapping-model/mappings/src/date.mapping-test.ts

@@ -36,7 +36,8 @@ export interface DateAndRange {
   type: ThingType.Date
 }
 
-export const dateAndRangeTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Dates and date ranges should have the correct type',
   name: ThingType.Date,
   map: {
     maps: {

test/mapping-model/mappings/src/default-generics.mapping-test.ts

@@ -30,7 +30,8 @@ interface InterfaceWithDefaultGeneric<T = number> {
   bar: T;
 }
 
-export const defaultGenericTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Default generics should fail',
   name: ThingType.DefaultGeneric,
   map: {
     maps: {

test/mapping-model/mappings/src/double-type-conflict.mapping-test.ts

@@ -36,7 +36,8 @@ export interface DoubleTypeConflict {
   type: ThingType.DoubleTypeConflict;
 }
 
-export const doubleTypeConflictTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Double type annotations should cause an error',
   name: ThingType.DoubleTypeConflict,
   map: {
     maps: {

test/mapping-model/mappings/src/enum.mapping-test.ts

@@ -40,7 +40,10 @@ enum Baz {
   f = 'f',
 }
 
-export const enumTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  // Known issue: Enums only use text
+  // https://gitlab.com/openstapps/core-tools/-/issues/46
+  testName: 'Emums should work',
   name: ThingType.Enum,
   map: {
     maps: {

test/mapping-model/mappings/src/filterable-tag.mapping-test.ts

@@ -48,7 +48,8 @@ export interface FilterableTag {
   type: ThingType.FilterableTag
 }
 
-export const filterableTagTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Filterable tag should add raw field to strings',
   name: ThingType.FilterableTag,
   map: {
     maps: {

test/mapping-model/mappings/src/generics.mapping-test.ts

@@ -35,7 +35,8 @@ interface InterfaceWithStringGeneric<T> {
   bar: T;
 }
 
-export const genericTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Generics should work',
   name: ThingType.Generics,
   map: {
     maps: {

test/mapping-model/mappings/src/impossible-union.mapping-test.ts

@@ -26,7 +26,8 @@ export interface ImpossibleUnion {
   type: ThingType.ImpossibleUnion
 }
 
-export const impossibleUnionTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Impossible union should cause an error',
   name: ThingType.ImpossibleUnion,
   map: {
     maps: {

test/mapping-model/mappings/src/incompatible-type.mapping-test.ts

@@ -45,7 +45,8 @@ export interface DoubleTypeConflict {
   type: ThingType.IncompatibleType;
 }
 
-export const incompatibleTypeTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Incompatible type annotations should cause an error and use defaults',
   name: ThingType.IncompatibleType,
   map: {
     maps: {

test/mapping-model/mappings/src/index-signature.mapping-test.ts

@@ -31,7 +31,8 @@ export interface IndexSignature {
   type: ThingType.IndexSignature;
 }
 
-export const indexSignatureTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Index Signatures should work',
   name: ThingType.IndexSignature,
   map: {
     maps: {

test/mapping-model/mappings/src/inferred-type-filterable.mapping-test.ts

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2020 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 {ElasticsearchDataType} from '../../../../src/config/typemap';
+import {MapAggTestOptions} from '../../MapAggTestOptions';
+import {ThingType} from './types';
+
+/**
+ * @date
+ */
+export type SCISO8601Date = string;
+
+/**
+ * @indexable
+ */
+export interface InferredTypeFilterable {
+  /**
+   * @filterable
+   */
+  foo: SCISO8601Date;
+
+  /**
+   * // no tag
+   */
+  bar: SCISO8601Date;
+
+  type: ThingType.InferredTypeFilterable
+}
+
+export const testConfig: MapAggTestOptions = {
+  testName: 'filterable tags should not override inferred tags',
+  name: ThingType.InferredTypeFilterable,
+  map: {
+    maps: {
+      foo: {
+        type: ElasticsearchDataType.date,
+        fields: {
+          raw: {
+            type: ElasticsearchDataType.keyword,
+          }
+        }
+      },
+      bar: {
+        type: ElasticsearchDataType.date,
+      }
+    }
+  }
+};

test/mapping-model/mappings/src/inherit-tags.mapping-test.ts

@@ -36,7 +36,8 @@ export interface InheritTags {
   type: ThingType.InheritTags;
 }
 
-export const inheritTagsTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Inherit tags tag should work',
   name: ThingType.InheritTags,
   map: {
     maps: {

test/mapping-model/mappings/src/inherited-property.mapping-test.ts

@@ -38,7 +38,8 @@ interface Bar {
   baz: number;
 }
 
-export const inheritedPropertyTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Inherited properties should inherit tags',
   name: ThingType.InheritedProperty,
   map: {
     maps: {

test/mapping-model/mappings/src/invalid-tag.mapping-test.ts

@@ -29,7 +29,8 @@ export interface InvalidTag {
   type: ThingType.InvalidTag;
 }
 
-export const invalidTagTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Invalid tags should cause an error',
   name: ThingType.InvalidTag,
   map: {
     maps: {

test/mapping-model/mappings/src/map-explicit-types.mapping-test.ts

@@ -54,7 +54,8 @@ export interface MapExplicitTypes {
   type: ThingType.MapExplicitTypes;
 }
 
-export const mapExplicitTypesTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Explicit type annotations should work',
   name: ThingType.MapExplicitTypes,
   map: {
     maps: {

test/mapping-model/mappings/src/missing-premap.mapping-test.ts

@@ -29,7 +29,8 @@ export interface MissingPremap {
   type: ThingType.MissingPremap;
 }
 
-export const missingPremapTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Missing premap should cause an error',
   name: ThingType.MissingPremap,
   map: {
     maps: {

test/mapping-model/mappings/src/nested.mapping-test.ts

@@ -37,7 +37,8 @@ export interface Nested {
   type: ThingType.Nested;
 }
 
-export const nestedTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Nested properties should work',
   name: ThingType.Nested,
   map: {
     maps: {

test/mapping-model/mappings/src/object-union.mapping-test.ts

@@ -40,7 +40,8 @@ interface Buu {
   intersection: string;
 }
 
-export const objectUnionTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Object union types should work',
   name: ThingType.ObjectUnion,
   map: {
     maps: {

test/mapping-model/mappings/src/paired-tags.mapping-test.ts

@@ -37,7 +37,8 @@ export interface PairedTags {
   type: ThingType.PairedTags;
 }
 
-export const pairedTagsTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Tags should be able to be paired',
   name: ThingType.PairedTags,
   map: {
     maps: {

test/mapping-model/mappings/src/sensible-defaults.mapping-test.ts

@@ -31,7 +31,8 @@ export interface SensibleDefaults {
   type: ThingType.SensibleDefaultType;
 }
 
-export const sensibleDefaultsTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Primitive types should have sensible defaults',
   name: ThingType.SensibleDefaultType,
   map: {
     maps: {

test/mapping-model/mappings/src/sortable-tag.mapping-test.ts

@@ -39,7 +39,8 @@ export interface SortableTag {
   type: ThingType.SortableTag
 }
 
-export const sortableTagTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Sortable tag should work',
   name: ThingType.SortableTag,
   map: {
     maps: {

test/mapping-model/mappings/src/tags-ignore-case.mapping-test.ts

@@ -40,7 +40,8 @@ export interface TagsIgnoreCase {
   type: ThingType.TagsIgnoreCase;
 }
 
-export const tagsIgnoreCaseTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Tags should ignore case',
   name: ThingType.TagsIgnoreCase,
   map: {
     maps: {

test/mapping-model/mappings/src/type-alias.mapping-test.ts

@@ -49,7 +49,8 @@ type ATextAlias = string;
  */
 type AKeywordAlias = string;
 
-export const typeAliasTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Type alias annotations should work',
   name: ThingType.TypeAlias,
   map: {
     maps: {

test/mapping-model/mappings/src/type-overrides.mapping-test.ts

@@ -30,7 +30,8 @@ export interface TypeOverrides {
   type: ThingType.TypeOverrides
 }
 
-export const typeOverridesTest: MapAggTestOptions = {
+export const testConfig: MapAggTestOptions = {
+  testName: 'Premaps should support non-external types',
   name: ThingType.TypeOverrides,
   map: {
     maps: {

test/mapping-model/mappings/src/type-query.mapping-test.disabled.ts

@@ -32,7 +32,9 @@ enum Bar {
   'c'
 }
 
-export const typeQueryTest: MapAggTestOptions = {
+// https://gitlab.com/openstapps/core-tools/-/issues/47
+export const testConfig: MapAggTestOptions = {
+  testName: 'Type queries should work',
   name: ThingType.TypeQuery,
   map: {
     maps: {

test/mapping-model/mappings/src/type-wrapper-inheritance.mapping-test.disabled.ts

@@ -43,7 +43,9 @@ type NumberWrapper = number;
 type StringWrapper = string;
 type StringLiteralWrapper = 'foo';
 
-export const typeWrapperInheritanceTest: MapAggTestOptions = {
+// https://gitlab.com/openstapps/core-tools/-/merge_requests/29
+export const testConfig: MapAggTestOptions = {
+  testName: 'Wrapper types should inherit tags',
   name: ThingType.TypeWrapperInheritance,
   map: {
     maps: {

test/mapping-model/mappings/src/types.ts

@@ -34,6 +34,7 @@ export enum ThingType {
   PairedTags = 'paired tags',
   FilterableTag = 'filterable tag',
   AnyUnknown = 'any unknown',
+  InferredTypeFilterable = 'inferred type filterable',
   Date = 'date',
   InheritTags = 'inherit tags',
   TagsIgnoreCase = 'tags ignore case',

test/mapping.spec.ts

@@ -13,171 +13,38 @@
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
 import {Logger} from '@openstapps/logger';
-import {slow, suite, test, timeout} from '@testdeck/mocha';
+import {readdirSync, statSync} from 'fs';
+import path from 'path';
 import {MapAggTest} from './mapping-model/MapAggTest';
-import {inheritTagsTest} from './mapping-model/mappings/src/inherit-tags';
-import {mapExplicitTypesTest} from './mapping-model/mappings/src/map-explicit-types';
-import {doubleTypeConflictTest} from './mapping-model/mappings/src/double-type-conflict';
-import {incompatibleTypeTest} from './mapping-model/mappings/src/incompatible-type';
-import {sensibleDefaultsTest} from './mapping-model/mappings/src/sensible-defaults';
-import {invalidTagTest} from './mapping-model/mappings/src/invalid-tag';
-import {missingPremapTest} from './mapping-model/mappings/src/missing-premap';
-import {defaultGenericTest} from './mapping-model/mappings/src/default-generics';
-import {genericTest} from './mapping-model/mappings/src/generics';
-import {nestedTest} from './mapping-model/mappings/src/nested';
-import {indexSignatureTest} from './mapping-model/mappings/src/index-signature';
-import {impossibleUnionTest} from './mapping-model/mappings/src/impossible-union';
-import {objectUnionTest} from './mapping-model/mappings/src/object-union';
-import {sortableTagTest} from './mapping-model/mappings/src/sortable-tag';
-import {enumTest} from './mapping-model/mappings/src/enum';
-import {inheritedPropertyTest} from './mapping-model/mappings/src/inherited-property';
-import {pairedTagsTest} from './mapping-model/mappings/src/paired-tags';
-import {filterableTagTest} from './mapping-model/mappings/src/filterable-tag';
-import {anyUnknownTest} from './mapping-model/mappings/src/any-unknown';
-import {tagsIgnoreCaseTest} from './mapping-model/mappings/src/tags-ignore-case';
-import {typeAliasTest} from './mapping-model/mappings/src/type-alias';
-import {dateAndRangeTest} from './mapping-model/mappings/src/date';
-import {typeOverridesTest} from './mapping-model/mappings/src/type-overrides';
+import {MapAggTestOptions} from './mapping-model/MapAggTestOptions';
 
-process.on('unhandledRejection', (error: unknown) => {
-  if (error instanceof Error) {
-    void Logger.error('UNHANDLED REJECTION', error.stack);
-  }
-  process.exit(1);
-});
+describe('ES Mapping Gen', async () => {
+  const magAppInstance = new MapAggTest('mappings');
 
-const magAppInstance = new MapAggTest('mappings');
+  /**
+   * Expand a path to a list of all files deeply contained in it
+   */
+  function expandPathToFilesSync(sourcePath: string, accept: (fileName: string) => boolean): string[] {
+    const fullPath = path.resolve(sourcePath);
+    const directory = statSync(fullPath);
 
-@suite(timeout(20000), slow(10000))
-export class MappingSpec {
-  @test
-  async 'Any or unknown should create a dynamic field'() {
-    magAppInstance.testInterfaceAgainstPath(anyUnknownTest);
+    return directory.isDirectory()
+      ? ([] as string[]).concat(...readdirSync(fullPath).map(fragment =>
+        expandPathToFilesSync(path.resolve(sourcePath, fragment), accept),
+      ))
+      : [fullPath].filter(accept);
   }
 
-  @test
-  async 'Filterable tag should add raw field to strings'() {
-    magAppInstance.testInterfaceAgainstPath(filterableTagTest);
+  for (const file of expandPathToFilesSync('./test/mapping-model/mappings/', file => file.endsWith('mapping-test.ts'))) {
+    try {
+      const test = (await import(file))['testConfig'] as MapAggTestOptions;
+
+      it(test.testName, function () {
+        magAppInstance.testInterfaceAgainstPath(test)
+      })
+    } catch (error) {
+      await Logger.error('UNHANDLED REJECTION', error.stack);
+      process.exit(1);
+    }
   }
-
-  @test
-  async 'Tags should be able to be paired'() {
-    magAppInstance.testInterfaceAgainstPath(pairedTagsTest);
-  }
-
-  @test
-  async 'Inherited properties should inherit tags'() {
-    magAppInstance.testInterfaceAgainstPath(inheritedPropertyTest);
-  }
-
-  @test
-  async 'Tags should ignore case'() {
-    magAppInstance.testInterfaceAgainstPath(tagsIgnoreCaseTest);
-  }
-
-  @test
-  async 'Emums should work'() {
-    // Known issue: Enums only use text
-    // https://gitlab.com/openstapps/core-tools/-/issues/46
-    magAppInstance.testInterfaceAgainstPath(enumTest);
-  }
-
-  @test
-  async 'Sortable tag should work'() {
-    magAppInstance.testInterfaceAgainstPath(sortableTagTest);
-  }
-
-  /*
-  https://gitlab.com/openstapps/core-tools/-/merge_requests/29
-  @test
-  async 'Wrapper types should inherit tags'() {
-    this.testInterfaceAgainstPath(typeWrapperInheritanceTest);
-  }*/
-
-  @test
-  async 'Inherit tags tag should work'() {
-    magAppInstance.testInterfaceAgainstPath(inheritTagsTest);
-  }
-
-  @test
-  async 'Object union types should work'() {
-    magAppInstance.testInterfaceAgainstPath(objectUnionTest);
-  }
-
-  /*
-  https://gitlab.com/openstapps/core-tools/-/issues/47
-  @test
-  async 'Type queries should work'() {
-    magAppInstance.testInterfaceAgainstPath(typeQueryTest);
-  }*/
-
-  @test
-  async 'Type alias annotations should work'(){
-    magAppInstance.testInterfaceAgainstPath(typeAliasTest);
-  }
-
-  @test
-  async 'Impossible union should cause an error'() {
-    magAppInstance.testInterfaceAgainstPath(impossibleUnionTest);
-  }
-
-  @test
-  async 'Index Signatures should work'() {
-    magAppInstance.testInterfaceAgainstPath(indexSignatureTest);
-  }
-
-  @test
-  async 'Nested properties should work'() {
-    magAppInstance.testInterfaceAgainstPath(nestedTest);
-  }
-
-  @test
-  async 'Generics should work'() {
-    magAppInstance.testInterfaceAgainstPath(genericTest);
-  }
-
-  @test
-  async 'Missing premap should cause an error'() {
-    magAppInstance.testInterfaceAgainstPath(missingPremapTest);
-  }
-
-  @test
-  async 'Default generics should fail'() {
-    magAppInstance.testInterfaceAgainstPath(defaultGenericTest);
-  }
-
-  @test
-  async 'Explicit type annotations should work'() {
-    magAppInstance.testInterfaceAgainstPath(mapExplicitTypesTest);
-  }
-
-  @test
-  async 'Double type annotations should cause an error'() {
-    magAppInstance.testInterfaceAgainstPath(doubleTypeConflictTest);
-  }
-
-  @test
-  async 'Incompatible type annotations should cause an error and use defaults'() {
-    magAppInstance.testInterfaceAgainstPath(incompatibleTypeTest);
-  }
-
-  @test
-  async 'Primitive types should have sensible defaults'() {
-    magAppInstance.testInterfaceAgainstPath(sensibleDefaultsTest);
-  }
-
-  @test
-  async 'Invalid tags should cause an error'() {
-    magAppInstance.testInterfaceAgainstPath(invalidTagTest);
-  }
-
-  @test
-  async 'Dates and date ranges should have the correct type'() {
-    magAppInstance.testInterfaceAgainstPath(dateAndRangeTest);
-  }
-
-  @test
-  async 'Premaps should support non-external types'() {
-    magAppInstance.testInterfaceAgainstPath(typeOverridesTest);
-  }
-}
+}).timeout(20_000).slow(10_000);