test: add aggregations and mapping test

2026-01-20 00:23:03 +00:00 · 2020-09-09 18:01:25 +02:00
parent e5511d0738
commit 24ea449dd4
38 changed files with 1945 additions and 3 deletions
--- a/test/mapping-model/MapAggTest.ts
+++ b/test/mapping-model/MapAggTest.ts
@@ -0,0 +1,136 @@
+// tslint:disable
+/*
+ * Copyright (C) 2019 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 {generateTemplate} from '../../src/mapping';
+import {resolve} from "path";
+import {expect} from "chai";
+import {ProjectReflection} from 'typedoc';
+import {getProjectReflection} from '../../src/common';
+import {AggregationSchema, ESNestedAggregation} from '../../src/mappings/aggregation-definitions';
+import {MapAggTestOptions, MinimalMappingDescription} from './MapAggTestOptions';
+import {ElasticsearchTemplateCollection} from '../../src/mappings/mapping-definitions';
+import {settings} from '../../src/mappings/definitions/settings';
+import {ElasticsearchDataType} from '../../src/mappings/definitions/typemap';
+
+export class MapAggTest {
+  mapping_model_path!: string;
+  reflection!: ProjectReflection;
+
+  constructor(dir: string) {
+    this.mapping_model_path = resolve(__dirname, dir);
+    this.reflection = getProjectReflection(this.mapping_model_path);
+  }
+
+  testInterfaceAgainstPath(options: MapAggTestOptions) {
+    const template = generateTemplate(this.reflection, options.ignoredTags ?? [], false, [options.name]);
+
+    if (typeof options.err !== 'undefined') {
+      for (const error of template.errors) {
+        expect(options.err).to.include(error, "Unexpected Error!")
+      }
+    } else {
+      expect(template.errors).to.be.deep.equal([], 'Unexpected Error!');
+    }
+
+    if (typeof options.agg !== 'undefined') {
+      const expectedAggSchema = MapAggTest.buildAggregation(options.name, options.agg.fields, options.agg.globals)
+      expect(template.aggregations).to.be.deep.equal(expectedAggSchema, 'Aggregation schema not equal!');
+    }
+
+    if (typeof options.map !== 'undefined') {
+      const expectedMappingSchema = MapAggTest.buildMapping(options.name, options.map);
+      expect(template.mappings).to.be.deep.equal(expectedMappingSchema, 'Mapping schema not equal!');
+    }
+  }
+
+  static buildAggregation(name: string, fields?: string[], globals?: string[]): AggregationSchema {
+    const out: AggregationSchema = {
+      '@all': {
+        aggs: {},
+        filter: {
+          match_all: {}
+        }
+      },
+    };
+
+    for (const global of globals ?? []) {
+      (out['@all']! as ESNestedAggregation).aggs[global] = {
+        terms: {
+          field: `${global}.raw`,
+          size: 1000,
+        }
+      }
+    }
+
+    if (typeof fields === 'undefined' || fields.length === 0) {
+      return out;
+    }
+
+    out[name] = {
+      aggs: {},
+      filter: {
+        type: {
+          value: name,
+        }
+      }
+    }
+
+    for (const field of fields) {
+      (out[name]! as ESNestedAggregation).aggs[field] = {
+        terms: {
+          field: `${field}.raw`,
+          size: 1000,
+        }
+      }
+    }
+
+    return out;
+  }
+
+  static buildMapping(name: string, map: MinimalMappingDescription): ElasticsearchTemplateCollection {
+    let typeNameWithoutSpaces = name.toLowerCase();
+    while (typeNameWithoutSpaces.includes(' ')) {
+      typeNameWithoutSpaces = typeNameWithoutSpaces.replace(' ', '_');
+    }
+
+    const out: ElasticsearchTemplateCollection = {};
+    const templateName = `template_${typeNameWithoutSpaces}`;
+    out[templateName] = {
+      mappings: {},
+      settings: settings,
+      template: `stapps_${typeNameWithoutSpaces}*`,
+    }
+    const maps = map.maps ?? {};
+    maps.type = {
+      type: ElasticsearchDataType.text
+    }
+    maps.creation_date = {
+      type: ElasticsearchDataType.date
+    }
+    out[templateName].mappings[name] = {
+      _source: {
+        excludes: [
+          'creation_date'
+        ]
+      },
+      date_detection: false,
+      dynamic: 'strict',
+      properties: maps,
+      dynamic_templates: map.dynamicTemplates ?? [],
+    }
+
+    return out;
+  }
+}