@malloydata/malloy-tests 0.0.66-dev230807232724

package/src/runtimes.ts

@@ -0,0 +1,182 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import {
+  Connection,
+  EmptyURLReader,
+  MalloyQueryData,
+  QueryDataRow,
+  Result,
+  RunSQLOptions,
+  SingleConnectionRuntime,
+} from '@malloydata/malloy';
+import {BigQueryConnection} from '@malloydata/db-bigquery';
+import {DuckDBConnection} from '@malloydata/db-duckdb';
+import {DuckDBWASMConnection} from '@malloydata/db-duckdb/wasm';
+import {PooledPostgresConnection} from '@malloydata/db-postgres';
+
+export class BigQueryTestConnection extends BigQueryConnection {
+  // we probably need a better way to do this.
+
+  public async runSQL(
+    sqlCommand: string,
+    options?: RunSQLOptions
+  ): Promise<MalloyQueryData> {
+    try {
+      return await super.runSQL(sqlCommand, options);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log(`Error in SQL:\n ${sqlCommand}`);
+      throw e;
+    }
+  }
+}
+
+export class PostgresTestConnection extends PooledPostgresConnection {
+  // we probably need a better way to do this.
+
+  public async runSQL(
+    sqlCommand: string,
+    options?: RunSQLOptions
+  ): Promise<MalloyQueryData> {
+    try {
+      return await super.runSQL(sqlCommand, options);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log(`Error in SQL:\n ${sqlCommand}`);
+      throw e;
+    }
+  }
+}
+
+export class DuckDBTestConnection extends DuckDBConnection {
+  // we probably need a better way to do this.
+
+  constructor(name: string) {
+    super(name, 'test/data/duckdb/duckdb_test.db');
+  }
+
+  public async runSQL(
+    sqlCommand: string,
+    options?: RunSQLOptions
+  ): Promise<MalloyQueryData> {
+    try {
+      return await super.runSQL(sqlCommand, options);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log(`Error in SQL:\n ${sqlCommand}`);
+      throw e;
+    }
+  }
+}
+
+export class DuckDBWASMTestConnection extends DuckDBWASMConnection {
+  // we probably need a better way to do this.
+
+  constructor(name: string) {
+    super(name, 'test/data/duckdb/duckdb_test.db');
+  }
+
+  public async runSQL(
+    sqlCommand: string,
+    options?: RunSQLOptions
+  ): Promise<MalloyQueryData> {
+    try {
+      return await super.runSQL(sqlCommand, options);
+    } catch (e) {
+      // eslint-disable-next-line no-console
+      console.log(`Error in SQL:\n ${sqlCommand}`);
+      throw e;
+    }
+  }
+}
+
+const files = new EmptyURLReader();
+
+export function rows(qr: Result): QueryDataRow[] {
+  return qr.data.value;
+}
+
+export function runtimeFor(dbName: string): SingleConnectionRuntime {
+  let connection;
+  switch (dbName) {
+    case 'bigquery':
+      connection = new BigQueryTestConnection(
+        dbName,
+        {},
+        {defaultProject: 'malloy-data'}
+      );
+      break;
+    case 'postgres':
+      connection = new PostgresTestConnection(dbName);
+      break;
+    case 'duckdb':
+      connection = new DuckDBTestConnection(dbName);
+      break;
+    case 'duckdb_wasm':
+      connection = new DuckDBWASMTestConnection(dbName);
+      break;
+    default:
+      throw new Error(`Unknown runtime "${dbName}`);
+  }
+  return testRuntimeFor(connection);
+}
+
+export function testRuntimeFor(connection: Connection) {
+  return new SingleConnectionRuntime(files, connection);
+}
+
+export const allDatabases = ['postgres', 'bigquery', 'duckdb', 'duckdb_wasm'];
+type RuntimeDatabaseNames = typeof allDatabases[number];
+
+export class RuntimeList {
+  runtimeMap = new Map<string, SingleConnectionRuntime>();
+  runtimeList: Array<[string, SingleConnectionRuntime]> = [];
+
+  constructor();
+  constructor(databaseList: RuntimeDatabaseNames[]);
+  constructor(externalConnections: SingleConnectionRuntime[]);
+  constructor(
+    ...args: (RuntimeDatabaseNames[] | undefined | SingleConnectionRuntime[])[]
+  ) {
+    const databases: RuntimeDatabaseNames[] | SingleConnectionRuntime[] =
+      args.length > 0 && args[0] !== undefined ? args[0] : allDatabases;
+    for (const database of databases) {
+      const rt: SingleConnectionRuntime =
+        database instanceof SingleConnectionRuntime
+          ? database
+          : runtimeFor(database);
+      this.runtimeMap.set(rt.connection.name, rt);
+      this.runtimeList.push([rt.connection.name, rt]);
+    }
+  }
+
+  async closeAll(): Promise<void> {
+    for (const [_key, runtime] of this.runtimeMap) {
+      await runtime.connection.close();
+    }
+    // Unfortunate hack to avoid slow to die background threads tripping
+    // up jest
+    await new Promise(resolve => setTimeout(resolve, 10000));
+  }
+}

package/src/tags.spec.ts

@@ -0,0 +1,277 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import {Tags, Annotation, MalloyTags} from '@malloydata/malloy';
+
+function tstTaglist(a: Annotation): string[] {
+  return new Tags(a).getTagList();
+}
+
+function tstTagParse(s: string): MalloyTags {
+  return new Tags({notes: [s]}).getMalloyTags();
+}
+
+describe('tag utilities', () => {
+  test('own/block ordering is correct', () => {
+    const testA = tstTaglist({
+      notes: ['#tag'],
+      blockNotes: ['#blockTag'],
+    });
+    expect(testA).toEqual(['#blockTag', '#tag']);
+  });
+  test('inherit ordering is correct', () => {
+    const testA = tstTaglist({
+      inherits: {notes: ['#inherited']},
+      notes: ['#tag'],
+    });
+    expect(testA).toEqual(['#inherited', '#tag']);
+  });
+  test.todo('check that results are annotated');
+  test('doc annotations', () => {
+    const a = tstTagParse('#" This is a doc string');
+    expect(a).toMatchObject({docStrings: ['This is a doc string']});
+  });
+  test('simple property', () => {
+    const a = tstTagParse('# linechart');
+    expect(a.properties).toHaveProperty('linechart', true);
+  });
+  test('negated property', () => {
+    const a = tstTagParse('# linechart -linechart');
+    expect(a.properties).not.toHaveProperty('linechart', true);
+  });
+  test('simple quoted property', () => {
+    const a = tstTagParse('# "linechart"');
+    expect(a.properties).toHaveProperty('linechart', true);
+  });
+  test('quoted property with " and space', () => {
+    const annotation = '# "a \\"chart\\""';
+    const a = tstTagParse(annotation);
+    expect(a.properties).toHaveProperty('a "chart"', true);
+  });
+  test('escaped non-quote', () => {
+    const annotation = '# "\\x"';
+    const a = tstTagParse(annotation);
+    expect(a.properties).toHaveProperty('x', true);
+  });
+  test('non-terminated string', () => {
+    const annotation = '# x="\\"';
+    const a = tstTagParse(annotation);
+    expect(a.properties).not.toHaveProperty('x', true);
+  });
+  test('quoted property with value', () => {
+    const a = tstTagParse('# "linechart"=yes');
+    expect(a.properties).toHaveProperty('linechart', 'yes');
+  });
+  test('property with simple value', () => {
+    const a = tstTagParse('# chart=line');
+    expect(a.properties).toHaveProperty('chart', 'line');
+  });
+  test('property with quoted value', () => {
+    const a = tstTagParse('# chart="line"');
+    expect(a.properties).toHaveProperty('chart', 'line');
+  });
+  test('spaces ignored', () => {
+    const a = tstTagParse('#     chart =  line ');
+    expect(a.properties).toHaveProperty('chart', 'line');
+  });
+  test('= with no value', () => {
+    expect(tstTagParse('# name =  ')).toMatchObject({properties: {}});
+  });
+  test('multiple = with no value', () => {
+    expect(tstTagParse('# name =  = me')).toMatchObject({properties: {}});
+  });
+  test('missing quote', () => {
+    expect(tstTagParse('# name =  "no quote')).toMatchObject({properties: {}});
+  });
+  test('leading =', () => {
+    expect(tstTagParse('#  =name  ')).toMatchObject({properties: {}});
+  });
+  test('complex line', () => {
+    const a = tstTagParse('# a b=c "d"=e f="g" "h"="i" "j" k -a');
+    expect(a).toBeDefined();
+    if (a) {
+      expect(a.properties).toEqual({
+        b: 'c',
+        d: 'e',
+        f: 'g',
+        h: 'i',
+        j: true,
+        k: true,
+      });
+    }
+  });
+});
+
+import {runtimeFor} from './runtimes';
+
+const runtime = runtimeFor('duckdb');
+
+describe('## top level', () => {
+  test('top level tags are available in the model def', async () => {
+    const model = await runtime
+      .loadModel(
+        `
+      ## propertyTag
+      ##" Doc String
+    `
+      )
+      .getModel();
+    const modelDesc = model.getTags().getMalloyTags();
+    expect(modelDesc).toEqual({
+      properties: {propertyTag: true},
+      docStrings: ['Doc String\n'],
+    });
+  });
+});
+describe('tags in results', () => {
+  test('nameless query', async () => {
+    const loaded = runtime.loadQuery(
+      `
+        sql: one is {connection: "duckdb" select: """SELECT 1 as one"""}
+        # b4query
+        query: # afterQuery
+          from_sql(one) -> { project: * }`
+    );
+    const query = await loaded.getPreparedQuery();
+    expect(query).toBeDefined();
+    const wantTags = ['# b4query\n', '# afterQuery\n'];
+    expect(query.getTags().getTagList()).toEqual(wantTags);
+    const result = await loaded.run();
+    expect(result.getTags().getTagList()).toEqual(wantTags);
+  });
+  const wantTags = ['# <Q\n', '# >Q\n', '# >name\n', '# >is\n'];
+  test('named query', async () => {
+    const loaded = runtime.loadQuery(
+      `
+        sql: one is {connection: "duckdb" select: """SELECT 1 as one"""}
+        # <Q
+        query: # >Q
+          theName
+          # >name
+          is
+          # >is
+          from_sql(one) -> { project: * }
+        query: -> theName`
+    );
+    const query = await loaded.getPreparedQuery();
+    expect(query).toBeDefined();
+    const wantTags = ['# <Q\n', '# >Q\n', '# >name\n', '# >is\n'];
+    expect(query.getTags().getTagList()).toEqual(wantTags);
+    const result = await loaded.run();
+    expect(result.getTags().getTagList()).toEqual(wantTags);
+  });
+  test('turtle query', async () => {
+    const loaded = runtime.loadQuery(
+      `
+        sql: one is {connection: "duckdb" select: """SELECT 1 as one"""}
+        query: from_sql(one) + {
+          # <Q
+          query: # >Q
+            in_one
+            # >name
+            is
+            # >is
+            { project: one }
+          }
+        -> in_one`
+    );
+    const query = await loaded.getPreparedQuery();
+    expect(query).toBeDefined();
+    expect(query.getTags().getTagList()).toEqual(wantTags);
+    const result = await loaded.run();
+    expect(result.getTags().getTagList()).toEqual(wantTags);
+  });
+  test('atomic field has tag', async () => {
+    const loaded = runtime.loadQuery(
+      `
+        sql: one is {connection: "duckdb" select: """SELECT 1 as one"""}
+        query: from_sql(one) -> {
+          project:
+            # note1
+            one
+        }`
+    );
+    const result = await loaded.run();
+    const shape = result.resultExplore;
+    const one = shape.getFieldByName('one');
+    expect(one).toBeDefined();
+    expect(one.getTags().getTagList()).toEqual(['# note1\n']);
+  });
+  test('nested query has tag', async () => {
+    const loaded = runtime.loadQuery(
+      `
+        sql: one is {connection: "duckdb" select: """SELECT 1 as one"""}
+        source: malloy_one is from_sql(one) + {
+          query: in_one is {
+            project: one
+          }
+          query: one_and_one is {
+            group_by: one
+            # note1
+            nest:
+              # note2
+              in_one
+          }
+        }
+        query: malloy_one -> one_and_one`
+    );
+    const result = await loaded.run();
+    const shape = result.resultExplore;
+    const one = shape.getFieldByName('in_one');
+    expect(one).toBeDefined();
+    expect(one.getTags().getTagList()).toEqual(['# note1\n', '# note2\n']);
+  });
+  test('render usage test case', async () => {
+    const loaded = runtime.loadQuery(
+      `
+      sql: one22 is { connection: "duckdb" select: """SELECT 1""" }
+      source: ages is from_sql(one22) + {
+        dimension: name is 'John'
+        query: height
+        # barchart
+         is {
+          project: heightd is 10
+         }
+
+        query: age
+        # barchart
+         is {
+          project: aged is 20
+         }
+
+      }
+      query: ages -> {
+         group_by: name
+         nest: height
+         nest: age
+      }
+      `
+    );
+    const result = await loaded.run();
+    const shape = result.resultExplore;
+    const ht = shape.getFieldByName('height').getTags().getMalloyTags();
+    const at = shape.getFieldByName('age').getTags().getMalloyTags();
+    expect(ht).toMatchObject({properties: {barchart: true}});
+    expect(at).toMatchObject({properties: {barchart: true}});
+  });
+});

package/src/util/db-jest-matchers.ts

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+import {
+  QueryMaterializer,
+  Result,
+  SingleConnectionRuntime,
+} from '@malloydata/malloy';
+
+declare global {
+  // eslint-disable-next-line @typescript-eslint/no-namespace
+  namespace jest {
+    interface Matchers<R> {
+      isSqlEq(): R;
+      /**
+       * Jest matcher for running a Malloy query, assumes you only care about
+       * columns in the first row.
+       *
+       *     await expect(runtime).queryMatches('query', {colName: colValue});
+       *
+       * @param runtime Database connection runtime
+       * @param querySrc Malloy source, last query in source will be run
+       * @param expected Key value pairs
+       */
+      queryMatches(
+        querySrc: string,
+        matchVals: Record<string, unknown>
+      ): Promise<R>;
+    }
+  }
+}
+
+expect.extend({
+  /**
+   * Check the return of `sqlEQ(expr1,expr2)` and error if the database
+   * does not find those two expressions to be equal.
+   */
+  isSqlEq(result: Result) {
+    const wantEq = result.data.path(0, 'calc').value;
+    const sql = result.sql.replace(/\n/g, '\n    ');
+    if (wantEq !== '=') {
+      return {
+        pass: false,
+        message: () =>
+          `Got '${wantEq}' ${Object.prototype.toString.call(
+            wantEq
+          )} instead of '='\nSQL:\n    ${sql}`,
+      };
+    }
+    return {
+      pass: true,
+      message: () => 'SQL expression matched',
+    };
+  },
+
+  async queryMatches(
+    runtime: SingleConnectionRuntime,
+    querySrc: string,
+    expected: Record<string, unknown>
+  ) {
+    if (!runtime.supportsNesting && querySrc.indexOf('nest:') >= 0) {
+      return {
+        pass: true,
+        message: () =>
+          'Test was skipped since connection does not support nesting.',
+      };
+    }
+
+    let query: QueryMaterializer;
+    try {
+      query = runtime.loadQuery(querySrc);
+    } catch (e) {
+      return {pass: false, message: () => `loadQuery failed: ${e.message}`};
+    }
+
+    let result: Result;
+    try {
+      result = await query.run();
+    } catch (e) {
+      const failMsg =
+        `query.run failed: ${e.message}\n` + `SQL: ${await query.getSQL()}`;
+      return {pass: false, message: () => failMsg};
+    }
+
+    const fails: string[] = [];
+    for (const [name, value] of Object.entries(expected)) {
+      try {
+        const got = result.data.path(0, name).value;
+        const mustBe = value instanceof Date ? value.getTime() : value;
+        const actuallyGot = got instanceof Date ? got.getTime() : got;
+        if (actuallyGot !== mustBe) {
+          fails.push(`Expected {${name}: ${value}} Got: ${got}`);
+        }
+      } catch (e) {
+        fails.push(`Expected {${name}: ${value}} Error: ${e.message}`);
+      }
+    }
+    if (fails.length !== 0) {
+      const failMsg = `SQL: ${await query.getSQL()}\n${fails.join('\n')}`;
+      return {pass: false, message: () => failMsg};
+    }
+
+    return {
+      pass: true,
+      message: () => `First row matched ${JSON.stringify(expected)}`,
+    };
+  },
+});