@cubejs-backend/query-orchestrator 0.23.3 → 0.24.2

package/orchestrator/RedisQueueDriver.js

@@ -1,286 +1,8 @@
-const R = require('ramda');
+const { RedisQueueDriver } = require('../dist/src/orchestrator/RedisQueueDriver');
 
-const BaseQueueDriver = require('./BaseQueueDriver');
-
-class RedisQueueDriverConnection {
-  constructor(driver, options) {
-    this.driver = driver;
-    this.redisClient = options.redisClient;
-    this.redisQueuePrefix = options.redisQueuePrefix;
-    this.continueWaitTimeout = options.continueWaitTimeout;
-    this.orphanedTimeout = options.orphanedTimeout;
-    this.heartBeatTimeout = options.heartBeatTimeout;
-    this.concurrency = options.concurrency;
-  }
-
-  async getResultBlocking(queryKey) {
-    const resultListKey = this.resultListKey(queryKey);
-    if (!(await this.redisClient.hgetAsync([this.queriesDefKey(), this.redisHash(queryKey)]))) {
-      return this.getResult(queryKey);
-    }
-    const result = await this.redisClient.brpopAsync([resultListKey, this.continueWaitTimeout]);
-    if (result) {
-      await this.redisClient.lpushAsync([resultListKey, result[1]]);
-      await this.redisClient.rpopAsync(resultListKey);
-    }
-    return result && JSON.parse(result[1]);
-  }
-
-  async getResult(queryKey) {
-    const resultListKey = this.resultListKey(queryKey);
-    const result = await this.redisClient.rpopAsync(resultListKey);
-    return result && JSON.parse(result);
-  }
-
-  addToQueue(keyScore, queryKey, time, queryHandler, query, priority, options) {
-    return this.redisClient.multi()
-      .zadd([this.toProcessRedisKey(), 'NX', keyScore, this.redisHash(queryKey)])
-      .zadd([this.recentRedisKey(), time, this.redisHash(queryKey)])
-      .hsetnx([
-        this.queriesDefKey(),
-        this.redisHash(queryKey),
-        JSON.stringify({
-          queryHandler,
-          query,
-          queryKey,
-          stageQueryKey: options.stageQueryKey,
-          priority,
-          requestId: options.requestId,
-          addedToQueueTime: new Date().getTime()
-        })
-      ])
-      .zcard(this.toProcessRedisKey())
-      .execAsync();
-  }
-
-  getToProcessQueries() {
-    return this.redisClient.zrangeAsync([this.toProcessRedisKey(), 0, -1]);
-  }
-
-  getActiveQueries() {
-    return this.redisClient.zrangeAsync([this.activeRedisKey(), 0, -1]);
-  }
-
-  async getQueryAndRemove(queryKey) {
-    const [query, ...restResult] = await this.redisClient.multi()
-      .hget([this.queriesDefKey(), this.redisHash(queryKey)])
-      .zrem([this.activeRedisKey(), this.redisHash(queryKey)])
-      .zrem([this.heartBeatRedisKey(), this.redisHash(queryKey)])
-      .zrem([this.toProcessRedisKey(), this.redisHash(queryKey)])
-      .zrem([this.recentRedisKey(), this.redisHash(queryKey)])
-      .hdel([this.queriesDefKey(), this.redisHash(queryKey)])
-      .del(this.queryProcessingLockKey(queryKey))
-      .execAsync();
-    return [JSON.parse(query), ...restResult];
-  }
-
-  async setResultAndRemoveQuery(queryKey, executionResult, processingId) {
-    try {
-      await this.redisClient.watchAsync(this.queryProcessingLockKey(queryKey));
-      const currentProcessId = await this.redisClient.getAsync(this.queryProcessingLockKey(queryKey));
-      if (processingId !== currentProcessId) {
-        return false;
-      }
-
-      return this.redisClient.multi()
-        .lpush([this.resultListKey(queryKey), JSON.stringify(executionResult)])
-        .zrem([this.activeRedisKey(), this.redisHash(queryKey)])
-        .zrem([this.heartBeatRedisKey(), this.redisHash(queryKey)])
-        .zrem([this.toProcessRedisKey(), this.redisHash(queryKey)])
-        .zrem([this.recentRedisKey(), this.redisHash(queryKey)])
-        .hdel([this.queriesDefKey(), this.redisHash(queryKey)])
-        .del(this.queryProcessingLockKey(queryKey))
-        .execAsync();
-    } finally {
-      await this.redisClient.unwatchAsync();
-    }
-  }
-
-  getOrphanedQueries() {
-    return this.redisClient.zrangebyscoreAsync(
-      [this.recentRedisKey(), 0, (new Date().getTime() - this.orphanedTimeout * 1000)]
-    );
-  }
-
-  getStalledQueries() {
-    return this.redisClient.zrangebyscoreAsync(
-      [this.heartBeatRedisKey(), 0, (new Date().getTime() - this.heartBeatTimeout * 1000)]
-    );
-  }
-
-  async getQueryStageState(onlyKeys) {
-    let request = this.redisClient.multi()
-      .zrange([this.activeRedisKey(), 0, -1])
-      .zrange([this.toProcessRedisKey(), 0, -1]);
-    if (!onlyKeys) {
-      request = request.hgetall(this.queriesDefKey());
-    }
-    const [active, toProcess, allQueryDefs] = await request.execAsync();
-    return [active, toProcess, R.map(q => JSON.parse(q), allQueryDefs || {})];
-  }
-
-  async getQueryDef(queryKey) {
-    const query = await this.redisClient.hgetAsync([this.queriesDefKey(), this.redisHash(queryKey)]);
-    return JSON.parse(query);
-  }
-
-  updateHeartBeat(queryKey) {
-    return this.redisClient.zaddAsync([this.heartBeatRedisKey(), new Date().getTime(), this.redisHash(queryKey)]);
-  }
-
-  async getNextProcessingId() {
-    const id = await this.redisClient.incrAsync(this.processingIdKey());
-    return id && id.toString();
-  }
-
-  async retrieveForProcessing(queryKey, processingId) {
-    try {
-      const lockKey = this.queryProcessingLockKey(queryKey);
-      await this.redisClient.watchAsync(lockKey);
-
-      const currentProcessId = await this.redisClient.getAsync(lockKey);
-
-      if (currentProcessId) {
-        return null;
-      }
-
-      const result =
-        await this.redisClient.multi()
-          .zadd([this.activeRedisKey(), 'NX', processingId, this.redisHash(queryKey)])
-          .zremrangebyrank([this.activeRedisKey(), this.concurrency, -1])
-          .zrange([this.activeRedisKey(), 0, this.concurrency - 1])
-          .zcard(this.toProcessRedisKey())
-          .hget(([this.queriesDefKey(), this.redisHash(queryKey)]))
-          .set(lockKey, processingId, 'NX')
-          .zadd([this.heartBeatRedisKey(), 'NX', new Date().getTime(), this.redisHash(queryKey)])
-          .execAsync();
-      if (result) {
-        result[4] = JSON.parse(result[4]);
-      }
-      return result;
-    } finally {
-      await this.redisClient.unwatchAsync();
-    }
-  }
-
-  async freeProcessingLock(queryKey, processingId, activated) {
-    try {
-      const lockKey = this.queryProcessingLockKey(queryKey);
-      await this.redisClient.watchAsync(lockKey);
-      const currentProcessId = await this.redisClient.getAsync(lockKey);
-      if (currentProcessId === processingId) {
-        let removeCommand = this.redisClient.multi()
-          .del(lockKey);
-        if (activated) {
-          removeCommand = removeCommand.zrem([this.activeRedisKey(), this.redisHash(queryKey)]);
-        }
-        await removeCommand
-          .execAsync();
-        return null;
-      } else {
-        return currentProcessId;
-      }
-    } finally {
-      await this.redisClient.unwatchAsync();
-    }
-  }
-
-  async optimisticQueryUpdate(queryKey, toUpdate, processingId) {
-    try {
-      let query = await this.getQueryDef(queryKey);
-      for (let i = 0; i < 10; i++) {
-        if (query) {
-          // eslint-disable-next-line no-await-in-loop
-          await this.redisClient.watchAsync(this.queryProcessingLockKey(queryKey));
-          const currentProcessId = await this.redisClient.getAsync(this.queryProcessingLockKey(queryKey));
-          if (currentProcessId !== processingId) {
-            return false;
-          }
-          let [beforeUpdate] = await this.redisClient
-            .multi()
-            .hget([this.queriesDefKey(), this.redisHash(queryKey)])
-            .hset([this.queriesDefKey(), this.redisHash(queryKey), JSON.stringify({ ...query, ...toUpdate })])
-            .execAsync();
-          beforeUpdate = JSON.parse(beforeUpdate);
-          if (JSON.stringify(query) === JSON.stringify(beforeUpdate)) {
-            return true;
-          }
-          query = beforeUpdate;
-        }
-      }
-      throw new Error(`Can't update ${queryKey} with ${JSON.stringify(toUpdate)}`);
-    } finally {
-      await this.redisClient.unwatchAsync();
-    }
-  }
-
-  release() {
-    return this.redisClient.quit();
-  }
-
-  toProcessRedisKey() {
-    return this.queueRedisKey('QUEUE');
-  }
-
-  recentRedisKey() {
-    return this.queueRedisKey('RECENT');
-  }
-
-  activeRedisKey() {
-    return this.queueRedisKey('ACTIVE');
-  }
-
-  heartBeatRedisKey() {
-    return this.queueRedisKey('HEART_BEAT');
-  }
-
-  queryRedisKey(queryKey, suffix) {
-    return `${this.redisQueuePrefix}_${this.redisHash(queryKey)}_${suffix}`;
-  }
-
-  queueRedisKey(suffix) {
-    return `${this.redisQueuePrefix}_${suffix}`;
-  }
-
-  queriesDefKey() {
-    return this.queueRedisKey('QUERIES');
-  }
-
-  processingIdKey() {
-    return this.queueRedisKey('PROCESSING_COUNTER');
-  }
-
-  resultListKey(queryKey) {
-    return this.queryRedisKey(queryKey, 'RESULT');
-  }
-
-  queryProcessingLockKey(queryKey) {
-    return this.queryRedisKey(queryKey, 'LOCK');
-  }
-
-  redisHash(queryKey) {
-    return this.driver.redisHash(queryKey);
-  }
-}
-
-class RedisQueueDriver extends BaseQueueDriver {
-  constructor(options) {
-    super();
-    this.redisPool = options.redisPool;
-    this.options = options;
-  }
-
-  async createConnection() {
-    const redisClient = await this.redisPool.getClient();
-    return new RedisQueueDriverConnection(this, {
-      redisClient,
-      ...this.options
-    });
-  }
-
-  release(connection) {
-    this.redisPool.release(connection.redisClient);
-  }
-}
+process.emitWarning(
+  'Using absolute import with @cubejs-backend/query-orchestrator is deprecated',
+  'DeprecationWarning'
+);
 
 module.exports = RedisQueueDriver;

package/orchestrator/TimeoutError.js

@@ -1,3 +1,8 @@
-class TimeoutError extends Error {}
+const { TimeoutError } = require('../dist/src/orchestrator/TimeoutError');
+
+process.emitWarning(
+  'Using absolute import with @cubejs-backend/query-orchestrator is deprecated',
+  'DeprecationWarning'
+);
 
 module.exports = TimeoutError;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@cubejs-backend/query-orchestrator",
   "description": "Cube.js Query Orchestrator and Cache",
   "author": "Cube Dev, Inc.",
-  "version": "0.23.3",
+  "version": "0.24.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/cube-js/cube.js.git",
@@ -11,24 +11,43 @@
   "engines": {
     "node": ">=8.11.1"
   },
+  "main": "dist/src/index.js",
+  "typings": "dist/src/index.d.ts",
   "scripts": {
+    "build": "rm -rf dist && npm run tsc",
+    "tsc": "tsc",
+    "watch": "tsc -w",
     "test": "npm run unit && npm run integration",
-    "unit": "jest --runInBand --verbose test/unit",
-    "integration": "jest --runInBand --verbose test/integration",
-    "lint": "eslint orchestrator/*.js driver/*.js"
+    "unit": "jest --runInBand --verbose dist/test/unit",
+    "integration": "npm run integration:redis",
+    "integration:redis": "jest --runInBand --verbose dist/test/integration",
+    "lint": "./node_modules/@cubejs-backend/linter/node_modules/.bin/eslint src/* test/* --ext .ts,.js",
+    "lint:fix": "./node_modules/@cubejs-backend/linter/node_modules/.bin/eslint --fix src/* test/* --ext .ts,.js"
   },
+  "files": [
+    "README.md",
+    "driver/*",
+    "orchestrator/*",
+    "dist/src/*"
+  ],
   "dependencies": {
     "generic-pool": "^3.7.1",
     "ramda": "^0.27.0",
     "redis": "^3.0.2"
   },
   "devDependencies": {
-    "eslint": "^6.8.0",
-    "eslint-config-airbnb-base": "^13.1.0",
-    "eslint-plugin-import": "^2.16.0",
-    "eslint-plugin-node": "^5.2.1",
-    "jest": "^25.1.0"
+    "@cubejs-backend/linter": "^0.24.2",
+    "@types/generic-pool": "^3.1.9",
+    "@types/jest": "^26.0.15",
+    "@types/node": "^8.10.66",
+    "@types/ramda": "^0.27.32",
+    "@types/redis": "^2.8.28",
+    "jest": "^26.6.3",
+    "typescript": "^4.0.5"
   },
   "license": "Apache-2.0",
-  "gitHead": "ae0115d4f65ddc4f91c38fa8325dc2252f892706"
+  "eslintConfig": {
+    "extends": "../cubejs-linter"
+  },
+  "gitHead": "20a2c50c07d1b7602c0958fd3d5a69f310a415f1"
 }

package/test/integration/PreAggregations.test.js

@@ -1,337 +0,0 @@
-/* globals describe, beforeAll, afterAll, beforeEach, test, expect */
-const R = require('ramda');
-
-class MockDriver {
-  constructor() {
-    this.tables = [];
-    this.executedQueries = [];
-    this.cancelledQueries = [];
-  }
-
-  query(query) {
-    this.executedQueries.push(query);
-    let promise = Promise.resolve([query]);
-    if (query.match(`orders_too_big`)) {
-      promise = promise.then((res) => new Promise(resolve => setTimeout(() => resolve(res), 3000)));
-    }
-    promise.cancel = async () => {
-      this.cancelledQueries.push(query);
-    };
-    return promise;
-  }
-
-  async getTablesQuery(schema) {
-    return this.tables.map(t => ({ table_name: t.replace(`${schema}.`, '') }));
-  }
-
-  async createSchemaIfNotExists(schema) {
-    this.schema = schema;
-    return null;
-  }
-
-  loadPreAggregationIntoTable(preAggregationTableName, loadSql) {
-    this.tables.push(preAggregationTableName.substring(0, 100));
-    return this.query(loadSql);
-  }
-
-  async dropTable(tableName) {
-    this.tables = this.tables.filter(t => t !== tableName);
-    return this.query(`DROP TABLE ${tableName}`);
-  }
-
-  async downloadTable(table) {
-    return { rows: await this.query(`SELECT * FROM ${table}`) };
-  }
-
-  async tableColumnTypes(table) {
-    return [];
-  }
-
-  async uploadTable(table, columns, tableData) {
-    await this.createTable(table, columns);
-  }
-
-  createTable(quotedTableName, columns) {
-    this.tables.push(quotedTableName);
-  }
-
-  readOnly() {
-    return false;
-  }
-}
-
-describe('PreAggregations', () => {
-  let mockDriver = null;
-  let mockExternalDriver = null;
-  let mockDriverFactory = null;
-  let mockDriverReadOnlyFactory = null;
-  let mockExternalDriverFactory = null;
-  let queryCache = null;
-  const basicQuery = {
-    query: "SELECT \"orders__created_at_week\" \"orders__created_at_week\", sum(\"orders__count\") \"orders__count\" FROM (SELECT * FROM stb_pre_aggregations.orders_number_and_count20191101) as partition_union  WHERE (\"orders__created_at_week\" >= ($1::timestamptz::timestamptz AT TIME ZONE 'UTC') AND \"orders__created_at_week\" <= ($2::timestamptz::timestamptz AT TIME ZONE 'UTC')) GROUP BY 1 ORDER BY 1 ASC LIMIT 10000",
-    values: ["2019-11-01T00:00:00Z", "2019-11-30T23:59:59Z"],
-    cacheKeyQueries: {
-      renewalThreshold: 21600,
-      queries: [["SELECT date_trunc('hour', (NOW()::timestamptz AT TIME ZONE 'UTC')) as current_hour", []]]
-    },
-    preAggregations: [{
-      preAggregationsSchema: "stb_pre_aggregations",
-      tableName: "stb_pre_aggregations.orders_number_and_count20191101",
-      loadSql: ["CREATE TABLE stb_pre_aggregations.orders_number_and_count20191101 AS SELECT\n      date_trunc('week', (\"orders\".created_at::timestamptz AT TIME ZONE 'UTC')) \"orders__created_at_week\", count(\"orders\".id) \"orders__count\", sum(\"orders\".number) \"orders__number\"\n    FROM\n      public.orders AS \"orders\"\n  WHERE (\"orders\".created_at >= $1::timestamptz AND \"orders\".created_at <= $2::timestamptz) GROUP BY 1", ["2019-11-01T00:00:00Z", "2019-11-30T23:59:59Z"]],
-      invalidateKeyQueries: [["SELECT date_trunc('hour', (NOW()::timestamptz AT TIME ZONE 'UTC')) as current_hour", []]]
-    }],
-    requestId: 'basic'
-  };
-  const basicQueryExternal = R.clone(basicQuery);
-  basicQueryExternal.preAggregations[0].external = true;
-  const basicQueryWithRenew = R.clone(basicQuery);
-  basicQueryWithRenew.renewQuery = true;
-  const basicQueryExternalWithRenew = R.clone(basicQueryExternal);
-  basicQueryExternalWithRenew.renewQuery = true;
-
-  beforeEach(() => {
-    mockDriver = new MockDriver();
-    mockExternalDriver = new MockDriver();
-    mockDriverFactory = async () => mockDriver;
-    mockDriverReadOnlyFactory = async () => {
-      const driver = mockDriver;
-      jest.spyOn(driver, 'readOnly').mockImplementation(() => true);
-      return driver;
-    }
-    mockExternalDriverFactory = async () => {
-      const driver = mockExternalDriver;
-      driver.createTable("stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il_1593709044209");
-      return driver;
-    }
-
-    jest.resetModules();
-    const QueryCache = require('../../orchestrator/QueryCache');
-    queryCache = new QueryCache(
-      "TEST",
-      mockDriverFactory,
-      (msg, params) => {},
-      {
-        queueOptions: {
-          executionTimeout: 1
-        },
-      },
-    );
-  });
-
-  describe('loadAllPreAggregationsIfNeeded', () => {
-    let preAggregations = null;
-
-    beforeEach(async () => {
-      const PreAggregations = require('../../orchestrator/PreAggregations');
-      preAggregations = new PreAggregations(
-        "TEST",
-        mockDriverFactory,
-        (msg, params) => {},
-        queryCache,
-        {
-          queueOptions: {
-            executionTimeout: 1
-          },
-        },
-      );
-    });
-
-    test('syncronously create rollup from scratch', async () => {
-      const result = await preAggregations.loadAllPreAggregationsIfNeeded(basicQueryWithRenew);
-      expect(result[0][1].targetTableName).toMatch(/stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il/);
-    });
-  });
-
-  describe(`loadAllPreAggregationsIfNeeded with external rollup and writable source`, () => {
-    let preAggregations = null;
-
-    beforeEach(async () => {
-      const PreAggregations = require('../../orchestrator/PreAggregations');
-      preAggregations = new PreAggregations(
-        "TEST",
-        mockDriverFactory,
-        (msg, params) => {},
-        queryCache,
-        {
-          queueOptions: {
-            executionTimeout: 1
-          },
-          externalDriverFactory: mockExternalDriverFactory,
-        },
-      );
-    });
-
-    test('refresh external preaggregation with a writable source (refreshImplTempTableExternalStrategy)', async () => {
-      const result = await preAggregations.loadAllPreAggregationsIfNeeded(basicQueryExternal);
-      expect(result[0][1].targetTableName).toMatch(/stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il/);
-    });
-  });
-
-  describe(`loadAllPreAggregationsIfNeeded with external rollup and readonly source`, () => {
-    let preAggregations = null;
-
-    beforeEach(async () => {
-      const PreAggregations = require('../../orchestrator/PreAggregations');
-      preAggregations = new PreAggregations(
-        "TEST",
-        mockDriverReadOnlyFactory,
-        (msg, params) => {},
-        queryCache,
-        {
-          queueOptions: {
-            executionTimeout: 1
-          },
-          externalDriverFactory: mockExternalDriverFactory,
-        },
-      );
-    });
-
-    test('refresh external preaggregation with a writable source (refreshImplStreamExternalStrategy)', async () => {
-      const result = await preAggregations.loadAllPreAggregationsIfNeeded(basicQueryExternal);
-      expect(result[0][1].targetTableName).toMatch(/stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il/);
-    });
-  });
-
-  describe(`loadAllPreAggregationsIfNeeded with externalRefresh true`, () => {
-    let preAggregations = null;
-
-    beforeEach(async () => {
-      const PreAggregations = require('../../orchestrator/PreAggregations');
-      preAggregations = new PreAggregations(
-        "TEST",
-        mockDriverFactory,
-        (msg, params) => {},
-        queryCache,
-        {
-          queueOptions: {
-            executionTimeout: 1
-          },
-          externalRefresh: true,
-        },
-      );
-    });
-
-    test('fail if waitForRenew is also specified', async () => {
-      await expect(preAggregations.loadAllPreAggregationsIfNeeded(basicQueryWithRenew))
-        .rejects.toThrowError(/Invalid configuration/);
-    });
-
-    test('fail if rollup doesn\'t already exist', async () => {
-      await expect(preAggregations.loadAllPreAggregationsIfNeeded(basicQuery))
-        .rejects.toThrowError(/One or more pre-aggregation tables could not be found to satisfy that query/);
-    });
-  });
-
-  describe(`loadAllPreAggregationsIfNeeded with external rollup and externalRefresh true`, () => {
-    let preAggregations = null;
-
-    beforeEach(async () => {
-      const PreAggregations = require('../../orchestrator/PreAggregations');
-      preAggregations = new PreAggregations(
-        "TEST",
-        () => { throw new Error('The source database factory should never be called when externalRefresh is true, as it will trigger testConnection'); },
-        (msg, params) => {},
-        queryCache,
-        {
-          queueOptions: {
-            executionTimeout: 1
-          },
-          externalDriverFactory: mockExternalDriverFactory,
-          externalRefresh: true,
-        },
-      );
-    });
-
-    test('fail if waitForRenew is also specified', async () => {
-      await expect(preAggregations.loadAllPreAggregationsIfNeeded(basicQueryExternalWithRenew))
-        .rejects.toThrowError(/Invalid configuration/);
-    });
-
-    test('load external preaggregation without communicating to the source database', async () => {
-      const result = await preAggregations.loadAllPreAggregationsIfNeeded(basicQueryExternal);
-      expect(result[0][1].targetTableName).toMatch(/stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il/);
-    });
-  });
-
-  describe(`naming_version tests`, () => {
-    let preAggregations = null;
-    let PreAggregations = null;
-
-    beforeEach(async () => {
-      PreAggregations = require('../orchestrator/PreAggregations');
-      preAggregations = new PreAggregations(
-        "TEST",
-        mockDriverFactory,
-        (msg, params) => {},
-        queryCache,
-        {
-          queueOptions: {
-            executionTimeout: 1
-          },
-          externalDriverFactory: async () => {
-            const driver = mockExternalDriver;
-            driver.createTable("stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il_1593709044209");
-            driver.createTable("stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il_1fm6652");
-            return driver;
-          },
-        },
-      );
-    });
-
-    test('test for function targetTableName', () => {
-      let result = PreAggregations.targetTableName({
-        table_name:'orders_number_and_count20191101',
-        content_version:'kjypcoio',
-        structure_version:'5yftl5il',
-        last_updated_at:1600329890789, 
-      });
-      expect(result).toEqual('orders_number_and_count20191101_kjypcoio_5yftl5il_1600329890789')
-
-      result = PreAggregations.targetTableName({
-        table_name:'orders_number_and_count20191101',
-        content_version:'kjypcoio',
-        structure_version:'5yftl5il',
-        last_updated_at:1600329890789, 
-        naming_version:2
-      });
-      expect(result).toEqual('orders_number_and_count20191101_kjypcoio_5yftl5il_1fm6652')
-    }); 
-
-    test('naming_version and sort by last_updated_at', async () => {
-      const result = await preAggregations.loadAllPreAggregationsIfNeeded(basicQueryExternal); 
-      expect(result[0][1].targetTableName).toMatch(/stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il_1fm6652/); 
-    }); 
-  });
-
-  describe(`naming_version sort tests`, () => {
-    let preAggregations = null;
-    let PreAggregations = null;
-
-    beforeEach(async () => {
-      PreAggregations = require('../orchestrator/PreAggregations');
-      preAggregations = new PreAggregations(
-        "TEST",
-        mockDriverFactory,
-        (msg, params) => {},
-        queryCache,
-        {
-          queueOptions: {
-            executionTimeout: 1
-          },
-          externalDriverFactory: async () => {
-            const driver = mockExternalDriver;
-            driver.createTable("stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il_1893709044209");
-            driver.createTable("stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il_1fm6652");
-            return driver;
-          },
-        },
-      );
-    });
-
-    test('naming_version and sort by last_updated_at', async () => {
-      const result = await preAggregations.loadAllPreAggregationsIfNeeded(basicQueryExternal); 
-      expect(result[0][1].targetTableName).toMatch(/stb_pre_aggregations.orders_number_and_count20191101_kjypcoio_5yftl5il_1893709044209/); 
-    }); 
-  });
-
-});