@malloydata/malloy-tests 0.0.261-dev250410215229 → 0.0.261-dev250410224545

package/package.json

@@ -21,14 +21,14 @@
   },
   "dependencies": {
     "@jest/globals": "^29.4.3",
-    "@malloydata/db-bigquery": "^0.0.261-dev250410215229",
-    "@malloydata/db-duckdb": "^0.0.261-dev250410215229",
-    "@malloydata/db-postgres": "^0.0.261-dev250410215229",
-    "@malloydata/db-snowflake": "^0.0.261-dev250410215229",
-    "@malloydata/db-trino": "^0.0.261-dev250410215229",
-    "@malloydata/malloy": "^0.0.261-dev250410215229",
-    "@malloydata/malloy-tag": "^0.0.261-dev250410215229",
-    "@malloydata/render": "^0.0.261-dev250410215229",
+    "@malloydata/db-bigquery": "^0.0.261-dev250410224545",
+    "@malloydata/db-duckdb": "^0.0.261-dev250410224545",
+    "@malloydata/db-postgres": "^0.0.261-dev250410224545",
+    "@malloydata/db-snowflake": "^0.0.261-dev250410224545",
+    "@malloydata/db-trino": "^0.0.261-dev250410224545",
+    "@malloydata/malloy": "^0.0.261-dev250410224545",
+    "@malloydata/malloy-tag": "^0.0.261-dev250410224545",
+    "@malloydata/render": "^0.0.261-dev250410224545",
     "events": "^3.3.0",
     "jsdom": "^22.1.0",
     "luxon": "^2.4.0",
@@ -38,5 +38,5 @@
     "@types/jsdom": "^21.1.1",
     "@types/luxon": "^2.4.0"
   },
-  "version": "0.0.261-dev250410215229"
+  "version": "0.0.261-dev250410224545"
 }

package/src/databases/all/problems.spec.ts

@@ -41,6 +41,23 @@ async function getError<T>(fn: () => Promise<T>) {
 }
 
 runtimes.runtimeMap.forEach((runtime, databaseName) => {
+  it(`properly quotes nested field names in ${databaseName}`, async () => {
+    const one = runtime.dialect.sqlMaybeQuoteIdentifier('one');
+    await expect(`
+      run: ${databaseName}.sql(""" SELECT 1 as ${one} """) -> {
+        nest: foo is {
+          group_by: one
+          aggregate: \`#\` is count(one)
+          nest: deepfoo is {
+            group_by: one
+            aggregate: \`#\` is count(one)
+          }
+        }
+      }`).matchesRows(runtime, {
+      foo: [{'one': 1, '#': 1, 'deepfoo': [{'one': 1, '#': 1}]}],
+    });
+  });
+
   describe('warnings', () => {
     // NOTE: This test generates SQL errors on the console because of
     // a hard-coded console.log() in the duckdb-wasm worker

package/src/databases/presto-trino/presto-trino.spec.ts

@@ -22,7 +22,6 @@ describe.each(runtimes.runtimeList)(
       throw new Error("Couldn't build runtime");
     }
     const presto = databaseName === 'presto';
-
     it(`runs an sql query - ${databaseName}`, async () => {
       await expect(
         `run: ${databaseName}.sql("SELECT 1 as n") -> { select: n }`

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

@@ -22,21 +22,16 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import type {
-  ModelMaterializer,
-  QueryMaterializer,
-  Result,
-  Runtime,
-  LogMessage,
-} from '@malloydata/malloy';
-import {MalloyError, SingleConnectionRuntime, API} from '@malloydata/malloy';
-import type {Tag} from '@malloydata/malloy-tag';
+import type {Result, Runtime} from '@malloydata/malloy';
+import {SingleConnectionRuntime} from '@malloydata/malloy';
 import EventEmitter from 'events';
 import {inspect} from 'util';
-
-type ExpectedResultRow = Record<string, unknown>;
-type ExpectedResult = ExpectedResultRow | ExpectedResultRow[];
-type Runner = Runtime | ModelMaterializer;
+import type {
+  ExpectedResult,
+  ExpectedResultRow,
+  TestRunner,
+} from './db-matcher-support';
+import {runQuery} from './db-matcher-support';
 
 interface ExpectedEvent {
   id: string;
@@ -74,9 +69,45 @@ declare global {
        * @param expected Key value pairs or array of key value pairs
        */
       malloyResultMatches(
-        runtime: Runner,
+        runtime: TestRunner,
         matchVals: ExpectedResult
       ): Promise<R>;
+      /**
+       * Jest matcher for running a Malloy query, checks that each row
+       * contains the values matching the template. The argument list
+       * at the end will be matched for each row of the query.
+       *
+       * To see if the first row of a query contains a field called num with a value of 7
+       * ( a "runtime"  can be a Runtime, or a Model from load/extend of a Model)
+       *
+       *     await expect('run: ...').matchesRows(runtime, {num: 7});
+       *
+       * To see if the first two rows of a query contains a field called num with a values 7 and 8
+       *
+       *     await expect('run: ...').matchesRows(runtime {num: 7}, {num:8});
+       *
+       * Every symbol in the expect match must be in the row, however there can be columns in the row
+       * which are not in the match.
+       *
+       * mtoy todo maybe this should be "debug_query()" instead of a tag ... ?
+       * In addition, the query is checked for the tags, preceed your run statement with ...
+       *
+       *   * test.debug -- Force test failure, and the result data will be printed
+       *
+       * @param matchVals ... list of row objects containing key-value pairs
+       */
+      matchesRows(
+        runtime: TestRunner,
+        ...matchVals: ExpectedResultRow[]
+      ): Promise<R>;
+      /**
+       * Similar to matchesRows, argument is an array of rows, not a list of rows
+       * Output on a mismatch is a jest-diff
+       */
+      matchesResult(
+        runtime: TestRunner,
+        matchVals: ExpectedResultRow[]
+      ): Promise<R>;
       toEmitDuringCompile(
         runtime: Runtime,
         ...events: ExpectedEvent[]
@@ -114,7 +145,7 @@ expect.extend({
 
   async malloyResultMatches(
     querySrc: string,
-    runtime: Runner,
+    runtime: TestRunner,
     shouldEqual: ExpectedResult
   ) {
     // TODO -- THIS IS NOT OK BUT I AM NOT FIXING IT NOW
@@ -131,48 +162,15 @@ expect.extend({
       }
     }
 
-    let query: QueryMaterializer;
-    let queryTestTag: Tag | undefined = undefined;
-    try {
-      query = runtime.loadQuery(querySrc);
-      const queryTags = (await query.getPreparedQuery()).tagParse().tag;
-      queryTestTag = queryTags.tag('test');
-    } catch (e) {
-      return {
-        pass: false,
-        message: () =>
-          `Could not prepare query to run: ${e.message}\nQuery:\n${querySrc}`,
-      };
-    }
-
-    let result: Result;
-    try {
-      result = await query.run();
-    } catch (e) {
-      let failMsg = `query.run failed: ${e.message}\n`;
-      if (e instanceof MalloyError) {
-        failMsg = `Error in query compilation\n${errorLogToString(
-          querySrc,
-          e.problems
-        )}`;
-      } else {
-        try {
-          failMsg += `SQL: ${await query.getSQL()}\n`;
-        } catch (e2) {
-          // we could not show the SQL for unknown reasons
-        }
-        failMsg += e.stack;
-      }
-      return {pass: false, message: () => failMsg};
-    }
-
-    try {
-      API.util.wrapResult(result);
-    } catch (error) {
+    const {fail, result, queryTestTag, query} = await runQuery({
+      runner: runtime,
+      src: querySrc,
+    });
+    if (fail) return fail;
+    if (!result) {
       return {
         pass: false,
-        message: () =>
-          `Result could not be wrapped into new style result: ${error}\n${error.stack}`,
+        message: () => 'runQuery returned no results and no errors',
       };
     }
 
@@ -229,11 +227,13 @@ expect.extend({
     }
 
     if (fails.length > 0) {
-      const fromSQL = '  ' + (await query.getSQL()).split('\n').join('\n  ');
       if (debugFail && !failedTest) {
         fails.push('\nTest forced failure (# test.debug)');
       }
-      const failMsg = `SQL Generated:\n${fromSQL}\n${fails.join('\n')}`;
+      const fromSQL = query
+        ? 'SQL Generated:\n  ' + (await query.getSQL()).split('\n').join('\n  ')
+        : 'SQL Missing';
+      const failMsg = `${fromSQL}\n${fails.join('\n')}`;
       return {pass: false, message: () => failMsg};
     }
 
@@ -242,6 +242,126 @@ expect.extend({
       message: () => 'All rows matched expected results',
     };
   },
+
+  async matchesRows(
+    querySrc: string,
+    runtime: TestRunner,
+    ...expected: ExpectedResultRow[]
+  ) {
+    querySrc = querySrc.trimEnd().replace(/^\n*/, '');
+    const {fail, result, queryTestTag, query} = await runQuery({
+      runner: runtime,
+      src: querySrc,
+    });
+    if (fail) return fail;
+    if (!result) {
+      return {
+        pass: false,
+        message: () => 'runQuery returned no results and no errors',
+      };
+    }
+
+    const fails: string[] = [];
+    const got = result.data.toObject();
+    const expectStr = this.utils.EXPECTED_COLOR(humanReadable(expected));
+
+    if (!Array.isArray(got)) {
+      fails.push(`!!! Expected: ${expectStr}`);
+      fails.push(
+        `??? NonArray: ${this.utils.RECEIVED_COLOR(humanReadable(got))}`
+      );
+    } else {
+      // compare each row in the result to each row in the expectation
+      // This is more useful than a straight diff
+      const diffs: string[] = [];
+      let unMatched = false;
+      for (let expectNum = 0; expectNum < expected.length; expectNum += 1) {
+        const eStr = humanReadable(expected[expectNum]);
+        if (objectsMatch(got[expectNum], expected[expectNum])) {
+          diffs.push(`              ${eStr}`);
+        } else {
+          diffs.push(this.utils.EXPECTED_COLOR(`<<< Expected: ${eStr}`));
+          diffs.push(
+            this.utils.RECEIVED_COLOR(
+              `>>> Received: ${humanReadable(got[expectNum])}`
+            )
+          );
+          unMatched = true;
+        }
+      }
+      if (unMatched) {
+        fails.push('ROWS:', ...diffs);
+      }
+    }
+
+    if (queryTestTag?.has('debug') && fails.length === 0) {
+      fails.push(
+        `\n${this.utils.RECEIVED_COLOR('Test forced failure (# test.debug)')}`
+      );
+      fails.push(`Received: ${this.utils.EXPECTED_COLOR(humanReadable(got))}`);
+    }
+
+    if (fails.length > 0) {
+      const fromSQL = query
+        ? 'SQL Generated:\n  ' + (await query.getSQL()).split('\n').join('\n  ')
+        : 'SQL Missing';
+      const failMsg = `QUERY:\n${querySrc}\n\n${fromSQL}\n${fails.join('\n')}`;
+      return {pass: false, message: () => failMsg};
+    }
+
+    return {pass: true, message: () => `Matched: ${expectStr}`};
+  },
+
+  async matchesResult(
+    querySrc: string,
+    runtime: TestRunner,
+    expected: ExpectedResultRow[]
+  ) {
+    querySrc = querySrc.trimEnd();
+    const {fail, result, queryTestTag, query} = await runQuery({
+      runner: runtime,
+      src: querySrc,
+    });
+    if (fail) return fail;
+    if (!result) {
+      return {
+        pass: false,
+        message: () => 'runQuery returned no results and no errors',
+      };
+    }
+
+    const fails: string[] = [];
+    const got = result.data.toObject();
+    const expectStr = humanReadable(expected);
+
+    if (!objectsMatch(got, expected)) {
+      fails.push(
+        'RESULT:',
+        this.utils.diff(expectStr, humanReadable(got)) || ''
+      );
+    }
+
+    if (queryTestTag?.has('debug') && fails.length === 0) {
+      fails.push(
+        `\n${this.utils.RECEIVED_COLOR('Test forced failure (# test.debug)')}`
+      );
+      fails.push(`Received: ${this.utils.EXPECTED_COLOR(humanReadable(got))}`);
+    }
+
+    if (fails.length > 0) {
+      const fromSQL = query
+        ? 'SQL Generated:\n  ' + (await query.getSQL()).split('\n').join('\n  ')
+        : 'SQL Missing';
+      const failMsg = `QUERY:\n${querySrc}\n${fromSQL}\n${fails.join('\n')}`;
+      return {pass: false, message: () => failMsg};
+    }
+
+    return {
+      pass: true,
+      message: () => `Matched: ${this.utils.EXPECTED_COLOR(expectStr)}`,
+    };
+  },
+
   async toEmitDuringCompile(
     querySrc: string,
     runtime: Runtime,
@@ -318,45 +438,28 @@ async function toEmit(
   };
 }
 
-function errorLogToString(src: string, msgs: LogMessage[]) {
-  let lovely = '';
-  let lineNo = 0;
-  for (const line of src.split('\n')) {
-    lovely += `    | ${line}\n`;
-    for (const entry of msgs) {
-      if (entry.at) {
-        if (entry.at.range.start.line === lineNo) {
-          const charFrom = entry.at.range.start.character;
-          lovely += `!!!!! ${' '.repeat(charFrom)}^ ${entry.message}\n`;
-        }
-      }
-    }
-    lineNo += 1;
-  }
-  return lovely;
-}
-
 function humanReadable(thing: unknown): string {
   return inspect(thing, {breakLength: 72, depth: Infinity});
 }
 
-// b is "expected"
-// a is "actual"
 // If expected is an object, all of the keys should also match,
 // but the expected is allowed to have other keys that are not matched
-function objectsMatch(a: unknown, b: unknown): boolean {
+function objectsMatch(a: unknown, mustHave: unknown): boolean {
   if (
-    typeof b === 'string' ||
-    typeof b === 'number' ||
-    typeof b === 'boolean' ||
-    typeof b === 'bigint' ||
-    b === undefined ||
-    b === null
+    typeof mustHave === 'string' ||
+    typeof mustHave === 'number' ||
+    typeof mustHave === 'boolean' ||
+    typeof mustHave === 'bigint' ||
+    mustHave === undefined ||
+    mustHave === null
   ) {
-    return b === a;
-  } else if (Array.isArray(b)) {
+    return mustHave === a;
+  } else if (Array.isArray(mustHave)) {
     if (Array.isArray(a)) {
-      return a.length === b.length && a.every((v, i) => objectsMatch(v, b[i]));
+      return (
+        a.length === mustHave.length &&
+        a.every((v, i) => objectsMatch(v, mustHave[i]))
+      );
     }
     return false;
   } else {
@@ -371,9 +474,9 @@ function objectsMatch(a: unknown, b: unknown): boolean {
       return false;
     }
     if (Array.isArray(a)) return false;
-    const keys = Object.keys(b);
+    const keys = Object.keys(mustHave);
     for (const key of keys) {
-      if (!objectsMatch(a[key], b[key])) {
+      if (!objectsMatch(a[key], mustHave[key])) {
         return false;
       }
     }

package/src/util/db-matcher-support.ts

@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type {
+  Result,
+  Runtime,
+  ModelMaterializer,
+  QueryMaterializer,
+  LogMessage,
+  Dialect,
+} from '@malloydata/malloy';
+import {API, MalloyError} from '@malloydata/malloy';
+import type {Tag} from '@malloydata/malloy-tag';
+
+type JestMatcherResult = {
+  pass: boolean;
+  message: () => string;
+};
+
+export type ExpectedResultRow = Record<string, unknown>;
+export type ExpectedResult = ExpectedResultRow | ExpectedResultRow[];
+export type TestRunner = Runtime | ModelMaterializer;
+
+export interface TestQuery {
+  runner: TestRunner;
+  src: string;
+}
+
+export function query(runner: TestRunner, querySource: string): TestQuery {
+  return {runner, src: querySource};
+}
+
+interface QueryRunResult {
+  fail: JestMatcherResult;
+  result: Result;
+  query: QueryMaterializer;
+  queryTestTag: Tag;
+}
+
+export async function runQuery(
+  tq: TestQuery
+): Promise<Partial<QueryRunResult>> {
+  let query: QueryMaterializer;
+  let queryTestTag: Tag | undefined = undefined;
+  try {
+    query = tq.runner.loadQuery(tq.src);
+    const queryTags = (await query.getPreparedQuery()).tagParse().tag;
+    queryTestTag = queryTags.tag('test');
+  } catch (e) {
+    // Add line numbers, helpful if failure is a compiler error
+    const queryText = tq.src
+      .split('\n')
+      .map((line, index) => `${(index + 1).toString().padStart(4)}: ${line}`)
+      .join('\n');
+    return {
+      fail: {
+        pass: false,
+        message: () =>
+          `Could not prepare query to run: ${e.message}\n\nQUERY:\n${queryText}`,
+      },
+    };
+  }
+
+  let result: Result;
+  try {
+    result = await query.run();
+  } catch (e) {
+    let failMsg = `QUERY RUN FAILED: ${tq.src}\nMESSAGE: ${e.message}\n`;
+    if (e instanceof MalloyError) {
+      failMsg = `Error in query compilation\n${errorLogToString(
+        tq.src,
+        e.problems
+      )}`;
+    } else {
+      try {
+        failMsg += `SQL: ${await query.getSQL()}\n`;
+      } catch (e2) {
+        failMsg += `SQL FOR FAILING QUERY COULD NOT BE COMPUTED: ${e2.message}\n`;
+      }
+      failMsg += e.stack;
+    }
+    return {fail: {pass: false, message: () => failMsg}, query};
+  }
+  try {
+    API.util.wrapResult(result);
+  } catch (error) {
+    return {
+      fail: {
+        pass: false,
+        message: () =>
+          `Result could not be wrapped into new style result: ${error}\n${error.stack}`,
+      },
+    };
+  }
+  return {result, queryTestTag, query};
+}
+
+function errorLogToString(src: string, msgs: LogMessage[]) {
+  let lovely = '';
+  let lineNo = 0;
+  for (const line of src.split('\n')) {
+    lovely += `    | ${line}\n`;
+    for (const entry of msgs) {
+      if (entry.at) {
+        if (entry.at.range.start.line === lineNo) {
+          const charFrom = entry.at.range.start.character;
+          lovely += `!!!!! ${' '.repeat(charFrom)}^ ${entry.message}\n`;
+        }
+      }
+    }
+    lineNo += 1;
+  }
+  return lovely;
+}
+
+type TL = 'timeLiteral';
+
+function lit(d: Dialect, t: string, type: 'timestamp' | 'date'): string {
+  const typeDef: {type: 'timestamp' | 'date'} = {type};
+  const timeLiteral: TL = 'timeLiteral';
+  const n = {
+    node: timeLiteral,
+    typeDef,
+    literal: t,
+  };
+  return d.sqlLiteralTime({}, n);
+}
+
+type SQLDataType = 'string' | 'number' | 'timestamp' | 'date' | 'boolean';
+type SQLRow = unknown[];
+
+/**
+ * Create source built from the SQL for a series of
+ * SELECT ... UNION ALL SELECT statements which returns
+ * the passed data. This uses the dialect object to do
+ * all the quoting and type translation.
+ * @returns '${connectionName}.sql("""SELECT ..."""")'
+ */
+export function mkSQLSource(
+  dialect: Dialect,
+  connectioName: string,
+  schema: Record<string, SQLDataType>,
+  ...dataRows: SQLRow[]
+): string {
+  const stmts: string[] = [];
+  for (const oneRow of dataRows) {
+    const outRow: string[] = [];
+    let colNum = 0;
+    for (const colName of Object.keys(schema)) {
+      const val = oneRow[colNum];
+      colNum += 1;
+      let valStr = `ERROR BAD TYPE FOR ${schema[colName]}: ${typeof val}`;
+      if (schema[colName] === 'string' && typeof val === 'string') {
+        valStr = dialect.sqlLiteralString(val);
+      } else if (schema[colName] === 'number' && typeof val === 'number') {
+        valStr = val.toString();
+      } else if (schema[colName] === 'boolean' && typeof val === 'boolean') {
+        valStr = val.toString();
+      } else if (val === null) {
+        valStr = 'NULL';
+      } else if (schema[colName] === 'timestamp' && typeof val === 'string') {
+        valStr = lit(dialect, val, 'timestamp');
+      } else if (schema[colName] === 'date' && typeof val === 'string') {
+        valStr = lit(dialect, val, 'date');
+      }
+      outRow.push(
+        stmts.length === 0
+          ? `${valStr} AS ${dialect.sqlMaybeQuoteIdentifier(colName)}`
+          : valStr
+      );
+    }
+    stmts.push(outRow.join(','));
+  }
+  return `${connectioName}.sql("""SELECT ${stmts.join(
+    '\nUNION ALL SELECT '
+  )}\n""")`;
+}